Add run-length encoding for image parser

Author: GwnDaan

src/main.rs

@@ -197,15 +197,14 @@ impl DesignerApp {
 
                                         // Set format to 8-bit for maximum color support
                                         o.format = PictureGraphicFormat::EightBit;
-                                        o.options.data_code_type = DataCodeType::Raw;
 
                                         // We set transparent color to 1 (arbitrary choice) as we
                                         // only use index 15..255 for actual colors
                                         o.transparency_colour = 1;
                                         o.options.transparent = true;
 
-                                        // Convert RGB pixels to color indices
-                                        o.data = img
+                                        // Convert RGB pixels to color indices (raw data)
+                                        let raw_data: Vec<u8> = img
                                             .to_rgba8()
                                             .pixels()
                                             .map(|pixel| {
@@ -218,6 +217,59 @@ impl DesignerApp {
                                                 )
                                             })
                                             .collect();
+
+                                        // Run-length encoding lambda that matches Python implementation
+                                        let run_length_encode = |data: &[u8]| -> Vec<u8> {
+                                            if data.is_empty() {
+                                                return Vec::new();
+                                            }
+
+                                            let mut compressed = Vec::new();
+                                            let mut count: u8 = 1;
+                                            let mut current_value = data[0];
+
+                                            for &value in &data[1..] {
+                                                if value == current_value && count < 255 {
+                                                    count += 1;
+                                                } else {
+                                                    // Append current run
+                                                    compressed.push(count);
+                                                    compressed.push(current_value);
+
+                                                    // Start new run
+                                                    current_value = value;
+                                                    count = 1;
+                                                }
+                                            }
+
+                                            // Append the final run
+                                            compressed.push(count);
+                                            compressed.push(current_value);
+
+                                            compressed
+                                        };
+
+                                        // Compute run-length encoded version
+                                        let run_length_data = run_length_encode(&raw_data);
+
+                                        // Automatically select the encoding that produces smaller output
+                                        if run_length_data.len() < raw_data.len() {
+                                            o.data = run_length_data;
+                                            o.options.data_code_type = DataCodeType::RunLength;
+                                            log::info!(
+                                                "Selected run-length encoding ({}  bytes) over raw ({} bytes)",
+                                                o.data.len(),
+                                                raw_data.len()
+                                            );
+                                        } else {
+                                            o.data = raw_data;
+                                            o.options.data_code_type = DataCodeType::Raw;
+                                            log::info!(
+                                                "Selected raw encoding ({} bytes) over run-length ({} bytes)",
+                                                o.data.len(),
+                                                run_length_data.len()
+                                            );
+                                        }
                                     } else {
                                         log::error!("Failed to decode image");
                                     }