microbridge-lmd 0.2.0__py3-none-any.whl

MicroBridge/CLI/cli.py

@@ -0,0 +1,63 @@
+import sys
+
+import click
+
+from pathlib import Path
+from xml.parsers.expat import ExpatError
+
+from MicroBridge.Core.core import convert_ndpa_to_lmd_core, derive_output_filename
+
+def convert_files(files, output):
+    successful = 0
+    failures = []
+    for file in files:
+        if Path(file).suffix != ".ndpa":
+            message = f"\nExpected a '.ndpa' file, got a '{Path(file).suffix}' file Instead"
+            failures.append((file, message))
+            continue
+        output_name = derive_output_filename(file)
+        if output:
+            output_name = str(Path(output) / Path(output_name).name)
+        try:
+            convert_ndpa_to_lmd_core(file, output_name)
+        except (ValueError, FileNotFoundError, IsADirectoryError, ExpatError) as e:
+            failures.append((file, e))
+            click.echo(f"Converting the ndpa to an LMD xml failed: {e}", err=True)
+        else:
+            click.echo("Successfully converted ndpa into LMD xml :3")
+            successful += 1
+    return successful, failures
+
+def find_ndpa_files(directory):
+    files = []
+    for entry in Path(directory).iterdir():
+        if entry.suffix == ".ndpa":
+            files.append(str(entry))
+    return files
+
+@click.command()
+@click.pass_context
+@click.option('-b', '--batch',type=click.Path(), nargs=1, required=False, help="Process a Directory of '.ndpa' files in one go.")
+@click.option('-o', '--output',type=click.Path(), nargs=1, required=False, help="Select an output directory for the converted '.ndpa' files to end up in.")
+@click.argument("files", nargs=-1, required=False)
+def run(ctx, files, batch, output):
+    if not files and not batch:
+        click.echo(ctx.get_help())
+        sys.exit(1)
+    elif files and batch:
+        click.echo(f"You cannot have files and -b dir in one command \n\n{ctx.get_help()}")
+        sys.exit(1)
+    elif batch:
+        files = find_ndpa_files(batch)
+    successful, failures = convert_files(files, output)
+
+
+    click.echo("\n\n\n===============================================")
+    if successful == len(files):
+        click.secho(f"{successful}/{len(files)} files converted. \nAll files converted fine :3", fg="green",err=False)
+        sys.exit(0)
+    else:
+        click.secho(f"{len(failures)}/{len(files)} failed to convert 3:\nThe files that failed to convert were:\n", fg="red", err=True)
+        for filename, err in failures:
+            click.secho(f"{filename} errored with: {err}", fg="red", bold=True, err=True)
+        sys.exit(1)

MicroBridge/Core/core.py

@@ -0,0 +1,110 @@
+from xml.dom import minidom
+from pathlib import Path
+
+def derive_output_filename(input_filename: str) -> str:
+    p = Path(input_filename)
+    new_path = p.parent / (p.stem + "_LMD.xml")
+
+    return str(new_path)
+
+def convert_ndpa_to_lmd_core(input_filename: str, output_filename: str) -> None:
+    # 1. Parsing The input
+    with open(input_filename, "r", encoding="utf-8") as file:
+        ndpa_xml = minidom.parse(file)
+
+    # Find all 'ndpviewstate' elements
+    regions = ndpa_xml.getElementsByTagName("ndpviewstate")
+
+    # 2. Extract Calibration points
+    calibration_points = []
+
+    for cal_idx in range(min(3, len(regions))):
+        region = regions[cal_idx]
+        x_um, y_um = None, None
+
+        # Method 1: checking for circle annotations (Should always use as the instructional documentation states)
+        annotations = region.getElementsByTagName("annotation")
+        if annotations:
+            x_elems = annotations[0].getElementsByTagName("x")
+            y_elems = annotations[0].getElementsByTagName("y")
+
+            if x_elems and y_elems:
+                # Data is in nanometers. Divide by 1000 to get micrometers
+                x_um = int(round(float(x_elems[0].firstChild.data) / 1000))
+                y_um = int(round(float(y_elems[0].firstChild.data) / 1000))
+
+        if x_um is None: # Method 2: Fallback to Freehand points
+            pointlist = region.getElementsByTagName("point")
+            if pointlist:
+                x_elem = pointlist[0].getElementsByTagName("x")[0]
+                y_elem = pointlist[0].getElementsByTagName("y")[0]
+
+                x_um = int(round(float(x_elem.firstChild.data) / 1000))
+                y_um = int(round(float(y_elem.firstChild.data) / 1000))
+
+        if x_um is None:
+            raise ValueError(f"Calibration point {cal_idx + 1} came back malformed or incorrectly made")
+
+        calibration_points.append((x_um, y_um))
+
+    # 3. Extracting Capture shapes
+    valid_shapes = []
+    shape_num = 1
+
+    for shape_idx in range(3, len(regions)):
+        region = regions[shape_idx]
+
+        # We do this to stop Any rulers from breaking and crashing the program
+        annotations = region.getElementsByTagName("annotation")
+        if annotations and annotations[0].getAttribute("type") == "linearmeasure":
+            continue
+
+        # We use this to extract all the annotations the scientists want
+        pointlist = region.getElementsByTagName("point")
+        if len(pointlist) > 0:
+            points = [] # Could change the name later to reduce the chances of "eye-slip"
+            for point_idx, point in enumerate(pointlist):
+                try:
+                    x_elem = point.getElementsByTagName("x")[0]
+                    y_elem = point.getElementsByTagName("y")[0]
+
+                    x_um = int(round(float(x_elem.firstChild.data) / 1000))
+                    y_um = int(round(float(y_elem.firstChild.data) / 1000))
+                except (IndexError, AttributeError) as e:
+                    raise ValueError(f"Shape {shape_num} data malformed at point {point_idx + 1}") from e
+                points.append((x_um, y_um))
+
+            valid_shapes.append({
+                "shape_num": shape_num,
+                "points":   points
+            })
+            shape_num += 1
+
+    # 4. LMD XML output
+    with open(output_filename, "w", encoding="utf-8") as f1:
+        f1.write('<?xml version="1.0" encoding="utf-8"?>\n')
+        f1.write("<ImageData>\n")
+        f1.write("  <GlobalCoordinates>1</GlobalCoordinates>\n")
+
+        # We write the 3 calibration points first
+        for cal_idx, (x_um, y_um) in enumerate(calibration_points):
+            f1.write(f"  <X_CalibrationPoint_{cal_idx + 1}>{x_um}</X_CalibrationPoint_{cal_idx + 1}>\n")
+            f1.write(f"  <Y_CalibrationPoint_{cal_idx + 1}>{y_um}</Y_CalibrationPoint_{cal_idx + 1}>\n")
+
+        f1.write(f"  <ShapeCount>{len(valid_shapes)}</ShapeCount>\n")
+
+        for shape_data in valid_shapes:
+            s_num = shape_data["shape_num"]
+            points = shape_data["points"]
+
+            f1.write(f"  <Shape_{s_num}>\n")
+            f1.write(f"    <PointCount>{len(points)}</PointCount>\n")
+
+            # We write the X/Y cords for the Verticies of this shape
+            for point_idx, (x_um, y_um) in enumerate(points):
+                f1.write(f"    <X_{point_idx + 1}>{x_um}</X_{point_idx + 1}>\n")
+                f1.write(f"    <Y_{point_idx + 1}>{y_um}</Y_{point_idx + 1}>\n")
+
+            f1.write(f"  </Shape_{s_num}>\n")
+
+        f1.write("</ImageData>\n")

MicroBridge/GUI/gui.py

@@ -0,0 +1,275 @@
+import sys
+import threading
+from pathlib import Path
+from tkinter import filedialog
+
+import customtkinter as ctk
+
+from MicroBridge.Core.core import convert_ndpa_to_lmd_core, derive_output_filename
+
+
+PAD = 12
+
+
+class App(ctk.CTk):
+    def __init__(self):
+        super().__init__()
+        self.title("MicroBridge")
+        self.geometry("1050x650")
+        self.minsize(850, 450)
+
+        self._set_window_icon()
+
+        self.input_files: list[str] = []
+        self.output_dir: str | None = None
+        self._converting = False
+
+        self._setup_ui()
+        self._log("ready — pick some files")
+
+    def _set_window_icon(self):
+        if sys.platform != "win32":
+            return
+        base = getattr(sys, "_MEIPASS", None)
+        if not base:
+            return
+        icon = Path(base) / "MicroBridge_Icon.ico"
+        if icon.exists():
+            self.iconbitmap(str(icon))
+
+    def _setup_ui(self):
+        self.grid_columnconfigure(0, weight=2, uniform="col")
+        self.grid_columnconfigure(1, weight=3, uniform="col")
+        self.grid_rowconfigure(0, weight=1)
+
+        self._build_left()
+        self._build_right()
+
+    def _build_left(self):
+        left = ctk.CTkFrame(self, corner_radius=12)
+        left.grid(row=0, column=0, sticky="nsew", padx=(PAD, 6), pady=PAD)
+        left.grid_columnconfigure(0, weight=1)
+        left.grid_rowconfigure(6, weight=1)
+
+        ctk.CTkLabel(
+            left,
+            text="MicroBridge",
+            font=ctk.CTkFont(size=22, weight="bold"),
+        ).grid(row=0, column=0, padx=PAD, pady=(16, 2), sticky="w")
+
+        sep = ctk.CTkFrame(left, height=1)
+        sep.grid(row=1, column=0, padx=PAD, pady=(4, 12), sticky="ew")
+
+        ctk.CTkLabel(left, text="Conversion type", anchor="w", font=ctk.CTkFont(size=11)).grid(
+            row=2, column=0, padx=PAD, pady=(0, 4), sticky="ew"
+        )
+        self.type_var = ctk.StringVar(value="NDPA")
+        ctk.CTkComboBox(
+            left,
+            values=["Auto", "NDPA", "CSV"],
+            variable=self.type_var,
+            state="readonly",
+            corner_radius=6,
+        ).grid(row=3, column=0, padx=PAD, pady=(0, 14), sticky="ew")
+
+        btn_frame = ctk.CTkFrame(left, fg_color="transparent")
+        btn_frame.grid(row=4, column=0, padx=PAD, pady=(0, 2), sticky="ew")
+        btn_frame.grid_columnconfigure((0, 1, 2), weight=1)
+
+        ctk.CTkButton(
+            btn_frame, text="Select input files", command=self._select_files, corner_radius=6,
+            fg_color="transparent", text_color=("gray10", "gray90"), hover_color=("#d0d0d0", "#333333"),
+            border_width=1,
+        ).grid(row=0, column=0, padx=2, sticky="ew")
+
+        ctk.CTkButton(
+            btn_frame, text="Scan a folder", command=self._select_folder, corner_radius=6,
+            fg_color="transparent", text_color=("gray10", "gray90"), hover_color=("#d0d0d0", "#333333"),
+            border_width=1,
+        ).grid(row=0, column=1, padx=2, sticky="ew")
+
+        ctk.CTkButton(
+            btn_frame, text="Pick output folder", command=self._select_output, corner_radius=6,
+            fg_color="transparent", text_color=("gray10", "gray90"), hover_color=("#d0d0d0", "#333333"),
+            border_width=1,
+        ).grid(row=0, column=2, padx=2, sticky="ew")
+
+        self.files_label = ctk.CTkLabel(
+            left, text="Selected files: (none)", anchor="w", font=ctk.CTkFont(size=11),
+        )
+        self.files_label.grid(row=5, column=0, padx=PAD, pady=(10, 2), sticky="ew")
+
+        self.files_text = ctk.CTkTextbox(left, state="disabled", corner_radius=6)
+        self.files_text.grid(row=6, column=0, padx=PAD, pady=(0, 6), sticky="nsew")
+
+        self.output_label = ctk.CTkLabel(
+            left,
+            text="Output: (same dir as input)",
+            anchor="w",
+            font=ctk.CTkFont(size=11),
+        )
+        self.output_label.grid(row=7, column=0, padx=PAD, pady=(0, 8), sticky="ew")
+
+        self.convert_btn = ctk.CTkButton(
+            left,
+            text="Convert",
+            height=42,
+            font=ctk.CTkFont(size=14, weight="bold"),
+            command=self._convert,
+            corner_radius=8,
+        )
+        self.convert_btn.grid(row=8, column=0, padx=PAD, pady=(4, 16), sticky="ew")
+
+    def _build_right(self):
+        right = ctk.CTkFrame(self, corner_radius=12)
+        right.grid(row=0, column=1, sticky="nsew", padx=(6, PAD), pady=PAD)
+        right.grid_columnconfigure(0, weight=1)
+        right.grid_rowconfigure(1, weight=1)
+
+        hdr = ctk.CTkFrame(right, fg_color="transparent")
+        hdr.grid(row=0, column=0, padx=PAD, pady=(14, 6), sticky="ew")
+        hdr.grid_columnconfigure(0, weight=1)
+
+        ctk.CTkLabel(
+            hdr,
+            text="Log",
+            font=ctk.CTkFont(size=16),
+        ).grid(row=0, column=0, sticky="w")
+
+        ctk.CTkButton(
+            hdr,
+            text="Clear",
+            width=56,
+            height=24,
+            font=ctk.CTkFont(size=11),
+            command=self._clear_log,
+            corner_radius=4,
+            fg_color="transparent",
+            text_color=("gray10", "gray90"),
+            hover_color=("#d0d0d0", "#333333"),
+            border_width=1,
+        ).grid(row=0, column=1)
+
+        self.log_text = ctk.CTkTextbox(right, state="disabled", corner_radius=6)
+        self.log_text.grid(row=1, column=0, padx=PAD, pady=(0, PAD), sticky="nsew")
+
+        self.log_text.tag_config("ok", foreground="#2b8a5e")
+        self.log_text.tag_config("err", foreground="#c0392b")
+        self.log_text.tag_config("warn", foreground="#b45309")
+        self.log_text.tag_config("muted", foreground="#6b7280")
+
+    def _log(self, msg: str, tag: str | None = None):
+        self.log_text.configure(state="normal")
+        if tag:
+            self.log_text.insert("end", msg + "\n", tag)
+        else:
+            self.log_text.insert("end", msg + "\n")
+        self.log_text.see("end")
+        self.log_text.configure(state="disabled")
+
+    def _clear_log(self):
+        self.log_text.configure(state="normal")
+        self.log_text.delete("1.0", "end")
+        self.log_text.configure(state="disabled")
+
+    def _select_files(self):
+        files = filedialog.askopenfilenames(
+            title="Select input files",
+            filetypes=[("NDPA files", "*.ndpa"), ("All files", "*.*")],
+        )
+        if files:
+            self.input_files = list(files)
+            self._update_files_display()
+
+    def _select_folder(self):
+        folder = filedialog.askdirectory(title="Select a folder")
+        if folder:
+            self.input_files = sorted(
+                str(f) for f in Path(folder).iterdir() if f.suffix == ".ndpa"
+            )
+            self._update_files_display()
+
+    def _select_output(self):
+        folder = filedialog.askdirectory(title="Select Output Folder")
+        if folder:
+            self.output_dir = folder
+            short = f"...{folder[-50:]}" if len(folder) > 53 else folder
+            self.output_label.configure(text=f"Output: {short}")
+
+    def _update_files_display(self):
+        self.files_text.configure(state="normal")
+        self.files_text.delete("1.0", "end")
+        for f in self.input_files:
+            self.files_text.insert("end", f + "\n")
+        self.files_text.configure(state="disabled")
+
+        count = len(self.input_files)
+        self.files_label.configure(text=f"Selected files: ({count})")
+        self._log(f"{count} file(s) selected", "ok" if count else None)
+
+    def _convert(self):
+        if self._converting:
+            return
+        if not self.input_files:
+            self._log("nothing to convert — pick files first", "err")
+            return
+        self._converting = True
+        self.convert_btn.configure(
+            state="disabled",
+            text="Converting...",
+        )
+        threading.Thread(target=self._convert_worker, daemon=True).start()
+
+    def _convert_finished(self):
+        self._converting = False
+        self.convert_btn.configure(
+            state="normal",
+            text="Convert",
+        )
+
+    def _convert_worker(self):
+        files = self.input_files[:]
+        out_dir = self.output_dir
+        total = len(files)
+        ok = 0
+        fails: list[tuple[str, str | Exception]] = []
+
+        for i, file in enumerate(files):
+            self.after(0, self._log, f"[{i+1}/{total}] {Path(file).name} ...", "muted")
+
+            if Path(file).suffix != ".ndpa":
+                msg = f"expected '.ndpa', got '{Path(file).suffix}'"
+                fails.append((file, msg))
+                self.after(0, self._log, f"  {msg}", "err")
+                continue
+
+            output = derive_output_filename(file)
+            if out_dir:
+                output = str(Path(out_dir) / Path(output).name)
+
+            try:
+                convert_ndpa_to_lmd_core(file, output)
+                ok += 1
+                self.after(0, self._log, f"  done", "ok")
+            except (ValueError, FileNotFoundError, IsADirectoryError) as e:
+                fails.append((file, e))
+                self.after(0, self._log, f"  failed: {e}", "err")
+
+        self.after(0, self._log, "")
+        self.after(0, self._log, "─" * 40, "muted")
+        if ok == total:
+            self.after(0, self._log, f"{ok}/{total} converted", "ok")
+        else:
+            self.after(0, self._log, f"{len(fails)}/{total} failed", "err")
+            self.after(0, self._log, "failed files:", "warn")
+            for fname, err in fails:
+                self.after(0, self._log, f"  {Path(fname).name} — {err}", "err")
+
+        self.after(0, self._convert_finished)
+
+
+def run():
+    ctk.set_appearance_mode("system")
+    ctk.set_default_color_theme("blue")
+    app = App()
+    app.mainloop()

MicroBridge/main.py

@@ -0,0 +1,45 @@
+import os
+import sys
+
+from MicroBridge.utils import should_use_cli
+
+
+def hide_console():
+    if os.name == 'nt':
+        import ctypes
+        kernel32 = ctypes.WinDLL('kernel32')
+        user32 = ctypes.WinDLL('user32')
+        hWnd = kernel32.GetConsoleWindow()
+        if hWnd:
+            user32.ShowWindow(hWnd, 0)
+
+
+def attach_parent_console():
+    if os.name != 'nt' or not getattr(sys, 'frozen', False):
+        return
+    import ctypes
+    kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+    if kernel32.AttachConsole(-1):
+        sys.stdout = open('CONOUT$', 'w')
+        sys.stderr = open('CONOUT$', 'w')
+        sys.stdin = open('CONIN$', 'r')
+    else:
+        if sys.stdout is None:
+            sys.stdout = open(os.devnull, 'w')
+        if sys.stderr is None:
+            sys.stderr = open(os.devnull, 'w')
+
+
+def main():
+    argv = sys.argv[1:]
+    if should_use_cli(argv):
+        attach_parent_console()
+        from MicroBridge.CLI.cli import run as cli_run
+        cli_run.main(args=argv)
+    else:
+        hide_console()
+        from MicroBridge.GUI.gui import run as gui_run
+        gui_run()
+
+if __name__ == "__main__":
+    main()

MicroBridge/utils.py

@@ -0,0 +1,15 @@
+# Checks to see if the program was ran with the --gui flag or without any arguments
+def should_use_cli(argv: list[str]) -> bool:
+    if not argv:
+        return False
+    lowered = [arg.lower() for arg in argv]
+    return "--gui" not in lowered
+
+# Simple utility that clears the terminal and uses the correct command based on OS type
+# nt = windows
+# else = macos & linux!
+# Not used atm
+# def clear_terminal():
+#     import os
+#     import subprocess
+#     subprocess.run("cls" if os.name == "nt" else "clear", shell=True)

microbridge_lmd-0.2.0.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: microbridge-lmd
+Version: 0.2.0
+Summary: NDP/CSV to LMD Converter
+Author: Rose Scott
+License-Expression: GPL-3.0-or-later
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click
+Requires-Dist: customtkinter
+Dynamic: license-file
+
+# MicroBridge
+MicroBridge is a tool that allows file conversion between Slide annotation software like NDP.view2 to an XML format that Leica Microdissection (LMD) microscopes support.  
+
+---
+# Purpose
+Scientists annotate regions of interest in software like NDP.view2, They would then have to re-draw those same annotations in the software for the LMDs.  
+MicroBridge takes the annotation files from NDP.view2 and converts them into a format that the LMD can understand, This gives the scientists more time to do experiments rather than annotating files for the 2nd time.
+
+---
+# Installation
+To install the package do one of the following:
+
+A. Grab the release from the release section
+(Mainly for windows)
+
+B. Clone the Repo
+Make a virtual environment
+```zsh
+python3 -m venv .venv
+```
+Then:
+```zsh
+pip install -e .
+```
+
+---
+# Usage
+There are 2 ways to use MicroBridge
+Option 1: Usage via the GUI (graphical user interface)
+Install it first
+And either run
+```zsh
+microbridge
+```
+In your terminal and it will open up
+Or use the desktop icon / entry to open the program
+
+Option 2: Usage via the terminal
+For typical usage you would run
+```zsh
+microbridge filename.ndpa file2.ndpa file3.ndpa ...
+```
+There are 2 flags that you can use to help with input and output
+Flag 1: Batch processing 
+To process a whole folder / directory run
+```zsh
+microbridge -b directory-path
+```
+Flag 2: output dir
+To set a specific directory / folder for the files be placed into run
+```zsh
+microbridge filename.ndpa -o 'path/to/dir'
+```
+
+You can use both flags with each other
+```zsh
+microbridge -b 'path/to/.ndpa/dir' -o 'path/to/output/dir'
+```
+
+You can also run 
+```zsh
+microbridge --help
+```
+This shows you all the commands and a quick run down of what they do
+
+---
+# Tests
+There is information about running the tests locally in the tests directory of the REPO
+
+You can run this
+```zsh
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+python run_tests.py
+```
+to set up the venv and run the tests
+
+---
+## ndpa -> LMD(xml) example
+A raw ndpa looks like this:
+```xml
+<!-- Calibration Point 3 - Circle annotation -->
+<ndpviewstate id="3">
+  <title>Calibration_3</title>
+  <annotation type="circle">
+    <x>200000000</x>
+    <y>300000000</y>
+    <radius>5000000</radius>
+  </annotation>
+</ndpviewstate>
+
+<!-- RULER - should be SKIPPED -->
+<ndpviewstate id="4">
+  <title>Measurement_1</title>
+  <annotation type="linearmeasure" displayname="AnnotateRuler" color="#ff0000">
+    <x1>100000000</x1>
+    <y1>100000000</y1>
+    <x2>200000000</x2>
+    <y2>200000000</y2>
+  </annotation>
+</ndpviewstate>
+```
+MicroBridge (currently) converts this to an XML for the LMD's which look like this:
+```xml
+  <X_CalibrationPoint_3>200000</X_CalibrationPoint_3>
+  <Y_CalibrationPoint_3>300000</Y_CalibrationPoint_3>
+  <ShapeCount>2</ShapeCount>
+  <Shape_1>
+    <PointCount>3</PointCount>
+    <X_1>300000</X_1>
+    <Y_1>400000</Y_1>
+    <X_2>350000</X_2>
+    <Y_2>400000</Y_2>
+    <X_3>350000</X_3>
+    <Y_3>450000</Y_3>
+  </Shape_1>
+```
+This example above is cut down for length reasons
+
+If you want to see a real world example and the full example above you can look here:
+[ndpa --> LMD(xml) examples](ndpa_to_LMD_examples/)
+
+---
+## Codebase Layout
+```
+src/
+    ├── MicroBridge/
+    │   ├── __init__.py
+    │   ├── core/
+    │   │   ├── __init__.py
+    │   │   ├── conversion.py
+    │   │   └── utils.py
+    │   ├── cli/
+    │   │   ├── __init__.py
+    │   │   └── main.py
+    │   └── gui/
+    │       ├── __init__.py
+    │       └── main.py
+tests/
+    ├── __init__.py
+    ├── README.md
+    ├── test_core.py
+    ├── test_gui.py
+    ├── test_intergration.py
+    ├── test_utils.py
+    ├── test_cli.py
+    └── test_Data/
+        └── All the test data, I am not writing that out...
+        
+pyproject.toml
+run_tests.py
+
+```
+
+---
+# License
+This project is licensed under the [GNU GPLv3.0 License](LICENSE)
+This is important as it support copyleft! and Free software!