fix: angle correction

add some point at begin and endm beacause angles wasn't calculate

copyme.settings.toml

@@ -35,3 +35,7 @@ Until = 48
 [[transformers]]
 [transformers.intensity]
 
+
+[[transformers]]
+[transformers.angle_correction]
+coef = 2000.0

examples/etherdream.rs

@@ -1,151 +0,0 @@
-extern crate ether_dream;
-
-use ether_dream::dac;
-
-fn main() {
-	println!("Listening for an Ether Dream DAC...");
-
-	let (dac_broadcast, source_addr) = ether_dream::recv_dac_broadcasts()
-		.expect("failed to bind to UDP socket")
-		.filter_map(Result::ok)
-		.next()
-		.unwrap();
-	let mac_address = dac::MacAddress(dac_broadcast.mac_address);
-
-	println!(
-		"Discovered DAC \"{}\" at \"{}\"! Connecting...",
-		mac_address, source_addr
-	);
-
-	// Establish the TCP connection.
-	let mut stream = dac::stream::connect(&dac_broadcast, source_addr.ip().clone()).unwrap();
-
-	// If we want to create an animation (in our case a moving sine wave) we need a frame rate.
-	let frames_per_second = 60.0;
-	// Lets use the DAC at an eighth the maximum scan rate.
-	let points_per_second = stream.dac().max_point_rate / 32;
-	// Determine the number of points per frame given our target frame and point rates.
-	let points_per_frame = (points_per_second as f32 / frames_per_second) as u16;
-
-	println!(
-		"Preparing for playback:\n\tframe_hz: {}\n\tpoint_hz: {}\n\tpoints_per_frame: {}\n",
-		frames_per_second, points_per_second, points_per_frame
-	);
-
-	// Prepare the DAC's playback engine and await the repsonse.
-	stream
-		.queue_commands()
-		.prepare_stream()
-		.submit()
-		.err()
-		.map(|err| {
-			eprintln!(
-				"err occurred when submitting PREPARE_STREAM \
-                      command and listening for response: {}",
-				err
-			);
-		});
-
-	println!("Beginning playback!");
-
-	// The sine wave used to generate points.
-	let mut sine_wave = SineWave {
-		point: 0,
-		points_per_frame,
-		frames_per_second,
-	};
-
-	// Queue the initial frame and tell the DAC to begin producing output.
-	let n_points = points_to_generate(stream.dac());
-	stream
-		.queue_commands()
-		.data(sine_wave.by_ref().take(n_points))
-		.begin(0, points_per_second)
-		.submit()
-		.err()
-		.map(|err| {
-			eprintln!(
-				"err occurred when submitting initial DATA and BEGIN \
-                      commands and listening for response: {}",
-				err
-			);
-		});
-	eprintln!("Stream dac{:?}", stream.dac());
-
-	// Loop and continue to send points forever.
-	loop {
-		// Determine how many points the DAC can currently receive.
-		let n_points = points_to_generate(stream.dac());
-		if let Err(err) = stream
-			.queue_commands()
-			.data(sine_wave.by_ref().take(n_points))
-			.submit()
-		{
-			eprintln!(
-				"err occurred when submitting DATA command and listening \
-                      for response: {}",
-				err
-			);
-			break;
-		}
-	}
-
-	// Tell the DAC to stop producing output and return to idle. Wait for the response.
-	//
-	// Note that the DAC is commanded to stop on `Drop` if this is not called and any errors
-	// produced are ignored.
-	stream
-		.queue_commands()
-		.stop()
-		.submit()
-		.expect("err occurred when submitting STOP command and listening for response");
-}
-
-// Determine the number of points needed to fill the DAC.
-fn points_to_generate(dac: &ether_dream::dac::Dac) -> usize {
-	dac.buffer_capacity as usize - 1 - dac.status.buffer_fullness as usize
-}
-
-// An iterator that endlessly generates a sine wave of DAC points.
-//
-// The sine wave oscillates at a rate of once per second.
-struct SineWave {
-	point: u32,
-	points_per_frame: u16,
-	frames_per_second: f32,
-}
-
-impl Iterator for SineWave {
-	type Item = ether_dream::protocol::DacPoint;
-	fn next(&mut self) -> Option<Self::Item> {
-		let coloured_points_per_frame = self.points_per_frame - 1;
-		let i = (self.point % self.points_per_frame as u32) as u16;
-		let hz = 1.0;
-		let fract = i as f32 / coloured_points_per_frame as f32;
-		let phase = (self.point as f32 / coloured_points_per_frame as f32) / self.frames_per_second;
-		let amp = (hz * (fract + phase) * 2.0 * std::f32::consts::PI).sin();
-		let (r, g, b) = match i {
-			i if i == coloured_points_per_frame || i < 13 => (0, 0, 0),
-			_ => (std::u16::MAX, std::u16::MAX, std::u16::MAX),
-		};
-		let x_min = std::i16::MIN;
-		let x_max = std::i8::MAX as i16;
-		let x = (x_min as f32 + fract * (x_max as f32 - x_min as f32)) as i16;
-		let y = (amp * x_max as f32) as i16;
-		let control = 0;
-		let (u1, u2) = (0, 0);
-		let p = ether_dream::protocol::DacPoint {
-			control,
-			x,
-			y,
-			i,
-			r,
-			g,
-			b,
-			u1,
-			u2,
-		};
-		self.point += 1;
-		Some(p)
-	}
-}

examples/populate_redis.rs

@@ -1,13 +1,6 @@
-use std::io::_print;
+///
-/**
+/// $ cargo run --example populate_redis
-
+///
-# Populate Redis Example
-
-**This script simulates the redis content provided by the LJ Python / web tool**
-
-$ cargo run --example populate_redis
- **/
-
 use redis::{
     //RedisResult,
     Client,
@@ -18,17 +11,16 @@ use redis::{
 fn do_something() -> redis::RedisResult<()> {
     let client = Client::open("redis://127.0.0.1/")?;
     let mut con: Connection = client.get_connection()?;
+
     let _ = con.set("/clientkey", "/pl/0/")?;
-	let _ = con.set("/EDH/0", "[[1.0, 0.0, 0.0],\n [ 0.0, 1.0, 0.0],\n [ 0.0, 0.0, 1.0]]")?;
+    let _ = con.set(
+        "/EDH/0",
+        "[[1.0, 0.0, 0.0],\n [ 0.0, 1.0, 0.0],\n [ 0.0, 0.0, 1.0]]",
+    )?;
     let _ = con.set("/kpps/0", "5000")?;
     let _ = con.set("/intensity/0", "255")?;
-	let _ = con.set("/pl/0/0", "[(1000, 2000, 0), (1000, 1000, 65535), (2000, 1000, 65535), (2000, 2000, 65535), (1000, 2000, 65535)]")?;
     Ok(())
 }
-
 fn main() {
-	match do_something() {
+    _ = do_something();
-		Err(err)    => println!("Something wrong occured: {:?}", err),
-		Ok(..)                  => println!("Successfully inserted content in Redis")
-	}
 }

examples/simple_client.rs

@@ -1,7 +1,6 @@
 ///
 /// $ cargo run --example simple_client
 ///
-
 use redis::{
     //RedisResult,
     Client,
@@ -20,20 +19,16 @@ fn do_something() -> redis::RedisResult<()> {
         let elapsed = start.elapsed();
         let time = 60.0 * elapsed.as_millis() as f32 / 1000.0;
 
-	let mut v : Vec<(f32,f32,u32)> = vec![];
+        let mut v: Vec<(f32, f32, u32)> = vec![];
 
         for i in 0..128 {
             let a = (time + i as f32) / 128.0 * std::f32::consts::PI * 2.0;
-	    let r = 1200.0 + (a*5.0).cos() * (500.0 * (time/5.0).cos());
+            let r = 1200.0 + (a * 5.0).cos() * (500.0 * (time / 5.0).cos());
 
             let x = a.cos() * r;
             let y = a.sin() * r;
-	    let col = if i % 8 < 4 {
+            let col = if i % 8 < 4 { 0x000000ff } else { 0x00ff0000 };
-		0x000000ff
+            v.push((x, y, col));
-	    } else {
-		0x00ff0000
-	    };
-	    v.push((x,y,col));
         }
         // println!("{:?}", v);
         let _ = con.set("/pl/0/0", format!("{:?}", v))?;

examples/test.rs

@@ -1,46 +0,0 @@
-///
-/// $ cargo run --example simple_client
-///
-
-use redis::{
-	//RedisResult,
-	Client,
-	Commands,
-	Connection,
-};
-
-use std::time::Instant;
-
-fn do_something() -> redis::RedisResult<()> {
-	let client = Client::open("redis://127.0.0.1/")?;
-	let mut con: Connection = client.get_connection()?;
-	let start = Instant::now();
-
-	loop {
-		let elapsed = start.elapsed();
-		let time = 60.0 * elapsed.as_millis() as f32 / 1000.0;
-
-		let mut v: Vec<(f32, f32, u32)> = vec![];
-
-		for i in 0..128 {
-			let a = (time + i as f32) / 128.0 * std::f32::consts::PI * 2.0;
-			let r = 1200.0 + (a * 5.0).cos() * (500.0 * (time / 5.0).cos());
-
-			let x = a.cos() * r;
-			let y = a.sin() * r;
-			let col = if i % 8 < 4 {
-				0x000000ff
-			} else {
-				0x00ff0000
-			};
-			v.push((x, y, col));
-		}
-		// println!("{:?}", v);
-		let _ = con.set("/pl/0/0", format!("{:?}", v))?;
-	}
-	// Ok(())
-}
-
-fn main() {
-	_ = do_something();
-}

src/conf.rs

@@ -1,7 +1,7 @@
-use config::Config;
-use serde::{Serialize, Deserialize};
 use crate::errors::{LJError, LJResult};
 use crate::transformer;
+use config::Config;
+use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Conf {
@@ -49,36 +49,39 @@ pub enum TransformConf {
     Grid(transformer::Grid),
     #[serde(rename = "homography")]
     Homography(transformer::Homography),
-	#[serde(rename = "helios_to_etherdream")]
+    #[serde(rename = "angle_correction")]
-	HeliosToEtherdream(transformer::HeliosToEtherdream),
+    AngleOptimisation(transformer::AngleOptimisation),
-	#[serde(rename = "intensity")]
-	Intensity(transformer::Intensity),
 }
 
-
 impl Conf {
     pub fn new(path: &str) -> LJResult<Conf> {
         let settings = Config::builder()
             .add_source(config::File::with_name(path))
             .build()?;
 
+        dbg!("path:", path);
+        //println!("plop");
+        dbg!(settings.clone());
         let conf: Conf = settings.try_deserialize().map_err(LJError::Config)?;
+
+        //println!("plum");
         Ok(conf)
     }
 
+    //println!("plop");
+
     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),
+                TransformConf::Rotate(r) => Box::new(*r),
                 TransformConf::FlipH(r) => Box::new(*r),
                 TransformConf::FlipV(r) => Box::new(*r),
                 TransformConf::Grid(r) => Box::new(*r),
-				TransformConf::HeliosToEtherdream(r) => Box::new(*r),
                 TransformConf::Homography(r) => Box::new(*r),
-				TransformConf::Intensity(r) => Box::new(*r),
+                TransformConf::AngleOptimisation(r) => Box::new(*r),
-				TransformConf::Replicate(r) => Box::new(*r),
-				TransformConf::Rotate(r) => Box::new(*r),
-				TransformConf::Translate(t) => Box::new(*t),
             };
             v.push(t);
         }

src/device.rs

@@ -1,15 +1,15 @@
-mod helios;
 mod dummy;
 mod etherdream;
+mod helios;
 
-use std::fmt;
 use crate::conf::{Conf, DacFamily /*EtherDreamConf, HeliosConf*/};
-use crate::device::helios::HeliosDevice;
 use crate::device::dummy::DummyDevice;
+use crate::device::etherdream::EtherdreamDevice;
+use crate::device::helios::HeliosDevice;
 use crate::errors::LJResult;
 use crate::point::Point;
 use serde::Serialize;
-use crate::device::etherdream::EtherdreamDevice;
+use std::fmt;
 
 /*
 self.protocol_version,
@@ -28,7 +28,8 @@ self.point_count
 pub enum PlaybackState {
     IDLE = 0,
     PREPARE = 1,
-	PLAYING = 2
+    PLAYING = 2,
+    UNKNOWN = 99,
 }
 
 impl fmt::Display for PlaybackState {
@@ -42,7 +43,7 @@ pub struct Status {
     pub last_traced_at: String,
     pub properties: Vec<String>,
     pub playback_state: PlaybackState,
-	pub capacity: usize,
+    pub capacity: u16,
     pub lack: String,
 }
 
@@ -52,11 +53,7 @@ pub struct Status {
 
 pub trait Device {
     fn status(&mut self) -> Status;
-	fn draw(
+    fn draw(&mut self, frame: Vec<Point>, speed: u32) -> LJResult<()>;
-		&mut self,
-		frame: Vec<Point>,
-		speed: u32,
-	) -> LJResult<()>;
     fn stop(&mut self) -> LJResult<()>;
     fn grid(&mut self) -> Vec<Point>;
 }
@@ -64,8 +61,8 @@ pub trait Device {
 pub fn device_factory(config: &Conf) -> LJResult<Box<dyn Device>> {
     let device: Box<dyn Device> = match &config.dac {
         DacFamily::Helios(conf) => Box::new(HeliosDevice::new(conf)?),
-		DacFamily::Etherdream( conf) => Box::new( EtherdreamDevice::new(conf)?),
+        DacFamily::Etherdream(conf) => Box::new(EtherdreamDevice::new(conf)?),
-		DacFamily::Dummy => Box::new(DummyDevice::new()?)
+        DacFamily::Dummy => Box::new(DummyDevice::new()?),
     };
     Ok(device)
 }

src/device/dummy.rs

@@ -1,15 +1,17 @@
-use crate::device::{Device, Status, PlaybackState};
+use crate::device::{Device, PlaybackState, Status};
 use crate::errors::LJResult;
 use crate::point::{Color, Point};
 use log::debug;
 
 pub struct DummyDevice {
-    state: PlaybackState
+    state: PlaybackState,
 }
 
 impl DummyDevice {
     pub fn new() -> LJResult<Self> {
-	    Ok(Self { state: PlaybackState::IDLE })
+        Ok(Self {
+            state: PlaybackState::IDLE,
+        })
     }
 }
 
@@ -20,14 +22,11 @@ impl Device for DummyDevice {
             properties: vec!["foo".to_string()],
             playback_state: self.state,
             capacity: 0,
-			lack: "lack".to_string()
+            lack: "lack".to_string(),
         }
     }
 
-	fn draw(&mut self,
+    fn draw(&mut self, line: Vec<Point>, speed: u32) -> LJResult<()> {
-	        line: Vec<Point>,
-	        speed: u32,
-	) -> LJResult<()> {
         debug!("Draw Line at speed {speed} : {:?}", line);
         Ok(())
     }
@@ -36,8 +35,10 @@ impl Device for DummyDevice {
         Ok(())
     }
     fn grid(&mut self) -> Vec<Point> {
-		vec!(
+        vec![Point {
-			Point{ x: 0 as f32, y: 0 as f32, color:Color{ r: 0, g: 0, b: 0 }}
+            x: 0 as f32,
-		)
+            y: 0 as f32,
+            color: Color { r: 0, g: 0, b: 0 },
+        }]
     }
 }

src/device/etherdream.rs

@@ -1,308 +1,155 @@
-#[warn(unused_imports)]
+use ether_dream::dac::stream::connect;
-use log::{ debug, info, warn};
+use ether_dream::dac::Stream;
-
 use std::net::SocketAddr;
-use std::thread::sleep;
-use ether_dream::dac::stream::{CommunicationError, connect};
-use ether_dream::dac::{Playback, Stream};
-use chrono::{DateTime, Utc};
 use std::time;
-use std::time::{Duration, SystemTime};
 
 use crate::conf::EtherDreamConf;
-use crate::device::{Device, Status, PlaybackState};
+use crate::device::{Device, PlaybackState, Status};
 use crate::errors::{LJError, LJResult};
 use crate::point::{Color, Point};
-use ether_dream::protocol::{DacBroadcast, DacResponse};
+use ether_dream::protocol::{DacBroadcast, DacStatus};
-
+use log::{info, warn};
 
 #[warn(dead_code)]
 pub struct EtherdreamDevice {
     pub conf: EtherDreamConf,
     dac: DacBroadcast,
+    // source_address: SocketAddr,
     stream: Stream,
-
+    // sent_points: u16,
-	// "a": ACK   "F": Full  "I": invalid. 64 or 35 for no connection.
+    lack: String,
-	//     /// The previous command was accepted.
+    last_traced_at: String,
-	//     pub const ACK: u8 = 0x61;
-	//     /// The write command could not be performed because there was not enough buffer space when it
-	//     /// was received.
-	//     pub const NAK_FULL: u8 = 0x46;
-	//     /// The command contained an invalid `command` byte or parameters.
-	//     pub const NAK_INVALID: u8 = 0x49;
-	//     /// An emergency-stop condition still exists.
-	//     pub const NAK_STOP_CONDITION: u8 = 0x21;
-	// }
-	dac_response: u8,
 }
 
 impl EtherdreamDevice {
     pub fn new(conf: &EtherDreamConf) -> LJResult<Self> {
-		let (dac, _source_address, stream) = EtherdreamDevice::connect(conf)?;
+        let (dac, _source_address, stream) = EtherdreamDevice::get_dac(conf)?;
+        // let (dac, source_address) = EtherdreamDevice::get_dac(conf)?;
         Ok(Self {
             conf: (*conf).clone(),
             dac,
+            // source_address,
             stream,
-			dac_response: DacResponse::ACK,
+            // sent_points: 0,
+            lack: "".to_string(),
+            last_traced_at: "1985-04-12T23:20:50.52Z".to_string(),
         })
     }
-	fn connect(conf: &EtherDreamConf) -> LJResult<(DacBroadcast, SocketAddr, Stream)> {
+    pub fn get_dac(conf: &EtherDreamConf) -> LJResult<(DacBroadcast, SocketAddr, Stream)> {
         let ip = &conf.ip;
         let dac_broadcast = ether_dream::recv_dac_broadcasts()?;
         dac_broadcast.set_timeout(Some(time::Duration::new(10, 0)))?;
         info!("Attempting to get DAC broadcast...");
         let broadcast = dac_broadcast
-			.take(3)
+            .filter_map(|result| match result {
-			.filter_map(|result| {
-				match result {
                 Err(err) => {
-						warn!( "Failed to find a valid DAC via broadcast. Error: {:?}", err);
+                    warn!("Failed to find a valid DAC via broadcast. Error: {:?}", err);
-						info!( "Retrying...");
+                    info!("Retrying...");
                     None
                 }
                 Ok((dac, source_addr)) => {
-						info!("Valid broadcast, source_addr: {}", source_addr);
                     if source_addr.is_ipv6() {
-							warn!("Broadcast ignored: ipv6 address.");
                         return None;
                     }
-						let src_ip = source_addr.ip().to_string();
+                    if &source_addr.ip().to_string() != ip {
-						if &src_ip != ip {
-							warn!("Broadcast ignored: expected {ip}, got: {src_ip} ");
                         return None;
                     }
+                    info!("Valid broadcast");
                     Some(Ok((dac, source_addr)))
                 }
-				}
             })
             .next()
             .expect("Failed to receive broadcast.");
         match broadcast {
-			Err(err) => {
+            Err(err) => Err(Box::new(LJError::EtherdreamConnectError(err))),
-				Err(Box::new(LJError::EtherdreamConnectError(err)))
-			}
             Ok((dac, source_addr)) => {
-				info!("Trying to open TCP stream...");
                 let stream = EtherdreamDevice::get_tcp_stream(&dac, &source_addr)?;
-				info!("Finished configuring DAC and TCP stream.");
                 Ok((dac, source_addr, stream))
             }
         }
     }
 
-	fn get_tcp_stream(dac: &DacBroadcast, source_address: &SocketAddr) -> LJResult<Stream> {
+    pub fn get_tcp_stream(dac: &DacBroadcast, source_address: &SocketAddr) -> LJResult<Stream> {
+        // Establish the TCP connection.
         let mut stream = connect(dac, source_address.ip())?;
-		match stream
+
+        // Prepare  stream
+        stream
             .queue_commands()
             .prepare_stream()
-			.submit() {
+            .submit()
-			Err(err) => warn!("err occurred when submitting PREPARE_STREAM command and listening for response: {}",err),
+            .err()
-			Ok(_) => info!("Prepared Stream.")
+            .map(|err| {
-		}
+                eprintln!(
-		// If we want to create an animation (in our case a moving sine wave) we need a frame rate.
+                    "err occurred when submitting PREPARE_STREAM \
-		let frames_per_second = 60.0;
+		                  command and listening for response: {}",
-		// Lets use the DAC at an eighth the maximum scan rate.
+                    err
-		let points_per_second = stream.dac().max_point_rate / 32;
+                );
-		// Determine the number of points per frame given our target frame and point rates.
+            });
-		let points_per_frame = (points_per_second as f32 / frames_per_second) as u16;
-
-		let mut sine_wave = SineWave {
-			point: 0,
-			points_per_frame,
-			frames_per_second,
-		};
-
-		match stream
-			.queue_commands()
-			.data(sine_wave.by_ref().take(400))
-			// .data(begin_list.into_iter().take(400 as usize))
-			.begin(0, points_per_second)
-			.submit() {
-			Err(err) => warn!("err occurred when submitting first data: {}",err),
-			Ok(_) => info!("Sent first data to Etherdream.")
-		}
 
         Ok(stream)
     }
 
-	fn points_capacity(&self) -> usize {
+    pub fn check_tcp_stream(&mut self) -> LJResult<()> {
-		/***
+        // todo Reinit stream if needed
-		Determine the number of points needed to fill the DAC.
+        // self.stream = EtherdreamDevice::get_tcp_stream(&self.dac, &self.source_address)?
-		 ***/
+        Ok(())
-		// Fixme thread 'main' panicked at 'attempt to subtract with overflow', src/device/etherdream.rs:144:24
-		let n_points = self.dac.buffer_capacity as usize - self.stream.dac().dac.status.buffer_fullness as usize - 1;
-		n_points
     }
 
-	fn ping(&mut self) -> LJResult<()> {
+    // Determine the number of points needed to fill the DAC.
-
+    fn points_to_generate(&self) -> usize {
-		Ok(self.stream.queue_commands().ping().submit()?)
+        self.dac.buffer_capacity as usize - 1 - self.dac.dac_status.buffer_fullness as usize
-
     }
 }
 
 impl Device for EtherdreamDevice {
     fn status(&mut self) -> Status {
-		let playback_state = match self.stream.dac().dac.status.playback {
+        let _ = self.check_tcp_stream();
-			Playback::Idle => PlaybackState::IDLE,
+
-			Playback::Prepared => PlaybackState::PREPARE,
+        // "a": ACK   "F": Full  "I": invalid. 64 or 35 for no connection.
-			Playback::Playing => PlaybackState::PLAYING,
+        let playback_state = match self.dac.dac_status.playback_state {
+            DacStatus::PLAYBACK_IDLE => PlaybackState::IDLE,
+            DacStatus::PLAYBACK_PREPARED => PlaybackState::PREPARE,
+            DacStatus::PLAYBACK_PLAYING => PlaybackState::PLAYING,
+            _ => PlaybackState::UNKNOWN,
         };
-		let now = SystemTime::now();
-		let now: DateTime<Utc> = now.into();
-		let now = now.to_rfc3339();
 
         Status {
-			last_traced_at: now,
+            last_traced_at: self.last_traced_at.clone(),
             properties: vec!["foo".to_string()],
             playback_state,
-			capacity: self.points_capacity(),
+            capacity: self.dac.dac_status.buffer_fullness,
-			lack: self.dac_response.to_string(),
+            lack: String::from(&self.lack),
         }
-		// debug!("Dac Status: {:?} ", status );
-		// debug!("Etherdream Dac {:?} ", self.dac );
-		// debug!("Stream dac{:?}", self.stream.dac());
-		// status
     }
 
-	fn draw(&mut self,
+    fn draw(&mut self, line: Vec<Point>, _speed: u32) -> LJResult<()> {
-	        line: Vec<Point>,
+        let n_points = self.points_to_generate();
-	        _speed: u32,
+        self.stream
-	) -> LJResult<()> {
-		let chunk_size = 64;
-		let points_iter = line.into_iter();
-		for chunk in  points_iter.as_slice().chunks(chunk_size){
-			debug!("New chunk length: {:?}", chunk.len());
-			loop {
-				let capacity = self.points_capacity();
-				if chunk.len() > capacity {
-					debug!("Sleep, capacity : {:?}", capacity);
-					// Sleep for 1/100th of a sec
-					sleep(Duration::new( 0,     10000000));
-					self.ping()?;
-				} else {
-					break;
-				}
-			}
-			debug!("drawing");
-			match self.stream
             .queue_commands()
-				.data(
+            .data(line.into_iter().map(|point| point.into()).take(n_points))
-					chunk.iter()
+            .submit()?;
-						.map(|point| (*point).into())
-						.take(chunk_size)
-				)
-				.submit() {
-				Err(err) => {
-					// We should account for
-					// 'Broken pipe (os error 32)'
-					// Connection reset by peer (os error 104)
-					self.dac_response = match err {
-						CommunicationError::Io(err) => {
-							warn!("IO ERROR while drawing: '{}'",err);
-							DacResponse::ACK
-						}
-						CommunicationError::Protocol(err) => {
-							warn!("Protocol ERROR while drawing: '{}'",err);
-							DacResponse::ACK
-						}
-						CommunicationError::Response(err) => {
-							warn!("Response ERROR while drawing: '{}'",err);
-							err.response.response
-						}
-					};
-				}
-				Ok(_) => {
-					self.dac_response = DacResponse::ACK;
-					// debug!("Draw is ok");
-				}
-			};
-		}
         Ok(())
     }
 
     fn stop(&mut self) -> LJResult<()> {
-		info!("Stopping Etherdream device...");
+        self.stream
-		match self.stream
             .queue_commands()
             .stop()
             .submit()
-		{
+            .expect("err occurred when submitting STOP command and listening for response");
-			Err(err) => {
-				warn!("Failed to stop EtherDream device with error {:?}", err);
-				Err(Box::new(err))
-			}
-			Ok(_) => {
-				info!("Sucessfully closed EtherDream device.");
         Ok(())
     }
-		}
-	}
 
     fn grid(&mut self) -> Vec<Point> {
-		let dim_mid = 16000.0;
+        vec![Point {
-		let dim_max = 32000.0;
+            x: 0.0,
-		let col_min = Color { r: 0, g: 0, b: 0 };
+            y: 0.0,
-		let col_max = Color { r: 255, g: 255, b: 255 };
+            color: Color {
-
+                r: 255,
-		vec![
+                g: 255,
-			Point { x: -dim_max, y: dim_max, color: col_min },
+                b: 255,
-			Point { x: -dim_max, y: dim_max, color: col_max },
+            },
-			Point { x: dim_max, y: dim_max, color: col_max },
+        }]
-			Point { x: dim_max, y: -dim_max, color: col_max },
-			Point { x: -dim_max, y: -dim_max, color: col_max },
-			Point { x: -dim_max, y: -dim_mid, color: col_min },
-			Point { x: -dim_mid, y: dim_mid, color: col_min },
-			Point { x: -dim_mid, y: dim_mid, color: col_max },
-			Point { x: dim_mid, y: dim_mid, color: col_max },
-			Point { x: dim_mid, y: -dim_mid, color: col_max },
-			Point { x: -dim_mid, y: -dim_mid, color: col_max },
-			Point { x: -dim_mid, y: -dim_mid, color: col_min },
-		]
-	}
-}
-
-// An iterator that endlessly generates a sine wave of DAC points.
-//
-// The sine wave oscillates at a rate of once per second.
-struct SineWave {
-	point: u32,
-	points_per_frame: u16,
-	frames_per_second: f32,
-}
-
-impl Iterator for SineWave {
-	type Item = ether_dream::protocol::DacPoint;
-	fn next(&mut self) -> Option<Self::Item> {
-		let coloured_points_per_frame = self.points_per_frame - 1;
-		let i = (self.point % self.points_per_frame as u32) as u16;
-		let hz = 1.0;
-		let fract = i as f32 / coloured_points_per_frame as f32;
-		let phase = (self.point as f32 / coloured_points_per_frame as f32) / self.frames_per_second;
-		let amp = (hz * (fract + phase) * 2.0 * std::f32::consts::PI).sin();
-		let (r, g, b) = match i {
-			i if i == coloured_points_per_frame || i < 13 => (0, 0, 0),
-			_ => (u16::MAX, u16::MAX, u16::MAX),
-		};
-		let x_min = i16::MIN;
-		let x_max = i16::MAX;
-		let x = (x_min as f32 + fract * (x_max as f32 - x_min as f32)) as i16;
-		let y = (amp * x_max as f32) as i16;
-		let control = 0;
-		let (u1, u2) = (0, 0);
-		let p = ether_dream::protocol::DacPoint {
-			control,
-			x,
-			y,
-			i,
-			r,
-			g,
-			b,
-			u1,
-			u2,
-		};
-		// debug!("{:?}",p);
-		self.point += 1;
-		Some(p)
     }
 }

src/device/helios.rs

@@ -1,9 +1,8 @@
-use std::time::SystemTime;
+use crate::conf::HeliosConf;
-///
+use crate::device::{Device, PlaybackState, Status};
-/// Configure udev:
+use crate::errors::{LJError, LJResult};
-/// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
+use crate::point::{Color, Point};
-///
+use chrono::Utc;
-use helios_dac::{NativeHeliosDac, NativeHeliosDacController};
 use helios_dac::{
     // Coordinate,
     // Color,
@@ -11,11 +10,11 @@ use helios_dac::{
     Frame,
     // Point as HeliosPoint,
 };
-use crate::conf::HeliosConf;
+///
-use crate::device::{Device, Status, PlaybackState};
+/// Configure udev:
-use crate::errors::{LJError, LJResult};
+/// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
-use crate::point::{Color, Point};
+///
-use chrono::{DateTime, Utc};
+use helios_dac::{NativeHeliosDac, NativeHeliosDacController};
 
 pub struct HeliosDevice {
     pub conf: HeliosConf,
@@ -35,17 +34,13 @@ impl HeliosDevice {
 			return Err(Box::new(LJError::HeliosDeviceMissing));
 		};
         let dac = device.open()?;
-		let now = SystemTime::now();
-		let now: DateTime<Utc> = now.into();
-		let last_traced_at = now.to_rfc3339();
-
         Ok(Self {
             conf: (*conf).clone(),
             dac,
             sent_points: 0,
             state: PlaybackState::PREPARE,
             lack: "".to_string(),
-			last_traced_at,
+            last_traced_at: "1985-04-12T23:20:50.52Z".to_string(),
         })
     }
 }
@@ -57,15 +52,12 @@ impl Device for HeliosDevice {
             last_traced_at: self.last_traced_at.clone(),
             properties: vec!["foo".to_string()],
             playback_state: self.state,
-			capacity: self.sent_points as usize,
+            capacity: self.sent_points,
             lack,
         }
     }
 
-	fn draw(&mut self,
+    fn draw(&mut self, line: Vec<Point>, speed: u32) -> LJResult<()> {
-	        line: Vec<Point>,
-	        speed: u32,
-	) -> LJResult<()> {
         self.state = PlaybackState::IDLE;
         while let Ok(DeviceStatus::NotReady) = self.dac.status() {}
         self.state = PlaybackState::PLAYING;
@@ -85,24 +77,76 @@ impl Device for HeliosDevice {
 
     fn grid(&mut self) -> Vec<Point> {
         let dim_min = 0 as f32;
-		let dim_mid = 2047.0;
+        let dim_mid = 2047 as f32;
-		let dim_max = 4095.0;
+        let dim_max = 4095 as f32;
         let col_min = Color { r: 0, g: 0, b: 0 };
-		let col_max = Color { r: 255, g: 255, b: 255 };
+        let col_max = Color {
+            r: 255,
+            g: 255,
+            b: 255,
+        };
 
         vec![
-			Point { x: dim_min, y: dim_max, color: col_min },
+            Point {
-			Point { x: dim_min, y: dim_max, color: col_max },
+                x: dim_min,
-			Point { x: dim_max, y: dim_max, color: col_max },
+                y: dim_max,
-			Point { x: dim_max, y: dim_min, color: col_max },
+                color: col_min,
-			Point { x: dim_min, y: dim_min, color: col_max },
+            },
-			Point { x: dim_min, y: dim_min, color: col_min },
+            Point {
-			Point { x: dim_min, y: dim_mid, color: col_min },
+                x: dim_min,
-			Point { x: dim_min, y: dim_mid, color: col_max },
+                y: dim_max,
-			Point { x: dim_mid, y: dim_mid, color: col_max },
+                color: col_max,
-			Point { x: dim_mid, y: dim_min, color: col_max },
+            },
-			Point { x: dim_min, y: dim_min, color: col_max },
+            Point {
-			Point { x: dim_min, y: dim_min, color: col_min },
+                x: dim_max,
+                y: dim_max,
+                color: col_max,
+            },
+            Point {
+                x: dim_max,
+                y: dim_min,
+                color: col_max,
+            },
+            Point {
+                x: dim_min,
+                y: dim_min,
+                color: col_max,
+            },
+            Point {
+                x: dim_min,
+                y: dim_min,
+                color: col_min,
+            },
+            Point {
+                x: dim_min,
+                y: dim_mid,
+                color: col_min,
+            },
+            Point {
+                x: dim_min,
+                y: dim_mid,
+                color: col_max,
+            },
+            Point {
+                x: dim_mid,
+                y: dim_mid,
+                color: col_max,
+            },
+            Point {
+                x: dim_mid,
+                y: dim_min,
+                color: col_max,
+            },
+            Point {
+                x: dim_min,
+                y: dim_min,
+                color: col_max,
+            },
+            Point {
+                x: dim_min,
+                y: dim_min,
+                color: col_min,
+            },
         ]
     }
 }

src/errors.rs

@@ -1,7 +1,7 @@
+use config::ConfigError;
+use redis::RedisError;
 use std::error::Error;
 use std::{fmt, io};
-use redis::RedisError;
-use config::ConfigError;
 
 pub type LJResult<T> = Result<T, Box<dyn std::error::Error>>;
 
@@ -44,7 +44,7 @@ impl Error for LJError {
 
         match self {
             RedisConnect(err) => Some(err),
-			_ => None
+            _ => None,
         }
     }
 }

src/framerate.rs

@@ -1,39 +0,0 @@
-use log::{debug, warn};
-use std::time::{Duration, Instant};
-use crate::errors::LJResult;
-use std::{thread};
-
-/// Converts helios Geometry to Helios
-#[derive(Debug, Clone, Copy)]
-pub struct Framerate {
-	prev_trace_time: Instant,
-	fps: u8,
-}
-
-impl Framerate {
-	pub fn new() -> LJResult<Self> {
-		Ok(Framerate {
-			prev_trace_time: Instant::now(),
-			fps: 20,
-		})
-	}
-	pub fn handle_time(&mut self) -> LJResult<()> {
-		let frame_time = 1000000000 / self.fps as u128;
-		let now = Instant::now();
-		// How long since last loop ?
-		let nanotime_spent = self.prev_trace_time.elapsed().as_nanos();
-		// Diw it go too fast? If so : sleep a bit
-		if frame_time > nanotime_spent {
-			let nanotime_towait = frame_time - nanotime_spent;
-			let dur = Duration::new(0, (nanotime_towait as f32 * 0.9) as u32);
-			// debug!("{:?} - {:?} : {:?}", nanotime_towait, self.prev_trace_time, now );
-			thread::sleep(dur);
-			debug!("Framerate OK");
-		} else {
-			warn!("Frame longer than expected {:?} > {:?}", nanotime_spent, frame_time, );
-		}
-
-		self.prev_trace_time = now;
-		Ok(())
-	}
-}

src/lib.rs

@@ -1,8 +1,7 @@
-pub mod redis_ctrl;
 pub mod conf;
-pub mod errors;
 pub mod device;
+pub mod errors;
 pub mod point;
+pub mod redis_ctrl;
 pub mod transformer;
 pub mod worldstate;
-pub mod framerate;

src/main.rs

@@ -1,28 +1,26 @@
+mod conf;
+mod device;
+mod errors;
+mod point;
 ///
 /// Configure udev:
 /// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
 ///
 mod redis_ctrl;
-mod conf;
-mod errors;
-mod point;
 mod transformer;
-mod device;
 mod worldstate;
-mod framerate;
 
+use conf::Conf;
 use device::device_factory;
+use env_logger::Builder;
+use errors::LJResult;
+use log::{/* warn, */ error, info, LevelFilter};
+use point::{Color, Point};
+use redis_ctrl::{Order, RedisCtrl};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-use redis_ctrl::{RedisCtrl, Order};
-use conf::Conf;
-use errors::LJResult;
-use point::{Point, Color};
 use transformer::Transformers;
-use log::{LevelFilter, info, /* warn, */ error};
-use env_logger::Builder;
 use worldstate::WorldState;
-use framerate::Framerate;
 
 const DEFAULT_CONF_FILE: &str = "settings.toml";
 
@@ -35,19 +33,11 @@ pub fn main() {
     }
 }
 
-
 fn run_all() -> LJResult<()> {
-	// Setup handler for interrupt Signals
-	let running = Arc::new(AtomicBool::new(true));
-	let r = running.clone();
-	ctrlc::set_handler(move || {
-		r.store(false, Ordering::SeqCst);
-	})?;
-
     // Setup configuration file and set up logs
-	let filename = std::env::args().nth(1).unwrap_or_else(|| {
+    let filename = std::env::args()
-		DEFAULT_CONF_FILE.to_string()
+        .nth(1)
-	});
+        .unwrap_or_else(|| DEFAULT_CONF_FILE.to_string());
 
     let config = Conf::new(&filename);
     init_logging(&config);
@@ -61,23 +51,31 @@ fn run_all() -> LJResult<()> {
 
     let mut world_state = rs.init_world_state().unwrap();
     info!("WorldState: {:?}", world_state);
+    dbg!("worldstate.kpps: {}", world_state.kpps);
 
+    // Setup handler for interrupt Signals
+    let running = Arc::new(AtomicBool::new(true));
+    let r = running.clone();
+    ctrlc::set_handler(move || {
+        r.store(false, Ordering::SeqCst);
+    })?;
 
     // Setup Laser Device based on conf
     let mut tracer = device_factory(&config)?;
     world_state.grid = tracer.grid();
 
+    // can't work, but we can add + Debug to Device to make it work...
+    //dbg!(tracer);
+
     // Setup geometry transformers on points lists
     let transformers = config.get_transformers();
 
-	// Setup framerate limiter
-	let mut framerate_handler = Framerate::new()?;
-
     // Dispatch based on redis requests
     while running.load(Ordering::SeqCst) {
         rs.set_status(tracer.status())?;
-		framerate_handler.handle_time()?;
+
         let order = rs.get_order(config.laser_id)?;
+
         match order {
             Order::Draw | Order::Black | Order::Grid => {
                 // 0 : Draw Normal point list
@@ -85,19 +83,13 @@ fn run_all() -> LJResult<()> {
                 // 3 : Draw GRID point list
                 world_state.draw_black = order == Order::Black;
                 world_state.draw_grid = order == Order::Grid;
-				let frame = get_next_frame(
+                let frame = get_next_frame(&config, &transformers, &mut rs, &world_state)?;
-					&config,
-					&transformers,
-					&mut rs,
-					&world_state,
-				)?;
                 // For now, draw all the time
                 tracer.draw(frame, world_state.kpps)?;
             }
             Order::Intensity => {
                 // 6 : Max Intensity Change     = reread redis key /intensity
-				world_state.intensity = rs.get_int("intensity")?
+                world_state.intensity = rs.get_int("intensity")?.try_into()?;
-					.try_into()?;
             }
             Order::Edh => {
                 // 1 : Get the new EDH          = reread redis key /EDH/lasernumber
@@ -106,18 +98,16 @@ fn run_all() -> LJResult<()> {
             Order::Kpps => {
                 // 7 : kpps change              = reread redis key /kpps
                 world_state.kpps = rs.get_int("kpps")?;
+                //dbg!(world_state.kpps);
             }
             Order::ClientKey => {
                 world_state.client_key = rs.get_client_key()?;
             }
-			Order::ColorBalance => {
+            // Order::ColorBalance => {},
-				let (r, g, b) = rs.get_color_balance()?;
-				world_state.color_balance = Color { r, g, b };
-			}
-			Order::Resampler => {
-				world_state.resampler = rs.get_resampler()?;
-			}
             _ => {
+                // 4 : Resampler Change (longs and shorts lsteps)
+                // 5 : Client Key Change        = reread redis key /clientkey
+                // 8 : color balance change     = reread redis keys /red /green /blue
                 // 9 : poweroff LJ
                 info!("Order: {:?}", order);
             }
@@ -131,18 +121,13 @@ fn run_all() -> LJResult<()> {
 
 fn init_logging(config: &LJResult<Conf>) {
     if let Ok(ref config) = config {
-		let level = if config.debug {
+        if config.debug {
-			LevelFilter::Debug
-		} else {
-			LevelFilter::Info
-		};
             let mut builder = Builder::from_default_env();
-		builder
+            builder.filter(None, LevelFilter::Info).init();
-			.filter(None, level)
-			.init();
             info!("Debug mode enabled from configuration file");
             return;
         }
+    }
     info!("Logging level inherited from env");
     env_logger::init();
 }
@@ -153,9 +138,7 @@ fn get_next_frame(
     rs: &mut RedisCtrl,
     world_state: &WorldState,
 ) -> LJResult<Vec<Point>> {
-	let format_key = format!("{}{}",
+    let format_key = format!("{}{}", world_state.client_key, config.laser_id);
-	                         world_state.client_key,
-	                         config.laser_id);
 
     // Handle the grid case
 
@@ -163,20 +146,20 @@ fn get_next_frame(
         world_state.grid.clone()
     } else {
         let redis_line = rs.get_line(&format_key)?;
-		redis_line.into_iter()
+        redis_line.into_iter().map(|tpl| tpl.into()).collect()
-			.map(|tpl| tpl.into())
-			.collect()
     };
 
     for transformer in transformers {
         line = transformer.apply(&line, world_state);
     }
 
-	// info!("Draw Black -> {}", world_state.draw_black);
+
-	// info!("Draw Grid -> {}", world_state.draw_grid);
+    info!("Draw Black -> {}", world_state.draw_black);
+    info!("Draw Grid -> {}", world_state.draw_grid);
 
     // LIMITER and BLACK
-	line = line.into_iter()
+    line = line
+        .into_iter()
         .map(|p| {
             let color = if world_state.draw_black {
                 Color { r: 0, g: 0, b: 0 }
@@ -187,14 +170,10 @@ fn get_next_frame(
                     b: p.color.b.min(world_state.intensity),
                 }
             };
-			Point {
+            Point { color, ..p }
-				color,
-				..p
-			}
         })
         .collect();
 
     //info!("Line: {:?}", line);
     Ok(line)
 }
-

src/point.rs

@@ -1,6 +1,4 @@
 use ether_dream::protocol::DacPoint;
-use std::ops::Mul;
-
 
 #[derive(Debug, Clone, Copy, Default, PartialEq)]
 pub struct Point {
@@ -15,18 +13,31 @@ pub struct Color {
     pub g: u8,
     pub b: u8,
 }
-impl Mul<u8> for Color {
-    type Output = Self;
 
-    fn mul(self, rhs: u8) -> Self {
+impl Point {
-	    Self{
+    pub fn diff(p1: &Self, p2: &Self) -> Self {
-		    r: (255 * self.r as u16 / rhs as u16) as u8,
+        Point {
-		    g: (255 * self.g as u16 / rhs as u16) as u8,
+            x: p1.x - p2.x,
-		    b: (255 * self.b as u16 / rhs as u16) as u8,
+            y: p1.y - p2.y,
+            color: Color { r: 0, g: 0, b: 0 },
         }
     }
+
+    pub fn normalize(&mut self) -> Self {
+        let length = (self.x * self.x + self.y * self.y).sqrt();
+        self.x = self.x / length;
+        self.y = self.y / length;
+        *self
+    }
+
+    pub fn cross(&self, pt: &Self) -> f32 {
+        self.x * pt.x + self.y * pt.y
+    }
 }
 
+// normalaize
+// diff
+
 impl From<Color> for u32 {
     fn from(value: Color) -> Self {
         let r = value.r as u32;
@@ -41,7 +52,11 @@ impl From<(f32, f32, u32)> for Point {
         let r = (color >> 16) as u8;
         let g = ((color >> 8) & 255) as u8;
         let b = (color & 255) as u8;
-		Point { x, y, color: Color { r, g, b } }
+        Point {
+            x,
+            y,
+            color: Color { r, g, b },
+        }
     }
 }
 
@@ -61,21 +76,17 @@ impl From<Point> for DacPoint {
     fn from(pt: Point) -> DacPoint {
         let control = 0;
         let (u1, u2) = (0, 0);
-		let i = 0;
+        let i = 255;
-		let x = pt.x.clamp(-32000.0, 32000.0);
+        DacPoint {
-		let y = pt.y.clamp(-32000.0, 32000.0);
-		let pt = DacPoint {
             control,
-			x: x as i16,
+            x: pt.x as i16,
-			y: y as i16,
+            y: pt.y as i16,
             i,
-			r: (pt.color.r as u16) * 255,
+            r: pt.color.r.into(),
-			g: (pt.color.g as u16) * 255,
+            g: pt.color.g.into(),
-			b: (pt.color.b as u16) * 255,
+            b: pt.color.b.into(),
             u1,
             u2,
-		};
+        }
-		// debug!("point {:?}", pt);
-		pt
     }
 }

src/redis_ctrl.rs

@@ -1,8 +1,8 @@
-use redis::{Client, Commands, Connection};
-use ron::de::from_str;
 use crate::device::Status;
 use crate::errors::{LJError, LJResult};
 use crate::worldstate::{WorldState, EDH};
+use redis::{Client, Commands, Connection};
+use ron::de::from_str;
 // use log::info;
 
 #[repr(u8)]
@@ -10,6 +10,7 @@ use crate::worldstate::{WorldState, EDH};
 pub enum Order {
     Draw = 0,
     Edh,
+    //homography
     Black,
     Grid,
     Resampler,
@@ -17,7 +18,6 @@ pub enum Order {
     Intensity,
     Kpps,
     ColorBalance,
-	PowerOff
 }
 
 impl TryFrom<u8> for Order {
@@ -40,14 +40,12 @@ impl TryFrom<u8> for Order {
             6 => Intensity,
             7 => Kpps,
             8 => ColorBalance,
-			9 => PowerOff,
+            _ => unreachable!(),
-			_ => unreachable!()
         })
     }
 }
 
 pub type Line = Vec<(f32, f32, u32)>;
-pub type Resampler = Vec<Vec<(f32,f32)>>;
 
 pub struct RedisCtrl {
     pub client: Client,
@@ -57,11 +55,13 @@ pub struct RedisCtrl {
 
 impl RedisCtrl {
     pub fn new(url: &str, laser_id: &u8) -> LJResult<Self> {
-		let client = Client::open(url)
+        let client = Client::open(url).map_err(LJError::RedisConnect)?;
-			.map_err(LJError::RedisConnect)?;
+        let connection = client.get_connection().map_err(LJError::RedisConnect)?;
-		let connection = client.get_connection()
+        Ok(RedisCtrl {
-			.map_err(LJError::RedisConnect)?;
+            client,
-		Ok(RedisCtrl { client, connection, laser_id: *laser_id })
+            connection,
+            laser_id: *laser_id,
+        })
     }
 
     pub fn get_line(&mut self, key: &str) -> LJResult<Line> {
@@ -86,6 +86,11 @@ impl RedisCtrl {
         Ok(val.try_into()?)
     }
 
+    /**
+    /lstt/lasernumber       etherdream last_status.playback_state  (0: idle   1: prepare   2: playing)
+    /cap/lasernumber        number of empty points sent to fill etherdream buffer (up to 1799)
+    /lack/lasernumber       "a": ACK   "F": Full  "I": invalid. 64 or 35 for no connection.
+     **/
     pub fn set_status(&mut self, status: Status) -> LJResult<()> {
         let lstt_key = format!("/lstt/{}", self.laser_id);
         let cap_key = format!("/cap/{}", self.laser_id);
@@ -98,10 +103,10 @@ impl RedisCtrl {
 
     pub fn init_world_state(&mut self) -> LJResult<WorldState> {
         Ok(WorldState {
-			client_key: self.get_client_key()?,
+            client_key: self.get_client_key().unwrap(),
-			edh: self.get_edh()?,
+            edh: self.get_edh().unwrap(),
-			kpps: self.get_int("kpps")?.try_into()?,
+            kpps: self.get_int("kpps").unwrap().try_into().unwrap(),
-			intensity: self.get_int("intensity")?.try_into()?,
+            intensity: self.get_int("intensity").unwrap().try_into().unwrap(),
             ..WorldState::default()
         })
     }
@@ -120,20 +125,6 @@ impl RedisCtrl {
         Ok(key)
     }
 
-	pub fn get_color_balance(&mut self) -> LJResult<(u8, u8, u8)> {
-		Ok((
-			self.connection.get("/red")?,
-			self.connection.get("/green")?,
-			self.connection.get("/blue")?,
-		))
-	}
-
-	pub fn get_resampler(&mut self ) -> LJResult<Resampler> {
-		let val: String = self.connection.get(format!("/resampler/{}", self.laser_id))?;
-		let resampler : Resampler = from_str(&val)?;
-		Ok(resampler)
-	}
-
     pub fn get_int(&mut self, key: &str) -> LJResult<u32> {
         // Get new Int
         let fmt = format!("/{key}/{}", self.laser_id);

src/transformer.rs

@@ -1,9 +1,9 @@
+//pub mod common;
+mod angle_optimisation;
 mod flip_horizontal;
 mod flip_vertical;
 mod grid;
-mod helios_to_etherdream;
 mod homography;
-mod intensity;
 mod replicate;
 mod rotate;
 mod translate;
@@ -12,20 +12,15 @@ use crate::point::Point;
 use crate::worldstate::WorldState;
 
 // re-export transformers to be abe to use it directly from transformer::
-pub use translate::Translate;
+pub use self::homography::Homography;
-pub use replicate::Replicate;
+pub use angle_optimisation::AngleOptimisation;
-pub use rotate::Rotate;
 pub use flip_horizontal::FlipHorizontal;
 pub use flip_vertical::FlipVertical;
 pub use grid::Grid;
-pub use self::homography::Homography;
+pub use replicate::Replicate;
-pub use helios_to_etherdream::HeliosToEtherdream;
+pub use rotate::Rotate;
-pub use intensity::Intensity;
+pub use translate::Translate;
 
 pub trait Transformers {
-    fn apply(
+    fn apply(&self, point_list: &[Point], world_state: &WorldState) -> Vec<Point>;
-	&self,
-	point_list: &[Point],
-	world_state: &WorldState
-    ) -> Vec<Point>;
 }

src/transformer/angle_optimisation.rs

@@ -0,0 +1,129 @@
+use crate::point::{Color, Point};
+use crate::transformer::Transformers;
+use crate::worldstate::WorldState;
+
+use serde::{Deserialize, Serialize};
+use std::f64::consts::PI;
+//use std::cmp::min;
+
+/// Angle Optimisation
+
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
+pub struct AngleOptimisation {
+    coef: f64,
+    //pps: u16,
+}
+
+fn color_not_zero(p1: &Point, p2: &Point, p3: &Point) -> bool {
+    let c0 = Color { r: 0, g: 0, b: 0 };
+    if p1.color == c0 || p2.color == c0 || p3.color == c0 {
+        false
+    } else {
+        true
+    }
+}
+
+fn pos_different(p1: &Point, p2: &Point) -> bool {
+    if p1.x == p2.x && p1.y == p2.y {
+        false
+    } else {
+        true
+    }
+}
+
+/*
+ * Le temps a attendre a un angle est toujours le meme, peu importe les kpps.
+ * Donc le nombre de point a rajouter est proportionelle a la vitesse du laser.
+ *
+ *  kpps /
+ * */
+
+fn color_same(p1: &Point, p2: &Point) -> bool {
+    if p1.color.r == p2.color.r && p1.color.g == p2.color.g && p1.color.b == p2.color.b {
+        true
+    } else {
+        false
+    }
+}
+
+// quand on rajoute un point, on le rejoute ou et avec quelle couleur
+//  -> j'ai l'impression qu'on le rajoute surtout a l'arriver
+
+fn get_prev(pl: &[Point], id: usize) -> (Option<&Point>, usize) {
+    for i in (0..id).rev() {
+        if pos_different(&pl[id], &pl[i]) {
+            return (Some(&pl[i]), id - i);
+        }
+    }
+    (None, id - 0)
+}
+
+fn get_next(pl: &[Point], id: usize) -> (Option<&Point>, usize) {
+    for i in id..(pl.len() - 1) {
+        if pos_different(&pl[id], &pl[i]) {
+            return (Some(&pl[i]), i - id);
+        }
+    }
+    (None, pl.len() - id - 1)
+}
+
+fn max(v1: f64, v2: f64) -> f64 {
+    if v1 > v2 {
+        v1
+    } else {
+        v2
+    }
+}
+
+impl Transformers for AngleOptimisation {
+    fn apply(&self, pl: &[Point], _ws: &WorldState) -> Vec<Point> {
+        let c0 = Color { r: 0, g: 0, b: 0 };
+        let mut v = vec![];
+
+        let to_add_max = _ws.kpps as f64 / self.coef; // for 180 deg
+        let to_add_min = max(to_add_max / 1.5, 2.); // for 180 deg
+
+        let mut first_blanc = pl[0].clone();
+        first_blanc.color = Color{r:0, g:0, b:0};
+        for _ in 0..(to_add_max as u32) {
+            v.push(first_blanc); // push first
+        }
+        v.push(pl[0]);
+        for i in 1..(pl.len() - 1) {
+            let node = &pl[i];
+            if let ((Some(prev), dist_prev), (Some(next), dist_next)) =
+                (get_prev(pl, i), get_next(pl, i))
+            {
+                let d1 = Point::diff(node, prev).normalize();
+                let d2 = Point::diff(next, node).normalize();
+                let angle = (d1.cross(&d2) as f64).acos();
+                let to_add = ((to_add_max - to_add_min) * (angle / PI) + to_add_min) as usize;
+                println!("\nangle: {}", (angle / PI * 180.));
+                dbg!(to_add);
+                dbg!(to_add_max);
+                for _ in 0..to_add {
+                    v.push(*node);
+                }
+            } else {
+                v.push(*node);
+            };
+            //v.push(*node); // push node
+        }
+        for _ in 0..(to_add_max as u32) {
+            v.push(pl[pl.len() - 2]); // push last
+        }
+        for _ in 0..(to_add_max as u32) {
+            v.push(pl[pl.len() - 1]); // push last
+        }
+        println!("\tbefore: {}\tafter: {}", pl.len(), v.len());
+
+        v
+    }
+}
+
+/*
+ *  |\
+ *  | \
+ *  |  \
+ *  |  |
+ * */

src/transformer/flip_horizontal.rs

@@ -1,24 +1,27 @@
-use crate::transformer::Transformers;
 use crate::point::Point;
+use crate::transformer::Transformers;
 use crate::worldstate::WorldState;
 
-use serde::{Serialize,Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// Flip Horizontal
 
-#[derive(Serialize,Deserialize,Debug,Clone,Copy)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub struct FlipHorizontal {
     x: f32,
 }
 
 impl Transformers for FlipHorizontal {
     fn apply(&self, point_list: &[Point], _ws: &WorldState) -> Vec<Point> {
-    point_list.iter()
+        point_list
-        .map(| pt | {
+            .iter()
+            .map(|pt| {
                 let dx = pt.x - self.x;
-            Point { x: dx - 2. * dx,
+                Point {
+                    x: dx - 2. * dx,
                     ..*pt
                 }
-        }).collect()
+            })
+            .collect()
     }
 }

src/transformer/flip_vertical.rs

@@ -1,24 +1,27 @@
-use crate::transformer::Transformers;
 use crate::point::Point;
+use crate::transformer::Transformers;
 use crate::worldstate::WorldState;
 
-use serde::{Serialize,Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// Flip Vertical
 
-#[derive(Serialize,Deserialize,Debug,Clone,Copy)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub struct FlipVertical {
     y: f32,
 }
 
 impl Transformers for FlipVertical {
     fn apply(&self, point_list: &[Point], _ws: &WorldState) -> Vec<Point> {
-    point_list.iter()
+        point_list
-        .map(| pt | {
+            .iter()
+            .map(|pt| {
                 let dy = pt.y - self.y;
-            Point { y: dy - 2. * dy,
+                Point {
+                    y: dy - 2. * dy,
                     ..*pt
                 }
-        }).collect()
+            })
+            .collect()
     }
 }

src/transformer/grid.rs

@@ -1,47 +1,38 @@
-use crate::transformer::Transformers;
 use crate::point::Point;
+use crate::transformer::Transformers;
 use crate::worldstate::WorldState;
 
-use serde::{Serialize,Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// Translate
 
-#[derive(Serialize,Deserialize,Debug,Clone,Copy)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub struct Grid {
     width: f32,
-    height: f32
+    height: f32,
 }
 
 fn square_box(size: f32, color: u32) -> Vec<(f32, f32, u32)> {
     vec![
         (-size, -size, 0),
         (-size, -size, color),
-
         (0.0, -size, color),
         (0.0, -size, color),
-	
         (size, -size, color),
         (size, -size, color),
-
         (size, 0.0, color),
         (size, 0.0, color),
-
         (size, size, color),
         (size, size, color),
-
         (0.0, size, color),
         (0.0, size, color),
-
         (-size, size, color),
         (-size, size, color),
-
         (-size, 0.0, color),
         (-size, 0.0, color),
-
         (-size, -size, color),
         (-size, -size, color),
-
+        (-size, -size, 0),
-	(-size, -size, 0)
     ]
 }
 
@@ -51,8 +42,7 @@ impl Transformers for Grid {
         let mut line = square_box(2000.0, 255);
         line.append(&mut sq1);
 
-	let line: Vec<Point> = line.into_iter()
+        let line: Vec<Point> = line.into_iter().map(|tpl| tpl.into()).collect();
-	    .map(|tpl| tpl.into()).collect();
         line
     }
 }

src/transformer/helios_to_etherdream.rs

@@ -1,27 +0,0 @@
-use crate::transformer::Transformers;
-use crate::point::Point;
-use crate::worldstate::WorldState;
-
-use serde::{Serialize, Deserialize};
-
-/// Converts helios Geometry to Helios
-#[allow(dead_code)]
-#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
-pub struct HeliosToEtherdream {
-}
-
-impl Transformers for HeliosToEtherdream {
-	fn apply(&self, point_list: &[Point], _ws: &WorldState) -> Vec<Point> {
-		// debug!("list helios {:?}", point_list);
-		let out = point_list.iter().map(|pt| {
-			Point {
-				x: 8.0 * (pt.x - 2047.0),
-				y: 8.0 * (pt.y - 2047.0),
-				..*pt
-			}
-		}).collect();
-		// debug!("list etherdream {:?}", out);
-		out
-	}
-}
-

src/transformer/homography.rs

@@ -1,20 +1,18 @@
-use crate::transformer::Transformers;
 use crate::point::Point;
-use crate::worldstate::{WorldState,EDH};
+use crate::transformer::Transformers;
-use serde::{Serialize,Deserialize};
+use crate::worldstate::{WorldState, EDH};
+use serde::{Deserialize, Serialize};
 
 /// Homography
 
-#[derive(Serialize,Deserialize,Debug,Clone,Copy)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub struct Homography {}
 
 impl Transformers for Homography {
     fn apply(&self, point_list: &[Point], ws: &WorldState) -> Vec<Point> {
-	let edh : &EDH = &ws.edh;
+        let edh: &EDH = &ws.edh;
 
-	point_list.iter()
+        point_list.iter().map(|point| edh.apply(point)).collect()
-	    .map(| point | edh.apply(point))
-	    .collect()
     }
 }
 
@@ -24,41 +22,67 @@ mod tests {
 
     #[test]
     fn identity_matrix_let_point_unchanged() {
-	let p0 = Point { x: -1500.0, y: 1500.0, ..Point::default() };
+        let p0 = Point {
+            x: -1500.0,
+            y: 1500.0,
+            ..Point::default()
+        };
 
         let edh = EDH::new(vec![
-	    vec![ 1.0, 0.0, 0.0 ],
+            vec![1.0, 0.0, 0.0],
-	    vec![ 0.0, 1.0, 0.0 ],
+            vec![0.0, 1.0, 0.0],
-	    vec![ 0.0, 0.0, 1.0 ]
+            vec![0.0, 0.0, 1.0],
-	]).unwrap();
+        ])
+        .unwrap();
 
-	let ws = WorldState { edh : edh, ..WorldState::default() };
+        let ws = WorldState {
+            edh: edh,
+            ..WorldState::default()
+        };
 
-	let homography = Homography{};
+        let homography = Homography {};
         let result = homography.apply(&[p0], &ws);
 
-	assert_eq!(result, vec![Point { x: -1500.0,
+        assert_eq!(
+            result,
+            vec![Point {
+                x: -1500.0,
                 y: 1500.0,
-					..Point::default() }]);
+                ..Point::default()
+            }]
+        );
     }
 
     #[test]
     fn rotation_matrix_rotate_the_point() {
-	let p0 = Point { x: -1500.0, y: 1500.0, ..Point::default() };
+        let p0 = Point {
+            x: -1500.0,
+            y: 1500.0,
+            ..Point::default()
+        };
 
         let edh = EDH::new(vec![
-	    vec![ 1.24107321e-03, 1.00500127e-03, 7.15439347e-01],
+            vec![1.24107321e-03, 1.00500127e-03, 7.15439347e-01],
-	    vec![-9.93223912e-04, 1.22652939e-03,-6.98671238e-01],
+            vec![-9.93223912e-04, 1.22652939e-03, -6.98671238e-01],
-	    vec![ 1.06017142e-17,-4.69459541e-17, 3.32700590e-05]
+            vec![1.06017142e-17, -4.69459541e-17, 3.32700590e-05],
-	]).unwrap();
+        ])
+        .unwrap();
 
-	let ws = WorldState { edh : edh, ..WorldState::default() };
+        let ws = WorldState {
+            edh: edh,
+            ..WorldState::default()
+        };
 
-	let homography = Homography{};
+        let homography = Homography {};
         let result = homography.apply(&[p0], &ws);
 
-	assert_eq!(result, vec![Point { x: 10860.557,
+        assert_eq!(
+            result,
+            vec![Point {
+                x: 10860.557,
                 y: 79078.87,
-					..Point::default() }]);
+                ..Point::default()
+            }]
+        );
     }
 }

src/transformer/intensity.rs

@@ -1,28 +0,0 @@
-use log::debug;
-use crate::transformer::Transformers;
-use crate::point::Point;
-use crate::worldstate::WorldState;
-
-use serde::{Serialize, Deserialize};
-
-/// Converts helios Geometry to Helios
-#[allow(dead_code)]
-#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
-pub struct Intensity {
-}
-
-impl Transformers for Intensity {
-	fn apply(&self, point_list: &[Point], ws: &WorldState) -> Vec<Point> {
-		// debug!("list helios {:?}", point_list);
-		let out = point_list.iter().map(|pt| {
-			Point {
-				x: pt.x,
-				y: pt.y,
-				color: pt.color * ws.intensity
-			}
-		}).collect();
-		debug!("list intensity {:?}", out);
-		out
-	}
-}
-

src/transformer/replicate.rs

@@ -1,27 +1,43 @@
+use crate::point::{Color, Point};
 use crate::transformer::Transformers;
-use crate::point::Point;
 use crate::worldstate::WorldState;
 
-use serde::{Serialize,Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// Replicate
 
 #[allow(dead_code)]
-#[derive(Serialize,Deserialize,Debug,Clone,Copy)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub enum Replicate {
     Until(usize),
-    Times(usize)
+    Times(usize),
 }
 
 impl Transformers for Replicate {
     fn apply(&self, point_list: &[Point], _ws: &WorldState) -> Vec<Point> {
         let mut point_list2 = vec![];
+
         match self {
             Replicate::Until(n) => {
                 while point_list2.len() < *n {
+                    if point_list.len() == 0 {
+                        // to prevent infinit loop in case of empty frame
+                        point_list2.append(
+                            &mut vec![
+                                Point {
+                                    x: 0.,
+                                    y: 0.,
+                                    color: Color { r: 0, g: 0, b: 0 }
+                                };
+                                *n
+                            ]
+                            .to_vec(),
+                        );
+                    } else {
                         point_list2.append(&mut point_list.to_vec());
                     }
-	    },
+                }
+            }
             Replicate::Times(n) => {
                 for _ in 0..*n {
                     point_list2.append(&mut point_list.to_vec());
@@ -31,4 +47,3 @@ impl Transformers for Replicate {
         point_list2
     }
 }
-

src/transformer/rotate.rs

@@ -1,35 +1,32 @@
-use crate::transformer::Transformers;
 use crate::point::Point;
+use crate::transformer::Transformers;
 use crate::worldstate::WorldState;
 
-use serde::{Serialize,Deserialize};
+use serde::{Deserialize, Serialize};
 //use std::f32::consts::PI;
 
 /// Rotate
 
-#[derive(Serialize,Deserialize,Debug,Clone,Copy)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub struct Rotate {
     cx: f32,
     cy: f32,
     angle: f32,
-
 }
 
 impl Transformers for Rotate {
     fn apply(&self, point_list: &[Point], _ws: &WorldState) -> Vec<Point> {
-    point_list.iter()
+        point_list
-        .map(| pt | {
+            .iter()
+            .map(|pt| {
                 let dx = pt.x - self.cx;
                 let dy = pt.y - self.cy;
                 let cos = self.angle.cos();
                 let sin = self.angle.sin();
                 let x = (dx * cos - dy * sin) + self.cx;
                 let y = (dx * sin + dy * cos) + self.cy;
-            Point { x,
+                Point { x, y, ..*pt }
-                y,
+            })
-                ..*pt
+            .collect()
-            }
-        }).collect()
     }
 }
-

src/transformer/translate.rs

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

src/worldstate.rs

@@ -1,8 +1,7 @@
-use crate::point::{Point, Color};
-use nalgebra::base::{Matrix3, Matrix1x3};
 use crate::errors::{LJError, LJResult};
+use crate::point::{Color, Point};
 use log::debug;
-use crate::redis_ctrl::Resampler;
+use nalgebra::base::{Matrix1x3, Matrix3};
 
 #[derive(Debug, Default)]
 pub struct EDH {
@@ -11,17 +10,15 @@ pub struct EDH {
 
 impl EDH {
     pub fn new(vec: Vec<Vec<f32>>) -> LJResult<EDH> {
-		if vec.len() != 3 ||
+        if vec.len() != 3 || vec[0].len() != 3 || vec[1].len() != 3 || vec[2].len() != 3 {
-			vec[0].len() != 3 ||
-			vec[1].len() != 3 ||
-			vec[2].len() != 3 {
             return Err(Box::new(LJError::BadEDH));
         }
 
         // this is the matrix already transposed.
-		let matrix = Matrix3::new(vec[0][0], vec[1][0], vec[2][0],
+        let matrix = Matrix3::new(
-		                          vec[0][1], vec[1][1], vec[2][1],
+            vec[0][0], vec[1][0], vec[2][0], vec[0][1], vec[1][1], vec[2][1], vec[0][2], vec[1][2],
-		                          vec[0][2], vec[1][2], vec[2][2]);
+            vec[2][2],
+        );
 
         Ok(EDH { matrix })
     }
@@ -29,7 +26,11 @@ impl EDH {
     pub fn apply(&self, point: &Point) -> Point {
         let p = Matrix1x3::new(point.x, point.y, 1.0);
         let p = p * self.matrix;
-		let new_p = Point { x: p[0] / p[2], y: p[1] / p[2], ..*point };
+        let new_p = Point {
+            x: p[0] / p[2],
+            y: p[1] / p[2],
+            ..*point
+        };
 
         debug!("{:?} => {:?}", point, new_p);
 
@@ -40,7 +41,7 @@ impl EDH {
 #[derive(Debug, Default)]
 pub struct WorldState {
     pub edh: EDH,
-	pub resampler: Resampler,
+    pub resampler: Vec<f32>,
     pub client_key: String,
     pub intensity: u8,
     pub kpps: u32,
@@ -48,7 +49,6 @@ pub struct WorldState {
     pub draw_black: bool,
     pub draw_grid: bool,
     pub grid: Vec<Point>,
-	pub color_balance: Color,
 }
 
 impl WorldState {}

tests/test_conf.rs

@@ -1,4 +1,4 @@
-use lj_rust::conf::{Conf, DacFamily, HeliosConf, EtherDreamConf};
+use lj_rust::conf::{Conf, DacFamily, EtherDreamConf, HeliosConf};
 
 #[test]
 fn it_loads_a_valid_conf() {