Update src/app.py

src/app.py

@@ -48,44 +48,65 @@ B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
 # =========================
 # Encoding Functions
 # =========================
-def encode_to_binary(text: str, scheme: str) -> tuple[list[int], list[str]]:
+def encode_to_binary(text: str, scheme: str) -> tuple[list[int], list[str], list[str]]:
     """
-    Returns (flat_bits, display_units).
-    display_units is a list of labels for each chunk (character, byte, or Base64 symbol).
+    Returns (flat_bits, display_units, source_chars).
+    - display_units: the encoded representation (Base64 symbol, hex byte, ASCII code, Voyager char)
+    - source_chars: the original text character each chunk maps to
     """
     if scheme == "Voyager 6-bit":
         bits = []
         for char in text:
             val = reverse_voyager_table.get(char.upper(), 0)
             bits.extend([(val >> b) & 1 for b in range(5, -1, -1)])
-        return bits, list(text.upper())
+        labels = list(text.upper())
+        return bits, labels, list(text)
 
     elif scheme == "ASCII (7-bit)":
         bits = []
         for c in text:
             val = ord(c) & 0x7F
             bits.extend([(val >> b) & 1 for b in range(6, -1, -1)])
-        return bits, list(text)
+        labels = [f"0x{ord(c) & 0x7F:02X}" for c in text]
+        return bits, labels, list(text)
 
     elif scheme == "UTF-8 (8-bit)":
         raw = text.encode("utf-8")
         bits = []
         for byte in raw:
             bits.extend([(byte >> b) & 1 for b in range(7, -1, -1)])
-        # For display: show hex byte value and the character it belongs to
         labels = [f"0x{b:02X}" for b in raw]
-        return bits, labels
+        # Map each byte back to its source character
+        source = []
+        for ch in text:
+            n_bytes = len(ch.encode("utf-8"))
+            source.extend([ch] * n_bytes)
+        return bits, labels, source
 
     elif scheme == "Base64 (6-bit)":
-        b64_str = base64.b64encode(text.encode("utf-8")).decode("ascii")
+        raw_bytes = text.encode("utf-8")
+        b64_str = base64.b64encode(raw_bytes).decode("ascii")
         bits = []
         clean = b64_str.rstrip("=")
         for c in clean:
             val = B64_ALPHABET.index(c)
             bits.extend([(val >> b) & 1 for b in range(5, -1, -1)])
-        return bits, list(clean)
+        labels = list(clean)
+        # Map each Base64 symbol to its primary source character
+        byte_to_char = []
+        for ch in text:
+            n_bytes = len(ch.encode("utf-8"))
+            byte_to_char.extend([ch] * n_bytes)
+        source = []
+        for j in range(len(clean)):
+            byte_idx = (j * 6) // 8
+            if byte_idx < len(byte_to_char):
+                source.append(byte_to_char[byte_idx])
+            else:
+                source.append("?")
+        return bits, labels, source
 
-    return [], []
+    return [], [], []
 
 
 # =========================
@@ -131,7 +152,6 @@ def decode_from_binary(bits: list[int], scheme: str) -> str:
             val = sum(b << (5 - j) for j, b in enumerate(chunk))
             chars.append(B64_ALPHABET[val])
         b64_str = ''.join(chars)
-        # Add Base64 padding
         while len(b64_str) % 4 != 0:
             b64_str += '='
         try:
@@ -145,7 +165,7 @@ def decode_from_binary(bits: list[int], scheme: str) -> str:
 # =========================
 # Tabs
 # =========================
-tab1, tab2, tab3, tab4, tab5 = st.tabs(["Encoding", "Decoding", "Image Preview", "Data Analytics", "Writing"])
+tab1, tab2, tab3, tab4 = st.tabs(["Encoding", "Decoding", "Data Analytics", "Writing"])
 
 # --------------------------------------------------
 # TAB 1: Text/Image → Binary
@@ -191,12 +211,11 @@ with tab1:
             group_size = custom_cols
 
         if user_input:
-            binary_labels, display_units = encode_to_binary(user_input, encoding_scheme)
+            binary_labels, display_units, source_chars = encode_to_binary(user_input, encoding_scheme)
             binary_concat = ''.join(map(str, binary_labels))
 
-            unit_label = "Character"
-            st.markdown(f"### Output 1 – Binary Labels per {unit_label}")
-            st.caption(f"Encoding: **{encoding_scheme}** — {bits_per} bits per {unit_label.lower()}")
+            st.markdown("### Output 1 – Binary Labels per Character")
+            st.caption(f"Encoding: **{encoding_scheme}** — {bits_per} bits per unit")
 
             grouped_bits = [binary_labels[i:i + bits_per] for i in range(0, len(binary_labels), bits_per)]
             scroll_html = (
@@ -204,17 +223,28 @@ with tab1:
                 "padding:6px; border:1px solid #ccc;'>"
             )
             for i, bits in enumerate(grouped_bits):
-                label = display_units[i] if i < len(display_units) else "?"
-                scroll_html += f"<div>'{label}' → {bits}</div>"
+                src = source_chars[i] if i < len(source_chars) else "?"
+                enc = display_units[i] if i < len(display_units) else "?"
+                if encoding_scheme == "Voyager 6-bit":
+                    # Voyager: direct char → binary (encoded label = uppercase of same char)
+                    scroll_html += f"<div>'{src}' → {bits}</div>"
+                else:
+                    # Show original → encoded representation → binary
+                    scroll_html += f"<div>'{src}' → '{enc}' → {bits}</div>"
             scroll_html += "</div>"
             st.markdown(scroll_html, unsafe_allow_html=True)
 
             per_char_lines = []
             for i, bits in enumerate(grouped_bits):
-                label = display_units[i] if i < len(display_units) else "?"
-                per_char_lines.append(f"'{label}' → {''.join(map(str, bits))}")
+                src = source_chars[i] if i < len(source_chars) else "?"
+                enc = display_units[i] if i < len(display_units) else "?"
+                bit_str = ''.join(map(str, bits))
+                if encoding_scheme == "Voyager 6-bit":
+                    per_char_lines.append(f"'{src}' → {bit_str}")
+                else:
+                    per_char_lines.append(f"'{src}' → '{enc}' → {bit_str}")
             st.download_button(
-                f"⬇️ Download Binary per {unit_label} (.txt)",
+                "⬇️ Download Binary per Character (.txt)",
                 data='\n'.join(per_char_lines),
                 file_name="binary_per_unit.txt",
                 mime="text/plain",
@@ -322,7 +352,7 @@ with tab1:
             )
 
             # Output as matrix with width = target_width
-            st.markdown("### Output 2 – Binary Matrix (rows = pixel rows)")
+            st.markdown("### Output 2 – Binary Matrix by dimension (Samples x Positions))")
             columns = [f"Position {i+1}" for i in range(target_width)]
             df_img = pd.DataFrame(binary_matrix, columns=columns)
             df_img.insert(0, "Sample", range(1, len(df_img) + 1))
@@ -337,7 +367,7 @@ with tab1:
             )
 
             # Also offer custom grouping (same as text mode)
-            st.markdown("### Output 3 – Custom Grouped Matrix")
+            st.markdown("### Output 3 – Custom Grouped Matrix by Number of Target Positions")
             col1, col2 = st.columns([2, 1])
             with col1:
                 img_group_size = st.slider(
@@ -375,190 +405,191 @@ with tab1:
             st.info("👆 Upload an image to encode it as binary.")
 
 # --------------------------------------------------
-# TAB 2: Binary → Text
+# TAB 2: Decoding (Text & Image)
 # --------------------------------------------------
 with tab2:
     st.markdown("""
-    Convert binary data back into readable text.  
-    Upload either:
-    - `.csv` file with 0/1 values (any number of columns/rows)  
-    - `.xlsx` Excel file  
-    - `.txt` file containing a concatenated binary string (e.g. `010101...`)
+    Decode binary data back into **text** or render it as a **black & white image**.
     """)
 
-    decode_scheme = st.selectbox(
-        "Decoding scheme (must match the encoding used):",
-        ENCODING_OPTIONS,
-        index=0,
-        key="dec_scheme",
-        help="Select the same encoding scheme that was used to produce the binary data."
-    )
+    decode_mode = st.selectbox("Output mode:", ["Text", "Image"], key="decode_mode")
 
-    uploaded_decode = st.file_uploader(
-        "Upload your file (.csv, .xlsx, or .txt):",
-        type=["csv", "xlsx", "txt"],
-        key="decode_uploader"
-    )
-
-    if uploaded_decode is not None:
-        try:
-            if uploaded_decode.name.endswith(".csv"):
-                df = pd.read_csv(uploaded_decode)
-                bits = df.values.flatten().astype(int).tolist()
-            elif uploaded_decode.name.endswith(".xlsx"):
-                df = pd.read_excel(uploaded_decode)
-                bits = df.values.flatten().astype(int).tolist()
-            elif uploaded_decode.name.endswith(".txt"):
-                content = uploaded_decode.read().decode().strip()
-                bits = [int(b) for b in content if b in ['0', '1']]
-            else:
-                bits = []
-
-            if not bits:
-                st.warning("No binary data detected.")
-            else:
-                recovered_text = decode_from_binary(bits, decode_scheme)
-                st.success(f"✅ Conversion complete using **{decode_scheme}**!")
-                st.markdown("**Recovered text:**")
-                st.text_area("Output", recovered_text, height=150)
-
-                st.download_button(
-                    "⬇️ Download Recovered Text (.txt)",
-                    data=recovered_text,
-                    file_name="recovered_text.txt",
-                    mime="text/plain",
-                    key="download_recovered"
-                )
-        except Exception as e:
-            st.error(f"Error reading or converting file: {e}")
-    else:
-        st.info("👆 Upload a file to start the reverse conversion.")
+    if decode_mode == "Text":
+        st.markdown("""
+        Upload either:
+        - `.csv` file with 0/1 values (any number of columns/rows)  
+        - `.xlsx` Excel file  
+        - `.txt` file containing a concatenated binary string (e.g. `010101...`)
+        """)
 
-# --------------------------------------------------
-# TAB 3: Image Preview
-# --------------------------------------------------
-with tab3:
-    st.header("🖼️ Image Preview")
-    st.markdown("""
-    Render binary data (0/1) as a **black & white image**.  
-    Upload a binary matrix CSV (rows × positions) or a concatenated binary `.txt` string.
-    """)
+        decode_scheme = st.selectbox(
+            "Decoding scheme (must match the encoding used):",
+            ENCODING_OPTIONS,
+            index=0,
+            key="dec_scheme",
+            help="Select the same encoding scheme that was used to produce the binary data."
+        )
 
-    img_preview_file = st.file_uploader(
-        "📤 Upload binary data file (.csv, .xlsx, or .txt):",
-        type=["csv", "xlsx", "txt"],
-        key="img_preview_uploader"
-    )
+        uploaded_decode = st.file_uploader(
+            "Upload your file (.csv, .xlsx, or .txt):",
+            type=["csv", "xlsx", "txt"],
+            key="decode_uploader"
+        )
 
-    if img_preview_file is not None:
-        try:
-            # --- Load binary data ---
-            if img_preview_file.name.endswith(".csv"):
-                idf = pd.read_csv(img_preview_file)
-                # Drop Sample column if present
-                if "Sample" in idf.columns or "sample" in idf.columns:
-                    idf = idf.drop(columns=[c for c in idf.columns if c.lower() == "sample"])
-                bits_matrix = idf.values.flatten().astype(int)
-                detected_width = len(idf.columns)
-            elif img_preview_file.name.endswith(".xlsx"):
-                idf = pd.read_excel(img_preview_file)
-                if "Sample" in idf.columns or "sample" in idf.columns:
-                    idf = idf.drop(columns=[c for c in idf.columns if c.lower() == "sample"])
-                bits_matrix = idf.values.flatten().astype(int)
-                detected_width = len(idf.columns)
-            elif img_preview_file.name.endswith(".txt"):
-                content = img_preview_file.read().decode().strip()
-                bits_matrix = np.array([int(b) for b in content if b in ['0', '1']])
-                detected_width = None
-            else:
-                bits_matrix = np.array([])
-                detected_width = None
+        if uploaded_decode is not None:
+            try:
+                if uploaded_decode.name.endswith(".csv"):
+                    df = pd.read_csv(uploaded_decode)
+                    bits = df.values.flatten().astype(int).tolist()
+                elif uploaded_decode.name.endswith(".xlsx"):
+                    df = pd.read_excel(uploaded_decode)
+                    bits = df.values.flatten().astype(int).tolist()
+                elif uploaded_decode.name.endswith(".txt"):
+                    content = uploaded_decode.read().decode().strip()
+                    bits = [int(b) for b in content if b in ['0', '1']]
+                else:
+                    bits = []
 
-            if len(bits_matrix) == 0:
-                st.warning("No binary data detected.")
-            else:
-                total_bits = len(bits_matrix)
-                st.success(f"✅ Loaded **{total_bits:,}** bits.")
+                if not bits:
+                    st.warning("No binary data detected.")
+                else:
+                    recovered_text = decode_from_binary(bits, decode_scheme)
+                    st.success(f"✅ Conversion complete using **{decode_scheme}**!")
+                    st.markdown("**Recovered text:**")
+                    st.text_area("Output", recovered_text, height=150)
+
+                    st.download_button(
+                        "⬇️ Download Recovered Text (.txt)",
+                        data=recovered_text,
+                        file_name="recovered_text.txt",
+                        mime="text/plain",
+                        key="download_recovered"
+                    )
+            except Exception as e:
+                st.error(f"Error reading or converting file: {e}")
+        else:
+            st.info("👆 Upload a file to start the reverse conversion.")
 
-                # --- Width control ---
-                st.markdown("#### ⚙️ Image Dimensions")
+    # =====================================================
+    # IMAGE DECODE MODE
+    # =====================================================
+    else:
+        st.markdown("""
+        Render binary data (0/1) as a **black & white image**.  
+        Upload a binary matrix CSV (rows × positions) or a concatenated binary `.txt` string.
+        """)
+
+        img_preview_file = st.file_uploader(
+            "📤 Upload binary data file (.csv, .xlsx, or .txt):",
+            type=["csv", "xlsx", "txt"],
+            key="img_preview_uploader"
+        )
 
-                if detected_width and detected_width > 1:
-                    default_w = detected_width
-                    st.caption(f"Auto-detected width from columns: **{detected_width}**")
+        if img_preview_file is not None:
+            try:
+                # --- Load binary data ---
+                if img_preview_file.name.endswith(".csv"):
+                    idf = pd.read_csv(img_preview_file)
+                    if "Sample" in idf.columns or "sample" in idf.columns:
+                        idf = idf.drop(columns=[c for c in idf.columns if c.lower() == "sample"])
+                    bits_matrix = idf.values.flatten().astype(int)
+                    detected_width = len(idf.columns)
+                elif img_preview_file.name.endswith(".xlsx"):
+                    idf = pd.read_excel(img_preview_file)
+                    if "Sample" in idf.columns or "sample" in idf.columns:
+                        idf = idf.drop(columns=[c for c in idf.columns if c.lower() == "sample"])
+                    bits_matrix = idf.values.flatten().astype(int)
+                    detected_width = len(idf.columns)
+                elif img_preview_file.name.endswith(".txt"):
+                    content = img_preview_file.read().decode().strip()
+                    bits_matrix = np.array([int(b) for b in content if b in ['0', '1']])
+                    detected_width = None
                 else:
-                    # Guess a square-ish default
-                    default_w = max(1, int(np.sqrt(total_bits)))
-
-                img_width = st.number_input(
-                    "Image width (pixels / positions per row):",
-                    min_value=1, max_value=total_bits, value=default_w, step=1,
-                    key="img_preview_width"
-                )
-                img_height = int(np.ceil(total_bits / img_width))
-                st.caption(f"Image size: **{img_width} × {img_height}** = **{img_width * img_height:,}** pixels "
-                           f"({total_bits:,} bits, {img_width * img_height - total_bits} padded)")
-
-                # Pad to fill the last row
-                padded = np.zeros(img_width * img_height, dtype=int)
-                padded[:total_bits] = bits_matrix[:total_bits]
-                img_data = padded.reshape((img_height, img_width))
-
-                # Render: 1 = black (0), 0 = white (255)
-                img_render = ((1 - img_data) * 255).astype(np.uint8)
-                pil_img = Image.fromarray(img_render, mode="L")
-
-                st.markdown("### 🖼️ Rendered Image")
-                # Use nearest-neighbor scaling for crisp pixels
-                display_scale = max(1, 256 // img_width)
-                display_w = img_width * display_scale
-                display_h = img_height * display_scale
-                pil_display = pil_img.resize((display_w, display_h), Image.NEAREST)
-                st.image(pil_display, caption=f"Binary image — {img_width}×{img_height} (1=black, 0=white)")
-
-                # Stats
-                ones = int(bits_matrix.sum())
-                st.markdown(
-                    f"- **Black pixels (1):** {ones:,} ({100*ones/total_bits:.1f}%)  \n"
-                    f"- **White pixels (0):** {total_bits - ones:,} ({100*(total_bits-ones)/total_bits:.1f}%)"
-                )
+                    bits_matrix = np.array([])
+                    detected_width = None
 
-                # Download rendered image as PNG
-                buf = io.BytesIO()
-                pil_img.save(buf, format="PNG")
-                st.download_button(
-                    "⬇️ Download as PNG",
-                    data=buf.getvalue(),
-                    file_name=f"binary_image_{img_width}x{img_height}.png",
-                    mime="image/png",
-                    key="download_preview_png"
-                )
+                if len(bits_matrix) == 0:
+                    st.warning("No binary data detected.")
+                else:
+                    total_bits = len(bits_matrix)
+                    st.success(f"✅ Loaded **{total_bits:,}** bits.")
 
-                # Also offer a high-res version
-                buf_hr = io.BytesIO()
-                pil_display.save(buf_hr, format="PNG")
-                st.download_button(
-                    "⬇️ Download Scaled PNG (for viewing)",
-                    data=buf_hr.getvalue(),
-                    file_name=f"binary_image_{display_w}x{display_h}_scaled.png",
-                    mime="image/png",
-                    key="download_preview_png_scaled"
-                )
+                    # --- Width control ---
+                    st.markdown("#### ⚙️ Image Dimensions")
 
-        except Exception as e:
-            st.error(f"❌ Error processing file: {e}")
-            import traceback
-            st.code(traceback.format_exc())
-    else:
-        st.info("👆 Upload a binary data file (CSV or TXT) to render as an image.")
+                    if detected_width and detected_width > 1:
+                        default_w = detected_width
+                        st.caption(f"Auto-detected width from columns: **{detected_width}**")
+                    else:
+                        default_w = max(1, int(np.sqrt(total_bits)))
+
+                    img_width = st.number_input(
+                        "Image width (pixels / positions per row):",
+                        min_value=1, max_value=total_bits, value=default_w, step=1,
+                        key="img_preview_width"
+                    )
+                    img_height = int(np.ceil(total_bits / img_width))
+                    st.caption(f"Image size: **{img_width} × {img_height}** = **{img_width * img_height:,}** pixels "
+                               f"({total_bits:,} bits, {img_width * img_height - total_bits} padded)")
+
+                    # Pad to fill the last row
+                    padded = np.zeros(img_width * img_height, dtype=int)
+                    padded[:total_bits] = bits_matrix[:total_bits]
+                    img_data = padded.reshape((img_height, img_width))
+
+                    # Render: 1 = black (0), 0 = white (255)
+                    img_render = ((1 - img_data) * 255).astype(np.uint8)
+                    pil_img = Image.fromarray(img_render, mode="L")
+
+                    st.markdown("### 🖼️ Rendered Image")
+                    display_scale = max(1, 256 // img_width)
+                    display_w = img_width * display_scale
+                    display_h = img_height * display_scale
+                    pil_display = pil_img.resize((display_w, display_h), Image.NEAREST)
+                    st.image(pil_display, caption=f"Binary image — {img_width}×{img_height} (1=black, 0=white)")
+
+                    # Stats
+                    ones = int(bits_matrix.sum())
+                    st.markdown(
+                        f"- **Black pixels (1):** {ones:,} ({100*ones/total_bits:.1f}%)  \n"
+                        f"- **White pixels (0):** {total_bits - ones:,} ({100*(total_bits-ones)/total_bits:.1f}%)"
+                    )
+
+                    # Download rendered image as PNG
+                    buf = io.BytesIO()
+                    pil_img.save(buf, format="PNG")
+                    st.download_button(
+                        "⬇️ Download as PNG",
+                        data=buf.getvalue(),
+                        file_name=f"binary_image_{img_width}x{img_height}.png",
+                        mime="image/png",
+                        key="download_preview_png"
+                    )
+
+                    buf_hr = io.BytesIO()
+                    pil_display.save(buf_hr, format="PNG")
+                    st.download_button(
+                        "⬇️ Download Scaled PNG (for viewing)",
+                        data=buf_hr.getvalue(),
+                        file_name=f"binary_image_{display_w}x{display_h}_scaled.png",
+                        mime="image/png",
+                        key="download_preview_png_scaled"
+                    )
+
+            except Exception as e:
+                st.error(f"❌ Error processing file: {e}")
+                import traceback
+                st.code(traceback.format_exc())
+        else:
+            st.info("👆 Upload a binary data file (CSV or TXT) to render as an image.")
 
 # --------------------------------------------------
-# TAB 4: Data Analytics
+# TAB 3: Data Analytics
 # --------------------------------------------------
-with tab4:
+with tab3:
     st.header("📊 Data Analytics")
     st.markdown("""
-    Upload your sample data file (Excel or CSV) for a quick exploratory assessment.  
+    Upload your sample data file (Excel or CSV) for a quick exploratory assessment of the editing rates distribution.  
     The file should contain samples as rows and position columns with editing values.  
     This tab provides visualizations **before** any binary labelling.
     """)
@@ -768,9 +799,9 @@ with tab4:
         st.info("👆 Upload a data file (CSV or Excel) to start exploring.")
 
 # --------------------------------------------------
-# TAB 5: Pipetting Command Generator
+# TAB 4: Pipetting Command Generator
 # --------------------------------------------------
-with tab5:
+with tab4:
     from math import ceil
 
     st.header("🧪 Pipetting Command Generator for Eppendorf epMotion liquid handler")
@@ -1099,4 +1130,4 @@ with tab5:
         except Exception as e:
             st.error(f"❌ Error processing file: {e}")
     else:
-        st.info("👆 Upload an Excel/CSV/TXT file to start.")
+        st.info("👆 Upload an Excel/CSV/TXT file to start.")