cleanup

src/main.rs

@@ -1,21 +1,20 @@
-use std::collections::{HashMap, VecDeque};
-use std::iter::{zip, Map};
-use std::sync::{mpsc, Arc};
-use std::sync::mpsc::Receiver;
-use std::thread;
-use std::time::{Duration, Instant};
 use hdbscan::{Hdbscan, HdbscanHyperParams};
 use image::{DynamicImage, ImageReader, Rgb, RgbImage};
-use rand::{Rng};
+use rand::Rng;
 use rayon::prelude::*;
 use show_image::{create_window, ImageInfo, ImageView, PixelFormat};
+use std::collections::{HashMap, VecDeque};
+use std::iter::zip;
+use std::sync::mpsc::Receiver;
+use std::sync::{mpsc, Arc};
+use std::thread;
+use std::time::{Duration, Instant};
 
 fn create_extract_thread(image_rx: Receiver<Arc<Vec<u8>>>, width: u32, threshold: u8, downsample: f64) -> Receiver<Arc<Vec<Vec<f64>>>> {
     let (tx, rx) = mpsc::sync_channel::<Arc<Vec<Vec<f64>>>>(1);
     thread::spawn(move || {
         for image in image_rx {
             let max_rng = (u32::MAX as f64 * downsample) as u32;
-            let width_2 = width as f64 / 2.0;
             let poi = image
                 .par_iter()
                 .enumerate()
@@ -55,8 +54,8 @@ fn create_pointcloud_labels_thread(pointcloud_rx: Receiver<Arc<Vec<Vec<f64>>>>)
     pointcloud_labels_rx
 }
 
-fn create_cluster_separator_thread(cluster_labels: Receiver<(Arc<Vec<Vec<f64>>>, Arc<Vec<i32>>)>) -> Receiver<Arc<HashMap::<i32, Vec<Vec<f64>>>>> {
+fn create_cluster_separator_thread(cluster_labels: Receiver<(Arc<Vec<Vec<f64>>>, Arc<Vec<i32>>)>) -> Receiver<Arc<HashMap<i32, Vec<Vec<f64>>>>> {
-    let (clusters_tx, clusters_rx) = mpsc::sync_channel::<Arc<HashMap::<i32, Vec<Vec<f64>>>>>(1);
+    let (clusters_tx, clusters_rx) = mpsc::sync_channel::<Arc<HashMap<i32, Vec<Vec<f64>>>>>(1);
 
     thread::spawn(move || {
         for (pointcloud, labels) in cluster_labels {
@@ -76,7 +75,7 @@ fn create_cluster_separator_thread(cluster_labels: Receiver<(Arc<Vec<Vec<f64>>>,
     clusters_rx
 }
 
-fn create_isolate_lane_thread(clusters_rx: Receiver<Arc<HashMap::<i32, Vec<Vec<f64>>>>>) -> Receiver<Arc<[Vec<Vec<f64>>; 2]>> {
+fn create_isolate_lane_thread(clusters_rx: Receiver<Arc<HashMap<i32, Vec<Vec<f64>>>>>) -> Receiver<Arc<[Vec<Vec<f64>>; 2]>> {
     let (lanes_tx, lanes_rx) = mpsc::sync_channel::<Arc<[Vec<Vec<f64>>; 2]>>(1);
 
     thread::spawn(move || {
@@ -132,7 +131,7 @@ fn create_transform_thread(pointcloud_rx : Receiver<Arc<Vec<Vec<f64>>>>) -> Rece
     projection_rx
 }
 
-fn create_filter_thread() {
+fn _create_filter_thread() {
 
 }
 
@@ -172,23 +171,23 @@ fn main() {
         let colors = vec![Rgb([0, 255, 0]), Rgb([255, 0, 0])];
         for (i, lane) in lanes.iter().enumerate() {
             let color = colors[i];
-            let _ = lane.iter().for_each(|(pixel)| {
+            let _ = lane.iter().for_each(|pixel| {
-                let x = (pixel[0] * 10.0 + rgb_image.width() as f64 / 2.0) as u32;
+                let x = (pixel[0] * 15.0 + rgb_image.width() as f64 / 2.0) as u32;
-                let y = rgb_image.height() - (pixel[1] * 10.0) as u32;
+                let y = rgb_image.height() - (pixel[1] * 15.0) as u32;
 
-                if x < 0 || x > 799 || y < 0 || y > 799  {}
+                if x > 799 || y > 799  {}
                 else {
                     rgb_image.put_pixel(x, y, color);
                     if x > 0 {
                         rgb_image.put_pixel(x - 1, y, color);
                     }
-                    if x < 399 {
+                    if x < 799 {
                         rgb_image.put_pixel(x + 1, y, color);
                     }
                     if y > 0 {
                         rgb_image.put_pixel(x, y - 1, color);
                     }
-                    if y < 399 {
+                    if y < 799 {
                         rgb_image.put_pixel(x, y + 1, color);
                     }
                 }
@@ -204,7 +203,7 @@ fn main() {
             t.pop_front();
         }
         t.push_back(now.elapsed());
-        println!("Avg: {:.6} s", (t.iter().map(|d| d.as_secs_f64()).sum::<f64>() / t.len() as f64));
+        println!("Avg: {:.6} s", t.iter().map(|d| d.as_secs_f64()).sum::<f64>() / t.len() as f64);
         now = Instant::now();
     }
 }