napari-tapenade-processing 0.0.1__tar.gz

napari_tapenade_processing-0.0.1/LICENSE

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Jules Vanaret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

napari_tapenade_processing-0.0.1/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]

napari_tapenade_processing-0.0.1/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.1
+Name: napari-tapenade-processing
+Version: 0.0.1
+Summary: A simple plugin to use FooBar segmentation within napari
+Home-page: https://github.com/jules-vanaret/napari-tapenade-processing
+Author: Jules Vanaret
+Author-email: jules.vanaret@univ-amu.fr
+License: MIT
+Project-URL: Bug Tracker, https://github.com/jules-vanaret/napari-tapenade-processing/issues
+Project-URL: Documentation, https://github.com/jules-vanaret/napari-tapenade-processing#README.md
+Project-URL: Source Code, https://github.com/jules-vanaret/napari-tapenade-processing
+Project-URL: User Support, https://github.com/jules-vanaret/napari-tapenade-processing/issues
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: napari
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: magicgui
+Requires-Dist: qtpy
+Requires-Dist: tifffile
+Provides-Extra: testing
+Requires-Dist: tox; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-qt; extra == "testing"
+Requires-Dist: napari; extra == "testing"
+Requires-Dist: pyqt5; extra == "testing"
+
+# :herb: napari-tapenade-processing
+
+<img src="https://github.com/GuignardLab/tapenade/blob/Packaging/imgs/tapenade3.png" width="100">
+
+A collection of methods to process images of deep 3D/3D+time tissues in Napari.
+
+`napari-tapenade-processing` is a [napari] plugin that is part of the [Tapenade](https://github.com/GuignardLab/tapenade) project. Tapenade is a tool for the analysis of dense 3D tissues acquired with deep imaging microscopy. It is designed to be user-friendly and to provide a comprehensive analysis of the data.
+
+If you use this plugin for your research, please [cite us](https://github.com/GuignardLab/tapenade/blob/main/README.md#how-to-cite).
+
+## Overview
+
+While working with large and dense 3D and 3D+time gastruloid datasets, we found that being able to visualise and interact with the data dynamically greatly helped processing it.
+During the pre-processing stage, dynamical exploration and interaction led to faster tuning of the parameters by allowing direct visual feedback, and gave key biophysical insight during the analysis stage.
+
+From a given set of raw images, segmented object instances, and object mask, the plugin allows the user to quickly run all pre-processing functions from our main pipeline with custom parameters while being able to see and interact with the result of each step. For large datasets that are cumbersome to manipulate or cannot be loaded in Napari, the plugin provides a macro recording feature: the users can experiment and design their own pipeline on a smaller subset of the dataset, then run it on the full dataset without having to load it in Napari.
+
+<img src="imgs/Fig_Napari_preprocessing.png">
+
+## Installation
+
+The plugin obviously requires [napari] to run. If you don't have it yet, follow the instructions [here](https://napari.org/stable/tutorials/fundamentals/installation.html).
+
+The simplest way to install `napari-tapenade-processing` is via the [napari] plugin manager. Open Napari, go to `Plugins > Install/Uninstall Packages...` and search for `napari-tapenade-processing`. Click on the install button and you are ready to go!
+
+You can also install `napari-tapenade-processing` via [pip]:
+
+    pip install napari-tapenade-processing
+
+To install latest development version :
+
+    pip install git+https://github.com/jules-vanaret/napari-tapenade-processing.git
+
+## Usage
+
+### General overview of the plugin within Napari
+
+<img src="imgs/proc_0.png">
+
+To start a pre-processing pipeline, follow these steps:
+
+1. First, load your images in Napari. You can drag and drop them from your file explorer to the Napari viewer, or open them using the `File > Open files...` menu.
+2. Click on the `Plugins > Tapenade Processing` menu to open the plugin.
+3. The image you have loaded will be displayed as individual layers in the Layer List. They can be clicked-on to reveal a set of visual parameters (see 4) that can be adjusted. By double-clicking on a layer name, you can change it. Right-clicking a layer will give you several options. The little eye icon next to the layer name can be clicked to hide the layer.
+4. You can adjust visual parameters for each layer, like the contrast limits, the colormap, the opacity, the blending mode, etc.
+5. If you want to switch between 2D and 3D views, click on the `Toggle 2D/3D view` button (it resembles a square when in 2D mode, or a cube when in 3D mode).
+6. You can toggle the grid view (as shown in the example image) by clicking on the `Toggle grid mode` button. By right-clicking the button, you can parametrize the grid view (e.g number of columns, number of rows, etc).
+7. The plugin is composed of three tabs. The first tab is dedicated to pre-processing functions, the second tab is dedicated to the macro recording feature, and the third tab is dedicated to advanced parameters.
+
+### Tab 1: The pre-processing functions
+
+<img src="imgs/proc_1.png" width=300>
+
+The pre-processing tab is composed of the following elements:
+
+1. A combo box to select the pre-processing function to apply from a list.
+2. A set of comboxes that allow you to select the layers to apply the function on. If a function does not require a specific layer, the combo box will be greyed out. `Image` layers correspond to integer or float data, `Labels` layers correspond to integer data and represent segmented object instances, `Mask` layers correspond to boolean data and usually represent the sample's large scale mask (inside/outside). All layers must have data of the same shape (same number of dimensions and same dimensions). Layers can be 3D or 3D+time, respectively with the ZYX or TZYX order.
+(2') If a layer does not appear in a combo box, but is present in the Layer List, you can click on the `Refresh` button to update the list of layers.
+3. A set of parameters that you can tune to adjust the function's behaviour. The parameters are specific to each function. In case of doubt, you can hover over the parameter name/widget to get a tooltip with a description.
+4. A `Run function` button to apply the function with the current parameters to the previously selected layers.
+
+
+### Tab 2: The macro recording feature
+
+In progress...
+
+### Tab 3: Advanced parameters
+
+<img src="imgs/proc_2.png" width=300>
+
+The advanced parameters tab is composed of the following elements:
+
+1. A checkbox `New layers overwrite previous ones`: whether the output of the pre-processing functions should be saved as new layers or overwrite the previous ones that were used as input. This can be useful to save memory when you don't need to compare the input and output of a function.
+2. A checkbox `Results are cropped using mask`: whether the output of functions are systematically cropped using the mask layer (if it is provided). This can be useful to save memory when you don't need to process the whole image.
+3. A slider `# parallel jobs`: the number of parallel jobs to use when running a function on a 3D+time input (each frame is processed in parallel). This can be useful to speed up the processing.
+
+## Contributing
+
+Contributions are very welcome. Tests can be run with [tox], please ensure
+the coverage at least stays the same before you submit a pull request.
+
+## License
+
+Distributed under the terms of the [MIT] license,
+"napari-tapenade-processing" is free and open source software
+
+## Issues
+
+If you encounter any problems, please [file an issue] along with a detailed description.
+
+
+----------------------------------
+
+This [napari] plugin was generated with [Cookiecutter] using [@napari]'s [cookiecutter-napari-plugin] template.
+
+[napari]: https://github.com/napari/napari
+[Cookiecutter]: https://github.com/audreyr/cookiecutter
+[@napari]: https://github.com/napari
+[MIT]: http://opensource.org/licenses/MIT
+[BSD-3]: http://opensource.org/licenses/BSD-3-Clause
+[GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
+[GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
+[Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
+[Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
+[cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin
+
+[file an issue]: https://github.com/jules-vanaret/napari-tapenade-processing/issues
+
+[napari]: https://github.com/napari/napari
+[tox]: https://tox.readthedocs.io/en/latest/
+[pip]: https://pypi.org/project/pip/
+[PyPI]: https://pypi.org/

napari_tapenade_processing-0.0.1/README.md

@@ -0,0 +1,112 @@
+# :herb: napari-tapenade-processing
+
+<img src="https://github.com/GuignardLab/tapenade/blob/Packaging/imgs/tapenade3.png" width="100">
+
+A collection of methods to process images of deep 3D/3D+time tissues in Napari.
+
+`napari-tapenade-processing` is a [napari] plugin that is part of the [Tapenade](https://github.com/GuignardLab/tapenade) project. Tapenade is a tool for the analysis of dense 3D tissues acquired with deep imaging microscopy. It is designed to be user-friendly and to provide a comprehensive analysis of the data.
+
+If you use this plugin for your research, please [cite us](https://github.com/GuignardLab/tapenade/blob/main/README.md#how-to-cite).
+
+## Overview
+
+While working with large and dense 3D and 3D+time gastruloid datasets, we found that being able to visualise and interact with the data dynamically greatly helped processing it.
+During the pre-processing stage, dynamical exploration and interaction led to faster tuning of the parameters by allowing direct visual feedback, and gave key biophysical insight during the analysis stage.
+
+From a given set of raw images, segmented object instances, and object mask, the plugin allows the user to quickly run all pre-processing functions from our main pipeline with custom parameters while being able to see and interact with the result of each step. For large datasets that are cumbersome to manipulate or cannot be loaded in Napari, the plugin provides a macro recording feature: the users can experiment and design their own pipeline on a smaller subset of the dataset, then run it on the full dataset without having to load it in Napari.
+
+<img src="imgs/Fig_Napari_preprocessing.png">
+
+## Installation
+
+The plugin obviously requires [napari] to run. If you don't have it yet, follow the instructions [here](https://napari.org/stable/tutorials/fundamentals/installation.html).
+
+The simplest way to install `napari-tapenade-processing` is via the [napari] plugin manager. Open Napari, go to `Plugins > Install/Uninstall Packages...` and search for `napari-tapenade-processing`. Click on the install button and you are ready to go!
+
+You can also install `napari-tapenade-processing` via [pip]:
+
+    pip install napari-tapenade-processing
+
+To install latest development version :
+
+    pip install git+https://github.com/jules-vanaret/napari-tapenade-processing.git
+
+## Usage
+
+### General overview of the plugin within Napari
+
+<img src="imgs/proc_0.png">
+
+To start a pre-processing pipeline, follow these steps:
+
+1. First, load your images in Napari. You can drag and drop them from your file explorer to the Napari viewer, or open them using the `File > Open files...` menu.
+2. Click on the `Plugins > Tapenade Processing` menu to open the plugin.
+3. The image you have loaded will be displayed as individual layers in the Layer List. They can be clicked-on to reveal a set of visual parameters (see 4) that can be adjusted. By double-clicking on a layer name, you can change it. Right-clicking a layer will give you several options. The little eye icon next to the layer name can be clicked to hide the layer.
+4. You can adjust visual parameters for each layer, like the contrast limits, the colormap, the opacity, the blending mode, etc.
+5. If you want to switch between 2D and 3D views, click on the `Toggle 2D/3D view` button (it resembles a square when in 2D mode, or a cube when in 3D mode).
+6. You can toggle the grid view (as shown in the example image) by clicking on the `Toggle grid mode` button. By right-clicking the button, you can parametrize the grid view (e.g number of columns, number of rows, etc).
+7. The plugin is composed of three tabs. The first tab is dedicated to pre-processing functions, the second tab is dedicated to the macro recording feature, and the third tab is dedicated to advanced parameters.
+
+### Tab 1: The pre-processing functions
+
+<img src="imgs/proc_1.png" width=300>
+
+The pre-processing tab is composed of the following elements:
+
+1. A combo box to select the pre-processing function to apply from a list.
+2. A set of comboxes that allow you to select the layers to apply the function on. If a function does not require a specific layer, the combo box will be greyed out. `Image` layers correspond to integer or float data, `Labels` layers correspond to integer data and represent segmented object instances, `Mask` layers correspond to boolean data and usually represent the sample's large scale mask (inside/outside). All layers must have data of the same shape (same number of dimensions and same dimensions). Layers can be 3D or 3D+time, respectively with the ZYX or TZYX order.
+(2') If a layer does not appear in a combo box, but is present in the Layer List, you can click on the `Refresh` button to update the list of layers.
+3. A set of parameters that you can tune to adjust the function's behaviour. The parameters are specific to each function. In case of doubt, you can hover over the parameter name/widget to get a tooltip with a description.
+4. A `Run function` button to apply the function with the current parameters to the previously selected layers.
+
+
+### Tab 2: The macro recording feature
+
+In progress...
+
+### Tab 3: Advanced parameters
+
+<img src="imgs/proc_2.png" width=300>
+
+The advanced parameters tab is composed of the following elements:
+
+1. A checkbox `New layers overwrite previous ones`: whether the output of the pre-processing functions should be saved as new layers or overwrite the previous ones that were used as input. This can be useful to save memory when you don't need to compare the input and output of a function.
+2. A checkbox `Results are cropped using mask`: whether the output of functions are systematically cropped using the mask layer (if it is provided). This can be useful to save memory when you don't need to process the whole image.
+3. A slider `# parallel jobs`: the number of parallel jobs to use when running a function on a 3D+time input (each frame is processed in parallel). This can be useful to speed up the processing.
+
+## Contributing
+
+Contributions are very welcome. Tests can be run with [tox], please ensure
+the coverage at least stays the same before you submit a pull request.
+
+## License
+
+Distributed under the terms of the [MIT] license,
+"napari-tapenade-processing" is free and open source software
+
+## Issues
+
+If you encounter any problems, please [file an issue] along with a detailed description.
+
+
+----------------------------------
+
+This [napari] plugin was generated with [Cookiecutter] using [@napari]'s [cookiecutter-napari-plugin] template.
+
+[napari]: https://github.com/napari/napari
+[Cookiecutter]: https://github.com/audreyr/cookiecutter
+[@napari]: https://github.com/napari
+[MIT]: http://opensource.org/licenses/MIT
+[BSD-3]: http://opensource.org/licenses/BSD-3-Clause
+[GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
+[GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
+[Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
+[Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
+[cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin
+
+[file an issue]: https://github.com/jules-vanaret/napari-tapenade-processing/issues
+
+[napari]: https://github.com/napari/napari
+[tox]: https://tox.readthedocs.io/en/latest/
+[pip]: https://pypi.org/project/pip/
+[PyPI]: https://pypi.org/

napari_tapenade_processing-0.0.1/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=42.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+
+
+[tool.black]
+line-length = 79
+target-version = ['py38', 'py39', 'py310']
+
+
+[tool.ruff]
+line-length = 79
+select = [
+    "E", "F", "W", #flake8
+    "UP", # pyupgrade
+    "I", # isort
+    "BLE", # flake8-blind-exception
+    "B", # flake8-bugbear
+    "A", # flake8-builtins
+    "C4", # flake8-comprehensions
+    "ISC", # flake8-implicit-str-concat
+    "G", # flake8-logging-format
+    "PIE", # flake8-pie
+    "SIM", # flake8-simplify
+]
+ignore = [
+    "E501", # line too long. let black handle this
+    "UP006", "UP007", # type annotation. As using magicgui require runtime type annotation then we disable this.
+    "SIM117", # flake8-simplify - some of merged with statements are not looking great with black, reanble after drop python 3.9
+]
+
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".mypy_cache",
+    ".pants.d",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+    "*vendored*",
+    "*_vendor*",
+]
+
+target-version = "py38"
+fix = true

napari_tapenade_processing-0.0.1/setup.cfg

@@ -0,0 +1,65 @@
+[metadata]
+name = napari-tapenade-processing
+version = attr: napari_tapenade_processing.__version__
+description = A simple plugin to use FooBar segmentation within napari
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/jules-vanaret/napari-tapenade-processing
+author = Jules Vanaret
+author_email = jules.vanaret@univ-amu.fr
+license = MIT
+license_files = LICENSE
+classifiers = 
+	Development Status :: 2 - Pre-Alpha
+	Framework :: napari
+	Intended Audience :: Developers
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+	Programming Language :: Python
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3 :: Only
+	Programming Language :: Python :: 3.8
+	Programming Language :: Python :: 3.9
+	Programming Language :: Python :: 3.10
+	Topic :: Scientific/Engineering :: Image Processing
+project_urls = 
+	Bug Tracker = https://github.com/jules-vanaret/napari-tapenade-processing/issues
+	Documentation = https://github.com/jules-vanaret/napari-tapenade-processing#README.md
+	Source Code = https://github.com/jules-vanaret/napari-tapenade-processing
+	User Support = https://github.com/jules-vanaret/napari-tapenade-processing/issues
+
+[options]
+packages = find:
+install_requires = 
+	numpy
+	magicgui
+	qtpy
+	tifffile
+python_requires = >=3.8
+include_package_data = True
+package_dir = 
+	=src
+
+[options.packages.find]
+where = src
+
+[options.entry_points]
+napari.manifest = 
+	napari-tapenade-processing = napari_tapenade_processing:napari.yaml
+
+[options.extras_require]
+testing = 
+	tox
+	pytest  # https://docs.pytest.org/en/latest/contents.html
+	pytest-cov  # https://pytest-cov.readthedocs.io/en/latest/
+	pytest-qt  # https://pytest-qt.readthedocs.io/en/latest/
+	napari
+	pyqt5
+
+[options.package_data]
+* = *.yaml
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

napari_tapenade_processing-0.0.1/src/napari_tapenade_processing/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "0.0.1"
+from ._widget import TapenadeProcessingWidget
+
+__all__ = (
+    "TapenadeProcessingWidget",
+    
+)

napari_tapenade_processing-0.0.1/src/napari_tapenade_processing/_custom_widgets.py

@@ -0,0 +1,99 @@
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import (
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QScrollArea,
+    QSizePolicy,
+    QStackedWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class MultiLineTabWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.initUI()
+
+    def initUI(self):
+        self.layout = QVBoxLayout()
+        self.tabBarLayout = QVBoxLayout()
+
+        self.scrollArea = QScrollArea()
+        self.scrollArea.setWidgetResizable(True)
+        self.tabContainer = QWidget()
+        self.tabContainer.setLayout(self.tabBarLayout)
+        self.scrollArea.setWidget(self.tabContainer)
+
+        self.layout.addWidget(self.scrollArea)
+
+        self.stackedWidget = QStackedWidget()
+        self.layout.addWidget(self.stackedWidget)
+
+        self.setLayout(self.layout)
+
+        self.tabs = []
+
+    def addTab(self, widget, title):
+        tabButton = QPushButton(title)
+        tabButton.setCheckable(True)
+        tabButton.clicked.connect(lambda: self.onTabClicked(tabButton))
+
+        tabRowLayout = None
+        if len(self.tabs) % 3 == 0:
+            tabRowLayout = QHBoxLayout()
+            self.tabBarLayout.addLayout(tabRowLayout)
+        else:
+            tabRowLayout = self.tabBarLayout.itemAt(
+                self.tabBarLayout.count() - 1
+            ).layout()
+
+        tabRowLayout.addWidget(tabButton)
+        self.tabs.append(tabButton)
+
+        self.stackedWidget.addWidget(widget)
+
+    def onTabClicked(self, tabButton):
+        for i, btn in enumerate(self.tabs):
+            if btn == tabButton:
+                self.stackedWidget.setCurrentIndex(i)
+                btn.setChecked(True)
+            else:
+                btn.setChecked(False)
+
+
+class RichTextPushButton(QPushButton):
+    def __init__(self, parent=None, text=None):
+        if parent is not None:
+            super().__init__(parent)
+        else:
+            super().__init__()
+        self.__lbl = QLabel(self)
+        if text is not None:
+            self.__lbl.setText(text)
+        self.__lyt = QHBoxLayout()
+        self.__lyt.setContentsMargins(0, 0, 0, 0)
+        self.__lyt.setSpacing(0)
+        self.setLayout(self.__lyt)
+        self.__lbl.setAttribute(Qt.WA_TranslucentBackground)
+        self.__lbl.setAttribute(Qt.WA_TransparentForMouseEvents)
+        self.__lbl.setSizePolicy(
+            QSizePolicy.Expanding,
+            QSizePolicy.Expanding,
+        )
+        self.__lbl.setTextFormat(Qt.RichText)
+        self.__lyt.addWidget(self.__lbl)
+        return
+
+    def setText(self, text):
+        self.__lbl.setText(text)
+        self.updateGeometry()
+        return
+
+    def sizeHint(self):
+        s = QPushButton.sizeHint(self)
+        w = self.__lbl.sizeHint()
+        s.setWidth(w.width())
+        s.setHeight(w.height())
+        return s

napari_tapenade_processing-0.0.1/src/napari_tapenade_processing/_macro_recorder.py

@@ -0,0 +1,99 @@
+import json
+import os
+from collections import OrderedDict
+from datetime import datetime
+
+
+class MacroRecorder:
+    def __init__(self, adjective_dict):
+        self._is_recording_parameters = False
+        self._record_parameters_list = []
+
+        # key: napari name, value: standardized name
+        self._record_data_dict = {
+            "mask": {},
+            "image": {},
+            "labels": {},
+            "tracks": {},
+        }
+
+        self._adjective_dict = adjective_dict
+
+    def _reset_recording(self):
+        for k in self._record_data_dict.keys():
+            self._record_data_dict[k] = {}
+        self._record_parameters_list = []
+
+    def dump_recorded_parameters(self, path: str):
+        date = (
+            str(datetime.now())
+            .split(".")[:-1][0]
+            .replace(" ", "_")
+            .replace(":", "-")
+        )
+        filename = f"recorded_parameters_{date}.json"
+
+        with open(os.path.join(path, filename), "w") as f:
+            json.dump(self._record_parameters_list, f)
+
+        self._reset_recording()
+
+    def record(
+        self,
+        function_name: str,
+        layers_names_in: dict,
+        layers_names_out: dict,
+        func_params: dict,
+        overwrite: bool,
+    ):
+        """
+        layer_names are dicts that map layer_type (e.g 'mask', 'image'...) to
+        the names of the layers in the viewer
+        """
+
+        dict_in = dict()
+        dict_out = OrderedDict()
+
+        for layer_type in ["mask", "image", "labels", "tracks"]:
+            # building dict_in
+            layer_in = None
+            if layer_type in layers_names_in:
+                layer_name_in = layers_names_in[layer_type]
+
+                if layer_name_in is not None:
+                    layer_in = self._record_data_dict[layer_type].get(
+                        layer_name_in, layer_type
+                    )
+
+                dict_in[layer_type] = layer_in
+            # building dict_out
+            if layer_type in layers_names_out:
+                layer_name_out = layers_names_out[layer_type]
+
+                if layer_name_out is not None:
+                    if overwrite and layer_in is not None:
+                        layer_out = layer_in
+                    elif layer_in is not None:
+                        adjective = self._adjective_dict[function_name]
+                        layer_out = f"{layer_in}_{adjective}"
+                        self._record_data_dict[layer_type][
+                            layer_name_out
+                        ] = layer_out
+                    else:
+                        layer_out = layer_type
+                        self._record_data_dict[layer_type][
+                            layer_name_out
+                        ] = layer_out
+                else:
+                    layer_out = None
+
+                dict_out[layer_type] = layer_out
+
+        params = {
+            "function": function_name,
+            "in": dict_in,
+            "out": dict_out,
+            "func_params": func_params,
+        }
+
+        self._record_parameters_list.append(params)