From a27e340de7d6480b4d12df86e3d36f1e5ee9c6b1 Mon Sep 17 00:00:00 2001 From: Lapin Raving Date: Wed, 20 Sep 2023 01:18:33 +0200 Subject: [PATCH] feat: during Qualibration and Sequence refacto --- src/qualib_refacto.rs | 196 +--------------------------- src/qualib_refacto/annalyse.rs | 2 +- src/qualib_refacto/borders.rs | 2 +- src/qualib_refacto/compute_image.rs | 2 +- src/qualib_refacto/init_border.rs | 2 +- src/qualib_refacto/param.rs | 181 +++++++++++++++++++++++++ src/qualib_refacto/wait_space.rs | 2 - 7 files changed, 190 insertions(+), 197 deletions(-) create mode 100644 src/qualib_refacto/param.rs diff --git a/src/qualib_refacto.rs b/src/qualib_refacto.rs index 550bc13..1e40c2d 100644 --- a/src/qualib_refacto.rs +++ b/src/qualib_refacto.rs @@ -13,23 +13,18 @@ use std::time::Instant; use crate::draw::{draw_line, draw_line_dotted}; use crate::point::{Color, Point}; -use enum_iterator::{next, Sequence as Seq}; use opencv::core::Mat; use opencv::Result; -use std::f64::consts::PI; +//use std::f64::consts::PI; -use opencv::core::{bitwise_and, find_file, in_range, Point as OcvPoint, Scalar, Size, Size_}; -use opencv::core::{VecN, Vector}; -use opencv::imgcodecs::imwrite; -use opencv::imgcodecs::{imread, IMREAD_COLOR}; -use opencv::imgproc::{canny, cvt_color, line, COLOR_BGR2GRAY}; use opencv::prelude::*; use opencv::{ highgui, videoio::{self, VideoCapture}, }; -use std::fs::create_dir; -use std::fs::read_dir; + +mod param; +use param::Param; mod init_border; mod load_image; @@ -40,71 +35,6 @@ use load_image::LoadImage; use save_image::SaveImage; use wait_space::WaitSpace; -//impl Clone for dyn Sequence { -// fn clone() { -// } -//} - -#[derive(Debug, Clone)] -pub struct HoughLine { - pub rho: i32, - pub theta: i32, - pub treshold: i32, - pub min_length: i32, - pub max_line_gap: i32, -} - -// ca c'est les donner qu'on envoie a la fonction -pub struct HoughLineValue { - pub rho: f64, - pub theta: f64, - pub treshold: i32, - pub min_length: f64, - pub max_line_gap: f64, -} - -impl HoughLine { - pub fn get_param(&self) -> HoughLineValue { - HoughLineValue { - rho: self.rho as f64 / 100., - theta: self.theta as f64 / 100. * PI / 180., - treshold: self.treshold, - min_length: self.min_length as f64 / 100., - max_line_gap: self.max_line_gap as f64 / 100., - } - } -} - -#[derive(Clone, Debug)] -pub struct Treshold { - pub win_name: String, - pub min_0: i32, - pub min_1: i32, - pub min_2: i32, - pub max_0: i32, - pub max_1: i32, - pub max_2: i32, -} - -impl Treshold { - pub fn new(name: &str, min: i32, max: i32) -> Result { - let tresh = Treshold { - win_name: name.to_owned(), - min_0: min, - min_1: min, - min_2: min, - max_0: max, - max_1: max, - max_2: max, - }; - - Ok(tresh) - } -} - -//impl - -//#[derive(Copy)] pub trait Sequence { fn draw(&self, mem: &Param) -> Option>; fn compute_sequence(&mut self, mem: &mut Param) -> Result<(), Box>; @@ -117,96 +47,11 @@ impl std::fmt::Debug for dyn Sequence { } } -#[derive(Clone, Debug)] -pub struct Param { - seq_id: usize, - imgs: Vec>, - dst_size: i32, - r: i32, - g: i32, - b: i32, - nb_all: i32, - nb_visible: i32, - nb_liss: i32, - tresh: Treshold, - canny_v1: i32, - canny_v2: i32, - hough_param: HoughLine, - border_pt: Vec<(f64, f64)>, - homography: Mat, - h_size: Size_, - line_pos: Vec, - multiple: u16, // le nombre de fois qu'une photo est prise pour certaine sequence - pub key: i32, - dir_name: String, - begin: Instant, - pub capture_mode: bool, -} - -impl Param { - fn save_image(&self) -> Result<()> { - let now = self.begin; - let img_root = format!("image"); - create_dir(&img_root).unwrap_or(()); - let new_dir = format!( - "{img_root}/{:0>6?}_{:0>9?}", - now.elapsed().as_millis(), - now.elapsed().as_nanos() - ); - create_dir(&new_dir).unwrap_or(()); - for (i, img_seq) in self.imgs.iter().enumerate() { - let seq_dir_name = format!("{new_dir}/{i}"); - create_dir(&seq_dir_name).unwrap_or(()); - for img in img_seq { - let mut name_img = format!("{seq_dir_name}/"); - name_img.push_str(&format!("img_{i}.png")); - imwrite(&name_img, img, &Vector::from_slice(&[6, 6, 6, 0]))?; - } - } - - Ok(()) - } - - fn load_image(&mut self) -> Result<(), Box> { - let mut imgs = vec![]; - let paths = read_dir(&self.dir_name)?; - for entry in paths { - let mut seq_img = vec![]; - let dir = entry?; - let path = dir.path(); // sequence directory - let names: Vec<&str> = path.to_str().unwrap().split("/").collect(); - let seq_id: usize = names[names.len() - 1].parse()?; - for entry in read_dir(&path)? { - let sub_path = entry?.path(); - let names: Vec<&str> = path.to_str().unwrap().split("/").collect(); - let img_name = names[names.len() - 1]; - let img_id: usize = img_name[4..img_name.len() - 4].parse()?; - let img: Mat = imread( - &find_file(&sub_path.to_str().unwrap(), false, false)?, - IMREAD_COLOR, - )?; - seq_img.push((img_id, img)); - } - imgs.push((seq_id, seq_img)); - } - - self.imgs = vec![vec![]; imgs.len()]; - for (seq_id, seq_img) in imgs { - self.imgs[seq_id] = vec![Mat::default(); seq_img.len()]; - for (img_id, img) in seq_img { - self.imgs[seq_id][img_id] = img; - } - } - - Ok(()) - } -} #[derive(Debug)] pub struct Qualibration { seq: Vec>, cam: VideoCapture, - cnt: usize, pub param: Param, } @@ -241,37 +86,7 @@ impl Qualibration { Ok(Qualibration { seq, cam, - cnt: 0, - param: Param { - begin: std::time::Instant::now(), - dir_name: dir_name.clone(), - capture_mode: dir_name.len() == 0, - key: -1, - imgs: vec![vec![]], - seq_id: 0, - dst_size: 900, - r: 150, - g: 0, - b: 0, - nb_all: 120, - nb_visible: 40, - nb_liss: 10, - tresh: Treshold::new("histogram", 160, 255)?, - canny_v1: 170, - canny_v2: 255, - hough_param: HoughLine { - rho: 100, - theta: 100, - treshold: 30, - min_length: 0, - max_line_gap: 50000, - }, - border_pt: vec![], - homography: Mat::default(), - h_size: Size::default(), - line_pos: vec![4095; 34], - multiple: 20, - }, + param: Param::new(dir_name.to_owned())?, }) } @@ -307,7 +122,6 @@ impl Qualibration { self.seq[self.param.seq_id].compute_sequence(&mut self.param)?; } - self.cnt += 1; Ok(()) } } diff --git a/src/qualib_refacto/annalyse.rs b/src/qualib_refacto/annalyse.rs index b16a54e..b69b443 100644 --- a/src/qualib_refacto/annalyse.rs +++ b/src/qualib_refacto/annalyse.rs @@ -25,7 +25,7 @@ opencv::not_opencv_branch_4! { use opencv::core::LINE_AA; } -use super::Treshold; +use super::param::Treshold; const MAX_TRACKBAR: i32 = 255; pub fn draw_histograme_dbg( diff --git a/src/qualib_refacto/borders.rs b/src/qualib_refacto/borders.rs index 1302317..326176f 100644 --- a/src/qualib_refacto/borders.rs +++ b/src/qualib_refacto/borders.rs @@ -1,4 +1,4 @@ -use super::HoughLine; +use super::param::HoughLine; use crate::utils::{CartesianEquation, EqAffine, Pt}; use opencv::core::{add, subtract, Mat, VecN, Vector, CV_8UC3}; //use opencv::prelude::MatTraitConst; diff --git a/src/qualib_refacto/compute_image.rs b/src/qualib_refacto/compute_image.rs index 910047b..1072dd8 100644 --- a/src/qualib_refacto/compute_image.rs +++ b/src/qualib_refacto/compute_image.rs @@ -1,4 +1,4 @@ -use super::Treshold; +use super::param::Treshold; use opencv::core::{self, bitwise_and, in_range, Mat, Scalar, Size_}; use opencv::imgproc; use opencv::Result; diff --git a/src/qualib_refacto/init_border.rs b/src/qualib_refacto/init_border.rs index fd6a422..9b082f3 100644 --- a/src/qualib_refacto/init_border.rs +++ b/src/qualib_refacto/init_border.rs @@ -1,6 +1,6 @@ use crate::draw::draw_line; use crate::point::{Color, Point}; -use crate::qualib_refacto::{HoughLine, Param, Sequence}; +use crate::qualib_refacto::{param::{Param, HoughLine}, Sequence}; use crate::qualib_refacto::annalyse::image_diff; use crate::qualib_refacto::borders::{ diff --git a/src/qualib_refacto/param.rs b/src/qualib_refacto/param.rs new file mode 100644 index 0000000..622c3fd --- /dev/null +++ b/src/qualib_refacto/param.rs @@ -0,0 +1,181 @@ +use opencv::{Result, core::{Mat, Size_, Size, Vector, find_file}}; +use opencv::imgcodecs::{imread, IMREAD_COLOR, imwrite}; +use std::time::Instant; +use std::fs::{create_dir, read_dir}; +use std::f64::consts::PI; + +#[derive(Clone, Debug)] +pub struct Param { + pub seq_id: usize, + pub imgs: Vec>, + pub dst_size: i32, + pub r: i32, + pub g: i32, + pub b: i32, + pub nb_all: i32, + pub nb_visible: i32, + pub nb_liss: i32, + pub tresh: Treshold, + pub canny_v1: i32, + pub canny_v2: i32, + pub hough_param: HoughLine, + pub border_pt: Vec<(f64, f64)>, + pub homography: Mat, + pub h_size: Size_, + pub line_pos: Vec, + pub multiple: u16, // le nombre de fois qu'une photo est prise pour certaine sequence + pub key: i32, + pub dir_name: String, + pub begin: Instant, + pub capture_mode: bool, +} + +impl Param { + pub fn new(dir_name: String) -> Result { + Ok(Self { + begin: std::time::Instant::now(), + capture_mode: dir_name.len() == 0, + dir_name, + key: -1, + imgs: vec![vec![]], + seq_id: 0, + dst_size: 900, + r: 150, + g: 0, + b: 0, + nb_all: 120, + nb_visible: 40, + nb_liss: 10, + tresh: Treshold::new("histogram", 160, 255)?, + canny_v1: 170, + canny_v2: 255, + hough_param: HoughLine { + rho: 100, + theta: 100, + treshold: 30, + min_length: 0, + max_line_gap: 50000, + }, + border_pt: vec![], + homography: Mat::default(), + h_size: Size::default(), + line_pos: vec![4095; 34], + multiple: 20, + }) + } + + pub fn save_image(&self) -> Result<()> { + let now = self.begin; + let img_root = format!("image"); + create_dir(&img_root).unwrap_or(()); + let new_dir = format!( + "{img_root}/{:0>6?}_{:0>9?}", + now.elapsed().as_millis(), + now.elapsed().as_nanos() + ); + create_dir(&new_dir).unwrap_or(()); + for (i, img_seq) in self.imgs.iter().enumerate() { + let seq_dir_name = format!("{new_dir}/{i}"); + create_dir(&seq_dir_name).unwrap_or(()); + for img in img_seq { + let mut name_img = format!("{seq_dir_name}/"); + name_img.push_str(&format!("img_{i}.png")); + imwrite(&name_img, img, &Vector::from_slice(&[6, 6, 6, 0]))?; + } + } + + Ok(()) + } + + pub fn load_image(&mut self) -> Result<(), Box> { + let mut imgs = vec![]; + let paths = read_dir(&self.dir_name)?; + for entry in paths { + let mut seq_img = vec![]; + let dir = entry?; + let path = dir.path(); // sequence directory + let names: Vec<&str> = path.to_str().unwrap().split("/").collect(); + let seq_id: usize = names[names.len() - 1].parse()?; + for entry in read_dir(&path)? { + let sub_path = entry?.path(); + let names: Vec<&str> = path.to_str().unwrap().split("/").collect(); + let img_name = names[names.len() - 1]; + let img_id: usize = img_name[4..img_name.len() - 4].parse()?; + let img: Mat = imread( + &find_file(&sub_path.to_str().unwrap(), false, false)?, + IMREAD_COLOR, + )?; + seq_img.push((img_id, img)); + } + imgs.push((seq_id, seq_img)); + } + + self.imgs = vec![vec![]; imgs.len()]; + for (seq_id, seq_img) in imgs { + self.imgs[seq_id] = vec![Mat::default(); seq_img.len()]; + for (img_id, img) in seq_img { + self.imgs[seq_id][img_id] = img; + } + } + + Ok(()) + } +} + + +#[derive(Debug, Clone)] +pub struct HoughLine { + pub rho: i32, + pub theta: i32, + pub treshold: i32, + pub min_length: i32, + pub max_line_gap: i32, +} + +// ca c'est les donner qu'on envoie a la fonction +pub struct HoughLineValue { + pub rho: f64, + pub theta: f64, + pub treshold: i32, + pub min_length: f64, + pub max_line_gap: f64, +} + +impl HoughLine { + pub fn get_param(&self) -> HoughLineValue { + HoughLineValue { + rho: self.rho as f64 / 100., + theta: self.theta as f64 / 100. * PI / 180., + treshold: self.treshold, + min_length: self.min_length as f64 / 100., + max_line_gap: self.max_line_gap as f64 / 100., + } + } +} + +#[derive(Clone, Debug)] +pub struct Treshold { + pub win_name: String, + pub min_0: i32, + pub min_1: i32, + pub min_2: i32, + pub max_0: i32, + pub max_1: i32, + pub max_2: i32, +} + +impl Treshold { + pub fn new(name: &str, min: i32, max: i32) -> Result { + let tresh = Treshold { + win_name: name.to_owned(), + min_0: min, + min_1: min, + min_2: min, + max_0: max, + max_1: max, + max_2: max, + }; + + Ok(tresh) + } +} diff --git a/src/qualib_refacto/wait_space.rs b/src/qualib_refacto/wait_space.rs index 655b6ae..e3d959b 100644 --- a/src/qualib_refacto/wait_space.rs +++ b/src/qualib_refacto/wait_space.rs @@ -12,8 +12,6 @@ impl WaitSpace { } impl Sequence for WaitSpace { - //type Obj = Self; - fn draw(&self, mem: &Param) -> Option> { if mem.key == 32 { return None;