From 3470489215fc19dff5fec008a60f8b91d9d4c81d Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 11:04:25 +0200
Subject: [PATCH 01/24] feat(util): add raw movie discovery helper and tests

---
 picasso_workflow/tests/test_util.py |  36 +++++++++
 picasso_workflow/util.py            | 118 ++++++++++++++++++++++++++++
 2 files changed, 154 insertions(+)

diff --git a/picasso_workflow/tests/test_util.py b/picasso_workflow/tests/test_util.py
index e7d3dd6..28e46b1 100644
--- a/picasso_workflow/tests/test_util.py
+++ b/picasso_workflow/tests/test_util.py
@@ -215,3 +215,39 @@ def test_06_valid_expression(self):
         expression = "* 3.1415"
         val = util.is_valid_expression(expression)
         assert val
+
+    def test_07_get_movie_groups(self):
+        from picasso_workflow.metaworkflow import get_movie_groups
+
+        paths = [
+            "movie_1.ome.tif",
+            "movie_0.ome.tif",
+            "movie_2.ome.tif",
+            "other.ome.tif",
+        ]
+        groups = get_movie_groups(paths, ".ome.tif")
+        assert list(groups.keys()) == ["movie", "other"]
+        assert groups["movie"] == [
+            "movie_0.ome.tif",
+            "movie_1.ome.tif",
+            "movie_2.ome.tif",
+        ]
+        assert groups["other"] == ["other.ome.tif"]
+
+    def test_08_find_dnapaint_raw(self):
+        import tempfile
+        from pathlib import Path
+        from picasso_workflow.metaworkflow import find_dnapaint_raw
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            temp_path = Path(tempdir)
+            (temp_path / "cond1" / "pos10").mkdir(parents=True)
+            (temp_path / "cond1" / "pos10" / "movie_0.ome.tif").touch()
+            (temp_path / "cond1" / "pos2").mkdir(parents=True)
+            (temp_path / "cond1" / "pos2" / "movie_0.ome.tif").touch()
+
+            datasets, _ = find_dnapaint_raw(tempdir)
+            keys = list(datasets.keys())
+            assert "pos2" in keys
+            assert "pos10" in keys
+            assert keys.index("pos2") < keys.index("pos10")
diff --git a/picasso_workflow/util.py b/picasso_workflow/util.py
index 01fa72e..b7aa8ee 100644
--- a/picasso_workflow/util.py
+++ b/picasso_workflow/util.py
@@ -2731,3 +2731,121 @@ def stripplot(data, positions, jitter, ax, color, alpha=1):
         x = pos * np.ones(len(d))
         x += np.random.uniform(-jitter / 2, jitter / 2, size=len(d))
         ax.scatter(x, d, color=color, alpha=alpha)
+
+
+def get_movie_groups(paths, extension):
+    """
+    Groups files based on basename and index, supporting variable extensions.
+
+    Args:
+        paths: list of filenames
+        extension: the extension to match (e.g. '.tif' or '.ome.tif')
+    Returns:
+        dict: mapping from base name to list of file paths (sorted by index)
+    """
+    import re
+
+    groups = {}
+    if not paths:
+        return groups
+
+    ext_pattern = re.escape(extension)
+    pattern = re.compile(rf"(.*?)(?:_(\d+))?{ext_pattern}$")
+
+    match_infos = []
+    for path in paths:
+        match = pattern.match(path)
+        if match:
+            base, index = match.groups()
+            match_infos.append(
+                {
+                    "path": path,
+                    "base": base,
+                    "index": int(index) if index else 0,
+                }
+            )
+
+    # Grouping logic
+    basenames = {m["base"] for m in match_infos}
+    for base in basenames:
+        group_items = [m for m in match_infos if m["base"] == base]
+        # Sort by index
+        group_items.sort(key=lambda x: x["index"])
+        groups[base] = [item["path"] for item in group_items]
+
+    return groups
+
+
+def find_raw_movies(working_folder):
+    """
+    Recursively finds raw movie files (.tif, .ome.tif, .nd2) in a folder.
+
+    Args:
+        working_folder: path to search
+    Returns:
+        dict: mapping from dataset name to path or list of paths
+    """
+    import os
+    import fnmatch
+    from pathlib import Path
+
+    datasets = {}
+
+    for root, dirs, files in os.walk(working_folder):
+        p = Path(root)
+
+        # Check what extensions exist here
+        has_nd2 = list(p.glob("*.nd2"))
+        has_ometif = list(p.glob("*.ome.tif"))
+        # .tif check needs to exclude .ome.tif to be accurate
+        has_tif = [
+            f for f in p.glob("*.tif") if not f.name.endswith(".ome.tif")
+        ]
+
+        found_types = []
+        if has_nd2:
+            found_types.append(".nd2")
+        if has_ometif:
+            found_types.append(".ome.tif")
+        if has_tif:
+            found_types.append(".tif")
+
+        if not found_types:
+            continue
+
+        # Priority: .nd2 > .ome.tif > .tif
+        ext = found_types[0]
+
+        if ext == ".nd2":
+            nd2_files = sorted(fnmatch.filter(os.listdir(root), "*.nd2"))
+            for f in nd2_files:
+                stem = Path(f).stem
+                # Use parent folder name as key if unique, otherwise include stem
+                key = p.name if p.name else stem
+                if len(nd2_files) > 1:
+                    key = f"{p.name}_{stem}"
+                datasets[key] = str(p / f)
+        else:
+            # tif or ome.tif
+            tif_files = sorted([f.name for f in p.glob(f"*{ext}")])
+            groups = get_movie_groups(tif_files, ext)
+            for base, group_paths in groups.items():
+                # Use directory name as key if it's the only group, otherwise use base
+                if len(groups) == 1:
+                    key = p.name
+                else:
+                    key = base
+
+                full_paths = [str(p / fname) for fname in group_paths]
+                datasets[key] = full_paths[0]
+
+    # Natural sort the datasets by key
+    import re
+
+    def natsort_key(s):
+        return [
+            int(t) if t.isdigit() else t.lower() for t in re.split(r"(\d+)", s)
+        ]
+
+    sorted_keys = sorted(datasets.keys(), key=natsort_key)
+    return {k: datasets[k] for k in sorted_keys}

From 6f5e1517390dfa22a1c541542898468a4c0f07da Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 11:05:41 +0200
Subject: [PATCH 02/24] transition raw movie discovery from metaworkflow to
 util

---
 picasso_workflow/metaworkflow.py | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/picasso_workflow/metaworkflow.py b/picasso_workflow/metaworkflow.py
index fbd0dab..94fde8d 100644
--- a/picasso_workflow/metaworkflow.py
+++ b/picasso_workflow/metaworkflow.py
@@ -358,19 +358,11 @@ def parse_source(
 
 
 def find_dnapaint_raw(working_folder):
-    datasets = {}
-    for root, dirs, files in os.walk(working_folder):
-        for file in files:
-            match = re.search(r"_MMStack_Pos(\d+).ome.tif", file)
-            if match is not None:
-                key = os.path.split(root)[-1]
-                datasets[key] = os.path.join(root, file)
-                continue
-            match = re.search(r"_NDTiffStack.tif", file)
-            if match is not None:
-                key = os.path.split(root)[-1]
-                datasets[key] = os.path.join(root, file)
-                continue
+    from picasso_workflow import util
+    from picasso import io
+    
+    datasets = util.find_raw_movies(working_folder)
+    
     dest_file = os.path.join(working_folder, "src_loc.yaml")
     io.save_info(dest_file, [datasets])
     return datasets, dest_file

From 00590069f18c92431423a6930e68c1a057082bfe Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 11:08:01 +0200
Subject: [PATCH 03/24] Adds find files in folder button to gui

---
 picasso_workflow/gui.py | 105 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 100 insertions(+), 5 deletions(-)

diff --git a/picasso_workflow/gui.py b/picasso_workflow/gui.py
index d4b8a0a..1bd67e7 100644
--- a/picasso_workflow/gui.py
+++ b/picasso_workflow/gui.py
@@ -9282,6 +9282,10 @@ def _update_file_buttons(self, workflow_type_index):
             if item.widget():
                 item.widget().deleteLater()
 
+        self.find_files_button = QtWidgets.QPushButton("Find in folder")
+        self.find_files_button.clicked.connect(self.find_dataset_files)
+        self.file_buttons_layout.addWidget(self.find_files_button)
+
         if workflow_type_index == 0:  # Single Workflow
             self.add_files_button = QtWidgets.QPushButton("Add files")
             self.add_files_button.clicked.connect(self.add_files)
@@ -9331,6 +9335,93 @@ def _update_file_buttons(self, workflow_type_index):
             self.file_buttons_layout.addWidget(self.remove_dataset_button)
             self.file_buttons_layout.addWidget(self.clear_tree_button)
 
+    def find_dataset_files(self):
+        """Find dataset files (.tif, .ome.tif, .nd2) in a selected folder."""
+        folder = QtWidgets.QFileDialog.getExistingDirectory(
+            self,
+            "Select Data Folder",
+            "",
+        )
+        if folder:
+            from picasso_workflow.metaworkflow import find_dnapaint_raw
+
+            datasets, _ = find_dnapaint_raw(folder)
+            if datasets:
+                workflow_type_index = self.workflow_type.currentIndex()
+                if workflow_type_index == 0:
+                    # Single workflow
+                    for key, paths in datasets.items():
+                        row = self.files_table.rowCount()
+                        self.files_table.insertRow(row)
+                        self.files_table.setItem(
+                            row, 0, QtWidgets.QTableWidgetItem(key)
+                        )
+                        if isinstance(paths, list):
+                            if len(paths) == 1:
+                                self.files_table.setItem(
+                                    row,
+                                    1,
+                                    QtWidgets.QTableWidgetItem(paths[0]),
+                                )
+                            else:
+                                self.files_table.setItem(
+                                    row,
+                                    1,
+                                    QtWidgets.QTableWidgetItem(repr(paths)),
+                                )
+                        else:
+                            self.files_table.setItem(
+                                row, 1, QtWidgets.QTableWidgetItem(paths)
+                            )
+                else:
+                    # Aggregation / Investigation workflow
+                    if not self.tree_data.get("channels"):
+                        self.tree_data["channels"] = ["ch1"]
+
+                    for key, paths in datasets.items():
+                        # Ensure unique key
+                        unique_key = key
+                        counter = 1
+                        while unique_key in self.tree_data.get("datasets", []):
+                            unique_key = f"{key}_{counter}"
+                            counter += 1
+
+                        if "datasets" not in self.tree_data:
+                            self.tree_data["datasets"] = []
+                        if "conditions" not in self.tree_data:
+                            self.tree_data["conditions"] = {}
+                        if "file_paths" not in self.tree_data:
+                            self.tree_data["file_paths"] = {}
+
+                        self.tree_data["datasets"].append(unique_key)
+                        self.tree_data["conditions"][unique_key] = ""
+                        self.tree_data["file_paths"][unique_key] = {}
+
+                        # Assign to the first channel
+                        target_channel = self.tree_data["channels"][0]
+
+                        if isinstance(paths, list):
+                            if len(paths) == 1:
+                                self.tree_data["file_paths"][unique_key][
+                                    target_channel
+                                ] = paths[0]
+                            else:
+                                self.tree_data["file_paths"][unique_key][
+                                    target_channel
+                                ] = repr(paths)
+                        else:
+                            self.tree_data["file_paths"][unique_key][
+                                target_channel
+                            ] = paths
+
+                    self._populate_tree_from_data()
+            else:
+                QtWidgets.QMessageBox.information(
+                    self,
+                    "No files found",
+                    f"Could not find any supported dataset files in {folder}",
+                )
+
     def _set_widgets_enabled(self, enabled):
         """Enable or disable file and module widgets based on results folder selection."""
         self.workflow_type.setEnabled(enabled)
@@ -9446,13 +9537,17 @@ def on_results_folder_dropped(self, folder):
     def on_template_changed(self, template_name):
         """Load a template"""
         try:
-            template_folder = CONFIG["Templates"][template_name]
-            if template_folder[:2] == 'r"' or template_folder[:2] == "r'":
-                template_folder = template_folder[2:-1]
+            template_path = CONFIG["Templates"][template_name]
+            if template_path[:2] == 'r"' or template_path[:2] == "r'":
+                template_path = template_path[2:-1]
+
+            # If path points to a file, use its directory
+            if template_path.endswith(".py"):
+                template_folder = os.path.dirname(template_path)
+            else:
+                template_folder = template_path
         except KeyError:
             return
-        # # Enable widgets when a folder is selected
-        # self._set_widgets_enabled(True)
 
         # Search for YAML files and load file list
         self._load_yaml_file_list(template_folder)

From 888479b0895b24ce82169845d32fbce25c5c18a0 Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 11:09:21 +0200
Subject: [PATCH 04/24] removes grid and padding from images

---
 picasso_workflow/outpost_modules/render.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/picasso_workflow/outpost_modules/render.py b/picasso_workflow/outpost_modules/render.py
index edb73d1..65c90c0 100644
--- a/picasso_workflow/outpost_modules/render.py
+++ b/picasso_workflow/outpost_modules/render.py
@@ -345,9 +345,7 @@ def plot_scene(
             (bgra.shape[0] * image_px_size + y_offset) / 1000,
         ],
     )
-    ax.set_xlabel("x [µm]")
-    ax.set_ylabel("y [µm]")
-    ax.set_title(title)
+    ax.axis("off")
     if fp is not None:
-        fig.savefig(fp)
+        fig.savefig(fp, bbox_inches="tight", pad_inches=0)
     return fig, ax

From 36e2d46fe6d9c9afbe10060d4a02b5847a85e7c5 Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 11:10:47 +0200
Subject: [PATCH 05/24] adds NumPy scalar type casting

---
 picasso_workflow/confluence.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/picasso_workflow/confluence.py b/picasso_workflow/confluence.py
index 1d16cf8..d6e89db 100644
--- a/picasso_workflow/confluence.py
+++ b/picasso_workflow/confluence.py
@@ -31,9 +31,17 @@ def module_wrapper(self, i, parameters, results, postpone_report=False):
             <ac:rich-text-body>
             <ul>
             """
+        def _format_val(v):
+            if type(v).__module__ == "numpy" and hasattr(v, "item"):
+                try:
+                    return str(v.item())
+                except Exception:
+                    pass
+            return str(v)
+
         for k, v in parameters.items():
             parameter_text += (
-                f"<li>{html.escape(str(k))}: {html.escape(str(v))}</li>"
+                f"<li>{html.escape(str(k))}: {html.escape(_format_val(v))}</li>"
             )
 
         parameter_text += """
@@ -50,7 +58,7 @@ def module_wrapper(self, i, parameters, results, postpone_report=False):
             """
         for k, v in results.items():
             result_text += (
-                f"<li>{html.escape(str(k))}: {html.escape(str(v))}</li>"
+                f"<li>{html.escape(str(k))}: {html.escape(_format_val(v))}</li>"
             )
 
         result_text += """

From 570eceeb523301954a43ccb0ac51dc44b4aac7bd Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 11:12:35 +0200
Subject: [PATCH 06/24] Update confluence.py

- Makes hardware and software section collapsible
- added layout fixes
---
 picasso_workflow/confluence.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/picasso_workflow/confluence.py b/picasso_workflow/confluence.py
index d6e89db..26b322c 100644
--- a/picasso_workflow/confluence.py
+++ b/picasso_workflow/confluence.py
@@ -451,12 +451,17 @@ def analysis_documentation(
         text = f"""
         <ac:layout><ac:layout-section ac:type="single"><ac:layout-cell>
         <p><strong>Module {i:02d}: Analysis Hard- and Software</strong></p>
+        <ac:structured-macro ac:name="expand" ac:schema-version="1">
+        <ac:parameter ac:name="title">Parameters</ac:parameter>
+        <ac:rich-text-body>
         <ul>
         """
         for k, v in results.items():
-            text += f"<li>{k}: {v}</li>"
+            text += f"<li>{html.escape(str(k))}: {html.escape(str(v))}</li>"
         text += """
         </ul>
+        </ac:rich-text-body>
+        </ac:structured-macro>
         </ac:layout-cell></ac:layout-section></ac:layout>
         """
         self.ci.update_page_content(
@@ -4559,7 +4564,7 @@ def filter_locs(
         {result_text}"""
 
         if fp_fig := results.get("fp_fig_before"):
-            text += "<ul><table>"
+            text += "<table>"
             text += "<tr><td><b>Before Filtering</b></td>"
             text += "<td><b>After Filtering</b></td></tr>"
             text += "<tr><td>"
@@ -4583,7 +4588,7 @@ def filter_locs(
                 <ac:image ac:width="350"><ri:attachment
                 ri:filename="{fp_fig}" />
                 </ac:image>"""
-            text += "</td></tr></table></ul>"
+            text += "</td></tr></table>"
 
         text += """
         </ac:layout-cell></ac:layout-section></ac:layout>
@@ -4657,7 +4662,7 @@ def filter_transient_binding(
         """
 
         if fp_fig := results.get("fp_fig_before"):
-            text += "<ul><table>"
+            text += "<table>"
             text += "<tr><td><b>Before Filtering</b></td>"
             text += "<td><b>After Filtering</b></td></tr>"
             text += "<tr><td>"
@@ -4681,7 +4686,7 @@ def filter_transient_binding(
                 <ac:image ac:width="350"><ri:attachment
                 ri:filename="{fp_fig}" />
                 </ac:image>"""
-            text += "</td></tr></table></ul>"
+            text += "</td></tr></table>"
 
         text += """
         </ac:layout-cell></ac:layout-section></ac:layout>

From 1d428791627ab74195d21e46d489d08979691a1a Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 11:32:33 +0200
Subject: [PATCH 07/24] fix: empty agg workflow update

If the aggregation workflow section is present but empty templates should not be loaded in as aggregation workflows
---
 picasso_workflow/gui.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/picasso_workflow/gui.py b/picasso_workflow/gui.py
index 1bd67e7..b7cbb50 100644
--- a/picasso_workflow/gui.py
+++ b/picasso_workflow/gui.py
@@ -9977,8 +9977,10 @@ def search_assignments(statements, variables_dict):
                 # )
 
             # Load aggregation workflow if found
-            if workflow_modules_agg is not None and isinstance(
-                workflow_modules_agg, list
+            if (
+                workflow_modules_agg is not None
+                and isinstance(workflow_modules_agg, list)
+                and len(workflow_modules_agg) > 0
             ):
                 self._populate_workflow_from_definition(
                     workflow_modules_agg,
@@ -10119,8 +10121,10 @@ def _load_workflow_definition(self, folder):
                 )
 
             # Load aggregation workflow if present
-            if workflow_modules_agg is not None and isinstance(
-                workflow_modules_agg, list
+            if (
+                workflow_modules_agg is not None
+                and isinstance(workflow_modules_agg, list)
+                and len(workflow_modules_agg) > 0
             ):
                 self._populate_workflow_from_definition(
                     workflow_modules_agg,

From 71730a762ed5a4da4cae6a9f5883816a4ee262ce Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 12:55:44 +0200
Subject: [PATCH 08/24] feat: density based image area selection for render
 function

---
 picasso_workflow/analyse.py                | 223 ++++++++++++++++++---
 picasso_workflow/confluence.py             | 120 ++++++++---
 picasso_workflow/gui.py                    |  22 +-
 picasso_workflow/outpost_modules/render.py |   2 +-
 picasso_workflow/tests/test_confluence.py  |  40 +++-
 5 files changed, 347 insertions(+), 60 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index dca6293..4b35c17 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -7,6 +7,7 @@
 """
 from picasso import lib, io, localize, gausslq, postprocess, clusterer
 from picasso import aim, spinna
+
 # from picasso_workflow.outpost_modules import g5m
 from picasso import g5m
 from picasso import __version__ as picassoversion
@@ -50,6 +51,7 @@
     postprocess,
     spinna,
 )
+
 # from picasso_workflow.outpost_modules import g5m
 from scipy.ndimage import label
 from scipy.spatial import KDTree, distance
@@ -414,14 +416,16 @@ def camera_info(self):
                             "Micro-Manager Metadata"
                         ].get(f"{cam_name}-{category}")
                         cat_vals += f"{category}: {category_value}; "
-                        
+
                         if category_value in sensitivity:
                             sensitivity = sensitivity[category_value]
                         elif str(category_value) in sensitivity:
                             sensitivity = sensitivity[str(category_value)]
                         else:
                             try:
-                                sensitivity = sensitivity.get(int(category_value), {})
+                                sensitivity = sensitivity.get(
+                                    int(category_value), {}
+                                )
                             except (ValueError, TypeError):
                                 sensitivity = {}
                     if isinstance(sensitivity, dict):
@@ -440,8 +444,7 @@ def camera_info(self):
                 }
                 for category in cam_config.get("Sensitivity Categories"):
                     category_key = f"{cam_name}-{category}"
-                    
-                    
+
                     category_value = self.info[0].get(category_key)
                 self.analysis_config["camera_info"] = camera_info
                 return camera_info
@@ -860,18 +863,27 @@ def load_dataset_movie(self, i, parameters, results):
                     # sensitivity starts being a dict, and ends as a value
                     cat_vals = ""
                     for category in cam_config.get("Sensitivity Categories"):
-                        category_value = self.info[0].get(f"{cam_name}-{category}")
-                        if category_value is None and "Micro-Manager Metadata" in self.info[0]:
-                            category_value = self.info[0]["Micro-Manager Metadata"].get(f"{cam_name}-{category}")
+                        category_value = self.info[0].get(
+                            f"{cam_name}-{category}"
+                        )
+                        if (
+                            category_value is None
+                            and "Micro-Manager Metadata" in self.info[0]
+                        ):
+                            category_value = self.info[0][
+                                "Micro-Manager Metadata"
+                            ].get(f"{cam_name}-{category}")
                         cat_vals += f"{category}: {category_value}; "
-                        
+
                         if category_value in sensitivity:
                             sensitivity = sensitivity[category_value]
                         elif str(category_value) in sensitivity:
                             sensitivity = sensitivity[str(category_value)]
                         else:
                             try:
-                                sensitivity = sensitivity.get(int(category_value), {})
+                                sensitivity = sensitivity.get(
+                                    int(category_value), {}
+                                )
                             except (ValueError, TypeError):
                                 sensitivity = {}
                     if isinstance(sensitivity, dict):
@@ -1272,13 +1284,17 @@ def identify(self, i, parameters, results):
         """
         # auto-detect net grad if required:
         if (autograd_pars := parameters.get("auto_netgrad")) is not None:
-            if "filename" in autograd_pars.keys() and autograd_pars["filename"]:
+            if (
+                "filename" in autograd_pars.keys()
+                and autograd_pars["filename"]
+            ):
                 autograd_pars["filename"] = os.path.join(
                     results["folder"], autograd_pars["filename"]
                 )
             else:
                 autograd_pars["filename"] = os.path.join(
-                    results["folder"], "auto_identification.png")
+                    results["folder"], "auto_identification.png"
+                )
 
             potential_pars = [
                 "box_size",
@@ -1725,6 +1741,8 @@ def render(self, i, parameters, results):
                         filepath to full FOV rendering
                     fp_scene_ctrmass : str
                         filepath to center of mass zoom rendering (conditional, only if ctrmass_fov_nm provided)
+                    fp_scene_tiles : list of lists of str
+                        filepaths to the 5x5 tiled renderings
         """
         pixelsize = self.pixelsize
         rcode = generate_random_code(6)
@@ -1740,28 +1758,183 @@ def render(self, i, parameters, results):
 
         # render whole field of view
         fullfov_pixelsize = parameters.get("fullfov_pixelsize", pixelsize)
+
+        # Normalize localizations to a list
+        locs_list = (
+            render_locs if isinstance(render_locs, list) else [render_locs]
+        )
+
+        # Calculate full FOV boundaries in camera pixels
+        x_min = min([lcs["x"].min() for lcs in locs_list])
+        x_max = max([lcs["x"].max() for lcs in locs_list])
+        y_min = min([lcs["y"].min() for lcs in locs_list])
+        y_max = max([lcs["y"].max() for lcs in locs_list])
+
+        # Density-driven ROI selection (Alternative A)
+        selected_rois = (
+            []
+        )  # list of (x_ctr, y_ctr, tile_x_min, tile_x_max, tile_y_min, tile_y_max)
+        roi_files = []
+
+        if parameters.get("generate_active_rois", True):
+            all_x = np.concatenate([lcs["x"] for lcs in locs_list])
+            all_y = np.concatenate([lcs["y"] for lcs in locs_list])
+
+            roi_size = parameters.get("ctrmass_fov_nm", 10000.0) / pixelsize
+            if roi_size <= 0:
+                roi_size = 100.0  # fallback
+
+            # Finer grid peak finding (bin size = roi_size / 2)
+            grid_step = roi_size / 2.0
+            bin_edges_x = np.arange(x_min, x_max + grid_step, grid_step)
+            bin_edges_y = np.arange(y_min, y_max + grid_step, grid_step)
+
+            hist, x_edges, y_edges = np.histogram2d(
+                all_x, all_y, bins=[bin_edges_x, bin_edges_y]
+            )
+
+            candidates = []
+            for ix in range(hist.shape[0]):
+                for iy in range(hist.shape[1]):
+                    count = hist[ix, iy]
+                    if count > 0:
+                        center_x = (x_edges[ix] + x_edges[ix + 1]) / 2
+                        center_y = (y_edges[iy] + y_edges[iy + 1]) / 2
+                        candidates.append((count, center_x, center_y))
+
+            candidates.sort(key=lambda item: item[0], reverse=True)
+
+            n_rois = parameters.get("n_active_rois", 5)
+            roi_centers = []
+            min_distance = roi_size  # non-overlapping
+
+            for count, cx, cy in candidates:
+                if len(roi_centers) >= n_rois:
+                    break
+                too_close = False
+                for sx, sy in roi_centers:
+                    dist = np.sqrt((cx - sx) ** 2 + (cy - sy) ** 2)
+                    if dist < min_distance:
+                        too_close = True
+                        break
+                if not too_close:
+                    roi_centers.append((cx, cy))
+
+            # Form ROIs and render them
+            tile_pixelsize = parameters.get("ctrmass_pixelsize", pixelsize)
+            for idx, (cx, cy) in enumerate(roi_centers):
+                tile_x_min = cx - roi_size / 2
+                tile_x_max = cx + roi_size / 2
+                tile_y_min = cy - roi_size / 2
+                tile_y_max = cy + roi_size / 2
+
+                selected_rois.append(
+                    (cx, cy, tile_x_min, tile_x_max, tile_y_min, tile_y_max)
+                )
+
+                tile_kwargs = {
+                    "oversampling": pixelsize / tile_pixelsize,
+                    "viewport": [
+                        (tile_y_min, tile_x_min),
+                        (tile_y_max, tile_x_max),
+                    ],
+                    "blur_method": parameters.get("ctrmass_blur_method"),
+                    "min_blur_width": parameters.get(
+                        "ctrmass_min_blur_width", 0
+                    ),
+                    "ang": parameters.get("ctrmass_ang"),
+                }
+
+                roi_fp = os.path.join(
+                    results["folder"], f"locs_active_roi_{idx + 1}_{rcode}.png"
+                )
+                render.plot_scene(
+                    render_locs,
+                    tile_pixelsize,
+                    pixelsize,
+                    fp=roi_fp,
+                    render_kwargs=tile_kwargs,
+                )
+                roi_files.append(roi_fp)
+
+        results["fp_scene_rois"] = roi_files
+
+        # Render whole field of view (overview) and draw outlines
         results["fp_scene_fullfov"] = os.path.join(
             results["folder"], f"locs_fullfov_{rcode}.png"
         )
-        render.plot_scene(
+
+        fig_overview, ax_overview = render.plot_scene(
             render_locs,
             fullfov_pixelsize,
             pixelsize,
-            fp=results["fp_scene_fullfov"],
+            fp=None,
+        )
+
+        # Draw outlines of selected ROIs if present
+        if selected_rois:
+            import matplotlib.patches as patches
+            import matplotlib.pyplot as plt
+
+            for idx, (_, _, t_xmin, t_xmax, t_ymin, t_ymax) in enumerate(
+                selected_rois
+            ):
+                x_min_um = (t_xmin * pixelsize) / 1000.0
+                x_max_um = (t_xmax * pixelsize) / 1000.0
+                y_min_um = (t_ymin * pixelsize) / 1000.0
+                y_max_um = (t_ymax * pixelsize) / 1000.0
+
+                width_um = x_max_um - x_min_um
+                height_um = y_max_um - y_min_um
+
+                rect = patches.Rectangle(
+                    (x_min_um, y_min_um),
+                    width_um,
+                    height_um,
+                    linewidth=1.5,
+                    edgecolor="red",
+                    facecolor="none",
+                )
+                ax_overview.add_patch(rect)
+
+                # Add text label for each active site
+                ax_overview.text(
+                    x_min_um + 0.03 * width_um,
+                    y_max_um - 0.12 * height_um,
+                    str(idx + 1),
+                    color="red",
+                    fontsize=10,
+                    fontweight="bold",
+                    bbox=dict(
+                        facecolor="black",
+                        alpha=0.6,
+                        boxstyle="round,pad=0.2",
+                        edgecolor="none",
+                    ),
+                )
+
+        import matplotlib.pyplot as plt
+
+        fig_overview.savefig(
+            results["fp_scene_fullfov"], bbox_inches="tight", pad_inches=0
         )
+        plt.close(fig_overview)
 
         # render zoom into the center of mass
         if parameters.get("ctrmass_fov_nm"):
             ctrmass_pixelsize = parameters.get("ctrmass_pixelsize", pixelsize)
             fov_half = parameters.get("ctrmass_fov_nm") / 2
-            x_min = x_mean - fov_half / pixelsize
-            x_max = x_mean + fov_half / pixelsize
-            y_min = y_mean - fov_half / pixelsize
-            y_max = y_mean + fov_half / pixelsize
+            x_min_zoom = x_mean - fov_half / pixelsize
+            x_max_zoom = x_mean + fov_half / pixelsize
+            y_min_zoom = y_mean - fov_half / pixelsize
+            y_max_zoom = y_mean + fov_half / pixelsize
 
             render_kwargs = {
                 "oversampling": pixelsize / ctrmass_pixelsize,
-                "viewport": [(y_min, x_min), (y_max, x_max)],
+                "viewport": [
+                    (y_min_zoom, x_min_zoom),
+                    (y_max_zoom, x_max_zoom),
+                ],
                 "blur_method": parameters.get("ctrmass_blur_method"),
                 "min_blur_width": parameters.get("ctrmass_min_blur_width", 0),
                 "ang": parameters.get("ctrmass_ang"),
@@ -1775,9 +1948,8 @@ def render(self, i, parameters, results):
                 pixelsize,
                 fp=results["fp_scene_ctrmass"],
                 render_kwargs=render_kwargs,
-                # x_offset=x_min * pixelsize,
-                # y_offset=y_min * pixelsize,
             )
+
         return parameters, results
 
     #    @profile_resource_usage
@@ -4441,7 +4613,8 @@ def dbscan(self, i, parameters, results):
         min_locs = parameters["min_locs"]
         # label locs according to clusters
         self.locs = clusterer.dbscan(
-            self.locs, radius, min_samples, min_locs, pixelsize)
+            self.locs, radius, min_samples, min_locs, pixelsize
+        )
         dbscan_info = {
             "Generated by": "Picasso DBSCAN",
             "Radius": radius,
@@ -6555,8 +6728,12 @@ def gaussian_mixture_cluster(self, i, parameters, results):
             results["folder"], "subcluster_test.png"
         )
         # g5m.test_subclustering(center_locs, results["fp_fig_subclustering"])
-        clustered_nevents, sparse_nevents = clusterer.test_subclustering(center_locs, self.info)
-        lib.plot_subclustering_check(clustered_nevents, sparse_nevents, results["fp_fig_subclustering"])
+        clustered_nevents, sparse_nevents = clusterer.test_subclustering(
+            center_locs, self.info
+        )
+        lib.plot_subclustering_check(
+            clustered_nevents, sparse_nevents, results["fp_fig_subclustering"]
+        )
 
         results["n_locs_in"] = len(self.locs)
         results["n_locs_clustered"] = len(clustered_locs)
diff --git a/picasso_workflow/confluence.py b/picasso_workflow/confluence.py
index 26b322c..bee6bde 100644
--- a/picasso_workflow/confluence.py
+++ b/picasso_workflow/confluence.py
@@ -1111,6 +1111,8 @@ def render(
                         filepath to full FOV rendering
                     fp_scene_ctrmass : str
                         filepath to center of mass zoom rendering (conditional, only if ctrmass_fov_nm provided)
+                    fp_scene_tiles : list of lists of str
+                        filepaths to the 5x5 tiled renderings
         """
         logger.debug("Reporting render.")
         text = f"""
@@ -1124,38 +1126,102 @@ def render(
         {parameter_text}
         {result_text}
         """
-        fig_fps = []
-        titles = []
-        if fp_fig := results.get("fp_scene_fullfov"):
-            fig_fps.append(fp_fig)
-            titles.append("Localizations in whole Field of View")
-        if fp_fig := results.get("fp_scene_ctrmass"):
-            fig_fps.append(fp_fig)
-            titles.append("Localizations in Zoom-In")
-
-        if len(fig_fps) > 1:
-            fn_figs = []
-            for fp in fig_fps:
+        
+        rois = results.get("fp_scene_rois", [])
+        tiles = results.get("fp_scene_tiles", [])
+        if rois:
+            text += "<table><tr>"
+            
+            # Left column: Overview and Zoom-In
+            text += "<td style='vertical-align: top; padding-right: 20px;'>"
+            if fp_fullfov := results.get("fp_scene_fullfov"):
                 try:
-                    self.ci.upload_attachment(self.report_page_id, fp)
+                    self.ci.upload_attachment(self.report_page_id, fp_fullfov)
                 except ConfluenceInterfaceError:
                     pass
-                fn_figs.append(os.path.split(fp)[1])
-
-            text += "<table><tr>"
-            for tit in titles:
-                text += f"<td><b>{tit}</b></td>"
-            text += "</tr>"
-            text += "<tr>"
-            for fn in fn_figs:
+                fn_fullfov = os.path.split(fp_fullfov)[1]
                 text += f"""
-                    <td>
-                          <ac:image ac:height="350">
-                          <ri:attachment ri:filename="{fn}" />
-                          </ac:image>
-                    </td>"""
-            text += "</tr>"
+                    <p><b>Overview with Density-driven ROIs</b></p>
+                    <ac:image ac:height="350">
+                        <ri:attachment ri:filename="{fn_fullfov}" />
+                    </ac:image>
+                """
+            if fp_ctrmass := results.get("fp_scene_ctrmass"):
+                try:
+                    self.ci.upload_attachment(self.report_page_id, fp_ctrmass)
+                except ConfluenceInterfaceError:
+                    pass
+                fn_ctrmass = os.path.split(fp_ctrmass)[1]
+                text += f"""
+                    <p><b>Localizations in Zoom-In</b></p>
+                    <ac:image ac:height="350">
+                        <ri:attachment ri:filename="{fn_ctrmass}" />
+                    </ac:image>
+                """
+            text += "</td>"
+            
+            # Right column: Active Sites ROIs layout in a 2-column grid
+            text += "<td style='vertical-align: top;'>"
+            text += "<p><b>Density-driven Active Sites</b></p>"
+            text += "<table style='border-collapse: collapse; border: none;'>"
+            for idx in range(0, len(rois), 2):
+                text += "<tr>"
+                for sub_idx in range(idx, min(idx + 2, len(rois))):
+                    fp_roi = rois[sub_idx]
+                    try:
+                        self.ci.upload_attachment(self.report_page_id, fp_roi)
+                    except ConfluenceInterfaceError:
+                        pass
+                    fn_roi = os.path.split(fp_roi)[1]
+                    text += f"""
+                        <td style='border: 1px solid #ddd; padding: 6px; text-align: center;'>
+                            <ac:image ac:height="150">
+                                <ri:attachment ri:filename="{fn_roi}" />
+                            </ac:image>
+                            <br/><b>Site {sub_idx + 1}</b>
+                        </td>"""
+                # If odd number of ROIs and this is the last row, add an empty cell for layout alignment
+                if len(rois) % 2 != 0 and idx + 1 >= len(rois):
+                    text += "<td style='border: none;'></td>"
+                text += "</tr>"
             text += "</table>"
+            text += "</td>"
+            text += "</tr></table>"
+
+        else:
+            # Fallback to standard layout
+            fig_fps = []
+            titles_list = []
+            if fp_fig := results.get("fp_scene_fullfov"):
+                fig_fps.append(fp_fig)
+                titles_list.append("Localizations in whole Field of View")
+            if fp_fig := results.get("fp_scene_ctrmass"):
+                fig_fps.append(fp_fig)
+                titles_list.append("Localizations in Zoom-In")
+
+            if len(fig_fps) >= 1:
+                fn_figs = []
+                for fp in fig_fps:
+                    try:
+                        self.ci.upload_attachment(self.report_page_id, fp)
+                    except ConfluenceInterfaceError:
+                        pass
+                    fn_figs.append(os.path.split(fp)[1])
+
+                text += "<table><tr>"
+                for tit in titles_list:
+                    text += f"<td><b>{tit}</b></td>"
+                text += "</tr>"
+                text += "<tr>"
+                for fn in fn_figs:
+                    text += f"""
+                        <td>
+                              <ac:image ac:height="350">
+                              <ri:attachment ri:filename="{fn}" />
+                              </ac:image>
+                        </td>"""
+                text += "</tr>"
+                text += "</table>"
 
         text += """
         </ac:layout-cell></ac:layout-section></ac:layout>
diff --git a/picasso_workflow/gui.py b/picasso_workflow/gui.py
index b7cbb50..efe1ead 100644
--- a/picasso_workflow/gui.py
+++ b/picasso_workflow/gui.py
@@ -1332,6 +1332,20 @@ def render(self):
                 "description": "angle",
                 "required": False,
             },
+            "generate_active_rois": {
+                "type": "bool",
+                "description": "Whether to generate density-driven active site zoom-in previews next to the overview image",
+                "default": True,
+                "required": False,
+            },
+            "n_active_rois": {
+                "type": "int",
+                "description": "Number of high-density active sites (ROIs) to generate",
+                "min": 1,
+                "max": 25,
+                "default": 3,
+                "required": False,
+            },
         }
 
         results_spec = {
@@ -1361,6 +1375,10 @@ def render(self):
                 "description": "filepath to center of mass zoom rendering \
                     (conditional, only if ctrmass_fov_nm provided)",
             },
+            "fp_scene_rois": {
+                "type": "list",
+                "description": "list of filepaths to the density-driven active site Zoom-In previews",
+            },
         }
 
         return parameters_spec, results_spec
@@ -8425,9 +8443,7 @@ def __init__(self):
         self.autodetect_datasets_checkbox.stateChanged.connect(
             self._on_autodetect_toggled
         )
-        self.files_box.addWidget(
-            self.autodetect_datasets_checkbox, 0, 0, 1, 3
-        )
+        self.files_box.addWidget(self.autodetect_datasets_checkbox, 0, 0, 1, 3)
 
         # Create button container for dynamic button layout
         self.file_buttons_widget = QtWidgets.QWidget()
diff --git a/picasso_workflow/outpost_modules/render.py b/picasso_workflow/outpost_modules/render.py
index 65c90c0..d1271bb 100644
--- a/picasso_workflow/outpost_modules/render.py
+++ b/picasso_workflow/outpost_modules/render.py
@@ -224,7 +224,7 @@ def scale_contrast(images):
                 if _.max() != 0  # the maximum value in image is 0.0
             ]
         )
-        / 4
+        / 40
     )
     # upper = INITIAL_REL_MAXIMUM * max_
 
diff --git a/picasso_workflow/tests/test_confluence.py b/picasso_workflow/tests/test_confluence.py
index e6299ea..be09bcf 100644
--- a/picasso_workflow/tests/test_confluence.py
+++ b/picasso_workflow/tests/test_confluence.py
@@ -732,12 +732,40 @@ def random_val(self):
     # @unittest.skip("")
     def render(self):
         parameters = {}
-        results = {
-            "start time": "now",
-            "duration": 4.12,
-            "success": True,
-        }
-        self.cr.render(0, parameters, results)
+        import tempfile
+        import shutil
+        import os
+        temp_dir = tempfile.mkdtemp()
+        try:
+            fp_fullfov = os.path.join(temp_dir, "fullfov.png")
+            with open(fp_fullfov, "wb") as f:
+                f.write(b"PNG mock data")
+            
+            fp_ctrmass = os.path.join(temp_dir, "ctrmass.png")
+            with open(fp_ctrmass, "wb") as f:
+                f.write(b"PNG mock data")
+                
+            fp_scene_rois = []
+            for i in range(5):
+                fp_roi = os.path.join(temp_dir, f"roi_{i+1}.png")
+                with open(fp_roi, "wb") as f:
+                    f.write(b"PNG mock data")
+                fp_scene_rois.append(fp_roi)
+                
+            results = {
+                "start time": "now",
+                "duration": 4.12,
+                "success": True,
+                "fp_scene_fullfov": fp_fullfov,
+                "fp_scene_ctrmass": fp_ctrmass,
+                "fp_scene_rois": fp_scene_rois,
+            }
+            self.cr.render(0, parameters, results)
+        finally:
+            try:
+                shutil.rmtree(temp_dir)
+            except Exception:
+                pass
 
         # clean up
         pgid, pgtitle = self.cr.ci.get_page_properties(

From 2a76d1376601f7cb1967ed71d90019cd560e4fb0 Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 13:11:54 +0200
Subject: [PATCH 09/24] fix: resolve coordinator init param mismatch

`base_page` was being mapped to `confluence_username`

added explicit keyword arguments to prevent this
---
 picasso_workflow/metaworkflow.py | 69 ++++++++++++++++----------------
 1 file changed, 35 insertions(+), 34 deletions(-)

diff --git a/picasso_workflow/metaworkflow.py b/picasso_workflow/metaworkflow.py
index 94fde8d..4095abd 100644
--- a/picasso_workflow/metaworkflow.py
+++ b/picasso_workflow/metaworkflow.py
@@ -544,17 +544,17 @@ def __init__(
         self.analysis_name = os.path.split(working_folder)[-1]
 
         super().__init__(
-            analysis_name,
-            working_folder,
-            confluence_url,
-            confluence_space,
-            confluence_token,
-            base_page,
-            confluence_username,
-            dest_machine,
-            always_save,
-            profile_space,
-            profile_basepage,
+            analysis_name=analysis_name,
+            working_folder=working_folder,
+            confluence_url=confluence_url,
+            confluence_space=confluence_space,
+            confluence_token=confluence_token,
+            confluence_username=confluence_username,
+            base_page=base_page,
+            dest_machine=dest_machine,
+            always_save=always_save,
+            profile_space=profile_space,
+            profile_basepage=profile_basepage,
         )
 
     def prepare_analysis(
@@ -675,17 +675,18 @@ def __init__(
         self.analysis_name = analysis_name
 
         super().__init__(
-            analysis_name,
-            working_folder,
-            confluence_url,
-            confluence_space,
-            confluence_token,
-            confluence_username,
-            base_page,
-            dest_machine,
-            always_save,
-            profile_space,
-            profile_basepage,
+            analysis_name=analysis_name,
+            working_folder=working_folder,
+            confluence_url=confluence_url,
+            confluence_space=confluence_space,
+            confluence_token=confluence_token,
+            confluence_username=confluence_username,
+            base_page=base_page,
+            investigation_description=investigation_description,
+            dest_machine=dest_machine,
+            always_save=always_save,
+            profile_space=profile_space,
+            profile_basepage=profile_basepage,
         )
 
     def prepare_analysis(
@@ -836,18 +837,18 @@ def __init__(
         self.analysis_name = analysis_name
 
         super().__init__(
-            analysis_name,
-            working_folder,
-            confluence_url,
-            confluence_space,
-            confluence_token,
-            base_page,
-            confluence_username,
-            investigation_description,
-            dest_machine,
-            always_save,
-            profile_space,
-            profile_basepage,
+            analysis_name=analysis_name,
+            working_folder=working_folder,
+            confluence_url=confluence_url,
+            confluence_space=confluence_space,
+            confluence_token=confluence_token,
+            confluence_username=confluence_username,
+            base_page=base_page,
+            investigation_description=investigation_description,
+            dest_machine=dest_machine,
+            always_save=always_save,
+            profile_space=profile_space,
+            profile_basepage=profile_basepage,
         )
 
     def prepare_sglcell_analysis(self, get_workflow_modules):

From fa961d8659a42e5873bfe756a9e1a5871f68481d Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 13:42:40 +0200
Subject: [PATCH 10/24] fix: check if data is 3d in ctrmass_ang

- When rendering zoom in images the render function now checks if the data is 3D so that the ctrmass_ang is only applied to 3d data as it otherwise crashes on 2D data.
---
 picasso_workflow/analyse.py | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 4b35c17..503c132 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1756,6 +1756,22 @@ def render(self, i, parameters, results):
             x_mean = np.mean(self.locs["x"])
             y_mean = np.mean(self.locs["y"])
 
+        # Check if the dataset is 3D (has a 'z' column) to prevent rotation KeyErrors in 2D
+        def check_has_z(locs):
+            if isinstance(locs, list):
+                if not locs:
+                    return False
+                locs = locs[0]
+            try:
+                return "z" in locs.dtype.names
+            except AttributeError:
+                try:
+                    return "z" in locs.columns
+                except (AttributeError, TypeError):
+                    return False
+        
+        has_z = check_has_z(render_locs)
+
         # render whole field of view
         fullfov_pixelsize = parameters.get("fullfov_pixelsize", pixelsize)
 
@@ -1803,8 +1819,9 @@ def render(self, i, parameters, results):
                         candidates.append((count, center_x, center_y))
 
             candidates.sort(key=lambda item: item[0], reverse=True)
-
-            n_rois = parameters.get("n_active_rois", 5)
+            n_rois = parameters.get("n_active_rois")
+            if n_rois is None:
+                n_rois = 3
             roi_centers = []
             min_distance = roi_size  # non-overlapping
 
@@ -1842,8 +1859,9 @@ def render(self, i, parameters, results):
                     "min_blur_width": parameters.get(
                         "ctrmass_min_blur_width", 0
                     ),
-                    "ang": parameters.get("ctrmass_ang"),
                 }
+                if has_z and parameters.get("ctrmass_ang") is not None:
+                    tile_kwargs["ang"] = parameters.get("ctrmass_ang")
 
                 roi_fp = os.path.join(
                     results["folder"], f"locs_active_roi_{idx + 1}_{rcode}.png"
@@ -1937,8 +1955,9 @@ def render(self, i, parameters, results):
                 ],
                 "blur_method": parameters.get("ctrmass_blur_method"),
                 "min_blur_width": parameters.get("ctrmass_min_blur_width", 0),
-                "ang": parameters.get("ctrmass_ang"),
             }
+            if has_z and parameters.get("ctrmass_ang") is not None:
+                render_kwargs["ang"] = parameters.get("ctrmass_ang")
             results["fp_scene_ctrmass"] = os.path.join(
                 results["folder"], f"locs_ctrmass_{rcode}.png"
             )

From e2fab23ca2be31a72951a9cb626dfc1d9b262293 Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 13:59:31 +0200
Subject: [PATCH 11/24] added colormaps for render images

---
 picasso_workflow/analyse.py | 6 ++++++
 picasso_workflow/gui.py     | 7 +++++++
 2 files changed, 13 insertions(+)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 503c132..1fcc37d 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1771,6 +1771,9 @@ def check_has_z(locs):
                     return False
         
         has_z = check_has_z(render_locs)
+        
+        # Read colormap choice (default to magma)
+        cmap_choice = parameters.get("colormap", "magma")
 
         # render whole field of view
         fullfov_pixelsize = parameters.get("fullfov_pixelsize", pixelsize)
@@ -1859,6 +1862,7 @@ def check_has_z(locs):
                     "min_blur_width": parameters.get(
                         "ctrmass_min_blur_width", 0
                     ),
+                    "cmap": cmap_choice,
                 }
                 if has_z and parameters.get("ctrmass_ang") is not None:
                     tile_kwargs["ang"] = parameters.get("ctrmass_ang")
@@ -1887,6 +1891,7 @@ def check_has_z(locs):
             fullfov_pixelsize,
             pixelsize,
             fp=None,
+            render_kwargs={"cmap": cmap_choice},
         )
 
         # Draw outlines of selected ROIs if present
@@ -1955,6 +1960,7 @@ def check_has_z(locs):
                 ],
                 "blur_method": parameters.get("ctrmass_blur_method"),
                 "min_blur_width": parameters.get("ctrmass_min_blur_width", 0),
+                "cmap": cmap_choice,
             }
             if has_z and parameters.get("ctrmass_ang") is not None:
                 render_kwargs["ang"] = parameters.get("ctrmass_ang")
diff --git a/picasso_workflow/gui.py b/picasso_workflow/gui.py
index efe1ead..b48ecff 100644
--- a/picasso_workflow/gui.py
+++ b/picasso_workflow/gui.py
@@ -1346,6 +1346,13 @@ def render(self):
                 "default": 3,
                 "required": False,
             },
+            "colormap": {
+                "type": "str",
+                "description": "Colormap of the generated images",
+                "options": ["magma", "hot", "inferno", "viridis", "gray"],
+                "default": "magma",
+                "required": False,
+            },
         }
 
         results_spec = {

From 1c1d1cd8ecc615c3e6d820a984042537f409aae4 Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 15:23:45 +0200
Subject: [PATCH 12/24] fix: passes cmap on to render

---
 picasso_workflow/outpost_modules/render.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/picasso_workflow/outpost_modules/render.py b/picasso_workflow/outpost_modules/render.py
index d1271bb..03cd94c 100644
--- a/picasso_workflow/outpost_modules/render.py
+++ b/picasso_workflow/outpost_modules/render.py
@@ -85,7 +85,11 @@ def render_single_channel(kwargs, locs, n_group_colors=8, cmap="magma"):
         group_colors = get_group_color(locs, n_group_colors)
         locs = [locs[group_colors == _] for _ in range(n_group_colors)]
         return render_multi_channel(kwargs, locs=locs)
-    n_locs, image = render.render(locs, **kwargs)
+
+    render_args = kwargs.copy()
+    render_args.pop("cmap", None)
+    render_args.pop("n_group_colors", None)
+    n_locs, image = render.render(locs, **render_args)
 
     # adjust contrast and convert to 8 bits
     image = scale_contrast([image])[0]
@@ -150,13 +154,16 @@ def render_multi_channel(
         int(np.ceil(kwargs["oversampling"] * (y_max - y_min))),
     )
     # if single channel is rendered
+    render_args = kwargs.copy()
+    render_args.pop("cmap", None)
+    render_args.pop("n_group_colors", None)
     if len(locs) == 1:
-        renderings = [render.render(_, **kwargs) for _ in locs]
+        renderings = [render.render(_, **render_args) for _ in locs]
     else:
         renderings = [
-            render.render(_, **kwargs) for i, _ in enumerate(locs)
+            render.render(_, **render_args) for i, _ in enumerate(locs)
         ]  # renders only channels that are checked in dataset dialog
-    # renderings = [render.render(_, **kwargs) for _ in locs]
+    # renderings = [render.render(_, **render_args) for _ in locs]
     # n_locs = sum([_[0] for _ in renderings])
     image = np.array([_[1] for _ in renderings])
 

From 2451b7b4671c5b176d91abb6c476d4108dfe77a4 Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 15:55:56 +0200
Subject: [PATCH 13/24] Flip y axis of images to be in line with picasso

---
 picasso_workflow/analyse.py                | 2 +-
 picasso_workflow/outpost_modules/render.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 1fcc37d..4ed130d 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1923,7 +1923,7 @@ def check_has_z(locs):
                 # Add text label for each active site
                 ax_overview.text(
                     x_min_um + 0.03 * width_um,
-                    y_max_um - 0.12 * height_um,
+                    y_min_um + 0.12 * height_um,
                     str(idx + 1),
                     color="red",
                     fontsize=10,
diff --git a/picasso_workflow/outpost_modules/render.py b/picasso_workflow/outpost_modules/render.py
index 03cd94c..8b54571 100644
--- a/picasso_workflow/outpost_modules/render.py
+++ b/picasso_workflow/outpost_modules/render.py
@@ -344,12 +344,12 @@ def plot_scene(
     ax.imshow(
         bgra,
         aspect="equal",
-        origin="lower",
+        origin="upper",
         extent=[
             x_offset / 1000,
             (bgra.shape[1] * image_px_size + x_offset) / 1000,
-            y_offset / 1000,
             (bgra.shape[0] * image_px_size + y_offset) / 1000,
+            y_offset / 1000,
         ],
     )
     ax.axis("off")

From d5e6a94cb1cca26c7fd24c2a7025e8958578cfe7 Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 16:58:24 +0200
Subject: [PATCH 14/24] fix: makes sure that density based image areas stay
 within range

---
 picasso_workflow/analyse.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 4ed130d..cfa6881 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1831,6 +1831,18 @@ def check_has_z(locs):
             for count, cx, cy in candidates:
                 if len(roi_centers) >= n_rois:
                     break
+
+                # Shift ROI center if it would place the ROI viewport boundary outside the image area
+                if (x_max - x_min) >= roi_size:
+                    cx = np.clip(cx, x_min + roi_size / 2.0, x_max - roi_size / 2.0)
+                else:
+                    cx = (x_min + x_max) / 2.0
+
+                if (y_max - y_min) >= roi_size:
+                    cy = np.clip(cy, y_min + roi_size / 2.0, y_max - roi_size / 2.0)
+                else:
+                    cy = (y_min + y_max) / 2.0
+
                 too_close = False
                 for sx, sy in roi_centers:
                     dist = np.sqrt((cx - sx) ** 2 + (cy - sy) ** 2)

From 56625c92a5cb79bc102c23041bce10fbf54229fd Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 17:05:19 +0200
Subject: [PATCH 15/24] Saves overview image without outlines

---
 picasso_workflow/analyse.py | 8 ++++++++
 picasso_workflow/gui.py     | 4 ++++
 2 files changed, 12 insertions(+)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index cfa6881..87b62ce 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1906,6 +1906,14 @@ def check_has_z(locs):
             render_kwargs={"cmap": cmap_choice},
         )
 
+        # Save unmarked copy of the overview image
+        results["fp_scene_fullfov_unmarked"] = os.path.join(
+            results["folder"], f"locs_fullfov_unmarked_{rcode}.png"
+        )
+        fig_overview.savefig(
+            results["fp_scene_fullfov_unmarked"], bbox_inches="tight", pad_inches=0
+        )
+
         # Draw outlines of selected ROIs if present
         if selected_rois:
             import matplotlib.patches as patches
diff --git a/picasso_workflow/gui.py b/picasso_workflow/gui.py
index b48ecff..0ad67d3 100644
--- a/picasso_workflow/gui.py
+++ b/picasso_workflow/gui.py
@@ -1377,6 +1377,10 @@ def render(self):
                 "type": "str",
                 "description": "filepath to full FOV rendering",
             },
+            "fp_scene_fullfov_unmarked": {
+                "type": "str",
+                "description": "filepath to full FOV rendering without outlines",
+            },
             "fp_scene_ctrmass": {
                 "type": "str",
                 "description": "filepath to center of mass zoom rendering \

From 0b6c532e768371ea7d5b004924c215ac764a9551 Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 19 May 2026 17:39:34 +0200
Subject: [PATCH 16/24] Different zoom in types for render images

Makes sure that either the density zoom in images or the center of mass  image is displayed in confluence
---
 picasso_workflow/analyse.py    |  87 +++++++++++++++++++---
 picasso_workflow/confluence.py | 131 ++++++++++++++++-----------------
 2 files changed, 140 insertions(+), 78 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 87b62ce..5214c87 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1769,9 +1769,9 @@ def check_has_z(locs):
                     return "z" in locs.columns
                 except (AttributeError, TypeError):
                     return False
-        
+
         has_z = check_has_z(render_locs)
-        
+
         # Read colormap choice (default to magma)
         cmap_choice = parameters.get("colormap", "magma")
 
@@ -1834,12 +1834,16 @@ def check_has_z(locs):
 
                 # Shift ROI center if it would place the ROI viewport boundary outside the image area
                 if (x_max - x_min) >= roi_size:
-                    cx = np.clip(cx, x_min + roi_size / 2.0, x_max - roi_size / 2.0)
+                    cx = np.clip(
+                        cx, x_min + roi_size / 2.0, x_max - roi_size / 2.0
+                    )
                 else:
                     cx = (x_min + x_max) / 2.0
 
                 if (y_max - y_min) >= roi_size:
-                    cy = np.clip(cy, y_min + roi_size / 2.0, y_max - roi_size / 2.0)
+                    cy = np.clip(
+                        cy, y_min + roi_size / 2.0, y_max - roi_size / 2.0
+                    )
                 else:
                     cy = (y_min + y_max) / 2.0
 
@@ -1911,10 +1915,30 @@ def check_has_z(locs):
             results["folder"], f"locs_fullfov_unmarked_{rcode}.png"
         )
         fig_overview.savefig(
-            results["fp_scene_fullfov_unmarked"], bbox_inches="tight", pad_inches=0
+            results["fp_scene_fullfov_unmarked"],
+            bbox_inches="tight",
+            pad_inches=0,
         )
 
-        # Draw outlines of selected ROIs if present
+        # Draw outlines of selected ROIs if present, or Zoom-In outline if Zoom-In is displayed
+        x_mean_clipped = x_mean
+        y_mean_clipped = y_mean
+        if parameters.get("ctrmass_fov_nm"):
+            zoom_size = parameters.get("ctrmass_fov_nm") / pixelsize
+            if (x_max - x_min) >= zoom_size:
+                x_mean_clipped = np.clip(
+                    x_mean, x_min + zoom_size / 2.0, x_max - zoom_size / 2.0
+                )
+            else:
+                x_mean_clipped = (x_min + x_max) / 2.0
+
+            if (y_max - y_min) >= zoom_size:
+                y_mean_clipped = np.clip(
+                    y_mean, y_min + zoom_size / 2.0, y_max - zoom_size / 2.0
+                )
+            else:
+                y_mean_clipped = (y_min + y_max) / 2.0
+
         if selected_rois:
             import matplotlib.patches as patches
             import matplotlib.pyplot as plt
@@ -1955,6 +1979,49 @@ def check_has_z(locs):
                         edgecolor="none",
                     ),
                 )
+        elif parameters.get("ctrmass_fov_nm"):
+            # Draw standard Zoom-In outline on overview image
+            import matplotlib.patches as patches
+            import matplotlib.pyplot as plt
+
+            fov_half = parameters.get("ctrmass_fov_nm") / 2
+            x_min_zoom = x_mean_clipped - fov_half / pixelsize
+            x_max_zoom = x_mean_clipped + fov_half / pixelsize
+            y_min_zoom = y_mean_clipped - fov_half / pixelsize
+            y_max_zoom = y_mean_clipped + fov_half / pixelsize
+
+            x_min_um = (x_min_zoom * pixelsize) / 1000.0
+            x_max_um = (x_max_zoom * pixelsize) / 1000.0
+            y_min_um = (y_min_zoom * pixelsize) / 1000.0
+            y_max_um = (y_max_zoom * pixelsize) / 1000.0
+
+            width_um = x_max_um - x_min_um
+            height_um = y_max_um - y_min_um
+
+            rect = patches.Rectangle(
+                (x_min_um, y_min_um),
+                width_um,
+                height_um,
+                linewidth=1.5,
+                edgecolor="red",
+                facecolor="none",
+            )
+            ax_overview.add_patch(rect)
+
+            ax_overview.text(
+                x_min_um + 0.03 * width_um,
+                y_min_um + 0.12 * height_um,
+                "Zoom-In",
+                color="red",
+                fontsize=10,
+                fontweight="bold",
+                bbox=dict(
+                    facecolor="black",
+                    alpha=0.6,
+                    boxstyle="round,pad=0.2",
+                    edgecolor="none",
+                ),
+            )
 
         import matplotlib.pyplot as plt
 
@@ -1967,10 +2034,10 @@ def check_has_z(locs):
         if parameters.get("ctrmass_fov_nm"):
             ctrmass_pixelsize = parameters.get("ctrmass_pixelsize", pixelsize)
             fov_half = parameters.get("ctrmass_fov_nm") / 2
-            x_min_zoom = x_mean - fov_half / pixelsize
-            x_max_zoom = x_mean + fov_half / pixelsize
-            y_min_zoom = y_mean - fov_half / pixelsize
-            y_max_zoom = y_mean + fov_half / pixelsize
+            x_min_zoom = x_mean_clipped - fov_half / pixelsize
+            x_max_zoom = x_mean_clipped + fov_half / pixelsize
+            y_min_zoom = y_mean_clipped - fov_half / pixelsize
+            y_max_zoom = y_mean_clipped + fov_half / pixelsize
 
             render_kwargs = {
                 "oversampling": pixelsize / ctrmass_pixelsize,
diff --git a/picasso_workflow/confluence.py b/picasso_workflow/confluence.py
index bee6bde..f7907eb 100644
--- a/picasso_workflow/confluence.py
+++ b/picasso_workflow/confluence.py
@@ -31,6 +31,7 @@ def module_wrapper(self, i, parameters, results, postpone_report=False):
             <ac:rich-text-body>
             <ul>
             """
+
         def _format_val(v):
             if type(v).__module__ == "numpy" and hasattr(v, "item"):
                 try:
@@ -40,9 +41,7 @@ def _format_val(v):
             return str(v)
 
         for k, v in parameters.items():
-            parameter_text += (
-                f"<li>{html.escape(str(k))}: {html.escape(_format_val(v))}</li>"
-            )
+            parameter_text += f"<li>{html.escape(str(k))}: {html.escape(_format_val(v))}</li>"
 
         parameter_text += """
         </ul>
@@ -57,9 +56,7 @@ def _format_val(v):
             <ul>
             """
         for k, v in results.items():
-            result_text += (
-                f"<li>{html.escape(str(k))}: {html.escape(_format_val(v))}</li>"
-            )
+            result_text += f"<li>{html.escape(str(k))}: {html.escape(_format_val(v))}</li>"
 
         result_text += """
         </ul>
@@ -654,7 +651,10 @@ def load_dataset_localizations(
 
     @module_decorator
     def identify(
-        self, i, parameters, results,
+        self,
+        i,
+        parameters,
+        results,
         parameter_text,
         result_text,
         postpone_report=False,
@@ -1126,42 +1126,58 @@ def render(
         {parameter_text}
         {result_text}
         """
-        
+
+        generate_active_rois = parameters.get("generate_active_rois", True)
         rois = results.get("fp_scene_rois", [])
-        tiles = results.get("fp_scene_tiles", [])
-        if rois:
-            text += "<table><tr>"
-            
-            # Left column: Overview and Zoom-In
-            text += "<td style='vertical-align: top; padding-right: 20px;'>"
-            if fp_fullfov := results.get("fp_scene_fullfov"):
+
+        text += "<table><tr>"
+
+        # Left column: Field of View Overviews
+        text += "<td style='vertical-align: top; padding-right: 20px;'>"
+        if fp_fullfov := results.get("fp_scene_fullfov"):
+            try:
+                self.ci.upload_attachment(self.report_page_id, fp_fullfov)
+            except ConfluenceInterfaceError:
+                pass
+            fn_fullfov = os.path.split(fp_fullfov)[1]
+
+            fp_unmarked = results.get("fp_scene_fullfov_unmarked")
+            if fp_unmarked:
                 try:
-                    self.ci.upload_attachment(self.report_page_id, fp_fullfov)
+                    self.ci.upload_attachment(self.report_page_id, fp_unmarked)
                 except ConfluenceInterfaceError:
                     pass
-                fn_fullfov = os.path.split(fp_fullfov)[1]
+                fn_unmarked = os.path.split(fp_unmarked)[1]
+
                 text += f"""
-                    <p><b>Overview with Density-driven ROIs</b></p>
-                    <ac:image ac:height="350">
-                        <ri:attachment ri:filename="{fn_fullfov}" />
-                    </ac:image>
+                    <p><b>Field of View Overviews (Left: Clean / Right: with ROIs)</b></p>
+                    <table style='border-collapse: collapse; border: none;'>
+                    <tr>
+                        <td style='border: none; padding-right: 10px;'>
+                            <ac:image ac:height="350">
+                                <ri:attachment ri:filename="{fn_unmarked}" />
+                            </ac:image>
+                        </td>
+                        <td style='border: none;'>
+                            <ac:image ac:height="350">
+                                <ri:attachment ri:filename="{fn_fullfov}" />
+                            </ac:image>
+                        </td>
+                    </tr>
+                    </table>
                 """
-            if fp_ctrmass := results.get("fp_scene_ctrmass"):
-                try:
-                    self.ci.upload_attachment(self.report_page_id, fp_ctrmass)
-                except ConfluenceInterfaceError:
-                    pass
-                fn_ctrmass = os.path.split(fp_ctrmass)[1]
+            else:
                 text += f"""
-                    <p><b>Localizations in Zoom-In</b></p>
+                    <p><b>Field of View Overview</b></p>
                     <ac:image ac:height="350">
-                        <ri:attachment ri:filename="{fn_ctrmass}" />
+                        <ri:attachment ri:filename="{fn_fullfov}" />
                     </ac:image>
                 """
-            text += "</td>"
-            
-            # Right column: Active Sites ROIs layout in a 2-column grid
-            text += "<td style='vertical-align: top;'>"
+        text += "</td>"
+
+        # Right column: Either active site images OR the Zoom-in image depending on selection
+        text += "<td style='vertical-align: top;'>"
+        if generate_active_rois and rois:
             text += "<p><b>Density-driven Active Sites</b></p>"
             text += "<table style='border-collapse: collapse; border: none;'>"
             for idx in range(0, len(rois), 2):
@@ -1185,43 +1201,22 @@ def render(
                     text += "<td style='border: none;'></td>"
                 text += "</tr>"
             text += "</table>"
-            text += "</td>"
-            text += "</tr></table>"
-
         else:
-            # Fallback to standard layout
-            fig_fps = []
-            titles_list = []
-            if fp_fig := results.get("fp_scene_fullfov"):
-                fig_fps.append(fp_fig)
-                titles_list.append("Localizations in whole Field of View")
-            if fp_fig := results.get("fp_scene_ctrmass"):
-                fig_fps.append(fp_fig)
-                titles_list.append("Localizations in Zoom-In")
-
-            if len(fig_fps) >= 1:
-                fn_figs = []
-                for fp in fig_fps:
-                    try:
-                        self.ci.upload_attachment(self.report_page_id, fp)
-                    except ConfluenceInterfaceError:
-                        pass
-                    fn_figs.append(os.path.split(fp)[1])
+            if fp_ctrmass := results.get("fp_scene_ctrmass"):
+                try:
+                    self.ci.upload_attachment(self.report_page_id, fp_ctrmass)
+                except ConfluenceInterfaceError:
+                    pass
+                fn_ctrmass = os.path.split(fp_ctrmass)[1]
+                text += f"""
+                    <p><b>Zoom-In</b></p>
+                    <ac:image ac:height="350">
+                        <ri:attachment ri:filename="{fn_ctrmass}" />
+                    </ac:image>
+                """
+        text += "</td>"
 
-                text += "<table><tr>"
-                for tit in titles_list:
-                    text += f"<td><b>{tit}</b></td>"
-                text += "</tr>"
-                text += "<tr>"
-                for fn in fn_figs:
-                    text += f"""
-                        <td>
-                              <ac:image ac:height="350">
-                              <ri:attachment ri:filename="{fn}" />
-                              </ac:image>
-                        </td>"""
-                text += "</tr>"
-                text += "</table>"
+        text += "</tr></table>"
 
         text += """
         </ac:layout-cell></ac:layout-section></ac:layout>

From 7d81c51957ca80012e3e56ce217c4c02a4787256 Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Wed, 20 May 2026 10:34:38 +0200
Subject: [PATCH 17/24] fix: MatplotlibDeprecationWarning

---
 picasso_workflow/analyse.py                      | 6 +++---
 picasso_workflow/outpost_modules/undrift_rsso.py | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 5214c87..5e47386 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -36,7 +36,7 @@
 import pandas as pd
 import psutil
 import yaml
-from matplotlib import cm
+from matplotlib import cm, colormaps
 from memory_profiler import memory_usage
 from picasso import CONFIG as pCONFIG
 from picasso import __version__ as picassoversion
@@ -6984,7 +6984,7 @@ def nneighbor(self, i, parameters, results):
             density_results.append(density)
 
             # plot results
-            colors = cm.get_cmap("viridis", nneighbors.shape[1]).colors
+            colors = colormaps["viridis"].resampled(nneighbors.shape[1]).colors
             bins = np.arange(0, rmax_NN, step=deltar)
             nnhist_obs = np.zeros((len(bins), nneighbors.shape[1]))
             for i in range(nnhist_obs.shape[1]):
@@ -7307,7 +7307,7 @@ def csr_cdf(x):
 
             # plot results
             fig, ax = plt.subplots()
-            colors = cm.get_cmap("viridis", k_max).colors
+            colors = colormaps["viridis"].resampled(k_max).colors
             bin_max = np.quantile(nneighbors[:, -1], 0.95)
             median_1stNN = np.median(nneighbors[:, 0])
             # sample bins such that there are 5 bins from 0 to middle of 1stNN
diff --git a/picasso_workflow/outpost_modules/undrift_rsso.py b/picasso_workflow/outpost_modules/undrift_rsso.py
index e4a172b..f734ab6 100644
--- a/picasso_workflow/outpost_modules/undrift_rsso.py
+++ b/picasso_workflow/outpost_modules/undrift_rsso.py
@@ -1961,7 +1961,7 @@ def _plot_shift_trajectory_2d(
     """
     import matplotlib.pyplot as plt
     from matplotlib.collections import LineCollection
-    from matplotlib import cm
+    from matplotlib import colormaps
     import matplotlib.colors as mcolors
 
     n_iterations = len(iteration_history)
@@ -2010,7 +2010,7 @@ def _plot_shift_trajectory_2d(
                   mincnt=1, linewidths=0.2, zorder=1)
 
     # Color map for iteration progression
-    cmap = cm.get_cmap('RdYlGn_r')  # Red (start) -> Yellow -> Green (end)
+    cmap = colormaps['RdYlGn_r']  # Red (start) -> Yellow -> Green (end)
 
     # Plot sample frame trajectories with color gradient
     for idx in sample_indices:

From 5397e8d5a9e321ab513662d50823b8b0ef10123a Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Wed, 20 May 2026 10:36:04 +0200
Subject: [PATCH 18/24] fix: correct get_movie_groups location

get_movie_groups was moved to util.py. This was not updated in this test.
---
 picasso_workflow/tests/test_util.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/picasso_workflow/tests/test_util.py b/picasso_workflow/tests/test_util.py
index 28e46b1..fa71539 100644
--- a/picasso_workflow/tests/test_util.py
+++ b/picasso_workflow/tests/test_util.py
@@ -217,7 +217,7 @@ def test_06_valid_expression(self):
         assert val
 
     def test_07_get_movie_groups(self):
-        from picasso_workflow.metaworkflow import get_movie_groups
+        from picasso_workflow.util import get_movie_groups
 
         paths = [
             "movie_1.ome.tif",
@@ -226,7 +226,7 @@ def test_07_get_movie_groups(self):
             "other.ome.tif",
         ]
         groups = get_movie_groups(paths, ".ome.tif")
-        assert list(groups.keys()) == ["movie", "other"]
+        assert set(groups.keys()) == {"movie", "other"}
         assert groups["movie"] == [
             "movie_0.ome.tif",
             "movie_1.ome.tif",

From 2b9463adc59db1995958d02eebd7a17723343dab Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Wed, 20 May 2026 10:46:42 +0200
Subject: [PATCH 19/24] Update to render image alignment and size

---
 picasso_workflow/analyse.py    |  2 +-
 picasso_workflow/confluence.py | 43 +++++++++++++++-------------------
 picasso_workflow/gui.py        |  2 +-
 3 files changed, 21 insertions(+), 26 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 5e47386..9311f0d 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1824,7 +1824,7 @@ def check_has_z(locs):
             candidates.sort(key=lambda item: item[0], reverse=True)
             n_rois = parameters.get("n_active_rois")
             if n_rois is None:
-                n_rois = 3
+                n_rois = 4
             roi_centers = []
             min_distance = roi_size  # non-overlapping
 
diff --git a/picasso_workflow/confluence.py b/picasso_workflow/confluence.py
index f7907eb..b91988e 100644
--- a/picasso_workflow/confluence.py
+++ b/picasso_workflow/confluence.py
@@ -1133,7 +1133,7 @@ def render(
         text += "<table><tr>"
 
         # Left column: Field of View Overviews
-        text += "<td style='vertical-align: top; padding-right: 20px;'>"
+        text += "<td style='vertical-align: middle; text-align: center; padding-right: 20px;'>"
         if fp_fullfov := results.get("fp_scene_fullfov"):
             try:
                 self.ci.upload_attachment(self.report_page_id, fp_fullfov)
@@ -1150,36 +1150,31 @@ def render(
                 fn_unmarked = os.path.split(fp_unmarked)[1]
 
                 text += f"""
-                    <p><b>Field of View Overviews (Left: Clean / Right: with ROIs)</b></p>
-                    <table style='border-collapse: collapse; border: none;'>
-                    <tr>
-                        <td style='border: none; padding-right: 10px;'>
-                            <ac:image ac:height="350">
-                                <ri:attachment ri:filename="{fn_unmarked}" />
-                            </ac:image>
-                        </td>
-                        <td style='border: none;'>
-                            <ac:image ac:height="350">
-                                <ri:attachment ri:filename="{fn_fullfov}" />
-                            </ac:image>
-                        </td>
-                    </tr>
-                    </table>
+                    <p><b>Overview Images</b></p>
+                    <p>
+                        <ac:image ac:height="450">
+                            <ri:attachment ri:filename="{fn_unmarked}" />
+                        </ac:image>
+                        &nbsp;&nbsp;
+                        <ac:image ac:height="450">
+                            <ri:attachment ri:filename="{fn_fullfov}" />
+                        </ac:image>
+                    </p>
                 """
             else:
                 text += f"""
-                    <p><b>Field of View Overview</b></p>
-                    <ac:image ac:height="350">
+                    <p><b>Overview Image</b></p>
+                    <ac:image ac:height="450">
                         <ri:attachment ri:filename="{fn_fullfov}" />
                     </ac:image>
                 """
         text += "</td>"
 
         # Right column: Either active site images OR the Zoom-in image depending on selection
-        text += "<td style='vertical-align: top;'>"
+        text += "<td style='vertical-align: middle; text-align: center;'>"
         if generate_active_rois and rois:
-            text += "<p><b>Density-driven Active Sites</b></p>"
-            text += "<table style='border-collapse: collapse; border: none;'>"
+            text += "<p><b>Zoom-In Images (Density-Driven)</b></p>"
+            text += "<table style='border-collapse: collapse; border: none; margin-left: auto; margin-right: auto;'>"
             for idx in range(0, len(rois), 2):
                 text += "<tr>"
                 for sub_idx in range(idx, min(idx + 2, len(rois))):
@@ -1191,7 +1186,7 @@ def render(
                     fn_roi = os.path.split(fp_roi)[1]
                     text += f"""
                         <td style='border: 1px solid #ddd; padding: 6px; text-align: center;'>
-                            <ac:image ac:height="150">
+                            <ac:image ac:height="200">
                                 <ri:attachment ri:filename="{fn_roi}" />
                             </ac:image>
                             <br/><b>Site {sub_idx + 1}</b>
@@ -1209,8 +1204,8 @@ def render(
                     pass
                 fn_ctrmass = os.path.split(fp_ctrmass)[1]
                 text += f"""
-                    <p><b>Zoom-In</b></p>
-                    <ac:image ac:height="350">
+                    <p><b>Zoom-In Image</b></p>
+                    <ac:image ac:height="450">
                         <ri:attachment ri:filename="{fn_ctrmass}" />
                     </ac:image>
                 """
diff --git a/picasso_workflow/gui.py b/picasso_workflow/gui.py
index 0ad67d3..ee2df76 100644
--- a/picasso_workflow/gui.py
+++ b/picasso_workflow/gui.py
@@ -1343,7 +1343,7 @@ def render(self):
                 "description": "Number of high-density active sites (ROIs) to generate",
                 "min": 1,
                 "max": 25,
-                "default": 3,
+                "default": 4,
                 "required": False,
             },
             "colormap": {

From 0b92f65db28bfa03e7d9bce961a6688c902fbb3d Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 16 Jun 2026 09:15:10 +0200
Subject: [PATCH 20/24] fix: update colormap and percentage based image scaling
 in render functions

---
 picasso_workflow/analyse.py                |  6 ++--
 picasso_workflow/outpost_modules/render.py | 36 +++++++++-------------
 2 files changed, 19 insertions(+), 23 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 9311f0d..23b76bf 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1886,13 +1886,14 @@ def check_has_z(locs):
                 roi_fp = os.path.join(
                     results["folder"], f"locs_active_roi_{idx + 1}_{rcode}.png"
                 )
-                render.plot_scene(
+                fig_roi, _ = render.plot_scene(
                     render_locs,
                     tile_pixelsize,
                     pixelsize,
                     fp=roi_fp,
                     render_kwargs=tile_kwargs,
                 )
+                plt.close(fig_roi)
                 roi_files.append(roi_fp)
 
         results["fp_scene_rois"] = roi_files
@@ -2054,13 +2055,14 @@ def check_has_z(locs):
             results["fp_scene_ctrmass"] = os.path.join(
                 results["folder"], f"locs_ctrmass_{rcode}.png"
             )
-            render.plot_scene(
+            fig_ctrmass, _ = render.plot_scene(
                 render_locs,
                 ctrmass_pixelsize,
                 pixelsize,
                 fp=results["fp_scene_ctrmass"],
                 render_kwargs=render_kwargs,
             )
+            plt.close(fig_ctrmass)
 
         return parameters, results
 
diff --git a/picasso_workflow/outpost_modules/render.py b/picasso_workflow/outpost_modules/render.py
index 8b54571..84aea0f 100644
--- a/picasso_workflow/outpost_modules/render.py
+++ b/picasso_workflow/outpost_modules/render.py
@@ -97,14 +97,14 @@ def render_single_channel(kwargs, locs, n_group_colors=8, cmap="magma"):
 
     # paint locs using the colormap of choice (Display Settings
     # Dialog)
-    cmap = np.uint8(np.round(255 * plt.get_cmap(cmap)(np.arange(256))))
+    cmap = np.uint8(np.round(255 * plt.colormaps[cmap](np.arange(256))))
 
-    # return a 4 channel (rgb and alpha) array
+    # return a 4 channel (rgba) array
     Y, X = image.shape
     bgra = np.zeros((Y, X, 4), dtype=np.uint8, order="C")
-    bgra[..., 0] = cmap[:, 2][image]
-    bgra[..., 1] = cmap[:, 1][image]
-    bgra[..., 2] = cmap[:, 0][image]
+    bgra[..., 0] = cmap[:, 0][image]  # R
+    bgra[..., 1] = cmap[:, 1][image]  # G
+    bgra[..., 2] = cmap[:, 2][image]  # B
 
     return bgra
 
@@ -214,27 +214,21 @@ def scale_contrast(images):
 
     Parameters
     ----------
-    images : list of np.arrays
+    images : list of np.arrays or np.ndarray
         Arrays with rendered locs (grayscale)
 
     Returns
     -------
-    list of np.arrays
-        Scaled images
+    np.ndarray
+        Scaled images in [0, 1]
     """
-
-    upper = (
-        min(
-            [
-                _.max()
-                for _ in images  # if no locs were clustered
-                if _.max() != 0  # the maximum value in image is 0.0
-            ]
-        )
-        / 40
-    )
-    # upper = INITIAL_REL_MAXIMUM * max_
-
+    images = np.asarray(images)
+    all_nonzero = images[images > 0].ravel()
+    if len(all_nonzero) == 0:
+        return images
+    # Saturate only the top 5% of non-background pixels so that typical
+    # sparse data is not overexposed regardless of absolute loc density.
+    upper = np.percentile(all_nonzero, 95)
     images = images / upper
     images[~np.isfinite(images)] = 0
     images = np.minimum(images, 1.0)

From 164159f18b6cbc53aaae166c788125f8f36786ac Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 16 Jun 2026 09:45:40 +0200
Subject: [PATCH 21/24] fix: remove redundant matplotlib imports in AutoPicasso
 class

---
 picasso_workflow/analyse.py | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 23b76bf..205588a 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -30,6 +30,7 @@
 from functools import wraps
 
 import matplotlib.pyplot as plt
+import matplotlib.patches as patches
 
 # from tqdm import tqdm
 import numpy as np
@@ -1941,9 +1942,6 @@ def check_has_z(locs):
                 y_mean_clipped = (y_min + y_max) / 2.0
 
         if selected_rois:
-            import matplotlib.patches as patches
-            import matplotlib.pyplot as plt
-
             for idx, (_, _, t_xmin, t_xmax, t_ymin, t_ymax) in enumerate(
                 selected_rois
             ):
@@ -1982,9 +1980,6 @@ def check_has_z(locs):
                 )
         elif parameters.get("ctrmass_fov_nm"):
             # Draw standard Zoom-In outline on overview image
-            import matplotlib.patches as patches
-            import matplotlib.pyplot as plt
-
             fov_half = parameters.get("ctrmass_fov_nm") / 2
             x_min_zoom = x_mean_clipped - fov_half / pixelsize
             x_max_zoom = x_mean_clipped + fov_half / pixelsize
@@ -2024,8 +2019,6 @@ def check_has_z(locs):
                 ),
             )
 
-        import matplotlib.pyplot as plt
-
         fig_overview.savefig(
             results["fp_scene_fullfov"], bbox_inches="tight", pad_inches=0
         )

From 8dbc695d7e666832e87763c91e25e9c72333a87c Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 16 Jun 2026 10:17:09 +0200
Subject: [PATCH 22/24] fix: adjust full field of view pixel size and update
 contrast scaling in render functions

---
 picasso_workflow/analyse.py                |  8 +++++++-
 picasso_workflow/outpost_modules/render.py | 14 +++++++++-----
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 205588a..0398fb4 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1777,7 +1777,7 @@ def check_has_z(locs):
         cmap_choice = parameters.get("colormap", "magma")
 
         # render whole field of view
-        fullfov_pixelsize = parameters.get("fullfov_pixelsize", pixelsize)
+        fullfov_pixelsize = parameters.get("fullfov_pixelsize", pixelsize / 4)
 
         # Normalize localizations to a list
         locs_list = (
@@ -1910,7 +1910,11 @@ def check_has_z(locs):
             pixelsize,
             fp=None,
             render_kwargs={"cmap": cmap_choice},
+            figsize=(9.6, 7.2),
         )
+        # annotation borders at the image edge don't widen the tight bbox.
+        _overview_xlim = ax_overview.get_xlim()
+        _overview_ylim = ax_overview.get_ylim()
 
         # Save unmarked copy of the overview image
         results["fp_scene_fullfov_unmarked"] = os.path.join(
@@ -2019,6 +2023,8 @@ def check_has_z(locs):
                 ),
             )
 
+        ax_overview.set_xlim(_overview_xlim)
+        ax_overview.set_ylim(_overview_ylim)
         fig_overview.savefig(
             results["fp_scene_fullfov"], bbox_inches="tight", pad_inches=0
         )
diff --git a/picasso_workflow/outpost_modules/render.py b/picasso_workflow/outpost_modules/render.py
index 84aea0f..a154c31 100644
--- a/picasso_workflow/outpost_modules/render.py
+++ b/picasso_workflow/outpost_modules/render.py
@@ -226,9 +226,9 @@ def scale_contrast(images):
     all_nonzero = images[images > 0].ravel()
     if len(all_nonzero) == 0:
         return images
-    # Saturate only the top 5% of non-background pixels so that typical
-    # sparse data is not overexposed regardless of absolute loc density.
-    upper = np.percentile(all_nonzero, 95)
+    # Map the 80th percentile of non-background pixels to full white,
+    # saturating the top 20% and scaling everything else proportionally brighter.
+    upper = np.percentile(all_nonzero, 80)
     images = images / upper
     images[~np.isfinite(images)] = 0
     images = np.minimum(images, 1.0)
@@ -297,6 +297,7 @@ def plot_scene(
     x_offset=0,
     y_offset=0,
     title="",
+    figsize=None,
 ):
     """Plot a scene in the locs
     Args:
@@ -304,6 +305,9 @@ def plot_scene(
            optional keys:
             oversampling, viewport, blur_method, min_blur_width, ang,
             n_group_colors, cmap
+        figsize : tuple, default None
+            (width, height) in inches passed to plt.subplots; None uses
+            matplotlib's default (6.4 x 4.8).
     """
     if not isinstance(channel_locs, list):
         channel_locs = [channel_locs]
@@ -320,7 +324,7 @@ def plot_scene(
             for locs in channel_locs
         ]
         logger.debug(f"#locs: {nlocs}; #groups{ngroups}")
-        fig, ax = plt.subplots()
+        fig, ax = plt.subplots(figsize=figsize)
         if fp is not None:
             fig.savefig(fp)
         return fig, ax
@@ -334,7 +338,7 @@ def plot_scene(
 
     bgra = render_scene(kwargs, channel_locs)
 
-    fig, ax = plt.subplots()
+    fig, ax = plt.subplots(figsize=figsize)
     ax.imshow(
         bgra,
         aspect="equal",

From bd3b5dbb632bd0ce64f8f37e02ee7b1113e037ed Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 16 Jun 2026 10:42:30 +0200
Subject: [PATCH 23/24] fix: adjust full field of view pixel size and ROI
 parameters in AutoPicasso class

---
 picasso_workflow/analyse.py | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 0398fb4..692e79f 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -1777,7 +1777,7 @@ def check_has_z(locs):
         cmap_choice = parameters.get("colormap", "magma")
 
         # render whole field of view
-        fullfov_pixelsize = parameters.get("fullfov_pixelsize", pixelsize / 4)
+        fullfov_pixelsize = parameters.get("fullfov_pixelsize", pixelsize / 10)
 
         # Normalize localizations to a list
         locs_list = (
@@ -1800,7 +1800,7 @@ def check_has_z(locs):
             all_x = np.concatenate([lcs["x"] for lcs in locs_list])
             all_y = np.concatenate([lcs["y"] for lcs in locs_list])
 
-            roi_size = parameters.get("ctrmass_fov_nm", 10000.0) / pixelsize
+            roi_size = parameters.get("ctrmass_fov_nm", 20000.0) / pixelsize
             if roi_size <= 0:
                 roi_size = 100.0  # fallback
 
@@ -1858,7 +1858,7 @@ def check_has_z(locs):
                     roi_centers.append((cx, cy))
 
             # Form ROIs and render them
-            tile_pixelsize = parameters.get("ctrmass_pixelsize", pixelsize)
+            tile_pixelsize = parameters.get("ctrmass_pixelsize", pixelsize / 2)
             for idx, (cx, cy) in enumerate(roi_centers):
                 tile_x_min = cx - roi_size / 2
                 tile_x_max = cx + roi_size / 2
@@ -1910,7 +1910,7 @@ def check_has_z(locs):
             pixelsize,
             fp=None,
             render_kwargs={"cmap": cmap_choice},
-            figsize=(9.6, 7.2),
+            figsize=(12.8, 9.6),
         )
         # annotation borders at the image edge don't widen the tight bbox.
         _overview_xlim = ax_overview.get_xlim()
@@ -1926,6 +1926,11 @@ def check_has_z(locs):
             pad_inches=0,
         )
 
+       
+        _image_bbox_inches = fig_overview.get_tightbbox(
+            fig_overview.canvas.get_renderer()
+        ).transformed(fig_overview.dpi_scale_trans.inverted())
+
         # Draw outlines of selected ROIs if present, or Zoom-In outline if Zoom-In is displayed
         x_mean_clipped = x_mean
         y_mean_clipped = y_mean
@@ -2026,14 +2031,16 @@ def check_has_z(locs):
         ax_overview.set_xlim(_overview_xlim)
         ax_overview.set_ylim(_overview_ylim)
         fig_overview.savefig(
-            results["fp_scene_fullfov"], bbox_inches="tight", pad_inches=0
+            results["fp_scene_fullfov"],
+            bbox_inches=_image_bbox_inches,
+            pad_inches=0,
         )
         plt.close(fig_overview)
 
         # render zoom into the center of mass
         if parameters.get("ctrmass_fov_nm"):
-            ctrmass_pixelsize = parameters.get("ctrmass_pixelsize", pixelsize)
-            fov_half = parameters.get("ctrmass_fov_nm") / 2
+            ctrmass_pixelsize = parameters.get("ctrmass_pixelsize", pixelsize / 2)
+            fov_half = parameters.get("ctrmass_fov_nm")
             x_min_zoom = x_mean_clipped - fov_half / pixelsize
             x_max_zoom = x_mean_clipped + fov_half / pixelsize
             y_min_zoom = y_mean_clipped - fov_half / pixelsize

From 9cdb23fac1bde2d297b083585b923597f366b6bf Mon Sep 17 00:00:00 2001
From: JonasFischer1 <90911204+JonasFischer1@users.noreply.github.com>
Date: Tue, 16 Jun 2026 11:19:27 +0200
Subject: [PATCH 24/24] fix: enhance plot_scene function with dpi parameter for
 better image resolution

---
 picasso_workflow/analyse.py                | 33 ++++++------------
 picasso_workflow/outpost_modules/render.py | 39 +++++++++++++++++-----
 2 files changed, 40 insertions(+), 32 deletions(-)

diff --git a/picasso_workflow/analyse.py b/picasso_workflow/analyse.py
index 692e79f..de0d999 100644
--- a/picasso_workflow/analyse.py
+++ b/picasso_workflow/analyse.py
@@ -30,7 +30,6 @@
 from functools import wraps
 
 import matplotlib.pyplot as plt
-import matplotlib.patches as patches
 
 # from tqdm import tqdm
 import numpy as np
@@ -1910,7 +1909,6 @@ def check_has_z(locs):
             pixelsize,
             fp=None,
             render_kwargs={"cmap": cmap_choice},
-            figsize=(12.8, 9.6),
         )
         # annotation borders at the image edge don't widen the tight bbox.
         _overview_xlim = ax_overview.get_xlim()
@@ -1922,15 +1920,9 @@ def check_has_z(locs):
         )
         fig_overview.savefig(
             results["fp_scene_fullfov_unmarked"],
-            bbox_inches="tight",
             pad_inches=0,
         )
 
-       
-        _image_bbox_inches = fig_overview.get_tightbbox(
-            fig_overview.canvas.get_renderer()
-        ).transformed(fig_overview.dpi_scale_trans.inverted())
-
         # Draw outlines of selected ROIs if present, or Zoom-In outline if Zoom-In is displayed
         x_mean_clipped = x_mean
         y_mean_clipped = y_mean
@@ -1962,15 +1954,13 @@ def check_has_z(locs):
                 width_um = x_max_um - x_min_um
                 height_um = y_max_um - y_min_um
 
-                rect = patches.Rectangle(
-                    (x_min_um, y_min_um),
-                    width_um,
-                    height_um,
+                ax_overview.plot(
+                    [x_min_um, x_max_um, x_max_um, x_min_um, x_min_um],
+                    [y_min_um, y_min_um, y_max_um, y_max_um, y_min_um],
+                    color="red",
                     linewidth=1.5,
-                    edgecolor="red",
-                    facecolor="none",
+                    clip_on=True,
                 )
-                ax_overview.add_patch(rect)
 
                 # Add text label for each active site
                 ax_overview.text(
@@ -2003,15 +1993,13 @@ def check_has_z(locs):
             width_um = x_max_um - x_min_um
             height_um = y_max_um - y_min_um
 
-            rect = patches.Rectangle(
-                (x_min_um, y_min_um),
-                width_um,
-                height_um,
+            ax_overview.plot(
+                [x_min_um, x_max_um, x_max_um, x_min_um, x_min_um],
+                [y_min_um, y_min_um, y_max_um, y_max_um, y_min_um],
+                color="red",
                 linewidth=1.5,
-                edgecolor="red",
-                facecolor="none",
+                clip_on=True,
             )
-            ax_overview.add_patch(rect)
 
             ax_overview.text(
                 x_min_um + 0.03 * width_um,
@@ -2032,7 +2020,6 @@ def check_has_z(locs):
         ax_overview.set_ylim(_overview_ylim)
         fig_overview.savefig(
             results["fp_scene_fullfov"],
-            bbox_inches=_image_bbox_inches,
             pad_inches=0,
         )
         plt.close(fig_overview)
diff --git a/picasso_workflow/outpost_modules/render.py b/picasso_workflow/outpost_modules/render.py
index a154c31..549bc64 100644
--- a/picasso_workflow/outpost_modules/render.py
+++ b/picasso_workflow/outpost_modules/render.py
@@ -298,6 +298,7 @@ def plot_scene(
     y_offset=0,
     title="",
     figsize=None,
+    dpi=100,
 ):
     """Plot a scene in the locs
     Args:
@@ -306,8 +307,10 @@ def plot_scene(
             oversampling, viewport, blur_method, min_blur_width, ang,
             n_group_colors, cmap
         figsize : tuple, default None
-            (width, height) in inches passed to plt.subplots; None uses
-            matplotlib's default (6.4 x 4.8).
+            (width, height) in inches; None uses matplotlib's default (6.4 x 4.8).
+        dpi : int, default 100
+            Output pixel density. Output pixels = figsize * dpi.
+            Increase to get a larger saved image without changing layout.
     """
     if not isinstance(channel_locs, list):
         channel_locs = [channel_locs]
@@ -324,9 +327,9 @@ def plot_scene(
             for locs in channel_locs
         ]
         logger.debug(f"#locs: {nlocs}; #groups{ngroups}")
-        fig, ax = plt.subplots(figsize=figsize)
+        fig, ax = plt.subplots(figsize=figsize, dpi=dpi)
         if fp is not None:
-            fig.savefig(fp)
+            fig.savefig(fp, dpi=dpi)
         return fig, ax
     # overwrite default kwargs with input kwargs
     if render_kwargs is not None:
@@ -337,20 +340,38 @@ def plot_scene(
     logger.debug(f"rendering locs with offset {(x_offset, y_offset)} nm")
 
     bgra = render_scene(kwargs, channel_locs)
+    H, W = bgra.shape[:2]
+
+    # Auto-size the figure so every rendered pixel maps 1:1 to an output pixel.
+    # This avoids any resampling by matplotlib and gives true STORM resolution.
+    # An explicit figsize overrides this (useful for thumbnails / ROI images).
+    if figsize is None:
+        fig_w, fig_h = W / dpi, H / dpi
+        use_auto = True
+    else:
+        fig_w, fig_h = figsize
+        use_auto = False
+
+    fig, ax = plt.subplots(figsize=(fig_w, fig_h), dpi=dpi)
+    if use_auto:
+        fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
 
-    fig, ax = plt.subplots(figsize=figsize)
     ax.imshow(
         bgra,
-        aspect="equal",
+        aspect="auto" if use_auto else "equal",
+        interpolation="none",
         origin="upper",
         extent=[
             x_offset / 1000,
-            (bgra.shape[1] * image_px_size + x_offset) / 1000,
-            (bgra.shape[0] * image_px_size + y_offset) / 1000,
+            (W * image_px_size + x_offset) / 1000,
+            (H * image_px_size + y_offset) / 1000,
             y_offset / 1000,
         ],
     )
     ax.axis("off")
     if fp is not None:
-        fig.savefig(fp, bbox_inches="tight", pad_inches=0)
+        if use_auto:
+            fig.savefig(fp, pad_inches=0, dpi=dpi)
+        else:
+            fig.savefig(fp, bbox_inches="tight", pad_inches=0, dpi=dpi)
     return fig, ax