chunk size diffuse

Author: MenxLi

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chaotic-enc"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 
 [lib]

src/lib.rs

@@ -124,7 +124,7 @@ pub fn encode(im: &[u8], secret: &str, max_side: i32, as_type: &str) -> Box<[u8]
     let seed = str2f(&secret);
     console_log!("Seed: {}", seed);
 
-    let pixels = logistic_map::encode(&im_v, seed);
+    let pixels = logistic_map::encode::<3>(&im_v, seed);
 
     vec2imblob(&pixels, im_opt, None, match as_type {
         "png" => ImageType::Png,
@@ -142,7 +142,7 @@ pub fn decode(im: &[u8], secret: &str, max_side: i32, as_type: &str) -> Box<[u8]
     let seed = str2f(&secret);
     console_log!("Seed: {}", seed);
 
-    let pixels = logistic_map::decode(&im_v, seed);
+    let pixels = logistic_map::decode::<3>(&im_v, seed);
 
     vec2imblob(&pixels, im_opt, max_side, match as_type {
         "png" => ImageType::Png,

src/logistic_map.rs

@@ -41,9 +41,9 @@ enum DiffuseDirection {
     Forward,
     Backward,
 }
-fn diffuse<T: Copy>(im: &Vec<T>, enc_map: &Vec<f64>, direction: DiffuseDirection) -> Vec<T> 
+fn diffuse<T: Copy>(im: &Vec<T>, enc_map: &Vec<f64>, direction: DiffuseDirection, chunk_size: usize) -> Vec<T> 
 {
-    let enc_map = enc_map
+    let enc_map = enc_map[..im.len()/chunk_size]
         .iter()
         .map(|&x| x.to_bits())
         .collect();
@@ -55,16 +55,22 @@ fn diffuse<T: Copy>(im: &Vec<T>, enc_map: &Vec<f64>, direction: DiffuseDirection
     match direction {
         DiffuseDirection::Forward => {
             for &index in &indices {
-                diffuse_pixels.push(im[index]);
+                for i in 0..chunk_size {
+                    let index = index * chunk_size + i;
+                    diffuse_pixels.push(im[index]);
+                }
             }
         },
         DiffuseDirection::Backward => {
-            let mut lookup: Vec<usize> = vec![0; im.len()];
+            let mut lookup: Vec<usize> = vec![0; im.len() / chunk_size];
             for (i, &index) in indices.iter().enumerate() {
                 lookup[index] = i;
             }
             for &index in &lookup {
-                diffuse_pixels.push(im[index]);
+                for i in 0..chunk_size {
+                    let index = index * chunk_size + i;
+                    diffuse_pixels.push(im[index]);
+                }
             }
         },
     }
@@ -73,24 +79,25 @@ fn diffuse<T: Copy>(im: &Vec<T>, enc_map: &Vec<f64>, direction: DiffuseDirection
     diffuse_pixels
 }
 
-pub fn encode(im: &Vec<u8>, x0: f64) -> Vec<u8> {
+// C: channel size, e.g. 3 for RGB
+pub fn encode<const C: usize>(im: &Vec<u8>, x0: f64) -> Vec<u8> {
     let enc_map = generate_map(LogisticMapOptions {
         x: x0,
         r: R,  
         size: im.len(),
     });
 
-    let im = diffuse(&im, &enc_map, DiffuseDirection::Forward);
+    let im = diffuse(&im, &enc_map, DiffuseDirection::Forward, C);
     confuse_xor(&im, &enc_map)
 }
 
-pub fn decode(im: &Vec<u8>, x0: f64) -> Vec<u8> {
+pub fn decode<const C:usize>(im: &Vec<u8>, x0: f64) -> Vec<u8> {
     let enc_map = generate_map(LogisticMapOptions {
         x: x0,
         r: R,  
         size: im.len(),
     });
 
     let im = confuse_xor(&im, &enc_map);
-    diffuse(&im, &enc_map, DiffuseDirection::Backward)
+    diffuse(&im, &enc_map, DiffuseDirection::Backward, C)
 }