Cargo.toml

@@ -14,4 +14,3 @@ log = "0.4.18"
 redis = "0.23.0"
 ron = "0.8.0"
 serde = { version = "1.0.163", features = ["derive"] }
-toml = "0.7.4"

copyme.Settings.toml

@@ -18,11 +18,3 @@ id = 0
 # For Etherdream. IP of the DAC
 # [dac.etherdream]
 # url = "192.168.1.68"
-
-[[transformers]]
-[transformers.translate]
-x = 2000
-y = 2000
-[[transformers]]
-[transformers.replicate]
-Until = 48

src/conf.rs

@@ -1,16 +1,13 @@
 use config::Config;
 use serde::{Serialize,Deserialize};
 use crate::errors::LJResult;
-use crate::transformer;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Conf {
     pub laser_id: u8,
     pub debug: bool,
     pub redis_url: String,
-    pub dac: DacFamily,
+    pub dac: DacFamily
-    #[serde(default)]
-    pub transformers: Vec<TransformConf>
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -31,15 +28,6 @@ pub struct EtherDreamConf {
     pub url: String
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum TransformConf {
-    #[serde(rename = "translate")] 
-    Translate(transformer::Translate),
-    #[serde(rename = "replicate")] 
-    Replicate(transformer::Replicate)
-}
-
-
 impl Conf {
     pub fn new(path: &str) -> LJResult<Conf> {
 	let settings = Config::builder()
@@ -49,31 +37,4 @@ impl Conf {
 	let conf : Conf = settings.try_deserialize()?;
 	Ok(conf)
     }
-
-    pub fn get_transformers(&self) -> Vec<Box<dyn transformer::Transformers>> {
-	let mut v = vec![];
-	for t in &self.transformers {
-	    let t : Box<dyn transformer::Transformers> = match t {
-		TransformConf::Translate(t) => Box::new(*t),
-		TransformConf::Replicate(r) => Box::new(*r)
-	    };
-	    v.push(t);
-	}
-	v
-    }
-
-    #[allow(dead_code)]
-    pub fn dump() {
-	let conf = Conf { laser_id: 0,
-			  debug: true,
-			  redis_url: "redis://127.0.0.1:6379/".to_string(),
-			  dac: DacFamily::Helios(HeliosConf { id: 0 }),
-			  transformers: vec![
-			      TransformConf::Translate(transformer::Translate::new(2000.0,2000.0)),
-			      TransformConf::Replicate(transformer::Replicate::Until(48))
-			  ]
-	};
-	let s = toml::to_string(&conf).unwrap();
-	println!("{}", s);
-    }
 }

src/device/common.rs

@@ -1,31 +0,0 @@
-
-/*
-self.protocol_version,
-self.le_state,
-self.playback_state,
-self.source,
-self.le_flags,
-self.playback_flags,
-self.source_flags,
-self.fullness,
-self.point_rate,
-self.point_count
-*/
-
-pub struct Status {
-    pub active: bool,
-    pub last_traced_at: String,
-    pub properties: Vec<String>
-}
-
-pub trait Device {
-    /**
-    fn intersect(&self, orig : &Vec3, dir : &Vec3) -> Option<Float>;
-    fn get_surface(&self, v : &Vec3) -> Vec3;
-    fn get_normal(&self, v : &Vec3) -> Vec3;
-    fn get_material(&self) -> &dyn Material;
-    **/
-
-    fn status( &self ) -> Status;
-
-}

src/device/helios.rs

@@ -5,10 +5,10 @@
 use helios_dac::{NativeHeliosDac, NativeHeliosDacController};
 use helios_dac::{
 	// Coordinate,
-	// Color,
+	Color,
 	DeviceStatus,
 	Frame,
-	// Point as HeliosPoint,
+	Point as HeliosPoint,
 };
 use crate::conf::HeliosConf;
 use crate::device::{Device, Status};
@@ -29,17 +29,19 @@ impl HeliosDevice {
 			return Err(Box::new(LJError::HeliosDeviceMissing));
 		};
 		let dac = device.open()?;
-		Ok(Self { conf: (*conf).clone(), dac })
+		Ok(Self {
+			conf: (*conf).clone(),			dac,
+		})
 	}
 }
 
 impl Device for HeliosDevice {
 	fn status(&self) -> Status {
-		Status {
+		return Status {
 			active: true,
 			last_traced_at: "now".to_string(),
 			properties: vec!["foo".to_string()],
-		}
+		};
 	}
 
 	fn draw(&self,
@@ -49,7 +51,7 @@ impl Device for HeliosDevice {
 		while let Ok(DeviceStatus::NotReady) = self.dac.status() {}
 
 		let points: Vec<helios_dac::Point> = line.into_iter().map(|p| p.into()).collect();
-		let _frame = Frame::new(speed, points);
+		let frame = Frame::new(speed, points);
 		Ok(())
 	}
 

src/device/mod.rs

@@ -2,7 +2,7 @@ use crate::point::Point;
 
 mod helios;
 
-use crate::conf::{Conf, DacFamily, /*EtherDreamConf, HeliosConf*/};
+use crate::conf::{Conf, DacFamily, EtherDreamConf, HeliosConf};
 use crate::device::helios::HeliosDevice;
 use crate::errors::LJResult;
 

src/lib.rs

@@ -1,6 +1,5 @@
-pub mod redis_ctrl;
 pub mod conf;
+pub mod redis_ctrl;
 pub mod errors;
 pub mod device;
 pub mod point;
-pub mod transformer;

src/main.rs

@@ -10,17 +10,20 @@ mod transformer;
 mod device;
 
 use device::device_factory;
+
+
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use redis_ctrl::{RedisCtrl, Order};
 use conf::Conf;
-use errors::LJResult;
+use errors::{LJError, LJResult};
 use point::Point;
-use transformer::Transformers;
+use transformer::{Transformers, Translate, Replicate};
 use log::{LevelFilter, info, /* warn, */ error};
 use env_logger::Builder;
 
 const DEFAULT_CONF_FILE: &str = "settings.toml";
+const CENTER: (f32, f32) = (2000.0, 2000.0);
 
 pub fn main() {
 	match run_all() {
@@ -32,18 +35,16 @@ pub fn main() {
 }
 
 fn run_all() -> LJResult<()> {
+
 	// Setup configuration file and set up logs
 	let filename = std::env::args().nth(1).unwrap_or_else(|| {
 		DEFAULT_CONF_FILE.to_string()
 	});
-
 	let config = Conf::new(&filename);
 	init_logging(&config);
 	let config = config?;
 	info!("*** Starting up ***");
 
-	info!("{:?}", config);
-
 	// Setup Redis Service
 	let mut rs = RedisCtrl::new(&config.redis_url)?;
 
@@ -61,7 +62,11 @@ fn run_all() -> LJResult<()> {
 	//dbg!(tracer);
 
 	// Setup geometry transformers on points lists
-	let transformers = config.get_transformers(); 
+	// @todo use the config
+	let transformers: Vec<Box<dyn Transformers>> = vec![
+		Box::new(Translate::new(CENTER.0, CENTER.1)),
+		Box::new(Replicate::Until(48)),
+	];
 
 	// Dispatch based on redis requests
 	while running.load(Ordering::SeqCst) {
@@ -69,7 +74,6 @@ fn run_all() -> LJResult<()> {
 		if order != Order::Draw {
 			info!("Order: {:?}", order);
 		}
-
 		let frame = get_next_frame(&config, &transformers,
 		                           &mut rs, order == Order::Black)?;
 

src/transformer.rs

@@ -1,13 +1,60 @@
-//pub mod common;
-mod translate;
-mod replicate;
-
 use crate::point::Point;
 
-// re-export transformers to be abe to use it directly from transformer::
-pub use translate::Translate;
-pub use replicate::Replicate;
-
 pub trait Transformers {
     fn apply(&self, point_list: &[Point]) -> Vec<Point>;
 }
+
+/// Translate
+
+#[derive(Debug,Clone,Copy)]
+pub struct Translate {
+    x: f32,
+    y: f32
+}
+
+impl Translate {
+    pub fn new(x: f32, y: f32) -> Self {
+	Self { x, y }
+    }
+}
+
+impl Transformers for Translate {
+    fn apply(&self, point_list: &[Point]) -> Vec<Point> {
+	point_list.iter()
+	    .map(| pt | {
+		Point { x: pt.x + self.x,
+			y: pt.y + self.y,
+			..*pt
+		}
+	    }).collect()
+    }
+}
+
+/// Replicate
+
+#[allow(dead_code)]
+#[derive(Debug,Clone,Copy)]
+pub enum Replicate {
+    Until(usize),
+    Times(usize)
+}
+
+impl Transformers for Replicate {
+    fn apply(&self, point_list: &[Point]) -> Vec<Point> {
+	let mut point_list2 = vec![];
+	match self {
+	    Replicate::Until(n) => {
+		while point_list2.len() < *n {
+		    point_list2.append(&mut point_list.to_vec());
+		}
+	    },
+	    Replicate::Times(n) => {
+		for _ in 0..*n {
+		    point_list2.append(&mut point_list.to_vec());		    
+		}
+	    }
+	}
+	point_list2
+    }
+}
+

src/transformer/replicate.rs

@@ -1,32 +0,0 @@
-use crate::transformer::Transformers;
-use crate::point::Point;
-use serde::{Serialize,Deserialize};
-
-/// Replicate
-
-#[allow(dead_code)]
-#[derive(Serialize,Deserialize,Debug,Clone,Copy)]
-pub enum Replicate {
-    Until(usize),
-    Times(usize)
-}
-
-impl Transformers for Replicate {
-    fn apply(&self, point_list: &[Point]) -> Vec<Point> {
-	let mut point_list2 = vec![];
-	match self {
-	    Replicate::Until(n) => {
-		while point_list2.len() < *n {
-		    point_list2.append(&mut point_list.to_vec());
-		}
-	    },
-	    Replicate::Times(n) => {
-		for _ in 0..*n {
-		    point_list2.append(&mut point_list.to_vec());		    
-		}
-	    }
-	}
-	point_list2
-    }
-}
-

src/transformer/translate.rs

@@ -1,29 +0,0 @@
-use crate::transformer::Transformers;
-use crate::point::Point;
-use serde::{Serialize,Deserialize};
-
-/// Translate
-
-#[derive(Serialize,Deserialize,Debug,Clone,Copy)]
-pub struct Translate {
-    x: f32,
-    y: f32
-}
-
-impl Translate {
-    pub fn new(x: f32, y: f32) -> Self {
-	Self { x, y }
-    }
-}
-
-impl Transformers for Translate {
-    fn apply(&self, point_list: &[Point]) -> Vec<Point> {
-	point_list.iter()
-	    .map(| pt | {
-		Point { x: pt.x + self.x,
-			y: pt.y + self.y,
-			..*pt
-		}
-	    }).collect()
-    }
-}