Update src/app.py

src/app.py

@@ -8,6 +8,7 @@ import base64
 import matplotlib.pyplot as plt
 import matplotlib.colors as mcolors
 from scipy.stats import gaussian_kde
+from PIL import Image
 
 # =========================
 # Streamlit App Setup
@@ -144,114 +145,234 @@ def decode_from_binary(bits: list[int], scheme: str) -> str:
 # =========================
 # Tabs
 # =========================
-tab1, tab2, tab3, tab4 = st.tabs(["Encoding", "Decoding", "Data Analytics", "Writing"])
+tab1, tab2, tab3, tab4, tab5 = st.tabs(["Encoding", "Decoding", "Image Preview", "Data Analytics", "Writing"])
 
 # --------------------------------------------------
-# TAB 1: Text → Binary
+# TAB 1: Text/Image → Binary
 # --------------------------------------------------
 with tab1:
     st.markdown("""
-    Convert any text into binary labels.  
-    Choose an encoding scheme and control how many positions (columns) are grouped per row.
+    Convert text or an image into binary labels.  
+    Choose an input mode, encoding scheme, and control grouping.
     """)
 
-    st.subheader("Step 1 – Choose Encoding & Input Text")
-
-    encoding_scheme = st.selectbox(
-        "Encoding scheme:",
-        ENCODING_OPTIONS,
-        index=0,
-        key="enc_scheme",
-        help=(
-            "**Voyager 6-bit** – Custom 56-character table (A-Z, 0-9, punctuation). 6 bits/char.\n\n"
-            "**Base64 (6-bit)** – Standard Base64 encoding of UTF-8 bytes. 6 bits/symbol.\n\n"
-            "**ASCII (7-bit)** – Standard 7-bit ASCII. 7 bits/char.\n\n"
-            "**UTF-8 (8-bit)** – Full UTF-8 byte encoding. 8 bits/byte. Supports all Unicode."
+    input_mode = st.selectbox("Input mode:", ["Text", "Image"], key="input_mode")
+
+    if input_mode == "Text":
+        st.subheader("Step 1 – Choose Encoding & Input Text")
+
+        encoding_scheme = st.selectbox(
+            "Encoding scheme:",
+            ENCODING_OPTIONS,
+            index=0,
+            key="enc_scheme",
+            help=(
+                "**Voyager 6-bit** – Custom 56-character table (A-Z, 0-9, punctuation). 6 bits/char.\n\n"
+                "**Base64 (6-bit)** – Standard Base64 encoding of UTF-8 bytes. 6 bits/symbol.\n\n"
+                "**ASCII (7-bit)** – Standard 7-bit ASCII. 7 bits/char.\n\n"
+                "**UTF-8 (8-bit)** – Full UTF-8 byte encoding. 8 bits/byte. Supports all Unicode."
+            )
         )
-    )
 
-    bits_per = BITS_PER_UNIT[encoding_scheme]
+        bits_per = BITS_PER_UNIT[encoding_scheme]
 
-    # Show a note for Voyager about supported characters
-    if encoding_scheme == "Voyager 6-bit":
-        supported = ''.join(voyager_table[i] for i in range(len(voyager_table)))
-        st.caption(f"Supported characters ({len(voyager_table)}): `{supported}`")
+        if encoding_scheme == "Voyager 6-bit":
+            supported = ''.join(voyager_table[i] for i in range(len(voyager_table)))
+            st.caption(f"Supported characters ({len(voyager_table)}): `{supported}`")
 
-    user_input = st.text_input("Enter your text:", value="DNA", key="input_text")
+        user_input = st.text_input("Enter your text:", value="DNA", key="input_text")
 
-    col1, col2 = st.columns([2, 1])
-    with col1:
-        group_size = st.slider("Select number of target positions:", min_value=12, max_value=128, value=25)
-    with col2:
-        custom_cols = st.number_input("Or enter custom number:", min_value=1, max_value=512, value=group_size)
-    if custom_cols != group_size:
-        group_size = custom_cols
+        col1, col2 = st.columns([2, 1])
+        with col1:
+            group_size = st.slider("Select number of target positions:", min_value=12, max_value=128, value=25)
+        with col2:
+            custom_cols = st.number_input("Or enter custom number:", min_value=1, max_value=512, value=group_size)
+        if custom_cols != group_size:
+            group_size = custom_cols
 
-    if user_input:
-        binary_labels, display_units = encode_to_binary(user_input, encoding_scheme)
-        binary_concat = ''.join(map(str, binary_labels))
+        if user_input:
+            binary_labels, display_units = encode_to_binary(user_input, encoding_scheme)
+            binary_concat = ''.join(map(str, binary_labels))
 
-        # --- Output 1: Binary Labels per Unit ---
-        unit_label = "Byte" if encoding_scheme == "UTF-8 (8-bit)" else "Character"
-        st.markdown(f"### Output 1 – Binary Labels per {unit_label}")
-        st.caption(f"Encoding: **{encoding_scheme}** — {bits_per} bits per {unit_label.lower()}")
+            unit_label = "Byte" if encoding_scheme == "UTF-8 (8-bit)" else "Character"
+            st.markdown(f"### Output 1 – Binary Labels per {unit_label}")
+            st.caption(f"Encoding: **{encoding_scheme}** — {bits_per} bits per {unit_label.lower()}")
 
-        grouped_bits = [binary_labels[i:i + bits_per] for i in range(0, len(binary_labels), bits_per)]
-        scroll_html = (
-            "<div style='max-height:300px; overflow-y:auto; font-family:monospace; "
-            "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>"
-        scroll_html += "</div>"
-        st.markdown(scroll_html, unsafe_allow_html=True)
-
-        # Download per-character breakdown
-        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))}")
-        st.download_button(
-            f"⬇️ Download Binary per {unit_label} (.txt)",
-            data='\n'.join(per_char_lines),
-            file_name="binary_per_unit.txt",
-            mime="text/plain",
-            key="download_per_unit"
-        )
+            grouped_bits = [binary_labels[i:i + bits_per] for i in range(0, len(binary_labels), bits_per)]
+            scroll_html = (
+                "<div style='max-height:300px; overflow-y:auto; font-family:monospace; "
+                "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>"
+            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))}")
+            st.download_button(
+                f"⬇️ Download Binary per {unit_label} (.txt)",
+                data='\n'.join(per_char_lines),
+                file_name="binary_per_unit.txt",
+                mime="text/plain",
+                key="download_per_unit"
+            )
 
-        # Download full concatenated binary text
-        st.download_button(
-            "⬇️ Download Concatenated Binary String",
-            data=binary_concat,
-            file_name="binary_full.txt",
-            mime="text/plain",
-            key="download_binary_txt"
-        )
+            st.download_button(
+                "⬇️ Download Concatenated Binary String",
+                data=binary_concat,
+                file_name="binary_full.txt",
+                mime="text/plain",
+                key="download_binary_txt"
+            )
 
-        # --- Output 2: Binary matrix split into reactions grouped by target position ---
-        st.markdown("### Output 2 – Binary matrix split into reactions grouped by target position")
-        groups = []
-        for i in range(0, len(binary_labels), group_size):
-            group = binary_labels[i:i + group_size]
-            if len(group) < group_size:
-                group += [0] * (group_size - len(group))
-            groups.append(group)
-
-        columns = [f"Position {i+1}" for i in range(group_size)]
-        df = pd.DataFrame(groups, columns=columns)
-        df.insert(0, "Sample", range(1, len(df) + 1))
-        st.dataframe(df, width="stretch")
-
-        st.download_button(
-            "⬇️ Download as CSV",
-            df.to_csv(index=False),
-            file_name=f"binary_labels_{group_size}_positions.csv",
-            mime="text/csv",
-            key="download_binary_csv"
-        )
+            st.markdown("### Output 2 – Binary matrix split into reactions grouped by target position")
+            groups = []
+            for i in range(0, len(binary_labels), group_size):
+                group = binary_labels[i:i + group_size]
+                if len(group) < group_size:
+                    group += [0] * (group_size - len(group))
+                groups.append(group)
+
+            columns = [f"Position {i+1}" for i in range(group_size)]
+            df = pd.DataFrame(groups, columns=columns)
+            df.insert(0, "Sample", range(1, len(df) + 1))
+            st.dataframe(df, width="stretch")
+
+            st.download_button(
+                "⬇️ Download as CSV",
+                df.to_csv(index=False),
+                file_name=f"binary_labels_{group_size}_positions.csv",
+                mime="text/csv",
+                key="download_binary_csv"
+            )
+        else:
+            st.info("👆 Enter text above to see binary labels.")
+
+    # =====================================================
+    # IMAGE INPUT MODE
+    # =====================================================
     else:
-        st.info("👆 Enter text above to see binary labels.")
+        st.subheader("Step 1 – Upload Image & Set Resolution")
+
+        uploaded_img = st.file_uploader(
+            "Upload an image (PNG, JPG, BMP, etc.):",
+            type=["png", "jpg", "jpeg", "bmp", "gif", "tiff", "webp"],
+            key="img_uploader"
+        )
+
+        if uploaded_img is not None:
+            img = Image.open(uploaded_img).convert("L")  # grayscale
+            orig_w, orig_h = img.size
+            aspect = orig_h / orig_w
+
+            st.image(img, caption=f"Original (grayscale) — {orig_w}×{orig_h} px", use_container_width=True)
+
+            st.markdown("#### ⚙️ Resolution & Threshold")
+            target_width = st.slider(
+                "Output width (pixels):",
+                min_value=8, max_value=min(orig_w, 256), value=min(64, orig_w), step=1,
+                help="Height is auto-calculated from aspect ratio. Each pixel = 1 bit."
+            )
+            target_height = max(1, int(round(target_width * aspect)))
+            total_bits = target_width * target_height
+            st.caption(f"Output size: **{target_width} × {target_height}** = **{total_bits:,}** bits (pixels)")
+
+            threshold = st.slider(
+                "Black/white threshold:",
+                min_value=0, max_value=255, value=128,
+                help="Pixels darker than this → 1 (black). Brighter → 0 (white)."
+            )
+
+            # Resize & threshold
+            img_resized = img.resize((target_width, target_height), Image.LANCZOS)
+            img_array = np.array(img_resized)
+            binary_matrix = (img_array < threshold).astype(int)  # dark = 1, light = 0
+
+            # Show preview
+            st.markdown("### Preview — Black & White Output")
+            col_prev1, col_prev2 = st.columns(2)
+            with col_prev1:
+                st.image(img_resized, caption=f"Resized grayscale ({target_width}×{target_height})", use_container_width=True)
+            with col_prev2:
+                bw_display = Image.fromarray(((1 - binary_matrix) * 255).astype(np.uint8))
+                st.image(bw_display, caption=f"Binary B&W ({target_width}×{target_height})", use_container_width=True)
+
+            # Flatten to binary labels
+            binary_labels = binary_matrix.flatten().tolist()
+            binary_concat = ''.join(map(str, binary_labels))
+
+            st.markdown("### Output 1 – Image Info")
+            st.markdown(
+                f"- **Dimensions:** {target_width} × {target_height}  \n"
+                f"- **Total bits:** {total_bits:,}  \n"
+                f"- **Black pixels (1s):** {sum(binary_labels):,}  \n"
+                f"- **White pixels (0s):** {total_bits - sum(binary_labels):,}"
+            )
+
+            st.download_button(
+                "⬇️ Download Concatenated Binary String",
+                data=binary_concat,
+                file_name="image_binary_full.txt",
+                mime="text/plain",
+                key="download_img_binary_txt"
+            )
+
+            # Output as matrix with width = target_width
+            st.markdown("### Output 2 – Binary Matrix (rows = pixel rows)")
+            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))
+            st.dataframe(df_img, width="stretch")
+
+            st.download_button(
+                "⬇️ Download as CSV",
+                df_img.to_csv(index=False),
+                file_name=f"image_binary_{target_width}x{target_height}.csv",
+                mime="text/csv",
+                key="download_img_csv"
+            )
+
+            # Also offer custom grouping (same as text mode)
+            st.markdown("### Output 3 – Custom Grouped Matrix")
+            col1, col2 = st.columns([2, 1])
+            with col1:
+                img_group_size = st.slider(
+                    "Select number of target positions:",
+                    min_value=12, max_value=128, value=target_width, key="img_group_slider"
+                )
+            with col2:
+                img_custom_cols = st.number_input(
+                    "Or enter custom number:",
+                    min_value=1, max_value=512, value=img_group_size, key="img_custom_cols"
+                )
+            if img_custom_cols != img_group_size:
+                img_group_size = img_custom_cols
+
+            groups = []
+            for i in range(0, len(binary_labels), img_group_size):
+                group = binary_labels[i:i + img_group_size]
+                if len(group) < img_group_size:
+                    group += [0] * (img_group_size - len(group))
+                groups.append(group)
+
+            columns_g = [f"Position {i+1}" for i in range(img_group_size)]
+            df_grouped = pd.DataFrame(groups, columns=columns_g)
+            df_grouped.insert(0, "Sample", range(1, len(df_grouped) + 1))
+            st.dataframe(df_grouped, width="stretch")
+
+            st.download_button(
+                "⬇️ Download Grouped CSV",
+                df_grouped.to_csv(index=False),
+                file_name=f"image_binary_grouped_{img_group_size}_positions.csv",
+                mime="text/csv",
+                key="download_img_grouped_csv"
+            )
+        else:
+            st.info("👆 Upload an image to encode it as binary.")
 
 # --------------------------------------------------
 # TAB 2: Binary → Text
@@ -314,9 +435,127 @@ with tab2:
         st.info("👆 Upload a file to start the reverse conversion.")
 
 # --------------------------------------------------
-# TAB 3: Data Analytics
+# 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.
+    """)
+
+    img_preview_file = st.file_uploader(
+        "📤 Upload binary data file (.csv, .xlsx, or .txt):",
+        type=["csv", "xlsx", "txt"],
+        key="img_preview_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 len(bits_matrix) == 0:
+                st.warning("No binary data detected.")
+            else:
+                total_bits = len(bits_matrix)
+                st.success(f"✅ Loaded **{total_bits:,}** bits.")
+
+                # --- Width control ---
+                st.markdown("#### ⚙️ Image Dimensions")
+
+                if detected_width and detected_width > 1:
+                    default_w = detected_width
+                    st.caption(f"Auto-detected width from columns: **{detected_width}**")
+                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}%)"
+                )
+
+                # 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"
+                )
+
+                # 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"
+                )
+
+        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
+# --------------------------------------------------
+with tab4:
     st.header("📊 Data Analytics")
     st.markdown("""
     Upload your sample data file (Excel or CSV) for a quick exploratory assessment.  
@@ -499,7 +738,8 @@ with tab3:
             # =====================================================
             st.markdown("#### 3️⃣ 2D Density Heatmap")
             st.caption("Binned heatmap of editing values by position — similar to a FACS density plot.")
-            y_bins = st.number_input("Vertical bins:", min_value=20, max_value=150, value=60, key="heatmap_ybins")
+
+            y_bins = st.slider("Vertical bins:", min_value=20, max_value=150, value=60, key="heatmap_ybins")
 
             positions_unique = sorted(melted["Position_idx"].unique())
             n_positions = len(positions_unique)
@@ -528,9 +768,9 @@ with tab3:
         st.info("👆 Upload a data file (CSV or Excel) to start exploring.")
 
 # --------------------------------------------------
-# TAB 4: Pipetting Command Generator
+# TAB 5: Pipetting Command Generator
 # --------------------------------------------------
-with tab4:
+with tab5:
     from math import ceil
 
     st.header("🧪 Pipetting Command Generator for Eppendorf epMotion liquid handler")