Moved let outside of loop in color conversion

diff --git a/src/main.rs b/src/main.rs
index e0b5d2f91e0a34e8809615af601b8500566a96b1..b2f0cb8bfaecf98c6b4d3020d2d04c53733f2cb7 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -92,25 +92,41 @@ impl ImageArray {
        }
 
        fn from_buffer (&mut self, buffer: &Vec<Complex<f32>>) -> () {
+               let mut r: f32;
+               let mut theta: f32;
+               let mut amplitude: f32;
+
+               let mut hue: f32;
+               let mut angle: f32;
+
+               let mut d:f32;
+               let mut s:f32;
+               let mut v:f32;
+               let mut c:f32;
+               let mut m:f32;
+               let mut x:f32;
+               let mut g:f32;
+               let mut b:f32;
+
                for i in 0..self.chunks {
-                       let (r, theta): (f32, f32) = buffer[i].to_polar();
+                       (r, theta) = buffer[i].to_polar();
 
-                       let amplitude = 20f32 * r.log10();
-                       let amplitude = ((amplitude - VOLUME_MIN) / (VOLUME_REL / AMPLITUDE_REL)) + AMPLITUDE_MIN;
+                       amplitude = 20f32 * r.log10();
+                       amplitude = ((amplitude - VOLUME_MIN) / (VOLUME_REL / AMPLITUDE_REL)) + AMPLITUDE_MIN;
 
-                       let hue = (180f32 / 255f32) * amplitude;
+                       hue = (180f32 / 255f32) * amplitude;
 
-                       let angle = (theta.to_degrees() + 180f32) * (ANGLE_REL / 360f32) + ANGLE_MIN;
+                       angle = (theta.to_degrees() + 180f32) * (ANGLE_REL / 360f32) + ANGLE_MIN;
 
-                       let d = hue * (1f32 / 30f32);
-                       let s = angle / 255f32;
-                       let v = amplitude / 255f32;
+                       d = hue * (1f32 / 30f32);
+                       s = angle / 255f32;
+                       v = amplitude / 255f32;
 
-                       let c = s * v;
-                       let m = v - c;
-                       let x = c * (1f32 - (d.rem_euclid(2f32) - 1f32).abs());
+                       c = s * v;
+                       m = v - c;
+                       x = c * (1f32 - (d.rem_euclid(2f32) - 1f32).abs());
 
-                       let (r, g, b) = match d.floor() {
+                       (r, g, b) = match d.floor() {
                                0.0 => (c, x, 0f32),
                                1.0 => (x, c, 0f32),
                                2.0 => (0f32, c, x),
@@ -126,21 +142,32 @@ impl ImageArray {
        }
 
        fn to_buffer (&mut self, buffer: &mut Vec<Complex<f32>>) -> () {
+               let mut r: f32;
+               let mut amplitude: f32;
+
+               let mut angle: f32;
+
+               let mut s:f32;
+               let mut v:f32;
+               let mut c:f32;
+               let mut g:f32;
+               let mut b:f32;
+
                for i in 0..self.chunks {
-                       let r = self.data[i*3] as f32;
-                       let g = self.data[i*3+1] as f32;
-                       let b = self.data[i*3+2] as f32;
+                       r = self.data[i*3] as f32;
+                       g = self.data[i*3+1] as f32;
+                       b = self.data[i*3+2] as f32;
 
-                       let v = r.max(g).max(b);
-                       let c = (v - r.min(g).min(b)) * 255f32;
-                       let s = if v == 0f32 { 0f32 } else { c / v };
+                       v = r.max(g).max(b);
+                       c = (v - r.min(g).min(b)) * 255f32;
+                       s = if v == 0f32 { 0f32 } else { c / v };
 
-                       let amplitude = (v - AMPLITUDE_MIN) * (VOLUME_REL / AMPLITUDE_REL) + VOLUME_MIN;
+                       amplitude = (v - AMPLITUDE_MIN) * (VOLUME_REL / AMPLITUDE_REL) + VOLUME_MIN;
 
-                       let amplitude = 10f32.powf(amplitude / 20f32);
+                       amplitude = 10f32.powf(amplitude / 20f32);
 
-                       let angle = (s - ANGLE_MIN) / (ANGLE_REL / 360f32) - 180f32;
-                       let angle = angle.to_radians();
+                       angle = (s - ANGLE_MIN) / (ANGLE_REL / 360f32) - 180f32;
+                       angle = angle.to_radians();
 
                        buffer[i] = Complex::from_polar(amplitude, angle);
                }