HW1 final

Author: kmgx

Arithmetic-Coding/Cargo.lock

@@ -7,3 +7,5 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+structopt = "0.3.3"
+rug = "1.6.0"

Arithmetic-Coding/Cargo.toml

@@ -0,0 +1 @@
+BILL GATES

Arithmetic-Coding/gates.txt

@@ -0,0 +1 @@
+BILL GATES

Arithmetic-Coding/lorem-ipsum.txt

@@ -1,3 +1,133 @@
+use structopt::StructOpt;
+use std::fs;
+use std::collections::HashMap;
+use rug::{Float, ops::AssignRound, float::Round};
+use std::mem;
+
+#[derive(StructOpt, Debug)]
+#[structopt(name = "basic")]
+struct Opt {
+    #[structopt(name = "FILE")]
+    file: String
+}
+
+
+fn find_frequencies(data : &String) -> HashMap<char, u32> {
+    let mut frequencies : HashMap<char, u32> = HashMap::new();
+
+    for c in data.chars() {
+        // Read previous character count
+        let mut cur_count : u32 = 0;
+        if let Some(&count) = frequencies.get(&c) { cur_count = count; }
+
+        // Increase it
+        let entry = frequencies.entry(c).or_insert(cur_count);
+        *entry = *entry + 1;
+    }
+
+    return frequencies;
+}
+
+fn compression_ratio(before: &String, after: &Float) -> f64 {
+    let before_size = mem::size_of_val(&before[..]);
+    let after_size = after.prec() + 32;
+    println!("before : {:?}, after : {:?}", before_size, after_size);
+    return after_size as f64 / before_size as f64;    
+
+}
+
+fn find_bounds(freqs: &HashMap<char, u32>, filesize: u32, step_precision: u32) -> HashMap<char, (Float, Float)> {
+    let mut bounds : HashMap<char, (Float, Float)> = HashMap::new();
+
+    let mut prevhigh = Float::with_val(step_precision, 0.0);
+    for (&c, &count) in freqs {
+        let low = prevhigh;
+        let high = Float::with_val(step_precision, low.clone() + (count as f64 / filesize as f64));
+        prevhigh = Float::with_val(step_precision, high.clone());
+
+        bounds.insert(c, (low, high));
+    }
+
+    return bounds;
+}
+
+fn arithmetic_encode(file: &String, bounds: &HashMap<char, (Float, Float)>, step_precision: u32) -> Float {
+
+    // Start with 1-bit precision
+    let mut high : Float = Float::with_val(32, 1);
+    let mut low : Float  = Float::with_val(32, 0);
+
+    for c in file.chars() {
+
+        // Increase the precision of the floats
+        high.set_prec(high.prec() + step_precision);
+        low.set_prec(low.prec() + step_precision);
+
+        //println!("{:?} : {:?}, {:?}, {:?}, {:?}, ", c, low.prec(), high.prec(), high, low);
+        
+        let range = high.clone() - low.clone();
+
+        //println!("{:?} : {:?}, {:?}, {:?}, {:?}, {:?}, ", c, low.prec(), high.prec(), range, high, low);
+
+        high.assign_round(low.clone() + (range.clone() * bounds.get(&c).unwrap().1.clone()), Round::Down);
+        low.assign_round(low.clone() + (range.clone() * bounds.get(&c).unwrap().0.clone()), Round::Up);
+        //println!("{:?} : {:?}, {:?}, {:?}, {:?}, {:?}, ", c, low.prec(), high.prec(), range, high, low); 
+    }
+
+    return (high + low)/2;
+}
+
+fn arithmetic_decode(encoded : &Float, bounds: &HashMap<char, (Float, Float)>, filesize : u32, step_precision: u32) -> String {
+    let mut result : String = String::new();
+    let mut data = encoded.clone();
+
+    // Initial precision is 32, so get back to that
+    while data.prec() > 32 {
+        for(c, bounds) in bounds {
+            if bounds.1 > data && bounds.0 < data {
+                println!("{:?} : {:?} at prec {:?}, bounds are {:?} - {:?}", c, data, data.prec(), bounds.0.clone(), bounds.1.clone());
+                result.push(*c);
+                data.assign_round((data.clone() - bounds.0.clone()) / (bounds.1.clone() - bounds.0.clone()), Round::Up);
+                data.set_prec(data.prec() - step_precision);
+                break;
+            }
+        }
+    }
+
+    return result;
+}
+
 fn main() {
-    println!("Hello, world!");
+    // Parse arguments
+    let opt = Opt::from_args();
+
+    println!("Reading file");
+    let contents = fs::read_to_string(opt.file).unwrap();
+    let filesize = contents.len() as u32;
+
+    // https://stackoverflow.com/questions/7150035/ and add a small pad :)
+    let step_precision = (filesize as f64).log2().ceil() as u32;
+    println!("Step precision : {:?}", step_precision);
+
+    // Find frequency
+    let frequencies = find_frequencies(&contents);
+    let bounds = find_bounds(&frequencies, filesize, step_precision);
+    println!("{:?}\n{:?}", frequencies.clone(), bounds.clone());
+
+    // Encode file
+    let encoded = arithmetic_encode(&contents, &bounds, step_precision);
+    println!("encoder result : {:?}", encoded);
+
+    // Compute compression ratio
+    let ratio = compression_ratio(&contents, &encoded);
+    println!("Compression ratio : {:?}", ratio);
+
+    // Decode file
+    let decoded = arithmetic_decode(&encoded, &bounds, filesize, step_precision);
+    println!("decoder result : {:?}", decoded);
+
+    println!("Saving result");
+    fs::write("output.txt", &decoded[..]).unwrap();
+
+    
 }

Arithmetic-Coding/output.txt

@@ -0,0 +1,46 @@
+   Compiling Ordered-Dithering v0.1.0 (/media/chris/Data/Github/MultimediaSignalProcessingClass/Ordered-Dithering)
+error[E0425]: cannot find value `index` in this scope
+  --> src/main.rs:46:26
+   |
+46 |             let img_x  = index % img_width;
+   |                          ^^^^^ not found in this scope
+
+error[E0425]: cannot find value `index` in this scope
+  --> src/main.rs:47:27
+   |
+47 |             let img_y = ((index as f64 - img_x as f64) / img_height as f64).floor();
+   |                           ^^^^^ not found in this scope
+
+error[E0425]: cannot find value `index` in this scope
+  --> src/main.rs:53:61
+   |
+53 |             println!("{:?}, {:?}, {:?}, {:?}, {:?}, {:?},", index, img_y, img_x, dither_y, dither_x, dither_index);
+   |                                                             ^^^^^ not found in this scope
+
+error[E0599]: no method named `floor` found for type `u32` in the current scope
+  --> src/main.rs:62:57
+   |
+62 |     let buffer = image::ImageBuffer::from_vec(img_width.floor() as u32, img_height.floor() as u32, result).unwrap();
+   |                                                         ^^^^^
+
+error[E0599]: no method named `floor` found for type `u32` in the current scope
+  --> src/main.rs:62:84
+   |
+62 |     let buffer = image::ImageBuffer::from_vec(img_width.floor() as u32, img_height.floor() as u32, result).unwrap();
+   |                                                                                    ^^^^^
+
+warning: unused import: `rayon::prelude`
+ --> src/main.rs:3:5
+  |
+3 | use rayon::prelude::*;
+  |     ^^^^^^^^^^^^^^
+  |
+  = note: #[warn(unused_imports)] on by default
+
+error: aborting due to 5 previous errors
+
+Some errors have detailed explanations: E0425, E0599.
+For more information about an error, try `rustc --explain E0425`.
+error: Could not compile `Ordered-Dithering`.
+
+To learn more, run the command again with --verbose.

Arithmetic-Coding/src/main.rs

@@ -36,31 +36,30 @@ fn apply_dithering(image: image::DynamicImage, dither_array : [f32; 64]) -> imag
 
     let mut pixels = image.raw_pixels();
     let size = image.dimensions();
-    let img_width = size.0;
-    let img_height = size.1;
+    let img_width = size.0 as usize;
+    let img_height = size.1 as usize;
     let dither_width = 8;
     let dither_height = 8;
 
-    let result = pixels.par_iter_mut().enumerate().map(|(index, pixel)| {
-            let img_x = (index as u32) % img_width;
-            let img_y = ((index as u32) - img_x) / img_height;
+    // println!("{:?}", pixels);
+    let result = pixels.into_par_iter().enumerate().map(|(index, pixel)| {
+            let img_x : usize  = index % img_width;
+            let img_y : usize = ((index as f64 - img_x as f64) / img_width as f64).floor() as usize;
 
             let dither_x = img_x % dither_width;
             let dither_y = img_y % dither_height;
-            let dither_index = dither_x + (dither_y * dither_width);
-            let dither_val = dither_array[dither_index as usize];
 
-            let downscaled_pix : f32 = (*pixel as f32)  / 255.0;
-            let result_pixel = match downscaled_pix {
-                downscaled_pix if downscaled_pix < dither_val => 0,
-                downscaled_pix if downscaled_pix > dither_val => 255,
-                _ => 255                // ARBITRARY CHOICE !
-            };
+            let dither_index = dither_x + (dither_y * dither_width);
+            //println!("{:?}, {:?}, {:?}, {:?}, {:?}, {:?},", index, img_y, img_x, dither_y, dither_x, dither_index);
+            let dither_val = dither_array[dither_index];
+            
 
-            return result_pixel;
+            if (pixel as f32)  / 255.0 < dither_val { 
+                return 0; 
+            } else { return 255; }
         }).collect();
 
-    let buffer = image::ImageBuffer::from_vec(img_width, img_height, result).unwrap();
+    let buffer = image::ImageBuffer::from_vec(img_width as u32, img_height as u32, result).unwrap();
     return image::DynamicImage::ImageLuma8(buffer);
 }