Add working BTC

Author: kmgx

.gitignore

@@ -8,11 +8,4 @@
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
-
-
-#Added by cargo
-#
-#already existing elements are commented out
-
-/target
-#**/*.rs.bk
+target/

Block-Truncation-Coding/.vscode/launch.json

@@ -10,4 +10,7 @@ edition = "2018"
 image = "0.22.3"
 structopt = "0.3.2"
 num-traits = "0.2.8"
-bitvec = "0.15.2"
+bitvec = "0.15.2"
+
+[dependencies.img-quality]
+path = "../img-quality"

Block-Truncation-Coding/Cargo.lock

@@ -2,11 +2,9 @@ use structopt::StructOpt;
 use image::GenericImageView;
 use num_traits::pow::Pow;
 use bitvec::prelude::*;
-use std::convert::From;
 use std::string::String;
-
-mod hpsnr;
-
+use img_quality;
+use std::fmt;
 
 #[derive(StructOpt, Debug)]
 #[structopt(name = "basic")]
@@ -15,67 +13,122 @@ struct Opt {
     file: String
 }
 
+#[derive(Clone)]
+struct VecBlock {
+    width : usize, height : usize,
+    pixels : Vec<u8>
+}
 
+#[derive(Debug, Clone)]
 struct BtcBlock {
-    highCcolor: u8,
-    lowColor: u8,
-    pixels: BitVec
+    highColor: u8, lowColor: u8,
+    width : usize, height : usize,
+    pixels: Vec<u8>
 }
 
+impl fmt::Display for BtcBlock { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    return write!(f, "VecBlock ({}, {}) with a = {}, b = {} has pixels {:?}", self.width, self.height, self.highColor, self.lowColor, self.pixels);
+}}
+
 struct BtcImage {
-    imgSize: (u32, u32),
-    blockSize: (u32, u32),
+    blockCountX: usize, blockCountY : usize,
+    width : usize, height : usize,
     blocks: Vec<BtcBlock>
 }
 
+fn no_overflow_cast(x : f64) -> u8 {
+    if x < 0.0 { 0 } else if x > 255.0 { 255 } else { x as u8 }
+}
+
+fn get_block_nb(i : usize, img_width : usize, img_height : usize, block_width : usize, block_height : usize, block_count_x : usize) -> (usize, usize, usize){
+    let pos_x = (i % img_width) as usize;
+    let pos_y = ((i - pos_x) / img_width) as usize;
+
+    let block_x = pos_x / block_width;
+    let block_y = pos_y / block_height;
+    let block_count = block_x + (block_y * block_count_x);
+    //println!("{:?}, {:?}, {:?}, {:?}, {:?}, {:?}, ", block_x, block_y, block_count_x, block_count_y, pos_x, pos_y);
+
+     let block_pos_x = pos_x % block_width;
+    let block_pos_y = pos_y % block_height;
+
+    return (block_count, block_pos_x, block_pos_y);
+}
 
 fn btc_encode(image: image::DynamicImage, blockWidth: usize, blockHeight: usize) -> BtcImage {
-    let mut pixels : Vec<u8> = image.raw_pixels();
+    let pixels : Vec<u8> = image.raw_pixels();
     let size = image.dimensions();
     let img_width = size.0 as usize;
     let img_height = size.1 as usize;
 
-    
-
-
     // Build the blocks
     let block_count_x = (img_width as f64 / blockWidth as f64).ceil() as usize;
     let block_count_y = (img_height as f64 / blockHeight as f64).ceil() as usize;
-    let block_count_total = block_count_x*block_count_y;
-    let mut blocks: Vec<Vec<u8>> = vec![vec![]; block_count_total];
+    let block_count_total = block_count_x * block_count_y;
+    let mut blocks: Vec<VecBlock> = vec![VecBlock{height : 0, width : 0, pixels : vec![]}; block_count_total];
+
     for i in 0..pixels.len() {
-        let pos_x = (i % img_width) as usize;
-        let pos_y = ((i - pos_x) / img_width) as usize;
+        
+        let (block_pos, block_pos_x, block_pos_y) = get_block_nb(i, img_width, img_height, blockWidth, blockHeight, block_count_x);
+        let block = &mut blocks[block_pos];
 
-        let block_x = pos_x / blockWidth;
-        let block_y = pos_y / blockHeight;
-        let block_count = block_x + (block_y * block_count_y);
+        if block_pos_x + 1 > block.width { block.width = block_pos_x + 1; }
+        if block_pos_y + 1 > block.height { block.height = block_pos_y + 1; }
+        block.pixels.push(pixels[i]);
+    }
 
-        //println!("{:?}, {:?}, {:?}, {:?}, {:?}, {:?}, ", block_x, block_y, block_count_x, block_count_y, pos_x, pos_y);
+    // println!("{:?}, {:?}", blocks[0].len(), blocks[0]);
+    // println!("{:?}", pixels.len());
 
-        blocks[block_count].push(pixels[i]);
+    let mut result : BtcImage = BtcImage{ blockCountX: block_count_x, blockCountY : block_count_y, blocks: vec![], width: img_width, height: img_height};
+    for i in 0..blocks.len() {
+        let block = &blocks[i];
+
+        let h : f64 = block.pixels.iter().map(|&x| x as f64).sum::<f64>() as f64 / block.pixels.len() as f64;
+        let h2 : f64  = block.pixels.iter().map(|&val| (val as f64).pow(2)).sum::<f64>() / block.pixels.len() as f64;
+        let theta : f64 = (h2 - h.pow(2) as f64).sqrt();
+        let q = block.pixels.iter().filter(|&&x| x as f64 >= h).count() as f64;
+        let m = block.pixels.len() as f64;
+
+        let a = if m-q == 0.0 { h } else { h - (theta * (q/(m-q)).sqrt()) };
+        let b = if q == 0.0 { h } else { h + (theta * ((m-q)/q).sqrt()) };
+        // println!("{:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, ", i, h, h2, theta, q, m, a, b);
+
+        //let pix : BitVec = block.pixels.iter().map(|&x| if x < h as u8 { 0 } else { 1 }).collect::<Vec<u8>>().into();
+        let pix : Vec<u8> = block.pixels.iter().map(|&x| if x < h as u8 { 0 } else { 1 }).collect::<Vec<u8>>().into();
+        let newblock = BtcBlock{pixels: pix, lowColor: no_overflow_cast(a), highColor: no_overflow_cast(b), width: block.width, height : block.height};
+        //println!("newblock : {}", newblock);
+        result.blocks.push(newblock);
+        
     }
 
-    //println!("{:?}", blocks[0].len());
+    return result;
+}
 
+fn btc_decode(image: BtcImage) -> image::DynamicImage {
+    let mut pixels : Vec<u8> = vec![];   
 
-    for i in 0..blocks.len() {
-        
-        let block = blocks[i];
+    let basewidth = image.blocks[0].width;
+    let baseheight = image.blocks[0].height;
+    let fullsize = image.width * image.height;
+    // println!("{:?}, {:?}", basewidth, baseheight);
 
-        let avg = block.iter().sum() as f64 / block.len() as f64;
-        let sd  = (block.iter().map(|val| (*val as f64 - avg).pow(2)).sum() as f64 / block.len() as f64).sqrt();
-        
+    for i in 0..fullsize {    
+
+            let (block_pos, block_pos_x, block_pos_y) = get_block_nb(i, image.width, image.height, basewidth, baseheight, image.blockCountX);
+            let block = &image.blocks[block_pos];
+            let pixel_pos = (block_pos_y * block.width) + block_pos_x;
+
+            let pixel = block.pixels[pixel_pos];
+            pixels.push(if pixel == 1 { block.highColor } else { block.lowColor });
 
 
     }
 
-    return BtcImage{ imgSize: (0,0), blockSize: (0,0), blocks: vec![]};
-}
+    // println!("{:?}", pixels.len());
 
-//fn btc_decode(image: BtcImage) -> image::DynamicImage {
-    
-//}
+    return image::DynamicImage::ImageLuma8(image::ImageBuffer::from_vec(image.width as u32, image.height as u32, pixels).unwrap());
+}
 
 
 fn main() {
@@ -101,15 +154,23 @@ fn main() {
     println!("Saving input image");
     img.save("./input.png").unwrap();
 
-    /*let output = btc_decode(btc_encode(img.clone()));
+    let output_4 = btc_decode(btc_encode(img.clone(), 4,4));
+    let output_8 = btc_decode(btc_encode(img.clone(), 8,8));
+    let output_16 = btc_decode(btc_encode(img.clone(), 16,16));
+    let output_32 = btc_decode(btc_encode(img.clone(), 32,32));
 
-    println!("MSE : {}", mse(&img, &output).unwrap());
+    println!("HPSNR 4x4 : {}", img_quality::hpsnr(&img, &output_4).unwrap());
+    println!("HPSNR 8x8 : {}", img_quality::hpsnr(&img, &output_8).unwrap());
+    println!("HPSNR 16x16 : {}", img_quality::hpsnr(&img, &output_16).unwrap());
+    println!("HPSNR 32x32 : {}", img_quality::hpsnr(&img, &output_32).unwrap());
 
 
 
-    println!("Saving result");
-    output.save("./output.png").unwrap();*/
-    btc_encode(img.clone(), 32, 32);
+    println!("Saving results");
+    output_4.save("./output4.png").unwrap();
+    output_8.save("./output8.png").unwrap();
+    output_16.save("./output16.png").unwrap();
+    output_32.save("./output32.png").unwrap();
 
 
 }