inverse dct

src/descriptors.rs

@@ -1,5 +1,5 @@
-use image::GenericImageView;
+use image::{save_buffer, GenericImageView};
-use std::f64::consts::PI;
+use std::f64::consts::{PI, SQRT_2};
 
 pub trait Descriptor {
     fn info(&self) -> String {
@@ -50,10 +50,19 @@ pub struct DCT;
 impl Descriptor for DCT {
     fn describe(&self, img: image::DynamicImage) -> u64 {
         let mut dct_values: [f64; 64] = [0.0; 64];
+        let mut reconstructed: [u8; 64] = [0; 64];
         let img = self.resize(img);
-        for v in 0..7 {
+        let _ = img.save("resize.png").expect("Error saving file");
-            for u in 0..7 {
+        for u in 0..8 {
-                let k = (u*8)+v;
+            for v in 0..8 {
+                let k = (v*8)+u;
+                let mut alpha = 0.25;
+                if u == 0 {
+                    alpha = alpha / SQRT_2
+                }
+                if v == 0 {
+                    alpha = alpha / SQRT_2
+                }
                 let v: f64 = v as f64;
                 let u: f64 = u as f64;
                 let mut sum: f64 = 0.0;
@@ -66,9 +75,45 @@ impl Descriptor for DCT {
                         (x*u*PI/16.0).cos() *
                         (y*v*PI/16.0).cos()
                 }
-                dct_values[k] = sum;
+                dct_values[k] = alpha * sum;
+                //println!("For {u},{v} the output is {}", dct_values[k]);
+                //println!{"{}", dct_values[k]}
             }
         }
+        for k in 0..64  {
+            let x = (k%8) as f64;
+            let y = (k/8) as f64;
+            let mut sum = 0.0;
+            for u in 0..8 {
+                for v in 0..8 {
+                    let mut alpha = 1.0;
+                    if u == 0 {
+                        alpha = alpha / SQRT_2
+                    }
+                    if v == 0 {
+                        alpha = alpha / SQRT_2
+                    }
+                    let uv = (v*8)+u;
+                    let v = v as f64;
+                    let u = u as f64;
+                    sum +=
+                        alpha *
+                        dct_values[uv] *
+                        ((2.0 * x + 1.0) * u * PI / 16.0).cos() *
+                        ((2.0 * y + 1.0) * v * PI / 16.0).cos()
+                }
+            }
+            println!("Reconstructed pixel: {}", 127 + (0.25 * sum).round() as u16);
+            reconstructed[k] = std::cmp::min(255_u16, 127 + (0.25 * sum).round() as u16) as u8;
+            //println!("{x},{y}: {}", dct_values[k])
+        }
+        save_buffer(
+            "reconstructed.png",
+            &reconstructed,
+            8, 
+            8,
+            image::ColorType::L8
+        ).expect("Error saving buffer");
         let mut mask: u64 = 0;
         for dct in dct_values {
             if dct > 0.0 {