From 54280f4f220a24b4aecea66779c661fae6f97b84 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 4 Jan 2019 20:56:59 +0100
Subject: [PATCH 001/264] setup package

---
 .gitignore          |  9 +++++++
 MANIFEST.in         |  0
 Makefile            |  2 ++
 bigfish/__init__.py |  0
 requirements.txt    | 10 ++++++++
 setup.py            | 59 +++++++++++++++++++++++++++++++++++++++++++++
 tests/tests.py      |  0
 7 files changed, 80 insertions(+)
 create mode 100644 MANIFEST.in
 create mode 100644 Makefile
 create mode 100644 bigfish/__init__.py
 create mode 100644 requirements.txt
 create mode 100644 setup.py
 create mode 100644 tests/tests.py

diff --git a/.gitignore b/.gitignore
index e69de29b..34419667 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,9 @@
+# dot files and directories
+.idea/
+.DS_Store
+
+# Packaging related files
+MANIFEST
+build/
+dist/
+big_fish.egg-info/
\ No newline at end of file
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 00000000..e69de29b
diff --git a/Makefile b/Makefile
new file mode 100644
index 00000000..1338cd03
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,2 @@
+init:
+    pip install -r requirements.txt
\ No newline at end of file
diff --git a/bigfish/__init__.py b/bigfish/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 00000000..1e86f229
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,10 @@
+--index-url https://pypi.python.org/simple/
+
+-e .
+
+numpy >= 1.15.4
+pip >= 18.1
+scikit-learn >= 0.20.2
+scipy >= 1.2.0
+tensorflow >= 1.12.0, < 2.0
+matplotlib >= 3.0.2
\ No newline at end of file
diff --git a/setup.py b/setup.py
new file mode 100644
index 00000000..300663c1
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,59 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Setup script.
+"""
+
+from setuptools import setup, find_packages
+
+# Package meta-data.
+VERSION = 1.0
+DESCRIPTION = 'Toolbox for cell FISH images.'
+
+# Package abstract dependencies
+REQUIRES = [
+      'numpy',
+      'scikit-learn',
+      'scipy',
+      'tensorflow',
+      'matplotlib'
+]
+
+# Long description of the package
+with open("README.md", "r") as f:
+    LONG_DESCRIPTION = f.read()
+
+# A list of classifiers to categorize the project (only used for searching and
+# browsing projects on PyPI).
+CLASSIFIERS = [
+      'Development Status :: 3 - Alpha',
+      'Intended Audience :: Science/Research',
+      'Intended Audience :: Developers',
+      'Intended Audience :: Biologist',
+      'Topic :: Software Development',
+      'Topic :: Scientific/Engineering',
+      'Topic :: Cellular Imagery',
+      'Operating System :: Unix',
+      'Operating System :: MacOS',
+      'Programming Language :: Python',
+      'Programming Language :: Python :: 3.6',
+      'License :: OSI Approved :: MIT License'
+]
+
+# Setup
+setup(name='big-fish',
+      version=VERSION,
+      description=DESCRIPTION,
+      long_description=LONG_DESCRIPTION,
+      long_description_content_type="text/markdown",
+      author='Arthur Imbert',
+      author_email='arthur.imbert.pro@gmail.com',
+      url='https://github.com/Henley13/big-fish',
+      packages=find_packages(),
+      license='MIT',
+      python_requires='>=3.6.8',
+      install_requires=REQUIRES,
+      classifiers=CLASSIFIERS
+      )
+
diff --git a/tests/tests.py b/tests/tests.py
new file mode 100644
index 00000000..e69de29b

From f5c948bde661751292ec273e7daba62e5a85fb0f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 25 Jan 2019 20:32:14 +0100
Subject: [PATCH 002/264] update setup, gitignore and requirements

---
 .gitignore       | 7 +++++--
 requirements.txt | 5 +++--
 setup.py         | 2 --
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/.gitignore b/.gitignore
index 34419667..523312a3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
-# dot files and directories
+# Dot files
 .idea/
 .DS_Store
 
@@ -6,4 +6,7 @@
 MANIFEST
 build/
 dist/
-big_fish.egg-info/
\ No newline at end of file
+big_fish.egg-info/
+
+# Notebooks
+notebooks/
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 1e86f229..a6e6f11a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,6 +5,7 @@
 numpy >= 1.15.4
 pip >= 18.1
 scikit-learn >= 0.20.2
-scipy >= 1.2.0
+scipy >= 1.1.0
 tensorflow >= 1.12.0, < 2.0
-matplotlib >= 3.0.2
\ No newline at end of file
+matplotlib >= 3.0.2
+pandas >= 0.23.4
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 300663c1..7a20d2f9 100644
--- a/setup.py
+++ b/setup.py
@@ -1,4 +1,3 @@
-#! /usr/bin/env python
 # -*- coding: utf-8 -*-
 
 """
@@ -56,4 +55,3 @@
       install_requires=REQUIRES,
       classifiers=CLASSIFIERS
       )
-

From 330d3af8544e5a7faac78ee9d9db0c42d54b7314 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 1 Feb 2019 17:56:38 +0100
Subject: [PATCH 003/264] create new submodules

---
 bigfish/classification/__init__.py |  0
 bigfish/plot/__init__.py           |  0
 bigfish/segmentation/__init__.py   |  0
 bigfish/spot_detection/__init__.py |  0
 bigfish/stack/__init__.py          |  0
 bigfish/stack/loader.py            | 12 ++++++++++++
 bigfish/stack/preprocessing.py     |  5 +++++
 setup.py                           |  2 +-
 8 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100644 bigfish/classification/__init__.py
 create mode 100644 bigfish/plot/__init__.py
 create mode 100644 bigfish/segmentation/__init__.py
 create mode 100644 bigfish/spot_detection/__init__.py
 create mode 100644 bigfish/stack/__init__.py
 create mode 100644 bigfish/stack/loader.py
 create mode 100644 bigfish/stack/preprocessing.py

diff --git a/bigfish/classification/__init__.py b/bigfish/classification/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/spot_detection/__init__.py b/bigfish/spot_detection/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/stack/loader.py b/bigfish/stack/loader.py
new file mode 100644
index 00000000..d03897a9
--- /dev/null
+++ b/bigfish/stack/loader.py
@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+"""
+Function used to read data from various sources and store them in a
+multidimensional tensor (technically a numpy ndarray).
+"""
+
+import os
+
+import numpy as np
+
+
diff --git a/bigfish/stack/preprocessing.py b/bigfish/stack/preprocessing.py
new file mode 100644
index 00000000..ab64f3d8
--- /dev/null
+++ b/bigfish/stack/preprocessing.py
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions used to format any input tensor loaded in bigfish.
+"""
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 7a20d2f9..f4373530 100644
--- a/setup.py
+++ b/setup.py
@@ -51,7 +51,7 @@
       url='https://github.com/Henley13/big-fish',
       packages=find_packages(),
       license='MIT',
-      python_requires='>=3.6.8',
+      python_requires='>=3.6.0',
       install_requires=REQUIRES,
       classifiers=CLASSIFIERS
       )

From ea820b9fd1f0369ed842d6a52ec15b50d67ee38f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 4 Feb 2019 17:14:35 +0100
Subject: [PATCH 004/264] add empty plot scripts

---
 bigfish/plot/plot_coordinates.py | 0
 bigfish/plot/plot_images.py      | 0
 tests/tests_loader.py            | 0
 3 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 bigfish/plot/plot_coordinates.py
 create mode 100644 bigfish/plot/plot_images.py
 create mode 100644 tests/tests_loader.py

diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/tests_loader.py b/tests/tests_loader.py
new file mode 100644
index 00000000..e69de29b

From 2831414dcd404eb5b0f727939b242ffaa4e47592 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 4 Feb 2019 17:15:15 +0100
Subject: [PATCH 005/264] update .gitignore and dependencies

---
 .gitignore       | 8 +++++++-
 requirements.txt | 1 +
 setup.py         | 1 +
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 523312a3..f5d9e2ec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,10 @@ dist/
 big_fish.egg-info/
 
 # Notebooks
-notebooks/
\ No newline at end of file
+notebooks/*
+
+# Data
+data/*
+
+# Cache
+__pycache__/
diff --git a/requirements.txt b/requirements.txt
index a6e6f11a..234b2e85 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,6 +5,7 @@
 numpy >= 1.15.4
 pip >= 18.1
 scikit-learn >= 0.20.2
+scikit-image >= 0.14.2
 scipy >= 1.1.0
 tensorflow >= 1.12.0, < 2.0
 matplotlib >= 3.0.2
diff --git a/setup.py b/setup.py
index f4373530..85647844 100644
--- a/setup.py
+++ b/setup.py
@@ -14,6 +14,7 @@
 REQUIRES = [
       'numpy',
       'scikit-learn',
+      'scikit-image',
       'scipy',
       'tensorflow',
       'matplotlib'

From 7b0624f952aec5a645f389d4ca8af8de48993f0f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 4 Feb 2019 17:16:07 +0100
Subject: [PATCH 006/264] add load functions

---
 bigfish/stack/__init__.py |  13 +++
 bigfish/stack/loader.py   | 203 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 215 insertions(+), 1 deletion(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index e69de29b..09eb5e9e 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+"""
+The 'stack' module includes function to read data, preprocess them and build
+stack of images.
+"""
+
+from .loader import read_tif, read_pickle, build_simulated_dataset
+
+
+__all__ = ["read_tif",
+           "read_pickle",
+           "build_simulated_dataset"]
diff --git a/bigfish/stack/loader.py b/bigfish/stack/loader.py
index d03897a9..4a02a1f3 100644
--- a/bigfish/stack/loader.py
+++ b/bigfish/stack/loader.py
@@ -2,11 +2,212 @@
 
 """
 Function used to read data from various sources and store them in a
-multidimensional tensor (technically a numpy ndarray).
+multidimensional tensor (np.ndarray) or a dataframe (pandas.DataFrame).
 """
 
 import os
+import pickle
 
 import numpy as np
+import pandas as pd
 
+from skimage import io, img_as_float32
 
+
+def read_tif(path):
+    """Read an image with the .tif or .tiff extension.
+
+    The input image should be in 2-d or 3-d, with unsigned integer. The output
+    tensor is normalized between 0 and 1.
+
+    Parameters
+    ----------
+    path : str
+        Path of the image to read.
+
+    Returns
+    -------
+    tensor : ndarray, np.float32
+        A 5-d tensor with shape (round, channel, z, y, x). Usually with smFISH
+        images there is only one round.
+
+    """
+    # read image
+    image = io.imread(path)
+
+    # build the 5-d tensor
+    if image.ndim == 3:
+        # we had the round and the channel dimensions
+        tensor = image[np.newaxis, np.newaxis, :, :, :]
+    elif image.ndim == 2:
+        # we had the round, the channel and the z dimensions
+        tensor = image[np.newaxis, np.newaxis, np.newaxis, :, :]
+    else:
+        # we raise an error otherwise
+        raise ValueError("Image should be in 2-d or 3-d. A {0}-d image is not "
+                         "processed yet.".format(len(image.shape)))
+
+    # cast the tensor as np.float32 and normalize it between 0 and 1
+    if isinstance(tensor, np.unsignedinteger):
+        tensor = img_as_float32(tensor)
+    else:
+        raise TypeError("{0} is not supported yet. Use unsigned integer "
+                        "instead".format(tensor.dtype))
+
+    return tensor
+
+
+def read_cell_json(path):
+    """Read the json file 'cellLibrary.json' used by FishQuant.
+
+    Parameters
+    ----------
+    path : str
+        Path of the json file to read.
+
+    Returns
+    -------
+    df : pandas DataFrame
+        Dataframe with the 2D coordinates of the nucleus and the cytoplasm of
+        actual cells used to simulate data.
+
+    """
+    # read json file and open it in a dataframe
+    df = pd.read_json(path)
+
+    # check the output has the right number of features
+    if df.ndim != 3:
+        raise ValueError("The file does not seem to have the right number of "
+                         "features. It returns {0} dimensions instead of 3."
+                         .format(df.ndim))
+
+    # check the output has the right features
+    col_names = df.columns
+    for col in col_names:
+        if col not in ["name_img_BGD", "pos_cell", "pos_nuc"]:
+            raise ValueError("The file does not seem to have the right "
+                             "features. The feature '{0}' does not exist."
+                             .format(col))
+
+    return df
+
+
+def read_rna_json(path):
+    """Read json files simulated by FishQuant with RNA 3D coordinates.
+
+    Parameters
+    ----------
+    path : str
+        Path of the json file to read.
+
+    Returns
+    -------
+    df : pandas.DataFrame
+        Dataframe with 3D coordinates of the simulated RNA, localization
+        pattern used to simulate them and its strength.
+
+    """
+    # read json file and open it in a dataframe
+    df = pd.read_json(path)
+
+    # check the output has the right number of features
+    if df.ndim != 9:
+        raise ValueError("The file does not seem to have the right number of "
+                         "features. It returns {0} dimensions instead of 9."
+                         .format(df.ndim))
+
+    # check the output has the right features
+    col_names = df.columns
+    for col in col_names:
+        if col not in ['RNA_pos', 'cell_ID', 'mRNA_level_avg',
+                       'mRNA_level_label', 'n_RNA', 'name_img_BGD',
+                       'pattern_level', 'pattern_name', 'pattern_prop']:
+            raise ValueError("The file does not seem to have the right "
+                             "features. The feature '{0}' does not exist."
+                             .format(col))
+
+    return df
+
+
+def build_simulated_dataset(path_cell, path_rna, path_output=None):
+    """Build a dataset from the simulated coordinates of the nucleus, the
+    cytoplasm and the RNA.
+
+    Parameters
+    ----------
+    path_cell : str
+        Path of the json file with the 2D nucleus and cytoplasm coordinates
+        used by FishQuant to simulate the data.
+    path_rna : str
+        Path of the json file with the 3D RNA localization simulated by
+        FishQuant. If it is the path of a folder, all its json files will be
+        aggregated.
+    path_output : str
+        Path of the output file with the merged dataset. The final dataframe is
+        serialized and store in a pickle file.
+
+    Returns
+    -------
+    df : pandas.DataFrame
+        Dataframe with all the simulated cells, the coordinates of their
+        different elements and the localization pattern used to simulate them.
+    df_cell : pandas.DataFrame
+        Dataframe with the 2D coordinates of the nucleus and the cytoplasm of
+        actual cells used to simulate data.
+    df_rna : pandas.DataFrame
+        Dataframe with 3D coordinates of the simulated RNA, localization
+        pattern used to simulate them and its strength.
+
+    """
+    # read the cell data (nucleus + cytoplasm)
+    df_cell = read_cell_json(path_cell)
+    print("data cell: {0}".format(df_cell.shape))
+
+    # read the RNA data
+    if os.path.isdir(path_rna):
+        # we concatenate all the json file in the folder
+        simulations = []
+        for filename in os.listdir(path_rna):
+            if ".json" in filename:
+                path = os.path.join(path_rna, filename)
+                df_ = read_rna_json(path)
+                simulations.append(df_)
+        df_rna = pd.concat(simulations)
+        df_rna.reset_index(drop=True, inplace=True)
+
+    else:
+        # we directly read the json file
+        df_rna = read_rna_json(path_rna)
+    print("data rna: {0}".format(df_rna.shape))
+
+    # merge the dataframe
+    df = pd.merge(df_rna, df_cell, on="name_img_BGD")
+    print("data: {0}".format(df.shape))
+
+    # save output
+    if path_output is not None:
+        df.to_pickle(path_output)
+
+    return df, df_cell, df_rna
+
+
+def read_pickle(path):
+    """Read serialized pickle file.
+
+    Parameters
+    ----------
+    path : str
+        Path of the file to read.
+
+    Returns
+    -------
+    data = pandas.DataFrame or np.ndarray
+        Data store in the pickle file (an image or coordinates with labels and
+        metadata).
+
+    """
+    # open the file and read it
+    with open(path, mode='rb') as f:
+        data = pickle.load(f)
+
+    return data

From a98401dd81b44fc0c80853d824d14f941627602c Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 5 Feb 2019 11:14:05 +0100
Subject: [PATCH 007/264] add empty scripts

---
 bigfish/stack/augmentation.py  |   0
 bigfish/stack/preparation.py   |   0
 bigfish/stack/preprocess.py    | 145 +++++++++++++++++++++++++++++++++
 bigfish/stack/preprocessing.py |   5 --
 4 files changed, 145 insertions(+), 5 deletions(-)
 create mode 100644 bigfish/stack/augmentation.py
 create mode 100644 bigfish/stack/preparation.py
 create mode 100644 bigfish/stack/preprocess.py
 delete mode 100644 bigfish/stack/preprocessing.py

diff --git a/bigfish/stack/augmentation.py b/bigfish/stack/augmentation.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
new file mode 100644
index 00000000..4aca2f62
--- /dev/null
+++ b/bigfish/stack/preprocess.py
@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions used to format any input tensor loaded in bigfish.
+"""
+
+import os
+
+import numpy as np
+import pandas as pd
+
+from scipy.sparse import coo_matrix
+from scipy import ndimage as ndi
+
+
+
+
+
+
+
+
+
+
+def check_volume(cyto_coord, nuc_coord):
+    """
+    cyto_coord: list
+    nuc_coord: list
+    """
+    # get coordinates
+    cyto = np.array(cyto_coord)
+    nuc = np.array(nuc_coord)
+
+    max_x = max(cyto[:, 0].max() + 5, nuc[:, 0].max() + 5)
+    max_y = max(cyto[:, 1].max() + 5, nuc[:, 1].max() + 5)
+
+    # build the dense representation for the cytoplasm
+    values = [1] * cyto.shape[0]
+    cyto = coo_matrix((values, (cyto[:, 0], cyto[:, 1])),
+                      shape=(max_x, max_y)).todense()
+
+    # build the dense representation for the nucleus
+    values = [1] * nuc.shape[0]
+    nuc = coo_matrix((values, (nuc[:, 0], nuc[:, 1])),
+                     shape=(max_x, max_y)).todense()
+
+    # check if the volume is valid
+    mask_cyto = ndi.binary_fill_holes(cyto)
+    mask_nuc = ndi.binary_fill_holes(nuc)
+    frame = np.zeros((max_x, max_y))
+    diff = frame - mask_cyto + mask_nuc
+    diff = (diff > 0).sum()
+
+    if diff > 0:
+        return False
+    else:
+        return True
+
+data_cell["valid"] = data_cell.apply(lambda row: check_volume(row["pos_cell"], row["pos_nuc"]), axis=1)
+
+
+background_to_remove = []
+for i in data_cell.index:
+    if np.logical_not(data_cell.loc[i, "valid"]):
+        plot_volume(data_cell, i)
+        background_to_remove.append(data_cell.loc[i, "name_img_BGD"])
+
+data_clean = data[~data["name_img_BGD"].isin(background_to_remove)]
+print(data.shape)
+print(data_clean.shape)
+
+
+def check_rna(rna_coord, nb_rna):
+    """
+    rna_coord: list
+    nb_rna: int
+    """
+    return nb_rna - len(rna_coord)
+
+
+data_clean.apply(lambda row: check_rna(row["RNA_pos"], row["n_RNA"]), axis=1).value_counts()
+
+
+def check_rna(cyto_coord, rna_coord):
+    """
+    cyto_coord: list
+    rna_coord: list
+    """
+    # get coordinates
+    cyto = np.array(cyto_coord)
+    if not isinstance(rna_coord[0], list):
+        # it means we have only one spot
+        return False
+    rna = np.array(rna_coord)
+
+    # check if the coordinates are positive
+    if rna.min() < 0:
+        return False
+
+    max_x = int(max(cyto[:, 0].max() + 5, rna[:, 0].max() + 5))
+    max_y = int(max(cyto[:, 1].max() + 5, rna[:, 1].max() + 5))
+
+    # build the dense representation for the cytoplasm
+    values = [1] * cyto.shape[0]
+    cyto = coo_matrix((values, (cyto[:, 0], cyto[:, 1])),
+                      shape=(max_x, max_y)).todense()
+
+    # build the dense representation for the rna
+    values = [1] * rna.shape[0]
+    rna = coo_matrix((values, (rna[:, 0], rna[:, 1])),
+                     shape=(max_x, max_y)).todense()
+    rna = (rna > 0)
+
+    # check if the coordinates are valid
+    mask_cyto = ndi.binary_fill_holes(cyto)
+    frame = np.zeros((max_x, max_y))
+    diff = frame - mask_cyto + rna
+    diff = (diff > 0).sum()
+
+    if diff > 0:
+        return False
+    else:
+        return True
+
+data_clean["valid"] = data_clean.apply(lambda row: check_rna(row["pos_cell"], row["RNA_pos"]), axis=1)
+
+data_clean = data_clean[data_clean["valid"]]
+print(data_clean.shape)
+data_clean.head()
+
+def count_rna(rna_coord):
+    """
+    rna_coord: list, rna spots coordinates
+    """
+    return len(rna_coord)
+
+data_clean["nb_rna"] = data_clean.apply(lambda row: count_rna(row["RNA_pos"]), axis=1)
+
+
+data_final = data_clean[['RNA_pos', 'cell_ID', 'pattern_level', 'pattern_name', 'pos_cell', 'pos_nuc', "nb_rna"]]
+print(data_final.shape)
+data_final.head()
+
+
+path_output = os.path.join(main_directory, "data_cleaned")
+data_final.to_pickle(path_output)
\ No newline at end of file
diff --git a/bigfish/stack/preprocessing.py b/bigfish/stack/preprocessing.py
deleted file mode 100644
index ab64f3d8..00000000
--- a/bigfish/stack/preprocessing.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-Functions used to format any input tensor loaded in bigfish.
-"""
\ No newline at end of file

From 7089e7d59afc86dcda9495cfc257d41dbcfe5688 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 5 Feb 2019 11:15:21 +0100
Subject: [PATCH 008/264] update read_tif()

---
 bigfish/stack/loader.py | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/bigfish/stack/loader.py b/bigfish/stack/loader.py
index 4a02a1f3..a34c22b1 100644
--- a/bigfish/stack/loader.py
+++ b/bigfish/stack/loader.py
@@ -28,24 +28,11 @@ def read_tif(path):
     Returns
     -------
     tensor : ndarray, np.float32
-        A 5-d tensor with shape (round, channel, z, y, x). Usually with smFISH
-        images there is only one round.
+        A 2-d or 3-d tensor with spatial dimensions.
 
     """
     # read image
-    image = io.imread(path)
-
-    # build the 5-d tensor
-    if image.ndim == 3:
-        # we had the round and the channel dimensions
-        tensor = image[np.newaxis, np.newaxis, :, :, :]
-    elif image.ndim == 2:
-        # we had the round, the channel and the z dimensions
-        tensor = image[np.newaxis, np.newaxis, np.newaxis, :, :]
-    else:
-        # we raise an error otherwise
-        raise ValueError("Image should be in 2-d or 3-d. A {0}-d image is not "
-                         "processed yet.".format(len(image.shape)))
+    tensor = io.imread(path)
 
     # cast the tensor as np.float32 and normalize it between 0 and 1
     if isinstance(tensor, np.unsignedinteger):

From a24987b6d126bd4bdc7b0a88888d31a9ec3e6e09 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 5 Feb 2019 11:38:55 +0100
Subject: [PATCH 009/264] update .gitignore

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index f5d9e2ec..531d5ccd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,7 +12,8 @@ big_fish.egg-info/
 notebooks/*
 
 # Data
-data/*
+data/input/*
+data/output/*
 
 # Cache
 __pycache__/

From e4f1bfce96e81884bcc9f6f21f144c69e4221ddd Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 5 Feb 2019 13:26:21 +0100
Subject: [PATCH 010/264] plot yx images

---
 bigfish/plot/__init__.py    | 10 ++++++
 bigfish/plot/plot_images.py | 71 +++++++++++++++++++++++++++++++++++++
 2 files changed, 81 insertions(+)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index e69de29b..38e5e0c6 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+"""
+The bigfish.plot module includes function to plot images and simulated data.
+"""
+
+from .plot_images import plot_yx
+
+
+__all__ = ["plot_yx"]
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index e69de29b..54f6f3c5 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+
+"""
+Function to plot 2-d images.
+"""
+
+import matplotlib.pyplot as plt
+
+
+def plot_yx(tensor, round=0, channel=0, z=0, title=None, path_output=None,
+            ext="png"):
+    """Plot the selected x and Y dimensions of an image.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.float32
+        A 2-d, 3-d or 5-d tensor with shape (y, x), (z, y, x) or
+        (round, channel, z, y, x) respectively.
+    round : int
+        Indice of the round to keep.
+    channel : int
+        Indice of the channel to keep.
+    z : int
+        Indice of the z slice to keep.
+    title : str
+        Title of the image.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or list
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+    xy_tensor : np.ndarray, np.float32
+        The 2-d tensor plotted.
+
+    """
+    # get the 2-d tensor
+    if tensor.ndim == 2:
+        xy_tensor = tensor
+    elif tensor.ndim == 3:
+        xy_tensor = tensor[z, :, :]
+    elif tensor.ndim == 5:
+        xy_tensor = tensor[round, channel, z, :, :]
+    else:
+        raise ValueError("{0} is not a valid shape for the tensor."
+                         .format(tensor.shape))
+
+    # plot
+    plt.figure(figsize=(15, 15))
+    plt.imshow(xy_tensor)
+    if title is not None:
+        plt.title(title, fontweight="bold", fontsize=25)
+    plt.axis('off')
+    plt.tight_layout()
+    plt.show()
+
+    # save the plot
+    if path_output is not None:
+        if isinstance(ext, str):
+            plt.savefig(path_output, format=ext)
+        elif isinstance(ext, list):
+            for ext_ in ext:
+                plt.savefig(path_output, format=ext_)
+        else:
+            Warning("Plot is not saved because the extension is not valid: "
+                    "{0}.".format(ext))
+
+    return xy_tensor
+

From 1d5862a162eb3366badea8c2b6479186e74ce14a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 5 Feb 2019 13:31:07 +0100
Subject: [PATCH 011/264] add framesize to 'plot_yx'

---
 bigfish/plot/plot_images.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 54f6f3c5..9b8a8408 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -7,8 +7,8 @@
 import matplotlib.pyplot as plt
 
 
-def plot_yx(tensor, round=0, channel=0, z=0, title=None, path_output=None,
-            ext="png"):
+def plot_yx(tensor, round=0, channel=0, z=0, title=None, framesize=(15, 15),
+            path_output=None, ext="png"):
     """Plot the selected x and Y dimensions of an image.
 
     Parameters
@@ -24,6 +24,8 @@ def plot_yx(tensor, round=0, channel=0, z=0, title=None, path_output=None,
         Indice of the z slice to keep.
     title : str
         Title of the image.
+    framesize : tuple
+        Size of the frame used to plot (plt.figure(figsize=framesize).
     path_output : str
         Path to save the image (without extension).
     ext : str or list
@@ -32,8 +34,6 @@ def plot_yx(tensor, round=0, channel=0, z=0, title=None, path_output=None,
 
     Returns
     -------
-    xy_tensor : np.ndarray, np.float32
-        The 2-d tensor plotted.
 
     """
     # get the 2-d tensor
@@ -48,7 +48,7 @@ def plot_yx(tensor, round=0, channel=0, z=0, title=None, path_output=None,
                          .format(tensor.shape))
 
     # plot
-    plt.figure(figsize=(15, 15))
+    plt.figure(figsize=framesize)
     plt.imshow(xy_tensor)
     if title is not None:
         plt.title(title, fontweight="bold", fontsize=25)
@@ -67,5 +67,5 @@ def plot_yx(tensor, round=0, channel=0, z=0, title=None, path_output=None,
             Warning("Plot is not saved because the extension is not valid: "
                     "{0}.".format(ext))
 
-    return xy_tensor
+    return
 

From 1c68eea21ef976944c009df7186c2b83627f296d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 6 Feb 2019 16:59:06 +0100
Subject: [PATCH 012/264] add main (empty) files for spot detection and
 segmentation

---
 bigfish/segmentation/segment.py  | 0
 bigfish/spot_detection/detect.py | 5 +++++
 2 files changed, 5 insertions(+)
 create mode 100644 bigfish/segmentation/segment.py
 create mode 100644 bigfish/spot_detection/detect.py

diff --git a/bigfish/segmentation/segment.py b/bigfish/segmentation/segment.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/spot_detection/detect.py b/bigfish/spot_detection/detect.py
new file mode 100644
index 00000000..18c5f521
--- /dev/null
+++ b/bigfish/spot_detection/detect.py
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+"""
+Class and functions to detect RNA spots in 2-d and 3-d.
+"""

From 080936068783aaa71be445beb7d6ecd5dde9b16b Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 6 Feb 2019 17:00:17 +0100
Subject: [PATCH 013/264] add 2D plot functions

---
 bigfish/plot/__init__.py    |  5 ++--
 bigfish/plot/plot_images.py | 56 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 58 insertions(+), 3 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index 38e5e0c6..f7693321 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -4,7 +4,8 @@
 The bigfish.plot module includes function to plot images and simulated data.
 """
 
-from .plot_images import plot_yx
+from .plot_images import plot_yx, plot_channels_2d
 
 
-__all__ = ["plot_yx"]
+__all__ = ["plot_yx",
+           "plot_channels_2d"]
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 9b8a8408..da933d05 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -9,7 +9,7 @@
 
 def plot_yx(tensor, round=0, channel=0, z=0, title=None, framesize=(15, 15),
             path_output=None, ext="png"):
-    """Plot the selected x and Y dimensions of an image.
+    """Plot the selected x and y dimensions of an image.
 
     Parameters
     ----------
@@ -56,6 +56,7 @@ def plot_yx(tensor, round=0, channel=0, z=0, title=None, framesize=(15, 15),
     plt.tight_layout()
     plt.show()
 
+    # TODO compare savefig with imsave
     # save the plot
     if path_output is not None:
         if isinstance(ext, str):
@@ -69,3 +70,56 @@ def plot_yx(tensor, round=0, channel=0, z=0, title=None, framesize=(15, 15),
 
     return
 
+
+def plot_channels_2d(tensor, round=0, z=0, framesize=(15, 15),
+                     path_output=None, ext="png"):
+    """Subplot the selected x and y dimensions of an image for all channels.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.float32
+        A 5-d tensor with shape (round, channel, z, y, x).
+    round : int
+        Indice of the round to keep.
+    z : int
+        Indice of the z slice to keep.
+    framesize : tuple
+        Size of the frame used to plot (plt.figure(figsize=framesize).
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or list
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # check tensor
+    if tensor.ndim != 5:
+        raise ValueError("Tensor should have 5 dimensions instead of {0}"
+                         .format(tensor.ndim))
+
+    # get the number of channels
+    nb_channels = tensor.shape[1]
+
+    # plot
+    fig, ax = plt.subplots(1, nb_channels, sharex='col', figsize=framesize)
+    for i in range(nb_channels):
+        ax[i].imshow(tensor[round, i, z, :, :])
+    plt.tight_layout()
+    plt.show()
+
+    # TODO compare savefig with imsave
+    # save the plot
+    if path_output is not None:
+        if isinstance(ext, str):
+            plt.savefig(path_output, format=ext)
+        elif isinstance(ext, list):
+            for ext_ in ext:
+                plt.savefig(path_output, format=ext_)
+        else:
+            Warning("Plot is not saved because the extension is not valid: "
+                    "{0}.".format(ext))
+
+    return

From 645937cb8b713402a630ae501afc5a387991cb32 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 6 Feb 2019 17:01:33 +0100
Subject: [PATCH 014/264] update read_tif function

---
 bigfish/stack/loader.py | 69 ++---------------------------------------
 1 file changed, 3 insertions(+), 66 deletions(-)

diff --git a/bigfish/stack/loader.py b/bigfish/stack/loader.py
index a34c22b1..d957c2e0 100644
--- a/bigfish/stack/loader.py
+++ b/bigfish/stack/loader.py
@@ -5,7 +5,6 @@
 multidimensional tensor (np.ndarray) or a dataframe (pandas.DataFrame).
 """
 
-import os
 import pickle
 
 import numpy as np
@@ -17,8 +16,8 @@
 def read_tif(path):
     """Read an image with the .tif or .tiff extension.
 
-    The input image should be in 2-d or 3-d, with unsigned integer. The output
-    tensor is normalized between 0 and 1.
+    The input image should be in 2-d or 3-d, with unsigned integer 16 bits.
+    The output tensor is normalized between 0 and 1.
 
     Parameters
     ----------
@@ -35,7 +34,7 @@ def read_tif(path):
     tensor = io.imread(path)
 
     # cast the tensor as np.float32 and normalize it between 0 and 1
-    if isinstance(tensor, np.unsignedinteger):
+    if isinstance(tensor, np.ndarray) and tensor.dtype == np.uint16:
         tensor = img_as_float32(tensor)
     else:
         raise TypeError("{0} is not supported yet. Use unsigned integer "
@@ -116,68 +115,6 @@ def read_rna_json(path):
     return df
 
 
-def build_simulated_dataset(path_cell, path_rna, path_output=None):
-    """Build a dataset from the simulated coordinates of the nucleus, the
-    cytoplasm and the RNA.
-
-    Parameters
-    ----------
-    path_cell : str
-        Path of the json file with the 2D nucleus and cytoplasm coordinates
-        used by FishQuant to simulate the data.
-    path_rna : str
-        Path of the json file with the 3D RNA localization simulated by
-        FishQuant. If it is the path of a folder, all its json files will be
-        aggregated.
-    path_output : str
-        Path of the output file with the merged dataset. The final dataframe is
-        serialized and store in a pickle file.
-
-    Returns
-    -------
-    df : pandas.DataFrame
-        Dataframe with all the simulated cells, the coordinates of their
-        different elements and the localization pattern used to simulate them.
-    df_cell : pandas.DataFrame
-        Dataframe with the 2D coordinates of the nucleus and the cytoplasm of
-        actual cells used to simulate data.
-    df_rna : pandas.DataFrame
-        Dataframe with 3D coordinates of the simulated RNA, localization
-        pattern used to simulate them and its strength.
-
-    """
-    # read the cell data (nucleus + cytoplasm)
-    df_cell = read_cell_json(path_cell)
-    print("data cell: {0}".format(df_cell.shape))
-
-    # read the RNA data
-    if os.path.isdir(path_rna):
-        # we concatenate all the json file in the folder
-        simulations = []
-        for filename in os.listdir(path_rna):
-            if ".json" in filename:
-                path = os.path.join(path_rna, filename)
-                df_ = read_rna_json(path)
-                simulations.append(df_)
-        df_rna = pd.concat(simulations)
-        df_rna.reset_index(drop=True, inplace=True)
-
-    else:
-        # we directly read the json file
-        df_rna = read_rna_json(path_rna)
-    print("data rna: {0}".format(df_rna.shape))
-
-    # merge the dataframe
-    df = pd.merge(df_rna, df_cell, on="name_img_BGD")
-    print("data: {0}".format(df.shape))
-
-    # save output
-    if path_output is not None:
-        df.to_pickle(path_output)
-
-    return df, df_cell, df_rna
-
-
 def read_pickle(path):
     """Read serialized pickle file.
 

From e6f8d53adf11b413493a51c47242dac6e1891442 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 11 Feb 2019 19:15:05 +0100
Subject: [PATCH 015/264] refactor segmentation subdirectory

---
 bigfish/segmentation/segmentation.py          | 28 +++++++++++++++++++
 .../segment.py => stack/filter.py}            |  0
 2 files changed, 28 insertions(+)
 create mode 100644 bigfish/segmentation/segmentation.py
 rename bigfish/{segmentation/segment.py => stack/filter.py} (100%)

diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
new file mode 100644
index 00000000..81506ba0
--- /dev/null
+++ b/bigfish/segmentation/segmentation.py
@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+"""
+Class and functions to segment nucleus and cytoplasm in 2-d and 3-d.
+"""
+
+from skimage.morphology import remove_small_objects
+from scipy import ndimage as ndi
+from bigfish import stack
+from skimage.measure import label
+
+
+def segnuc_threshold(image, filter_size=200, small_object_size=2000):
+    image_filtered = stack.remove_background(image, filter_size)
+    image_segmented = image_filtered >= 2
+    remove_small_objects(image_segmented,
+                         min_size=small_object_size,
+                         in_place=True)
+    image_segmented = ndi.binary_fill_holes(image_segmented)
+    return image_segmented
+
+
+def label_nucleus(image_segmented):
+    image_label, nb_labels = label(image_segmented, return_num=True)
+    return image_label, nb_labels
+
+
+
diff --git a/bigfish/segmentation/segment.py b/bigfish/stack/filter.py
similarity index 100%
rename from bigfish/segmentation/segment.py
rename to bigfish/stack/filter.py

From 568e0d51974ca588e0fa373e137b1fc1a659c0c5 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 11 Feb 2019 19:15:42 +0100
Subject: [PATCH 016/264] remove casting in float32 for tiff images

---
 bigfish/stack/loader.py | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/bigfish/stack/loader.py b/bigfish/stack/loader.py
index d957c2e0..ada2ae4e 100644
--- a/bigfish/stack/loader.py
+++ b/bigfish/stack/loader.py
@@ -10,14 +10,13 @@
 import numpy as np
 import pandas as pd
 
-from skimage import io, img_as_float32
+from skimage import io
 
 
 def read_tif(path):
     """Read an image with the .tif or .tiff extension.
 
     The input image should be in 2-d or 3-d, with unsigned integer 16 bits.
-    The output tensor is normalized between 0 and 1.
 
     Parameters
     ----------
@@ -26,19 +25,17 @@ def read_tif(path):
 
     Returns
     -------
-    tensor : ndarray, np.float32
+    tensor : ndarray, np.uint16
         A 2-d or 3-d tensor with spatial dimensions.
 
     """
     # read image
     tensor = io.imread(path)
 
-    # cast the tensor as np.float32 and normalize it between 0 and 1
-    if isinstance(tensor, np.ndarray) and tensor.dtype == np.uint16:
-        tensor = img_as_float32(tensor)
-    else:
-        raise TypeError("{0} is not supported yet. Use unsigned integer "
-                        "instead".format(tensor.dtype))
+    # check the image is in unsigned integer 16 bits
+    if not isinstance(tensor, np.ndarray) or tensor.dtype != np.uint16:
+        raise TypeError("{0} is not supported yet. Use unsigned integer 16 "
+                        "bits instead".format(tensor.dtype))
 
     return tensor
 

From 51d2d87500cf140c66cf6b0abf30eafd13b09980 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 11 Feb 2019 19:16:28 +0100
Subject: [PATCH 017/264] build stack and projections

---
 bigfish/stack/preprocess.py | 574 ++++++++++++++++++++++++++++++------
 1 file changed, 488 insertions(+), 86 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 4aca2f62..31055a1f 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 """
-Functions used to format any input tensor loaded in bigfish.
+Functions used to format and clean any input loaded in bigfish.
 """
 
 import os
@@ -9,137 +9,539 @@
 import numpy as np
 import pandas as pd
 
-from scipy.sparse import coo_matrix
-from scipy import ndimage as ndi
+from bigfish.stack.loader import read_tif, read_cell_json, read_rna_json
+
+from skimage import img_as_ubyte, img_as_float32
+from skimage.morphology.selem import square
+from skimage.filters import rank
+
+
+def build_simulated_dataset(path_cell, path_rna, path_output=None):
+    """Build a dataset from the simulated coordinates of the nucleus, the
+    cytoplasm and the RNA.
+
+    Parameters
+    ----------
+    path_cell : str
+        Path of the json file with the 2D nucleus and cytoplasm coordinates
+        used by FishQuant to simulate the data.
+    path_rna : str
+        Path of the json file with the 3D RNA localization simulated by
+        FishQuant. If it is the path of a folder, all its json files will be
+        aggregated.
+    path_output : str
+        Path of the output file with the merged dataset. The final dataframe is
+        serialized and store in a pickle file.
+
+    Returns
+    -------
+    df : pandas.DataFrame
+        Dataframe with all the simulated cells, the coordinates of their
+        different elements and the localization pattern used to simulate them.
+    df_cell : pandas.DataFrame
+        Dataframe with the 2D coordinates of the nucleus and the cytoplasm of
+        actual cells used to simulate data.
+    df_rna : pandas.DataFrame
+        Dataframe with 3D coordinates of the simulated RNA, localization
+        pattern used to simulate them and its strength.
 
+    """
+    # read the cell data (nucleus + cytoplasm)
+    df_cell = read_cell_json(path_cell)
+    print("data cell: {0}".format(df_cell.shape))
+
+    # read the RNA data
+    if os.path.isdir(path_rna):
+        # we concatenate all the json file in the folder
+        simulations = []
+        for filename in os.listdir(path_rna):
+            if ".json" in filename:
+                path = os.path.join(path_rna, filename)
+                df_ = read_rna_json(path)
+                simulations.append(df_)
+        df_rna = pd.concat(simulations)
+        df_rna.reset_index(drop=True, inplace=True)
+
+    else:
+        # we directly read the json file
+        df_rna = read_rna_json(path_rna)
+    print("data rna: {0}".format(df_rna.shape))
+
+    # merge the dataframe
+    df = pd.merge(df_rna, df_cell, on="name_img_BGD")
+    print("data: {0}".format(df.shape))
+
+    # save output
+    if path_output is not None:
+        df.to_pickle(path_output)
+
+    return df, df_cell, df_rna
+
+
+
+
+
+
+def build_stack(recipe, input_folder, input_dimension=None):
+    """
 
+    Parameters
+    ----------
+    recipe
+    input_folder
+    input_dimension
 
+    Returns
+    -------
 
+    """
+    if input_dimension is None:
+        fov_str = recipe["fov"]
+        ext_str = "." + recipe["ext"]
+        filenames = [filename
+                     for filename in os.listdir(input_folder)
+                     if fov_str in filename and ext_str in filename]
+        path = os.path.join(input_folder, filenames[0])
+        test = read_tif(path)
+        input_dimension = test.ndim
+
+    if input_dimension == 2:
+        stack = _build_stack_from_2d(recipe, input_folder)
+    elif input_dimension == 3:
+        stack = _build_stack_from_3d(recipe, input_folder)
+    elif input_dimension == 4:
+        stack = _build_stack_from_4d(recipe, input_folder)
+    else:
+        # TODO Error message
+        raise ValueError("Blablabla")
 
+    return stack
 
 
+def check_recipe(recipe):
+    """Check and validate a recipe.
 
+    Parameters
+    ----------
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions.
 
+    Returns
+    -------
+    expected_dimension : int
+        The number of dimensions expected in the tensors used with this
+        recipe. A 0 value means the recipe is not valid.
 
-def check_volume(cyto_coord, nuc_coord):
     """
-    cyto_coord: list
-    nuc_coord: list
+    expected_dimension = 0
+    # check recipe is a dictionary with the "fov" key
+    if not isinstance(recipe, dict) or "fov" not in recipe:
+        return expected_dimension
+
+    # determine the minimum number of dimensions expected for the tensors
+    if ("round" in recipe and isinstance(recipe["round"], list)
+            and len(recipe["round"]) > 0):
+        expected_dimension = 4
+    if ("channel" in recipe and isinstance(recipe["channel"], list)
+            and len(recipe["channel"]) > 0):
+        expected_dimension = 3
+    if ("z" in recipe and isinstance(recipe["z"], list)
+            and len(recipe["z"]) > 0):
+        expected_dimension = 2
+
+    return expected_dimension
+
+
+def _extract_recipe(recipe):
     """
-    # get coordinates
-    cyto = np.array(cyto_coord)
-    nuc = np.array(nuc_coord)
 
-    max_x = max(cyto[:, 0].max() + 5, nuc[:, 0].max() + 5)
-    max_y = max(cyto[:, 1].max() + 5, nuc[:, 1].max() + 5)
+    Parameters
+    ----------
+    recipe
 
-    # build the dense representation for the cytoplasm
-    values = [1] * cyto.shape[0]
-    cyto = coo_matrix((values, (cyto[:, 0], cyto[:, 1])),
-                      shape=(max_x, max_y)).todense()
+    Returns
+    -------
 
-    # build the dense representation for the nucleus
-    values = [1] * nuc.shape[0]
-    nuc = coo_matrix((values, (nuc[:, 0], nuc[:, 1])),
-                     shape=(max_x, max_y)).todense()
+    """
+    # check recipe
+    expected_dimension = check_recipe(recipe)
+    if expected_dimension == 0:
+        raise Exception("The recipe is not valid")
+
+    # we collect the different morphemes we use to identify the images
+    if ("round" in recipe
+            and isinstance(recipe["round"], list)
+            and len(recipe["round"]) > 0):
+        l_round = recipe["round"]
+    else:
+        l_round = [""]
 
-    # check if the volume is valid
-    mask_cyto = ndi.binary_fill_holes(cyto)
-    mask_nuc = ndi.binary_fill_holes(nuc)
-    frame = np.zeros((max_x, max_y))
-    diff = frame - mask_cyto + mask_nuc
-    diff = (diff > 0).sum()
+    if ("channel" in recipe
+            and isinstance(recipe["channel"], list)
+            and len(recipe["channel"]) > 0):
+        l_channel = recipe["channel"]
+    else:
+        l_channel = [""]
 
-    if diff > 0:
-        return False
+    if ("z" in recipe
+            and isinstance(recipe["z"], list)
+            and len(recipe["z"]) > 0):
+        l_z = recipe["z"]
     else:
-        return True
+        l_z = [""]
+
+    return expected_dimension, l_round, l_channel, l_z
+
+
+def _build_stack_from_2d(recipe, input_folder):
+    """
+
+    Parameters
+    ----------
+    recipe
+    input_folder
+
+    Returns
+    -------
+
+    """
+    # check we can find the tensors to stack from the recipe
+    expected_dimension, l_round, l_channel, l_z = _extract_recipe(recipe)
+
+    # stack the images
+    fov_str = recipe["fov"]
+    ext_str = "." + recipe["ext"]
+
+    tensors_4d = []
+    for round_str in l_round:
+        if round_str != "":
+            round_str = "_" + round_str
+
+        tensors_3d = []
+        for channel_str in l_channel:
+            if channel_str != "":
+                channel_str = "_" + channel_str
+
+            tensors_2d = []
+            for z_str in l_z:
+                if z_str != "":
+                    z_str = "_" + z_str
+
+                filename = fov_str + z_str + channel_str + round_str + ext_str
+
+                path = os.path.join(input_folder, filename)
+                tensor_2d = read_tif(path)
+                tensors_2d.append(tensor_2d)
+
+            tensor_3d = np.stack(tensors_2d, axis=0)
+            tensors_3d.append(tensor_3d)
+
+        tensor_4d = np.stack(tensors_3d, axis=0)
+        tensors_4d.append(tensor_4d)
+
+    tensor_5d = np.stack(tensors_4d, axis=0)
+
+    return tensor_5d
+
+
+def _build_stack_from_3d(recipe, input_folder):
+    """
+
+    Parameters
+    ----------
+    recipe
+    input_folder
+
+    Returns
+    -------
+
+    """
+    # check we can find the tensors to stack from the recipe
+    expected_dimension, l_round, l_channel, l_z = _extract_recipe(recipe)
+
+    # stack the images
+    fov_str = recipe["fov"]
+    ext_str = "." + recipe["ext"]
+
+    tensors_4d = []
+    for round_str in l_round:
+        if round_str != "":
+            round_str = "_" + round_str
+
+        tensors_3d = []
+        for channel_str in l_channel:
+            if channel_str != "":
+                channel_str = "_" + channel_str
+
+            filename = fov_str + channel_str + round_str + ext_str
 
-data_cell["valid"] = data_cell.apply(lambda row: check_volume(row["pos_cell"], row["pos_nuc"]), axis=1)
+            path = os.path.join(input_folder, filename)
+            tensor_3d = read_tif(path)
+            tensors_3d.append(tensor_3d)
 
+        tensor_4d = np.stack(tensors_3d, axis=0)
+        tensors_4d.append(tensor_4d)
 
-background_to_remove = []
-for i in data_cell.index:
-    if np.logical_not(data_cell.loc[i, "valid"]):
-        plot_volume(data_cell, i)
-        background_to_remove.append(data_cell.loc[i, "name_img_BGD"])
+    tensor_5d = np.stack(tensors_4d, axis=0)
 
-data_clean = data[~data["name_img_BGD"].isin(background_to_remove)]
-print(data.shape)
-print(data_clean.shape)
+    return tensor_5d
 
 
-def check_rna(rna_coord, nb_rna):
+def _build_stack_from_4d(recipe, input_folder):
     """
-    rna_coord: list
-    nb_rna: int
+
+    Parameters
+    ----------
+    recipe
+    input_folder
+
+    Returns
+    -------
+
     """
-    return nb_rna - len(rna_coord)
+    # check we can find the tensors to stack from the recipe
+    expected_dimension, l_round, l_channel, l_z = _extract_recipe(recipe)
+
+    # stack the images
+    fov_str = recipe["fov"]
+    ext_str = "." + recipe["ext"]
+
+    tensors_4d = []
+    for round_str in l_round:
+        if round_str != "":
+            round_str = "_" + round_str
+
+        filename = fov_str + round_str + ext_str
 
+        path = os.path.join(input_folder, filename)
+        tensor_4d = read_tif(path)
+        tensors_4d.append(tensor_4d)
 
-data_clean.apply(lambda row: check_rna(row["RNA_pos"], row["n_RNA"]), axis=1).value_counts()
+    tensor_5d = np.stack(tensors_4d, axis=0)
 
+    return tensor_5d
+
+
+def maximum_projection(tensor):
+    """Project the z-dimension of a tensor, keeping the maximum intensity of
+    each yx pixel.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.float32
+        A 5-d tensor with shape (round, channel, z, y, x).
+
+    Returns
+    -------
+    projected_tensor : np.ndarray, np.float32
+        A 5-d tensor with shape (round, channel, 1, y, x).
 
-def check_rna(cyto_coord, rna_coord):
     """
-    cyto_coord: list
-    rna_coord: list
+    # check tensor dimensions
+    if tensor.ndim != 5:
+        raise ValueError("Tensor should have 5 dimensions instead of {0}"
+                         .format(tensor.ndim))
+
+    # project tensor along the z axis
+    projected_tensor = tensor.max(axis=2, keepdims=True)
+
+    return projected_tensor
+
+
+def focus_measurement_2d(image, neighborhood_size):
+    """Helmli and Scherer’s mean method used as a focus metric.
+
+    For each pixel xy in an image, we compute the ratio:
+
+        R(x, y) = mu(x, y) / I(x, y), if mu(x, y) >= I(x, y)
+
+    or
+
+        R(x, y) = I(x, y) / mu(x, y), otherwise
+
+    with I(x, y) the intensity of the pixel xy and mu(x, y) the mean intensity
+    of the pixels of its neighborhood.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        A 2-d tensor with shape (y, x).
+    neighborhood_size : int
+        The size of the square used to define the neighborhood of each pixel.
+
+    Returns
+    -------
+    global_focus : np.float32
+        Mean value of the ratio computed for every pixels of the image. Can be
+        used as a metric to quantify the focus level of an 2-d image.
+    ratio : np.ndarray, np.float32
+        A 2-d tensor with the R(x, y) computed for each pixel of the original
+        image.
+    image_filtered_mean : np.ndarray, np.float32
+        A 2-d tensor with shape (y, x).
+
     """
-    # get coordinates
-    cyto = np.array(cyto_coord)
-    if not isinstance(rna_coord[0], list):
-        # it means we have only one spot
-        return False
-    rna = np.array(rna_coord)
 
-    # check if the coordinates are positive
-    if rna.min() < 0:
-        return False
+    # scikit-image filter use np.uint dtype (so we cast to np.uint8)
+    image_2d = img_as_ubyte(image)
+
+    # filter the image with a mean filter
+    selem = square(neighborhood_size)
+    image_filtered_mean = rank.mean(image_2d, selem)
+
+    # cast again in np.float32
+    image_2d = img_as_float32(image_2d)
+    image_filtered_mean = img_as_float32(image_filtered_mean)
 
-    max_x = int(max(cyto[:, 0].max() + 5, rna[:, 0].max() + 5))
-    max_y = int(max(cyto[:, 1].max() + 5, rna[:, 1].max() + 5))
+    # case where mu(x, y) >= I(x, y)
+    mask_1 = image_2d != 0
+    out_1 = np.zeros_like(image_filtered_mean, dtype=np.float32)
+    ratio_1 = np.divide(image_filtered_mean, image_2d, out=out_1, where=mask_1)
+    ratio_1 = np.where(image_filtered_mean >= image_2d, ratio_1, 0)
 
-    # build the dense representation for the cytoplasm
-    values = [1] * cyto.shape[0]
-    cyto = coo_matrix((values, (cyto[:, 0], cyto[:, 1])),
-                      shape=(max_x, max_y)).todense()
+    # case where I(x, y) > mu(x, y)
+    mask_2 = image_filtered_mean != 0
+    out_2 = np.zeros_like(image_2d, dtype=np.float32)
+    ratio_2 = np.divide(image_2d, image_filtered_mean, out=out_2, where=mask_2)
+    ratio_2 = np.where(image_2d > image_filtered_mean, ratio_2, 0)
 
-    # build the dense representation for the rna
-    values = [1] * rna.shape[0]
-    rna = coo_matrix((values, (rna[:, 0], rna[:, 1])),
-                     shape=(max_x, max_y)).todense()
-    rna = (rna > 0)
+    # compute ratio and global focus for the entire image
+    ratio = ratio_1 + ratio_2
+    global_focus = ratio.mean()
 
-    # check if the coordinates are valid
-    mask_cyto = ndi.binary_fill_holes(cyto)
-    frame = np.zeros((max_x, max_y))
-    diff = frame - mask_cyto + rna
-    diff = (diff > 0).sum()
+    return global_focus, ratio, image_filtered_mean
 
-    if diff > 0:
-        return False
+
+def focus_measurement_3d(image, neighborhood_size):
+    """Helmli and Scherer’s mean method used as a focus metric.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        A 3-d tensor with shape (z, y, x).
+    neighborhood_size : int
+        The size of the square used to define the neighborhood of each pixel.
+
+    Returns
+    -------
+    ratio : np.ndarray, np.float32
+        A 3-d tensor with the R(x, y) computed for each pixel of the original
+        3-d image, for each z-slice.
+    l_focus : list
+        List of the global focus computed for each z-slice.
+
+    """
+    # apply focus_measurement_2d for each z-slice
+    l_ratio = []
+    l_focus = []
+    for z in range(image.shape[0]):
+        focus, ratio_2d, _ = focus_measurement_2d(image[z], neighborhood_size)
+        l_ratio.append(ratio_2d)
+        l_focus.append(focus)
+
+    # get 3-d Helmli and Scherer’s ratio
+    ratio = np.stack(l_ratio)
+
+    return ratio, l_focus
+
+
+def get_in_focus(l_focus, proportion):
+    """ Select the best in-focus z-slices.
+
+    Parameters
+    ----------
+    l_focus : array_like
+        List of the global focus computed for each z-slice.
+    proportion : float or int
+        Proportion of z-slices to keep (float between 0 and 1) or number of
+        z-slices to keep (integer above 1).
+
+    Returns
+    -------
+    indices_to_keep : np.array
+    """
+    # get the number of z-slices to keep
+    if proportion < 1 and isinstance(proportion, float):
+        n = int(len(l_focus) * proportion)
     else:
-        return True
+        n = int(proportion)
 
-data_clean["valid"] = data_clean.apply(lambda row: check_rna(row["pos_cell"], row["RNA_pos"]), axis=1)
+    # select the best z-slices
+    indices_to_keep = np.argsort(l_focus)[-n:]
 
-data_clean = data_clean[data_clean["valid"]]
-print(data_clean.shape)
-data_clean.head()
+    return indices_to_keep
+
+
+def one_hot_3d(tensor_2d, depth):
+    """Build a 3-d one-hot matrix from a 2-d indices matrix.
+
+    Parameters
+    ----------
+    tensor_2d : np.ndarray, int
+        A 2-d tensor with integer indices and shape (y, x).
+    depth : int
+        Depth of the 3-d one-hot matrix.
+
+    Returns
+    -------
+    one_hot : np.ndarray, np.uint8
+        A 3-d binary tensor with shape (depth, y, x)
 
-def count_rna(rna_coord):
     """
-    rna_coord: list, rna spots coordinates
+    # initialize the 3-d one-hot matrix
+    one_hot = np.zeros((tensor_2d.size, depth), dtype=np.uint8)
+
+    # flatten the matrix to easily one-hot encode it, then reshape it
+    one_hot[np.arange(tensor_2d.size), tensor_2d.ravel()] = 1
+    one_hot.shape = tensor_2d.shape + (depth,)
+
+    # rearrange the axis
+    one_hot = np.moveaxis(one_hot, source=2, destination=0)
+
+    return one_hot
+
+
+def focus_projection(tensor, channel=0, p=0.75, global_neighborhood_size=30, method="best"):
     """
-    return len(rna_coord)
 
-data_clean["nb_rna"] = data_clean.apply(lambda row: count_rna(row["RNA_pos"]), axis=1)
+    Parameters
+    ----------
+    tensor
+    channel
+    p
+    global_neighborhood_size
+
+    Returns
+    -------
+
+    """
+
+    # get 3-d image
+    image = tensor[0, channel, :, :, :]
+
+    # measure global focus level for each z-slices
+    ratio, l_focus = focus_measurement_3d(image, global_neighborhood_size)
+
+    # remove out-of-focus slices
+    indices_to_keep = get_in_focus(l_focus, p)
+    in_focus_image = image[indices_to_keep]
+
+    projected_image = None
+    if method == "bast":
+        # for each pixel, we project the z-slice value with the highest focus
+        ratio_2d = np.argmax(ratio[indices_to_keep], axis=0)
+        one_hot = one_hot_3d(ratio_2d, depth=len(indices_to_keep))
+        projected_image = np.multiply(in_focus_image, one_hot).max(axis=0)
+    elif method == "median":
+        # for each pixel, we compute the median value of the in-focus z-slices
+        projected_image = np.median(in_focus_image, axis=0)
+    elif method == "mean":
+        # for each pixel, we compute the mean value of the in-focus z-slices
+        projected_image = np.median(in_focus_image, axis=0)
+
+    return projected_image, ratio, l_focus
 
 
-data_final = data_clean[['RNA_pos', 'cell_ID', 'pattern_level', 'pattern_name', 'pos_cell', 'pos_nuc', "nb_rna"]]
-print(data_final.shape)
-data_final.head()
 
 
-path_output = os.path.join(main_directory, "data_cleaned")
-data_final.to_pickle(path_output)
\ No newline at end of file

From d8678f2259b6bb31728e0c1d544c4d42bba7d581 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Feb 2019 11:45:55 +0100
Subject: [PATCH 018/264] add safety check for inputs

---
 bigfish/stack/loader.py |  34 +++--------
 bigfish/stack/utils.py  | 127 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 136 insertions(+), 25 deletions(-)
 create mode 100644 bigfish/stack/utils.py

diff --git a/bigfish/stack/loader.py b/bigfish/stack/loader.py
index ada2ae4e..e7e79c22 100644
--- a/bigfish/stack/loader.py
+++ b/bigfish/stack/loader.py
@@ -11,6 +11,7 @@
 import pandas as pd
 
 from skimage import io
+from .utils import check_array, check_features_df
 
 
 def read_tif(path):
@@ -32,10 +33,8 @@ def read_tif(path):
     # read image
     tensor = io.imread(path)
 
-    # check the image is in unsigned integer 16 bits
-    if not isinstance(tensor, np.ndarray) or tensor.dtype != np.uint16:
-        raise TypeError("{0} is not supported yet. Use unsigned integer 16 "
-                        "bits instead".format(tensor.dtype))
+    # check the image is in unsigned integer 16 bits with 2 or 3 dimensions
+    check_array(tensor, dtype=np.uint16, ndim=[2, 3])
 
     return tensor
 
@@ -50,7 +49,7 @@ def read_cell_json(path):
 
     Returns
     -------
-    df : pandas DataFrame
+    df : pd.DataFrame
         Dataframe with the 2D coordinates of the nucleus and the cytoplasm of
         actual cells used to simulate data.
 
@@ -58,19 +57,8 @@ def read_cell_json(path):
     # read json file and open it in a dataframe
     df = pd.read_json(path)
 
-    # check the output has the right number of features
-    if df.ndim != 3:
-        raise ValueError("The file does not seem to have the right number of "
-                         "features. It returns {0} dimensions instead of 3."
-                         .format(df.ndim))
-
     # check the output has the right features
-    col_names = df.columns
-    for col in col_names:
-        if col not in ["name_img_BGD", "pos_cell", "pos_nuc"]:
-            raise ValueError("The file does not seem to have the right "
-                             "features. The feature '{0}' does not exist."
-                             .format(col))
+    check_features_df(df, features=["name_img_BGD", "pos_cell", "pos_nuc"])
 
     return df
 
@@ -100,14 +88,10 @@ def read_rna_json(path):
                          .format(df.ndim))
 
     # check the output has the right features
-    col_names = df.columns
-    for col in col_names:
-        if col not in ['RNA_pos', 'cell_ID', 'mRNA_level_avg',
-                       'mRNA_level_label', 'n_RNA', 'name_img_BGD',
-                       'pattern_level', 'pattern_name', 'pattern_prop']:
-            raise ValueError("The file does not seem to have the right "
-                             "features. The feature '{0}' does not exist."
-                             .format(col))
+    expected_features = ['RNA_pos', 'cell_ID', 'mRNA_level_avg',
+                         'mRNA_level_label', 'n_RNA', 'name_img_BGD',
+                         'pattern_level', 'pattern_name', 'pattern_prop']
+    check_features_df(df, features=expected_features)
 
     return df
 
diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
new file mode 100644
index 00000000..648a37bc
--- /dev/null
+++ b/bigfish/stack/utils.py
@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+
+"""
+Utility functions.
+"""
+
+import numpy as np
+
+
+# TODO complete the checks for the dataframe (dtype, missing values).
+# ### Sanity checks ###
+
+def check_features_df(df, features):
+    """Check that the dataframe has the right features.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Dataframe to check.
+    features : List[str]
+        Names of the features expected.
+
+    Returns
+    -------
+
+    """
+    # get dataframe's features
+    col_names = df.columns
+
+    # sort the two lists
+    col_names.sort()
+    features.sort()
+
+    if col_names == features:
+        return
+    else:
+        raise ValueError("The file does not seem to have the right features. "
+                         "{0} instead of {1}".format(col_names, features))
+
+
+def check_array(array, ndim=None, dtype=None):
+    """Full safety check of an array.
+
+    Parameters
+    ----------
+    array : np.ndarray
+        Array to check.
+    ndim : int or List[int]
+        Number of dimensions expected.
+    dtype : type or List[type]
+        Types expected.
+    Returns
+    -------
+
+    """
+    # check the array itself
+    if not isinstance(array, np.ndarray):
+        raise ValueError("Data should be a np.ndarray instead of {0}."
+                         .format(type(array)))
+
+    # check the dtype
+    if dtype is not None:
+        check_dtype_array(array, dtype)
+
+    # check the number of dimension
+    if ndim is not None:
+        check_dim_array(array, ndim)
+
+    # TODO check the order of the dimensions
+
+    # TODO check nan
+
+    return
+
+
+def check_dtype_array(array, dtype):
+    """Check that a np.ndarray has the right dtype.
+
+    Parameters
+    ----------
+    array : np.ndarray
+        Array to check
+    dtype : type or List[type]
+        Type expected.
+
+    Returns
+    -------
+
+    """
+    # enlist the dtype expected
+    if isinstance(dtype, type):
+        dtype = [dtype]
+
+    # check the dtype of the array
+    for dtype_expected in dtype:
+        if isinstance(array, dtype_expected):
+            return
+    raise TypeError("{0} is not supported yet. Use one of those dtypes "
+                    "instead {1}.".format(array.dtype, dtype))
+
+
+def check_dim_array(array, ndim):
+    """Check that the array has the right number of dimensions.
+
+    Parameters
+    ----------
+    array : np.ndarray
+        Array to check.
+    ndim : int or List[int]
+        Number of dimensions expected
+
+    Returns
+    -------
+
+    """
+
+    # enlist the number of expected dimensions
+    if isinstance(ndim, int):
+        ndim = [ndim]
+
+    # check the number of dimensions of the array
+    if array.ndim in ndim:
+        return
+    else:
+        raise ValueError("Array can't have {0} dimension(s). Expected "
+                         "dimensions are: {1}.".format(array.ndim, ndim))
+

From 855b1e67749291c565387801c0b59792f762da11 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Feb 2019 12:45:24 +0100
Subject: [PATCH 019/264] misc

---
 bigfish/stack/utils.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 648a37bc..f75d373a 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 """
-Utility functions.
+Utility functions for bigfish.stack submodule.
 """
 
 import numpy as np
@@ -60,11 +60,11 @@ def check_array(array, ndim=None, dtype=None):
 
     # check the dtype
     if dtype is not None:
-        check_dtype_array(array, dtype)
+        _check_dtype_array(array, dtype)
 
     # check the number of dimension
     if ndim is not None:
-        check_dim_array(array, ndim)
+        _check_dim_array(array, ndim)
 
     # TODO check the order of the dimensions
 
@@ -73,7 +73,7 @@ def check_array(array, ndim=None, dtype=None):
     return
 
 
-def check_dtype_array(array, dtype):
+def _check_dtype_array(array, dtype):
     """Check that a np.ndarray has the right dtype.
 
     Parameters
@@ -99,7 +99,7 @@ def check_dtype_array(array, dtype):
                     "instead {1}.".format(array.dtype, dtype))
 
 
-def check_dim_array(array, ndim):
+def _check_dim_array(array, ndim):
     """Check that the array has the right number of dimensions.
 
     Parameters

From dda0c248ebae78009d4c872ea791a61bdd0a9ba3 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Feb 2019 13:05:03 +0100
Subject: [PATCH 020/264] fix dtype comparison

---
 bigfish/stack/utils.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index f75d373a..7b976a45 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -93,10 +93,10 @@ def _check_dtype_array(array, dtype):
 
     # check the dtype of the array
     for dtype_expected in dtype:
-        if isinstance(array, dtype_expected):
+        if array.dtype == dtype_expected:
             return
     raise TypeError("{0} is not supported yet. Use one of those dtypes "
-                    "instead {1}.".format(array.dtype, dtype))
+                    "instead: {1}.".format(array.dtype, dtype))
 
 
 def _check_dim_array(array, ndim):

From 69837040c4b159254ab0271ae20d2faf8fc5d77a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Feb 2019 15:44:29 +0100
Subject: [PATCH 021/264] improve dtype in 'build_stack' and add 'rescale'

---
 bigfish/stack/preprocess.py | 336 ++++++++++++++++++++++++++++--------
 1 file changed, 263 insertions(+), 73 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 31055a1f..6829c17a 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -9,13 +9,17 @@
 import numpy as np
 import pandas as pd
 
-from bigfish.stack.loader import read_tif, read_cell_json, read_rna_json
+from .loader import read_tif, read_cell_json, read_rna_json
+from .utils import check_array
 
 from skimage import img_as_ubyte, img_as_float32
 from skimage.morphology.selem import square
 from skimage.filters import rank
+from skimage.exposure import rescale_intensity
 
 
+# ### Simulated data ###
+
 def build_simulated_dataset(path_cell, path_rna, path_output=None):
     """Build a dataset from the simulated coordinates of the nucleus, the
     cytoplasm and the RNA.
@@ -78,23 +82,79 @@ def build_simulated_dataset(path_cell, path_rna, path_output=None):
     return df, df_cell, df_rna
 
 
-
-
-
+# ### Real data ###
 
 def build_stack(recipe, input_folder, input_dimension=None):
-    """
+    """Build a 5-d tensor from the same field of view (fov).
+
+    The function stacks a set of images using a recipe mapping the
+    different images with the dimensions they represent. Each stacking step
+    add a new dimension to the original tensors (eg. we stack 2-d images with
+    the same xy coordinates, but different depths to get a 3-d image). If the
+    files we need to build a new dimension are not included in the
+    recipe, an empty dimension is added. This operation is repeated until we
+    get a 5-d tensor. We first operate on the z dimension, then the
+    channels and eventually the rounds.
+
+    The recipe dictionary for one field of view takes the form:
+
+        {
+         "fov": str,
+         "z": List[str],
+         "c": List[str],
+         "r": List[str],
+         "ext": str
+         }
+
+    - A field of view is defined by an ID common to every images belonging to
+    the field of view ("fov").
+    - At least every images are in 2-d with x and y dimensions. So we need to
+    mention the round-dimension, the channel-dimension and the z-dimension to
+    add ("r", "c" and "z"). For these keys, we provide a list of
+    strings to identify the images to stack. By default, we assume the filename
+    fit the pattern fov_z_c_r.tif.
+    - An extra information to identify the files to stack in the input folder
+    can be provided with the file extension "ext" (usually 'tif' or 'tiff').
+
+    # TODO generalize with different filename patterns
+    # TODO allow a recipe without 'ext'
+
+    For example, let us assume 3-d images (zyx dimensions) saved as
+    "r03c03f01_405.tif", "r03c03f01_488.tif" and "r03c03f01_561.tif". The first
+    morpheme "r03c03f01" uniquely identifies a 3-d field of view. The second
+    morphemes "405", "488" and "561" identify three different channels we
+    want to stack. There is no round in this experiment. Thus, the recipe is:
+
+        {
+         "fov": "r03c03f01",
+         "c": ["405", "488", "561"],
+         "ext": "tif"
+         }
+
+    The function should return a tensor with shape (1, 3, z, y, x).
+
+    # TODO manage the order of the channel
 
     Parameters
     ----------
-    recipe
-    input_folder
-    input_dimension
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions.
+    input_folder : str
+        Path of the folder containing the images.
+    input_dimension : str
+        Number of dimensions of the loaded files.
 
     Returns
     -------
+    tensor : np.ndarray, np.uint
+        Tensor with shape (r, c, z, y, x).
 
     """
+    # check recipe
+    check_recipe(recipe)
+
+    # if the initial dimension of the files is unknown, we read one of them
     if input_dimension is None:
         fov_str = recipe["fov"]
         ext_str = "." + recipe["ext"]
@@ -102,18 +162,22 @@ def build_stack(recipe, input_folder, input_dimension=None):
                      for filename in os.listdir(input_folder)
                      if fov_str in filename and ext_str in filename]
         path = os.path.join(input_folder, filenames[0])
-        test = read_tif(path)
-        input_dimension = test.ndim
+        testfile = read_tif(path)
+        input_dimension = testfile.ndim
 
+    # we stack our files according to their initial dimension
     if input_dimension == 2:
         stack = _build_stack_from_2d(recipe, input_folder)
     elif input_dimension == 3:
         stack = _build_stack_from_3d(recipe, input_folder)
     elif input_dimension == 4:
         stack = _build_stack_from_4d(recipe, input_folder)
+    elif input_dimension == 5:
+        stack = _build_stack_from_5d(recipe, input_folder)
     else:
-        # TODO Error message
-        raise ValueError("Blablabla")
+        raise ValueError("Files do not have the right number of dimensions: "
+                         "{0}. The files we stack should be in 2-d, 3-d, 4-d "
+                         "or 5-d.".format(input_dimension))
 
     return stack
 
@@ -131,56 +195,59 @@ def check_recipe(recipe):
     -------
     expected_dimension : int
         The number of dimensions expected in the tensors used with this
-        recipe. A 0 value means the recipe is not valid.
+        recipe.
 
     """
-    expected_dimension = 0
     # check recipe is a dictionary with the "fov" key
-    if not isinstance(recipe, dict) or "fov" not in recipe:
-        return expected_dimension
+    if (not isinstance(recipe, dict)
+            or "fov" not in recipe
+            or "ext" not in recipe):
+        raise Exception("The recipe is not valid.")
 
     # determine the minimum number of dimensions expected for the tensors
-    if ("round" in recipe and isinstance(recipe["round"], list)
-            and len(recipe["round"]) > 0):
-        expected_dimension = 4
-    if ("channel" in recipe and isinstance(recipe["channel"], list)
-            and len(recipe["channel"]) > 0):
-        expected_dimension = 3
+    if ("r" in recipe and isinstance(recipe["r"], list)
+            and len(recipe["r"]) > 0):
+        return 4
+    if ("c" in recipe and isinstance(recipe["c"], list)
+            and len(recipe["c"]) > 0):
+        return 3
     if ("z" in recipe and isinstance(recipe["z"], list)
             and len(recipe["z"]) > 0):
-        expected_dimension = 2
-
-    return expected_dimension
+        return 2
+    raise Exception("The recipe is not valid.")
 
 
 def _extract_recipe(recipe):
-    """
+    """Extract morphemes from the recipe to correctly stack the files.
 
     Parameters
     ----------
-    recipe
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions.
 
     Returns
     -------
+    l_round : List[str]
+        List of morphemes used to catch the files from the right round.
+    l_channel : List[str]
+        List of morphemes used to catch the files from the right channel.
+    l_z : List[str]
+        List of morphemes used to catch the files from the right z.
 
     """
-    # check recipe
-    expected_dimension = check_recipe(recipe)
-    if expected_dimension == 0:
-        raise Exception("The recipe is not valid")
-
     # we collect the different morphemes we use to identify the images
-    if ("round" in recipe
-            and isinstance(recipe["round"], list)
-            and len(recipe["round"]) > 0):
-        l_round = recipe["round"]
+    if ("r" in recipe
+            and isinstance(recipe["r"], list)
+            and len(recipe["r"]) > 0):
+        l_round = recipe["r"]
     else:
         l_round = [""]
 
-    if ("channel" in recipe
-            and isinstance(recipe["channel"], list)
-            and len(recipe["channel"]) > 0):
-        l_channel = recipe["channel"]
+    if ("c" in recipe
+            and isinstance(recipe["c"], list)
+            and len(recipe["c"]) > 0):
+        l_channel = recipe["c"]
     else:
         l_channel = [""]
 
@@ -191,49 +258,54 @@ def _extract_recipe(recipe):
     else:
         l_z = [""]
 
-    return expected_dimension, l_round, l_channel, l_z
+    return l_round, l_channel, l_z
 
 
 def _build_stack_from_2d(recipe, input_folder):
-    """
+    """Load and stack 2-d tensors.
 
     Parameters
     ----------
-    recipe
-    input_folder
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions.
+    input_folder : str
+        Path of the folder containing the images.
 
     Returns
     -------
+    tensor_5d : np.ndarray, np.uint
+        Tensor with shape (r, c, z, y, x).
 
     """
     # check we can find the tensors to stack from the recipe
-    expected_dimension, l_round, l_channel, l_z = _extract_recipe(recipe)
+    l_round, l_channel, l_z = _extract_recipe(recipe)
 
-    # stack the images
+    # stack images from the same fov
     fov_str = recipe["fov"]
     ext_str = "." + recipe["ext"]
 
+    # stack 4-d tensors in 5-d
     tensors_4d = []
     for round_str in l_round:
         if round_str != "":
             round_str = "_" + round_str
 
+        # stack 3-d tensors in 4-d
         tensors_3d = []
         for channel_str in l_channel:
             if channel_str != "":
                 channel_str = "_" + channel_str
 
+            # stack 2-d tensors in 3-d
             tensors_2d = []
             for z_str in l_z:
                 if z_str != "":
                     z_str = "_" + z_str
-
                 filename = fov_str + z_str + channel_str + round_str + ext_str
-
                 path = os.path.join(input_folder, filename)
                 tensor_2d = read_tif(path)
                 tensors_2d.append(tensor_2d)
-
             tensor_3d = np.stack(tensors_2d, axis=0)
             tensors_3d.append(tensor_3d)
 
@@ -246,40 +318,44 @@ def _build_stack_from_2d(recipe, input_folder):
 
 
 def _build_stack_from_3d(recipe, input_folder):
-    """
+    """Load and stack 3-d tensors.
 
     Parameters
     ----------
-    recipe
-    input_folder
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions.
+    input_folder : str
+        Path of the folder containing the images.
 
     Returns
     -------
+    tensor_5d : np.ndarray, np.uint
+        Tensor with shape (r, c, z, y, x).
 
     """
     # check we can find the tensors to stack from the recipe
-    expected_dimension, l_round, l_channel, l_z = _extract_recipe(recipe)
+    l_round, l_channel, l_z = _extract_recipe(recipe)
 
-    # stack the images
+    # stack images from the same fov
     fov_str = recipe["fov"]
     ext_str = "." + recipe["ext"]
 
+    # stack 4-d tensors in 5-d
     tensors_4d = []
     for round_str in l_round:
         if round_str != "":
             round_str = "_" + round_str
 
+        # stack 3-d tensors in 4-d
         tensors_3d = []
         for channel_str in l_channel:
             if channel_str != "":
                 channel_str = "_" + channel_str
-
             filename = fov_str + channel_str + round_str + ext_str
-
             path = os.path.join(input_folder, filename)
             tensor_3d = read_tif(path)
             tensors_3d.append(tensor_3d)
-
         tensor_4d = np.stack(tensors_3d, axis=0)
         tensors_4d.append(tensor_4d)
 
@@ -289,40 +365,102 @@ def _build_stack_from_3d(recipe, input_folder):
 
 
 def _build_stack_from_4d(recipe, input_folder):
-    """
+    """Load and stack 4-d tensors.
 
     Parameters
     ----------
-    recipe
-    input_folder
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions.
+    input_folder : str
+        Path of the folder containing the images.
 
     Returns
     -------
+    tensor_5d : np.ndarray, np.uint
+        Tensor with shape (r, c, z, y, x).
 
     """
     # check we can find the tensors to stack from the recipe
-    expected_dimension, l_round, l_channel, l_z = _extract_recipe(recipe)
+    l_round, l_channel, l_z = _extract_recipe(recipe)
 
-    # stack the images
+    # stack images from the same fov
     fov_str = recipe["fov"]
     ext_str = "." + recipe["ext"]
 
+    # stack 4-d tensors in 5-d
     tensors_4d = []
     for round_str in l_round:
         if round_str != "":
             round_str = "_" + round_str
-
         filename = fov_str + round_str + ext_str
-
         path = os.path.join(input_folder, filename)
         tensor_4d = read_tif(path)
         tensors_4d.append(tensor_4d)
-
     tensor_5d = np.stack(tensors_4d, axis=0)
 
     return tensor_5d
 
 
+def _build_stack_from_5d(recipe, input_folder):
+    """Load directly a 5-d tensor.
+
+    Parameters
+    ----------
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions.
+    input_folder : str
+        Path of the folder containing the images.
+
+    Returns
+    -------
+    tensor_5d : np.ndarray, np.uint
+        Tensor with shape (r, c, z, y, x).
+
+    """
+    # stack the images
+    fov_str = recipe["fov"]
+    ext_str = "." + recipe["ext"]
+    filename = fov_str + ext_str
+    path = os.path.join(input_folder, filename)
+    tensor_5d = read_tif(path)
+
+    return tensor_5d
+
+
+# ### Projections 2-d ###
+
+def projection(tensor, method="mip"):
+    """ Project a tensor along the z-dimension.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.float32
+        A 5-d tensor with shape (r, c, z, y, x).
+    method : str
+        Method used to project ('mip', 'focus').
+
+    Returns
+    -------
+    projected_tensor : np.ndarray, np.float32
+        A 5-d tensor with shape (r, c, 1, y, x).
+
+    """
+    # check tensor dimensions and its dtype
+    check_array(tensor, ndim=5, dtype=np.float32)
+
+    # apply projection along the z-dimension
+    projected_tensor = None
+    if method == "mip":
+        projected_tensor = maximum_projection(tensor)
+    elif method == "focus":
+        # TODO complete focus projection with different strategies
+        raise ValueError("Focus projection is not implemented yet.")
+
+    return projected_tensor
+
+
 def maximum_projection(tensor):
     """Project the z-dimension of a tensor, keeping the maximum intensity of
     each yx pixel.
@@ -330,19 +468,14 @@ def maximum_projection(tensor):
     Parameters
     ----------
     tensor : np.ndarray, np.float32
-        A 5-d tensor with shape (round, channel, z, y, x).
+        A 5-d tensor with shape (r, c, z, y, x).
 
     Returns
     -------
     projected_tensor : np.ndarray, np.float32
-        A 5-d tensor with shape (round, channel, 1, y, x).
+        A 5-d tensor with shape (r, c, 1, y, x).
 
     """
-    # check tensor dimensions
-    if tensor.ndim != 5:
-        raise ValueError("Tensor should have 5 dimensions instead of {0}"
-                         .format(tensor.ndim))
-
     # project tensor along the z axis
     projected_tensor = tensor.max(axis=2, keepdims=True)
 
@@ -502,7 +635,8 @@ def one_hot_3d(tensor_2d, depth):
     return one_hot
 
 
-def focus_projection(tensor, channel=0, p=0.75, global_neighborhood_size=30, method="best"):
+def focus_projection(tensor, channel=0, p=0.75, global_neighborhood_size=30,
+                     method="best"):
     """
 
     Parameters
@@ -543,5 +677,61 @@ def focus_projection(tensor, channel=0, p=0.75, global_neighborhood_size=30, met
     return projected_image, ratio, l_focus
 
 
+# ### Normalization ###
+
+def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
+    """Rescale tensor values up to its dtype range.
 
+    Each round and each channel is rescaled independently.
+
+    We can improve the contrast of the image by stretching its range of
+    intensity values. To do that we provide a smaller range of pixel intensity
+    to rescale, spreading out the information contained in the original
+    histogram. Usually, we apply such normalization to smFish channels. Other
+    channels are simply rescale from the minimum and maximum intensity values
+    of the image to those of its dtype.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint16
+        Tensor to rescale with shape (r, c, z, y, x).
+    channel_to_stretch : int or List[int]
+        Channel to stretch.
+    stretching_percentile : float
+        Percentile to determine the maximum intensity value used to rescale
+        the image.
+
+    Returns
+    -------
+    tensor : np.ndarray, np.uint16
+        Tensor to rescale with shape (r, c, z, y, x).
+
+    """
+    # format 'channel_to_stretch'
+    if channel_to_stretch is None:
+        channel_to_stretch = []
+    elif isinstance(channel_to_stretch, int):
+        channel_to_stretch = [channel_to_stretch]
+
+    # rescale each round independently
+    rounds = []
+    for r in range(tensor.shape[0]):
+
+        # rescale each channel independently
+        channels = []
+        for i in range(tensor.shape[1]):
+            channel = tensor[r, i, :, :, :]
+            if i in channel_to_stretch:
+                pa, pb = np.percentile(channel, (0, stretching_percentile))
+                channel_rescaled = rescale_intensity(channel,
+                                                     in_range=(pa, pb))
+            else:
+                channel_rescaled = rescale_intensity(channel)
+            channels.append(channel_rescaled)
+        tensor_4d = np.stack(channels, axis=0)
+        rounds.append(tensor_4d)
+
+    tensor_5d = np.stack(rounds, axis=0)
+
+    return tensor_5d
 

From e0a05d69d5b33ece1ace561e419d7ff6334dfe4a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Feb 2019 16:49:26 +0100
Subject: [PATCH 022/264] add log filter

---
 bigfish/stack/preprocess.py | 111 ++++++++++++++++++++++++++++++++++--
 1 file changed, 106 insertions(+), 5 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 6829c17a..b7538d6f 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -5,6 +5,7 @@
 """
 
 import os
+import warnings
 
 import numpy as np
 import pandas as pd
@@ -17,6 +18,8 @@
 from skimage.filters import rank
 from skimage.exposure import rescale_intensity
 
+from scipy.ndimage import gaussian_laplace
+
 
 # ### Simulated data ###
 
@@ -436,19 +439,19 @@ def projection(tensor, method="mip"):
 
     Parameters
     ----------
-    tensor : np.ndarray, np.float32
+    tensor : np.ndarray, np.uint16
         A 5-d tensor with shape (r, c, z, y, x).
     method : str
         Method used to project ('mip', 'focus').
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.float32
+    projected_tensor : np.ndarray, np.uint16
         A 5-d tensor with shape (r, c, 1, y, x).
 
     """
     # check tensor dimensions and its dtype
-    check_array(tensor, ndim=5, dtype=np.float32)
+    check_array(tensor, ndim=5, dtype=np.uint16)
 
     # apply projection along the z-dimension
     projected_tensor = None
@@ -467,12 +470,12 @@ def maximum_projection(tensor):
 
     Parameters
     ----------
-    tensor : np.ndarray, np.float32
+    tensor : np.ndarray, np.uint16
         A 5-d tensor with shape (r, c, z, y, x).
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.float32
+    projected_tensor : np.ndarray, np.uint16
         A 5-d tensor with shape (r, c, 1, y, x).
 
     """
@@ -735,3 +738,101 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
 
     return tensor_5d
 
+
+def cast_uint8(tensor):
+    """Cast the data in np.uint8.
+
+    Cast data from np.uint16 to np.uint8 reduce the memory needed to process
+    it and accelerate computations.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint16
+        Tensor to cast with shape (r, c, z, y, x).
+
+    Returns
+    -------
+    tensor : np.ndarray, np.uint8
+        Tensor with shape (r, c, z, y, x).
+
+    """
+    # cast tensor
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        tensor = img_as_ubyte(tensor)
+
+    return tensor
+
+
+def cast_float32(tensor):
+    """Cast the data in np.float32 and scale it between 0 and 1.
+
+    Parameters
+    ----------
+    tensor : np.ndarray
+        Tensor to cast with shape (r, c, z, y, x).
+
+    Returns
+    -------
+    tensor : np.ndarray, np.float32
+        Tensor with shape (r, c, z, y, x).
+
+    """
+    # cast tensor
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        tensor = img_as_float32(tensor)
+
+    return tensor
+
+
+# ### Filters ###
+
+def remove_background(image, filter_size):
+    """
+
+    Parameters
+    ----------
+    image
+    filter_size
+
+    Returns
+    -------
+
+    """
+    # TODO to complete
+    background = rank.mean(image, square(filter_size))
+    mask = image > background
+    image_without_back = np.subtract(image, background,
+                                     out=np.zeros_like(image, dtype=np.uint8),
+                                     where=mask)
+    return image_without_back
+
+
+def log_filter(image, sigma):
+    """Apply a Laplacian of Gaussian filter to a 2-d or 3-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint16
+        Image with shape (z, y, x) or (y, x).
+    sigma : float or Tuple(float)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.float32
+        Filtered image
+    """
+    # we cast the data in np.float32 to allow negative values
+    image_float32 = cast_float32(image)
+
+    # we apply LoG filter
+    image_filtered = gaussian_laplace(image_float32, sigma=sigma)
+
+    # as the LoG filter makes the peaks in the original image appear as a
+    # reversed mexican hat, we inverse the result and clip negative values to 0
+    image_filtered = np.clip(-image_filtered, a_min=0, a_max=None)
+
+    return image_filtered

From 96b915eefdd9cf2b9520d76af3278753e990f42c Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Feb 2019 17:02:27 +0100
Subject: [PATCH 023/264] refactor filters

---
 bigfish/stack/filter.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 bigfish/stack/filter.py

diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
deleted file mode 100644
index e69de29b..00000000

From ed41ca4336bb1daaeace3ecc84951928fc5260be Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Feb 2019 17:03:08 +0100
Subject: [PATCH 024/264] refactor check ndim

---
 bigfish/stack/utils.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 7b976a45..60e54850 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -119,9 +119,6 @@ def _check_dim_array(array, ndim):
         ndim = [ndim]
 
     # check the number of dimensions of the array
-    if array.ndim in ndim:
-        return
-    else:
+    if array.ndim not in ndim:
         raise ValueError("Array can't have {0} dimension(s). Expected "
                          "dimensions are: {1}.".format(array.ndim, ndim))
-

From 8c351dd809c3de3b0bfc4c5dd62c3162fd15da99 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Feb 2019 18:04:29 +0100
Subject: [PATCH 025/264]  add filters and kernel definition

---
 bigfish/stack/preprocess.py | 217 ++++++++++++++++++++++++++++++++++--
 1 file changed, 208 insertions(+), 9 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index b7538d6f..533b1487 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -14,7 +14,7 @@
 from .utils import check_array
 
 from skimage import img_as_ubyte, img_as_float32
-from skimage.morphology.selem import square
+from skimage.morphology.selem import square, diamond, rectangle, disk
 from skimage.filters import rank
 from skimage.exposure import rescale_intensity
 
@@ -434,7 +434,7 @@ def _build_stack_from_5d(recipe, input_folder):
 
 # ### Projections 2-d ###
 
-def projection(tensor, method="mip"):
+def projection(tensor, method="mip", r=0, c=0):
     """ Project a tensor along the z-dimension.
 
     Parameters
@@ -443,20 +443,24 @@ def projection(tensor, method="mip"):
         A 5-d tensor with shape (r, c, z, y, x).
     method : str
         Method used to project ('mip', 'focus').
+    r : int
+        Index of a specific round to project.
+    c : int
+        Index of a specific channel to project.
 
     Returns
     -------
     projected_tensor : np.ndarray, np.uint16
-        A 5-d tensor with shape (r, c, 1, y, x).
+        A 2-d tensor with shape (y, x).
 
     """
     # check tensor dimensions and its dtype
     check_array(tensor, ndim=5, dtype=np.uint16)
 
     # apply projection along the z-dimension
-    projected_tensor = None
+    projected_tensor = tensor[r, c, :, :, :]
     if method == "mip":
-        projected_tensor = maximum_projection(tensor)
+        projected_tensor = maximum_projection(projected_tensor)
     elif method == "focus":
         # TODO complete focus projection with different strategies
         raise ValueError("Focus projection is not implemented yet.")
@@ -471,18 +475,18 @@ def maximum_projection(tensor):
     Parameters
     ----------
     tensor : np.ndarray, np.uint16
-        A 5-d tensor with shape (r, c, z, y, x).
+        A 3-d tensor with shape (z, y, x).
 
     Returns
     -------
     projected_tensor : np.ndarray, np.uint16
-        A 5-d tensor with shape (r, c, 1, y, x).
+        A 2-d tensor with shape (y, x).
 
     """
     # project tensor along the z axis
-    projected_tensor = tensor.max(axis=2, keepdims=True)
+    projected_tensor = tensor.max(axis=0, keepdims=True)
 
-    return projected_tensor
+    return projected_tensor[0]
 
 
 def focus_measurement_2d(image, neighborhood_size):
@@ -809,6 +813,201 @@ def remove_background(image, filter_size):
     return image_without_back
 
 
+def _define_kernel(shape, size, dtype):
+    """Build a kernel to apply a filter on images.
+
+    Parameters
+    ----------
+    shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+    dtype : type
+        Dtype used for the kernel (the same as the image).
+
+    Returns
+    -------
+    kernel : skimage.morphology.selem object
+        Kernel to use with a skimage filter.
+
+    """
+    # build the kernel
+    if shape == "diamond":
+        kernel = diamond(size, dtype=dtype)
+    elif shape == "disk":
+        kernel = disk(size, dtype=dtype)
+    elif shape == "rectangle" and isinstance(size, tuple):
+        kernel = rectangle(size[0], size[1], dtype=dtype)
+    elif shape == "square":
+        kernel = square(size, dtype=dtype)
+    else:
+        raise ValueError("Kernel definition is wrong.")
+
+    return kernel
+
+
+def mean_filter(image, kernel_shape, kernel_size):
+    """Apply a mean filter to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint16
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint16
+        Filtered 2-d image with shape (y, x).
+
+    """
+
+    # get kernel
+    kernel = _define_kernel(shape=kernel_shape,
+                            size=kernel_size,
+                            dtype=image.dtype)
+
+    # apply filter
+    image_filtered = rank.mean(image, kernel)
+
+    return image_filtered
+
+
+def median_filter(image, kernel_shape, kernel_size):
+    """Apply a median filter to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint16
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint16
+        Filtered 2-d image with shape (y, x).
+
+    """
+
+    # get kernel
+    kernel = _define_kernel(shape=kernel_shape,
+                            size=kernel_size,
+                            dtype=image.dtype)
+
+    # apply filter
+    image_filtered = rank.median(image, kernel)
+
+    return image_filtered
+
+
+def maximum_filter(image, kernel_shape, kernel_size):
+    """Apply a maximum filter to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint16
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint16
+        Filtered 2-d image with shape (y, x).
+
+    """
+
+    # get kernel
+    kernel = _define_kernel(shape=kernel_shape,
+                            size=kernel_size,
+                            dtype=image.dtype)
+
+    # apply filter
+    image_filtered = rank.maximum(image, kernel)
+
+    return image_filtered
+
+
+def minimum_filter(image, kernel_shape, kernel_size):
+    """Apply a minimum filter to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint16
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint16
+        Filtered 2-d image with shape (y, x).
+
+    """
+
+    # get kernel
+    kernel = _define_kernel(shape=kernel_shape,
+                            size=kernel_size,
+                            dtype=image.dtype)
+
+    # apply filter
+    image_filtered = rank.minimum(image, kernel)
+
+    return image_filtered
+
+
+def subtract_mean_filter(image, kernel_shape, kernel_size):
+    """Apply a mean filter to a 2-d image and an image subtract from it.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint16
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint16
+        Filtered 2-d image with shape (y, x).
+
+    """
+
+    # get kernel
+    kernel = _define_kernel(shape=kernel_shape,
+                            size=kernel_size,
+                            dtype=image.dtype)
+
+    # apply filter
+    image_filtered = rank.subtract_mean(image, kernel)
+
+    return image_filtered
+
+
 def log_filter(image, sigma):
     """Apply a Laplacian of Gaussian filter to a 2-d or 3-d image.
 

From 8ca2b915bdc35b1cecc3e62735e0e684adf0c465 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Feb 2019 12:27:38 +0100
Subject: [PATCH 026/264] add 'load_stack' and 'build_stack'

---
 bigfish/stack/preprocess.py | 107 ++++++++++++++++--------------------
 1 file changed, 46 insertions(+), 61 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 533b1487..9498168c 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -87,7 +87,45 @@ def build_simulated_dataset(path_cell, path_rna, path_output=None):
 
 # ### Real data ###
 
-def build_stack(recipe, input_folder, input_dimension=None):
+def build_stack(recipe, input_folder, input_dimension=None,
+                channel_to_stretch=None, stretching_percentile=99.9):
+    """Build 5-d stack and normalize it.
+
+    Parameters
+    ----------
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions.
+    input_folder : str
+        Path of the folder containing the images.
+    input_dimension : str
+        Number of dimensions of the loaded files.
+    channel_to_stretch : int or List[int]
+        Channel to stretch.
+    stretching_percentile : float
+        Percentile to determine the maximum intensity value used to rescale
+        the image.
+
+    Returns
+    -------
+    tensor : np.ndarray, np.uint8
+        Tensor with shape (r, c, z, y, x).
+
+    """
+    # build stack from recipe and tif files
+    tensor = load_stack(recipe, input_folder, input_dimension)
+
+    # rescale data and improve contrast
+    tensor = rescale(tensor, channel_to_stretch, stretching_percentile)
+
+    # cast in np.uint8 if necessary, in order to reduce memory allocation
+    if tensor.dtype == np.uint16:
+        tensor = cast_uint8(tensor)
+
+    return tensor
+
+
+def load_stack(recipe, input_folder, input_dimension=None):
     """Build a 5-d tensor from the same field of view (fov).
 
     The function stacks a set of images using a recipe mapping the
@@ -439,7 +477,7 @@ def projection(tensor, method="mip", r=0, c=0):
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint16
+    tensor : np.ndarray, np.uint8
         A 5-d tensor with shape (r, c, z, y, x).
     method : str
         Method used to project ('mip', 'focus').
@@ -450,12 +488,12 @@ def projection(tensor, method="mip", r=0, c=0):
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.uint16
+    projected_tensor : np.ndarray, np.uint8
         A 2-d tensor with shape (y, x).
 
     """
     # check tensor dimensions and its dtype
-    check_array(tensor, ndim=5, dtype=np.uint16)
+    check_array(tensor, ndim=5, dtype=np.uint8)
 
     # apply projection along the z-dimension
     projected_tensor = tensor[r, c, :, :, :]
@@ -474,12 +512,12 @@ def maximum_projection(tensor):
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint16
+    tensor : np.ndarray, np.uint8
         A 3-d tensor with shape (z, y, x).
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.uint16
+    projected_tensor : np.ndarray, np.uint8
         A 2-d tensor with shape (y, x).
 
     """
@@ -700,7 +738,7 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint16
+    tensor : np.ndarray, np.uint
         Tensor to rescale with shape (r, c, z, y, x).
     channel_to_stretch : int or List[int]
         Channel to stretch.
@@ -710,7 +748,7 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
 
     Returns
     -------
-    tensor : np.ndarray, np.uint16
+    tensor : np.ndarray, np.uint
         Tensor to rescale with shape (r, c, z, y, x).
 
     """
@@ -792,27 +830,6 @@ def cast_float32(tensor):
 
 # ### Filters ###
 
-def remove_background(image, filter_size):
-    """
-
-    Parameters
-    ----------
-    image
-    filter_size
-
-    Returns
-    -------
-
-    """
-    # TODO to complete
-    background = rank.mean(image, square(filter_size))
-    mask = image > background
-    image_without_back = np.subtract(image, background,
-                                     out=np.zeros_like(image, dtype=np.uint8),
-                                     where=mask)
-    return image_without_back
-
-
 def _define_kernel(shape, size, dtype):
     """Build a kernel to apply a filter on images.
 
@@ -976,38 +993,6 @@ def minimum_filter(image, kernel_shape, kernel_size):
     return image_filtered
 
 
-def subtract_mean_filter(image, kernel_shape, kernel_size):
-    """Apply a mean filter to a 2-d image and an image subtract from it.
-
-    Parameters
-    ----------
-    image : np.ndarray, np.uint16
-        Image with shape (y, x).
-    kernel_shape : str
-        Shape of the kernel used to compute the filter ('diamond', 'disk',
-        'rectangle' or 'square').
-    kernel_size : int or Tuple(int)
-        The size of the kernel. For the rectangle we expect two integers
-        (width, height).
-
-    Returns
-    -------
-    image_filtered : np.ndarray, np.uint16
-        Filtered 2-d image with shape (y, x).
-
-    """
-
-    # get kernel
-    kernel = _define_kernel(shape=kernel_shape,
-                            size=kernel_size,
-                            dtype=image.dtype)
-
-    # apply filter
-    image_filtered = rank.subtract_mean(image, kernel)
-
-    return image_filtered
-
-
 def log_filter(image, sigma):
     """Apply a Laplacian of Gaussian filter to a 2-d or 3-d image.
 

From 00d7909c911d7c03fc9669075dd3c15123923df4 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Feb 2019 12:28:34 +0100
Subject: [PATCH 027/264] add nuclei segmentation in 2D with threshold

---
 bigfish/segmentation/__init__.py     |  11 +++
 bigfish/segmentation/segmentation.py | 143 +++++++++++++++++++++++++--
 2 files changed, 148 insertions(+), 6 deletions(-)

diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index e69de29b..6fc57d16 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+"""
+The bigfish.segment module includes function to segment nucleus, cytoplasm and
+label them.
+"""
+
+from .segmentation import nuc_segmentation_2d
+
+
+__all__ = ["nuc_segmentation_2d"]
diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
index 81506ba0..71ae7203 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/segmentation.py
@@ -4,23 +4,154 @@
 Class and functions to segment nucleus and cytoplasm in 2-d and 3-d.
 """
 
-from skimage.morphology import remove_small_objects
-from scipy import ndimage as ndi
 from bigfish import stack
+
+from skimage.morphology import remove_small_objects
 from skimage.measure import label
+from scipy import ndimage as ndi
+import numpy as np
+
+
+def nuc_segmentation_2d(tensor, r=0, nuc_channel=0, method="threshold"):
+    """Segment nuclei from a 2d projection.
+
+    Parameters
+    ----------
+    tensor : nd.ndarray, np.uint8
+        Tensor with shape (r, c, z, y, x).
+    r : int
+        Round index to segment.
+    nuc_channel : int
+        Channel index of the dapi image.
+    method : str
+        Method used to segment.
+
+    Returns
+    -------
+    image_segmented : np.ndarray, np.uint8
+        Binary 2-d image with shape (y, x).
+    image_labelled : np.ndarray, np.uint8
+        Image with labelled segmented instances and shape (y, x).
+    nb_labels : int
+        Number of different instances segmented.
+    """
+    # get 2D dapi image
+    image_2d = stack.projection(tensor, method="mip", r=r, c=nuc_channel)
+
+    # apply segmentation
+    image_segmented = None
+    if method == "threshold":
+        # TODO be able to change the parameters of 'filtered_threshold'
+        image_segmented = filtered_threshold(image_2d)
+
+    # labelled and count segmented instances
+    if label:
+        image_labelled, nb_labels = label_instances(image_segmented)
+        return image_segmented, image_labelled, nb_labels
+    else:
+        return image_segmented
+
+
+def filtered_threshold(image, kernel_shape="disk", kernel_size=200,
+                       threshold=2, small_object_size=2000):
+    """Segment a 2-d image to discriminate object from background.
+
+    1) Compute background noise applying a large mean filter.
+    2) remove this background from original image, clipping negative values
+    to 0.
+    3) Apply a threshold in the image
+    4) Remove object with a small pixel area.
+    5) Fill in holes in the segmented objects.
 
+    Parameters
+    ----------
+    image : np.ndarray, np.uint8
+        A 2-d image to segment with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+    threshold : int
+        Pixel intensity threshold used to discriminate background from nuclei.
+    small_object_size : int
+        Pixel area of small objects removed after segmentation.
 
-def segnuc_threshold(image, filter_size=200, small_object_size=2000):
-    image_filtered = stack.remove_background(image, filter_size)
-    image_segmented = image_filtered >= 2
+    Returns
+    -------
+    image_segmented : np.ndarray, np.uint8
+        Binary 2-d image with shape (y, x).
+
+    """
+    # remove background noise from image
+    image = _remove_background(image,
+                               kernel_shape=kernel_shape,
+                               kernel_size=kernel_size)
+
+    # discriminate nuclei from background, applying a threshold.
+    image_segmented = image >= threshold
+
+    # clean the segmented result
     remove_small_objects(image_segmented,
                          min_size=small_object_size,
                          in_place=True)
     image_segmented = ndi.binary_fill_holes(image_segmented)
+
     return image_segmented
 
 
-def label_nucleus(image_segmented):
+def _remove_background(image, kernel_shape="disk", kernel_size=200):
+    """Remove background noise from a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint8
+        Image to process. Casting in np.uint8 makes the computation faster.
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_without_back : np.ndarray, np.uint8
+        Image processed.
+
+    """
+    # compute background noise with a large mean filter
+    background = stack.mean_filter(image,
+                                   kernel_shape=kernel_shape,
+                                   kernel_size=kernel_size)
+    # subtract the background from the original image, clipping negative
+    # values to 0
+    mask = image > background
+    image_without_back = np.subtract(image, background,
+                                     out=np.zeros_like(image, dtype=np.uint8),
+                                     where=mask)
+
+    return image_without_back
+
+
+def label_instances(image_segmented):
+    """Count and label the different instances previously segmented in an
+    image.
+
+    Parameters
+    ----------
+    image_segmented : np.ndarray, np.uint8
+        Binary segmented image with shape (y, x).
+
+    Returns
+    -------
+    image_label : np.ndarray, np.uint8
+        Labelled image. Each object is characterized by the same pixel value.
+    nb_labels : int
+        Number of different instances counted in the image.
+
+    """
     image_label, nb_labels = label(image_segmented, return_num=True)
     return image_label, nb_labels
 

From 955845398496c0f088caa4547b380b7da06a86be Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Feb 2019 12:29:12 +0100
Subject: [PATCH 028/264] update __init__.py

---
 bigfish/stack/__init__.py | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 09eb5e9e..36d29aa6 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -1,13 +1,29 @@
 # -*- coding: utf-8 -*-
 
 """
-The 'stack' module includes function to read data, preprocess them and build
-stack of images.
+The bigfish.stack module includes function to read data, preprocess them and
+build stack of images.
 """
 
-from .loader import read_tif, read_pickle, build_simulated_dataset
+from .loader import read_tif, read_pickle
+from .preprocess import (build_stack, check_recipe, build_simulated_dataset,
+                         projection, rescale, cast_uint8, cast_float32,
+                         log_filter, mean_filter, median_filter,
+                         maximum_filter, minimum_filter, load_stack)
 
 
 __all__ = ["read_tif",
            "read_pickle",
-           "build_simulated_dataset"]
+           "build_simulated_dataset",
+           "load_stack",
+           "build_stack",
+           "check_recipe",
+           "projection",
+           "rescale",
+           "cast_uint8",
+           "cast_float32",
+           "log_filter",
+           "mean_filter",
+           "median_filter",
+           "maximum_filter",
+           "minimum_filter"]

From a5fa1502cfd20ca8e3cecc61131700eaf7f4265c Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Feb 2019 13:05:32 +0100
Subject: [PATCH 029/264] add segmentation plot

---
 bigfish/plot/__init__.py                      |   5 +-
 bigfish/plot/plot_images.py                   | 112 ++++++++++++++----
 .../{detect.py => detection.py}               |   0
 3 files changed, 89 insertions(+), 28 deletions(-)
 rename bigfish/spot_detection/{detect.py => detection.py} (100%)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index f7693321..b5770879 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -4,8 +4,9 @@
 The bigfish.plot module includes function to plot images and simulated data.
 """
 
-from .plot_images import plot_yx, plot_channels_2d
+from .plot_images import plot_yx, plot_channels_2d, plot_segmentation
 
 
 __all__ = ["plot_yx",
-           "plot_channels_2d"]
+           "plot_channels_2d",
+           "plot_segmentation"]
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index da933d05..21c25c0d 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -4,31 +4,34 @@
 Function to plot 2-d images.
 """
 
+import bigfish.stack as stack
+
 import matplotlib.pyplot as plt
+import numpy as np
 
 
-def plot_yx(tensor, round=0, channel=0, z=0, title=None, framesize=(15, 15),
+def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
             path_output=None, ext="png"):
     """Plot the selected x and y dimensions of an image.
 
     Parameters
     ----------
-    tensor : np.ndarray, np.float32
+    tensor : np.ndarray, np.uint8
         A 2-d, 3-d or 5-d tensor with shape (y, x), (z, y, x) or
-        (round, channel, z, y, x) respectively.
-    round : int
-        Indice of the round to keep.
-    channel : int
-        Indice of the channel to keep.
+        (r, c, z, y, x) respectively.
+    r : int
+        Index of the round to keep.
+    c : int
+        Index of the channel to keep.
     z : int
-        Indice of the z slice to keep.
+        Index of the z slice to keep.
     title : str
         Title of the image.
     framesize : tuple
-        Size of the frame used to plot (plt.figure(figsize=framesize).
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
     path_output : str
         Path to save the image (without extension).
-    ext : str or list
+    ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
 
@@ -42,7 +45,7 @@ def plot_yx(tensor, round=0, channel=0, z=0, title=None, framesize=(15, 15),
     elif tensor.ndim == 3:
         xy_tensor = tensor[z, :, :]
     elif tensor.ndim == 5:
-        xy_tensor = tensor[round, channel, z, :, :]
+        xy_tensor = tensor[r, c, z, :, :]
     else:
         raise ValueError("{0} is not a valid shape for the tensor."
                          .format(tensor.shape))
@@ -56,7 +59,6 @@ def plot_yx(tensor, round=0, channel=0, z=0, title=None, framesize=(15, 15),
     plt.tight_layout()
     plt.show()
 
-    # TODO compare savefig with imsave
     # save the plot
     if path_output is not None:
         if isinstance(ext, str):
@@ -71,23 +73,23 @@ def plot_yx(tensor, round=0, channel=0, z=0, title=None, framesize=(15, 15),
     return
 
 
-def plot_channels_2d(tensor, round=0, z=0, framesize=(15, 15),
-                     path_output=None, ext="png"):
+def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
+                     ext="png"):
     """Subplot the selected x and y dimensions of an image for all channels.
 
     Parameters
     ----------
-    tensor : np.ndarray, np.float32
-        A 5-d tensor with shape (round, channel, z, y, x).
-    round : int
-        Indice of the round to keep.
+    tensor : np.ndarray, np.uint8
+        A 5-d tensor with shape (r, c, z, y, x).
+    r : int
+        Index of the round to keep.
     z : int
-        Indice of the z slice to keep.
+        Index of the z slice to keep.
     framesize : tuple
-        Size of the frame used to plot (plt.figure(figsize=framesize).
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
     path_output : str
         Path to save the image (without extension).
-    ext : str or list
+    ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
 
@@ -96,9 +98,7 @@ def plot_channels_2d(tensor, round=0, z=0, framesize=(15, 15),
 
     """
     # check tensor
-    if tensor.ndim != 5:
-        raise ValueError("Tensor should have 5 dimensions instead of {0}"
-                         .format(tensor.ndim))
+    stack.check_array(tensor, ndim=5, dtype=np.uint8)
 
     # get the number of channels
     nb_channels = tensor.shape[1]
@@ -106,11 +106,10 @@ def plot_channels_2d(tensor, round=0, z=0, framesize=(15, 15),
     # plot
     fig, ax = plt.subplots(1, nb_channels, sharex='col', figsize=framesize)
     for i in range(nb_channels):
-        ax[i].imshow(tensor[round, i, z, :, :])
+        ax[i].imshow(tensor[r, i, z, :, :])
     plt.tight_layout()
     plt.show()
 
-    # TODO compare savefig with imsave
     # save the plot
     if path_output is not None:
         if isinstance(ext, str):
@@ -123,3 +122,64 @@ def plot_channels_2d(tensor, round=0, z=0, framesize=(15, 15),
                     "{0}.".format(ext))
 
     return
+
+
+def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
+                      framesize=(15, 15), path_output=None, ext="png"):
+    """Plot result of a 2-d segmentation, with labelled instances is available.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint8
+        A 5-d tensor with shape (r, c, z, y, x).
+    segmentation : np.ndarray, bool
+        A 2-d image with shape (y, x).
+    r : int
+        Index of the round to keep.
+    c : int
+        Index of the channel to keep.
+    z : int
+        Index of the z-slice to keep.
+    label : np.ndarray, np.int64
+        A 2-d image with shape (y, x).
+    framesize : tuple
+        Size of the frame used to plot (plt.figure(figsize=framesize).
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # check tensor
+    stack.check_array(tensor, ndim=5, dtype=np.uint8)
+    stack.check_array(segmentation, ndim=2, dtype=bool)
+    if label is not None:
+        stack.check_array(label, ndim=2, dtype=np.int64)
+
+    # plot
+    if label is not None:
+        fig, ax = plt.subplots(1, 3, sharex='col', figsize=framesize)
+        ax[0].imshow(tensor[r, c, z, :, :])
+        ax[1].imshow(segmentation)
+        ax[2].imshow(label)
+    else:
+        fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
+        ax[0].imshow(tensor[r, c, z, :, :])
+        ax[1].imshow(segmentation)
+    plt.tight_layout()
+    plt.show()
+
+    # save the plot
+    if path_output is not None:
+        if isinstance(ext, str):
+            plt.savefig(path_output, format=ext)
+        elif isinstance(ext, list):
+            for ext_ in ext:
+                plt.savefig(path_output, format=ext_)
+        else:
+            Warning("Plot is not saved because the extension is not valid: "
+                    "{0}.".format(ext))
diff --git a/bigfish/spot_detection/detect.py b/bigfish/spot_detection/detection.py
similarity index 100%
rename from bigfish/spot_detection/detect.py
rename to bigfish/spot_detection/detection.py

From 3ed8837cf7f364b881ba49ed6ff11d7373900692 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Feb 2019 13:06:15 +0100
Subject: [PATCH 030/264] fix dtype in docstring

---
 bigfish/segmentation/__init__.py     |  5 +++--
 bigfish/segmentation/segmentation.py | 17 ++++++++++-------
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index 6fc57d16..32667544 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -1,11 +1,12 @@
 # -*- coding: utf-8 -*-
 
 """
-The bigfish.segment module includes function to segment nucleus, cytoplasm and
-label them.
+The bigfish.segmentation module includes function to segment nucleus,
+cytoplasm and label them, in 2-d and 3-d.
 """
 
 from .segmentation import nuc_segmentation_2d
 
 
 __all__ = ["nuc_segmentation_2d"]
+
diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
index 71ae7203..a1014432 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/segmentation.py
@@ -12,7 +12,8 @@
 import numpy as np
 
 
-def nuc_segmentation_2d(tensor, r=0, nuc_channel=0, method="threshold"):
+def nuc_segmentation_2d(tensor, r=0, nuc_channel=0, method="threshold",
+                        return_label=True):
     """Segment nuclei from a 2d projection.
 
     Parameters
@@ -25,12 +26,14 @@ def nuc_segmentation_2d(tensor, r=0, nuc_channel=0, method="threshold"):
         Channel index of the dapi image.
     method : str
         Method used to segment.
+    return_label : bool
+        Condition to count and label the instances segmented in the image.
 
     Returns
     -------
-    image_segmented : np.ndarray, np.uint8
+    image_segmented : np.ndarray, bool
         Binary 2-d image with shape (y, x).
-    image_labelled : np.ndarray, np.uint8
+    image_labelled : np.ndarray, np.int64
         Image with labelled segmented instances and shape (y, x).
     nb_labels : int
         Number of different instances segmented.
@@ -45,7 +48,7 @@ def nuc_segmentation_2d(tensor, r=0, nuc_channel=0, method="threshold"):
         image_segmented = filtered_threshold(image_2d)
 
     # labelled and count segmented instances
-    if label:
+    if return_label:
         image_labelled, nb_labels = label_instances(image_segmented)
         return image_segmented, image_labelled, nb_labels
     else:
@@ -80,7 +83,7 @@ def filtered_threshold(image, kernel_shape="disk", kernel_size=200,
 
     Returns
     -------
-    image_segmented : np.ndarray, np.uint8
+    image_segmented : np.ndarray, bool
         Binary 2-d image with shape (y, x).
 
     """
@@ -141,12 +144,12 @@ def label_instances(image_segmented):
 
     Parameters
     ----------
-    image_segmented : np.ndarray, np.uint8
+    image_segmented : np.ndarray, bool
         Binary segmented image with shape (y, x).
 
     Returns
     -------
-    image_label : np.ndarray, np.uint8
+    image_label : np.ndarray, np.uint64
         Labelled image. Each object is characterized by the same pixel value.
     nb_labels : int
         Number of different instances counted in the image.

From 03ecf4e320baa102a1c181201b621d4faa76d640 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Feb 2019 13:06:56 +0100
Subject: [PATCH 031/264] update __init__.py

---
 bigfish/stack/__init__.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 36d29aa6..632bcf82 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -10,6 +10,7 @@
                          projection, rescale, cast_uint8, cast_float32,
                          log_filter, mean_filter, median_filter,
                          maximum_filter, minimum_filter, load_stack)
+from .utils import check_array, check_features_df
 
 
 __all__ = ["read_tif",
@@ -26,4 +27,6 @@
            "mean_filter",
            "median_filter",
            "maximum_filter",
-           "minimum_filter"]
+           "minimum_filter",
+           "check_array",
+           "check_features_df"]

From 4846f23cddac7b16491cb2037fb07848c3b5e3e2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Feb 2019 13:26:29 +0100
Subject: [PATCH 032/264] add projection plot

---
 bigfish/plot/__init__.py    |  4 ++-
 bigfish/plot/plot_images.py | 66 +++++++++++++++++++++++++++++++++----
 2 files changed, 63 insertions(+), 7 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index b5770879..d44df256 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -4,9 +4,11 @@
 The bigfish.plot module includes function to plot images and simulated data.
 """
 
-from .plot_images import plot_yx, plot_channels_2d, plot_segmentation
+from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
+                          plot_projection)
 
 
 __all__ = ["plot_yx",
            "plot_channels_2d",
+           "plot_projection",
            "plot_segmentation"]
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 21c25c0d..f6153dab 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -10,13 +10,15 @@
 import numpy as np
 
 
+# TODO add title in the plot and remove axes
+
 def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
             path_output=None, ext="png"):
     """Plot the selected x and y dimensions of an image.
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint8
+    tensor : np.ndarray, np.uint
         A 2-d, 3-d or 5-d tensor with shape (y, x), (z, y, x) or
         (r, c, z, y, x) respectively.
     r : int
@@ -39,16 +41,17 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
     -------
 
     """
+    # check tensor
+    stack.check_array(tensor, ndim=[2, 3, 5], dtype=[np.uint8, np.uint16])
+
     # get the 2-d tensor
+    xy_tensor = None
     if tensor.ndim == 2:
         xy_tensor = tensor
     elif tensor.ndim == 3:
         xy_tensor = tensor[z, :, :]
     elif tensor.ndim == 5:
         xy_tensor = tensor[r, c, z, :, :]
-    else:
-        raise ValueError("{0} is not a valid shape for the tensor."
-                         .format(tensor.shape))
 
     # plot
     plt.figure(figsize=framesize)
@@ -79,7 +82,7 @@ def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint8
+    tensor : np.ndarray, np.uint
         A 5-d tensor with shape (r, c, z, y, x).
     r : int
         Index of the round to keep.
@@ -98,7 +101,7 @@ def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
 
     """
     # check tensor
-    stack.check_array(tensor, ndim=5, dtype=np.uint8)
+    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
 
     # get the number of channels
     nb_channels = tensor.shape[1]
@@ -124,6 +127,57 @@ def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
     return
 
 
+def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
+                    path_output=None, ext="png"):
+    """Plot result of a 2-d projection.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint8
+        A 5-d tensor with shape (r, c, z, y, x).
+    projection : np.ndarray, np.uint8
+        A 2-d image with shape (y, x).
+    r : int
+        Index of the round to keep.
+    c : int
+        Index of the channel to keep.
+    z : int
+        Index of the z-slice to keep.
+    framesize : tuple
+        Size of the frame used to plot (plt.figure(figsize=framesize).
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # check tensor
+    stack.check_array(tensor, ndim=5, dtype=np.uint8)
+    stack.check_array(projection, ndim=2, dtype=np.uint8)
+
+    # plot
+    fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
+    ax[0].imshow(tensor[r, c, z, :, :])
+    ax[1].imshow(projection)
+    plt.tight_layout()
+    plt.show()
+
+    # save the plot
+    if path_output is not None:
+        if isinstance(ext, str):
+            plt.savefig(path_output, format=ext)
+        elif isinstance(ext, list):
+            for ext_ in ext:
+                plt.savefig(path_output, format=ext_)
+        else:
+            Warning("Plot is not saved because the extension is not valid: "
+                    "{0}.".format(ext))
+
+
 def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
                       framesize=(15, 15), path_output=None, ext="png"):
     """Plot result of a 2-d segmentation, with labelled instances is available.

From ba32a59e6d182f930cf5a938fc348273acb4c876 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Feb 2019 14:35:45 +0100
Subject: [PATCH 033/264] add gaussian filter

---
 bigfish/stack/__init__.py   |  4 +++-
 bigfish/stack/preprocess.py | 34 ++++++++++++++++++++++++++++++----
 2 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 632bcf82..ded4dbdf 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -9,7 +9,8 @@
 from .preprocess import (build_stack, check_recipe, build_simulated_dataset,
                          projection, rescale, cast_uint8, cast_float32,
                          log_filter, mean_filter, median_filter,
-                         maximum_filter, minimum_filter, load_stack)
+                         maximum_filter, minimum_filter, load_stack,
+                         gaussian_filter)
 from .utils import check_array, check_features_df
 
 
@@ -24,6 +25,7 @@
            "cast_uint8",
            "cast_float32",
            "log_filter",
+           "gaussian_filter",
            "mean_filter",
            "median_filter",
            "maximum_filter",
diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 9498168c..f9e1f038 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -15,7 +15,7 @@
 
 from skimage import img_as_ubyte, img_as_float32
 from skimage.morphology.selem import square, diamond, rectangle, disk
-from skimage.filters import rank
+from skimage.filters import rank, gaussian
 from skimage.exposure import rescale_intensity
 
 from scipy.ndimage import gaussian_laplace
@@ -812,12 +812,12 @@ def cast_float32(tensor):
     Parameters
     ----------
     tensor : np.ndarray
-        Tensor to cast with shape (r, c, z, y, x).
+        Tensor to cast.
 
     Returns
     -------
     tensor : np.ndarray, np.float32
-        Tensor with shape (r, c, z, y, x).
+        Tensor cast.
 
     """
     # cast tensor
@@ -1007,7 +1007,7 @@ def log_filter(image, sigma):
     Returns
     -------
     image_filtered : np.ndarray, np.float32
-        Filtered image
+        Filtered image.
     """
     # we cast the data in np.float32 to allow negative values
     image_float32 = cast_float32(image)
@@ -1020,3 +1020,29 @@ def log_filter(image, sigma):
     image_filtered = np.clip(-image_filtered, a_min=0, a_max=None)
 
     return image_filtered
+
+
+def gaussian_filter(image, sigma):
+    """Apply a Gaussian filter to a 2-d or 3-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint16
+        Image with shape (z, y, x) or (y, x).
+    sigma : float or Tuple(float)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.float32
+        Filtered image.
+
+    """
+    # we cast the data in np.float32 to allow negative values
+    image_float32 = cast_float32(image)
+
+    # we apply gaussian filter
+    image_filtered = gaussian(image_float32, sigma=sigma)
+
+    return image_filtered

From 22dcde257b5456b69b5ee6e396de2b539af3b6f2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Feb 2019 14:36:32 +0100
Subject: [PATCH 034/264] add subplot routines

---
 bigfish/plot/__init__.py    |  3 +-
 bigfish/plot/plot_images.py | 67 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 68 insertions(+), 2 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index d44df256..f96a9b54 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -5,10 +5,11 @@
 """
 
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
-                          plot_projection)
+                          plot_projection, plot_images)
 
 
 __all__ = ["plot_yx",
+           "plot_images",
            "plot_channels_2d",
            "plot_projection",
            "plot_segmentation"]
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index f6153dab..995c7460 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -42,7 +42,8 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
 
     """
     # check tensor
-    stack.check_array(tensor, ndim=[2, 3, 5], dtype=[np.uint8, np.uint16])
+    stack.check_array(tensor, ndim=[2, 3, 5],
+                      dtype=[np.uint8, np.uint16, np.float32, bool])
 
     # get the 2-d tensor
     xy_tensor = None
@@ -76,6 +77,70 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
     return
 
 
+def plot_images(images, framesize=(15, 15), path_output=None, ext="png"):
+    """Plot or subplot of 2-d images.
+
+    Parameters
+    ----------
+    images : np.ndarray or List[np.ndarray]
+        Images with shape (y, x).
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # enlist image if necessary
+    if isinstance(images, np.ndarray):
+        images = [images]
+
+    # check images
+    for image in images:
+        stack.check_array(image, ndim=2,
+                          dtype=[np.uint8, np.uint16, np.float32, np.float64,
+                                 bool])
+
+    # we plot 3 images by row maximum
+    nrow = int(np.ceil(len(images)/3))
+    ncol = min(len(images), 3)
+
+    # plot one image
+    if len(images) == 1:
+        plot_yx(images[0], framesize=framesize,
+                path_output=path_output, ext=ext)
+        return
+
+    # plot multiple images
+    fig, ax = plt.subplots(nrow, ncol, figsize=framesize)
+    if len(images) in [2, 3]:
+        for i, image in enumerate(images):
+            ax[i].imshow(image)
+    else:
+        for i, image in enumerate(images):
+            row = i // 3
+            col = i % 3
+            ax[row, col].imshow(image)
+    plt.tight_layout()
+    plt.show()
+
+    # save the plot
+    if path_output is not None:
+        if isinstance(ext, str):
+            plt.savefig(path_output, format=ext)
+        elif isinstance(ext, list):
+            for ext_ in ext:
+                plt.savefig(path_output, format=ext_)
+        else:
+            Warning("Plot is not saved because the extension is not valid: "
+                    "{0}.".format(ext))
+
+
 def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
                      ext="png"):
     """Subplot the selected x and y dimensions of an image for all channels.

From 036b182e3a1d3ceddca6a80b2583b0108f565ccb Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 18 Feb 2019 11:43:00 +0100
Subject: [PATCH 035/264] change default value 'return_label'

---
 bigfish/segmentation/segmentation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
index a1014432..2a1408d5 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/segmentation.py
@@ -13,7 +13,7 @@
 
 
 def nuc_segmentation_2d(tensor, r=0, nuc_channel=0, method="threshold",
-                        return_label=True):
+                        return_label=False):
     """Segment nuclei from a 2d projection.
 
     Parameters

From 118ea8fe5dd0f5dfbd38c70ed673a590dd44c689 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 18 Feb 2019 12:32:55 +0100
Subject: [PATCH 036/264] add generator 'build_stacks'

---
 bigfish/stack/__init__.py   |   3 +-
 bigfish/stack/preprocess.py | 158 ++++++++++++++++++++++++++++++++----
 2 files changed, 145 insertions(+), 16 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index ded4dbdf..a5c145fb 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -10,7 +10,7 @@
                          projection, rescale, cast_uint8, cast_float32,
                          log_filter, mean_filter, median_filter,
                          maximum_filter, minimum_filter, load_stack,
-                         gaussian_filter)
+                         gaussian_filter, build_stacks)
 from .utils import check_array, check_features_df
 
 
@@ -19,6 +19,7 @@
            "build_simulated_dataset",
            "load_stack",
            "build_stack",
+           "build_stacks",
            "check_recipe",
            "projection",
            "rescale",
diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index f9e1f038..b1060425 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -87,10 +87,128 @@ def build_simulated_dataset(path_cell, path_rna, path_output=None):
 
 # ### Real data ###
 
-def build_stack(recipe, input_folder, input_dimension=None,
+def build_stacks(data_map, input_dimension=None, normalize=True,
+                 channel_to_stretch=None, stretching_percentile=99.9):
+    """Generator to build several stacks.
+
+    To build a stack, a recipe should be linked to a directory including all
+    the files needed to build the stack. The content of the recipe allows to
+    reorganize the different files stored in the directory in order to build
+    a 5-d tensor.
+
+    The dictionary 'data_map' takes the form:
+
+        {
+         "path_input_directory_1": List[recipe_1, recipe_2, ...],
+         "path_input_directory_2": List[recipe_1, recipe_2, ...],
+         ...
+        }
+
+    The recipe dictionary for one field of view takes the form:
+
+        {
+         "fov": str,
+         "z": List[str], (optional)
+         "c": List[str], (optional)
+         "r": List[str], (optional)
+         "ext": str
+         }
+
+    - A field of view is defined by an ID common to every images belonging to
+    the field of view ("fov").
+    - At least every images are in 2-d with x and y dimensions. So we need to
+    mention the round-dimension, the channel-dimension and the z-dimension to
+    add ("r", "c" and "z"). For these keys, we provide a list of
+    strings to identify the images to stack. By default, we assume the filename
+    fit the pattern fov_z_c_r.tif.
+    - An extra information to identify the files to stack in the input folder
+    can be provided with the file extension "ext" (usually 'tif' or 'tiff').
+
+    For example, let us assume 3-d images (zyx dimensions) saved as
+    "r03c03f01_405.tif", "r03c03f01_488.tif" and "r03c03f01_561.tif". The first
+    morpheme "r03c03f01" uniquely identifies a 3-d field of view. The second
+    morphemes "405", "488" and "561" identify three different channels we
+    want to stack. There is no round in this experiment. Thus, the recipe is:
+
+        {
+         "fov": "r03c03f01",
+         "c": ["405", "488", "561"],
+         "ext": "tif"
+         }
+
+    The function should return a tensor with shape (1, 3, z, y, x).
+
+    Parameters
+    ----------
+    data_map : dict
+        Map between input directories and recipes.
+    input_dimension : str
+        Number of dimensions of the loaded files.
+    normalize : bool
+        Normalize the different channels of the loaded stack (rescaling).
+    channel_to_stretch : int or List[int]
+        Channel to stretch.
+    stretching_percentile : float
+        Percentile to determine the maximum intensity value used to rescale
+        the image.
+
+    Returns
+    -------
+    tensor : np.ndarray, np.uint8
+        Tensor with shape (r, c, z, y, x).
+    input_directory : str
+        Path of the input directory from where the tensor is built.
+    recipe : dict
+        Recipe used to build the tensor.
+
+    """
+    # load and generate tensors
+    for input_folder, recipes in data_map.items():
+        for recipe in recipes:
+            tensor = build_stack(recipe, input_folder, input_dimension,
+                                 normalize, channel_to_stretch,
+                                 stretching_percentile)
+            yield tensor, input_folder, recipe
+
+
+def build_stack(recipe, input_folder, input_dimension=None, normalize=True,
                 channel_to_stretch=None, stretching_percentile=99.9):
     """Build 5-d stack and normalize it.
 
+    The recipe dictionary for one field of view takes the form:
+
+        {
+         "fov": str,
+         "z": List[str], (optional)
+         "c": List[str], (optional)
+         "r": List[str], (optional)
+         "ext": str
+         }
+
+    - A field of view is defined by an ID common to every images belonging to
+    the field of view ("fov").
+    - At least every images are in 2-d with x and y dimensions. So we need to
+    mention the round-dimension, the channel-dimension and the z-dimension to
+    add ("r", "c" and "z"). For these keys, we provide a list of
+    strings to identify the images to stack. By default, we assume the filename
+    fit the pattern fov_z_c_r.tif.
+    - An extra information to identify the files to stack in the input folder
+    can be provided with the file extension "ext" (usually 'tif' or 'tiff').
+
+    For example, let us assume 3-d images (zyx dimensions) saved as
+    "r03c03f01_405.tif", "r03c03f01_488.tif" and "r03c03f01_561.tif". The first
+    morpheme "r03c03f01" uniquely identifies a 3-d field of view. The second
+    morphemes "405", "488" and "561" identify three different channels we
+    want to stack. There is no round in this experiment. Thus, the recipe is:
+
+        {
+         "fov": "r03c03f01",
+         "c": ["405", "488", "561"],
+         "ext": "tif"
+         }
+
+    The function should return a tensor with shape (1, 3, z, y, x).
+
     Parameters
     ----------
     recipe : dict
@@ -100,6 +218,8 @@ def build_stack(recipe, input_folder, input_dimension=None,
         Path of the folder containing the images.
     input_dimension : str
         Number of dimensions of the loaded files.
+    normalize : bool
+        Normalize the different channels of the loaded stack (rescaling).
     channel_to_stretch : int or List[int]
         Channel to stretch.
     stretching_percentile : float
@@ -112,11 +232,13 @@ def build_stack(recipe, input_folder, input_dimension=None,
         Tensor with shape (r, c, z, y, x).
 
     """
+    # TODO add sanity checks for the parameters
     # build stack from recipe and tif files
     tensor = load_stack(recipe, input_folder, input_dimension)
 
     # rescale data and improve contrast
-    tensor = rescale(tensor, channel_to_stretch, stretching_percentile)
+    if normalize:
+        tensor = rescale(tensor, channel_to_stretch, stretching_percentile)
 
     # cast in np.uint8 if necessary, in order to reduce memory allocation
     if tensor.dtype == np.uint16:
@@ -141,9 +263,9 @@ def load_stack(recipe, input_folder, input_dimension=None):
 
         {
          "fov": str,
-         "z": List[str],
-         "c": List[str],
-         "r": List[str],
+         "z": List[str], (optional)
+         "c": List[str], (optional)
+         "r": List[str], (optional)
          "ext": str
          }
 
@@ -870,7 +992,7 @@ def mean_filter(image, kernel_shape, kernel_size):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint16
+    image : np.ndarray, np.uint8
         Image with shape (y, x).
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -881,7 +1003,7 @@ def mean_filter(image, kernel_shape, kernel_size):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.uint16
+    image_filtered : np.ndarray, np.uint8
         Filtered 2-d image with shape (y, x).
 
     """
@@ -902,7 +1024,7 @@ def median_filter(image, kernel_shape, kernel_size):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint16
+    image : np.ndarray, np.uint8
         Image with shape (y, x).
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -913,7 +1035,7 @@ def median_filter(image, kernel_shape, kernel_size):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.uint16
+    image_filtered : np.ndarray, np.uint8
         Filtered 2-d image with shape (y, x).
 
     """
@@ -934,7 +1056,7 @@ def maximum_filter(image, kernel_shape, kernel_size):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint16
+    image : np.ndarray, np.uint8
         Image with shape (y, x).
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -945,7 +1067,7 @@ def maximum_filter(image, kernel_shape, kernel_size):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.uint16
+    image_filtered : np.ndarray, np.uint8
         Filtered 2-d image with shape (y, x).
 
     """
@@ -966,7 +1088,7 @@ def minimum_filter(image, kernel_shape, kernel_size):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint16
+    image : np.ndarray, np.uint8
         Image with shape (y, x).
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -977,7 +1099,7 @@ def minimum_filter(image, kernel_shape, kernel_size):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.uint16
+    image_filtered : np.ndarray, np.uint8
         Filtered 2-d image with shape (y, x).
 
     """
@@ -998,7 +1120,7 @@ def log_filter(image, sigma):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint16
+    image : np.ndarray, np.uint8
         Image with shape (z, y, x) or (y, x).
     sigma : float or Tuple(float)
         Sigma used for the gaussian filter (one for each dimension). If it's a
@@ -1012,6 +1134,12 @@ def log_filter(image, sigma):
     # we cast the data in np.float32 to allow negative values
     image_float32 = cast_float32(image)
 
+    # check sigma
+    if isinstance(sigma, (tuple, list)):
+        if len(sigma) != image.ndim:
+            raise ValueError("'Sigma' must be a scalar or a sequence with the "
+                             "same length as 'image.ndim'.")
+
     # we apply LoG filter
     image_filtered = gaussian_laplace(image_float32, sigma=sigma)
 
@@ -1027,7 +1155,7 @@ def gaussian_filter(image, sigma):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint16
+    image : np.ndarray, np.uint8
         Image with shape (z, y, x) or (y, x).
     sigma : float or Tuple(float)
         Sigma used for the gaussian filter (one for each dimension). If it's a

From 73b204f04ba6034d256e127aba9faae9e3d64647 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Feb 2019 08:44:03 +0100
Subject: [PATCH 037/264] fix dtype for preprocess and default normalization
 parameter

---
 bigfish/process.py          |   0
 bigfish/stack/preprocess.py | 124 ++++++++++++++++++++++++------------
 2 files changed, 83 insertions(+), 41 deletions(-)
 create mode 100644 bigfish/process.py

diff --git a/bigfish/process.py b/bigfish/process.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index b1060425..28092a9a 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -13,7 +13,7 @@
 from .loader import read_tif, read_cell_json, read_rna_json
 from .utils import check_array
 
-from skimage import img_as_ubyte, img_as_float32
+from skimage import img_as_ubyte, img_as_float32, img_as_float
 from skimage.morphology.selem import square, diamond, rectangle, disk
 from skimage.filters import rank, gaussian
 from skimage.exposure import rescale_intensity
@@ -88,7 +88,8 @@ def build_simulated_dataset(path_cell, path_rna, path_output=None):
 # ### Real data ###
 
 def build_stacks(data_map, input_dimension=None, normalize=True,
-                 channel_to_stretch=None, stretching_percentile=99.9):
+                 channel_to_stretch=None, stretching_percentile=99.9,
+                 cast_8bit=False, return_origin=False):
     """Generator to build several stacks.
 
     To build a stack, a recipe should be linked to a directory including all
@@ -96,13 +97,15 @@ def build_stacks(data_map, input_dimension=None, normalize=True,
     reorganize the different files stored in the directory in order to build
     a 5-d tensor.
 
-    The dictionary 'data_map' takes the form:
+    The list 'data_map' takes the form:
 
-        {
-         "path_input_directory_1": List[recipe_1, recipe_2, ...],
-         "path_input_directory_2": List[recipe_1, recipe_2, ...],
+        [
+         (recipe_1, path_input_directory_1),
+         (recipe_2, path_input_directory_1),
+         (recipe_3, path_input_directory_1),
+         (recipe_4, path_input_directory_2),
          ...
-        }
+        ]
 
     The recipe dictionary for one field of view takes the form:
 
@@ -140,7 +143,7 @@ def build_stacks(data_map, input_dimension=None, normalize=True,
 
     Parameters
     ----------
-    data_map : dict
+    data_map : List[tuple]
         Map between input directories and recipes.
     input_dimension : str
         Number of dimensions of the loaded files.
@@ -151,10 +154,14 @@ def build_stacks(data_map, input_dimension=None, normalize=True,
     stretching_percentile : float
         Percentile to determine the maximum intensity value used to rescale
         the image.
+    return_origin : bool
+        Return the input directory and the recipe used to build the stack.
+    cast_8bit : bool
+        Cast tensor in np.uint8.
 
     Returns
     -------
-    tensor : np.ndarray, np.uint8
+    tensor : np.ndarray, np.uint
         Tensor with shape (r, c, z, y, x).
     input_directory : str
         Path of the input directory from where the tensor is built.
@@ -163,16 +170,19 @@ def build_stacks(data_map, input_dimension=None, normalize=True,
 
     """
     # load and generate tensors
-    for input_folder, recipes in data_map.items():
-        for recipe in recipes:
-            tensor = build_stack(recipe, input_folder, input_dimension,
-                                 normalize, channel_to_stretch,
-                                 stretching_percentile)
+    for recipe, input_folder in data_map:
+        tensor = build_stack(recipe, input_folder, input_dimension, normalize,
+                             channel_to_stretch, stretching_percentile,
+                             cast_8bit)
+        if return_origin:
             yield tensor, input_folder, recipe
+        else:
+            yield tensor
 
 
-def build_stack(recipe, input_folder, input_dimension=None, normalize=True,
-                channel_to_stretch=None, stretching_percentile=99.9):
+def build_stack(recipe, input_folder, input_dimension=None, normalize=False,
+                channel_to_stretch=None, stretching_percentile=99.9,
+                cast_8bit=False):
     """Build 5-d stack and normalize it.
 
     The recipe dictionary for one field of view takes the form:
@@ -225,10 +235,12 @@ def build_stack(recipe, input_folder, input_dimension=None, normalize=True,
     stretching_percentile : float
         Percentile to determine the maximum intensity value used to rescale
         the image.
+    cast_8bit : bool
+        Cast the tensor in np.uint8.
 
     Returns
     -------
-    tensor : np.ndarray, np.uint8
+    tensor : np.ndarray, np.uint
         Tensor with shape (r, c, z, y, x).
 
     """
@@ -241,7 +253,7 @@ def build_stack(recipe, input_folder, input_dimension=None, normalize=True,
         tensor = rescale(tensor, channel_to_stretch, stretching_percentile)
 
     # cast in np.uint8 if necessary, in order to reduce memory allocation
-    if tensor.dtype == np.uint16:
+    if tensor.dtype == np.uint16 and cast_8bit:
         tensor = cast_uint8(tensor)
 
     return tensor
@@ -599,7 +611,7 @@ def projection(tensor, method="mip", r=0, c=0):
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint8
+    tensor : np.ndarray, np.uint
         A 5-d tensor with shape (r, c, z, y, x).
     method : str
         Method used to project ('mip', 'focus').
@@ -610,12 +622,12 @@ def projection(tensor, method="mip", r=0, c=0):
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.uint8
+    projected_tensor : np.ndarray, np.uint
         A 2-d tensor with shape (y, x).
 
     """
     # check tensor dimensions and its dtype
-    check_array(tensor, ndim=5, dtype=np.uint8)
+    check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
 
     # apply projection along the z-dimension
     projected_tensor = tensor[r, c, :, :, :]
@@ -634,12 +646,12 @@ def maximum_projection(tensor):
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint8
+    tensor : np.ndarray, np.uint
         A 3-d tensor with shape (z, y, x).
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.uint8
+    projected_tensor : np.ndarray, np.uint
         A 2-d tensor with shape (y, x).
 
     """
@@ -950,6 +962,28 @@ def cast_float32(tensor):
     return tensor
 
 
+def cast_float64(tensor):
+    """Cast the data in np.float64 and scale it between 0 and 1.
+
+    Parameters
+    ----------
+    tensor : np.ndarray
+        Tensor to cast.
+
+    Returns
+    -------
+    tensor : np.ndarray, np.float64
+        Tensor cast.
+
+    """
+    # cast tensor
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        tensor = img_as_float(tensor)
+
+    return tensor
+
+
 # ### Filters ###
 
 def _define_kernel(shape, size, dtype):
@@ -992,7 +1026,7 @@ def mean_filter(image, kernel_shape, kernel_size):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint8
+    image : np.ndarray, np.uint
         Image with shape (y, x).
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -1003,7 +1037,7 @@ def mean_filter(image, kernel_shape, kernel_size):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.uint8
+    image_filtered : np.ndarray, np.uint
         Filtered 2-d image with shape (y, x).
 
     """
@@ -1024,7 +1058,7 @@ def median_filter(image, kernel_shape, kernel_size):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint8
+    image : np.ndarray, np.uint
         Image with shape (y, x).
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -1035,7 +1069,7 @@ def median_filter(image, kernel_shape, kernel_size):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.uint8
+    image_filtered : np.ndarray, np.uint
         Filtered 2-d image with shape (y, x).
 
     """
@@ -1056,7 +1090,7 @@ def maximum_filter(image, kernel_shape, kernel_size):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint8
+    image : np.ndarray, np.uint
         Image with shape (y, x).
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -1067,7 +1101,7 @@ def maximum_filter(image, kernel_shape, kernel_size):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.uint8
+    image_filtered : np.ndarray, np.uint
         Filtered 2-d image with shape (y, x).
 
     """
@@ -1088,7 +1122,7 @@ def minimum_filter(image, kernel_shape, kernel_size):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint8
+    image : np.ndarray, np.uint
         Image with shape (y, x).
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -1099,7 +1133,7 @@ def minimum_filter(image, kernel_shape, kernel_size):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.uint8
+    image_filtered : np.ndarray, np.uint
         Filtered 2-d image with shape (y, x).
 
     """
@@ -1120,7 +1154,7 @@ def log_filter(image, sigma):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint8
+    image : np.ndarray, np.uint
         Image with shape (z, y, x) or (y, x).
     sigma : float or Tuple(float)
         Sigma used for the gaussian filter (one for each dimension). If it's a
@@ -1128,11 +1162,15 @@ def log_filter(image, sigma):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.float32
+    image_filtered : np.ndarray, np.float
         Filtered image.
     """
-    # we cast the data in np.float32 to allow negative values
-    image_float32 = cast_float32(image)
+    # we cast the data in np.float to allow negative values
+    image_float = None
+    if image.dtype == np.uint8:
+        image_float = cast_float32(image)
+    elif image.dtype == np.uint16:
+        image_float = cast_float64(image)
 
     # check sigma
     if isinstance(sigma, (tuple, list)):
@@ -1141,7 +1179,7 @@ def log_filter(image, sigma):
                              "same length as 'image.ndim'.")
 
     # we apply LoG filter
-    image_filtered = gaussian_laplace(image_float32, sigma=sigma)
+    image_filtered = gaussian_laplace(image_float, sigma=sigma)
 
     # as the LoG filter makes the peaks in the original image appear as a
     # reversed mexican hat, we inverse the result and clip negative values to 0
@@ -1155,7 +1193,7 @@ def gaussian_filter(image, sigma):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint8
+    image : np.ndarray, np.uint
         Image with shape (z, y, x) or (y, x).
     sigma : float or Tuple(float)
         Sigma used for the gaussian filter (one for each dimension). If it's a
@@ -1163,14 +1201,18 @@ def gaussian_filter(image, sigma):
 
     Returns
     -------
-    image_filtered : np.ndarray, np.float32
+    image_filtered : np.ndarray, np.float
         Filtered image.
 
     """
-    # we cast the data in np.float32 to allow negative values
-    image_float32 = cast_float32(image)
+    # we cast the data in np.float to allow negative values
+    image_float = None
+    if image.dtype == np.uint8:
+        image_float = cast_float32(image)
+    elif image.dtype == np.uint16:
+        image_float = cast_float64(image)
 
     # we apply gaussian filter
-    image_filtered = gaussian(image_float32, sigma=sigma)
+    image_filtered = gaussian(image_float, sigma=sigma)
 
     return image_filtered

From 4d418c90b2f4d51105bd162a0456b32a8dcbe852 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Feb 2019 08:45:12 +0100
Subject: [PATCH 038/264] refactor the all detection pipeline and add snr (to
 be continued)

---
 bigfish/spot_detection/__init__.py  |  13 ++
 bigfish/spot_detection/detection.py | 240 ++++++++++++++++++++++++++++
 2 files changed, 253 insertions(+)

diff --git a/bigfish/spot_detection/__init__.py b/bigfish/spot_detection/__init__.py
index e69de29b..c12dd8ed 100644
--- a/bigfish/spot_detection/__init__.py
+++ b/bigfish/spot_detection/__init__.py
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+"""
+The bigfish.detection module includes function to detect RNA spot in 2-d and
+3-d.
+"""
+
+from .detection import detection, compute_snr, optimize_threshold_log_lm
+
+
+__all__ = ["detection",
+           "compute_snr",
+           "optimize_threshold_log_lm"]
diff --git a/bigfish/spot_detection/detection.py b/bigfish/spot_detection/detection.py
index 18c5f521..12f5da93 100644
--- a/bigfish/spot_detection/detection.py
+++ b/bigfish/spot_detection/detection.py
@@ -3,3 +3,243 @@
 """
 Class and functions to detect RNA spots in 2-d and 3-d.
 """
+
+import scipy.ndimage as ndi
+import numpy as np
+
+from bigfish import stack
+
+
+def detection(tensor, r, c, detection_method, **kargs):
+    """
+
+    Parameters
+    ----------
+    tensor : nd.ndarray, np.uint
+        Tensor with shape (r, c, z, y, x).
+    r : int
+        Round index to process.
+    c : int
+        Channel index of the smfish image.
+    detection_method : str
+        Method used to detect spots.
+
+    Returns
+    -------
+    peak_coordinates : np.ndarray, np.int64
+        Coordinate of the local peaks with shape (nb_peaks, 3) or
+        (nb_peaks, 2) for 3-d or 2-d images respectively.
+    radius : float
+        Radius of the detected peaks.
+
+    """
+    # get the smfish image
+    image = tensor[r, c, :, :, :]
+
+    # apply spot detection
+    peak_coordinates, radius = None, None
+    if detection_method == "log_lm":
+        peak_coordinates, radius = log_lm(image, **kargs)
+
+    return peak_coordinates, radius
+
+
+def log_lm(image, sigma, minimum_distance=1, threshold=None):
+    """Apply LoG filter followed by a Local Maximum algorithm to detect spots
+    in a 2-d or 3-d image.
+
+    1) We smooth the image with a LoG filter.
+    2) We apply a multidimensional maximum filter.
+    3) A pixel which has the same value in the original and filtered images
+    is a local maximum.
+    4) We remove local peaks under a threshold.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        Image with shape (z, y, x) or (y, x).
+    sigma : float or Tuple(float)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+    minimum_distance : int
+        Minimum distance (in number of pixels) between two local peaks.
+    threshold : float or int
+        A threshold to detect peaks. Considered as a relative threshold if
+        float.
+
+    Returns
+    -------
+    peak_coordinates : np.ndarray, np.int64
+        Coordinate of the local peaks with shape (nb_peaks, 3) or
+        (nb_peaks, 2) for 3-d or 2-d images respectively.
+    radius : float
+        Radius of the detected peaks.
+
+    """
+    # cast image in np.float and apply LoG filter
+    image_filtered = stack.log_filter(image, sigma)
+
+    # find local maximum
+    mask = _non_maximum_suppression_mask(image_filtered, minimum_distance)
+
+    # remove peak with a low intensity
+    if isinstance(threshold, float):
+        threshold *= image.max()
+    mask &= image > threshold
+
+    # get peak coordinates and radius
+    peak_coordinates = np.nonzero(mask)
+    peak_coordinates = np.column_stack(peak_coordinates)
+    radius = np.sqrt(image.ndim) * sigma[-1]
+
+    return peak_coordinates, radius
+
+
+def local_maximum_detection(image, minimum_distance=1, threshold=0.2):
+    """Find local maximum in a 2-d or 3-d image.
+
+    1) We apply a multidimensional maximum filter.
+    2) A pixel which has the same value in the original and filtered images
+    is a local maximum.
+    3) We remove local peaks under a threshold.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float
+        Image to process with shape (z, y, x) or (y, x).
+    minimum_distance : int
+        Minimum distance (in number of pixels) between two local peaks.
+    threshold : float or int
+        A threshold to detect peaks. Considered as a relative threshold if
+        float.
+
+    Returns
+    -------
+    peak_coordinate : np.ndarray, np.int64
+        Coordinate of the local peaks with shape (nb_peaks, 3) or
+        (nb_peaks, 2).
+    """
+    mask = _non_maximum_suppression_mask(image, minimum_distance)
+
+    if isinstance(threshold, float):
+        threshold *= image.max()
+    mask &= image > threshold
+
+    peak_coordinate = np.nonzero(mask)
+    peak_coordinate = np.column_stack(peak_coordinate)
+
+    return peak_coordinate
+
+
+def _non_maximum_suppression_mask(image, minimum_distance):
+    """Compute a mask to keep only local maximum, in 2-d and 3-d.
+
+    1) We apply a multidimensional maximum filter.
+    2) A pixel which has the same value in the original and filtered images
+    is a local maximum.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float
+        Image to process with shape (z, y, x) or (y, x).
+    minimum_distance : int
+        Minimum distance (in number of pixels) between two local peaks.
+
+    Returns
+    -------
+    mask : np.ndarray, bool
+        Mask with shape (z, y, x) or (y, x) indicating the local peaks.
+
+    """
+    # compute the kernel size (centered around our pixel because it is uneven
+    kernel_size = 2 * minimum_distance + 1
+
+    # apply maximum filter to the original image
+    image_filtered = ndi.maximum_filter(image, size=kernel_size,
+                                        mode='constant')
+
+    # we keep the pixels with the same value before and after the filtering
+    mask = image == image_filtered
+
+    return mask
+
+
+def optimize_threshold_log_lm(tensor, sigma, thresholds,
+                              r=0, c=2, minimum_distance=1, verbose=False):
+    # get the smfish image
+    image = tensor[r, c, :, :, :]
+
+    # cast image in np.float and apply LoG filter
+    image_filtered = stack.log_filter(image, sigma)
+
+    # find local maximum
+    mask = _non_maximum_suppression_mask(image_filtered, minimum_distance)
+    if verbose:
+        print("{0} local peaks detected.".format(mask.sum()))
+
+    # test different thresholds
+    peak_coordinates = []
+    for threshold in thresholds:
+        if isinstance(threshold, float):
+            threshold *= image.max()
+        mask_ = (mask & (image > threshold))
+
+        # get peak coordinates
+        peak_coordinates_ = np.nonzero(mask_)
+        peak_coordinates_ = np.column_stack(peak_coordinates_)
+        peak_coordinates.append(peak_coordinates_)
+
+        if verbose:
+            print("Threshold {0}: {1} RNA detected."
+                  .format(threshold, peak_coordinates_.shape[0]))
+
+        # early stop if we detect zero rna
+        if peak_coordinates_.shape[0] == 0:
+            break
+
+    # reshape threshold
+    thresholds = thresholds[:len(peak_coordinates)]
+
+    # get radius
+    radius = np.sqrt(image.ndim) * sigma[-1]
+
+    return peak_coordinates, thresholds, radius
+
+
+def compute_snr(image, threshold_signal_detection=0.5, neighbor_size=None):
+    # TODO add documentation
+    # TODO keep only local snr
+    # TODO improve local snr with a mean of computed local snr and not a global
+    #  snr computed with local noise.
+    mask = _non_maximum_suppression_mask(image, minimum_distance=1)
+
+    if isinstance(threshold_signal_detection, float):
+        threshold_signal_detection *= image.max()
+    mask &= image > threshold_signal_detection
+
+    signal = image.astype(np.float64)
+    signal[~mask] = np.nan
+
+    noise = image.astype(np.float64)
+    noise[mask] = np.nan
+
+    # global SNR
+    snr_1 = np.nanmean(signal) / np.nanstd(noise)
+    snr_2 = np.nanmean(signal) / np.nanstd(signal)
+
+    # local SNR
+    if neighbor_size is not None:
+        mask_filtered = ndi.maximum_filter(mask,
+                                           size=neighbor_size,
+                                           mode='constant')
+
+        mask_local = mask_filtered & ~mask
+        noise_local = image.astype(np.float64)
+        noise_local[mask_local] = np.nan
+
+        snr_local = np.nanmean(signal) / np.nanstd(noise_local)
+
+        return snr_1, snr_2, snr_local
+
+    else:
+        return snr_1, snr_2

From 4cabc3abd16f4e995b9a191bdad3543a24a1b147 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Feb 2019 08:46:33 +0100
Subject: [PATCH 039/264] add projection parameter for spot detection plot

---
 bigfish/plot/__init__.py    |   5 +-
 bigfish/plot/plot_images.py | 156 ++++++++++++++++++++++++++----------
 2 files changed, 118 insertions(+), 43 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index f96a9b54..ff65caa8 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -5,11 +5,12 @@
 """
 
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
-                          plot_projection, plot_images)
+                          plot_projection, plot_images, plot_spot_detection)
 
 
 __all__ = ["plot_yx",
            "plot_images",
            "plot_channels_2d",
            "plot_projection",
-           "plot_segmentation"]
+           "plot_segmentation",
+           "plot_spot_detection"]
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 995c7460..0a46bad2 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -64,15 +64,7 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
     plt.show()
 
     # save the plot
-    if path_output is not None:
-        if isinstance(ext, str):
-            plt.savefig(path_output, format=ext)
-        elif isinstance(ext, list):
-            for ext_ in ext:
-                plt.savefig(path_output, format=ext_)
-        else:
-            Warning("Plot is not saved because the extension is not valid: "
-                    "{0}.".format(ext))
+    _save_plot(path_output, ext)
 
     return
 
@@ -130,15 +122,7 @@ def plot_images(images, framesize=(15, 15), path_output=None, ext="png"):
     plt.show()
 
     # save the plot
-    if path_output is not None:
-        if isinstance(ext, str):
-            plt.savefig(path_output, format=ext)
-        elif isinstance(ext, list):
-            for ext_ in ext:
-                plt.savefig(path_output, format=ext_)
-        else:
-            Warning("Plot is not saved because the extension is not valid: "
-                    "{0}.".format(ext))
+    _save_plot(path_output, ext)
 
 
 def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
@@ -179,15 +163,7 @@ def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
     plt.show()
 
     # save the plot
-    if path_output is not None:
-        if isinstance(ext, str):
-            plt.savefig(path_output, format=ext)
-        elif isinstance(ext, list):
-            for ext_ in ext:
-                plt.savefig(path_output, format=ext_)
-        else:
-            Warning("Plot is not saved because the extension is not valid: "
-                    "{0}.".format(ext))
+    _save_plot(path_output, ext)
 
     return
 
@@ -198,7 +174,7 @@ def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint8
+    tensor : np.ndarray, np.uint
         A 5-d tensor with shape (r, c, z, y, x).
     projection : np.ndarray, np.uint8
         A 2-d image with shape (y, x).
@@ -221,8 +197,8 @@ def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
 
     """
     # check tensor
-    stack.check_array(tensor, ndim=5, dtype=np.uint8)
-    stack.check_array(projection, ndim=2, dtype=np.uint8)
+    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+    stack.check_array(projection, ndim=2, dtype=[np.uint8, np.uint16])
 
     # plot
     fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
@@ -232,15 +208,7 @@ def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
     plt.show()
 
     # save the plot
-    if path_output is not None:
-        if isinstance(ext, str):
-            plt.savefig(path_output, format=ext)
-        elif isinstance(ext, list):
-            for ext_ in ext:
-                plt.savefig(path_output, format=ext_)
-        else:
-            Warning("Plot is not saved because the extension is not valid: "
-                    "{0}.".format(ext))
+    _save_plot(path_output, ext)
 
 
 def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
@@ -249,7 +217,7 @@ def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint8
+    tensor : np.ndarray, np.uint
         A 5-d tensor with shape (r, c, z, y, x).
     segmentation : np.ndarray, bool
         A 2-d image with shape (y, x).
@@ -274,7 +242,7 @@ def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
 
     """
     # check tensor
-    stack.check_array(tensor, ndim=5, dtype=np.uint8)
+    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
     stack.check_array(segmentation, ndim=2, dtype=bool)
     if label is not None:
         stack.check_array(label, ndim=2, dtype=np.int64)
@@ -292,6 +260,112 @@ def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
     plt.tight_layout()
     plt.show()
 
+    # save the plot
+    _save_plot(path_output, ext)
+
+
+def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
+                        framesize=(15, 15), projection_2d=False,
+                        path_output=None, ext="png"):
+    """
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint
+        A 5-d tensor with shape (r, c, z, y, x).
+    coordinates : np.ndarray, np.int64
+        Coordinate of the spots with shape (nb_spots, 3) or
+        (nb_spots, 2) for 3-d or 2-d images respectively.
+    radius : float
+        Radius of the detected spots.
+    r : int
+        Index of the round to keep.
+    c : int
+        Index of the channel to keep.
+    z : int
+        Index of the z-slice to keep.
+    framesize : tuple
+        Size of the frame used to plot (plt.figure(figsize=framesize).
+    projection_2d : bool
+        Project the image in 2-d and plot the spot detected on the projection.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # TODO check coordinates shape
+    # check tensor
+    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+    stack.check_array(coordinates, ndim=2, dtype=np.int64)
+
+    # projection 2d
+    if projection_2d:
+        image_2d = stack.projection(tensor,
+                                    method="mip",
+                                    r=r,
+                                    c=c)
+
+        # plot
+        fig, ax = plt.subplots(1, 2, figsize=framesize)
+        ax[0].imshow(image_2d)
+        ax[1].imshow(image_2d)
+        for spot_coordinate in coordinates:
+            _, y, x = spot_coordinate
+            c = plt.Circle((x, y), radius,
+                           color="red",
+                           linewidth=1,
+                           fill=False)
+            ax[1].add_patch(c)
+        plt.tight_layout()
+        plt.show()
+
+    # a specific z-slice
+    else:
+        # keep spot detected for a specific height
+        if coordinates.shape[1] == 3:
+            coordinates = coordinates[coordinates[:, 0] == z]
+            coordinates = coordinates[:, 1:]
+
+        image_2d = tensor[r, c, z, :, :]
+
+        # plot
+        fig, ax = plt.subplots(1, 2, figsize=framesize)
+        ax[0].imshow(image_2d)
+        ax[1].imshow(image_2d)
+        for spot_coordinate in coordinates:
+            y, x = spot_coordinate
+            c = plt.Circle((x, y), radius,
+                           color="red",
+                           linewidth=1,
+                           fill=False)
+            ax[1].add_patch(c)
+        plt.tight_layout()
+        plt.show()
+
+    # save the plot
+    _save_plot(path_output, ext)
+
+
+def _save_plot(path_output, ext):
+    """Save the plot.
+
+    Parameters
+    ----------
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
     # save the plot
     if path_output is not None:
         if isinstance(ext, str):

From 143b4a1f9fe5f9265132bd59a6f9c8b226e59e1f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Feb 2019 08:47:06 +0100
Subject: [PATCH 040/264] add joblib dependency

---
 requirements.txt | 3 ++-
 setup.py         | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index 234b2e85..7aa95e6d 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -9,4 +9,5 @@ scikit-image >= 0.14.2
 scipy >= 1.1.0
 tensorflow >= 1.12.0, < 2.0
 matplotlib >= 3.0.2
-pandas >= 0.23.4
\ No newline at end of file
+pandas >= 0.23.4
+joblib >= 0.13.2
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 85647844..d99c1bfd 100644
--- a/setup.py
+++ b/setup.py
@@ -17,7 +17,8 @@
       'scikit-image',
       'scipy',
       'tensorflow',
-      'matplotlib'
+      'matplotlib',
+      'joblib'
 ]
 
 # Long description of the package

From 856d5cce64b97ab70a46cc37df0e88144a30eb69 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Feb 2019 08:48:04 +0100
Subject: [PATCH 041/264] fix dtype in segmentation methods

---
 bigfish/segmentation/segmentation.py | 40 ++++++++++++++++------------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
index 2a1408d5..e87b3a82 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/segmentation.py
@@ -12,20 +12,22 @@
 import numpy as np
 
 
-def nuc_segmentation_2d(tensor, r=0, nuc_channel=0, method="threshold",
-                        return_label=False):
-    """Segment nuclei from a 2d projection.
+def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
+                        return_label=False, **kargs):
+    """Segment nuclei from a 2-d projection.
 
     Parameters
     ----------
-    tensor : nd.ndarray, np.uint8
+    tensor : nd.ndarray, np.uint
         Tensor with shape (r, c, z, y, x).
+    projection_method : str
+        Method used to project the image in 2-d.
     r : int
-        Round index to segment.
-    nuc_channel : int
+        Round index to process.
+    c : int
         Channel index of the dapi image.
-    method : str
-        Method used to segment.
+    segmentation_method : str
+        Method used to segment the nuclei.
     return_label : bool
         Condition to count and label the instances segmented in the image.
 
@@ -38,14 +40,18 @@ def nuc_segmentation_2d(tensor, r=0, nuc_channel=0, method="threshold",
     nb_labels : int
         Number of different instances segmented.
     """
-    # get 2D dapi image
-    image_2d = stack.projection(tensor, method="mip", r=r, c=nuc_channel)
+    # get a 2-d dapi image
+    image_2d = stack.projection(tensor,
+                                method=projection_method,
+                                r=r,
+                                c=c)
 
     # apply segmentation
-    image_segmented = None
-    if method == "threshold":
-        # TODO be able to change the parameters of 'filtered_threshold'
-        image_segmented = filtered_threshold(image_2d)
+    image_segmented = stack.cast_uint8(image_2d)
+    if segmentation_method == "threshold":
+        image_segmented = filtered_threshold(image_segmented, **kargs)
+    else:
+        pass
 
     # labelled and count segmented instances
     if return_label:
@@ -68,7 +74,7 @@ def filtered_threshold(image, kernel_shape="disk", kernel_size=200,
 
     Parameters
     ----------
-    image : np.ndarray, np.uint8
+    image : np.ndarray, np.uint
         A 2-d image to segment with shape (y, x).
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -109,7 +115,7 @@ def _remove_background(image, kernel_shape="disk", kernel_size=200):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint8
+    image : np.ndarray, np.uint
         Image to process. Casting in np.uint8 makes the computation faster.
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
@@ -120,7 +126,7 @@ def _remove_background(image, kernel_shape="disk", kernel_size=200):
 
     Returns
     -------
-    image_without_back : np.ndarray, np.uint8
+    image_without_back : np.ndarray, np.uint
         Image processed.
 
     """

From 84ad12aa557500c84d08751fc5ebee134c5e67de Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 26 Feb 2019 11:20:36 +0100
Subject: [PATCH 042/264] update default parameter value

---
 bigfish/stack/preprocess.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 28092a9a..84ffaa89 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -87,7 +87,7 @@ def build_simulated_dataset(path_cell, path_rna, path_output=None):
 
 # ### Real data ###
 
-def build_stacks(data_map, input_dimension=None, normalize=True,
+def build_stacks(data_map, input_dimension=None, normalize=False,
                  channel_to_stretch=None, stretching_percentile=99.9,
                  cast_8bit=False, return_origin=False):
     """Generator to build several stacks.

From 1d2b891b626b7ea9777611031214e6305a8c8948 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Mar 2019 17:46:35 +0100
Subject: [PATCH 043/264] add sanity checks

---
 bigfish/stack/__init__.py   |  16 +-
 bigfish/stack/preprocess.py | 321 +++++++++++++++++++++++++++++-------
 2 files changed, 271 insertions(+), 66 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index a5c145fb..1657261a 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -7,10 +7,12 @@
 
 from .loader import read_tif, read_pickle
 from .preprocess import (build_stack, check_recipe, build_simulated_dataset,
-                         projection, rescale, cast_uint8, cast_float32,
+                         projection, rescale, cast_img_uint8, cast_img_uint16,
                          log_filter, mean_filter, median_filter,
                          maximum_filter, minimum_filter, load_stack,
-                         gaussian_filter, build_stacks)
+                         gaussian_filter, build_stacks, cast_img_float32,
+                         cast_img_float64, compute_illumination_surface,
+                         correct_illumination_surface)
 from .utils import check_array, check_features_df
 
 
@@ -23,8 +25,10 @@
            "check_recipe",
            "projection",
            "rescale",
-           "cast_uint8",
-           "cast_float32",
+           "cast_img_uint8",
+           "cast_img_uint16",
+           "cast_img_float32",
+           "cast_img_float64",
            "log_filter",
            "gaussian_filter",
            "mean_filter",
@@ -32,4 +36,6 @@
            "maximum_filter",
            "minimum_filter",
            "check_array",
-           "check_features_df"]
+           "check_features_df",
+           "compute_illumination_surface",
+           "correct_illumination_surface"]
diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 84ffaa89..bdc55ae0 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -13,13 +13,15 @@
 from .loader import read_tif, read_cell_json, read_rna_json
 from .utils import check_array
 
-from skimage import img_as_ubyte, img_as_float32, img_as_float
+from skimage import img_as_ubyte, img_as_float32, img_as_float64, img_as_uint
 from skimage.morphology.selem import square, diamond, rectangle, disk
 from skimage.filters import rank, gaussian
 from skimage.exposure import rescale_intensity
 
 from scipy.ndimage import gaussian_laplace
 
+# TODO add safety checks
+
 
 # ### Simulated data ###
 
@@ -622,7 +624,7 @@ def projection(tensor, method="mip", r=0, c=0):
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.uint
+    projected_tensor : np.ndarray
         A 2-d tensor with shape (y, x).
 
     """
@@ -633,6 +635,10 @@ def projection(tensor, method="mip", r=0, c=0):
     projected_tensor = tensor[r, c, :, :, :]
     if method == "mip":
         projected_tensor = maximum_projection(projected_tensor)
+    elif method == "mean":
+        projected_tensor = mean_projection(projected_tensor)
+    elif method == "median":
+        projected_tensor = median_projection(projected_tensor)
     elif method == "focus":
         # TODO complete focus projection with different strategies
         raise ValueError("Focus projection is not implemented yet.")
@@ -661,6 +667,91 @@ def maximum_projection(tensor):
     return projected_tensor[0]
 
 
+def mean_projection(tensor):
+    """Project the z-dimension of a tensor, computing the mean intensity of
+    each yx pixel.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint
+        A 3-d tensor with shape (z, y, x).
+
+    Returns
+    -------
+    projected_tensor : np.ndarray, np.float
+        A 2-d tensor with shape (y, x).
+
+    """
+    # project tensor along the z axis
+    projected_tensor = tensor.mean(axis=0, keepdims=True)
+
+    return projected_tensor[0]
+
+
+def median_projection(tensor):
+    """Project the z-dimension of a tensor, computing the median intensity of
+    each yx pixel.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint
+        A 3-d tensor with shape (z, y, x).
+
+    Returns
+    -------
+    projected_tensor : np.ndarray, np.uint
+        A 2-d tensor with shape (y, x).
+
+    """
+    # project tensor along the z axis
+    projected_tensor = tensor.median(axis=0, keepdims=True)
+
+    return projected_tensor[0]
+
+
+def focus_projection(tensor, channel=0, p=0.75, global_neighborhood_size=30,
+                     method="best"):
+    """
+
+    Parameters
+    ----------
+    tensor
+    channel
+    p
+    global_neighborhood_size
+    method
+
+    Returns
+    -------
+
+    """
+
+    # get 3-d image
+    image = tensor[0, channel, :, :, :]
+
+    # measure global focus level for each z-slices
+    ratio, l_focus = focus_measurement_3d(image, global_neighborhood_size)
+
+    # remove out-of-focus slices
+    indices_to_keep = get_in_focus(l_focus, p)
+    in_focus_image = image[indices_to_keep]
+
+    projected_image = None
+    if method == "bast":
+        # for each pixel, we project the z-slice value with the highest focus
+        ratio_2d = np.argmax(ratio[indices_to_keep], axis=0)
+        one_hot = one_hot_3d(ratio_2d, depth=len(indices_to_keep))
+        projected_image = np.multiply(in_focus_image, one_hot).max(axis=0)
+    elif method == "median":
+        # for each pixel, we compute the median value of the in-focus z-slices
+        projected_image = np.median(in_focus_image, axis=0)
+    elif method == "mean":
+        # for each pixel, we compute the mean value of the in-focus z-slices
+        projected_image = np.median(in_focus_image, axis=0)
+
+    return projected_image, ratio, l_focus
+
+
 def focus_measurement_2d(image, neighborhood_size):
     """Helmli and Scherer’s mean method used as a focus metric.
 
@@ -814,48 +905,6 @@ def one_hot_3d(tensor_2d, depth):
     return one_hot
 
 
-def focus_projection(tensor, channel=0, p=0.75, global_neighborhood_size=30,
-                     method="best"):
-    """
-
-    Parameters
-    ----------
-    tensor
-    channel
-    p
-    global_neighborhood_size
-
-    Returns
-    -------
-
-    """
-
-    # get 3-d image
-    image = tensor[0, channel, :, :, :]
-
-    # measure global focus level for each z-slices
-    ratio, l_focus = focus_measurement_3d(image, global_neighborhood_size)
-
-    # remove out-of-focus slices
-    indices_to_keep = get_in_focus(l_focus, p)
-    in_focus_image = image[indices_to_keep]
-
-    projected_image = None
-    if method == "bast":
-        # for each pixel, we project the z-slice value with the highest focus
-        ratio_2d = np.argmax(ratio[indices_to_keep], axis=0)
-        one_hot = one_hot_3d(ratio_2d, depth=len(indices_to_keep))
-        projected_image = np.multiply(in_focus_image, one_hot).max(axis=0)
-    elif method == "median":
-        # for each pixel, we compute the median value of the in-focus z-slices
-        projected_image = np.median(in_focus_image, axis=0)
-    elif method == "mean":
-        # for each pixel, we compute the mean value of the in-focus z-slices
-        projected_image = np.median(in_focus_image, axis=0)
-
-    return projected_image, ratio, l_focus
-
-
 # ### Normalization ###
 
 def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
@@ -886,6 +935,9 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
         Tensor to rescale with shape (r, c, z, y, x).
 
     """
+    # check tensor dtype
+    check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+
     # format 'channel_to_stretch'
     if channel_to_stretch is None:
         channel_to_stretch = []
@@ -915,23 +967,26 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
     return tensor_5d
 
 
-def cast_uint8(tensor):
-    """Cast the data in np.uint8.
+def cast_img_uint8(tensor):
+    """Cast the image in np.uint8.
 
-    Cast data from np.uint16 to np.uint8 reduce the memory needed to process
-    it and accelerate computations.
+    Casting image to np.uint8 reduce the memory needed to process it and
+    accelerate computations.
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint16
-        Tensor to cast with shape (r, c, z, y, x).
+    tensor : np.ndarray
+        Image to cast.
 
     Returns
     -------
     tensor : np.ndarray, np.uint8
-        Tensor with shape (r, c, z, y, x).
+        Image cast.
 
     """
+    # check tensor dtype
+    check_array(tensor, dtype=[np.uint16, np.float32, np.float64])
+
     # cast tensor
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
@@ -940,20 +995,53 @@ def cast_uint8(tensor):
     return tensor
 
 
-def cast_float32(tensor):
+def cast_img_uint16(tensor):
+    """Cast the data in np.uint16.
+
+    Parameters
+    ----------
+    tensor : np.ndarray
+        Image to cast.
+
+    Returns
+    -------
+    tensor : np.ndarray, np.uint16
+        Image cast.
+
+    """
+    # check tensor dtype
+    check_array(tensor, dtype=[np.uint8, np.float32, np.float64])
+
+    # cast tensor
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        tensor = img_as_uint(tensor)
+
+    return tensor
+
+
+def cast_img_float32(tensor):
     """Cast the data in np.float32 and scale it between 0 and 1.
 
+    If the input data is already in np.float, the values are not rescaled.
+
+    Casting image to np.float32 reduce the memory needed to process it and
+    accelerate computations.
+
     Parameters
     ----------
     tensor : np.ndarray
-        Tensor to cast.
+        Image to cast.
 
     Returns
     -------
     tensor : np.ndarray, np.float32
-        Tensor cast.
+        image cast.
 
     """
+    # check tensor dtype
+    check_array(tensor, dtype=[np.uint8, np.uint16, np.float64])
+
     # cast tensor
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
@@ -962,9 +1050,11 @@ def cast_float32(tensor):
     return tensor
 
 
-def cast_float64(tensor):
+def cast_img_float64(tensor):
     """Cast the data in np.float64 and scale it between 0 and 1.
 
+    If the input data is already in np.float, the values are not rescaled.
+
     Parameters
     ----------
     tensor : np.ndarray
@@ -976,10 +1066,13 @@ def cast_float64(tensor):
         Tensor cast.
 
     """
+    # check tensor dtype
+    check_array(tensor, dtype=[np.uint8, np.uint16, np.float32])
+
     # cast tensor
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
-        tensor = img_as_float(tensor)
+        tensor = img_as_float64(tensor)
 
     return tensor
 
@@ -1041,6 +1134,8 @@ def mean_filter(image, kernel_shape, kernel_size):
         Filtered 2-d image with shape (y, x).
 
     """
+    # check image dtype and ndim
+    check_array(image, ndim=2, dtype=[np.uint8, np.uint16])
 
     # get kernel
     kernel = _define_kernel(shape=kernel_shape,
@@ -1073,6 +1168,8 @@ def median_filter(image, kernel_shape, kernel_size):
         Filtered 2-d image with shape (y, x).
 
     """
+    # check image dtype and ndim
+    check_array(image, ndim=2, dtype=[np.uint8, np.uint16])
 
     # get kernel
     kernel = _define_kernel(shape=kernel_shape,
@@ -1105,6 +1202,8 @@ def maximum_filter(image, kernel_shape, kernel_size):
         Filtered 2-d image with shape (y, x).
 
     """
+    # check image dtype and ndim
+    check_array(image, ndim=2, dtype=[np.uint8, np.uint16])
 
     # get kernel
     kernel = _define_kernel(shape=kernel_shape,
@@ -1137,6 +1236,8 @@ def minimum_filter(image, kernel_shape, kernel_size):
         Filtered 2-d image with shape (y, x).
 
     """
+    # check image dtype and ndim
+    check_array(image, ndim=2, dtype=[np.uint8, np.uint16])
 
     # get kernel
     kernel = _define_kernel(shape=kernel_shape,
@@ -1152,9 +1253,14 @@ def minimum_filter(image, kernel_shape, kernel_size):
 def log_filter(image, sigma):
     """Apply a Laplacian of Gaussian filter to a 2-d or 3-d image.
 
+    The function returns the inverse of the filtered image such that the pixels
+    with the highest intensity from the original (smoothed) image have
+    positive values. Those with a low intensity returning a negative value are
+    clipped to zero.
+
     Parameters
     ----------
-    image : np.ndarray, np.uint
+    image : np.ndarray
         Image with shape (z, y, x) or (y, x).
     sigma : float or Tuple(float)
         Sigma used for the gaussian filter (one for each dimension). If it's a
@@ -1165,12 +1271,16 @@ def log_filter(image, sigma):
     image_filtered : np.ndarray, np.float
         Filtered image.
     """
+    # check image dtype and ndim
+    check_array(image, ndim=[2, 3], dtype=[np.uint8, np.uint16,
+                                           np.float32, np.float64])
+
     # we cast the data in np.float to allow negative values
     image_float = None
     if image.dtype == np.uint8:
-        image_float = cast_float32(image)
+        image_float = cast_img_float32(image)
     elif image.dtype == np.uint16:
-        image_float = cast_float64(image)
+        image_float = cast_img_float64(image)
 
     # check sigma
     if isinstance(sigma, (tuple, list)):
@@ -1205,14 +1315,103 @@ def gaussian_filter(image, sigma):
         Filtered image.
 
     """
+    # TODO check for negative values
+    # check image dtype and ndim
+    check_array(image, ndim=[2, 3], dtype=[np.uint8, np.uint16,
+                                           np.float32, np.float64])
+
     # we cast the data in np.float to allow negative values
     image_float = None
     if image.dtype == np.uint8:
-        image_float = cast_float32(image)
+        image_float = cast_img_float32(image)
     elif image.dtype == np.uint16:
-        image_float = cast_float64(image)
+        image_float = cast_img_float64(image)
 
     # we apply gaussian filter
     image_filtered = gaussian(image_float, sigma=sigma)
 
     return image_filtered
+
+
+# ### Illumination surface ###
+
+def compute_illumination_surface(stacks, sigma=None):
+    """Compute the illumination surface of a specific experiment.
+
+    Parameters
+    ----------
+    stacks : np.ndarray, np.uint
+        Concatenated 5-d tensors along the z-dimension with shape
+        (r, c, z, y, x). They represent different images acquired during a
+        same experiment.
+    sigma : int
+        Sigma of the gaussian filtering used to smooth the illumination
+        surface.
+
+    Returns
+    -------
+    illumination_surfaces : np.ndarray, np.float
+        A 4-d tensor with shape (r, c, y, x) approximating the average
+        differential of illumination in our stack of images, for each channel
+        and each round.
+
+    """
+    # check stacks dtype and ndim
+    check_array(stacks, ndim=5, dtype=[np.uint8, np.uint16])
+
+    # initialize illumination surfaces
+    r, c, z, y, x = stacks.shape
+    illumination_surfaces = np.zeros((r, c, y, x))
+
+    # compute mean over the z-dimension
+    mean_stacks = np.mean(stacks, axis=2)
+
+    # separate the channels and the rounds
+    for i_round in range(r):
+        for i_channel in range(c):
+            illumination_surface = mean_stacks[i_round, i_channel, :, :]
+
+            # smooth the surface
+            if sigma is not None:
+                illumination_surface = gaussian(illumination_surface, sigma)
+
+            illumination_surfaces[i_round, i_channel] = illumination_surface
+
+    return illumination_surfaces
+
+
+def correct_illumination_surface(tensor, illumination_surfaces):
+    """Correct a tensor with uneven illumination.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint
+        A 5-d tensor with shape (r, c, z, y, x).
+    illumination_surfaces : np.ndarray, np.float
+        A 4-d tensor with shape (r, c, y, x) approximating the average
+        differential of illumination in our stack of images, for each channel
+        and each round.
+
+    Returns
+    -------
+    tensor_corrected : np.ndarray, np.float
+        A 5-d tensor with shape (r, c, z, y, x).
+
+    """
+    # check dtype and ndim
+    check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+    check_array(illumination_surfaces, ndim=4, dtype=[np.float32, np.float64])
+
+    # initialize corrected tensor
+    tensor_corrected = np.zeros_like(tensor)
+
+    # TODO control the multiplication and the division
+    # correct each round/channel independently
+    r, c, _, _, _ = tensor.shape
+    for i_round in range(r):
+        for i_channel in range(c):
+            image_3d = tensor[i_round, i_channel, ...]
+            s = illumination_surfaces[i_round, i_channel]
+            tensor_corrected[i_round, i_channel] = image_3d * np.mean(s) / s
+
+    return tensor_corrected

From 484bb2ffaa79e16c13080c1966492d6aff850c72 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Mar 2019 17:51:22 +0100
Subject: [PATCH 044/264] misc

---
 bigfish/__init__.py                  | 0
 bigfish/process.py                   | 0
 bigfish/segmentation/segmentation.py | 7 +++----
 3 files changed, 3 insertions(+), 4 deletions(-)
 delete mode 100644 bigfish/__init__.py
 delete mode 100644 bigfish/process.py

diff --git a/bigfish/__init__.py b/bigfish/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/bigfish/process.py b/bigfish/process.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
index e87b3a82..1cb4b3a5 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/segmentation.py
@@ -11,6 +11,8 @@
 from scipy import ndimage as ndi
 import numpy as np
 
+# TODO rename functions
+
 
 def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
                         return_label=False, **kargs):
@@ -47,7 +49,7 @@ def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
                                 c=c)
 
     # apply segmentation
-    image_segmented = stack.cast_uint8(image_2d)
+    image_segmented = stack.cast_img_uint8(image_2d)
     if segmentation_method == "threshold":
         image_segmented = filtered_threshold(image_segmented, **kargs)
     else:
@@ -163,6 +165,3 @@ def label_instances(image_segmented):
     """
     image_label, nb_labels = label(image_segmented, return_num=True)
     return image_label, nb_labels
-
-
-

From be3536e663649c2f8a1b325a5852a047a9561e9f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Mar 2019 17:52:47 +0100
Subject: [PATCH 045/264] add SNR computation

---
 bigfish/spot_detection/detection.py | 293 +++++++++++++++++++---------
 1 file changed, 204 insertions(+), 89 deletions(-)

diff --git a/bigfish/spot_detection/detection.py b/bigfish/spot_detection/detection.py
index 12f5da93..91d9d516 100644
--- a/bigfish/spot_detection/detection.py
+++ b/bigfish/spot_detection/detection.py
@@ -10,6 +10,10 @@
 from bigfish import stack
 
 
+# TODO complete documentation
+
+# ### Spot detection ###
+
 def detection(tensor, r, c, detection_method, **kargs):
     """
 
@@ -39,12 +43,12 @@ def detection(tensor, r, c, detection_method, **kargs):
     # apply spot detection
     peak_coordinates, radius = None, None
     if detection_method == "log_lm":
-        peak_coordinates, radius = log_lm(image, **kargs)
+        peak_coordinates, radius = detection_log_lm(image, **kargs)
 
     return peak_coordinates, radius
 
 
-def log_lm(image, sigma, minimum_distance=1, threshold=None):
+def detection_log_lm(image, sigma, minimum_distance=1, threshold=None):
     """Apply LoG filter followed by a Local Maximum algorithm to detect spots
     in a 2-d or 3-d image.
 
@@ -76,59 +80,47 @@ def log_lm(image, sigma, minimum_distance=1, threshold=None):
         Radius of the detected peaks.
 
     """
-    # cast image in np.float and apply LoG filter
-    image_filtered = stack.log_filter(image, sigma)
-
-    # find local maximum
-    mask = _non_maximum_suppression_mask(image_filtered, minimum_distance)
-
-    # remove peak with a low intensity
-    if isinstance(threshold, float):
-        threshold *= image.max()
-    mask &= image > threshold
+    # cast image in np.float, apply LoG filter and find local maximum
+    mask = log_lm(image, sigma, minimum_distance)
 
-    # get peak coordinates and radius
-    peak_coordinates = np.nonzero(mask)
-    peak_coordinates = np.column_stack(peak_coordinates)
-    radius = np.sqrt(image.ndim) * sigma[-1]
+    # remove peak with a low intensity and return coordinates and radius
+    peak_coordinates, radius = from_threshold_to_spots(image, sigma, mask,
+                                                       threshold)
 
     return peak_coordinates, radius
 
 
-def local_maximum_detection(image, minimum_distance=1, threshold=0.2):
+def log_lm(image, sigma, minimum_distance=1):
     """Find local maximum in a 2-d or 3-d image.
 
-    1) We apply a multidimensional maximum filter.
-    2) A pixel which has the same value in the original and filtered images
+    1) We smooth the image with a LoG filter.
+    2) We apply a multidimensional maximum filter.
+    3) A pixel which has the same value in the original and filtered images
     is a local maximum.
-    3) We remove local peaks under a threshold.
 
     Parameters
     ----------
     image : np.ndarray, np.float
         Image to process with shape (z, y, x) or (y, x).
+    sigma : float or Tuple(float)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
     minimum_distance : int
         Minimum distance (in number of pixels) between two local peaks.
-    threshold : float or int
-        A threshold to detect peaks. Considered as a relative threshold if
-        float.
 
     Returns
     -------
-    peak_coordinate : np.ndarray, np.int64
-        Coordinate of the local peaks with shape (nb_peaks, 3) or
-        (nb_peaks, 2).
-    """
-    mask = _non_maximum_suppression_mask(image, minimum_distance)
+    mask : np.ndarray, bool
+        Mask with shape (z, y, x) or (y, x) indicating the local peaks.
 
-    if isinstance(threshold, float):
-        threshold *= image.max()
-    mask &= image > threshold
+    """
+    # cast image in np.float and apply LoG filter
+    image_filtered = stack.log_filter(image, sigma)
 
-    peak_coordinate = np.nonzero(mask)
-    peak_coordinate = np.column_stack(peak_coordinate)
+    # find local maximum
+    mask = _non_maximum_suppression_mask(image_filtered, minimum_distance)
 
-    return peak_coordinate
+    return mask
 
 
 def _non_maximum_suppression_mask(image, minimum_distance):
@@ -164,82 +156,205 @@ def _non_maximum_suppression_mask(image, minimum_distance):
     return mask
 
 
+def from_threshold_to_spots(image, sigma, mask, threshold):
+    """
+
+    Parameters
+    ----------
+    image
+    sigma
+    mask
+    threshold
+
+    Returns
+    -------
+
+    """
+    # remove peak with a low intensity
+    if isinstance(threshold, float):
+        threshold *= image.max()
+    mask_ = (mask & (image > threshold))
+
+    # get peak coordinates and radius
+    peak_coordinates = np.nonzero(mask_)
+    peak_coordinates = np.column_stack(peak_coordinates)
+    radius = np.sqrt(image.ndim) * sigma[-1]
+
+    return peak_coordinates, radius
+
+
+# ### Signal-to-Noise ratio ###
+
+def compute_snr(image, sigma, minimum_distance=1,
+                threshold_signal_detection=2000, neighbor_factor=3):
+    """Compute Signal-to-Noise ratio for each spot detected.
+
+    Parameters
+    ----------
+    image
+    sigma
+    minimum_distance
+    threshold_signal_detection
+    neighbor_factor
+
+    Returns
+    -------
+
+    """
+    # cast image in np.float, apply LoG filter and find local maximum
+    mask = log_lm(image, sigma, minimum_distance)
+
+    # apply a specific threshold to filter the detected spots and compute snr
+    l_snr = from_threshold_to_snr(image, sigma, mask,
+                                  threshold_signal_detection,
+                                  neighbor_factor)
+
+    return l_snr
+
+
+def from_threshold_to_snr(image, sigma, mask, threshold=2000,
+                          neighbor_factor=3):
+    """
+
+    Parameters
+    ----------
+    image
+    sigma
+    mask
+    threshold
+    neighbor_factor
+
+    Returns
+    -------
+
+    """
+    # remove peak with a low intensity
+    if isinstance(threshold, float):
+        threshold *= image.max()
+    mask_ = (mask & (image > threshold))
+
+    # no spot detected
+    if mask_.sum() == 0:
+        return []
+
+    # we get the xy coordinate of the detected spot
+    spot_coordinates = np.nonzero(mask_)
+    spot_coordinates = np.column_stack(spot_coordinates)
+
+    # compute radius for the spot and the neighborhood
+    s = np.sqrt(image.ndim)
+    (z_radius, yx_radius) = (int(s * sigma[0]), int(s * sigma[1]))
+    (z_neigh, yx_neigh) = (int(s * sigma[0] * neighbor_factor),
+                           int(s * sigma[1] * neighbor_factor))
+
+    # we enlarge our mask to localize the complete signal and not just
+    # the peak
+    kernel_size_z = 2 * z_radius + 1
+    kernel_size_yx = 2 * yx_radius + 1
+    kernel_size = (kernel_size_z, kernel_size_yx, kernel_size_yx)
+    mask_ = ndi.maximum_filter(mask_, size=kernel_size,
+                               mode='constant')
+
+    # we define a binary matrix of noise
+    noise = image.astype(np.float64)
+    noise[mask_] = np.nan
+
+    l_snr = []
+    for i in range(spot_coordinates.shape[0]):
+        (z, y, x) = (spot_coordinates[i, 0],
+                     spot_coordinates[i, 1],
+                     spot_coordinates[i, 2])
+
+        max_z, max_y, max_x = image.shape
+        if (z_neigh <= z <= max_z - z_neigh - 1
+                and yx_neigh <= y <= max_y - yx_neigh - 1
+                and yx_neigh <= x <= max_x - yx_neigh - 1):
+            pass
+        else:
+            l_snr.append(np.nan)
+            continue
+
+        # extract local signal
+        local_signal = image[z - z_radius: z + z_radius + 1,
+                             y - yx_radius: y + yx_radius + 1,
+                             x - yx_radius: x + yx_radius + 1].copy()
+
+        # extract local noise
+        local_noise = noise[z - z_neigh: z + z_neigh + 1,
+                            y - yx_neigh: y + yx_neigh + 1,
+                            x - yx_neigh: x + yx_neigh + 1].copy()
+        local_noise[z_neigh - z_radius: z_neigh + z_radius + 1,
+                    yx_neigh - yx_radius: yx_neigh + yx_radius + 1,
+                    yx_neigh - yx_radius: yx_neigh + yx_radius + 1] = np.nan
+
+        # compute snr
+        snr = np.nanmean(local_signal) / np.nanstd(local_noise)
+        l_snr.append(snr)
+
+    return l_snr
+
+
+# ### Signal-to-Noise ratio ###
+
 def optimize_threshold_log_lm(tensor, sigma, thresholds,
                               r=0, c=2, minimum_distance=1, verbose=False):
+    """
+
+    Parameters
+    ----------
+    tensor
+    sigma
+    thresholds
+    r
+    c
+    minimum_distance
+    verbose
+
+    Returns
+    -------
+
+    """
     # get the smfish image
     image = tensor[r, c, :, :, :]
 
-    # cast image in np.float and apply LoG filter
-    image_filtered = stack.log_filter(image, sigma)
-
-    # find local maximum
-    mask = _non_maximum_suppression_mask(image_filtered, minimum_distance)
+    # cast image in np.float, apply LoG filter and find local maximum
+    mask = log_lm(image, sigma, minimum_distance)
     if verbose:
         print("{0} local peaks detected.".format(mask.sum()))
 
     # test different thresholds
+    radius = None
     peak_coordinates = []
     for threshold in thresholds:
-        if isinstance(threshold, float):
-            threshold *= image.max()
-        mask_ = (mask & (image > threshold))
 
         # get peak coordinates
-        peak_coordinates_ = np.nonzero(mask_)
-        peak_coordinates_ = np.column_stack(peak_coordinates_)
+        peak_coordinates_, radius = from_threshold_to_spots(image, sigma, mask,
+                                                            threshold)
         peak_coordinates.append(peak_coordinates_)
-
         if verbose:
             print("Threshold {0}: {1} RNA detected."
                   .format(threshold, peak_coordinates_.shape[0]))
 
-        # early stop if we detect zero rna
-        if peak_coordinates_.shape[0] == 0:
-            break
-
-    # reshape threshold
-    thresholds = thresholds[:len(peak_coordinates)]
-
-    # get radius
-    radius = np.sqrt(image.ndim) * sigma[-1]
-
     return peak_coordinates, thresholds, radius
 
 
-def compute_snr(image, threshold_signal_detection=0.5, neighbor_size=None):
-    # TODO add documentation
-    # TODO keep only local snr
-    # TODO improve local snr with a mean of computed local snr and not a global
-    #  snr computed with local noise.
-    mask = _non_maximum_suppression_mask(image, minimum_distance=1)
-
-    if isinstance(threshold_signal_detection, float):
-        threshold_signal_detection *= image.max()
-    mask &= image > threshold_signal_detection
-
-    signal = image.astype(np.float64)
-    signal[~mask] = np.nan
-
-    noise = image.astype(np.float64)
-    noise[mask] = np.nan
-
-    # global SNR
-    snr_1 = np.nanmean(signal) / np.nanstd(noise)
-    snr_2 = np.nanmean(signal) / np.nanstd(signal)
+def get_sigma(resolution_xy=103, resolution_z=300):
+    """Compute the optimal sigma to use gaussian models with spots.
 
-    # local SNR
-    if neighbor_size is not None:
-        mask_filtered = ndi.maximum_filter(mask,
-                                           size=neighbor_size,
-                                           mode='constant')
-
-        mask_local = mask_filtered & ~mask
-        noise_local = image.astype(np.float64)
-        noise_local[mask_local] = np.nan
-
-        snr_local = np.nanmean(signal) / np.nanstd(noise_local)
+    Parameters
+    ----------
+    resolution_xy
+    resolution_z
 
-        return snr_1, snr_2, snr_local
+    Returns
+    -------
 
-    else:
-        return snr_1, snr_2
+    """
+    # compute sigma
+    psf_xy = 200
+    psf_z = 400
+    sigma_xy = psf_xy / resolution_xy
+    sigma_z = psf_z / resolution_z
+    sigma = (sigma_z, sigma_xy, sigma_xy)
+
+    return sigma

From 0262d85a9f421b2af2c994e29df8eb8da14fe104 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Mar 2019 17:55:31 +0100
Subject: [PATCH 046/264] add todo

---
 bigfish/segmentation/segmentation.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
index 1cb4b3a5..dd014e01 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/segmentation.py
@@ -12,6 +12,7 @@
 import numpy as np
 
 # TODO rename functions
+# TODO complete documentation methods
 
 
 def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,

From d03bbf72b2bb00bb652ac8152cc5bc2e6e506872 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Mar 2019 17:58:37 +0100
Subject: [PATCH 047/264] add sanity checks

---
 bigfish/segmentation/segmentation.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
index dd014e01..8c24bfd0 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/segmentation.py
@@ -43,6 +43,9 @@ def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
     nb_labels : int
         Number of different instances segmented.
     """
+    # check tensor dimensions and its dtype
+    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+
     # get a 2-d dapi image
     image_2d = stack.projection(tensor,
                                 method=projection_method,

From 159da82a4652c7b5caed3ac01869305a950c2018 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Mar 2019 18:24:21 +0100
Subject: [PATCH 048/264] clean code detection

---
 bigfish/spot_detection/__init__.py  |   4 +-
 bigfish/spot_detection/detection.py | 158 ++++++++++++++--------------
 2 files changed, 81 insertions(+), 81 deletions(-)

diff --git a/bigfish/spot_detection/__init__.py b/bigfish/spot_detection/__init__.py
index c12dd8ed..cc9036a6 100644
--- a/bigfish/spot_detection/__init__.py
+++ b/bigfish/spot_detection/__init__.py
@@ -5,9 +5,9 @@
 3-d.
 """
 
-from .detection import detection, compute_snr, optimize_threshold_log_lm
+from .detection import (detection, compute_snr, get_sigma)
 
 
 __all__ = ["detection",
            "compute_snr",
-           "optimize_threshold_log_lm"]
+           "get_sigma"]
diff --git a/bigfish/spot_detection/detection.py b/bigfish/spot_detection/detection.py
index 91d9d516..d859c3c2 100644
--- a/bigfish/spot_detection/detection.py
+++ b/bigfish/spot_detection/detection.py
@@ -4,18 +4,18 @@
 Class and functions to detect RNA spots in 2-d and 3-d.
 """
 
+from bigfish import stack
+
 import scipy.ndimage as ndi
 import numpy as np
 
-from bigfish import stack
-
 
-# TODO complete documentation
+# TODO complete documentation methods
 
 # ### Spot detection ###
 
 def detection(tensor, r, c, detection_method, **kargs):
-    """
+    """Apply spot detection.
 
     Parameters
     ----------
@@ -37,6 +37,9 @@ def detection(tensor, r, c, detection_method, **kargs):
         Radius of the detected peaks.
 
     """
+    # check tensor dimensions and its dtype
+    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+
     # get the smfish image
     image = tensor[r, c, :, :, :]
 
@@ -81,16 +84,16 @@ def detection_log_lm(image, sigma, minimum_distance=1, threshold=None):
 
     """
     # cast image in np.float, apply LoG filter and find local maximum
-    mask = log_lm(image, sigma, minimum_distance)
+    mask = _log_lm(image, sigma, minimum_distance)
 
     # remove peak with a low intensity and return coordinates and radius
-    peak_coordinates, radius = from_threshold_to_spots(image, sigma, mask,
-                                                       threshold)
+    peak_coordinates, radius = _from_threshold_to_spots(image, sigma, mask,
+                                                        threshold)
 
     return peak_coordinates, radius
 
 
-def log_lm(image, sigma, minimum_distance=1):
+def _log_lm(image, sigma, minimum_distance=1):
     """Find local maximum in a 2-d or 3-d image.
 
     1) We smooth the image with a LoG filter.
@@ -100,7 +103,7 @@ def log_lm(image, sigma, minimum_distance=1):
 
     Parameters
     ----------
-    image : np.ndarray, np.float
+    image : np.ndarray, np.uint
         Image to process with shape (z, y, x) or (y, x).
     sigma : float or Tuple(float)
         Sigma used for the gaussian filter (one for each dimension). If it's a
@@ -156,18 +159,30 @@ def _non_maximum_suppression_mask(image, minimum_distance):
     return mask
 
 
-def from_threshold_to_spots(image, sigma, mask, threshold):
-    """
+def _from_threshold_to_spots(image, sigma, mask, threshold):
+    """Filter detected local maximum and get coordinates of the remaining
+    spots.
 
     Parameters
     ----------
-    image
-    sigma
-    mask
-    threshold
+    image : np.ndarray, np.uint
+        Image with shape (z, y, x) or (y, x).
+    sigma : float or Tuple(float)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+    mask : np.ndarray, bool
+        Mask with shape (z, y, x) or (y, x) indicating the local peaks.
+    threshold : float or int
+        A threshold to detect peaks. Considered as a relative threshold if
+        float.
 
     Returns
     -------
+    peak_coordinates : np.ndarray, np.int64
+        Coordinate of the local peaks with shape (nb_peaks, 3) or
+        (nb_peaks, 2) for 3-d or 2-d images respectively.
+    radius : float
+        Radius of the detected peaks.
 
     """
     # remove peak with a low intensity
@@ -191,38 +206,54 @@ def compute_snr(image, sigma, minimum_distance=1,
 
     Parameters
     ----------
-    image
-    sigma
-    minimum_distance
-    threshold_signal_detection
-    neighbor_factor
+    image : np.ndarray, np.uint
+        Image with shape (z, y, x) or (y, x).
+    sigma : float or Tuple(float)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+    minimum_distance : int
+        Minimum distance (in number of pixels) between two local peaks.
+    threshold_signal_detection : float or int
+        A threshold to detect peaks. Considered as a relative threshold if
+        float.
+    neighbor_factor : int or float
+        The ratio between the radius of the neighborhood defining the noise
+        and the radius of the signal.
 
     Returns
     -------
 
     """
     # cast image in np.float, apply LoG filter and find local maximum
-    mask = log_lm(image, sigma, minimum_distance)
+    mask = _log_lm(image, sigma, minimum_distance)
 
     # apply a specific threshold to filter the detected spots and compute snr
-    l_snr = from_threshold_to_snr(image, sigma, mask,
-                                  threshold_signal_detection,
-                                  neighbor_factor)
+    l_snr = _from_threshold_to_snr(image, sigma, mask,
+                                   threshold_signal_detection,
+                                   neighbor_factor)
 
     return l_snr
 
 
-def from_threshold_to_snr(image, sigma, mask, threshold=2000,
-                          neighbor_factor=3):
+def _from_threshold_to_snr(image, sigma, mask, threshold=2000,
+                           neighbor_factor=3):
     """
 
     Parameters
     ----------
-    image
-    sigma
-    mask
-    threshold
-    neighbor_factor
+    image : np.ndarray, np.uint
+        Image with shape (z, y, x) or (y, x).
+    sigma : float or Tuple(float)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+    mask : np.ndarray, bool
+        Mask with shape (z, y, x) or (y, x) indicating the local peaks.
+    threshold : float or int
+        A threshold to detect peaks. Considered as a relative threshold if
+        float.
+    neighbor_factor : int or float
+        The ratio between the radius of the neighborhood defining the noise
+        and the radius of the signal.
 
     Returns
     -------
@@ -294,65 +325,34 @@ def from_threshold_to_snr(image, sigma, mask, threshold=2000,
     return l_snr
 
 
-# ### Signal-to-Noise ratio ###
-
-def optimize_threshold_log_lm(tensor, sigma, thresholds,
-                              r=0, c=2, minimum_distance=1, verbose=False):
-    """
-
-    Parameters
-    ----------
-    tensor
-    sigma
-    thresholds
-    r
-    c
-    minimum_distance
-    verbose
-
-    Returns
-    -------
-
-    """
-    # get the smfish image
-    image = tensor[r, c, :, :, :]
-
-    # cast image in np.float, apply LoG filter and find local maximum
-    mask = log_lm(image, sigma, minimum_distance)
-    if verbose:
-        print("{0} local peaks detected.".format(mask.sum()))
-
-    # test different thresholds
-    radius = None
-    peak_coordinates = []
-    for threshold in thresholds:
-
-        # get peak coordinates
-        peak_coordinates_, radius = from_threshold_to_spots(image, sigma, mask,
-                                                            threshold)
-        peak_coordinates.append(peak_coordinates_)
-        if verbose:
-            print("Threshold {0}: {1} RNA detected."
-                  .format(threshold, peak_coordinates_.shape[0]))
-
-    return peak_coordinates, thresholds, radius
-
+# ### Utils ###
 
-def get_sigma(resolution_xy=103, resolution_z=300):
+def get_sigma(resolution_xy=103, resolution_z=300, psf_xy=200, psf_z=400):
     """Compute the optimal sigma to use gaussian models with spots.
 
     Parameters
     ----------
-    resolution_xy
-    resolution_z
+    resolution_xy : int
+        Distance, in nanometer, between two pixels along the XY dimension.
+    resolution_z : int
+        Distance, in nanometer, between two pixels along the Z dimension.
+
+    psf_xy : int
+        Theoretical size (in nanometer) of the signal emitted by a spot in
+        the XY plan.
+    psf_z : int
+        Theoretical size (in nanometer) of the signal emitted by a spot in
+        the Z plan.
 
     Returns
     -------
+    sigma : Tuple
+        A Tuple with 3 items corresponding to the sigma used by a gaussian
+        filter in each direction of the image (approximately the same size of
+        the spot in the image).
 
     """
     # compute sigma
-    psf_xy = 200
-    psf_z = 400
     sigma_xy = psf_xy / resolution_xy
     sigma_z = psf_z / resolution_z
     sigma = (sigma_z, sigma_xy, sigma_xy)

From 0a7055354c2ef94612bba14b82af25689935dd1e Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Mar 2019 18:47:16 +0100
Subject: [PATCH 049/264] add plot illumination surface & manage subtitle

---
 bigfish/plot/__init__.py    |   6 +-
 bigfish/plot/plot_images.py | 122 +++++++++++++++++++++++++++++-------
 2 files changed, 104 insertions(+), 24 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index ff65caa8..3bb1a97c 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -5,7 +5,8 @@
 """
 
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
-                          plot_projection, plot_images, plot_spot_detection)
+                          plot_projection, plot_images, plot_spot_detection,
+                          plot_illumination_surface)
 
 
 __all__ = ["plot_yx",
@@ -13,4 +14,5 @@
            "plot_channels_2d",
            "plot_projection",
            "plot_segmentation",
-           "plot_spot_detection"]
+           "plot_spot_detection",
+           "plot_illumination_surface"]
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 0a46bad2..e51363ef 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -14,7 +14,7 @@
 
 def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
             path_output=None, ext="png"):
-    """Plot the selected x and y dimensions of an image.
+    """Plot the selected yx plan of the selected dimensions of an image.
 
     Parameters
     ----------
@@ -43,7 +43,9 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
     """
     # check tensor
     stack.check_array(tensor, ndim=[2, 3, 5],
-                      dtype=[np.uint8, np.uint16, np.float32, bool])
+                      dtype=[np.uint8, np.uint16,
+                             np.float32, np.float64,
+                             bool])
 
     # get the 2-d tensor
     xy_tensor = None
@@ -61,15 +63,14 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
         plt.title(title, fontweight="bold", fontsize=25)
     plt.axis('off')
     plt.tight_layout()
-    plt.show()
-
-    # save the plot
     _save_plot(path_output, ext)
+    plt.show()
 
     return
 
 
-def plot_images(images, framesize=(15, 15), path_output=None, ext="png"):
+def plot_images(images, framesize=(15, 15), titles=None,
+                path_output=None, ext="png"):
     """Plot or subplot of 2-d images.
 
     Parameters
@@ -78,6 +79,8 @@ def plot_images(images, framesize=(15, 15), path_output=None, ext="png"):
         Images with shape (y, x).
     framesize : tuple
         Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    titles : List[str]
+        Titles of the subplots.
     path_output : str
         Path to save the image (without extension).
     ext : str or List[str]
@@ -104,7 +107,7 @@ def plot_images(images, framesize=(15, 15), path_output=None, ext="png"):
 
     # plot one image
     if len(images) == 1:
-        plot_yx(images[0], framesize=framesize,
+        plot_yx(images[0], framesize=framesize, title=titles,
                 path_output=path_output, ext=ext)
         return
 
@@ -113,21 +116,27 @@ def plot_images(images, framesize=(15, 15), path_output=None, ext="png"):
     if len(images) in [2, 3]:
         for i, image in enumerate(images):
             ax[i].imshow(image)
+            if titles is not None:
+                ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
     else:
         for i, image in enumerate(images):
             row = i // 3
             col = i % 3
             ax[row, col].imshow(image)
+            if titles is not None:
+                ax[row, col].set_title(titles[i],
+                                       fontweight="bold", fontsize=15)
     plt.tight_layout()
+    _save_plot(path_output, ext)
     plt.show()
 
-    # save the plot
-    _save_plot(path_output, ext)
+    return
 
 
-def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
-                     ext="png"):
-    """Subplot the selected x and y dimensions of an image for all channels.
+def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), titles=None,
+                     path_output=None, ext="png"):
+    """Subplot the yx plan of the selected dimensions of an image for all
+    channels.
 
     Parameters
     ----------
@@ -139,6 +148,8 @@ def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
         Index of the z slice to keep.
     framesize : tuple
         Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    titles : List[str]
+        Titles of the subplots (one per channel).
     path_output : str
         Path to save the image (without extension).
     ext : str or List[str]
@@ -159,11 +170,58 @@ def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), path_output=None,
     fig, ax = plt.subplots(1, nb_channels, sharex='col', figsize=framesize)
     for i in range(nb_channels):
         ax[i].imshow(tensor[r, i, z, :, :])
+        if titles is not None:
+            ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
     plt.tight_layout()
+    _save_plot(path_output, ext)
     plt.show()
 
-    # save the plot
+    return
+
+
+def plot_illumination_surface(illumination_surface, r=0, framesize=(15, 15),
+                              titles=None, path_output=None, ext="png"):
+    """Subplot the yx plan of the dimensions of an illumination surface for
+    all channels.
+
+    Parameters
+    ----------
+    illumination_surface : np.ndarray, np.float
+        A 4-d tensor with shape (r, c, y, x) approximating the average
+        differential of illumination in our stack of images, for each channel
+        and each round.
+    r : int
+        Index of the round to keep.
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    titles : List[str]
+        Titles of the subplots (one per channel).
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # check tensor
+    stack.check_array(illumination_surface, ndim=4,
+                      dtype=[np.float32, np.float64])
+
+    # get the number of channels
+    nb_channels = illumination_surface.shape[1]
+
+    # plot
+    fig, ax = plt.subplots(1, nb_channels, sharex='col', figsize=framesize)
+    for i in range(nb_channels):
+        ax[i].imshow(illumination_surface[r, i, :, :])
+        if titles is not None:
+            ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
+    plt.tight_layout()
     _save_plot(path_output, ext)
+    plt.show()
 
     return
 
@@ -176,7 +234,7 @@ def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
     ----------
     tensor : np.ndarray, np.uint
         A 5-d tensor with shape (r, c, z, y, x).
-    projection : np.ndarray, np.uint8
+    projection : np.ndarray
         A 2-d image with shape (y, x).
     r : int
         Index of the round to keep.
@@ -198,22 +256,25 @@ def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
     """
     # check tensor
     stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-    stack.check_array(projection, ndim=2, dtype=[np.uint8, np.uint16])
+    stack.check_array(projection, ndim=2, dtype=[np.uint8, np.uint16,
+                                                 np.float32, np.float64])
 
     # plot
     fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
     ax[0].imshow(tensor[r, c, z, :, :])
+    ax[0].set_title("Z-slice: {0}".format(z), fontweight="bold", fontsize=15)
     ax[1].imshow(projection)
+    ax[1].set_title("Projected image", fontweight="bold", fontsize=15)
     plt.tight_layout()
+    _save_plot(path_output, ext)
     plt.show()
 
-    # save the plot
-    _save_plot(path_output, ext)
+    return
 
 
 def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
                       framesize=(15, 15), path_output=None, ext="png"):
-    """Plot result of a 2-d segmentation, with labelled instances is available.
+    """Plot result of a 2-d segmentation, with labelled instances if available.
 
     Parameters
     ----------
@@ -251,17 +312,26 @@ def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
     if label is not None:
         fig, ax = plt.subplots(1, 3, sharex='col', figsize=framesize)
         ax[0].imshow(tensor[r, c, z, :, :])
+        ax[0].set_title("Z-slice: {0}".format(z),
+                        fontweight="bold", fontsize=15)
         ax[1].imshow(segmentation)
+        ax[1].set_title("Segmentation", fontweight="bold", fontsize=15)
         ax[2].imshow(label)
+        ax[2].set_title("Labels", fontweight="bold", fontsize=15)
+
     else:
         fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
         ax[0].imshow(tensor[r, c, z, :, :])
+        ax[0].set_title("Z-slice: {0}".format(z),
+                        fontweight="bold", fontsize=15)
         ax[1].imshow(segmentation)
+        ax[1].set_title("Segmentation", fontweight="bold", fontsize=15)
+
     plt.tight_layout()
+    _save_plot(path_output, ext)
     plt.show()
 
-    # save the plot
-    _save_plot(path_output, ext)
+    return
 
 
 def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
@@ -313,7 +383,9 @@ def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
         # plot
         fig, ax = plt.subplots(1, 2, figsize=framesize)
         ax[0].imshow(image_2d)
+        ax[1].set_title("Projected image", fontweight="bold", fontsize=15)
         ax[1].imshow(image_2d)
+        ax[1].set_title("All detected spots", fontweight="bold", fontsize=15)
         for spot_coordinate in coordinates:
             _, y, x = spot_coordinate
             c = plt.Circle((x, y), radius,
@@ -322,6 +394,7 @@ def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
                            fill=False)
             ax[1].add_patch(c)
         plt.tight_layout()
+        _save_plot(path_output, ext)
         plt.show()
 
     # a specific z-slice
@@ -336,7 +409,10 @@ def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
         # plot
         fig, ax = plt.subplots(1, 2, figsize=framesize)
         ax[0].imshow(image_2d)
+        ax[0].set_title("Z-slice: {0}".format(z),
+                        fontweight="bold", fontsize=15)
         ax[1].imshow(image_2d)
+        ax[1].set_title("Detected spots", fontweight="bold", fontsize=15)
         for spot_coordinate in coordinates:
             y, x = spot_coordinate
             c = plt.Circle((x, y), radius,
@@ -345,10 +421,10 @@ def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
                            fill=False)
             ax[1].add_patch(c)
         plt.tight_layout()
+        _save_plot(path_output, ext)
         plt.show()
 
-    # save the plot
-    _save_plot(path_output, ext)
+    return
 
 
 def _save_plot(path_output, ext):
@@ -376,3 +452,5 @@ def _save_plot(path_output, ext):
         else:
             Warning("Plot is not saved because the extension is not valid: "
                     "{0}.".format(ext))
+
+    return

From 07bccd84e04e79b80bd519a257600c55d8520177 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Mar 2019 18:48:39 +0100
Subject: [PATCH 050/264] remove an unit test

---
 tests/tests_loader.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 tests/tests_loader.py

diff --git a/tests/tests_loader.py b/tests/tests_loader.py
deleted file mode 100644
index e69de29b..00000000

From 04dd5edbfba615c767fe8b837191cf7df29abcf0 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Mar 2019 17:59:41 +0100
Subject: [PATCH 051/264] add plot coordinates

---
 bigfish/plot/__init__.py         |  5 +-
 bigfish/plot/plot_coordinates.py | 94 ++++++++++++++++++++++++++++++++
 bigfish/plot/plot_images.py      | 47 ++++------------
 bigfish/plot/utils.py            |  0
 4 files changed, 108 insertions(+), 38 deletions(-)
 create mode 100644 bigfish/plot/utils.py

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index 3bb1a97c..68d8bd10 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -7,6 +7,7 @@
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
                           plot_projection, plot_images, plot_spot_detection,
                           plot_illumination_surface)
+from .plot_coordinates import plot_volume, plot_rna
 
 
 __all__ = ["plot_yx",
@@ -15,4 +16,6 @@
            "plot_projection",
            "plot_segmentation",
            "plot_spot_detection",
-           "plot_illumination_surface"]
+           "plot_illumination_surface",
+           "plot_volume",
+           "plot_rna"]
diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
index e69de29b..2c72dc51 100644
--- a/bigfish/plot/plot_coordinates.py
+++ b/bigfish/plot/plot_coordinates.py
@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions to plot nucleus, cytoplasm and RNA coordinates.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from .utils import save_plot
+
+
+def plot_volume(data_cell, id_cell, framesize=(7, 7), path_output=None,
+                ext="png"):
+    """Plot Cytoplasm and nucleus borders.
+
+    Parameters
+    ----------
+    data_cell : pandas.DataFrame
+        Dataframe with the coordinates of the cell.
+    id_cell : int
+        Id of the cell volume to plot.
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # TODO Sanity check of the dataframe
+
+    # get cloud points
+    cyto = data_cell.loc[id_cell, "pos_cell"]
+    cyto = np.array(cyto)
+    nuc = data_cell.loc[id_cell, "pos_nuc"]
+    nuc = np.array(nuc)
+
+    # plot
+    plt.figure(figsize=framesize)
+    plt.plot(cyto[:, 1], cyto[:, 0], c="black", linewidth=2)
+    plt.plot(nuc[:, 1], nuc[:, 0], c="steelblue", linewidth=2)
+    plt.title("Cell id: {}".format(id_cell), fontweight="bold", fontsize=15)
+    plt.tight_layout()
+    save_plot(path_output, ext)
+    plt.show()
+
+    return
+
+
+def plot_rna(data_merged, id_cell, framesize=(7, 7), path_output=None,
+             ext="png"):
+    """
+
+    Parameters
+    ----------
+    data_merged : pandas.DataFrame
+        Dataframe with the coordinate of the cell and those of the RNA.
+    id_cell : int
+        ID of the cell to plot.
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # TODO Sanity check of the dataframe
+
+    # get cloud points
+    cyto = data_merged.loc[id_cell, "pos_cell"]
+    cyto = np.array(cyto)
+    rna = data_merged.loc[id_cell, "RNA_pos"]
+    rna = np.array(rna)
+
+    # plot
+    plt.figure(figsize=framesize)
+    plt.plot(cyto[:, 1], cyto[:, 0], c="black", linewidth=2)
+    plt.scatter(rna[:, 1], rna[:, 0], c="firebrick", s=50, marker="x")
+    plt.title("Cell id: {}".format(id_cell), fontweight="bold", fontsize=15)
+    plt.tight_layout()
+    save_plot(path_output, ext)
+    plt.show()
+
+    return
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index e51363ef..3a10d670 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -9,6 +9,8 @@
 import matplotlib.pyplot as plt
 import numpy as np
 
+from .utils import save_plot
+
 
 # TODO add title in the plot and remove axes
 
@@ -63,7 +65,7 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
         plt.title(title, fontweight="bold", fontsize=25)
     plt.axis('off')
     plt.tight_layout()
-    _save_plot(path_output, ext)
+    save_plot(path_output, ext)
     plt.show()
 
     return
@@ -127,7 +129,7 @@ def plot_images(images, framesize=(15, 15), titles=None,
                 ax[row, col].set_title(titles[i],
                                        fontweight="bold", fontsize=15)
     plt.tight_layout()
-    _save_plot(path_output, ext)
+    save_plot(path_output, ext)
     plt.show()
 
     return
@@ -173,7 +175,7 @@ def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), titles=None,
         if titles is not None:
             ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
     plt.tight_layout()
-    _save_plot(path_output, ext)
+    save_plot(path_output, ext)
     plt.show()
 
     return
@@ -220,7 +222,7 @@ def plot_illumination_surface(illumination_surface, r=0, framesize=(15, 15),
         if titles is not None:
             ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
     plt.tight_layout()
-    _save_plot(path_output, ext)
+    save_plot(path_output, ext)
     plt.show()
 
     return
@@ -266,7 +268,7 @@ def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
     ax[1].imshow(projection)
     ax[1].set_title("Projected image", fontweight="bold", fontsize=15)
     plt.tight_layout()
-    _save_plot(path_output, ext)
+    save_plot(path_output, ext)
     plt.show()
 
     return
@@ -328,7 +330,7 @@ def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
         ax[1].set_title("Segmentation", fontweight="bold", fontsize=15)
 
     plt.tight_layout()
-    _save_plot(path_output, ext)
+    save_plot(path_output, ext)
     plt.show()
 
     return
@@ -394,7 +396,7 @@ def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
                            fill=False)
             ax[1].add_patch(c)
         plt.tight_layout()
-        _save_plot(path_output, ext)
+        save_plot(path_output, ext)
         plt.show()
 
     # a specific z-slice
@@ -421,36 +423,7 @@ def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
                            fill=False)
             ax[1].add_patch(c)
         plt.tight_layout()
-        _save_plot(path_output, ext)
+        save_plot(path_output, ext)
         plt.show()
 
     return
-
-
-def _save_plot(path_output, ext):
-    """Save the plot.
-
-    Parameters
-    ----------
-    path_output : str
-        Path to save the image (without extension).
-    ext : str or List[str]
-        Extension used to save the plot. If it is a list of strings, the plot
-        will be saved several times.
-
-    Returns
-    -------
-
-    """
-    # save the plot
-    if path_output is not None:
-        if isinstance(ext, str):
-            plt.savefig(path_output, format=ext)
-        elif isinstance(ext, list):
-            for ext_ in ext:
-                plt.savefig(path_output, format=ext_)
-        else:
-            Warning("Plot is not saved because the extension is not valid: "
-                    "{0}.".format(ext))
-
-    return
diff --git a/bigfish/plot/utils.py b/bigfish/plot/utils.py
new file mode 100644
index 00000000..e69de29b

From 83a9865cbe1fef40c8cbc6dd31a535f2e7924474 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 15 Mar 2019 18:00:41 +0100
Subject: [PATCH 052/264] refactor save_plot

---
 bigfish/plot/utils.py | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/bigfish/plot/utils.py b/bigfish/plot/utils.py
index e69de29b..c342e519 100644
--- a/bigfish/plot/utils.py
+++ b/bigfish/plot/utils.py
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+"""
+Utility functions for bigfish.plot submodule.
+"""
+
+import matplotlib.pyplot as plt
+
+
+def save_plot(path_output, ext):
+    """Save the plot.
+
+    Parameters
+    ----------
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # save the plot
+    if path_output is not None:
+        if isinstance(ext, str):
+            plt.savefig(path_output, format=ext)
+        elif isinstance(ext, list):
+            for ext_ in ext:
+                plt.savefig(path_output, format=ext_)
+        else:
+            Warning("Plot is not saved because the extension is not valid: "
+                    "{0}.".format(ext))
+
+    return

From 4870816550dc4b45f4e8ea9862072bc430e04439 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Mar 2019 19:53:00 +0100
Subject: [PATCH 053/264] add plot coordinates

---
 bigfish/plot/__init__.py         |   8 +-
 bigfish/plot/plot_coordinates.py | 144 ++++++++++++++++++++++++++++++-
 2 files changed, 149 insertions(+), 3 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index 68d8bd10..506c9a14 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -7,7 +7,8 @@
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
                           plot_projection, plot_images, plot_spot_detection,
                           plot_illumination_surface)
-from .plot_coordinates import plot_volume, plot_rna
+from .plot_coordinates import (plot_volume, plot_rna, plot_distribution_rna,
+                               plot_cell_coordinates, plot_layers_coordinates)
 
 
 __all__ = ["plot_yx",
@@ -18,4 +19,7 @@
            "plot_spot_detection",
            "plot_illumination_surface",
            "plot_volume",
-           "plot_rna"]
+           "plot_rna",
+           "plot_distribution_rna",
+           "plot_cell_coordinates",
+           "plot_layers_coordinates"]
diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
index 2c72dc51..a8a993bd 100644
--- a/bigfish/plot/plot_coordinates.py
+++ b/bigfish/plot/plot_coordinates.py
@@ -3,6 +3,7 @@
 """
 Functions to plot nucleus, cytoplasm and RNA coordinates.
 """
+import bigfish.stack as stack
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -54,7 +55,7 @@ def plot_volume(data_cell, id_cell, framesize=(7, 7), path_output=None,
 
 def plot_rna(data_merged, id_cell, framesize=(7, 7), path_output=None,
              ext="png"):
-    """
+    """Plot cytoplasm border and RNA spots.
 
     Parameters
     ----------
@@ -92,3 +93,144 @@ def plot_rna(data_merged, id_cell, framesize=(7, 7), path_output=None,
     plt.show()
 
     return
+
+
+def plot_distribution_rna(data, data_validation=None, data_test=None,
+                          framesize=(10, 5), path_output=None, ext="png"):
+    """Plot RNA distribution.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with all the data (or the train data in case of split data).
+    data_validation : pandas.DataFrame
+        Dataframe with the validation data
+    data_test : pandas.DataFrame
+        Dataframe with the test data.
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # plot one histogram
+    if data_validation is None and data_test is None:
+        plt.figure(figsize=framesize)
+        plt.title("RNA distribution", fontweight="bold")
+        plt.hist(data["nb_rna"], bins=100, color="steelblue",
+                 edgecolor='black', linewidth=1.2)
+        plt.xlabel("Number of RNA")
+        plt.ylabel("Frequency")
+        plt.tight_layout()
+        save_plot(path_output, ext)
+        plt.show()
+
+    # plot several histograms
+    elif data_validation is not None and data_test is not None:
+        fig, ax = plt.subplots(3, 1, sharex="col", figsize=framesize)
+        ax[0].hist(data["nb_rna"], bins=100, color="steelblue",
+                   edgecolor='black', linewidth=1.2)
+        ax[0].set_title("RNA distribution (train)", fontweight="bold",
+                        fontsize=15)
+        ax[0].set_ylabel("Frequency")
+        ax[1].hist(data_validation["nb_rna"], bins=100, color="steelblue",
+                   edgecolor='black', linewidth=1.2)
+        ax[1].set_title("RNA distribution (validation)", fontweight="bold",
+                        fontsize=15)
+        ax[1].set_ylabel("Frequency")
+        ax[2].hist(data_test["nb_rna"], bins=100, color="steelblue",
+                   edgecolor='black', linewidth=1.2)
+        ax[2].set_title("RNA distribution (test)", fontweight="bold",
+                        fontsize=15)
+        ax[2].set_ylabel("Frequency")
+        ax[2].set_xlabel("Number of RNA")
+        plt.tight_layout()
+        save_plot(path_output, ext)
+        plt.show()
+
+    return
+
+
+def plot_cell_coordinates(data, id_cell, title=None, framesize=(5, 10),
+                          path_output=None, ext="png"):
+    """
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with all the data.
+    id_cell : int
+        Index of the cell to plot
+    title : str
+        Title of the plot
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # get the cytoplasm, the nuclei and the rna spots
+    cyt, nuc, rna = stack.get_coordinates(data, id_cell)
+
+    # plot
+    plt.figure(figsize=framesize)
+    if title is not None:
+        plt.title(title, fontweight="bold", fontsize=25)
+    plt.plot(cyt[:, 1], cyt[:, 0], c="black", linewidth=2)
+    plt.plot(nuc[:, 1], nuc[:, 0], c="steelblue", linewidth=2)
+    plt.scatter(rna[:, 1], rna[:, 0], s=25, c="firebrick", marker=".")
+    plt.tight_layout()
+    save_plot(path_output, ext)
+    plt.show()
+
+    return
+
+
+def plot_layers_coordinates(layers, titles=None, framesize=(5, 10),
+                            path_output=None, ext="png"):
+    """Plot input layers of the classification model.
+
+    Parameters
+    ----------
+    layers : List[np.ndarray]
+        List of the input images feed into the model.
+    titles : List[str]
+        List of the subtitles.
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # plot
+    fig, ax = plt.subplots(1, 3, figsize=framesize)
+    ax[0].imshow(layers[0], cmap="binary", origin='lower')
+    ax[1].imshow(layers[1], cmap="binary", origin='lower')
+    ax[2].imshow(layers[2], cmap="binary", origin='lower')
+    if titles is not None:
+        ax[0].set_title(titles[0], fontweight="bold", fontsize=15)
+        ax[1].set_title(titles[1], fontweight="bold", fontsize=15)
+        ax[2].set_title(titles[2], fontweight="bold", fontsize=15)
+    plt.tight_layout()
+    save_plot(path_output, ext)
+    plt.show()
+
+    return

From 49f6ba58186b2f46d6ecf3c770cedc8e5ca24b8e Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Mar 2019 19:53:58 +0100
Subject: [PATCH 054/264] fix 'read_rna_json'

---
 bigfish/stack/loader.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bigfish/stack/loader.py b/bigfish/stack/loader.py
index e7e79c22..5323fc6a 100644
--- a/bigfish/stack/loader.py
+++ b/bigfish/stack/loader.py
@@ -82,7 +82,7 @@ def read_rna_json(path):
     df = pd.read_json(path)
 
     # check the output has the right number of features
-    if df.ndim != 9:
+    if df.shape[1] != 9:
         raise ValueError("The file does not seem to have the right number of "
                          "features. It returns {0} dimensions instead of 9."
                          .format(df.ndim))

From 185986bee3d4a8cde3f0f554b16b5ae2e0d5098d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Mar 2019 19:54:21 +0100
Subject: [PATCH 055/264] add augmentation functions

---
 bigfish/stack/augmentation.py | 188 ++++++++++++++++++++++++++++++++++
 1 file changed, 188 insertions(+)

diff --git a/bigfish/stack/augmentation.py b/bigfish/stack/augmentation.py
index e69de29b..3ca5cf21 100644
--- a/bigfish/stack/augmentation.py
+++ b/bigfish/stack/augmentation.py
@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions to augment the data (images or coordinates).
+"""
+
+import numpy as np
+
+
+def identity(image):
+    """don't apply any operation to the image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        Image with shape (x, y, channels).
+
+    Returns
+    -------
+    image : np.ndarray, np.float32
+        Image with shape (x, y, channels).
+
+    """
+    return image
+
+
+def flip_h(image):
+    """Flip an image horizontally.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        Image to flip with shape (x, y, channels).
+
+    Returns
+    -------
+    image_flipped : np.ndarray, np.float32
+        Image flipped with shape (x, y, channels).
+
+    """
+    image_flipped = np.flip(image, axis=0)
+
+    return image_flipped
+
+
+def flip_v(image):
+    """Flip an image vertically.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        Image to flip with shape (x, y, channels).
+
+    Returns
+    -------
+    image_flipped : np.ndarray, np.float32
+        Image flipped with shape (x, y, channels).
+
+    """
+    image_flipped = np.flip(image, axis=1)
+
+    return image_flipped
+
+
+def transpose(image):
+    """Transpose an image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        Image to transpose with shape (x, y, channels).
+
+    Returns
+    -------
+    image_transposed : np.ndarray, np.float32
+        Image transposed with shape (x, y, channels).
+
+    """
+    image_transposed = np.transpose(image, axes=(1, 0, 2))
+
+    return image_transposed
+
+
+def rotation_90(image):
+    """Rotate an image with 90 degrees.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        Image to rotate with shape (x, y, channels).
+
+    Returns
+    -------
+    image_rotated : np.ndarray, np.float32
+        Image rotated with shape (x, y, channels).
+
+    """
+    image_rotated = flip_h(image)
+    image_rotated = transpose(image_rotated)
+
+    return image_rotated
+
+
+def rotation_180(image):
+    """Rotate an image with 90 degrees.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        Image to rotate with shape (x, y, channels).
+
+    Returns
+    -------
+    image_rotated : np.ndarray, np.float32
+        Image rotated with shape (x, y, channels).
+
+    """
+    image_rotated = flip_v(image)
+    image_rotated = flip_h(image_rotated)
+
+    return image_rotated
+
+
+def rotation_270(image):
+    """Rotate an image with 90 degrees.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        Image to rotate with shape (x, y, channels).
+
+    Returns
+    -------
+    image_rotated : np.ndarray, np.float32
+        Image rotated with shape (x, y, channels).
+
+    """
+    image_rotated = flip_v(image)
+    image_rotated = transpose(image_rotated)
+
+    return image_rotated
+
+
+def transpose_inverse(image):
+    """Transpose an image from the other diagonal.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        Image to transpose with shape (x, y, channels).
+
+    Returns
+    -------
+    image_transposed : np.ndarray, np.float32
+        Image transposed with shape (x, y, channels).
+
+    """
+    image_transposed = rotation_270(image)
+    image_transposed = transpose(image_transposed)
+
+    return image_transposed
+
+
+def augment(image):
+    """Augment an image applying a random operation.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        Image to augment with shape (x, y, channels).
+
+    Returns
+    -------
+    image_augmented : np.ndarray, np.float32
+        Image augmented with shape (x, y, channels).
+
+    """
+    # randomly choose an operator
+    operations = [identity,
+                  flip_h, flip_v,
+                  transpose, transpose_inverse,
+                  rotation_90, rotation_180, rotation_270]
+    random_operation = np.random.choice(operations)
+
+    # augment the image
+    image_augmented = random_operation(image)
+
+    return image_augmented

From 9f22efd2a9a882932226c9225f414e238a9be077 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Mar 2019 19:55:00 +0100
Subject: [PATCH 056/264] add cleaning functions for point cloud data

---
 bigfish/stack/preprocess.py | 285 ++++++++++++++++++++++++++++++++++--
 1 file changed, 276 insertions(+), 9 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index bdc55ae0..dd607be2 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -11,7 +11,9 @@
 import pandas as pd
 
 from .loader import read_tif, read_cell_json, read_rna_json
-from .utils import check_array
+from .utils import check_array, check_range_value
+
+from sklearn.preprocessing import LabelEncoder
 
 from skimage import img_as_ubyte, img_as_float32, img_as_float64, img_as_uint
 from skimage.morphology.selem import square, diamond, rectangle, disk
@@ -19,6 +21,10 @@
 from skimage.exposure import rescale_intensity
 
 from scipy.ndimage import gaussian_laplace
+from scipy.sparse import coo_matrix
+
+from scipy import ndimage as ndi
+
 
 # TODO add safety checks
 
@@ -57,7 +63,6 @@ def build_simulated_dataset(path_cell, path_rna, path_output=None):
     """
     # read the cell data (nucleus + cytoplasm)
     df_cell = read_cell_json(path_cell)
-    print("data cell: {0}".format(df_cell.shape))
 
     # read the RNA data
     if os.path.isdir(path_rna):
@@ -74,11 +79,9 @@ def build_simulated_dataset(path_cell, path_rna, path_output=None):
     else:
         # we directly read the json file
         df_rna = read_rna_json(path_rna)
-    print("data rna: {0}".format(df_rna.shape))
 
     # merge the dataframe
     df = pd.merge(df_rna, df_cell, on="name_img_BGD")
-    print("data: {0}".format(df.shape))
 
     # save output
     if path_output is not None:
@@ -256,7 +259,7 @@ def build_stack(recipe, input_folder, input_dimension=None, normalize=False,
 
     # cast in np.uint8 if necessary, in order to reduce memory allocation
     if tensor.dtype == np.uint16 and cast_8bit:
-        tensor = cast_uint8(tensor)
+        tensor = cast_img_uint8(tensor)
 
     return tensor
 
@@ -985,7 +988,25 @@ def cast_img_uint8(tensor):
 
     """
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint16, np.float32, np.float64])
+    check_array(tensor, dtype=[np.uint16,
+                               np.float32, np.float64,
+                               np.bool])
+
+    # check the range value for float tensors
+    if tensor.dtype in [np.float32, np.float64]:
+        if not check_range_value(tensor, 0, 1):
+            raise ValueError("To cast a tensor from {0} to np.uint8, its "
+                             "values must be between 0 and 1, and not {1} "
+                             "and {2}."
+                             .format(tensor.dtype, tensor.min(), tensor.max()))
+
+    # check the range value for integer tensors
+    elif tensor.dtype == np.uint16:
+        if not check_range_value(tensor, 0, 255):
+            raise ValueError("To cast a tensor from np.uint16 to np.uint8, "
+                             "its values must be between 0 and 255, and not "
+                             "{0} and {1}.Otherwise, the values are clipped."
+                             .format(tensor.min(), tensor.max()))
 
     # cast tensor
     with warnings.catch_warnings():
@@ -1010,7 +1031,17 @@ def cast_img_uint16(tensor):
 
     """
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint8, np.float32, np.float64])
+    check_array(tensor, dtype=[np.uint8,
+                               np.float32, np.float64,
+                               np.bool])
+
+    # check the range value for float tensors
+    if tensor.dtype in [np.float32, np.float64]:
+        if not check_range_value(tensor, 0, 1):
+            raise ValueError("To cast a tensor from {0} to np.uint16, its "
+                             "values must be between 0 and 1, and not {1} "
+                             "and {2}."
+                             .format(tensor.dtype, tensor.min(), tensor.max()))
 
     # cast tensor
     with warnings.catch_warnings():
@@ -1040,7 +1071,8 @@ def cast_img_float32(tensor):
 
     """
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint8, np.uint16, np.float64])
+    check_array(tensor, dtype=[np.uint8, np.uint16,
+                               np.float64, np.bool])
 
     # cast tensor
     with warnings.catch_warnings():
@@ -1067,7 +1099,9 @@ def cast_img_float64(tensor):
 
     """
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint8, np.uint16, np.float32])
+    check_array(tensor, dtype=[np.uint8, np.uint16,
+                               np.float32,
+                               np.bool])
 
     # cast tensor
     with warnings.catch_warnings():
@@ -1415,3 +1449,236 @@ def correct_illumination_surface(tensor, illumination_surfaces):
             tensor_corrected[i_round, i_channel] = image_3d * np.mean(s) / s
 
     return tensor_corrected
+
+
+# ### Coordinates data cleaning ###
+
+def clean_simulated_data(data, data_cell, path_output=None):
+    """Clean simulated dataset.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with all the simulated cells, the coordinates of their
+        different elements and the localization pattern used to simulate them.
+    data_cell : pandas.DataFrame
+        Dataframe with the 2D coordinates of the nucleus and the cytoplasm of
+        actual cells used to simulate data.
+    path_output : str
+        Path to save the cleaned dataset.
+
+    Returns
+    -------
+    data_final : pandas.DataFrame
+        Cleaned dataset.
+    background_to_remove : List[str]
+        Invalid background.
+    id_volume : List[int]
+        Background id from 'data_cell' to remove.
+    id_rna : List[int]
+        Cell id to remove from data.
+
+    """
+    # filter invalid simulated cell backgrounds
+    data_clean, background_to_remove, id_volume = clean_volume(data, data_cell)
+
+    # filter invalid simulated rna spots
+    data_clean, id_rna = clean_rna(data_clean)
+
+    # make the feature 'n_rna' consistent
+    data_clean["nb_rna"] = data_clean.apply(
+        lambda row: len(row["RNA_pos"]),
+        axis=1)
+
+    # remove useless features
+    data_final = data_clean[
+        ['RNA_pos', 'cell_ID', 'pattern_level', 'pattern_name', 'pos_cell',
+         'pos_nuc', "nb_rna"]]
+
+    # encode the label
+    le = LabelEncoder()
+    data_final["label"] = le.fit_transform(data_final["pattern_name"])
+
+    # reset index
+    data_final.reset_index(drop=True, inplace=True)
+
+    # save cleaned dataset
+    if path_output is not None:
+        data_final.to_pickle(path_output)
+
+    return data_final, background_to_remove, id_volume, id_rna
+
+
+def clean_volume(data, data_cell):
+    """Remove misaligned simulated cells from the dataset.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with all the simulated cells, the coordinates of their
+        different elements and the localization pattern used to simulate them.
+    data_cell : pandas.DataFrame
+        Dataframe with the 2D coordinates of the nucleus and the cytoplasm of
+        actual cells used to simulate data.
+
+    Returns
+    -------
+    data_clean : pandas.DataFrame
+        Cleaned dataframe.
+    background_to_remove : List[str]
+        Invalid background.
+    id_to_remove : List[int]
+        Background id from 'data_cell' to remove.
+
+    """
+    # for each cell, check if the volume is valid or not
+    data_cell["valid_volume"] = data_cell.apply(
+        lambda row: _check_volume(row["pos_cell"], row["pos_nuc"]),
+        axis=1)
+
+    # get the invalid backgrounds
+    background_to_remove = []
+    id_to_remove = []
+    for i in data_cell.index:
+        if np.logical_not(data_cell.loc[i, "valid_volume"]):
+            background_to_remove.append(data_cell.loc[i, "name_img_BGD"])
+            id_to_remove.append(i)
+
+    # remove invalid simulated cells
+    data_clean = data[~data["name_img_BGD"].isin(background_to_remove)]
+
+    return data_clean, background_to_remove, id_to_remove
+
+
+def _check_volume(cyto_coord, nuc_coord):
+    """Check nucleus coordinates are not outside the boundary of the cytoplasm.
+
+    Parameters
+    ----------
+    cyto_coord : pandas.Series
+        Coordinates of the cytoplasm membrane.
+    nuc_coord : pandas.Series
+        Coordinates of the nucleus border.
+
+    Returns
+    -------
+    _ : bool
+        Tell if the cell volume is valid or not.
+
+    """
+    # get coordinates
+    cyto = np.array(cyto_coord)
+    nuc = np.array(nuc_coord)
+
+    max_x = max(cyto[:, 0].max() + 5, nuc[:, 0].max() + 5)
+    max_y = max(cyto[:, 1].max() + 5, nuc[:, 1].max() + 5)
+
+    # build the dense representation for the cytoplasm
+    values = [1] * cyto.shape[0]
+    cyto = coo_matrix((values, (cyto[:, 0], cyto[:, 1])),
+                      shape=(max_x, max_y)).todense()
+
+    # build the dense representation for the nucleus
+    values = [1] * nuc.shape[0]
+    nuc = coo_matrix((values, (nuc[:, 0], nuc[:, 1])),
+                     shape=(max_x, max_y)).todense()
+
+    # check if the volume is valid
+    mask_cyto = ndi.binary_fill_holes(cyto)
+    mask_nuc = ndi.binary_fill_holes(nuc)
+    frame = np.zeros((max_x, max_y))
+    diff = frame - mask_cyto + mask_nuc
+    diff = (diff > 0).sum()
+
+    if diff > 0:
+        return False
+    else:
+        return True
+
+
+def clean_rna(data):
+    """Remove cells with misaligned simulated rna spots from the dataset.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with all the simulated cells, the coordinates of their
+        different elements and the localization pattern used to simulate them.
+
+    Returns
+    -------
+    data_clean : pandas.DataFrame
+        Cleaned dataframe.
+    id_to_remove : List[int]
+        Cell id to remove from data.
+
+    """
+    # for each cell we check if the rna spots are valid or not
+    data["valid_rna"] = data.apply(
+        lambda row: _check_rna(row["pos_cell"], row["RNA_pos"]),
+        axis=1)
+
+    # get id of the invalid cells
+    id_to_remove = []
+    for i in data.index:
+        if np.logical_not(data.loc[i, "valid_rna"]):
+            id_to_remove.append(i)
+
+    # remove invalid simulated cells
+    data_clean = data[data["valid_rna"]]
+
+    return data_clean, id_to_remove
+
+
+def _check_rna(cyto_coord, rna_coord):
+    """Check rna spots coordinates are not outside the boundary of the
+    cytoplasm.
+
+    Parameters
+    ----------
+    cyto_coord : pandas.Series
+        Coordinates of the cytoplasm membrane.
+    rna_coord : pandas.Series
+        Coordinates of the rna spots.
+
+    Returns
+    -------
+    _ : bool
+        Tell if the rna spots are valid or not.
+
+    """
+    # get coordinates
+    cyto = np.array(cyto_coord)
+    if not isinstance(rna_coord[0], list):
+        # it means we have only one spot
+        return False
+    rna = np.array(rna_coord)
+
+    # check if the coordinates are positive
+    if rna.min() < 0:
+        return False
+
+    max_x = int(max(cyto[:, 0].max() + 5, rna[:, 0].max() + 5))
+    max_y = int(max(cyto[:, 1].max() + 5, rna[:, 1].max() + 5))
+
+    # build the dense representation for the cytoplasm
+    values = [1] * cyto.shape[0]
+    cyto = coo_matrix((values, (cyto[:, 0], cyto[:, 1])),
+                      shape=(max_x, max_y)).todense()
+
+    # build the dense representation for the rna
+    values = [1] * rna.shape[0]
+    rna = coo_matrix((values, (rna[:, 0], rna[:, 1])),
+                     shape=(max_x, max_y)).todense()
+    rna = (rna > 0)
+
+    # check if the coordinates are valid
+    mask_cyto = ndi.binary_fill_holes(cyto)
+    frame = np.zeros((max_x, max_y))
+    diff = frame - mask_cyto + rna
+    diff = (diff > 0).sum()
+
+    if diff > 0:
+        return False
+    else:
+        return True

From 695c1d7fc931f3771bbc268bbc76cca7ad37daa9 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Mar 2019 19:55:39 +0100
Subject: [PATCH 057/264] build images and generator

---
 bigfish/stack/preparation.py | 536 +++++++++++++++++++++++++++++++++++
 1 file changed, 536 insertions(+)

diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index e69de29b..67081056 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -0,0 +1,536 @@
+# -*- coding: utf-8 -*-
+
+"""
+Function to prepare the data before feeding a model.
+"""
+
+import numpy as np
+
+from .preprocess import (cast_img_uint8, cast_img_uint16, cast_img_float32,
+                         cast_img_float64)
+from .augmentation import augment
+from .utils import check_array
+
+from skimage.transform import resize
+from scipy.sparse import coo_matrix
+
+from scipy import ndimage as ndi
+
+
+# TODO define the requirements for 'data'
+
+# ### Split data ###
+
+def split_from_background(data, p_validation=0.2, p_test=0.2):
+    """Split dataset between train, validation and test, based on the
+    background volume used to simulate the cell.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with the simulated data.
+    p_validation : float
+        Proportion of the validation dataset.
+    p_test : float
+        Proportion of the test dataset.
+
+    Returns
+    -------
+    df_train : pandas.DataFrame
+        Dataframe with the train dataset.
+    df_validation : pandas.DataFrame
+        Dataframe with the validation dataset.
+    df_test : pandas.DataFrame
+        Dataframe with the test dataset.
+
+    """
+    # get unique background cell
+    background_id = list(set(data["cell_ID"]))
+    np.random.shuffle(background_id)
+
+    # split background cell between train, validation and test
+    nb_validation = int(len(background_id) * p_validation)
+    nb_test = int(len(background_id) * p_test)
+    validation_cell = background_id[:nb_validation]
+    test_cell = background_id[nb_validation:nb_validation+nb_test]
+    train_cell = background_id[nb_validation+nb_test:]
+
+    # split data between train, validation and test
+    data_train = data.query("cell_ID in {}".format(str(train_cell)))
+    data_train.reset_index(drop=True, inplace=True)
+    data_validation = data.query("cell_ID in {}".format(str(validation_cell)))
+    data_validation.reset_index(drop=True, inplace=True)
+    data_test = data.query("cell_ID in {}".format(str(test_cell)))
+    data_test.reset_index(drop=True, inplace=True)
+
+    return data_train, data_validation, data_test
+
+
+# ### Build images ###
+
+
+def build_input_image(data, id_cell, channels="normal", input_shape=None,
+                      augmentation=False):
+    """
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with the data.
+    id_cell : int
+        Index of the targeted cell.
+    channels : str
+        channels used in the input image.
+            - 'normal' for (rna, cyt, nuc)
+            - 'distance' for (rna, distance_cyt, distance_nuc)
+            - 'surface' for (rna, surface_cyt, surface_nuc)
+    input_shape : Tuple[int]
+        Shape of the input image.
+    augmentation : bool
+        Apply a random operator on the image.
+
+    Returns
+    -------
+    image : np.ndarray, np.float32
+        A 3-d tensor with shape (x, y, channels). Values are normalized between
+        0 and 1 (binaries values are unchanged and float values are rescaled
+        according to their original dtype).
+
+    """
+    # TODO improve the resizing of different channels
+    # build image from coordinates data
+    cyt, nuc, rna = build_cell_2d(data, id_cell)
+
+    # build the required input image
+    if channels == "normal":
+        image = np.stack((rna, cyt, nuc), axis=-1)
+        image = resize_image(image, new_shape=input_shape, binary=True)
+    elif channels == "distance":
+        distance_cyt, distance_nuc = get_distance_layers(cyt, nuc)
+        rna = resize_image(rna, new_shape=input_shape, binary=True)
+        distance_cyt = resize_image(distance_cyt, new_shape=input_shape)
+        distance_nuc = resize_image(distance_nuc, new_shape=input_shape)
+        image = np.stack((rna, distance_cyt, distance_nuc), axis=-1)
+    elif channels == "surface":
+        surface_cyt, surface_nuc = get_surface_layers(cyt, nuc)
+        image = np.stack((rna, surface_cyt, surface_nuc), axis=-1)
+        image = resize_image(image, new_shape=input_shape, binary=True)
+    else:
+        raise ValueError("{0} is an invalid value for parameter 'channels': "
+                         "must be 'normal', 'distance' or 'surface'."
+                         .format(channels))
+
+    if augmentation:
+        image = augment(image)
+
+    return image
+
+
+def build_cell_2d(data, id_cell):
+    """Build 2-d images from data coordinates.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with the data.
+    id_cell : int
+        Index of the targeted cell.
+
+    Returns
+    -------
+    cyt : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+    nuc : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+    rna : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+
+    """
+    # get coordinates
+    cyt_coord, nuc_coord, rna_coord = get_coordinates(data, id_cell)
+
+    # build 2d images
+    cyt, nuc, rna = from_coord_to_image(cyt_coord, nuc_coord, rna_coord)
+
+    return cyt, nuc, rna
+
+
+def get_coordinates(data, id_cell):
+    """Get the coordinates a specific cell.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with the data.
+    id_cell : int
+        Index of the targeted cell.
+
+    Returns
+    -------
+    cyt : np.ndarray, np.int64
+        Cytoplasm coordinates with shape (x, y).
+    nuc : np.ndarray, np.int64
+        Nucleus coordinates with shape (x, y).
+    rna : np.ndarray, np.int64
+        RNA spots coordinates with shape (x, y, z).
+
+    """
+    # get coordinates
+    cyt = data.loc[id_cell, "pos_cell"]
+    cyt = np.array(cyt, dtype=np.int64)
+    nuc = data.loc[id_cell, "pos_nuc"]
+    nuc = np.array(nuc, dtype=np.int64)
+    rna = data.loc[id_cell, "RNA_pos"]
+    rna = np.array(rna, dtype=np.int64)
+
+    return cyt, nuc, rna
+
+
+def from_coord_to_image(cyt_coord, nuc_coord, rna_coord=None):
+    """Build 2-d images from the coordinates data.
+
+    Parameters
+    ----------
+    cyt_coord : np.ndarray, np.int64
+        Cytoplasm coordinates in 2-d with shape (x, y).
+    nuc_coord : np.ndarray, np.int64
+        Nucleus coordinates in 2-d with shape (x, y).
+    rna_coord : np.ndarray, np.int64
+        RNA spots coordinates in 3-d with shape (x, y, z).
+
+    Returns
+    -------
+    cyt : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+    nuc : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+    rna : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+
+    """
+    # build the dense representation for the cytoplasm
+    values = [1] * cyt_coord.shape[0]
+    max_x = cyt_coord[:, 0].max() + 5
+    max_y = cyt_coord[:, 1].max() + 5
+    cyt = coo_matrix((values, (cyt_coord[:, 0], cyt_coord[:, 1])),
+                     shape=(max_x, max_y))
+    cyt = (cyt > 0)
+    cyt = cast_img_float32(cyt.todense())
+
+    # build the dense representation for the nucleus
+    values = [1] * nuc_coord.shape[0]
+    nuc = coo_matrix((values, (nuc_coord[:, 0], nuc_coord[:, 1])),
+                     shape=(max_x, max_y))
+    nuc = (nuc > 0)
+    nuc = cast_img_float32(nuc.todense())
+
+    if rna_coord is None:
+        return cyt, nuc
+
+    else:
+        # TODO manage the case where different spots meet at different heights,
+        #  but same xy localization
+        # build the dense representation for the rna if available
+        values = [1] * rna_coord.shape[0]
+        rna = coo_matrix((values, (rna_coord[:, 0], rna_coord[:, 1])),
+                         shape=(max_x, max_y))
+        rna = (rna > 0)
+        rna = cast_img_float32(rna.todense())
+
+        return cyt, nuc, rna
+
+
+def get_distance_layers(cyt, nuc):
+    """Compute distance layers as input for the model.
+
+    Parameters
+    ----------
+    cyt : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+    nuc : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+
+    Returns
+    -------
+    distance_cyt : np.ndarray, np.float32
+        A 2-d tensor with shape (x, y) showing distance to the cytoplasm
+        border.
+    distance_nuc : np.ndarray, np.float32
+        A 2-d tensor with shape (x, y) showing distance to the nucleus border.
+
+    """
+    # compute distances from cytoplasm and nucleus
+    mask_cyt = ndi.binary_fill_holes(cyt)
+    mask_nuc = ndi.binary_fill_holes(nuc)
+    distance_cyt = ndi.distance_transform_edt(ndi.binary_fill_holes(cyt))
+    distance_nuc_ = ndi.distance_transform_edt(~mask_nuc)
+    distance_nuc = mask_cyt * distance_nuc_
+
+    # cast to np.float32 and normalize it between 0 and 1
+    distance_cyt = cast_img_float32(distance_cyt / distance_cyt.max())
+    distance_nuc = cast_img_float32(distance_nuc / distance_nuc.max())
+
+    return distance_cyt, distance_nuc
+
+
+def get_surface_layers(cyt, nuc):
+    """Compute plain surface layers as input for the model.
+
+    Parameters
+    ----------
+    cyt : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+    nuc : np.ndarray, np.float32
+        A 2-d binary image with shape (x, y).
+
+    Returns
+    -------
+    surface_cyt : np.ndarray, np.float32
+        A 2-d binary tensor with shape (x, y) showing cytoplasm surface.
+        border.
+    surface_nuc : np.ndarray, np.float32
+        A 2-d binary tensor with shape (x, y) showing nucleus surface.
+
+        """
+    # compute surface from cytoplasm and nucleus
+    surface_cyt = ndi.binary_fill_holes(cyt)
+    surface_nuc = ndi.binary_fill_holes(nuc)
+
+    # cast to np.float32
+    surface_cyt = cast_img_float32(surface_cyt)
+    surface_nuc = cast_img_float32(surface_nuc)
+
+    return surface_cyt, surface_nuc
+
+
+def resize_image(image, new_shape=None, binary=False):
+    """Resize image.
+
+    If the size is decreased, the image is downsampled using a mean filter. If
+    the shape is increased, new pixels' values are interpolated using spline
+    method.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image the resize with shape (y, x) or (y, x, channel).
+    new_shape : Tuple[int]
+        Spatial shape used for input images.
+    binary : bool
+        Keep binaries values after the resizing.
+
+    Returns
+    -------
+    image_output : np.ndarray
+        Resized image with shape (new_y, new_x) or (new_y, new_x, channel).
+
+    """
+    # check image dtype
+    check_array(image, dtype=[np.uint8, np.uint16,
+                              np.float32, np.float64,
+                              np.bool])
+
+    # get default output_shape
+    if new_shape is None:
+        return image
+
+    # resize
+    image_dtype = image.dtype
+    if binary:
+        # TODO use 'order=1' then binarize the image and reduce connected
+        #  component.
+        image_output = resize(image, new_shape,
+                              anti_aliasing=False,
+                              mode="constant",
+                              cval=0)
+        image_output = (image_output > 0)
+    else:
+        image_output = resize(image, new_shape,
+                              anti_aliasing=True,
+                              mode="constant",
+                              cval=0)
+
+    # cast the image in the original dtype
+    if image_dtype == np.bool:
+        image_output = (image_output > 0)
+    elif image_dtype == np.uint8:
+        image_output = cast_img_uint8(image_output)
+    elif image_dtype == np.uint16:
+        image_output = cast_img_uint16(image_output)
+    elif image_dtype == np.float32:
+        image_output = cast_img_float32(image_output)
+    elif image_dtype == np.float64:
+        image_output = cast_img_float64(image_output)
+
+    return image_output
+
+
+def get_label(data, id_cell):
+    """Get the label of a specific cell.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with the data.
+    id_cell : int
+        Index of the targeted cell.
+
+    Returns
+    -------
+    label : int
+        Encoded label of the cell.
+
+    """
+    # get encoded label
+    label = data.loc[id_cell, "label"]
+
+    return label
+
+
+# ### Generator ###
+
+def build_batch(data, indices, method="normal", input_shape=(224, 244),
+                augmentation=True, with_label=False, nb_classes=9):
+    """Build a batch of data.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with the data.
+    indices : List[int]
+        List of indices to use for the batch.
+    method : str
+        Channels used in the input image.
+            - 'normal' for (rna, cyt, nuc)
+            - 'distance' for (rna, distance_cyt, distance_nuc)
+            - 'surface' for (rna, surface_cyt, surface_nuc)
+    input_shape : Tuple[int]
+        Shape of the input image.
+    augmentation : bool
+        Apply a random operator on the image.
+    with_label : bool
+        Return label of the image as well.
+    nb_classes : int
+        Number of different classes available.
+
+    Returns
+    -------
+    batch_data : np.ndarray, np.float32
+        Tensor with shape (batch_size, x, y, 3).
+    batch_label : np.ndarray, np.int64
+        Tensor of the encoded label, with shape (batch_size,)
+
+    """
+    # TODO try to fully vectorize this step
+    # initialize the batch
+    batch_size = len(indices)
+    batch_data = np.zeros((batch_size, input_shape[0], input_shape[1], 3),
+                          dtype=np.float32)
+
+    # build each input image of the batch
+    for i in range(batch_size):
+        id_cell = indices[i]
+        image = build_input_image(data, id_cell, method, input_shape,
+                                  augmentation)
+        batch_data[i] = image
+
+    # return images with one-hot labels
+    if with_label:
+        labels = np.array(data.loc[indices, "label"], dtype=np.int64)
+        batch_label = one_hot_label(labels, nb_classes)
+
+        return batch_data, batch_label
+
+    # return images only
+    else:
+
+        return batch_data
+
+
+def one_hot_label(labels, nb_classes):
+    """Binarize labels in a one-vs-all fashion.
+
+    Parameters
+    ----------
+    labels : np.ndarray, np.int64
+        Vector of labels with shape (nb_sample,).
+    nb_classes : int
+        Number of different classes available.
+
+    Returns
+    -------
+    label_one_hot : np.ndarray, np.float32
+        One-hot label (binary) with shape (nb_samples, nb_classes).
+
+    """
+    # binarize labels
+    label_one_hot = np.eye(nb_classes, dtype=np.float32)[labels]
+
+    return label_one_hot
+
+
+def generate_images(data, method, batch_size, input_shape, augmentation,
+                    with_label, nb_classes):
+    """Generate batches of images.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with the data.
+    method : str
+        Channels used in the input image.
+            - 'normal' for (rna, cyt, nuc)
+            - 'distance' for (rna, distance_cyt, distance_nuc)
+            - 'surface' for (rna, surface_cyt, surface_nuc)
+    batch_size : int
+        Size of the batch.
+    input_shape : Tuple[int]
+        Shape of the input image.
+    augmentation : bool
+        Apply a random operator on the image.
+    with_label : bool
+        Return label of the image as well.
+    nb_classes : int
+        Number of different classes available.
+
+    Returns
+    -------
+    batch_data: np.ndarray, np.float32
+        Tensor with shape (batch_size, x, y, 3).
+    batch_label : np.ndarray, np.int64
+        Tensor of the encoded label, with shape (batch_size,)
+
+    """
+    # TODO make it loop indefinitely
+    # shuffle input data and get their indices
+    input_indices_ordered = list(data.index)
+    np.random.shuffle(input_indices_ordered)
+    nb_samples = len(input_indices_ordered)
+
+    # compute the number of batches to generate for the entire epoch
+    if nb_samples % batch_size == 0:
+        nb_batch = len(input_indices_ordered) // batch_size
+    else:
+        # the last batch can be smaller
+        nb_batch = (len(input_indices_ordered) // batch_size) + 1
+
+    # build batches
+    for i_batch in range(nb_batch):
+        start_index = i_batch * batch_size
+        end_index = min((i_batch + 1) * batch_size, nb_samples)
+        indices_batch = input_indices_ordered[start_index:end_index]
+
+        # return batch with label
+        if with_label:
+            batch_data, batch_label = build_batch(data, indices_batch, method,
+                                                  input_shape, augmentation,
+                                                  with_label, nb_classes)
+
+            yield batch_data, batch_label
+
+        # return batch without label
+        else:
+            batch_data = build_batch(data, indices_batch, method, input_shape,
+                                     augmentation, with_label, nb_classes)
+
+            yield batch_data

From a8859d24e20d7b48308e2b61fc9a7bbb39303137 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Mar 2019 19:56:14 +0100
Subject: [PATCH 058/264] add 'check_range_value'

---
 bigfish/stack/utils.py | 29 +++++++++++++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 60e54850..7df222cb 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -28,8 +28,8 @@ def check_features_df(df, features):
     col_names = df.columns
 
     # sort the two lists
-    col_names.sort()
-    features.sort()
+    col_names = sorted(col_names)
+    features = sorted(features)
 
     if col_names == features:
         return
@@ -49,6 +49,7 @@ def check_array(array, ndim=None, dtype=None):
         Number of dimensions expected.
     dtype : type or List[type]
         Types expected.
+
     Returns
     -------
 
@@ -122,3 +123,27 @@ def _check_dim_array(array, ndim):
     if array.ndim not in ndim:
         raise ValueError("Array can't have {0} dimension(s). Expected "
                          "dimensions are: {1}.".format(array.ndim, ndim))
+
+
+def check_range_value(array, min_, max_):
+    """
+
+    Parameters
+    ----------
+    array : np.ndarray
+        Array to check.
+    min_ : int
+        Minimum value allowed.
+    max_ : int
+        Maximum value allowed.
+
+    Returns
+    -------
+    _ : bool
+        Assert if the array is within the requested bound.
+
+    """
+    if array.min() < min_ or array.max() > max_:
+        return False
+    else:
+        return True

From af96db125f75cc59eb81dfec2abade0cf070c356 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 22 Mar 2019 19:56:30 +0100
Subject: [PATCH 059/264] update __init__

---
 bigfish/stack/__init__.py | 27 ++++++++++++++++++++++++---
 1 file changed, 24 insertions(+), 3 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 1657261a..3f287269 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -12,8 +12,14 @@
                          maximum_filter, minimum_filter, load_stack,
                          gaussian_filter, build_stacks, cast_img_float32,
                          cast_img_float64, compute_illumination_surface,
-                         correct_illumination_surface)
-from .utils import check_array, check_features_df
+                         correct_illumination_surface, clean_simulated_data)
+from .preparation import (split_from_background, build_cell_2d,
+                          get_coordinates, from_coord_to_image,
+                          get_distance_layers, get_surface_layers,
+                          build_input_image, resize_image, build_batch,
+                          generate_images, get_label, one_hot_label)
+from .augmentation import augment
+from .utils import check_array, check_features_df, check_range_value
 
 
 __all__ = ["read_tif",
@@ -38,4 +44,19 @@
            "check_array",
            "check_features_df",
            "compute_illumination_surface",
-           "correct_illumination_surface"]
+           "correct_illumination_surface",
+           "clean_simulated_data",
+           "split_from_background",
+           "build_cell_2d",
+           "get_coordinates",
+           "from_coord_to_image",
+           "get_distance_layers",
+           "get_surface_layers",
+           "build_input_image",
+           "check_range_value",
+           "resize_image",
+           "augment",
+           "build_batch",
+           "generate_images",
+           "get_label",
+           "one_hot_label"]

From 5d102ca825b7ac7d03c83839520e9d46994a4354 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 27 Mar 2019 10:00:06 +0100
Subject: [PATCH 060/264] add Generator

---
 bash_scripts/2d_pattern_classification.py |   0
 bigfish/classification/base.py            |  47 ++++
 bigfish/classification/inception.py       |   0
 bigfish/classification/squeezenet.py      | 246 +++++++++++++++++++++
 bigfish/stack/__init__.py                 |   5 +-
 bigfish/stack/preparation.py              | 255 ++++++++++++++++------
 6 files changed, 483 insertions(+), 70 deletions(-)
 create mode 100644 bash_scripts/2d_pattern_classification.py
 create mode 100644 bigfish/classification/base.py
 create mode 100644 bigfish/classification/inception.py
 create mode 100644 bigfish/classification/squeezenet.py

diff --git a/bash_scripts/2d_pattern_classification.py b/bash_scripts/2d_pattern_classification.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/classification/base.py b/bigfish/classification/base.py
new file mode 100644
index 00000000..6bd1f024
--- /dev/null
+++ b/bigfish/classification/base.py
@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+"""
+General classes and methods to use the models. to classify the localization patterns of an cell image.
+"""
+
+from abc import ABCMeta, abstractmethod
+
+
+# ### Load models ###
+
+# ### General models ###
+
+class BaseModel(metaclass=ABCMeta):
+
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def fit(self):
+        pass
+
+    @abstractmethod
+    def predict(self):
+        pass
+
+    @abstractmethod
+    def evaluate(self):
+        pass
+
+
+# ### 2D models ###
+
+class SqueezeNet(BaseModel):
+
+    def __init__(self):
+        super().__init__()
+        pass
+
+    def fit(self):
+        pass
+
+    def predict(self):
+        pass
+
+    def evaluate(self):
+        pass
diff --git a/bigfish/classification/inception.py b/bigfish/classification/inception.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
new file mode 100644
index 00000000..04353530
--- /dev/null
+++ b/bigfish/classification/squeezenet.py
@@ -0,0 +1,246 @@
+# -*- coding: utf-8 -*-
+
+"""
+Models based on SqueezeNet.
+
+Paper: "SqueezeNet: AlexNet-level accuracy with 50x fewer parameters
+        and <0.5MB model size"
+Authors: Iandola, Forrest N
+         Han, Song
+         Moskewicz, Matthew W
+         Ashraf, Khalid
+         Dally, William J
+         Keutzer, Kurt
+Year: 2016
+Version: 1.1 (see github https://github.com/DeepScale/SqueezeNet)
+"""
+
+from .base import BaseModel
+
+import tensorflow as tf
+
+from tensorflow.python.keras.layers import Conv2D, Concatenate
+
+
+# ### 2D models ###
+
+class SqueezeNet(BaseModel):
+
+    def __init__(self):
+        super().__init__()
+        pass
+
+    def fit(self):
+        pass
+
+    def predict(self):
+        pass
+
+    def evaluate(self):
+        pass
+
+
+# ### Functions ###
+
+def squeezenet_network(input_tensor):
+
+    # first convolution block
+
+    tensor = Conv2D(
+        filters=96,
+        kernel_size=(7, 7),
+        strides=(2, 2),
+        padding='valid',
+        activation='relu',
+        name='conv_0')(
+        input_)
+
+    # fire modules
+
+    fire_module(input_tensor, nb_filters_squeeze, nb_filters_expand_1x1,
+                nb_filters_expand_3x3, name)
+
+    # last convolution block
+
+
+
+    return
+
+
+__init__(
+    filters,
+    kernel_size,
+    strides=(1, 1),
+    padding='valid',
+    data_format=None,
+    dilation_rate=(1, 1),
+    activation=None,
+    use_bias=True,
+    kernel_initializer='glorot_uniform',
+    bias_initializer='zeros',
+    kernel_regularizer=None,
+    bias_regularizer=None,
+    activity_regularizer=None,
+    kernel_constraint=None,
+    bias_constraint=None,
+    **kwargs
+)
+
+
+def fire_module(input_tensor, nb_filters_squeeze, nb_filters_expand_1x1,
+                nb_filters_expand_3x3, name):
+    """Fire module.
+
+    A first convolution 2-d 1x1 reduces the depth of the input tensor (squeeze
+    layer). It then allows us to 1) replace 3x3 filters by 1x1 filters and 2)
+    decrease the number of input channels to 3x3 filters (expand layer). To
+    define a convolution step with different kernel size (1x1 and 3x3), we use
+    two different convolution layers, then we concatenate their results along
+    the channel dimension (output layer).
+
+    Parameters
+    ----------
+    input_tensor :
+        Input tensor with shape (batch_size, height, width, channels).
+    nb_filters_squeeze : int
+        Number of filters of the squeeze layer (1x1 Conv2D).
+    nb_filters_expand_1x1 : int
+        Number of filters of the expand layer (1x1 Conv2D).
+    nb_filters_expand_3x3 : int
+        Number of filters of the expand layer (3x3 Conv2D).
+    name : str
+        Name of these layers.
+
+    Returns
+    -------
+    output_layer :
+        Output tensor with shape (batch_size, height, width,
+        nb_filters_expand_1x1 + nb_filters_expand_3x3)).
+
+    """
+    # squeeze layer to reduce depth
+    squeeze_layer = Conv2D(
+        filters=nb_filters_squeeze,
+        kernel_size=(1, 1),
+        activation="relu",
+        name="{0}_squeeze_layer".format(name))(
+        input_tensor)
+
+    # expand layer
+    expand_layer_1x1 = Conv2D(
+        filters=nb_filters_expand_1x1,
+        kernel_size=(1, 1),
+        activation="relu",
+        name="{0}_expand_layer_1x1".format(name))(
+        squeeze_layer)
+    expand_layer_3x3 = Conv2D(
+        filters=nb_filters_expand_3x3,
+        kernel_size=(3, 3),
+        activation="relu",
+        padding="same",
+        name="{0}_expand_layer_3x3".format(name))(
+        squeeze_layer)
+
+    # output layer
+    output_layer = Concatenate(
+        axis=-1,
+        name="{0}_output_layer".format(name))(
+        [expand_layer_1x1, expand_layer_3x3])
+
+    return output_layer
+
+
+
+
+def SqueezeNetOutput(input_, num_classes=4, bypass=None):
+    valid = [None, 'simple', 'complex']
+    if bypass not in valid:
+        raise UserWarning('"bypass" argument must be one of %s.' % ', '.join(map(str, valid)))
+
+    conv_0 = Conv2D(64, (3, 3), strides=(2, 2), padding='valid', name='conv_0', activation='relu')(input_)
+    mxp_0 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool_0')(conv_0)
+
+    # Block 1
+    fm_2 = fire_module(id=2, squeeze=16, expand=64)(mxp_0)
+    fm_3 = fire_module(id=3, squeeze=16, expand=64)(fm_2)
+    input_fm_4_ = fm_3
+    if bypass == 'simple':
+        input_fm_4_ = Add()([fm_2, fm_3])
+    fm_4 = fire_module(id=4, squeeze=32, expand=128)(input_fm_4_)
+    mxp_1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool_1')(fm_4)
+
+    # Block 2
+    fm_5 = fire_module(id=5, squeeze=32, expand=128)(mxp_1)
+    input_fm_6_ = fm_5
+    if bypass == 'simple':
+        input_fm_6_ = Add()([mxp_1, fm_5])
+    fm_6 = fire_module(id=6, squeeze=48, expand=192)(input_fm_6_)
+    fm_7 = fire_module(id=7, squeeze=48, expand=192)(fm_6)
+    input_fm_8_ = fm_7
+    if bypass == 'simple':
+        input_fm_8_ = Add()([fm_6, fm_7])
+    fm_8 = fire_module(id=8, squeeze=64, expand=256)(input_fm_8_)
+    mxp_2 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool_2')(fm_8)
+
+    # Block 3
+    fm_9 = fire_module(id=9, squeeze=64, expand=256)(mxp_2)
+    input_conv_10_ = fm_9
+    if bypass == 'simple':
+        input_conv_10_ = Add()([mxp_2, fm_9])
+    # embedding = GlobalAveragePooling2D(name='embedding_layer')(input_conv_10_)
+    dropped = Dropout(0.5, name='Dropout')(input_conv_10_)
+    conv_10 = Conv2D(num_classes, (1, 1), padding='valid', name='conv10', activation='relu')(dropped)
+    normalized = BatchNormalization(name='batch_normalization')(conv_10)
+
+    # Predictions
+    avgp_0 = GlobalAveragePooling2D(name='globalaveragepooling')(normalized)
+    probas = Activation('softmax', name='probabilities')(avgp_0)
+
+    return probas
+
+
+input_ = Input(shape=next(train_generator)[0].shape[1:])
+        if self.model.lower() == 'squeezenet':
+            output_ = SqueezeNetOutput(input_, num_classes, bypass='simple')
+
+
+model = Model(input_, output_, name=self.model)
+# model = multi_gpu_model(model, gpus=len(
+#                 gpus), cpu_merge=False, cpu_relocation=False)
+
+adam = Adam(lr=1e-4)
+logdir = LOCAL + self.logdir
+
+if not os.path.exists(logdir):
+    os.makedirs(logdir)
+else:
+    try:
+        print('Picking up checkpoint')
+        model.load_weights(logdir + '/model-ckpt')
+    except OSError:
+        pass
+
+
+
+        model.compile(loss='categorical_crossentropy' if self.model != 'ae' else 'binary_crossentropy',
+                      optimizer=adam,
+                      metrics=['acc'],
+                      options=run_options,
+                      run_metadata=run_metadata
+                      )
+
+        # Fit on generator
+        # with K.tf.device('/gpu:0'):
+        model.fit_generator(
+            generator=train_generator,
+            steps_per_epoch=train_dataset.shape[0] // BATCH_SIZE,
+            callbacks=[tb, checkpointer, reduce_lr, earl],
+            validation_data=test_generator,
+            validation_steps=test_dataset.shape[0] // BATCH_SIZE,
+            epochs=50,
+            verbose=1,
+            max_queue_size=5,
+            workers=1,
+            use_multiprocessing=False,
+            class_weight=class_weights
+        )
\ No newline at end of file
diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 3f287269..5d2feff4 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,7 +17,7 @@
                           get_coordinates, from_coord_to_image,
                           get_distance_layers, get_surface_layers,
                           build_input_image, resize_image, build_batch,
-                          generate_images, get_label, one_hot_label)
+                          generate_images, get_label, one_hot_label, Generator)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
 
@@ -59,4 +59,5 @@
            "build_batch",
            "generate_images",
            "get_label",
-           "one_hot_label"]
+           "one_hot_label",
+           "Generator"]
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 67081056..7d3c63c4 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 """
-Function to prepare the data before feeding a model.
+Functions to prepare the data before feeding a model.
 """
 
 import numpy as np
@@ -389,6 +389,192 @@ def get_label(data, id_cell):
 
 # ### Generator ###
 
+class Generator:
+
+    # TODO add documentation
+    # TODO check threading.Lock()
+    def __init__(self, data, method, batch_size, input_shape, augmentation,
+                 with_label, nb_classes, nb_epoch_max=10):
+        # get attributes
+        self.data = data
+        self.method = method
+        self.batch_size = batch_size
+        self.input_shape = input_shape
+        self.augmentation = augmentation
+        self.with_label = with_label
+        self.nb_classes = nb_classes
+        self.nb_epoch_max = nb_epoch_max
+
+        # initialize generator
+        self.nb_samples = self.data.shape[0]
+        self.indices = self._get_shuffled_indices()
+        self.nb_batch_per_epoch = self._get_batch_per_epoch()
+        self.i_batch = 0
+        self.i_epoch = 0
+
+    def __len__(self):
+        if self.nb_epoch_max is None:
+            raise ValueError("This generator loops over the data "
+                             "indefinitely. The 'len' function can't be "
+                             "applied.")
+        else:
+            return self.nb_samples * self.nb_epoch_max
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        # we reach the end of an epoch
+        if self.i_batch == self.nb_batch_per_epoch:
+
+            # the generator loop over the data indefinitely
+            if self.nb_epoch_max is None:
+                if self.i_epoch == 500:
+                    raise StopIteration
+                self.i_epoch += 1
+                self.i_batch = 0
+                self.indices = self._get_shuffled_indices()
+                return self.__next__()
+
+            # we start a new epoch
+            elif (self.nb_epoch_max is not None
+                  and self.i_epoch < self.nb_epoch_max):
+                self.i_epoch += 1
+                self.i_batch = 0
+                self.indices = self._get_shuffled_indices()
+                return self.__next__()
+
+            # we reach the maximum number of epochs
+            elif (self.nb_epoch_max is not None
+                  and self.i_epoch == self.nb_epoch_max):
+                raise StopIteration
+
+        # we build a new batch
+        else:
+            if self.with_label:
+                batch_data, batch_label = self._build_batch(self.i_batch)
+                self.i_batch += 1
+                return batch_data, batch_label
+            else:
+                batch_data = self._build_batch(self.i_batch)
+                self.i_batch += 1
+                return batch_data
+
+    def _get_shuffled_indices(self):
+        # shuffle input data and get their indices
+        input_indices_ordered = list(self.data.index)
+        np.random.shuffle(input_indices_ordered)
+        return input_indices_ordered
+
+    def _get_batch_per_epoch(self):
+        # compute the number of batches to generate for the entire epoch
+        if self.nb_samples % self.batch_size == 0:
+            nb_batch = len(self.indices) // self.batch_size
+        else:
+            # the last batch can be smaller
+            nb_batch = (len(self.indices) // self.batch_size) + 1
+        return nb_batch
+
+    def _build_batch(self, i_batch):
+        # build a batch
+        start_index = i_batch * self.batch_size
+        end_index = min((i_batch + 1) * self.batch_size, self.nb_samples)
+        indices_batch = self.indices[start_index:end_index]
+
+        # return batch with label
+        if self.with_label:
+            batch_data, batch_label = build_batch(
+                data=self.data,
+                indices=indices_batch,
+                method=self.method,
+                input_shape=self.input_shape,
+                augmentation=self.augmentation,
+                with_label=self.with_label,
+                nb_classes=self.nb_classes)
+
+            return batch_data, batch_label
+
+        # return batch without label
+        else:
+            batch_data = build_batch(
+                data=self.data,
+                indices=indices_batch,
+                method=self.method,
+                input_shape=self.input_shape,
+                augmentation=self.augmentation,
+                with_label=self.with_label,
+                nb_classes=self.nb_classes)
+
+            return batch_data
+
+
+def generate_images(data, method, batch_size, input_shape, augmentation,
+                    with_label, nb_classes):
+    """Generate batches of images.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Dataframe with the data.
+    method : str
+        Channels used in the input image.
+            - 'normal' for (rna, cyt, nuc)
+            - 'distance' for (rna, distance_cyt, distance_nuc)
+            - 'surface' for (rna, surface_cyt, surface_nuc)
+    batch_size : int
+        Size of the batch.
+    input_shape : Tuple[int]
+        Shape of the input image.
+    augmentation : bool
+        Apply a random operator on the image.
+    with_label : bool
+        Return label of the image as well.
+    nb_classes : int
+        Number of different classes available.
+
+    Returns
+    -------
+    batch_data: np.ndarray, np.float32
+        Tensor with shape (batch_size, x, y, 3).
+    batch_label : np.ndarray, np.int64
+        Tensor of the encoded label, with shape (batch_size,)
+
+    """
+    # TODO make it loop indefinitely
+    # shuffle input data and get their indices
+    input_indices_ordered = list(data.index)
+    np.random.shuffle(input_indices_ordered)
+    nb_samples = len(input_indices_ordered)
+
+    # compute the number of batches to generate for the entire epoch
+    if nb_samples % batch_size == 0:
+        nb_batch = len(input_indices_ordered) // batch_size
+    else:
+        # the last batch can be smaller
+        nb_batch = (len(input_indices_ordered) // batch_size) + 1
+
+    # build batches
+    for i_batch in range(nb_batch):
+        start_index = i_batch * batch_size
+        end_index = min((i_batch + 1) * batch_size, nb_samples)
+        indices_batch = input_indices_ordered[start_index:end_index]
+
+        # return batch with label
+        if with_label:
+            batch_data, batch_label = build_batch(data, indices_batch, method,
+                                                  input_shape, augmentation,
+                                                  with_label, nb_classes)
+
+            yield batch_data, batch_label
+
+        # return batch without label
+        else:
+            batch_data = build_batch(data, indices_batch, method, input_shape,
+                                     augmentation, with_label, nb_classes)
+
+            yield batch_data
+
+
 def build_batch(data, indices, method="normal", input_shape=(224, 244),
                 augmentation=True, with_label=False, nb_classes=9):
     """Build a batch of data.
@@ -467,70 +653,3 @@ def one_hot_label(labels, nb_classes):
     label_one_hot = np.eye(nb_classes, dtype=np.float32)[labels]
 
     return label_one_hot
-
-
-def generate_images(data, method, batch_size, input_shape, augmentation,
-                    with_label, nb_classes):
-    """Generate batches of images.
-
-    Parameters
-    ----------
-    data : pandas.DataFrame
-        Dataframe with the data.
-    method : str
-        Channels used in the input image.
-            - 'normal' for (rna, cyt, nuc)
-            - 'distance' for (rna, distance_cyt, distance_nuc)
-            - 'surface' for (rna, surface_cyt, surface_nuc)
-    batch_size : int
-        Size of the batch.
-    input_shape : Tuple[int]
-        Shape of the input image.
-    augmentation : bool
-        Apply a random operator on the image.
-    with_label : bool
-        Return label of the image as well.
-    nb_classes : int
-        Number of different classes available.
-
-    Returns
-    -------
-    batch_data: np.ndarray, np.float32
-        Tensor with shape (batch_size, x, y, 3).
-    batch_label : np.ndarray, np.int64
-        Tensor of the encoded label, with shape (batch_size,)
-
-    """
-    # TODO make it loop indefinitely
-    # shuffle input data and get their indices
-    input_indices_ordered = list(data.index)
-    np.random.shuffle(input_indices_ordered)
-    nb_samples = len(input_indices_ordered)
-
-    # compute the number of batches to generate for the entire epoch
-    if nb_samples % batch_size == 0:
-        nb_batch = len(input_indices_ordered) // batch_size
-    else:
-        # the last batch can be smaller
-        nb_batch = (len(input_indices_ordered) // batch_size) + 1
-
-    # build batches
-    for i_batch in range(nb_batch):
-        start_index = i_batch * batch_size
-        end_index = min((i_batch + 1) * batch_size, nb_samples)
-        indices_batch = input_indices_ordered[start_index:end_index]
-
-        # return batch with label
-        if with_label:
-            batch_data, batch_label = build_batch(data, indices_batch, method,
-                                                  input_shape, augmentation,
-                                                  with_label, nb_classes)
-
-            yield batch_data, batch_label
-
-        # return batch without label
-        else:
-            batch_data = build_batch(data, indices_batch, method, input_shape,
-                                     augmentation, with_label, nb_classes)
-
-            yield batch_data

From 8ceceb68259324554d6c8d73ae9147891475f806 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 27 Mar 2019 10:01:08 +0100
Subject: [PATCH 061/264] fix 'kwargs'

---
 bigfish/segmentation/segmentation.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
index 8c24bfd0..1d4ebca5 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/segmentation.py
@@ -16,7 +16,7 @@
 
 
 def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
-                        return_label=False, **kargs):
+                        return_label=False, **kwargs):
     """Segment nuclei from a 2-d projection.
 
     Parameters
@@ -55,7 +55,7 @@ def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
     # apply segmentation
     image_segmented = stack.cast_img_uint8(image_2d)
     if segmentation_method == "threshold":
-        image_segmented = filtered_threshold(image_segmented, **kargs)
+        image_segmented = filtered_threshold(image_segmented, **kwargs)
     else:
         pass
 

From 7df763d0455f87a8f04d46720f2bc7c935e8c192 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 27 Mar 2019 10:01:23 +0100
Subject: [PATCH 062/264] fix 'kwargs'

---
 bigfish/spot_detection/detection.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/spot_detection/detection.py b/bigfish/spot_detection/detection.py
index d859c3c2..f2c9b6e5 100644
--- a/bigfish/spot_detection/detection.py
+++ b/bigfish/spot_detection/detection.py
@@ -14,7 +14,7 @@
 
 # ### Spot detection ###
 
-def detection(tensor, r, c, detection_method, **kargs):
+def detection(tensor, r, c, detection_method, **kwargs):
     """Apply spot detection.
 
     Parameters
@@ -46,7 +46,7 @@ def detection(tensor, r, c, detection_method, **kargs):
     # apply spot detection
     peak_coordinates, radius = None, None
     if detection_method == "log_lm":
-        peak_coordinates, radius = detection_log_lm(image, **kargs)
+        peak_coordinates, radius = detection_log_lm(image, **kwargs)
 
     return peak_coordinates, radius
 

From bef512c5cd9810baa0011e814f77e18f8145547d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 27 Mar 2019 10:02:09 +0100
Subject: [PATCH 063/264] SqueezeNet model

---
 bigfish/classification/__init__.py   |  13 +
 bigfish/classification/base.py       |  66 ++-
 bigfish/classification/squeezenet.py | 608 ++++++++++++++++++++-------
 3 files changed, 528 insertions(+), 159 deletions(-)

diff --git a/bigfish/classification/__init__.py b/bigfish/classification/__init__.py
index e69de29b..b7276b76 100644
--- a/bigfish/classification/__init__.py
+++ b/bigfish/classification/__init__.py
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+"""
+The bigfish.classification module includes models to classify the localization
+patterns of the RNA.
+"""
+
+from .squeezenet import SqueezeNet0
+
+# ### Load models ###
+
+
+__all__ = ["SqueezeNet0"]
diff --git a/bigfish/classification/base.py b/bigfish/classification/base.py
index 6bd1f024..b0611cde 100644
--- a/bigfish/classification/base.py
+++ b/bigfish/classification/base.py
@@ -1,23 +1,29 @@
 # -*- coding: utf-8 -*-
 
 """
-General classes and methods to use the models. to classify the localization patterns of an cell image.
+General classes and methods to use the models.
 """
 
 from abc import ABCMeta, abstractmethod
 
+from tensorflow.python.keras.optimizers import (Adam, Adadelta, Adagrad,
+                                                Adamax, SGD)
 
-# ### Load models ###
 
 # ### General models ###
 
-class BaseModel(metaclass=ABCMeta):
+class BaseModel(object, metaclass=ABCMeta):
 
     def __init__(self):
         pass
 
     @abstractmethod
-    def fit(self):
+    def fit(self, train_data, train_label, validation_data, validation_label,
+            batch_size, nb_epochs):
+        pass
+
+    @abstractmethod
+    def fit_generator(self, train_generator, validation_generator, nb_epochs):
         pass
 
     @abstractmethod
@@ -25,23 +31,51 @@ def predict(self):
         pass
 
     @abstractmethod
-    def evaluate(self):
+    def evaluate(self, data, label):
         pass
 
 
-# ### 2D models ###
+# ### optimizer ###
 
-class SqueezeNet(BaseModel):
+def get_optimizer(optimizer_name="adam", **kwargs):
+    """Instantiate the optimizer.
 
-    def __init__(self):
-        super().__init__()
-        pass
+    Parameters
+    ----------
+    optimizer_name : str
+        Name of the optimizer to use.
 
-    def fit(self):
-        pass
+    Returns
+    -------
+    optimizer : tf.keras.optimizers
+        Optimizer instance used in the model.
 
-    def predict(self):
-        pass
+    """
+    # TODO use tensorflow optimizer
+    if optimizer_name == "adam":
+        optimizer = Adam(**kwargs)
+    elif optimizer_name == "adadelta":
+        optimizer = Adadelta(**kwargs)
+    elif optimizer_name == "adagrad":
+        optimizer = Adagrad(**kwargs)
+    elif optimizer_name == "adamax":
+        optimizer = Adamax(**kwargs)
+    elif optimizer_name == "sgd":
+        optimizer = SGD(**kwargs)
+    else:
+        raise ValueError("Instead of {0}, optimizer must be chosen among "
+                         "['adam', 'adadelta', 'adagrad', adamax', sgd']."
+                         .format(optimizer_name))
 
-    def evaluate(self):
-        pass
+    return optimizer
+
+
+
+
+#print(globals())
+#print()
+#print(globals()["BaseModel"])
+#print()
+#print(locals())
+#print()
+#print(BaseModel.__subclasses__())
diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 04353530..12c21cbb 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -15,80 +15,455 @@
 Version: 1.1 (see github https://github.com/DeepScale/SqueezeNet)
 """
 
-from .base import BaseModel
+import os
 
 import tensorflow as tf
 
-from tensorflow.python.keras.layers import Conv2D, Concatenate
+from .base import BaseModel, get_optimizer
 
+from tensorflow.python.keras.backend import function
+from tensorflow.python.keras.models import Model
+from tensorflow.python.keras.callbacks import ModelCheckpoint
+from tensorflow.python.keras.layers import (Conv2D, Concatenate, MaxPooling2D,
+                                            Dropout, GlobalAveragePooling2D,
+                                            Add, Input, Activation,
+                                            ZeroPadding2D)
 
+
+# TODO add logging routines
+# TODO add cache routines
+# TODO manage multiprocessing
 # ### 2D models ###
 
-class SqueezeNet(BaseModel):
+class SqueezeNet0(BaseModel):
+    # TODO add documentation
 
-    def __init__(self):
+    def __init__(self, nb_classes, bypass=False, optimizer="adam",
+                 logdir=None):
+        # get model's attributes
         super().__init__()
-        pass
+        self.nb_classes = nb_classes
+        self.bypass = bypass
+        self.logdir = logdir
+
+        # initialize model
+        if not os.path.exists(self.logdir):
+            os.mkdir(self.logdir)
+        self.model = None
+        self.trained = False
+
+        # build model architecture
+        input_ = Input(shape=(224, 224, 3),
+                       name="input",
+                       dtype="float32")
+        logit_ = squeezenet_network_v0(input_tensor=input_,
+                                       nb_classes=self.nb_classes,
+                                       bypass=self.bypass)
+        output_ = squeezenet_classifier(logit=logit_)
+
+        self.model = Model(inputs=input_,
+                           outputs=output_,
+                           name="SqueezeNet_v0")
+
+        # get optimizer
+        self.optimizer = get_optimizer(optimizer_name=optimizer)
+
+    def fit(self, train_data, train_label, validation_data, validation_label,
+            batch_size, nb_epochs):
+        # TODO exploit 'sample_weight'
+        # TODO implement resumed training with 'initial_epoch'
+        # TODO add documentation
+        # TODO add callbacks
+        # compile model
+        self.compile_model()
+
+        # fit model
+        self.model.fit(
+            x=train_data,
+            y=train_label,
+            batch_size=batch_size,
+            epochs=nb_epochs,
+            verbose=2,
+            callbacks=None,
+            validation_data=(validation_data, validation_label),
+            shuffle=True,
+            sample_weight=None,
+            initial_epoch=0)
+
+        # update model attribute
+        self.trained = True
+
+        return
+
+    def fit_generator(self, train_generator, validation_generator, nb_epochs):
+        # TODO implement multiprocessing
+        # TODO exploit an equivalent of 'sample_weight'
+        # TODO implement resumed training with 'initial_epoch'
+        # TODO add documentation
+        # TODO check distribution strategy during compilation
+        # TODO check callbacks parameters
+        # check generators
+        if train_generator.nb_epoch_max is not None:
+            Warning("Train generator must loop indefinitely over the data. "
+                    "The parameter 'nb_epoch_max' is set to None.")
+            train_generator.nb_epoch_max = None
+        if validation_generator.nb_epoch_max != 1:
+            Warning("Validation generator should check all the validation "
+                    "data once. The parameter 'nb_epoch_max' is set to 1.")
+            validation_generator.nb_epoch_max = 1
+
+        # compile model
+        self.compile_model()
+
+        # define callbacks
+        if self.logdir is not None:
+            # create checkpoint callback
+            checkpoint_path = os.path.join(self.logdir, "cp-{epoch}.ckpt")
+            # checkpoint_path = os.path.join(self.logdir, "cp.ckpt")
+            cp_callback = ModelCheckpoint(
+                filepath=checkpoint_path,
+                verbose=1)
+            callbacks = [cp_callback]
+        else:
+            callbacks = None
+
+        # fit model from generator
+        steps_per_epoch = train_generator.nb_batch_per_epoch
+        self.model.fit_generator(
+            generator=train_generator,
+            steps_per_epoch=steps_per_epoch,
+            epochs=nb_epochs,
+            verbose=2,
+            callbacks=callbacks,
+            validation_data=validation_generator,
+            validation_steps=validation_generator.nb_batch_per_epoch,
+            max_queue_size=10,
+            workers=1,
+            use_multiprocessing=False,
+            initial_epoch=0)
 
-    def fit(self):
-        pass
+        # update model attribute
+        self.trained = True
+
+        return
 
     def predict(self):
         pass
 
-    def evaluate(self):
-        pass
+    def evaluate(self, data, label):
+        # If the model is not trained yet, we load it
+        if not self.trained:
+            loading = self.get_weight()
+            if not loading:
+                raise ValueError("Model is not trained yet and pre-trained "
+                                 "weights are not available.")
+
+        # evaluate model
+        loss, accuracy = self.model.evaluate(data, label)
+        print("Loss: {0} | Accuracy: {1}".format(loss, 100 * accuracy))
+
+        return loss, accuracy
+
+    def evaluate_generator(self, generator):
+        # TODO check the outcome 'loss' and 'accuracy'
+        # If the model is not trained yet, we load it
+        if not self.trained:
+            # loading = self.get_weight()
+            loading = True
+            if not loading:
+                raise ValueError("Model is not trained yet and pre-trained "
+                                 "weights are not available.")
+
+        # evaluate model
+        loss, accuracy = self.model.evaluate_generator(
+            generator=generator,
+            steps=generator.nb_batch_per_epoch,
+            workers=1,
+            use_multiprocessing=False,
+            verbose=1)
 
+        return loss, accuracy
 
-# ### Functions ###
+    def print_model(self):
+        print(self.model.summary(), "\n")
 
-def squeezenet_network(input_tensor):
+    def get_weight(self, latest=True, checkpoint_name="cp.ckpt"):
+        # TODO fix the loose of the optimizer state
+        # load weights from a training checkpoint if it exists
+        if self.logdir is not None:
+
+            # the last one
+            if latest:
+                checkpoint_path = tf.train.latest_checkpoint(self.logdir)
+
+            # or a specific one
+            else:
+                checkpoint_path = os.path.join(self.logdir, checkpoint_name)
+
+            # load weights and compile model
+            self.model.load_weights(checkpoint_path)
+            self.compile_model()
+            self.trained = True
+
+            return True
+
+        else:
+
+            return False
+
+    def compile_model(self):
+        # compile model
+        self.model.compile(
+            optimizer=self.optimizer,
+            loss="categorical_crossentropy",
+            metrics=["categorical_accuracy"])
+        return
 
-    # first convolution block
 
-    tensor = Conv2D(
+# ### Architecture functions ###
+
+def squeezenet_network_v0(input_tensor, nb_classes, bypass=False):
+    """Original architecture of the network.
+
+    Parameters
+    ----------
+    input_tensor : Keras tensor, float32
+        Input tensor with shape (batch_size, 224, 224, 3).
+    nb_classes : int
+        Number of final classes.
+    bypass : bool
+        Use residual bypasses.
+
+    Returns
+    -------
+    tensor : Keras tensor, float32
+        Output tensor with shape (batch_size, nb_classes)
+
+    """
+    # first convolution block
+    padding1 = ZeroPadding2D(
+        padding=((2, 2), (2, 2)),
+        name="padding1")(
+        input_tensor)  # (batch_size, 228, 228, 3)
+    conv1 = Conv2D(
         filters=96,
         kernel_size=(7, 7),
         strides=(2, 2),
-        padding='valid',
         activation='relu',
-        name='conv_0')(
-        input_)
+        name='conv1')(
+        padding1)  # (batch_size, 111, 111, 96)
+    maxpool1 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool1")(
+        conv1)  # (batch_size, 55, 55, 96)
 
     # fire modules
-
-    fire_module(input_tensor, nb_filters_squeeze, nb_filters_expand_1x1,
-                nb_filters_expand_3x3, name)
+    fire2 = fire_module(
+        input_tensor=maxpool1,
+        nb_filters_s1x1=16,
+        nb_filters_e1x1=64,
+        nb_filters_e3x3=64,
+        name="fire2")  # (batch_size, 55, 55, 128)
+    fire3 = fire_module(
+        input_tensor=fire2,
+        nb_filters_s1x1=16,
+        nb_filters_e1x1=64,
+        nb_filters_e3x3=64,
+        name="fire3")  # (batch_size, 55, 55, 128)
+    if bypass:
+        fire3 = Add()([fire2, fire3])
+    fire4 = fire_module(
+        input_tensor=fire3,
+        nb_filters_s1x1=32,
+        nb_filters_e1x1=128,
+        nb_filters_e3x3=128,
+        name="fire4")  # (batch_size, 55, 55, 256)
+    maxpool4 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool4")(
+        fire4)  # (batch_size, 27, 27, 256)
+    fire5 = fire_module(
+        input_tensor=maxpool4,
+        nb_filters_s1x1=32,
+        nb_filters_e1x1=128,
+        nb_filters_e3x3=128,
+        name="fire5")  # (batch_size, 27, 27, 256)
+    if bypass:
+        fire5 = Add()([fire4, fire5])
+    fire6 = fire_module(
+        input_tensor=fire5,
+        nb_filters_s1x1=48,
+        nb_filters_e1x1=192,
+        nb_filters_e3x3=192,
+        name="fire6")  # (batch_size, 27, 27, 384)
+    fire7 = fire_module(
+        input_tensor=fire6,
+        nb_filters_s1x1=48,
+        nb_filters_e1x1=192,
+        nb_filters_e3x3=192,
+        name="fire7")  # (batch_size, 27, 27, 384)
+    if bypass:
+        fire7 = Add()([fire6, fire7])
+    fire8 = fire_module(
+        input_tensor=fire7,
+        nb_filters_s1x1=64,
+        nb_filters_e1x1=256,
+        nb_filters_e3x3=256,
+        name="fire8")  # (batch_size, 27, 27, 512)
+    maxpool8 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool3")(
+        fire8)  # (batch_size, 13, 13, 512)
+    fire9 = fire_module(
+        input_tensor=maxpool8,
+        nb_filters_s1x1=64,
+        nb_filters_e1x1=256,
+        nb_filters_e3x3=256,
+        name="fire9")  # (batch_size, 13, 13, 512)
+    if bypass:
+        fire9 = Add()([fire8, fire9])
 
     # last convolution block
+    dropout10 = Dropout(
+        rate=0.5,
+        name="dropout10")(
+        fire9)
+    conv10 = Conv2D(
+        filters=nb_classes,
+        kernel_size=(1, 1),
+        activation='relu',
+        name='conv10')(
+        dropout10)  # (batch_size, 13, 13, nb_classes)
+    avgpool10 = GlobalAveragePooling2D(
+        name="avgpool10")(
+        conv10)  # (batch_size, nb_classes)
+
+    return avgpool10
 
 
+def squeezenet_network_v1(input_tensor, nb_classes, bypass=False):
+    """A lighter architecture of the network.
 
-    return
+    Parameters
+    ----------
+    input_tensor : Keras tensor, float32
+        Input tensor with shape (batch_size, 224, 224, 3).
+    nb_classes : int
+        Number of final classes.
+    bypass : bool
+        Use residual bypasses.
+
+    Returns
+    -------
+    tensor : Keras tensor, float32
+        Output tensor with shape (batch_size, nb_classes)
+
+    """
+    # first convolution block
+    conv1 = Conv2D(
+        filters=64,
+        kernel_size=(3, 3),
+        strides=(2, 2),
+        activation='relu',
+        name='conv1')(
+        input_tensor)  # (batch_size, 111, 111, 64)
+    maxpool1 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool1")(
+        conv1)  # (batch_size, 55, 55, 64)
 
+    # fire modules
+    fire2 = fire_module(
+        input_tensor=maxpool1,
+        nb_filters_s1x1=16,
+        nb_filters_e1x1=64,
+        nb_filters_e3x3=64,
+        name="fire2")  # (batch_size, 55, 55, 128)
+    fire3 = fire_module(
+        input_tensor=fire2,
+        nb_filters_s1x1=16,
+        nb_filters_e1x1=64,
+        nb_filters_e3x3=64,
+        name="fire3")  # (batch_size, 55, 55, 128)
+    if bypass:
+        fire3 = Add()([fire2, fire3])
+    maxpool3 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool3")(
+        fire3)  # (batch_size, 27, 27, 128)
+    fire4 = fire_module(
+        input_tensor=maxpool3,
+        nb_filters_s1x1=32,
+        nb_filters_e1x1=128,
+        nb_filters_e3x3=128,
+        name="fire4")  # (batch_size, 27, 27, 256)
+    fire5 = fire_module(
+        input_tensor=fire4,
+        nb_filters_s1x1=32,
+        nb_filters_e1x1=128,
+        nb_filters_e3x3=128,
+        name="fire5")  # (batch_size, 27, 27, 256)
+    if bypass:
+        fire5 = Add()([fire4, fire5])
+    maxpool5 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool5")(
+        fire5)  # (batch_size, 13, 13, 256)
+    fire6 = fire_module(
+        input_tensor=maxpool5,
+        nb_filters_s1x1=48,
+        nb_filters_e1x1=192,
+        nb_filters_e3x3=192,
+        name="fire6")  # (batch_size, 13, 13, 384)
+    fire7 = fire_module(
+        input_tensor=fire6,
+        nb_filters_s1x1=48,
+        nb_filters_e1x1=192,
+        nb_filters_e3x3=192,
+        name="fire7")  # (batch_size, 13, 13, 384)
+    if bypass:
+        fire7 = Add()([fire6, fire7])
+    fire8 = fire_module(
+        input_tensor=fire7,
+        nb_filters_s1x1=64,
+        nb_filters_e1x1=256,
+        nb_filters_e3x3=256,
+        name="fire8")  # (batch_size, 13, 13, 512)
+    fire9 = fire_module(
+        input_tensor=fire8,
+        nb_filters_s1x1=64,
+        nb_filters_e1x1=256,
+        nb_filters_e3x3=256,
+        name="fire9")  # (batch_size, 13, 13, 512)
+    if bypass:
+        fire9 = Add()([fire8, fire9])
 
-__init__(
-    filters,
-    kernel_size,
-    strides=(1, 1),
-    padding='valid',
-    data_format=None,
-    dilation_rate=(1, 1),
-    activation=None,
-    use_bias=True,
-    kernel_initializer='glorot_uniform',
-    bias_initializer='zeros',
-    kernel_regularizer=None,
-    bias_regularizer=None,
-    activity_regularizer=None,
-    kernel_constraint=None,
-    bias_constraint=None,
-    **kwargs
-)
+    # last convolution block
+    dropout10 = Dropout(
+        rate=0.5,
+        name="dropout10")(
+        fire9)
+    conv10 = Conv2D(
+        filters=nb_classes,
+        kernel_size=(1, 1),
+        activation='relu',
+        name='conv10')(
+        dropout10)  # (batch_size, 13, 13, nb_classes)
+    avgpool10 = GlobalAveragePooling2D(
+        name="avgpool10")(
+        conv10)  # (batch_size, nb_classes)
 
+    return avgpool10
 
-def fire_module(input_tensor, nb_filters_squeeze, nb_filters_expand_1x1,
-                nb_filters_expand_3x3, name):
+
+def fire_module(input_tensor, nb_filters_s1x1, nb_filters_e1x1,
+                nb_filters_e3x3, name):
     """Fire module.
 
     A first convolution 2-d 1x1 reduces the depth of the input tensor (squeeze
@@ -100,147 +475,94 @@ def fire_module(input_tensor, nb_filters_squeeze, nb_filters_expand_1x1,
 
     Parameters
     ----------
-    input_tensor :
+    input_tensor : Keras tensor, float32
         Input tensor with shape (batch_size, height, width, channels).
-    nb_filters_squeeze : int
+    nb_filters_s1x1 : int
         Number of filters of the squeeze layer (1x1 Conv2D).
-    nb_filters_expand_1x1 : int
+    nb_filters_e1x1 : int
         Number of filters of the expand layer (1x1 Conv2D).
-    nb_filters_expand_3x3 : int
+    nb_filters_e3x3 : int
         Number of filters of the expand layer (3x3 Conv2D).
     name : str
         Name of these layers.
 
     Returns
     -------
-    output_layer :
-        Output tensor with shape (batch_size, height, width,
-        nb_filters_expand_1x1 + nb_filters_expand_3x3)).
+    output_layer : Keras tensor, float32
+        Output tensor with shape
+        (batch_size, height, width, nb_filters_e1x1 + nb_filters_e3x3)).
 
     """
-    # squeeze layer to reduce depth
+    # squeeze layer
     squeeze_layer = Conv2D(
-        filters=nb_filters_squeeze,
+        filters=nb_filters_s1x1,
         kernel_size=(1, 1),
         activation="relu",
-        name="{0}_squeeze_layer".format(name))(
+        name="{0}_s1x1".format(name))(
         input_tensor)
 
     # expand layer
     expand_layer_1x1 = Conv2D(
-        filters=nb_filters_expand_1x1,
+        filters=nb_filters_e1x1,
         kernel_size=(1, 1),
         activation="relu",
-        name="{0}_expand_layer_1x1".format(name))(
+        name="{0}_e1x1".format(name))(
         squeeze_layer)
     expand_layer_3x3 = Conv2D(
-        filters=nb_filters_expand_3x3,
+        filters=nb_filters_e3x3,
         kernel_size=(3, 3),
         activation="relu",
         padding="same",
-        name="{0}_expand_layer_3x3".format(name))(
+        name="{0}_e3x3".format(name))(
         squeeze_layer)
 
     # output layer
     output_layer = Concatenate(
         axis=-1,
-        name="{0}_output_layer".format(name))(
+        name="{0}_output".format(name))(
         [expand_layer_1x1, expand_layer_3x3])
 
     return output_layer
 
 
+def squeezenet_classifier(logit):
+    """Normalized logit using softmax function.
 
+    Parameters
+    ----------
+    logit : Keras tensor, float32
+        Output layer of the network.
 
-def SqueezeNetOutput(input_, num_classes=4, bypass=None):
-    valid = [None, 'simple', 'complex']
-    if bypass not in valid:
-        raise UserWarning('"bypass" argument must be one of %s.' % ', '.join(map(str, valid)))
-
-    conv_0 = Conv2D(64, (3, 3), strides=(2, 2), padding='valid', name='conv_0', activation='relu')(input_)
-    mxp_0 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool_0')(conv_0)
-
-    # Block 1
-    fm_2 = fire_module(id=2, squeeze=16, expand=64)(mxp_0)
-    fm_3 = fire_module(id=3, squeeze=16, expand=64)(fm_2)
-    input_fm_4_ = fm_3
-    if bypass == 'simple':
-        input_fm_4_ = Add()([fm_2, fm_3])
-    fm_4 = fire_module(id=4, squeeze=32, expand=128)(input_fm_4_)
-    mxp_1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool_1')(fm_4)
-
-    # Block 2
-    fm_5 = fire_module(id=5, squeeze=32, expand=128)(mxp_1)
-    input_fm_6_ = fm_5
-    if bypass == 'simple':
-        input_fm_6_ = Add()([mxp_1, fm_5])
-    fm_6 = fire_module(id=6, squeeze=48, expand=192)(input_fm_6_)
-    fm_7 = fire_module(id=7, squeeze=48, expand=192)(fm_6)
-    input_fm_8_ = fm_7
-    if bypass == 'simple':
-        input_fm_8_ = Add()([fm_6, fm_7])
-    fm_8 = fire_module(id=8, squeeze=64, expand=256)(input_fm_8_)
-    mxp_2 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool_2')(fm_8)
-
-    # Block 3
-    fm_9 = fire_module(id=9, squeeze=64, expand=256)(mxp_2)
-    input_conv_10_ = fm_9
-    if bypass == 'simple':
-        input_conv_10_ = Add()([mxp_2, fm_9])
-    # embedding = GlobalAveragePooling2D(name='embedding_layer')(input_conv_10_)
-    dropped = Dropout(0.5, name='Dropout')(input_conv_10_)
-    conv_10 = Conv2D(num_classes, (1, 1), padding='valid', name='conv10', activation='relu')(dropped)
-    normalized = BatchNormalization(name='batch_normalization')(conv_10)
-
-    # Predictions
-    avgp_0 = GlobalAveragePooling2D(name='globalaveragepooling')(normalized)
-    probas = Activation('softmax', name='probabilities')(avgp_0)
-
-    return probas
-
-
-input_ = Input(shape=next(train_generator)[0].shape[1:])
-        if self.model.lower() == 'squeezenet':
-            output_ = SqueezeNetOutput(input_, num_classes, bypass='simple')
-
-
-model = Model(input_, output_, name=self.model)
-# model = multi_gpu_model(model, gpus=len(
-#                 gpus), cpu_merge=False, cpu_relocation=False)
-
-adam = Adam(lr=1e-4)
-logdir = LOCAL + self.logdir
-
-if not os.path.exists(logdir):
-    os.makedirs(logdir)
-else:
-    try:
-        print('Picking up checkpoint')
-        model.load_weights(logdir + '/model-ckpt')
-    except OSError:
-        pass
+    Returns
+    -------
+    normalized_logit : Keras tensor, float32
+        Normalized output of the network, between 0 and 1.
 
+    """
+    # softmax
+    normalized_logit = Activation(activation="softmax", name="softmax")(logit)
 
+    return normalized_logit
 
-        model.compile(loss='categorical_crossentropy' if self.model != 'ae' else 'binary_crossentropy',
-                      optimizer=adam,
-                      metrics=['acc'],
-                      options=run_options,
-                      run_metadata=run_metadata
-                      )
+# ### Utils functions ###
 
-        # Fit on generator
-        # with K.tf.device('/gpu:0'):
-        model.fit_generator(
-            generator=train_generator,
-            steps_per_epoch=train_dataset.shape[0] // BATCH_SIZE,
-            callbacks=[tb, checkpointer, reduce_lr, earl],
-            validation_data=test_generator,
-            validation_steps=test_dataset.shape[0] // BATCH_SIZE,
-            epochs=50,
-            verbose=1,
-            max_queue_size=5,
-            workers=1,
-            use_multiprocessing=False,
-            class_weight=class_weights
-        )
\ No newline at end of file
+
+
+
+#from keras import backend as K
+#import numpy as np
+
+
+#nS = 100 # number of Monte Carlo samples
+#MC_output = K.function([model.layers[0].input, K.learning_phase()], [model.layers[-1].output])
+#learning_phase = True  # use dropout at test time
+#MC_samples = [MC_output([x_test, learning_phase])[0] for _ in range(nS)]
+#MC_samples = np.array(MC_samples)
+## print(MC_samples.shape)
+
+#predictions = np.mean(MC_samples,axis=0)
+#y_preds = np.argmax(predictions, axis=1)
+#nberr_S = np.where(y_preds != y_test, 1.0, 0.0).sum()
+#print("nb errors MC dropout="+str(nberr_S))
+
+#np.save("MC_samples_dropout", MC_samples)
\ No newline at end of file

From 5ec79e91660193e03f7f10e9469531143366e17f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 27 Mar 2019 10:02:42 +0100
Subject: [PATCH 064/264] script ISBI 2019

---
 bash_scripts/2d_pattern_classification.py | 125 ++++++++++++++++++++++
 1 file changed, 125 insertions(+)

diff --git a/bash_scripts/2d_pattern_classification.py b/bash_scripts/2d_pattern_classification.py
index e69de29b..28b4cc4c 100644
--- a/bash_scripts/2d_pattern_classification.py
+++ b/bash_scripts/2d_pattern_classification.py
@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+
+"""
+Localization pattern classification of RNA molecules in 2-d.
+"""
+
+import os
+import argparse
+import pickle
+
+import bigfish.stack as stack
+import bigfish.classification as classification
+
+# TODO build tensorflow from source to avoid the next line
+# Your CPU supports instructions that this TensorFlow binary was not compiled
+# to use: AVX2 FMA
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+if __name__ == '__main__':
+    print()
+    print("Running {0} file...". format(os.path.basename(__file__)), "\n")
+
+    # parse arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument("path_input",
+                        help="Path of the input data.",
+                        type=str)
+    parser.add_argument("log_directory",
+                        help="Path of the log directory.",
+                        type=str)
+    parser.add_argument("--batch_size",
+                        help="Size of a batch.",
+                        type=int,
+                        default=16)
+    parser.add_argument("--input_shape",
+                        help="Shape of the input data.",
+                        type=tuple,
+                        default=(224, 224))
+    parser.add_argument("--nb_classes",
+                        help=" Final number of classes.",
+                        type=int,
+                        default=9)
+    parser.add_argument("--nb_epochs",
+                        help="Number of epochs to train the model.",
+                        type=int,
+                        default=10)
+    args = parser.parse_args()
+
+    print("------------------------")
+    print("Input data: {0}".format(args.path_input))
+    print("Output logs: {0}".format(args.log_directory), "\n")
+
+    print("------------------------")
+    print("Input shape: {0}".format(args.input_shape))
+    print("Batch size: {0}".format(args.batch_size))
+    print("Number of classes: {0}".format(args.nb_classes))
+    print("Number of epochs: {0}".format(args.nb_epochs), "\n")
+
+    print("--- PREPROCESSING ---", "\n")
+
+    # load data
+    # path_output = os.path.join(main_directory, "data_cleaned_small")
+    with open(args.path_input, mode='rb') as f:
+        df = pickle.load(f)
+    print("Shape input dataframe (before preparation): {0}".format(df.shape))
+
+    # prepare data
+    classes = ["inNUC", "cell2D", "nuc2D", "foci", "polarized", "cellext",
+               "random"]
+    query = "pattern_name in {0}".format(str(classes))
+    df = df.query(query)
+    print("Shape input dataframe (after preparation): {0}".format(df.shape))
+    df_train, df_validation, df_test = stack.split_from_background(
+        data=df,
+        p_validation=0.2,
+        p_test=0.2)
+    print("Split train|validation|test: {0}|{1}|{2}"
+          .format(df_train.shape[0], df_validation.shape[0], df_test.shape[0]))
+
+    # build train generator
+    train_generator = stack.Generator(
+        data=df_train,
+        method="normal",
+        batch_size=args.batch_size,
+        input_shape=args.input_shape,
+        augmentation=True,
+        with_label=True,
+        nb_classes=args.nb_classes,
+        nb_epoch_max=None)
+    print("Number of train batches per epoch: {0}"
+          .format(train_generator.nb_batch_per_epoch))
+
+    # build validation generator
+    validation_generator = stack.Generator(
+        data=df_validation,
+        method="normal",
+        batch_size=args.batch_size,
+        input_shape=args.input_shape,
+        augmentation=False,
+        with_label=True,
+        nb_classes=args.nb_classes,
+        nb_epoch_max=1)
+    print("Number of validation batches per epoch: {0}"
+          .format(validation_generator.nb_batch_per_epoch))
+    print()
+
+    print("--- TRAINING ---", "\n")
+
+    # build and fit model
+    model = classification.SqueezeNet0(
+        nb_classes=args.nb_classes,
+        bypass=False,
+        optimizer="adam",
+        logdir=args.log_directory)
+    print("Model trained: {0}".format(model.trained))
+    model.print_model()
+    model.fit_generator(train_generator, validation_generator, args.nb_epochs)
+    print()
+
+    print("--- EVALUATION ---", "\n")
+
+    # evaluate model
+    print("Model trained: {0}".format(model.trained))
+    loss, accuracy = model.evaluate_generator(validation_generator)
+    print("Loss: {0} | Accuracy: {1}".format(loss, 100 * accuracy))

From 479455b330617ba1f179eee695b5c47e75a670ce Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 28 Mar 2019 12:05:55 +0100
Subject: [PATCH 065/264] update requirements

---
 requirements.txt        |  8 ++++----
 requirements_stable.txt | 13 +++++++++++++
 2 files changed, 17 insertions(+), 4 deletions(-)
 create mode 100644 requirements_stable.txt

diff --git a/requirements.txt b/requirements.txt
index 7aa95e6d..e6533271 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,12 +2,12 @@
 
 -e .
 
-numpy >= 1.15.4
+numpy >= 1.16.0
 pip >= 18.1
 scikit-learn >= 0.20.2
 scikit-image >= 0.14.2
-scipy >= 1.1.0
+scipy >= 1.2.0
 tensorflow >= 1.12.0, < 2.0
 matplotlib >= 3.0.2
-pandas >= 0.23.4
-joblib >= 0.13.2
\ No newline at end of file
+pandas >= 0.24.0
+joblib >= 0.13.2
diff --git a/requirements_stable.txt b/requirements_stable.txt
new file mode 100644
index 00000000..460b54e5
--- /dev/null
+++ b/requirements_stable.txt
@@ -0,0 +1,13 @@
+--index-url https://pypi.python.org/simple/
+
+-e .
+
+numpy == 1.16.0
+pip == 18.1
+scikit-learn == 0.20.2
+scikit-image == 0.14.2
+scipy == 1.2.0
+tensorflow == 1.12.0
+matplotlib == 3.0.2
+pandas == 0.24.0
+joblib == 0.13.2

From 0443efddc6cf7297f440e9e7f688cc20547341e4 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 28 Mar 2019 15:05:16 +0100
Subject: [PATCH 066/264] add prediction function

---
 bigfish/classification/base.py       |  18 ++-
 bigfish/classification/squeezenet.py | 159 +++++++++++++++------------
 2 files changed, 105 insertions(+), 72 deletions(-)

diff --git a/bigfish/classification/base.py b/bigfish/classification/base.py
index b0611cde..a15fe6c2 100644
--- a/bigfish/classification/base.py
+++ b/bigfish/classification/base.py
@@ -27,13 +27,29 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs):
         pass
 
     @abstractmethod
-    def predict(self):
+    def predict(self, data, return_probability=False):
+        pass
+
+    @abstractmethod
+    def predict_generator(self, generator, return_probability=False):
+        pass
+
+    @abstractmethod
+    def predict_probability(self, data):
+        pass
+
+    @abstractmethod
+    def predict_probability_generator(self, generator):
         pass
 
     @abstractmethod
     def evaluate(self, data, label):
         pass
 
+    @abstractmethod
+    def evaluate_generator(self, generator):
+        pass
+
 
 # ### optimizer ###
 
diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 12c21cbb..f4a17477 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -18,6 +18,7 @@
 import os
 
 import tensorflow as tf
+import numpy as np
 
 from .base import BaseModel, get_optimizer
 
@@ -27,7 +28,7 @@
 from tensorflow.python.keras.layers import (Conv2D, Concatenate, MaxPooling2D,
                                             Dropout, GlobalAveragePooling2D,
                                             Add, Input, Activation,
-                                            ZeroPadding2D)
+                                            ZeroPadding2D, BatchNormalization)
 
 
 # TODO add logging routines
@@ -43,7 +44,6 @@ def __init__(self, nb_classes, bypass=False, optimizer="adam",
         # get model's attributes
         super().__init__()
         self.nb_classes = nb_classes
-        self.bypass = bypass
         self.logdir = logdir
 
         # initialize model
@@ -52,21 +52,8 @@ def __init__(self, nb_classes, bypass=False, optimizer="adam",
         self.model = None
         self.trained = False
 
-        # build model architecture
-        input_ = Input(shape=(224, 224, 3),
-                       name="input",
-                       dtype="float32")
-        logit_ = squeezenet_network_v0(input_tensor=input_,
-                                       nb_classes=self.nb_classes,
-                                       bypass=self.bypass)
-        output_ = squeezenet_classifier(logit=logit_)
-
-        self.model = Model(inputs=input_,
-                           outputs=output_,
-                           name="SqueezeNet_v0")
-
-        # get optimizer
-        self.optimizer = get_optimizer(optimizer_name=optimizer)
+        # build model
+        self._build_model(bypass, optimizer)
 
     def fit(self, train_data, train_label, validation_data, validation_label,
             batch_size, nb_epochs):
@@ -74,8 +61,6 @@ def fit(self, train_data, train_label, validation_data, validation_label,
         # TODO implement resumed training with 'initial_epoch'
         # TODO add documentation
         # TODO add callbacks
-        # compile model
-        self.compile_model()
 
         # fit model
         self.model.fit(
@@ -107,13 +92,10 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs):
             Warning("Train generator must loop indefinitely over the data. "
                     "The parameter 'nb_epoch_max' is set to None.")
             train_generator.nb_epoch_max = None
-        if validation_generator.nb_epoch_max != 1:
-            Warning("Validation generator should check all the validation "
-                    "data once. The parameter 'nb_epoch_max' is set to 1.")
-            validation_generator.nb_epoch_max = 1
-
-        # compile model
-        self.compile_model()
+        if validation_generator.nb_epoch_max is not None:
+            Warning("Validation generator must loop indefinitely over the "
+                    "data. The parameter 'nb_epoch_max' is set to None.")
+            validation_generator.nb_epoch_max = None
 
         # define callbacks
         if self.logdir is not None:
@@ -147,77 +129,113 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs):
 
         return
 
-    def predict(self):
-        pass
+    def predict(self, data, return_probability=False):
+        # compute probabilities
+        probability = self.predict_probability(data=data)
 
-    def evaluate(self, data, label):
-        # If the model is not trained yet, we load it
-        if not self.trained:
-            loading = self.get_weight()
-            if not loading:
-                raise ValueError("Model is not trained yet and pre-trained "
-                                 "weights are not available.")
+        # make prediction
+        prediction = np.argmax(probability, axis=-1)
 
+        if return_probability:
+            return prediction, probability
+        else:
+            return prediction
+
+    def predict_probability(self, data):
+        # compute probabilities
+        probability = self.model.predict(x=data)
+
+        return probability
+
+    def predict_generator(self, generator, return_probability=False):
+        # compute probabilities
+        probability = self.predict_probability_generator(generator=generator)
+
+        # make prediction
+        prediction = np.argmax(probability, axis=-1)
+
+        if return_probability:
+            return prediction, probability
+        else:
+            return prediction
+
+    def predict_probability_generator(self, generator):
+        # TODO add multiprocessing
+        # compute probabilities
+        probability = self.model.predict_generator(
+            generator=generator,
+            steps=generator.nb_batch_per_epoch,
+            workers=1,
+            max_queue_size=1,
+            use_multiprocessing=False)
+
+        return probability
+
+    def evaluate(self, data, label):
         # evaluate model
-        loss, accuracy = self.model.evaluate(data, label)
-        print("Loss: {0} | Accuracy: {1}".format(loss, 100 * accuracy))
+        loss, accuracy = self.model.evaluate(x=data, y=label)
+        print("Loss: {0:.3f} | Accuracy: {1:.3f}".format(loss, 100 * accuracy))
 
         return loss, accuracy
 
     def evaluate_generator(self, generator):
         # TODO check the outcome 'loss' and 'accuracy'
-        # If the model is not trained yet, we load it
-        if not self.trained:
-            # loading = self.get_weight()
-            loading = True
-            if not loading:
-                raise ValueError("Model is not trained yet and pre-trained "
-                                 "weights are not available.")
-
         # evaluate model
         loss, accuracy = self.model.evaluate_generator(
             generator=generator,
             steps=generator.nb_batch_per_epoch,
             workers=1,
+            max_queue_size=1,
             use_multiprocessing=False,
             verbose=1)
+        print("Loss: {0:.3f} | Accuracy: {1:.3f}".format(loss, 100 * accuracy))
 
         return loss, accuracy
 
+    def _build_model(self, bypass, optimizer):
+        # build model architecture
+        input_ = Input(shape=(224, 224, 3),
+                       name="input",
+                       dtype="float32")
+        logit_ = squeezenet_network_v0(input_tensor=input_,
+                                       nb_classes=self.nb_classes,
+                                       bypass=bypass)
+        output_ = squeezenet_classifier(logit=logit_)
+
+        self.model = Model(inputs=input_,
+                           outputs=output_,
+                           name="SqueezeNet_v0")
+
+        # get optimizer
+        self.optimizer = get_optimizer(optimizer_name=optimizer)
+
+        # compile model
+        self.model.compile(
+            optimizer=self.optimizer,
+            loss="categorical_crossentropy",
+            metrics=["categorical_accuracy"])
+
     def print_model(self):
         print(self.model.summary(), "\n")
 
     def get_weight(self, latest=True, checkpoint_name="cp.ckpt"):
         # TODO fix the loose of the optimizer state
         # load weights from a training checkpoint if it exists
-        if self.logdir is not None:
-
-            # the last one
+        if self.logdir is not None and os.path.isdir(self.logdir):
+            # the last one...
             if latest:
                 checkpoint_path = tf.train.latest_checkpoint(self.logdir)
-
-            # or a specific one
+            # ...or a specific one
             else:
                 checkpoint_path = os.path.join(self.logdir, checkpoint_name)
 
-            # load weights and compile model
+            # load weights
             self.model.load_weights(checkpoint_path)
-            self.compile_model()
             self.trained = True
 
-            return True
-
         else:
-
-            return False
-
-    def compile_model(self):
-        # compile model
-        self.model.compile(
-            optimizer=self.optimizer,
-            loss="categorical_crossentropy",
-            metrics=["categorical_accuracy"])
-        return
+            raise ValueError("Impossible to load pre-trained weights. The log "
+                             "directory is not specified or does not exist.")
 
 
 # ### Architecture functions ###
@@ -291,7 +309,7 @@ def squeezenet_network_v0(input_tensor, nb_classes, bypass=False):
         nb_filters_e3x3=128,
         name="fire5")  # (batch_size, 27, 27, 256)
     if bypass:
-        fire5 = Add()([fire4, fire5])
+        fire5 = Add()([maxpool4, fire5])
     fire6 = fire_module(
         input_tensor=fire5,
         nb_filters_s1x1=48,
@@ -324,7 +342,7 @@ def squeezenet_network_v0(input_tensor, nb_classes, bypass=False):
         nb_filters_e3x3=256,
         name="fire9")  # (batch_size, 13, 13, 512)
     if bypass:
-        fire9 = Add()([fire8, fire9])
+        fire9 = Add()([maxpool8, fire9])
 
     # last convolution block
     dropout10 = Dropout(
@@ -337,9 +355,12 @@ def squeezenet_network_v0(input_tensor, nb_classes, bypass=False):
         activation='relu',
         name='conv10')(
         dropout10)  # (batch_size, 13, 13, nb_classes)
+    norm10 = BatchNormalization(
+        name="batchnorm10")(
+        conv10)  # (batch_size, 13, 13, nb_classes)
     avgpool10 = GlobalAveragePooling2D(
         name="avgpool10")(
-        conv10)  # (batch_size, nb_classes)
+        norm10)  # (batch_size, nb_classes)
 
     return avgpool10
 
@@ -544,10 +565,6 @@ def squeezenet_classifier(logit):
 
     return normalized_logit
 
-# ### Utils functions ###
-
-
-
 
 #from keras import backend as K
 #import numpy as np

From 3c7ea4f3d207fb10ee0b660dcf6cbdda5b37ae57 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 28 Mar 2019 15:05:36 +0100
Subject: [PATCH 067/264] update script

---
 bash_scripts/2d_pattern_classification.py | 61 +++++++++++++++--------
 1 file changed, 39 insertions(+), 22 deletions(-)

diff --git a/bash_scripts/2d_pattern_classification.py b/bash_scripts/2d_pattern_classification.py
index 28b4cc4c..aa62c4fa 100644
--- a/bash_scripts/2d_pattern_classification.py
+++ b/bash_scripts/2d_pattern_classification.py
@@ -32,30 +32,31 @@
                         help="Size of a batch.",
                         type=int,
                         default=16)
-    parser.add_argument("--input_shape",
-                        help="Shape of the input data.",
-                        type=tuple,
-                        default=(224, 224))
-    parser.add_argument("--nb_classes",
-                        help=" Final number of classes.",
-                        type=int,
-                        default=9)
     parser.add_argument("--nb_epochs",
                         help="Number of epochs to train the model.",
                         type=int,
                         default=10)
     args = parser.parse_args()
 
+    # parameters
+    classes = ["inNUC", "cell2D", "nuc2D", "foci", "polarized", "cellext",
+               "random"]
+    nb_classes = len(classes)
+    input_shape = (224, 224)
+
     print("------------------------")
     print("Input data: {0}".format(args.path_input))
     print("Output logs: {0}".format(args.log_directory), "\n")
 
     print("------------------------")
-    print("Input shape: {0}".format(args.input_shape))
+    print("Number of classes: {0}".format(nb_classes))
+    print("Input shape: {0}".format(input_shape))
     print("Batch size: {0}".format(args.batch_size))
-    print("Number of classes: {0}".format(args.nb_classes))
     print("Number of epochs: {0}".format(args.nb_epochs), "\n")
 
+    print("------------------------")
+    print("Classes: {0}".format(classes), "\n")
+
     print("--- PREPROCESSING ---", "\n")
 
     # load data
@@ -65,10 +66,7 @@
     print("Shape input dataframe (before preparation): {0}".format(df.shape))
 
     # prepare data
-    classes = ["inNUC", "cell2D", "nuc2D", "foci", "polarized", "cellext",
-               "random"]
-    query = "pattern_name in {0}".format(str(classes))
-    df = df.query(query)
+    df = stack.subset_data(df, classes_name=classes)
     print("Shape input dataframe (after preparation): {0}".format(df.shape))
     df_train, df_validation, df_test = stack.split_from_background(
         data=df,
@@ -82,10 +80,10 @@
         data=df_train,
         method="normal",
         batch_size=args.batch_size,
-        input_shape=args.input_shape,
+        input_shape=input_shape,
         augmentation=True,
         with_label=True,
-        nb_classes=args.nb_classes,
+        nb_classes=nb_classes,
         nb_epoch_max=None)
     print("Number of train batches per epoch: {0}"
           .format(train_generator.nb_batch_per_epoch))
@@ -95,21 +93,35 @@
         data=df_validation,
         method="normal",
         batch_size=args.batch_size,
-        input_shape=args.input_shape,
+        input_shape=input_shape,
         augmentation=False,
         with_label=True,
-        nb_classes=args.nb_classes,
-        nb_epoch_max=1)
+        nb_classes=nb_classes,
+        nb_epoch_max=None)
     print("Number of validation batches per epoch: {0}"
           .format(validation_generator.nb_batch_per_epoch))
+
+    # build test generator
+    test_generator = stack.Generator(
+        data=df_test,
+        method="normal",
+        batch_size=args.batch_size,
+        input_shape=input_shape,
+        augmentation=False,
+        with_label=True,
+        nb_classes=nb_classes,
+        nb_epoch_max=None,
+        shuffle=False)
+    print("Number of test batches per epoch: {0}"
+          .format(test_generator.nb_batch_per_epoch))
     print()
 
     print("--- TRAINING ---", "\n")
 
     # build and fit model
     model = classification.SqueezeNet0(
-        nb_classes=args.nb_classes,
-        bypass=False,
+        nb_classes=nb_classes,
+        bypass=True,
         optimizer="adam",
         logdir=args.log_directory)
     print("Model trained: {0}".format(model.trained))
@@ -121,5 +133,10 @@
 
     # evaluate model
     print("Model trained: {0}".format(model.trained))
+    validation_generator.reset()
     loss, accuracy = model.evaluate_generator(validation_generator)
-    print("Loss: {0} | Accuracy: {1}".format(loss, 100 * accuracy))
+    print("Loss validation: {0} | Accuracy validation: {1}"
+          .format(loss, 100 * accuracy))
+    loss, accuracy = model.evaluate_generator(test_generator)
+    print("Loss test: {0} | Accuracy test: {1}"
+          .format(loss, 100 * accuracy))

From bec4b2ac24de663ec10853181e86bc5c71614eb8 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 28 Mar 2019 15:06:50 +0100
Subject: [PATCH 068/264] fix warning pandas

---
 bigfish/stack/preprocess.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index dd607be2..64c811f5 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -1479,6 +1479,7 @@ def clean_simulated_data(data, data_cell, path_output=None):
         Cell id to remove from data.
 
     """
+    # TODO remove the 'SettingWithCopyWarning'
     # filter invalid simulated cell backgrounds
     data_clean, background_to_remove, id_volume = clean_volume(data, data_cell)
 

From 8d3220b90c7333cdb5ea529bbf0ee52d9c0103a1 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 28 Mar 2019 15:07:54 +0100
Subject: [PATCH 069/264] fix bug generator & add reset & add subset labels

---
 bigfish/stack/__init__.py    |  6 +++--
 bigfish/stack/preparation.py | 51 +++++++++++++++++++++++++++++-------
 2 files changed, 45 insertions(+), 12 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 5d2feff4..5018b75f 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,7 +17,8 @@
                           get_coordinates, from_coord_to_image,
                           get_distance_layers, get_surface_layers,
                           build_input_image, resize_image, build_batch,
-                          generate_images, get_label, one_hot_label, Generator)
+                          generate_images, get_label, one_hot_label, Generator,
+                          subset_data)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
 
@@ -60,4 +61,5 @@
            "generate_images",
            "get_label",
            "one_hot_label",
-           "Generator"]
+           "Generator",
+           "subset_data"]
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 7d3c63c4..a069c6e9 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -13,13 +13,14 @@
 
 from skimage.transform import resize
 from scipy.sparse import coo_matrix
+from sklearn.preprocessing import LabelEncoder
 
 from scipy import ndimage as ndi
 
 
 # TODO define the requirements for 'data'
 
-# ### Split data ###
+# ### Split and subset data ###
 
 def split_from_background(data, p_validation=0.2, p_test=0.2):
     """Split dataset between train, validation and test, based on the
@@ -56,19 +57,34 @@ def split_from_background(data, p_validation=0.2, p_test=0.2):
     train_cell = background_id[nb_validation+nb_test:]
 
     # split data between train, validation and test
-    data_train = data.query("cell_ID in {}".format(str(train_cell)))
+    data_train = data.query("cell_ID in {0}".format(str(train_cell)))
     data_train.reset_index(drop=True, inplace=True)
-    data_validation = data.query("cell_ID in {}".format(str(validation_cell)))
+    data_validation = data.query("cell_ID in {0}".format(str(validation_cell)))
     data_validation.reset_index(drop=True, inplace=True)
-    data_test = data.query("cell_ID in {}".format(str(test_cell)))
+    data_test = data.query("cell_ID in {0}".format(str(test_cell)))
     data_test.reset_index(drop=True, inplace=True)
 
     return data_train, data_validation, data_test
 
 
-# ### Build images ###
+def subset_data(data, classes_name=None):
+    # choose classes to keep
+    if classes_name is None:
+        classes_name = list(set(data["pattern_name"]))
+
+    # keep specific classes
+    query = "pattern_name in {0}".format(str(classes_name))
+    data = data.query(query)
+
+    # encode the label
+    le = LabelEncoder()
+    data = data.assign(label=le.fit_transform(data["pattern_name"]))
+
+    return data
 
 
+# ### Build images ###
+
 def build_input_image(data, id_cell, channels="normal", input_shape=None,
                       augmentation=False):
     """
@@ -393,8 +409,9 @@ class Generator:
 
     # TODO add documentation
     # TODO check threading.Lock()
+    # TODO add classes
     def __init__(self, data, method, batch_size, input_shape, augmentation,
-                 with_label, nb_classes, nb_epoch_max=10):
+                 with_label, nb_classes, nb_epoch_max=10, shuffle=True):
         # get attributes
         self.data = data
         self.method = method
@@ -404,6 +421,7 @@ def __init__(self, data, method, batch_size, input_shape, augmentation,
         self.with_label = with_label
         self.nb_classes = nb_classes
         self.nb_epoch_max = nb_epoch_max
+        self.shuffle = shuffle
 
         # initialize generator
         self.nb_samples = self.data.shape[0]
@@ -414,12 +432,17 @@ def __init__(self, data, method, batch_size, input_shape, augmentation,
 
     def __len__(self):
         if self.nb_epoch_max is None:
-            raise ValueError("This generator loops over the data "
-                             "indefinitely. The 'len' function can't be "
-                             "applied.")
+            raise ValueError("This generator loops indefinitely over the "
+                             "data. The 'len' method can't be used.")
         else:
             return self.nb_samples * self.nb_epoch_max
 
+    def __bool__(self):
+        if self.nb_epoch_max is None or self.nb_epoch_max > 0:
+            return True
+        else:
+            return False
+
     def __iter__(self):
         return self
 
@@ -463,7 +486,8 @@ def __next__(self):
     def _get_shuffled_indices(self):
         # shuffle input data and get their indices
         input_indices_ordered = list(self.data.index)
-        np.random.shuffle(input_indices_ordered)
+        if self.shuffle:
+            np.random.shuffle(input_indices_ordered)
         return input_indices_ordered
 
     def _get_batch_per_epoch(self):
@@ -507,6 +531,13 @@ def _build_batch(self, i_batch):
 
             return batch_data
 
+    def reset(self):
+        # initialize generator
+        self.indices = self._get_shuffled_indices()
+        self.nb_batch_per_epoch = self._get_batch_per_epoch()
+        self.i_batch = 0
+        self.i_epoch = 0
+
 
 def generate_images(data, method, batch_size, input_shape, augmentation,
                     with_label, nb_classes):

From dc61c490a3d91c8e46b960f3466720664dc7a397 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 28 Mar 2019 20:49:38 +0100
Subject: [PATCH 070/264] add gpu environment variable

---
 bash_scripts/2d_pattern_classification.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bash_scripts/2d_pattern_classification.py b/bash_scripts/2d_pattern_classification.py
index aa62c4fa..c46cc5f5 100644
--- a/bash_scripts/2d_pattern_classification.py
+++ b/bash_scripts/2d_pattern_classification.py
@@ -15,6 +15,7 @@
 # Your CPU supports instructions that this TensorFlow binary was not compiled
 # to use: AVX2 FMA
 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+os.environ["CUDA_VISIBLE_DEVICES"] = 0
 
 if __name__ == '__main__':
     print()

From df094dd937272eb561d4d4ff0c2c4e7aada8f44a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 09:47:43 +0100
Subject: [PATCH 071/264] make generator thread safe

---
 bigfish/stack/preparation.py | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index a069c6e9..7ad45550 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -4,6 +4,7 @@
 Functions to prepare the data before feeding a model.
 """
 
+import threading
 import numpy as np
 
 from .preprocess import (cast_img_uint8, cast_img_uint16, cast_img_float32,
@@ -405,6 +406,33 @@ def get_label(data, id_cell):
 
 # ### Generator ###
 
+class ThreadSafeIter:
+    """Takes an iterator/generator and makes it thread-safe by
+    serializing call to the `next` method of given iterator/generator.
+    https://gist.github.com/platdrag/e755f3947552804c42633a99ffd325d4
+    """
+    def __init__(self, it):
+        self.it = it
+        self.lock = threading.Lock()
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        with self.lock:
+            return self.it.__next__()
+
+
+def threadsafe_generator(f):
+    """A decorator that takes a generator function and makes it thread-safe.
+    """
+    def g(*a, **kw):
+        return ThreadSafeIter(f(*a, **kw))
+
+    return g
+
+
+@threadsafe_generator
 class Generator:
 
     # TODO add documentation

From 20019eff97512b4f7de38c72e6b915393ecc9917 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 09:59:10 +0100
Subject: [PATCH 072/264] make generator thread safe #2

---
 bigfish/stack/preparation.py | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 7ad45550..dcdb6773 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -440,6 +440,9 @@ class Generator:
     # TODO add classes
     def __init__(self, data, method, batch_size, input_shape, augmentation,
                  with_label, nb_classes, nb_epoch_max=10, shuffle=True):
+        # make generator threadsafe
+        self.lock = threading.Lock()
+
         # get attributes
         self.data = data
         self.method = method
@@ -475,6 +478,10 @@ def __iter__(self):
         return self
 
     def __next__(self):
+        with self.lock:
+            return self._next()
+
+    def _next(self):
         # we reach the end of an epoch
         if self.i_batch == self.nb_batch_per_epoch:
 
@@ -485,7 +492,7 @@ def __next__(self):
                 self.i_epoch += 1
                 self.i_batch = 0
                 self.indices = self._get_shuffled_indices()
-                return self.__next__()
+                return self._next()
 
             # we start a new epoch
             elif (self.nb_epoch_max is not None
@@ -493,7 +500,7 @@ def __next__(self):
                 self.i_epoch += 1
                 self.i_batch = 0
                 self.indices = self._get_shuffled_indices()
-                return self.__next__()
+                return self._next()
 
             # we reach the maximum number of epochs
             elif (self.nb_epoch_max is not None

From 0aec7fde890478f57ceeca838b7c2a301bef28ac Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 09:59:39 +0100
Subject: [PATCH 073/264] make generator thread safe #3

---
 bigfish/stack/preparation.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index dcdb6773..0392e2c8 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -432,7 +432,6 @@ def g(*a, **kw):
     return g
 
 
-@threadsafe_generator
 class Generator:
 
     # TODO add documentation

From 8aeb2a82d008e2db8a8f00766a9a1ec669b4c95a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 14:22:29 +0100
Subject: [PATCH 074/264] check gpu device

---
 bash_scripts/2d_pattern_classification.py |  4 ++--
 bash_scripts/check_gpu.py                 | 19 +++++++++++++++++++
 2 files changed, 21 insertions(+), 2 deletions(-)
 create mode 100644 bash_scripts/check_gpu.py

diff --git a/bash_scripts/2d_pattern_classification.py b/bash_scripts/2d_pattern_classification.py
index c46cc5f5..6011965b 100644
--- a/bash_scripts/2d_pattern_classification.py
+++ b/bash_scripts/2d_pattern_classification.py
@@ -14,8 +14,8 @@
 # TODO build tensorflow from source to avoid the next line
 # Your CPU supports instructions that this TensorFlow binary was not compiled
 # to use: AVX2 FMA
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-os.environ["CUDA_VISIBLE_DEVICES"] = 0
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = "2"
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
 
 if __name__ == '__main__':
     print()
diff --git a/bash_scripts/check_gpu.py b/bash_scripts/check_gpu.py
new file mode 100644
index 00000000..8eb763d8
--- /dev/null
+++ b/bash_scripts/check_gpu.py
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+"""
+Test if the code use GPU device"""
+
+import os
+import tensorflow as tf
+
+if __name__ == '__main__':
+    print()
+    print("Running {0} file...". format(os.path.basename(__file__)), "\n")
+
+    with tf.device('/gpu:0'):
+        a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')
+        b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')
+        c = tf.matmul(a, b)
+
+    with tf.Session() as sess:
+        print(sess.run(c))

From c401e2f65065a33094956ac379e679b75bdaee51 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 14:30:43 +0100
Subject: [PATCH 075/264] check gpu device #2

---
 bash_scripts/check_gpu.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/bash_scripts/check_gpu.py b/bash_scripts/check_gpu.py
index 8eb763d8..15198264 100644
--- a/bash_scripts/check_gpu.py
+++ b/bash_scripts/check_gpu.py
@@ -6,6 +6,8 @@
 import os
 import tensorflow as tf
 
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+
 if __name__ == '__main__':
     print()
     print("Running {0} file...". format(os.path.basename(__file__)), "\n")

From f38a48f79145f874726ce23a027d80e4ae1c3dbc Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 15:37:24 +0100
Subject: [PATCH 076/264] check gpu device #3

---
 bash_scripts/check_gpu.py | 79 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 75 insertions(+), 4 deletions(-)

diff --git a/bash_scripts/check_gpu.py b/bash_scripts/check_gpu.py
index 15198264..528a3edf 100644
--- a/bash_scripts/check_gpu.py
+++ b/bash_scripts/check_gpu.py
@@ -12,10 +12,81 @@
     print()
     print("Running {0} file...". format(os.path.basename(__file__)), "\n")
 
-    with tf.device('/gpu:0'):
-        a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')
-        b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')
+    print("--- DEVICES ---", "\n")
+
+    # creates a graph
+    a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name="a")
+    b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name="b")
+    c = tf.matmul(a, b)
+
+    # run a session with 'log_device_placement'
+    config = tf.ConfigProto(log_device_placement=True)
+    with tf.Session(config=config) as sess:
+        print(sess.run(c))
+    print()
+
+    print("--- GPU ACCESS ---", "\n")
+
+    # creates a graph assigning the devices
+    with tf.device("/cpu:0"):
+        a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name="a")
+        b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name="b")
+    with tf.device("/gpu:0"):
+        c = tf.matmul(a, b)
+
+    # run a session with 'log_device_placement'
+    config = tf.ConfigProto(log_device_placement=True)
+    with tf.Session(config=config) as sess:
+        print(sess.run(c))
+    print()
+
+    print("--- GPU GROWTH ---", "\n")
+
+    # creates a graph assigning the devices
+    with tf.device("/cpu:0"):
+        a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name="a")
+        b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name="b")
+    with tf.device("/gpu:0"):
         c = tf.matmul(a, b)
 
-    with tf.Session() as sess:
+    # run a session with 'log_device_placement'
+    config = tf.ConfigProto(log_device_placement=True)
+    config.gpu_options.allow_growth = True
+    # config.gpu_options.per_process_gpu_memory_fraction = 0.4
+    with tf.Session(config=config) as sess:
         print(sess.run(c))
+    print()
+
+    print("--- SOFT PLACEMENT ---", "\n")
+
+    # creates a graph assigning the devices
+    with tf.device("/cpu:0"):
+        a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name="a")
+        b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name="b")
+    with tf.device("/gpu:0"):
+        c = tf.matmul(a, b)
+
+    # run a session with 'log_device_placement'
+    config = tf.ConfigProto(log_device_placement=True,
+                            allow_soft_placement=True)
+    with tf.Session(config=config) as sess:
+        print(sess.run(c))
+    print()
+
+    print("--- MULTI-GPU ACCESS ---", "\n")
+
+    # creates a graph assigning the devices
+    c = []
+    for d in ["/gpu:0", "/gpu:1"]:
+        with tf.device(d):
+            a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3])
+            b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2])
+            c.append(tf.matmul(a, b))
+    with tf.device("/cpu:0"):
+        s = tf.add_n(c)
+
+    # run a session with 'log_device_placement'
+    config = tf.ConfigProto(log_device_placement=True)
+    with tf.Session(config=config) as sess:
+        print(sess.run(s))
+    print()

From 25a9a27542f2297750ac9e25837e1256b6c2f898 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 16:07:55 +0100
Subject: [PATCH 077/264] check gpu device #4

---
 bash_scripts/check_gpu.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/bash_scripts/check_gpu.py b/bash_scripts/check_gpu.py
index 528a3edf..94e92392 100644
--- a/bash_scripts/check_gpu.py
+++ b/bash_scripts/check_gpu.py
@@ -4,9 +4,10 @@
 Test if the code use GPU device"""
 
 import os
+import time
 import tensorflow as tf
 
-os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"
 
 if __name__ == '__main__':
     print()
@@ -24,6 +25,7 @@
     with tf.Session(config=config) as sess:
         print(sess.run(c))
     print()
+    time.sleep(2)
 
     print("--- GPU ACCESS ---", "\n")
 
@@ -39,6 +41,7 @@
     with tf.Session(config=config) as sess:
         print(sess.run(c))
     print()
+    time.sleep(2)
 
     print("--- GPU GROWTH ---", "\n")
 
@@ -56,6 +59,7 @@
     with tf.Session(config=config) as sess:
         print(sess.run(c))
     print()
+    time.sleep(2)
 
     print("--- SOFT PLACEMENT ---", "\n")
 
@@ -72,6 +76,7 @@
     with tf.Session(config=config) as sess:
         print(sess.run(c))
     print()
+    time.sleep(2)
 
     print("--- MULTI-GPU ACCESS ---", "\n")
 

From 3c28fcb1d37cc79bcf8469b7ec8ee0180674a17a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 16:19:14 +0100
Subject: [PATCH 078/264] check gpu device #5

---
 bash_scripts/check_gpu.py | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/bash_scripts/check_gpu.py b/bash_scripts/check_gpu.py
index 94e92392..44b8ca9b 100644
--- a/bash_scripts/check_gpu.py
+++ b/bash_scripts/check_gpu.py
@@ -22,8 +22,9 @@
 
     # run a session with 'log_device_placement'
     config = tf.ConfigProto(log_device_placement=True)
-    with tf.Session(config=config) as sess:
-        print(sess.run(c))
+    session = tf.Session(config=config)
+    print(session.run(c))
+    session.close()
     print()
     time.sleep(2)
 
@@ -38,8 +39,9 @@
 
     # run a session with 'log_device_placement'
     config = tf.ConfigProto(log_device_placement=True)
-    with tf.Session(config=config) as sess:
-        print(sess.run(c))
+    session = tf.Session(config=config)
+    print(session.run(c))
+    session.close()
     print()
     time.sleep(2)
 
@@ -56,8 +58,9 @@
     config = tf.ConfigProto(log_device_placement=True)
     config.gpu_options.allow_growth = True
     # config.gpu_options.per_process_gpu_memory_fraction = 0.4
-    with tf.Session(config=config) as sess:
-        print(sess.run(c))
+    session = tf.Session(config=config)
+    print(session.run(c))
+    session.close()
     print()
     time.sleep(2)
 
@@ -73,8 +76,9 @@
     # run a session with 'log_device_placement'
     config = tf.ConfigProto(log_device_placement=True,
                             allow_soft_placement=True)
-    with tf.Session(config=config) as sess:
-        print(sess.run(c))
+    session = tf.Session(config=config)
+    print(session.run(c))
+    session.close()
     print()
     time.sleep(2)
 
@@ -92,6 +96,7 @@
 
     # run a session with 'log_device_placement'
     config = tf.ConfigProto(log_device_placement=True)
-    with tf.Session(config=config) as sess:
-        print(sess.run(s))
+    session = tf.Session(config=config)
+    print(session.run(s))
+    session.close()
     print()

From 62179461e2f353fad6ffa35572b9a3e50185c91e Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 18:18:23 +0100
Subject: [PATCH 079/264] add multiprocessing

---
 bigfish/classification/base.py       | 12 ++++++++----
 bigfish/classification/squeezenet.py | 29 +++++++++++++++++-----------
 2 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/bigfish/classification/base.py b/bigfish/classification/base.py
index a15fe6c2..8845f48e 100644
--- a/bigfish/classification/base.py
+++ b/bigfish/classification/base.py
@@ -23,7 +23,8 @@ def fit(self, train_data, train_label, validation_data, validation_label,
         pass
 
     @abstractmethod
-    def fit_generator(self, train_generator, validation_generator, nb_epochs):
+    def fit_generator(self, train_generator, validation_generator, nb_epochs,
+                      nb_workers=1, multiprocessing=False):
         pass
 
     @abstractmethod
@@ -31,7 +32,8 @@ def predict(self, data, return_probability=False):
         pass
 
     @abstractmethod
-    def predict_generator(self, generator, return_probability=False):
+    def predict_generator(self, generator, return_probability=False,
+                          nb_workers=1, multiprocessing=False):
         pass
 
     @abstractmethod
@@ -39,7 +41,8 @@ def predict_probability(self, data):
         pass
 
     @abstractmethod
-    def predict_probability_generator(self, generator):
+    def predict_probability_generator(self, generator,
+                                      nb_workers=1, multiprocessing=False):
         pass
 
     @abstractmethod
@@ -47,7 +50,8 @@ def evaluate(self, data, label):
         pass
 
     @abstractmethod
-    def evaluate_generator(self, generator):
+    def evaluate_generator(self, generator, nb_workers=1,
+                           multiprocessing=False):
         pass
 
 
diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index f4a17477..06807c1a 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -80,7 +80,8 @@ def fit(self, train_data, train_label, validation_data, validation_label,
 
         return
 
-    def fit_generator(self, train_generator, validation_generator, nb_epochs):
+    def fit_generator(self, train_generator, validation_generator, nb_epochs,
+                      nb_workers=1, multiprocessing=False):
         # TODO implement multiprocessing
         # TODO exploit an equivalent of 'sample_weight'
         # TODO implement resumed training with 'initial_epoch'
@@ -120,8 +121,8 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs):
             validation_data=validation_generator,
             validation_steps=validation_generator.nb_batch_per_epoch,
             max_queue_size=10,
-            workers=1,
-            use_multiprocessing=False,
+            workers=nb_workers,
+            use_multiprocessing=multiprocessing,
             initial_epoch=0)
 
         # update model attribute
@@ -147,9 +148,13 @@ def predict_probability(self, data):
 
         return probability
 
-    def predict_generator(self, generator, return_probability=False):
+    def predict_generator(self, generator, return_probability=False,
+                          nb_workers=1, multiprocessing=False):
         # compute probabilities
-        probability = self.predict_probability_generator(generator=generator)
+        probability = self.predict_probability_generator(
+            generator=generator,
+            nb_workers=nb_workers,
+            multiprocessing=multiprocessing)
 
         # make prediction
         prediction = np.argmax(probability, axis=-1)
@@ -159,15 +164,16 @@ def predict_generator(self, generator, return_probability=False):
         else:
             return prediction
 
-    def predict_probability_generator(self, generator):
+    def predict_probability_generator(self, generator, nb_workers=1,
+                                      multiprocessing=False):
         # TODO add multiprocessing
         # compute probabilities
         probability = self.model.predict_generator(
             generator=generator,
             steps=generator.nb_batch_per_epoch,
-            workers=1,
+            workers=nb_workers,
             max_queue_size=1,
-            use_multiprocessing=False)
+            use_multiprocessing=multiprocessing)
 
         return probability
 
@@ -178,15 +184,16 @@ def evaluate(self, data, label):
 
         return loss, accuracy
 
-    def evaluate_generator(self, generator):
+    def evaluate_generator(self, generator, nb_workers=1,
+                           multiprocessing=False):
         # TODO check the outcome 'loss' and 'accuracy'
         # evaluate model
         loss, accuracy = self.model.evaluate_generator(
             generator=generator,
             steps=generator.nb_batch_per_epoch,
-            workers=1,
+            workers=nb_workers,
             max_queue_size=1,
-            use_multiprocessing=False,
+            use_multiprocessing=multiprocessing,
             verbose=1)
         print("Loss: {0:.3f} | Accuracy: {1:.3f}".format(loss, 100 * accuracy))
 

From 0a79fac671107d4b49ec7fa7bdee60d703c96d85 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 18:18:59 +0100
Subject: [PATCH 080/264] add multiprocessing otpions

---
 bash_scripts/2d_pattern_classification.py | 36 +++++++++++++++++++----
 1 file changed, 31 insertions(+), 5 deletions(-)

diff --git a/bash_scripts/2d_pattern_classification.py b/bash_scripts/2d_pattern_classification.py
index 6011965b..c38eef39 100644
--- a/bash_scripts/2d_pattern_classification.py
+++ b/bash_scripts/2d_pattern_classification.py
@@ -15,7 +15,7 @@
 # Your CPU supports instructions that this TensorFlow binary was not compiled
 # to use: AVX2 FMA
 os.environ['TF_CPP_MIN_LOG_LEVEL'] = "2"
-os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3"
 
 if __name__ == '__main__':
     print()
@@ -37,6 +37,14 @@
                         help="Number of epochs to train the model.",
                         type=int,
                         default=10)
+    parser.add_argument("--nb_workers",
+                        help="Number of workers to use.",
+                        type=int,
+                        default=1)
+    parser.add_argument("--multiprocessing",
+                        help="Use multiprocessing.",
+                        type=bool,
+                        default=False)
     args = parser.parse_args()
 
     # parameters
@@ -54,6 +62,8 @@
     print("Input shape: {0}".format(input_shape))
     print("Batch size: {0}".format(args.batch_size))
     print("Number of epochs: {0}".format(args.nb_epochs), "\n")
+    print("Number of workers: {0}".format(args.nb_workers), "\n")
+    print("Multiprocessing: {0}".format(args.multiprocessing), "\n")
 
     print("------------------------")
     print("Classes: {0}".format(classes), "\n")
@@ -127,17 +137,33 @@
         logdir=args.log_directory)
     print("Model trained: {0}".format(model.trained))
     model.print_model()
-    model.fit_generator(train_generator, validation_generator, args.nb_epochs)
+    model.fit_generator(train_generator, validation_generator, args.nb_epochs,
+                        args.nb_workers, args.multiprocessing)
     print()
 
     print("--- EVALUATION ---", "\n")
 
-    # evaluate model
+    # evaluate model with train data
+    print("Model trained: {0}".format(model.trained))
+    train_generator.reset()
+    loss, accuracy = model.evaluate_generator(train_generator,
+                                              args.nb_workers,
+                                              args.multiprocessing)
+    print("Loss train: {0} | Accuracy train: {1}"
+          .format(loss, 100 * accuracy))
+
+    # evaluate model with validation data
     print("Model trained: {0}".format(model.trained))
     validation_generator.reset()
-    loss, accuracy = model.evaluate_generator(validation_generator)
+    loss, accuracy = model.evaluate_generator(validation_generator,
+                                              args.nb_workers,
+                                              args.multiprocessing)
     print("Loss validation: {0} | Accuracy validation: {1}"
           .format(loss, 100 * accuracy))
-    loss, accuracy = model.evaluate_generator(test_generator)
+
+    # evaluate model with test data
+    loss, accuracy = model.evaluate_generator(test_generator,
+                                              args.nb_workers,
+                                              args.multiprocessing)
     print("Loss test: {0} | Accuracy test: {1}"
           .format(loss, 100 * accuracy))

From 345c6b0f418dcd3878c46fd4e813dbd2f015d2eb Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 18:23:34 +0100
Subject: [PATCH 081/264] add features method option

---
 bash_scripts/2d_pattern_classification.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/bash_scripts/2d_pattern_classification.py b/bash_scripts/2d_pattern_classification.py
index c38eef39..610724e9 100644
--- a/bash_scripts/2d_pattern_classification.py
+++ b/bash_scripts/2d_pattern_classification.py
@@ -29,6 +29,11 @@
     parser.add_argument("log_directory",
                         help="Path of the log directory.",
                         type=str)
+    parser.add_argument("--features",
+                        help="Features used ('normal', 'distance' or "
+                             "'surface')",
+                        type=str,
+                        default="normal")
     parser.add_argument("--batch_size",
                         help="Size of a batch.",
                         type=int,
@@ -60,6 +65,7 @@
     print("------------------------")
     print("Number of classes: {0}".format(nb_classes))
     print("Input shape: {0}".format(input_shape))
+    print("Features: {0}".format(args.features))
     print("Batch size: {0}".format(args.batch_size))
     print("Number of epochs: {0}".format(args.nb_epochs), "\n")
     print("Number of workers: {0}".format(args.nb_workers), "\n")
@@ -89,7 +95,7 @@
     # build train generator
     train_generator = stack.Generator(
         data=df_train,
-        method="normal",
+        method=args.features,
         batch_size=args.batch_size,
         input_shape=input_shape,
         augmentation=True,
@@ -102,7 +108,7 @@
     # build validation generator
     validation_generator = stack.Generator(
         data=df_validation,
-        method="normal",
+        method=args.features,
         batch_size=args.batch_size,
         input_shape=input_shape,
         augmentation=False,
@@ -115,7 +121,7 @@
     # build test generator
     test_generator = stack.Generator(
         data=df_test,
-        method="normal",
+        method=args.features,
         batch_size=args.batch_size,
         input_shape=input_shape,
         augmentation=False,

From 69104cfdf44f83cc339054db0dc9614e3cc4cdb5 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 29 Mar 2019 18:30:01 +0100
Subject: [PATCH 082/264] fix verbose evaluation

---
 bash_scripts/2d_pattern_classification.py | 15 +++++++++------
 bigfish/classification/squeezenet.py      | 14 +++++++++-----
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/bash_scripts/2d_pattern_classification.py b/bash_scripts/2d_pattern_classification.py
index 610724e9..19f116f7 100644
--- a/bash_scripts/2d_pattern_classification.py
+++ b/bash_scripts/2d_pattern_classification.py
@@ -154,8 +154,9 @@
     train_generator.reset()
     loss, accuracy = model.evaluate_generator(train_generator,
                                               args.nb_workers,
-                                              args.multiprocessing)
-    print("Loss train: {0} | Accuracy train: {1}"
+                                              args.multiprocessing,
+                                              verbose=0)
+    print("Loss train: {0:.3f} | Accuracy train: {1:.3f}"
           .format(loss, 100 * accuracy))
 
     # evaluate model with validation data
@@ -163,13 +164,15 @@
     validation_generator.reset()
     loss, accuracy = model.evaluate_generator(validation_generator,
                                               args.nb_workers,
-                                              args.multiprocessing)
-    print("Loss validation: {0} | Accuracy validation: {1}"
+                                              args.multiprocessing,
+                                              verbose=0)
+    print("Loss validation: {0:.3f} | Accuracy validation: {1:.3f}"
           .format(loss, 100 * accuracy))
 
     # evaluate model with test data
     loss, accuracy = model.evaluate_generator(test_generator,
                                               args.nb_workers,
-                                              args.multiprocessing)
-    print("Loss test: {0} | Accuracy test: {1}"
+                                              args.multiprocessing,
+                                              verbose=0)
+    print("Loss test: {0:.3f} | Accuracy test: {1:.3f}"
           .format(loss, 100 * accuracy))
diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 06807c1a..2aa7de7c 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -177,15 +177,17 @@ def predict_probability_generator(self, generator, nb_workers=1,
 
         return probability
 
-    def evaluate(self, data, label):
+    def evaluate(self, data, label, verbose=0):
         # evaluate model
         loss, accuracy = self.model.evaluate(x=data, y=label)
-        print("Loss: {0:.3f} | Accuracy: {1:.3f}".format(loss, 100 * accuracy))
+        if verbose > 0:
+            print("Loss: {0:.3f} | Accuracy: {1:.3f}"
+                  .format(loss, 100 * accuracy))
 
         return loss, accuracy
 
     def evaluate_generator(self, generator, nb_workers=1,
-                           multiprocessing=False):
+                           multiprocessing=False, verbose=0):
         # TODO check the outcome 'loss' and 'accuracy'
         # evaluate model
         loss, accuracy = self.model.evaluate_generator(
@@ -194,8 +196,10 @@ def evaluate_generator(self, generator, nb_workers=1,
             workers=nb_workers,
             max_queue_size=1,
             use_multiprocessing=multiprocessing,
-            verbose=1)
-        print("Loss: {0:.3f} | Accuracy: {1:.3f}".format(loss, 100 * accuracy))
+            verbose=verbose)
+        if verbose > 0:
+            print("Loss: {0:.3f} | Accuracy: {1:.3f}"
+                  .format(loss, 100 * accuracy))
 
         return loss, accuracy
 

From 57b0d53b6795129b596e4ba12d54b78d48fa09cb Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 2 Apr 2019 10:53:09 +0200
Subject: [PATCH 083/264] add duration bash script

---
 bash_scripts/2d_pattern_classification.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/bash_scripts/2d_pattern_classification.py b/bash_scripts/2d_pattern_classification.py
index 19f116f7..dd4423ff 100644
--- a/bash_scripts/2d_pattern_classification.py
+++ b/bash_scripts/2d_pattern_classification.py
@@ -7,6 +7,7 @@
 import os
 import argparse
 import pickle
+import time
 
 import bigfish.stack as stack
 import bigfish.classification as classification
@@ -20,6 +21,7 @@
 if __name__ == '__main__':
     print()
     print("Running {0} file...". format(os.path.basename(__file__)), "\n")
+    start_time = time.time()
 
     # parse arguments
     parser = argparse.ArgumentParser()
@@ -67,8 +69,8 @@
     print("Input shape: {0}".format(input_shape))
     print("Features: {0}".format(args.features))
     print("Batch size: {0}".format(args.batch_size))
-    print("Number of epochs: {0}".format(args.nb_epochs), "\n")
-    print("Number of workers: {0}".format(args.nb_workers), "\n")
+    print("Number of epochs: {0}".format(args.nb_epochs))
+    print("Number of workers: {0}".format(args.nb_workers))
     print("Multiprocessing: {0}".format(args.multiprocessing), "\n")
 
     print("------------------------")
@@ -176,3 +178,7 @@
                                               verbose=0)
     print("Loss test: {0:.3f} | Accuracy test: {1:.3f}"
           .format(loss, 100 * accuracy))
+
+    end_time = time.time()
+    duration = int(round((end_time - start_time) / 60))
+    print("Duration: {0} minutes.".format(duration))

From 10734e962fb9c5d392d880094342146a88d40d96 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 3 Apr 2019 18:56:20 +0200
Subject: [PATCH 084/264] add early stopping

---
 bigfish/classification/squeezenet.py          | 68 ++++++++++++++++---
 {bash_scripts => python_scripts}/check_gpu.py |  0
 .../isbi_2019}/2d_pattern_classification.py   |  0
 python_scripts/isbi_2019/utils.py             |  0
 4 files changed, 57 insertions(+), 11 deletions(-)
 rename {bash_scripts => python_scripts}/check_gpu.py (100%)
 rename {bash_scripts => python_scripts/isbi_2019}/2d_pattern_classification.py (100%)
 create mode 100644 python_scripts/isbi_2019/utils.py

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 2aa7de7c..33f8e990 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -12,7 +12,7 @@
          Dally, William J
          Keutzer, Kurt
 Year: 2016
-Version: 1.1 (see github https://github.com/DeepScale/SqueezeNet)
+Version: 1.0 and 1.1 (see github https://github.com/DeepScale/SqueezeNet)
 """
 
 import os
@@ -24,7 +24,7 @@
 
 from tensorflow.python.keras.backend import function
 from tensorflow.python.keras.models import Model
-from tensorflow.python.keras.callbacks import ModelCheckpoint
+from tensorflow.python.keras.callbacks import ModelCheckpoint, EarlyStopping, LearningRateScheduler
 from tensorflow.python.keras.layers import (Conv2D, Concatenate, MaxPooling2D,
                                             Dropout, GlobalAveragePooling2D,
                                             Add, Input, Activation,
@@ -51,6 +51,7 @@ def __init__(self, nb_classes, bypass=False, optimizer="adam",
             os.mkdir(self.logdir)
         self.model = None
         self.trained = False
+        self.history = None
 
         # build model
         self._build_model(bypass, optimizer)
@@ -60,16 +61,35 @@ def fit(self, train_data, train_label, validation_data, validation_label,
         # TODO exploit 'sample_weight'
         # TODO implement resumed training with 'initial_epoch'
         # TODO add documentation
-        # TODO add callbacks
+
+        callbacks = []
+
+        # define checkpoints
+        if self.logdir is not None:
+            # create checkpoint callback
+            checkpoint_path = os.path.join(self.logdir, "cp-{epoch}.ckpt")
+            cp_callback = ModelCheckpoint(
+                filepath=checkpoint_path,
+                verbose=1)
+            callbacks.append(cp_callback)
+
+        # define early stopping
+        early_stop = EarlyStopping(
+            monitor='val_categorical_accuracy',
+            min_delta=0,
+            patience=3,
+            verbose=1,
+            baseline=0.9)
+        callbacks.append(early_stop)
 
         # fit model
-        self.model.fit(
+        self.history = self.model.fit(
             x=train_data,
             y=train_label,
             batch_size=batch_size,
             epochs=nb_epochs,
             verbose=2,
-            callbacks=None,
+            callbacks=callbacks,
             validation_data=(validation_data, validation_label),
             shuffle=True,
             sample_weight=None,
@@ -98,21 +118,29 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs,
                     "data. The parameter 'nb_epoch_max' is set to None.")
             validation_generator.nb_epoch_max = None
 
-        # define callbacks
+        callbacks = []
+
+        # define checkpoints
         if self.logdir is not None:
             # create checkpoint callback
             checkpoint_path = os.path.join(self.logdir, "cp-{epoch}.ckpt")
-            # checkpoint_path = os.path.join(self.logdir, "cp.ckpt")
             cp_callback = ModelCheckpoint(
                 filepath=checkpoint_path,
                 verbose=1)
-            callbacks = [cp_callback]
-        else:
-            callbacks = None
+            callbacks.append(cp_callback)
+
+        # define early stopping
+        early_stop = EarlyStopping(
+            monitor='val_categorical_accuracy',
+            min_delta=0,
+            patience=3,
+            verbose=1,
+            baseline=0.9)
+        callbacks.append(early_stop)
 
         # fit model from generator
         steps_per_epoch = train_generator.nb_batch_per_epoch
-        self.model.fit_generator(
+        self.history = self.model.fit_generator(
             generator=train_generator,
             steps_per_epoch=steps_per_epoch,
             epochs=nb_epochs,
@@ -248,6 +276,24 @@ def get_weight(self, latest=True, checkpoint_name="cp.ckpt"):
             raise ValueError("Impossible to load pre-trained weights. The log "
                              "directory is not specified or does not exist.")
 
+    def save_training_history(self):
+        """Save the loss and accuracy of the train and validation data over
+        the different epochs.
+
+        Returns
+        -------
+
+        """
+        if self.logdir is not None:
+            path = os.path.join(self.logdir, "history.npz")
+            np.savez(path,
+                     loss=self.history.history["loss"],
+                     categorical_accuracy=self.history.history["loss"],
+                     val_loss=self.history.history["loss"],
+                     val_categorical_accuracy=self.history.history["loss"])
+
+        return
+
 
 # ### Architecture functions ###
 
diff --git a/bash_scripts/check_gpu.py b/python_scripts/check_gpu.py
similarity index 100%
rename from bash_scripts/check_gpu.py
rename to python_scripts/check_gpu.py
diff --git a/bash_scripts/2d_pattern_classification.py b/python_scripts/isbi_2019/2d_pattern_classification.py
similarity index 100%
rename from bash_scripts/2d_pattern_classification.py
rename to python_scripts/isbi_2019/2d_pattern_classification.py
diff --git a/python_scripts/isbi_2019/utils.py b/python_scripts/isbi_2019/utils.py
new file mode 100644
index 00000000..e69de29b

From 23d2bea5179f31624821af56663991e7177a7f34 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 3 Apr 2019 18:57:06 +0200
Subject: [PATCH 085/264] fix label encoding

---
 bigfish/stack/__init__.py    |  6 ++---
 bigfish/stack/preparation.py | 44 ++++++++++++++++--------------------
 2 files changed, 22 insertions(+), 28 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 5018b75f..5d2feff4 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,8 +17,7 @@
                           get_coordinates, from_coord_to_image,
                           get_distance_layers, get_surface_layers,
                           build_input_image, resize_image, build_batch,
-                          generate_images, get_label, one_hot_label, Generator,
-                          subset_data)
+                          generate_images, get_label, one_hot_label, Generator)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
 
@@ -61,5 +60,4 @@
            "generate_images",
            "get_label",
            "one_hot_label",
-           "Generator",
-           "subset_data"]
+           "Generator"]
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 0392e2c8..1f80f80c 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -4,26 +4,26 @@
 Functions to prepare the data before feeding a model.
 """
 
+import os
 import threading
+
 import numpy as np
+from scipy import ndimage as ndi
 
-from .preprocess import (cast_img_uint8, cast_img_uint16, cast_img_float32,
-                         cast_img_float64)
 from .augmentation import augment
 from .utils import check_array
+from .preprocess import (cast_img_uint8, cast_img_uint16, cast_img_float32,
+                         cast_img_float64)
 
 from skimage.transform import resize
 from scipy.sparse import coo_matrix
-from sklearn.preprocessing import LabelEncoder
-
-from scipy import ndimage as ndi
 
 
 # TODO define the requirements for 'data'
 
 # ### Split and subset data ###
 
-def split_from_background(data, p_validation=0.2, p_test=0.2):
+def split_from_background(data, p_validation=0.2, p_test=0.2, logdir=None):
     """Split dataset between train, validation and test, based on the
     background volume used to simulate the cell.
 
@@ -35,6 +35,8 @@ def split_from_background(data, p_validation=0.2, p_test=0.2):
         Proportion of the validation dataset.
     p_test : float
         Proportion of the test dataset.
+    logdir : str
+        Path of the log directory used to save the split indices.
 
     Returns
     -------
@@ -59,29 +61,23 @@ def split_from_background(data, p_validation=0.2, p_test=0.2):
 
     # split data between train, validation and test
     data_train = data.query("cell_ID in {0}".format(str(train_cell)))
-    data_train.reset_index(drop=True, inplace=True)
     data_validation = data.query("cell_ID in {0}".format(str(validation_cell)))
-    data_validation.reset_index(drop=True, inplace=True)
     data_test = data.query("cell_ID in {0}".format(str(test_cell)))
-    data_test.reset_index(drop=True, inplace=True)
-
-    return data_train, data_validation, data_test
-
-
-def subset_data(data, classes_name=None):
-    # choose classes to keep
-    if classes_name is None:
-        classes_name = list(set(data["pattern_name"]))
 
-    # keep specific classes
-    query = "pattern_name in {0}".format(str(classes_name))
-    data = data.query(query)
+    # save indices
+    if logdir is not None:
+        path = os.path.join(logdir, "indices_split.npz")
+        np.savez(path,
+                 indices_train=np.array(data_train.index),
+                 indices_validation=np.array(data_validation.index),
+                 indices_test=np.array(data_test.index))
 
-    # encode the label
-    le = LabelEncoder()
-    data = data.assign(label=le.fit_transform(data["pattern_name"]))
+    # reset index
+    data_train.reset_index(drop=True, inplace=True)
+    data_validation.reset_index(drop=True, inplace=True)
+    data_test.reset_index(drop=True, inplace=True)
 
-    return data
+    return data_train, data_validation, data_test
 
 
 # ### Build images ###

From 8b887d27fe2c31ed390e040fe1faa6221cc85bd6 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 3 Apr 2019 18:57:51 +0200
Subject: [PATCH 086/264] fix label encoding #2

---
 .../isbi_2019/2d_pattern_classification.py    |  37 ++--
 python_scripts/isbi_2019/utils.py             | 191 ++++++++++++++++++
 2 files changed, 212 insertions(+), 16 deletions(-)

diff --git a/python_scripts/isbi_2019/2d_pattern_classification.py b/python_scripts/isbi_2019/2d_pattern_classification.py
index dd4423ff..22df4503 100644
--- a/python_scripts/isbi_2019/2d_pattern_classification.py
+++ b/python_scripts/isbi_2019/2d_pattern_classification.py
@@ -6,12 +6,13 @@
 
 import os
 import argparse
-import pickle
 import time
 
 import bigfish.stack as stack
 import bigfish.classification as classification
 
+from .utils import encode_labels
+
 # TODO build tensorflow from source to avoid the next line
 # Your CPU supports instructions that this TensorFlow binary was not compiled
 # to use: AVX2 FMA
@@ -33,9 +34,13 @@
                         type=str)
     parser.add_argument("--features",
                         help="Features used ('normal', 'distance' or "
-                             "'surface')",
+                             "'surface').",
                         type=str,
                         default="normal")
+    parser.add_argument("--classes",
+                        help="Set of classes to predict.",
+                        type=str,
+                        default="all")
     parser.add_argument("--batch_size",
                         help="Size of a batch.",
                         type=int,
@@ -55,9 +60,6 @@
     args = parser.parse_args()
 
     # parameters
-    classes = ["inNUC", "cell2D", "nuc2D", "foci", "polarized", "cellext",
-               "random"]
-    nb_classes = len(classes)
     input_shape = (224, 224)
 
     print("------------------------")
@@ -65,7 +67,6 @@
     print("Output logs: {0}".format(args.log_directory), "\n")
 
     print("------------------------")
-    print("Number of classes: {0}".format(nb_classes))
     print("Input shape: {0}".format(input_shape))
     print("Features: {0}".format(args.features))
     print("Batch size: {0}".format(args.batch_size))
@@ -73,24 +74,28 @@
     print("Number of workers: {0}".format(args.nb_workers))
     print("Multiprocessing: {0}".format(args.multiprocessing), "\n")
 
-    print("------------------------")
-    print("Classes: {0}".format(classes), "\n")
-
     print("--- PREPROCESSING ---", "\n")
 
     # load data
-    # path_output = os.path.join(main_directory, "data_cleaned_small")
-    with open(args.path_input, mode='rb') as f:
-        df = pickle.load(f)
+    df = stack.read_pickle(args.path_input)
     print("Shape input dataframe (before preparation): {0}".format(df.shape))
 
     # prepare data
-    df = stack.subset_data(df, classes_name=classes)
+    df, encoder, classes = encode_labels(df,
+                                         column_name="pattern_name",
+                                         classes_to_analyse="all")
+    nb_classes = len(classes)
+    print("Number of classes: {0}".format(nb_classes))
+    print("Classes: {0}".format(classes))
     print("Shape input dataframe (after preparation): {0}".format(df.shape))
+    print()
+
+    # split data
     df_train, df_validation, df_test = stack.split_from_background(
         data=df,
         p_validation=0.2,
-        p_test=0.2)
+        p_test=0.2,
+        logdir=args.log_directory)
     print("Split train|validation|test: {0}|{1}|{2}"
           .format(df_train.shape[0], df_validation.shape[0], df_test.shape[0]))
 
@@ -147,12 +152,13 @@
     model.print_model()
     model.fit_generator(train_generator, validation_generator, args.nb_epochs,
                         args.nb_workers, args.multiprocessing)
+    model.save_training_history()
+    print("Model trained: {0}".format(model.trained))
     print()
 
     print("--- EVALUATION ---", "\n")
 
     # evaluate model with train data
-    print("Model trained: {0}".format(model.trained))
     train_generator.reset()
     loss, accuracy = model.evaluate_generator(train_generator,
                                               args.nb_workers,
@@ -162,7 +168,6 @@
           .format(loss, 100 * accuracy))
 
     # evaluate model with validation data
-    print("Model trained: {0}".format(model.trained))
     validation_generator.reset()
     loss, accuracy = model.evaluate_generator(validation_generator,
                                               args.nb_workers,
diff --git a/python_scripts/isbi_2019/utils.py b/python_scripts/isbi_2019/utils.py
index e69de29b..ae7c01bc 100644
--- a/python_scripts/isbi_2019/utils.py
+++ b/python_scripts/isbi_2019/utils.py
@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+
+"""
+Utility functions.
+"""
+
+from sklearn.preprocessing import LabelEncoder
+
+
+def encode_labels(data, column_name="pattern_name", classes_to_analyse="all"):
+    """Filter classes we want to analyze and encode them from a string format
+    to a numerical one.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        Dataframe with a feature containing the label in string format.
+    column_name : str
+        Name of the feature to use in the dataframe as label.
+    classes_to_analyse : str
+        Define the set of classe we want to keep and to encode before training
+        a model:
+        - 'experimental' to fit with the experimental data (5 classes).
+        - '2d' to analyze the 2-d classes only (7 classes).
+        - 'all' to analyze all the classes (9 classes).
+
+    Returns
+    -------
+    data : pd.DataFrame
+        Dataframe with the encoded label in an additional column 'label'. If
+        the original columns label is already named 'label', we rename both
+        columns 'label_str' and 'label_num'.
+    encoder : sklearn.preprocessing.LabelEncoder
+        Fitted encoder to encode of decode a label.
+    classes : List[str]
+        List of the classes to keep and encode.
+
+    """
+    # experimental analysis
+    if classes_to_analyse == "experimental":
+        data, encoder, classes = _encode_label_experimental(data, column_name)
+    # 2-d analysis
+    elif classes_to_analyse == "2d":
+        data, encoder, classes = _encode_label_2d(data, column_name)
+    # complete analysis
+    elif classes_to_analyse == "all":
+        data, encoder, classes = _encode_label_all(data, column_name)
+    else:
+        raise ValueError("'classes_to_analyse' can only take three values: "
+                         "'experimental', '2d' or 'all'.")
+
+    return data, encoder, classes
+
+
+def _encode_label_experimental(data, column_name):
+    """Filter the 5 classes included in the experimental dataset, then encode
+    them from a string format to a numerical one.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        Dataframe with a feature containing the label in string format.
+    column_name : str
+        Name of the feature to use in the dataframe as label.
+
+    Returns
+    -------
+    data : pd.DataFrame
+        Dataframe with the encoded label in an additional column 'label'. If
+        the original columns label is already named 'label', we rename both
+        columns 'label_str' and 'label_num'.
+    encoder : sklearn.preprocessing.LabelEncoder
+        Fitted encoder to encode of decode a label.
+    classes : List[str]
+        List of the classes to keep and encode.
+
+    """
+    # get classes to use
+    classes = ["random", "foci", "cellext", "inNUC", "nuc2D"]
+
+    # fit a label encoder
+    encoder = LabelEncoder()
+    encoder.fit(classes)
+
+    # filter rows
+    query = "{0} in {1}".format(column_name, str(classes))
+    data = data.query(query)
+
+    # encode labels
+    if column_name == "label":
+        data = data.assign(
+            label_str=data.loc[:, column_name],
+            label_num=encoder.transform(data.loc[:, column_name]))
+    else:
+        data = data.assign(
+            label=encoder.transform(data.loc[:, column_name]))
+
+    return data, encoder, classes
+
+
+def _encode_label_2d(data, column_name):
+    """Filter the 2-d classes, then encode them from a string format to a
+    numerical one.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        Dataframe with a feature containing the label in string format.
+    column_name : str
+        Name of the feature to use in the dataframe as label.
+
+    Returns
+    -------
+    data : pd.DataFrame
+        Dataframe with the encoded label in an additional column 'label'. If
+        the original columns label is already named 'label', we rename both
+        columns 'label_str' and 'label_num'.
+    encoder : sklearn.preprocessing.LabelEncoder
+        Fitted encoder to encode of decode a label.
+    classes : List[str]
+        List of the classes to keep and encode.
+
+    """
+    # get classes to use
+    classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
+               "polarized"]
+
+    # fit a label encoder
+    encoder = LabelEncoder()
+    encoder.fit(classes)
+
+    # filter rows
+    query = "{0} in {1}".format(column_name, str(classes))
+    data = data.query(query)
+
+    # encode labels
+    if column_name == "label":
+        data = data.assign(
+            label_str=data.loc[:, column_name],
+            label_num=encoder.transform(data.loc[:, column_name]))
+    else:
+        data = data.assign(
+            label=encoder.transform(data.loc[:, column_name]))
+
+    return data, encoder, classes
+
+
+def _encode_label_all(data, column_name):
+    """Encode all the classes from a string format to a numerical one.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        Dataframe with a feature containing the label in string format.
+    column_name : str
+        Name of the feature to use in the dataframe as label.
+
+    Returns
+    -------
+    data : pd.DataFrame
+        Dataframe with the encoded label in an additional column 'label'. If
+        the original columns label is already named 'label', we rename both
+        columns 'label_str' and 'label_num'.
+    encoder : sklearn.preprocessing.LabelEncoder
+        Fitted encoder to encode of decode a label.
+    classes : List[str]
+        List of the classes to keep and encode.
+
+    """
+    # get classes to use
+    classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
+               "polarized", "cell3D", "nuc3D"]
+
+    # fit a label encoder
+    encoder = LabelEncoder()
+    encoder.fit(classes)
+
+    # filter rows
+    query = "{0} in {1}".format(column_name, str(classes))
+    data = data.query(query)
+
+    # encode labels
+    if column_name == "label":
+        data = data.assign(
+            label_str=data.loc[:, column_name],
+            label_num=encoder.transform(data.loc[:, column_name]))
+    else:
+        data = data.assign(
+            label=encoder.transform(data.loc[:, column_name]))
+
+    return data, encoder, classes

From 4a6bba7bb94d55d0e3e88325faa25c62bd05c558 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 09:37:34 +0200
Subject: [PATCH 087/264] update requirements

---
 requirements.txt        | 2 +-
 requirements_stable.txt | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index e6533271..6a408165 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,7 +7,7 @@ pip >= 18.1
 scikit-learn >= 0.20.2
 scikit-image >= 0.14.2
 scipy >= 1.2.0
-tensorflow >= 1.12.0, < 2.0
+# tensorflow >= 1.12.0, < 2.0
 matplotlib >= 3.0.2
 pandas >= 0.24.0
 joblib >= 0.13.2
diff --git a/requirements_stable.txt b/requirements_stable.txt
index 460b54e5..e21aaf78 100644
--- a/requirements_stable.txt
+++ b/requirements_stable.txt
@@ -7,7 +7,7 @@ pip == 18.1
 scikit-learn == 0.20.2
 scikit-image == 0.14.2
 scipy == 1.2.0
-tensorflow == 1.12.0
+tensorflow-gpu == 1.12.0
 matplotlib == 3.0.2
 pandas == 0.24.0
 joblib == 0.13.2

From d7d8c5ac94259354f232bea7568d77a4f105153c Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 09:45:18 +0200
Subject: [PATCH 088/264] update requirements #2

---
 requirements_stable.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements_stable.txt b/requirements_stable.txt
index e21aaf78..319656cf 100644
--- a/requirements_stable.txt
+++ b/requirements_stable.txt
@@ -7,7 +7,7 @@ pip == 18.1
 scikit-learn == 0.20.2
 scikit-image == 0.14.2
 scipy == 1.2.0
-tensorflow-gpu == 1.12.0
+# tensorflow-gpu == 1.12.0
 matplotlib == 3.0.2
 pandas == 0.24.0
 joblib == 0.13.2

From e38be0e8ac343c00fdeb77603e65d6f89409bfe4 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 10:10:38 +0200
Subject: [PATCH 089/264] update imports

---
 bigfish/classification/playground.py | 40 ++++++++++++++++++++++++++++
 bigfish/classification/squeezenet.py |  3 +--
 python_scripts/__init_.py            |  0
 python_scripts/isbi_2019/__init__.py |  0
 4 files changed, 41 insertions(+), 2 deletions(-)
 create mode 100644 bigfish/classification/playground.py
 create mode 100644 python_scripts/__init_.py
 create mode 100644 python_scripts/isbi_2019/__init__.py

diff --git a/bigfish/classification/playground.py b/bigfish/classification/playground.py
new file mode 100644
index 00000000..af8210c8
--- /dev/null
+++ b/bigfish/classification/playground.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+"""
+Models based on SqueezeNet.
+
+Paper: "SqueezeNet: AlexNet-level accuracy with 50x fewer parameters
+        and <0.5MB model size"
+Authors: Iandola, Forrest N
+         Han, Song
+         Moskewicz, Matthew W
+         Ashraf, Khalid
+         Dally, William J
+         Keutzer, Kurt
+Year: 2016
+"""
+
+import tensorflow as tf
+#from tensorflow.keras import layer
+#from tensorflow.keras.layers import Dense, Conv2D
+
+print(tf.VERSION)
+print(tf.keras.__version__)
+
+
+from collections import Iterator, Generator
+import unittest
+
+class Test(unittest.TestCase):
+    def test_Fib(self):
+        f = Fib()
+        self.assertEqual(next(f), 0)
+        self.assertEqual(next(f), 1)
+        self.assertEqual(next(f), 1)
+        self.assertEqual(next(f), 2) #etc...
+    def test_Fib_is_iterator(self):
+        f = Fib()
+        self.assertIsInstance(f, Iterator)
+    def test_Fib_is_generator(self):
+        f = Fib()
+        self.assertIsInstance(f, Generator)
\ No newline at end of file
diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 33f8e990..fbcb98dc 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -22,9 +22,8 @@
 
 from .base import BaseModel, get_optimizer
 
-from tensorflow.python.keras.backend import function
 from tensorflow.python.keras.models import Model
-from tensorflow.python.keras.callbacks import ModelCheckpoint, EarlyStopping, LearningRateScheduler
+from tensorflow.python.keras.callbacks import ModelCheckpoint, EarlyStopping
 from tensorflow.python.keras.layers import (Conv2D, Concatenate, MaxPooling2D,
                                             Dropout, GlobalAveragePooling2D,
                                             Add, Input, Activation,
diff --git a/python_scripts/__init_.py b/python_scripts/__init_.py
new file mode 100644
index 00000000..e69de29b
diff --git a/python_scripts/isbi_2019/__init__.py b/python_scripts/isbi_2019/__init__.py
new file mode 100644
index 00000000..e69de29b

From 719f9cdda1ab0799ddcdb0fb64dd378e7f6aa518 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 10:19:24 +0200
Subject: [PATCH 090/264] refactoring

---
 bigfish/classification/playground.py          |  40 ----
 bigfish/stack/__init__.py                     |   6 +-
 bigfish/stack/preparation.py                  | 189 +++++++++++++++++-
 .../2d_pattern_classification.py              |   8 +-
 python_scripts/__init_.py                     |   0
 python_scripts/isbi_2019/__init__.py          |   0
 python_scripts/{isbi_2019 => }/utils.py       |   0
 7 files changed, 195 insertions(+), 48 deletions(-)
 delete mode 100644 bigfish/classification/playground.py
 rename python_scripts/{isbi_2019 => }/2d_pattern_classification.py (96%)
 delete mode 100644 python_scripts/__init_.py
 delete mode 100644 python_scripts/isbi_2019/__init__.py
 rename python_scripts/{isbi_2019 => }/utils.py (100%)

diff --git a/bigfish/classification/playground.py b/bigfish/classification/playground.py
deleted file mode 100644
index af8210c8..00000000
--- a/bigfish/classification/playground.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-Models based on SqueezeNet.
-
-Paper: "SqueezeNet: AlexNet-level accuracy with 50x fewer parameters
-        and <0.5MB model size"
-Authors: Iandola, Forrest N
-         Han, Song
-         Moskewicz, Matthew W
-         Ashraf, Khalid
-         Dally, William J
-         Keutzer, Kurt
-Year: 2016
-"""
-
-import tensorflow as tf
-#from tensorflow.keras import layer
-#from tensorflow.keras.layers import Dense, Conv2D
-
-print(tf.VERSION)
-print(tf.keras.__version__)
-
-
-from collections import Iterator, Generator
-import unittest
-
-class Test(unittest.TestCase):
-    def test_Fib(self):
-        f = Fib()
-        self.assertEqual(next(f), 0)
-        self.assertEqual(next(f), 1)
-        self.assertEqual(next(f), 1)
-        self.assertEqual(next(f), 2) #etc...
-    def test_Fib_is_iterator(self):
-        f = Fib()
-        self.assertIsInstance(f, Iterator)
-    def test_Fib_is_generator(self):
-        f = Fib()
-        self.assertIsInstance(f, Generator)
\ No newline at end of file
diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 5d2feff4..2115c0e5 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,7 +17,8 @@
                           get_coordinates, from_coord_to_image,
                           get_distance_layers, get_surface_layers,
                           build_input_image, resize_image, build_batch,
-                          generate_images, get_label, one_hot_label, Generator)
+                          generate_images, get_label, one_hot_label, Generator,
+                          encode_labels)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
 
@@ -60,4 +61,5 @@
            "generate_images",
            "get_label",
            "one_hot_label",
-           "Generator"]
+           "Generator",
+           "encode_labels"]
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 1f80f80c..2c9f53e0 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -17,11 +17,12 @@
 
 from skimage.transform import resize
 from scipy.sparse import coo_matrix
+from sklearn.preprocessing import LabelEncoder
 
 
 # TODO define the requirements for 'data'
 
-# ### Split and subset data ###
+# ### Split data ###
 
 def split_from_background(data, p_validation=0.2, p_test=0.2, logdir=None):
     """Split dataset between train, validation and test, based on the
@@ -80,6 +81,192 @@ def split_from_background(data, p_validation=0.2, p_test=0.2, logdir=None):
     return data_train, data_validation, data_test
 
 
+# ### Encode labels ###
+
+def encode_labels(data, column_name="pattern_name", classes_to_analyse="all"):
+    """Filter classes we want to analyze and encode them from a string format
+    to a numerical one.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        Dataframe with a feature containing the label in string format.
+    column_name : str
+        Name of the feature to use in the dataframe as label.
+    classes_to_analyse : str
+        Define the set of classes we want to keep and to encode before training
+        a model:
+        - 'experimental' to fit with the experimental data (5 classes).
+        - '2d' to analyze the 2-d classes only (7 classes).
+        - 'all' to analyze all the classes (9 classes).
+
+    Returns
+    -------
+    data : pd.DataFrame
+        Dataframe with the encoded label in an additional column 'label'. If
+        the original columns label is already named 'label', we rename both
+        columns 'label_str' and 'label_num'.
+    encoder : sklearn.preprocessing.LabelEncoder
+        Fitted encoder to encode of decode a label.
+    classes : List[str]
+        List of the classes to keep and encode.
+
+    """
+    # experimental analysis
+    if classes_to_analyse == "experimental":
+        data, encoder, classes = _encode_label_experimental(data, column_name)
+    # 2-d analysis
+    elif classes_to_analyse == "2d":
+        data, encoder, classes = _encode_label_2d(data, column_name)
+    # complete analysis
+    elif classes_to_analyse == "all":
+        data, encoder, classes = _encode_label_all(data, column_name)
+    else:
+        raise ValueError("'classes_to_analyse' can only take three values: "
+                         "'experimental', '2d' or 'all'.")
+
+    return data, encoder, classes
+
+
+def _encode_label_experimental(data, column_name):
+    """Filter the 5 classes included in the experimental dataset, then encode
+    them from a string format to a numerical one.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        Dataframe with a feature containing the label in string format.
+    column_name : str
+        Name of the feature to use in the dataframe as label.
+
+    Returns
+    -------
+    data : pd.DataFrame
+        Dataframe with the encoded label in an additional column 'label'. If
+        the original columns label is already named 'label', we rename both
+        columns 'label_str' and 'label_num'.
+    encoder : sklearn.preprocessing.LabelEncoder
+        Fitted encoder to encode of decode a label.
+    classes : List[str]
+        List of the classes to keep and encode.
+
+    """
+    # get classes to use
+    classes = ["random", "foci", "cellext", "inNUC", "nuc2D"]
+
+    # fit a label encoder
+    encoder = LabelEncoder()
+    encoder.fit(classes)
+
+    # filter rows
+    query = "{0} in {1}".format(column_name, str(classes))
+    data = data.query(query)
+
+    # encode labels
+    if column_name == "label":
+        data = data.assign(
+            label_str=data.loc[:, column_name],
+            label_num=encoder.transform(data.loc[:, column_name]))
+    else:
+        data = data.assign(
+            label=encoder.transform(data.loc[:, column_name]))
+
+    return data, encoder, classes
+
+
+def _encode_label_2d(data, column_name):
+    """Filter the 2-d classes, then encode them from a string format to a
+    numerical one.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        Dataframe with a feature containing the label in string format.
+    column_name : str
+        Name of the feature to use in the dataframe as label.
+
+    Returns
+    -------
+    data : pd.DataFrame
+        Dataframe with the encoded label in an additional column 'label'. If
+        the original columns label is already named 'label', we rename both
+        columns 'label_str' and 'label_num'.
+    encoder : sklearn.preprocessing.LabelEncoder
+        Fitted encoder to encode of decode a label.
+    classes : List[str]
+        List of the classes to keep and encode.
+
+    """
+    # get classes to use
+    classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
+               "polarized"]
+
+    # fit a label encoder
+    encoder = LabelEncoder()
+    encoder.fit(classes)
+
+    # filter rows
+    query = "{0} in {1}".format(column_name, str(classes))
+    data = data.query(query)
+
+    # encode labels
+    if column_name == "label":
+        data = data.assign(
+            label_str=data.loc[:, column_name],
+            label_num=encoder.transform(data.loc[:, column_name]))
+    else:
+        data = data.assign(
+            label=encoder.transform(data.loc[:, column_name]))
+
+    return data, encoder, classes
+
+
+def _encode_label_all(data, column_name):
+    """Encode all the classes from a string format to a numerical one.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        Dataframe with a feature containing the label in string format.
+    column_name : str
+        Name of the feature to use in the dataframe as label.
+
+    Returns
+    -------
+    data : pd.DataFrame
+        Dataframe with the encoded label in an additional column 'label'. If
+        the original columns label is already named 'label', we rename both
+        columns 'label_str' and 'label_num'.
+    encoder : sklearn.preprocessing.LabelEncoder
+        Fitted encoder to encode of decode a label.
+    classes : List[str]
+        List of the classes to keep and encode.
+
+    """
+    # get classes to use
+    classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
+               "polarized", "cell3D", "nuc3D"]
+
+    # fit a label encoder
+    encoder = LabelEncoder()
+    encoder.fit(classes)
+
+    # filter rows
+    query = "{0} in {1}".format(column_name, str(classes))
+    data = data.query(query)
+
+    # encode labels
+    if column_name == "label":
+        data = data.assign(
+            label_str=data.loc[:, column_name],
+            label_num=encoder.transform(data.loc[:, column_name]))
+    else:
+        data = data.assign(
+            label=encoder.transform(data.loc[:, column_name]))
+
+    return data, encoder, classes
+
+
 # ### Build images ###
 
 def build_input_image(data, id_cell, channels="normal", input_shape=None,
diff --git a/python_scripts/isbi_2019/2d_pattern_classification.py b/python_scripts/2d_pattern_classification.py
similarity index 96%
rename from python_scripts/isbi_2019/2d_pattern_classification.py
rename to python_scripts/2d_pattern_classification.py
index 22df4503..d04aad3e 100644
--- a/python_scripts/isbi_2019/2d_pattern_classification.py
+++ b/python_scripts/2d_pattern_classification.py
@@ -11,8 +11,6 @@
 import bigfish.stack as stack
 import bigfish.classification as classification
 
-from .utils import encode_labels
-
 # TODO build tensorflow from source to avoid the next line
 # Your CPU supports instructions that this TensorFlow binary was not compiled
 # to use: AVX2 FMA
@@ -81,9 +79,9 @@
     print("Shape input dataframe (before preparation): {0}".format(df.shape))
 
     # prepare data
-    df, encoder, classes = encode_labels(df,
-                                         column_name="pattern_name",
-                                         classes_to_analyse="all")
+    df, encoder, classes = stack.encode_labels(df,
+                                               column_name="pattern_name",
+                                               classes_to_analyse="all")
     nb_classes = len(classes)
     print("Number of classes: {0}".format(nb_classes))
     print("Classes: {0}".format(classes))
diff --git a/python_scripts/__init_.py b/python_scripts/__init_.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/python_scripts/isbi_2019/__init__.py b/python_scripts/isbi_2019/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/python_scripts/isbi_2019/utils.py b/python_scripts/utils.py
similarity index 100%
rename from python_scripts/isbi_2019/utils.py
rename to python_scripts/utils.py

From 0f576fe0f1ec4e69bf6b5f0ebb2c01c3e14c1891 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 10:39:42 +0200
Subject: [PATCH 091/264] fix encode labels

---
 python_scripts/2d_pattern_classification.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python_scripts/2d_pattern_classification.py b/python_scripts/2d_pattern_classification.py
index d04aad3e..17cba526 100644
--- a/python_scripts/2d_pattern_classification.py
+++ b/python_scripts/2d_pattern_classification.py
@@ -81,7 +81,7 @@
     # prepare data
     df, encoder, classes = stack.encode_labels(df,
                                                column_name="pattern_name",
-                                               classes_to_analyse="all")
+                                               classes_to_analyse=args.classes)
     nb_classes = len(classes)
     print("Number of classes: {0}".format(nb_classes))
     print("Classes: {0}".format(classes))

From 1c6660ad9add0a54b28a1160882066c74a5d56b3 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 21:27:38 +0200
Subject: [PATCH 092/264] fix feature layers and generator epoch count

---
 bigfish/plot/plot_classification.py |  0
 bigfish/stack/preparation.py        | 58 ++++++++++++++++++++++++++---
 2 files changed, 52 insertions(+), 6 deletions(-)
 create mode 100644 bigfish/plot/plot_classification.py

diff --git a/bigfish/plot/plot_classification.py b/bigfish/plot/plot_classification.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 2c9f53e0..c6618488 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -16,6 +16,8 @@
                          cast_img_float64)
 
 from skimage.transform import resize
+from skimage.morphology.selem import square
+from skimage.morphology import binary_dilation
 from scipy.sparse import coo_matrix
 from sklearn.preprocessing import LabelEncoder
 
@@ -267,6 +269,17 @@ def _encode_label_all(data, column_name):
     return data, encoder, classes
 
 
+def get_map_label(data, column_num="label", columns_str="pattern_name"):
+    label_num = list(set(data.loc[:, column_num]))
+    label_str = list(set(data.loc[:, columns_str]))
+    d = {}
+    for i, label_num_ in enumerate(label_num):
+        label_str_ = label_str[i]
+        d[label_str_] = label_num
+
+    return d
+
+
 # ### Build images ###
 
 def build_input_image(data, id_cell, channels="normal", input_shape=None,
@@ -459,10 +472,17 @@ def get_distance_layers(cyt, nuc):
         A 2-d tensor with shape (x, y) showing distance to the nucleus border.
 
     """
+    # compute surfaces from cytoplasm and nucleus
+    mask_cyt, mask_nuc = get_surface_layers(cyt, nuc)
+    mask_cyt = mask_cyt.astype(np.bool)
+    mask_nuc = mask_nuc.astype(np.bool)
+
+    # case where the initial boundary is too fragmented to return a volume
+    if mask_cyt.sum() * mask_nuc.sum() == 0:
+        return np.zeros_like(cyt), np.zeros_like(nuc)
+
     # compute distances from cytoplasm and nucleus
-    mask_cyt = ndi.binary_fill_holes(cyt)
-    mask_nuc = ndi.binary_fill_holes(nuc)
-    distance_cyt = ndi.distance_transform_edt(ndi.binary_fill_holes(cyt))
+    distance_cyt = ndi.distance_transform_edt(mask_cyt)
     distance_nuc_ = ndi.distance_transform_edt(~mask_nuc)
     distance_nuc = mask_cyt * distance_nuc_
 
@@ -476,6 +496,10 @@ def get_distance_layers(cyt, nuc):
 def get_surface_layers(cyt, nuc):
     """Compute plain surface layers as input for the model.
 
+    Sometimes the border is too fragmented to compute the surface. In this
+    case, we iteratively apply a dilatation filter (with an increasing kernel
+    size) until the boundary is properly connected the boundaries.
+
     Parameters
     ----------
     cyt : np.ndarray, np.float32
@@ -496,6 +520,28 @@ def get_surface_layers(cyt, nuc):
     surface_cyt = ndi.binary_fill_holes(cyt)
     surface_nuc = ndi.binary_fill_holes(nuc)
 
+    # check if we need to dilate the border
+    if np.array_equal(surface_cyt, cyt) or np.array_equal(surface_nuc, nuc):
+        # we dilate the surface until the boundaries are fully connected and
+        # we can return a plain surface (we apply at most three rounds of
+        # dilatation, each time with a larger kernel size)
+        for kernel_size in [2, 3, 4]:
+            kernel = square(kernel_size, dtype=np.float32)
+            cyt = binary_dilation(cyt, selem=kernel).astype(np.float32)
+            nuc = binary_dilation(nuc, selem=kernel).astype(np.float32)
+            surface_cyt = ndi.binary_fill_holes(cyt)
+            surface_nuc = ndi.binary_fill_holes(nuc)
+
+            if (not np.array_equal(surface_cyt, cyt)
+                    and not np.array_equal(surface_nuc, nuc)):
+                # cast to np.float32
+                surface_cyt = cast_img_float32(surface_cyt)
+                surface_nuc = cast_img_float32(surface_nuc)
+
+                return surface_cyt, surface_nuc
+
+        return np.zeros_like(cyt), np.zeros_like(nuc)
+
     # cast to np.float32
     surface_cyt = cast_img_float32(surface_cyt)
     surface_nuc = cast_img_float32(surface_nuc)
@@ -666,12 +712,13 @@ def __next__(self):
     def _next(self):
         # we reach the end of an epoch
         if self.i_batch == self.nb_batch_per_epoch:
+            self.i_epoch += 1
 
             # the generator loop over the data indefinitely
             if self.nb_epoch_max is None:
+                # TODO find something better
                 if self.i_epoch == 500:
                     raise StopIteration
-                self.i_epoch += 1
                 self.i_batch = 0
                 self.indices = self._get_shuffled_indices()
                 return self._next()
@@ -679,7 +726,6 @@ def _next(self):
             # we start a new epoch
             elif (self.nb_epoch_max is not None
                   and self.i_epoch < self.nb_epoch_max):
-                self.i_epoch += 1
                 self.i_batch = 0
                 self.indices = self._get_shuffled_indices()
                 return self._next()
@@ -823,7 +869,7 @@ def generate_images(data, method, batch_size, input_shape, augmentation,
             yield batch_data
 
 
-def build_batch(data, indices, method="normal", input_shape=(224, 244),
+def build_batch(data, indices, method="normal", input_shape=(224, 224),
                 augmentation=True, with_label=False, nb_classes=9):
     """Build a batch of data.
 

From e6be4d868e0c442bee01d3a3722787b2a4241089 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 21:28:05 +0200
Subject: [PATCH 093/264] add map for the label encoding

---
 bigfish/stack/__init__.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 2115c0e5..ebe2a29d 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -18,7 +18,7 @@
                           get_distance_layers, get_surface_layers,
                           build_input_image, resize_image, build_batch,
                           generate_images, get_label, one_hot_label, Generator,
-                          encode_labels)
+                          encode_labels, get_map_label)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
 
@@ -62,4 +62,5 @@
            "get_label",
            "one_hot_label",
            "Generator",
-           "encode_labels"]
+           "encode_labels",
+           "get_map_label"]

From 860ad551fc71581d9a26fd150395761439006b0f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 21:29:32 +0200
Subject: [PATCH 094/264] fix early stopping

---
 bigfish/classification/squeezenet.py | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index fbcb98dc..84b13af9 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -33,6 +33,7 @@
 # TODO add logging routines
 # TODO add cache routines
 # TODO manage multiprocessing
+# TODO improve logging
 # ### 2D models ###
 
 class SqueezeNet0(BaseModel):
@@ -72,11 +73,12 @@ def fit(self, train_data, train_label, validation_data, validation_label,
                 verbose=1)
             callbacks.append(cp_callback)
 
+        # TODO debug early stopping
         # define early stopping
         early_stop = EarlyStopping(
-            monitor='val_categorical_accuracy',
+            monitor="val_acc",
             min_delta=0,
-            patience=3,
+            patience=5,
             verbose=1,
             baseline=0.9)
         callbacks.append(early_stop)
@@ -176,12 +178,13 @@ def predict_probability(self, data):
         return probability
 
     def predict_generator(self, generator, return_probability=False,
-                          nb_workers=1, multiprocessing=False):
+                          nb_workers=1, multiprocessing=False, verbose=0):
         # compute probabilities
         probability = self.predict_probability_generator(
             generator=generator,
             nb_workers=nb_workers,
-            multiprocessing=multiprocessing)
+            multiprocessing=multiprocessing,
+            verbose=verbose)
 
         # make prediction
         prediction = np.argmax(probability, axis=-1)
@@ -192,7 +195,7 @@ def predict_generator(self, generator, return_probability=False,
             return prediction
 
     def predict_probability_generator(self, generator, nb_workers=1,
-                                      multiprocessing=False):
+                                      multiprocessing=False, verbose=0):
         # TODO add multiprocessing
         # compute probabilities
         probability = self.model.predict_generator(
@@ -200,7 +203,8 @@ def predict_probability_generator(self, generator, nb_workers=1,
             steps=generator.nb_batch_per_epoch,
             workers=nb_workers,
             max_queue_size=1,
-            use_multiprocessing=multiprocessing)
+            use_multiprocessing=multiprocessing,
+            verbose=verbose)
 
         return probability
 

From 0f4b4fdb1adeb738dfd98baf0aa6947ca2526ce4 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 21:30:14 +0200
Subject: [PATCH 095/264] add projection 2d plot and confusion matrix plot

---
 bigfish/plot/__init__.py            |   6 +-
 bigfish/plot/plot_classification.py | 132 ++++++++++++++++++++++++++++
 2 files changed, 136 insertions(+), 2 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index 506c9a14..711620c9 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -9,7 +9,7 @@
                           plot_illumination_surface)
 from .plot_coordinates import (plot_volume, plot_rna, plot_distribution_rna,
                                plot_cell_coordinates, plot_layers_coordinates)
-
+from .plot_classification import plot_confusion_matrix, plot_2d_projection
 
 __all__ = ["plot_yx",
            "plot_images",
@@ -22,4 +22,6 @@
            "plot_rna",
            "plot_distribution_rna",
            "plot_cell_coordinates",
-           "plot_layers_coordinates"]
+           "plot_layers_coordinates",
+           "plot_confusion_matrix",
+           "plot_2d_projection"]
diff --git a/bigfish/plot/plot_classification.py b/bigfish/plot/plot_classification.py
index e69de29b..3471d4ef 100644
--- a/bigfish/plot/plot_classification.py
+++ b/bigfish/plot/plot_classification.py
@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions to plot results from classification model.
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+from .utils import save_plot
+
+from sklearn.metrics import confusion_matrix
+
+
+def plot_confusion_matrix(y_true, y_pred, normalize=False, classes_num=None,
+                          classes_str=None, title=None, framesize=(8, 8),
+                          path_output=None, ext="png"):
+    """
+
+    Parameters
+    ----------
+    y_true
+    y_pred
+    normalize
+    classes_num
+    classes_str
+    title
+    framesize
+    path_output
+    ext
+
+    Returns
+    -------
+
+    """
+    # TODO add documentation
+    # compute confusion matrix
+    cm = confusion_matrix(y_true=y_true, y_pred=y_pred, labels=classes_num)
+
+    # normalize confusion matrix
+    if normalize:
+        cm = cm.astype(np.float32)
+        mask = (cm != 0)
+        cm = np.divide(cm, cm.sum(axis=1)[:, np.newaxis],
+                       out=np.zeros_like(cm),
+                       where=mask)
+
+    # plot confusion matrix and colorbar
+    fig, ax = plt.subplots(figsize=framesize)
+    frame = ax.imshow(cm, interpolation='nearest', cmap=plt.get_cmap("Blues"))
+    colorbar = ax.figure.colorbar(frame, ax=ax, fraction=0.0453, pad=0.05)
+    if normalize:
+        colorbar.ax.set_ylabel("Density", rotation=-90, va="bottom",
+                               fontweight="bold", fontsize=10)
+    else:
+        colorbar.ax.set_ylabel("Frequency", rotation=-90, va="bottom",
+                               fontweight="bold", fontsize=10)
+    # cax = divider.append_axes("right", size=width, pad=pad)
+
+    # set ticks
+    ax.set_xticks(np.arange(cm.shape[1]))
+    ax.set_yticks(np.arange(cm.shape[0]))
+    ax.set_xticks(np.arange(cm.shape[1] + 1) - .5, minor=True)
+    ax.set_yticks(np.arange(cm.shape[0] + 1) - .5, minor=True)
+    ax.grid(which="minor", color="white", linestyle='-', linewidth=3)
+    ax.tick_params(which="minor", bottom=False, left=False)
+    if classes_str is not None:
+        ax.set_xticklabels(classes_str, rotation=45, ha="right",
+                           rotation_mode="anchor", fontsize=10)
+        ax.set_yticklabels(classes_str, fontsize=10)
+    if title is not None:
+        ax.set_title(title, fontweight="bold", fontsize=20)
+    ax.set_xlabel("Predicted label", fontweight="bold", fontsize=15)
+    ax.set_ylabel("True label", fontweight="bold", fontsize=15)
+
+    # text annotations in the matrix
+    fmt = '.2f' if normalize else 'd'
+    threshold = np.nanmax(cm) / 2.
+    for i in range(cm.shape[0]):
+        for j in range(cm.shape[1]):
+            ax.text(j, i, format(cm[i, j], fmt), fontsize=8,
+                    ha="center", va="center",
+                    color="white" if cm[i, j] > threshold else "black")
+
+    fig.tight_layout()
+    save_plot(path_output, ext)
+    fig.show()
+
+    return
+
+
+def plot_2d_projection(x, y, labels_num, labels_str, colors, markers=None,
+                       title=None, framesize=(8, 8), path_output=None,
+                       ext="png"):
+    """
+
+    Parameters
+    ----------
+    x
+    y
+    labels_num
+    labels_str
+    colors
+    markers
+    title
+    framesize
+    path_output
+    ext
+
+    Returns
+    -------
+
+    """
+    # TODO add documentation
+    # define markers
+    if markers is None:
+        markers = ["."] * len(labels_str)
+
+    # plot
+    plt.figure(figsize=framesize)
+    for i, label_num in enumerate(labels_num):
+        plt.scatter(x[y == label_num, 0], x[y == label_num, 1],
+                    s=30, c=colors[i], label=labels_str[i], marker=markers[i])
+    if title is not None:
+        plt.title(title, fontweight="bold", fontsize=20)
+    plt.xlabel("First component", fontweight="bold", fontsize=15)
+    plt.ylabel("Second component", fontweight="bold", fontsize=15)
+    plt.legend(prop={'size': 10})
+    plt.tight_layout()
+    save_plot(path_output, ext)
+    plt.show()
+
+    return

From e25136808bf49aabeefa416047d7256386608888 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 4 Apr 2019 23:42:10 +0200
Subject: [PATCH 096/264] fix early stopping

---
 bigfish/classification/squeezenet.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 84b13af9..8e4def0f 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -132,9 +132,9 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs,
 
         # define early stopping
         early_stop = EarlyStopping(
-            monitor='val_categorical_accuracy',
+            monitor='val_acc',
             min_delta=0,
-            patience=3,
+            patience=5,
             verbose=1,
             baseline=0.9)
         callbacks.append(early_stop)

From f681f370ae496fdc559213acf536b4acf93d259d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Apr 2019 09:26:01 +0200
Subject: [PATCH 097/264] remove useless functions

---
 bigfish/stack/__init__.py    |  3 +-
 bigfish/stack/preparation.py | 93 ------------------------------------
 2 files changed, 1 insertion(+), 95 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index ebe2a29d..f3ff7bd4 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,7 +17,7 @@
                           get_coordinates, from_coord_to_image,
                           get_distance_layers, get_surface_layers,
                           build_input_image, resize_image, build_batch,
-                          generate_images, get_label, one_hot_label, Generator,
+                          get_label, one_hot_label, Generator,
                           encode_labels, get_map_label)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
@@ -58,7 +58,6 @@
            "resize_image",
            "augment",
            "build_batch",
-           "generate_images",
            "get_label",
            "one_hot_label",
            "Generator",
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index c6618488..9eb6c757 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -635,32 +635,6 @@ def get_label(data, id_cell):
 
 # ### Generator ###
 
-class ThreadSafeIter:
-    """Takes an iterator/generator and makes it thread-safe by
-    serializing call to the `next` method of given iterator/generator.
-    https://gist.github.com/platdrag/e755f3947552804c42633a99ffd325d4
-    """
-    def __init__(self, it):
-        self.it = it
-        self.lock = threading.Lock()
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        with self.lock:
-            return self.it.__next__()
-
-
-def threadsafe_generator(f):
-    """A decorator that takes a generator function and makes it thread-safe.
-    """
-    def g(*a, **kw):
-        return ThreadSafeIter(f(*a, **kw))
-
-    return g
-
-
 class Generator:
 
     # TODO add documentation
@@ -802,73 +776,6 @@ def reset(self):
         self.i_epoch = 0
 
 
-def generate_images(data, method, batch_size, input_shape, augmentation,
-                    with_label, nb_classes):
-    """Generate batches of images.
-
-    Parameters
-    ----------
-    data : pandas.DataFrame
-        Dataframe with the data.
-    method : str
-        Channels used in the input image.
-            - 'normal' for (rna, cyt, nuc)
-            - 'distance' for (rna, distance_cyt, distance_nuc)
-            - 'surface' for (rna, surface_cyt, surface_nuc)
-    batch_size : int
-        Size of the batch.
-    input_shape : Tuple[int]
-        Shape of the input image.
-    augmentation : bool
-        Apply a random operator on the image.
-    with_label : bool
-        Return label of the image as well.
-    nb_classes : int
-        Number of different classes available.
-
-    Returns
-    -------
-    batch_data: np.ndarray, np.float32
-        Tensor with shape (batch_size, x, y, 3).
-    batch_label : np.ndarray, np.int64
-        Tensor of the encoded label, with shape (batch_size,)
-
-    """
-    # TODO make it loop indefinitely
-    # shuffle input data and get their indices
-    input_indices_ordered = list(data.index)
-    np.random.shuffle(input_indices_ordered)
-    nb_samples = len(input_indices_ordered)
-
-    # compute the number of batches to generate for the entire epoch
-    if nb_samples % batch_size == 0:
-        nb_batch = len(input_indices_ordered) // batch_size
-    else:
-        # the last batch can be smaller
-        nb_batch = (len(input_indices_ordered) // batch_size) + 1
-
-    # build batches
-    for i_batch in range(nb_batch):
-        start_index = i_batch * batch_size
-        end_index = min((i_batch + 1) * batch_size, nb_samples)
-        indices_batch = input_indices_ordered[start_index:end_index]
-
-        # return batch with label
-        if with_label:
-            batch_data, batch_label = build_batch(data, indices_batch, method,
-                                                  input_shape, augmentation,
-                                                  with_label, nb_classes)
-
-            yield batch_data, batch_label
-
-        # return batch without label
-        else:
-            batch_data = build_batch(data, indices_batch, method, input_shape,
-                                     augmentation, with_label, nb_classes)
-
-            yield batch_data
-
-
 def build_batch(data, indices, method="normal", input_shape=(224, 224),
                 augmentation=True, with_label=False, nb_classes=9):
     """Build a batch of data.

From e5bfdccbda988700ae00a478b230cf79693bf63b Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Apr 2019 12:06:52 +0200
Subject: [PATCH 098/264] fix early stopping (again)

---
 bigfish/classification/squeezenet.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 8e4def0f..ee628078 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -76,7 +76,7 @@ def fit(self, train_data, train_label, validation_data, validation_label,
         # TODO debug early stopping
         # define early stopping
         early_stop = EarlyStopping(
-            monitor="val_acc",
+            monitor="val_categorical_accuracy",
             min_delta=0,
             patience=5,
             verbose=1,
@@ -132,7 +132,7 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs,
 
         # define early stopping
         early_stop = EarlyStopping(
-            monitor='val_acc',
+            monitor='val_categorical_accuracy',
             min_delta=0,
             patience=5,
             verbose=1,

From ef7d6cbf8d4a50e5c8bb5f45c689f794435e737c Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Apr 2019 12:11:42 +0200
Subject: [PATCH 099/264] improve features generation (constant scale) for
 simulated data

---
 bigfish/stack/preparation.py                | 111 ++++++++++++++++++--
 python_scripts/2d_pattern_classification.py |  11 +-
 2 files changed, 112 insertions(+), 10 deletions(-)

diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 9eb6c757..6e8712fd 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -333,12 +333,59 @@ def build_input_image(data, id_cell, channels="normal", input_shape=None,
                          "must be 'normal', 'distance' or 'surface'."
                          .format(channels))
 
+    # apply augmentation
     if augmentation:
         image = augment(image)
 
     return image
 
 
+def build_input_image_precomputed(data, id_cell, channels="normal",
+                                  input_shape=None, augmentation=False,
+                                  precomputed_features=None):
+    # TODO improve the resizing of different channels
+    # TODO add documentation
+    # build rna image from coordinates data
+    rna = build_rna_2d(data, id_cell)
+    rna = resize_image(rna, new_shape=input_shape, binary=True)
+
+    # get precomputed features
+    id_cell = data.loc[id_cell, "cell_ID"]
+    cyt, nuc = precomputed_features[id_cell]
+
+    # build the required input image
+    image = np.stack((rna, cyt, nuc), axis=-1)
+    if channels not in ["normal", "distance", "surface"]:
+        raise ValueError("{0} is an invalid value for parameter 'channels': "
+                         "must be 'normal', 'distance' or 'surface'."
+                         .format(channels))
+
+    # apply augmentation
+    if augmentation:
+        image = augment(image)
+
+    return image
+
+
+def build_rna_2d(data, id_cell):
+    # TODO add documentation
+    # get coordinates
+    cyt_coord, _, rna_coord = get_coordinates(data, id_cell)
+
+    # TODO manage the case where different spots meet at different heights,
+    #  but same xy localization
+    # build the dense representation for the rna if available
+    max_x = cyt_coord[:, 0].max() + 5
+    max_y = cyt_coord[:, 1].max() + 5
+    values = [1] * rna_coord.shape[0]
+    rna = coo_matrix((values, (rna_coord[:, 0], rna_coord[:, 1])),
+                     shape=(max_x, max_y))
+    rna = (rna > 0)
+    rna = cast_img_float32(rna.todense())
+
+    return rna
+
+
 def build_cell_2d(data, id_cell):
     """Build 2-d images from data coordinates.
 
@@ -641,7 +688,8 @@ class Generator:
     # TODO check threading.Lock()
     # TODO add classes
     def __init__(self, data, method, batch_size, input_shape, augmentation,
-                 with_label, nb_classes, nb_epoch_max=10, shuffle=True):
+                 with_label, nb_classes, nb_epoch_max=10, shuffle=True,
+                 precompute_features=False):
         # make generator threadsafe
         self.lock = threading.Lock()
 
@@ -655,6 +703,7 @@ def __init__(self, data, method, batch_size, input_shape, augmentation,
         self.nb_classes = nb_classes
         self.nb_epoch_max = nb_epoch_max
         self.shuffle = shuffle
+        self.precompute_features = precompute_features
 
         # initialize generator
         self.nb_samples = self.data.shape[0]
@@ -663,6 +712,13 @@ def __init__(self, data, method, batch_size, input_shape, augmentation,
         self.i_batch = 0
         self.i_epoch = 0
 
+        # precompute feature if necessary
+        if self.precompute_features and "cell_ID" in self.data.columns:
+            unique_cells = list(set(self.data.loc[:, "cell_ID"]))
+            self.precomputed_features = self._precompute_features(unique_cells)
+        else:
+            self.precomputed_features = None
+
     def __len__(self):
         if self.nb_epoch_max is None:
             raise ValueError("This generator loops indefinitely over the "
@@ -751,7 +807,8 @@ def _build_batch(self, i_batch):
                 input_shape=self.input_shape,
                 augmentation=self.augmentation,
                 with_label=self.with_label,
-                nb_classes=self.nb_classes)
+                nb_classes=self.nb_classes,
+                precomputed_features=self.precomputed_features)
 
             return batch_data, batch_label
 
@@ -764,10 +821,35 @@ def _build_batch(self, i_batch):
                 input_shape=self.input_shape,
                 augmentation=self.augmentation,
                 with_label=self.with_label,
-                nb_classes=self.nb_classes)
+                nb_classes=self.nb_classes,
+                precomputed_features=self.precomputed_features)
 
             return batch_data
 
+    def _precompute_features(self, unique_cells):
+        """
+
+        Parameters
+        ----------
+        unique_cells
+
+        Returns
+        -------
+
+        """
+        # TODO add documentation
+        # get a sample for each instance of cell
+        d_features = {}
+        for cell in unique_cells:
+            df_cell = self.data.loc[self.data.cell_ID == cell, :]
+            cell_ref_if = df_cell.index[0]
+            image_ref = build_input_image(self.data, cell_ref_if,
+                                          channels=self.method,
+                                          input_shape=self.input_shape)
+            d_features[cell] = (image_ref[:, :, 1], image_ref[:, :, 2])
+
+        return d_features
+
     def reset(self):
         # initialize generator
         self.indices = self._get_shuffled_indices()
@@ -776,8 +858,10 @@ def reset(self):
         self.i_epoch = 0
 
 
+# TODO try to fully vectorize this step
 def build_batch(data, indices, method="normal", input_shape=(224, 224),
-                augmentation=True, with_label=False, nb_classes=9):
+                augmentation=True, with_label=False, nb_classes=9,
+                precomputed_features=None):
     """Build a batch of data.
 
     Parameters
@@ -799,6 +883,12 @@ def build_batch(data, indices, method="normal", input_shape=(224, 224),
         Return label of the image as well.
     nb_classes : int
         Number of different classes available.
+    precomputed_features : dict
+        Some datasets are simulated from a small limited set of background
+        cells (cytoplasm and nucleus). In this case, we can precompute and keep
+        in memory the related features layers in order to dramatically speed
+        up the program. this dict associate the id of the reference cells to
+        their computed features layers (cytoplasm, nucleus).
 
     Returns
     -------
@@ -808,7 +898,6 @@ def build_batch(data, indices, method="normal", input_shape=(224, 224),
         Tensor of the encoded label, with shape (batch_size,)
 
     """
-    # TODO try to fully vectorize this step
     # initialize the batch
     batch_size = len(indices)
     batch_data = np.zeros((batch_size, input_shape[0], input_shape[1], 3),
@@ -817,8 +906,16 @@ def build_batch(data, indices, method="normal", input_shape=(224, 224),
     # build each input image of the batch
     for i in range(batch_size):
         id_cell = indices[i]
-        image = build_input_image(data, id_cell, method, input_shape,
-                                  augmentation)
+
+        # use precomputed features if available
+        if precomputed_features is None:
+            image = build_input_image(data, id_cell, method, input_shape,
+                                      augmentation)
+        else:
+            image = build_input_image_precomputed(data, id_cell, method,
+                                                  input_shape, augmentation,
+                                                  precomputed_features)
+
         batch_data[i] = image
 
     # return images with one-hot labels
diff --git a/python_scripts/2d_pattern_classification.py b/python_scripts/2d_pattern_classification.py
index 17cba526..92b44620 100644
--- a/python_scripts/2d_pattern_classification.py
+++ b/python_scripts/2d_pattern_classification.py
@@ -106,7 +106,9 @@
         augmentation=True,
         with_label=True,
         nb_classes=nb_classes,
-        nb_epoch_max=None)
+        nb_epoch_max=None,
+        shuffle=True,
+        precompute_features=True)
     print("Number of train batches per epoch: {0}"
           .format(train_generator.nb_batch_per_epoch))
 
@@ -119,7 +121,9 @@
         augmentation=False,
         with_label=True,
         nb_classes=nb_classes,
-        nb_epoch_max=None)
+        nb_epoch_max=None,
+        shuffle=True,
+        precompute_features=True)
     print("Number of validation batches per epoch: {0}"
           .format(validation_generator.nb_batch_per_epoch))
 
@@ -133,7 +137,8 @@
         with_label=True,
         nb_classes=nb_classes,
         nb_epoch_max=None,
-        shuffle=False)
+        shuffle=False,
+        precompute_features=True)
     print("Number of test batches per epoch: {0}"
           .format(test_generator.nb_batch_per_epoch))
     print()

From 4f095abf3b64bbf2e54b295ae0cd14705c5a03e1 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Apr 2019 17:07:50 +0200
Subject: [PATCH 100/264] use 'polygon_perimeter' to build surface layer

---
 bigfish/stack/preparation.py | 37 +++++++++++-------------------------
 1 file changed, 11 insertions(+), 26 deletions(-)

diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 6e8712fd..bd63d5dc 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -18,6 +18,7 @@
 from skimage.transform import resize
 from skimage.morphology.selem import square
 from skimage.morphology import binary_dilation
+from skimage.draw import polygon_perimeter
 from scipy.sparse import coo_matrix
 from sklearn.preprocessing import LabelEncoder
 
@@ -443,6 +444,16 @@ def get_coordinates(data, id_cell):
     rna = data.loc[id_cell, "RNA_pos"]
     rna = np.array(rna, dtype=np.int64)
 
+    # complete cytoplasm and nucleus coordinates
+    cyt_x, cyt_y = polygon_perimeter(cyt[:, 0], cyt[:, 1])
+    cyt_x = cyt_x[:, np.newaxis]
+    cyt_y = cyt_y[:, np.newaxis]
+    cyt = np.concatenate((cyt_x, cyt_y), axis=-1)
+    nuc_x, nuc_y = polygon_perimeter(nuc[:, 0], nuc[:, 1])
+    nuc_x = nuc_x[:, np.newaxis]
+    nuc_y = nuc_y[:, np.newaxis]
+    nuc = np.concatenate((nuc_x, nuc_y), axis=-1)
+
     return cyt, nuc, rna
 
 
@@ -524,10 +535,6 @@ def get_distance_layers(cyt, nuc):
     mask_cyt = mask_cyt.astype(np.bool)
     mask_nuc = mask_nuc.astype(np.bool)
 
-    # case where the initial boundary is too fragmented to return a volume
-    if mask_cyt.sum() * mask_nuc.sum() == 0:
-        return np.zeros_like(cyt), np.zeros_like(nuc)
-
     # compute distances from cytoplasm and nucleus
     distance_cyt = ndi.distance_transform_edt(mask_cyt)
     distance_nuc_ = ndi.distance_transform_edt(~mask_nuc)
@@ -567,28 +574,6 @@ def get_surface_layers(cyt, nuc):
     surface_cyt = ndi.binary_fill_holes(cyt)
     surface_nuc = ndi.binary_fill_holes(nuc)
 
-    # check if we need to dilate the border
-    if np.array_equal(surface_cyt, cyt) or np.array_equal(surface_nuc, nuc):
-        # we dilate the surface until the boundaries are fully connected and
-        # we can return a plain surface (we apply at most three rounds of
-        # dilatation, each time with a larger kernel size)
-        for kernel_size in [2, 3, 4]:
-            kernel = square(kernel_size, dtype=np.float32)
-            cyt = binary_dilation(cyt, selem=kernel).astype(np.float32)
-            nuc = binary_dilation(nuc, selem=kernel).astype(np.float32)
-            surface_cyt = ndi.binary_fill_holes(cyt)
-            surface_nuc = ndi.binary_fill_holes(nuc)
-
-            if (not np.array_equal(surface_cyt, cyt)
-                    and not np.array_equal(surface_nuc, nuc)):
-                # cast to np.float32
-                surface_cyt = cast_img_float32(surface_cyt)
-                surface_nuc = cast_img_float32(surface_nuc)
-
-                return surface_cyt, surface_nuc
-
-        return np.zeros_like(cyt), np.zeros_like(nuc)
-
     # cast to np.float32
     surface_cyt = cast_img_float32(surface_cyt)
     surface_nuc = cast_img_float32(surface_nuc)

From 4f3c3c614e6b60a708a83dea67bc16a2322fdb2c Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Apr 2019 20:48:54 +0200
Subject: [PATCH 101/264] improve resizing

---
 bigfish/stack/__init__.py    |  4 +-
 bigfish/stack/preparation.py | 85 ++++++++++++++++++++++--------------
 2 files changed, 55 insertions(+), 34 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index f3ff7bd4..17ad5dae 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -5,7 +5,7 @@
 build stack of images.
 """
 
-from .loader import read_tif, read_pickle
+from .loader import read_tif, read_pickle, read_cell_json, read_rna_json
 from .preprocess import (build_stack, check_recipe, build_simulated_dataset,
                          projection, rescale, cast_img_uint8, cast_img_uint16,
                          log_filter, mean_filter, median_filter,
@@ -25,6 +25,8 @@
 
 __all__ = ["read_tif",
            "read_pickle",
+           "read_cell_json",
+           "read_rna_json",
            "build_simulated_dataset",
            "load_stack",
            "build_stack",
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index bd63d5dc..c2576dd1 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -16,8 +16,6 @@
                          cast_img_float64)
 
 from skimage.transform import resize
-from skimage.morphology.selem import square
-from skimage.morphology import binary_dilation
 from skimage.draw import polygon_perimeter
 from scipy.sparse import coo_matrix
 from sklearn.preprocessing import LabelEncoder
@@ -313,22 +311,28 @@ def build_input_image(data, id_cell, channels="normal", input_shape=None,
     """
     # TODO improve the resizing of different channels
     # build image from coordinates data
-    cyt, nuc, rna = build_cell_2d(data, id_cell)
+    cyt_coord, nuc_coord, rna_coord = get_coordinates(data, id_cell)
+    cyt, nuc, _ = from_coord_to_image(cyt_coord, nuc_coord)
+
+    # build rna directly with the right shape
+    rna = _build_resize_rna(rna_coord, cyt.shape, input_shape)
 
     # build the required input image
     if channels == "normal":
+        # TODO improve resizing using 'polynom_delimeter'
+        cyt = resize_image(cyt, new_shape=input_shape, binary=True)
+        nuc = resize_image(nuc, new_shape=input_shape, binary=True)
         image = np.stack((rna, cyt, nuc), axis=-1)
-        image = resize_image(image, new_shape=input_shape, binary=True)
-    elif channels == "distance":
-        distance_cyt, distance_nuc = get_distance_layers(cyt, nuc)
-        rna = resize_image(rna, new_shape=input_shape, binary=True)
-        distance_cyt = resize_image(distance_cyt, new_shape=input_shape)
-        distance_nuc = resize_image(distance_nuc, new_shape=input_shape)
-        image = np.stack((rna, distance_cyt, distance_nuc), axis=-1)
     elif channels == "surface":
-        surface_cyt, surface_nuc = get_surface_layers(cyt, nuc)
-        image = np.stack((rna, surface_cyt, surface_nuc), axis=-1)
-        image = resize_image(image, new_shape=input_shape, binary=True)
+        cyt, nuc = get_surface_layers(cyt, nuc)
+        cyt = resize_image(cyt, new_shape=input_shape, binary=True)
+        nuc = resize_image(nuc, new_shape=input_shape, binary=True)
+        image = np.stack((rna, cyt, nuc), axis=-1)
+    elif channels == "distance":
+        cyt, nuc = get_distance_layers(cyt, nuc)
+        cyt = resize_image(cyt, new_shape=input_shape, binary=False)
+        nuc = resize_image(nuc, new_shape=input_shape, binary=False)
+        image = np.stack((rna, cyt, nuc), axis=-1)
     else:
         raise ValueError("{0} is an invalid value for parameter 'channels': "
                          "must be 'normal', 'distance' or 'surface'."
@@ -347,8 +351,11 @@ def build_input_image_precomputed(data, id_cell, channels="normal",
     # TODO improve the resizing of different channels
     # TODO add documentation
     # build rna image from coordinates data
-    rna = build_rna_2d(data, id_cell)
-    rna = resize_image(rna, new_shape=input_shape, binary=True)
+    cyt_coord, nuc_coord, rna_coord = get_coordinates(data, id_cell)
+    cyt, nuc, _ = from_coord_to_image(cyt_coord, nuc_coord)
+    rna = _build_resize_rna(rna_coord, cyt.shape, input_shape)
+    if channels == "distance":
+        rna = cast_img_float32(rna)
 
     # get precomputed features
     id_cell = data.loc[id_cell, "cell_ID"]
@@ -368,19 +375,32 @@ def build_input_image_precomputed(data, id_cell, channels="normal",
     return image
 
 
-def build_rna_2d(data, id_cell):
+def _build_resize_rna(rna_coord, current_shape, resized_shape):
+    """
+
+    Parameters
+    ----------
+    rna_coord
+    current_shape
+    resized_shape
+
+    Returns
+    -------
+
+    """
     # TODO add documentation
-    # get coordinates
-    cyt_coord, _, rna_coord = get_coordinates(data, id_cell)
+    # compute resizing factor
+    delta_x = resized_shape[0] / current_shape[0]
+    delta_y = resized_shape[1] / current_shape[1]
+    factor = np.array([delta_x, delta_y, 1])[np.newaxis, :]
 
-    # TODO manage the case where different spots meet at different heights,
-    #  but same xy localization
-    # build the dense representation for the rna if available
-    max_x = cyt_coord[:, 0].max() + 5
-    max_y = cyt_coord[:, 1].max() + 5
+    # resize coordinates directly
+    rna_coord = np.round(rna_coord * factor)
+
+    # build rna image
     values = [1] * rna_coord.shape[0]
     rna = coo_matrix((values, (rna_coord[:, 0], rna_coord[:, 1])),
-                     shape=(max_x, max_y))
+                     shape=resized_shape)
     rna = (rna > 0)
     rna = cast_img_float32(rna.todense())
 
@@ -388,7 +408,7 @@ def build_rna_2d(data, id_cell):
 
 
 def build_cell_2d(data, id_cell):
-    """Build 2-d images from data coordinates.
+    """Build 2-d images from data coordinates, without resizing.
 
     Parameters
     ----------
@@ -496,7 +516,7 @@ def from_coord_to_image(cyt_coord, nuc_coord, rna_coord=None):
     nuc = cast_img_float32(nuc.todense())
 
     if rna_coord is None:
-        return cyt, nuc
+        return cyt, nuc, None
 
     else:
         # TODO manage the case where different spots meet at different heights,
@@ -615,18 +635,17 @@ def resize_image(image, new_shape=None, binary=False):
     # resize
     image_dtype = image.dtype
     if binary:
-        # TODO use 'order=1' then binarize the image and reduce connected
-        #  component.
         image_output = resize(image, new_shape,
-                              anti_aliasing=False,
                               mode="constant",
-                              cval=0)
-        image_output = (image_output > 0)
+                              cval=0,
+                              order=0,
+                              anti_aliasing=False)
     else:
         image_output = resize(image, new_shape,
-                              anti_aliasing=True,
                               mode="constant",
-                              cval=0)
+                              cval=0,
+                              order=1,
+                              anti_aliasing=False)
 
     # cast the image in the original dtype
     if image_dtype == np.bool:

From 343677dfeff185d75fab3b3bf98286b5badda1de Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 6 Apr 2019 15:48:33 +0200
Subject: [PATCH 102/264] dramatically improve image building

---
 bigfish/stack/__init__.py    |  17 +-
 bigfish/stack/preparation.py | 418 +++++++++++++----------------------
 2 files changed, 155 insertions(+), 280 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 17ad5dae..94ce7a57 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -13,12 +13,9 @@
                          gaussian_filter, build_stacks, cast_img_float32,
                          cast_img_float64, compute_illumination_surface,
                          correct_illumination_surface, clean_simulated_data)
-from .preparation import (split_from_background, build_cell_2d,
-                          get_coordinates, from_coord_to_image,
-                          get_distance_layers, get_surface_layers,
-                          build_input_image, resize_image, build_batch,
-                          get_label, one_hot_label, Generator,
-                          encode_labels, get_map_label)
+from .preparation import (split_from_background, build_image, get_coordinates,
+                          get_distance_layers, get_surface_layers, build_batch,
+                          get_label, Generator, encode_labels, get_map_label)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
 
@@ -50,18 +47,14 @@
            "correct_illumination_surface",
            "clean_simulated_data",
            "split_from_background",
-           "build_cell_2d",
            "get_coordinates",
-           "from_coord_to_image",
            "get_distance_layers",
            "get_surface_layers",
-           "build_input_image",
            "check_range_value",
-           "resize_image",
            "augment",
            "build_batch",
            "get_label",
-           "one_hot_label",
            "Generator",
            "encode_labels",
-           "get_map_label"]
+           "get_map_label",
+           "build_image"]
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index c2576dd1..929cdc79 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -11,13 +11,9 @@
 from scipy import ndimage as ndi
 
 from .augmentation import augment
-from .utils import check_array
-from .preprocess import (cast_img_uint8, cast_img_uint16, cast_img_float32,
-                         cast_img_float64)
+from .preprocess import cast_img_float32
 
-from skimage.transform import resize
 from skimage.draw import polygon_perimeter
-from scipy.sparse import coo_matrix
 from sklearn.preprocessing import LabelEncoder
 
 
@@ -281,81 +277,85 @@ def get_map_label(data, column_num="label", columns_str="pattern_name"):
 
 # ### Build images ###
 
-def build_input_image(data, id_cell, channels="normal", input_shape=None,
-                      augmentation=False):
+def build_image(data, id_cell, image_shape=None, coord_refinement=True,
+                method="normal", augmentation=False):
     """
 
     Parameters
     ----------
-    data : pandas.DataFrame
-        Dataframe with the data.
-    id_cell : int
-        Index of the targeted cell.
-    channels : str
-        channels used in the input image.
-            - 'normal' for (rna, cyt, nuc)
-            - 'distance' for (rna, distance_cyt, distance_nuc)
-            - 'surface' for (rna, surface_cyt, surface_nuc)
-    input_shape : Tuple[int]
-        Shape of the input image.
-    augmentation : bool
-        Apply a random operator on the image.
+    data
+    id_cell
+    image_shape
+    coord_refinement
+    method
+    augmentation
 
     Returns
     -------
-    image : np.ndarray, np.float32
-        A 3-d tensor with shape (x, y, channels). Values are normalized between
-        0 and 1 (binaries values are unchanged and float values are rescaled
-        according to their original dtype).
 
     """
-    # TODO improve the resizing of different channels
-    # build image from coordinates data
-    cyt_coord, nuc_coord, rna_coord = get_coordinates(data, id_cell)
-    cyt, nuc, _ = from_coord_to_image(cyt_coord, nuc_coord)
-
-    # build rna directly with the right shape
-    rna = _build_resize_rna(rna_coord, cyt.shape, input_shape)
-
-    # build the required input image
-    if channels == "normal":
-        # TODO improve resizing using 'polynom_delimeter'
-        cyt = resize_image(cyt, new_shape=input_shape, binary=True)
-        nuc = resize_image(nuc, new_shape=input_shape, binary=True)
-        image = np.stack((rna, cyt, nuc), axis=-1)
-    elif channels == "surface":
+    # TODO add documentation
+    # TODO add sanity check for precomputation
+    # get coordinates
+    rna_coord, cyt_coord, nuc_coord = get_coordinates(data, id_cell,
+                                                      image_shape,
+                                                      coord_refinement)
+
+    # build matrices
+    if image_shape is None:
+        max_x = cyt_coord[:, 0].max() + 5
+        max_y = cyt_coord[:, 1].max() + 5
+        image_shape = (max_x, max_y)
+    rna = np.zeros(image_shape, dtype=np.float32)
+    rna[rna_coord[:, 0], rna_coord[:, 1]] = 1.0
+    cyt = np.zeros(image_shape, dtype=np.float32)
+    cyt[cyt_coord[:, 0], cyt_coord[:, 1]] = 1.0
+    nuc = np.zeros(image_shape, dtype=np.float32)
+    nuc[nuc_coord[:, 0], nuc_coord[:, 1]] = 1.0
+
+    # get features
+    if method == "normal":
+        pass
+    elif method == "surface":
         cyt, nuc = get_surface_layers(cyt, nuc)
-        cyt = resize_image(cyt, new_shape=input_shape, binary=True)
-        nuc = resize_image(nuc, new_shape=input_shape, binary=True)
-        image = np.stack((rna, cyt, nuc), axis=-1)
-    elif channels == "distance":
+    elif method == "distance":
         cyt, nuc = get_distance_layers(cyt, nuc)
-        cyt = resize_image(cyt, new_shape=input_shape, binary=False)
-        nuc = resize_image(nuc, new_shape=input_shape, binary=False)
-        image = np.stack((rna, cyt, nuc), axis=-1)
     else:
-        raise ValueError("{0} is an invalid value for parameter 'channels': "
-                         "must be 'normal', 'distance' or 'surface'."
-                         .format(channels))
+        raise ValueError(
+            "{0} is an invalid value for parameter 'channels': must be "
+            "'normal', 'distance' or 'surface'.".format(method))
 
-    # apply augmentation
+    # stack image
+    image = np.stack((rna, cyt, nuc), axis=-1)
+
+    # augment
     if augmentation:
         image = augment(image)
 
     return image
 
 
-def build_input_image_precomputed(data, id_cell, channels="normal",
-                                  input_shape=None, augmentation=False,
-                                  precomputed_features=None):
-    # TODO improve the resizing of different channels
+def build_image_precomputed(data, id_cell, image_shape=None,
+                            precomputed_features=None, augmentation=False):
+    """
+
+    Parameters
+    ----------
+    data
+    id_cell
+    image_shape
+    precomputed_features
+    augmentation
+
+    Returns
+    -------
+
+    """
     # TODO add documentation
+    # TODO add sanity check for precomputation
+
     # build rna image from coordinates data
-    cyt_coord, nuc_coord, rna_coord = get_coordinates(data, id_cell)
-    cyt, nuc, _ = from_coord_to_image(cyt_coord, nuc_coord)
-    rna = _build_resize_rna(rna_coord, cyt.shape, input_shape)
-    if channels == "distance":
-        rna = cast_img_float32(rna)
+    rna = _build_rna(data, id_cell, image_shape)
 
     # get precomputed features
     id_cell = data.loc[id_cell, "cell_ID"]
@@ -363,10 +363,6 @@ def build_input_image_precomputed(data, id_cell, channels="normal",
 
     # build the required input image
     image = np.stack((rna, cyt, nuc), axis=-1)
-    if channels not in ["normal", "distance", "surface"]:
-        raise ValueError("{0} is an invalid value for parameter 'channels': "
-                         "must be 'normal', 'distance' or 'surface'."
-                         .format(channels))
 
     # apply augmentation
     if augmentation:
@@ -375,160 +371,98 @@ def build_input_image_precomputed(data, id_cell, channels="normal",
     return image
 
 
-def _build_resize_rna(rna_coord, current_shape, resized_shape):
-    """
+def _build_rna(data, id_cell, output_shape=None):
+    # TODO add documentation
+    # TODO check if 'polygone_perimeter' changes the input shape
+    # get coordinates
+    rna_coord = data.loc[id_cell, "RNA_pos"]
+    rna_coord = np.array(rna_coord, dtype=np.int64)
 
-    Parameters
-    ----------
-    rna_coord
-    current_shape
-    resized_shape
+    # get current shape
+    cyt_coord = data.loc[id_cell, "pos_cell"]
+    cyt_coord = np.array(cyt_coord, dtype=np.int64)
+    max_x = cyt_coord[:, 0].max() + 5
+    max_y = cyt_coord[:, 1].max() + 5
+    input_shape = (max_x, max_y)
 
-    Returns
-    -------
+    if output_shape is not None:
+        # compute resizing factor
+        factor = _compute_resizing_factor(input_shape, output_shape)
 
-    """
-    # TODO add documentation
-    # compute resizing factor
-    delta_x = resized_shape[0] / current_shape[0]
-    delta_y = resized_shape[1] / current_shape[1]
-    factor = np.array([delta_x, delta_y, 1])[np.newaxis, :]
+        # resize coordinates directly
+        rna_coord = _resize_coord(rna_coord, factor)
 
-    # resize coordinates directly
-    rna_coord = np.round(rna_coord * factor)
+    else:
+        output_shape = input_shape
 
     # build rna image
-    values = [1] * rna_coord.shape[0]
-    rna = coo_matrix((values, (rna_coord[:, 0], rna_coord[:, 1])),
-                     shape=resized_shape)
-    rna = (rna > 0)
-    rna = cast_img_float32(rna.todense())
+    rna = np.zeros(output_shape, dtype=np.float32)
+    rna[rna_coord[:, 0], rna_coord[:, 1]] = 1.0
 
     return rna
 
 
-def build_cell_2d(data, id_cell):
-    """Build 2-d images from data coordinates, without resizing.
-
-    Parameters
-    ----------
-    data : pandas.DataFrame
-        Dataframe with the data.
-    id_cell : int
-        Index of the targeted cell.
-
-    Returns
-    -------
-    cyt : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
-    nuc : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
-    rna : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
-
+def get_coordinates(data, id_cell, output_shape=None, coord_refinement=True):
     """
-    # get coordinates
-    cyt_coord, nuc_coord, rna_coord = get_coordinates(data, id_cell)
-
-    # build 2d images
-    cyt, nuc, rna = from_coord_to_image(cyt_coord, nuc_coord, rna_coord)
-
-    return cyt, nuc, rna
-
-
-def get_coordinates(data, id_cell):
-    """Get the coordinates a specific cell.
 
     Parameters
     ----------
-    data : pandas.DataFrame
-        Dataframe with the data.
-    id_cell : int
-        Index of the targeted cell.
+    data
+    id_cell
+    output_shape
+    coord_refinement
 
     Returns
     -------
-    cyt : np.ndarray, np.int64
-        Cytoplasm coordinates with shape (x, y).
-    nuc : np.ndarray, np.int64
-        Nucleus coordinates with shape (x, y).
-    rna : np.ndarray, np.int64
-        RNA spots coordinates with shape (x, y, z).
 
     """
+    # TODO add documentation
     # get coordinates
-    cyt = data.loc[id_cell, "pos_cell"]
-    cyt = np.array(cyt, dtype=np.int64)
-    nuc = data.loc[id_cell, "pos_nuc"]
-    nuc = np.array(nuc, dtype=np.int64)
-    rna = data.loc[id_cell, "RNA_pos"]
-    rna = np.array(rna, dtype=np.int64)
+    rna_coord = data.loc[id_cell, "RNA_pos"]
+    rna_coord = np.array(rna_coord, dtype=np.int64)
+    cyt_coord = data.loc[id_cell, "pos_cell"]
+    cyt_coord = np.array(cyt_coord, dtype=np.int64)
+    nuc_coord = data.loc[id_cell, "pos_nuc"]
+    nuc_coord = np.array(nuc_coord, dtype=np.int64)
+
+    # resize coordinates
+    if output_shape is not None:
+        max_x = cyt_coord[:, 0].max() + 5
+        max_y = cyt_coord[:, 1].max() + 5
+        input_shape = (max_x, max_y)
+        factor = _compute_resizing_factor(input_shape, output_shape)
+        rna_coord = _resize_coord(rna_coord, factor)
+        cyt_coord = _resize_coord(cyt_coord, factor[:, :2])
+        nuc_coord = _resize_coord(nuc_coord, factor[:, :2])
 
     # complete cytoplasm and nucleus coordinates
-    cyt_x, cyt_y = polygon_perimeter(cyt[:, 0], cyt[:, 1])
-    cyt_x = cyt_x[:, np.newaxis]
-    cyt_y = cyt_y[:, np.newaxis]
-    cyt = np.concatenate((cyt_x, cyt_y), axis=-1)
-    nuc_x, nuc_y = polygon_perimeter(nuc[:, 0], nuc[:, 1])
-    nuc_x = nuc_x[:, np.newaxis]
-    nuc_y = nuc_y[:, np.newaxis]
-    nuc = np.concatenate((nuc_x, nuc_y), axis=-1)
+    if coord_refinement:
+        cyt_x, cyt_y = polygon_perimeter(cyt_coord[:, 0], cyt_coord[:, 1])
+        cyt_x = cyt_x[:, np.newaxis]
+        cyt_y = cyt_y[:, np.newaxis]
+        cyt_coord = np.concatenate((cyt_x, cyt_y), axis=-1)
+        nuc_x, nuc_y = polygon_perimeter(nuc_coord[:, 0], nuc_coord[:, 1])
+        nuc_x = nuc_x[:, np.newaxis]
+        nuc_y = nuc_y[:, np.newaxis]
+        nuc_coord = np.concatenate((nuc_x, nuc_y), axis=-1)
 
-    return cyt, nuc, rna
+    return rna_coord, cyt_coord, nuc_coord
 
 
-def from_coord_to_image(cyt_coord, nuc_coord, rna_coord=None):
-    """Build 2-d images from the coordinates data.
+def _compute_resizing_factor(input_shape, output_shape):
+    # compute factor
+    delta_x = output_shape[0] / input_shape[0]
+    delta_y = output_shape[1] / input_shape[1]
+    factor = np.array([delta_x, delta_y, 1], dtype=np.float32)[np.newaxis, :]
 
-    Parameters
-    ----------
-    cyt_coord : np.ndarray, np.int64
-        Cytoplasm coordinates in 2-d with shape (x, y).
-    nuc_coord : np.ndarray, np.int64
-        Nucleus coordinates in 2-d with shape (x, y).
-    rna_coord : np.ndarray, np.int64
-        RNA spots coordinates in 3-d with shape (x, y, z).
+    return factor
 
-    Returns
-    -------
-    cyt : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
-    nuc : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
-    rna : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
 
-    """
-    # build the dense representation for the cytoplasm
-    values = [1] * cyt_coord.shape[0]
-    max_x = cyt_coord[:, 0].max() + 5
-    max_y = cyt_coord[:, 1].max() + 5
-    cyt = coo_matrix((values, (cyt_coord[:, 0], cyt_coord[:, 1])),
-                     shape=(max_x, max_y))
-    cyt = (cyt > 0)
-    cyt = cast_img_float32(cyt.todense())
-
-    # build the dense representation for the nucleus
-    values = [1] * nuc_coord.shape[0]
-    nuc = coo_matrix((values, (nuc_coord[:, 0], nuc_coord[:, 1])),
-                     shape=(max_x, max_y))
-    nuc = (nuc > 0)
-    nuc = cast_img_float32(nuc.todense())
-
-    if rna_coord is None:
-        return cyt, nuc, None
-
-    else:
-        # TODO manage the case where different spots meet at different heights,
-        #  but same xy localization
-        # build the dense representation for the rna if available
-        values = [1] * rna_coord.shape[0]
-        rna = coo_matrix((values, (rna_coord[:, 0], rna_coord[:, 1])),
-                         shape=(max_x, max_y))
-        rna = (rna > 0)
-        rna = cast_img_float32(rna.todense())
+def _resize_coord(coord, factor):
+    # resize coordinates directly
+    coord = np.round(coord * factor).astype(np.int64)
 
-        return cyt, nuc, rna
+    return coord
 
 
 def get_distance_layers(cyt, nuc):
@@ -601,67 +535,6 @@ def get_surface_layers(cyt, nuc):
     return surface_cyt, surface_nuc
 
 
-def resize_image(image, new_shape=None, binary=False):
-    """Resize image.
-
-    If the size is decreased, the image is downsampled using a mean filter. If
-    the shape is increased, new pixels' values are interpolated using spline
-    method.
-
-    Parameters
-    ----------
-    image : np.ndarray
-        Image the resize with shape (y, x) or (y, x, channel).
-    new_shape : Tuple[int]
-        Spatial shape used for input images.
-    binary : bool
-        Keep binaries values after the resizing.
-
-    Returns
-    -------
-    image_output : np.ndarray
-        Resized image with shape (new_y, new_x) or (new_y, new_x, channel).
-
-    """
-    # check image dtype
-    check_array(image, dtype=[np.uint8, np.uint16,
-                              np.float32, np.float64,
-                              np.bool])
-
-    # get default output_shape
-    if new_shape is None:
-        return image
-
-    # resize
-    image_dtype = image.dtype
-    if binary:
-        image_output = resize(image, new_shape,
-                              mode="constant",
-                              cval=0,
-                              order=0,
-                              anti_aliasing=False)
-    else:
-        image_output = resize(image, new_shape,
-                              mode="constant",
-                              cval=0,
-                              order=1,
-                              anti_aliasing=False)
-
-    # cast the image in the original dtype
-    if image_dtype == np.bool:
-        image_output = (image_output > 0)
-    elif image_dtype == np.uint8:
-        image_output = cast_img_uint8(image_output)
-    elif image_dtype == np.uint16:
-        image_output = cast_img_uint16(image_output)
-    elif image_dtype == np.float32:
-        image_output = cast_img_float32(image_output)
-    elif image_dtype == np.float64:
-        image_output = cast_img_float64(image_output)
-
-    return image_output
-
-
 def get_label(data, id_cell):
     """Get the label of a specific cell.
 
@@ -846,10 +719,13 @@ def _precompute_features(self, unique_cells):
         d_features = {}
         for cell in unique_cells:
             df_cell = self.data.loc[self.data.cell_ID == cell, :]
-            cell_ref_if = df_cell.index[0]
-            image_ref = build_input_image(self.data, cell_ref_if,
-                                          channels=self.method,
-                                          input_shape=self.input_shape)
+            id_cell = df_cell.index[0]
+            image_ref = build_image(
+                self.data, id_cell,
+                image_shape=self.input_shape,
+                coord_refinement=True,
+                method=self.method,
+                augmentation=False)
             d_features[cell] = (image_ref[:, :, 1], image_ref[:, :, 2])
 
         return d_features
@@ -908,24 +784,30 @@ def build_batch(data, indices, method="normal", input_shape=(224, 224),
                           dtype=np.float32)
 
     # build each input image of the batch
-    for i in range(batch_size):
-        id_cell = indices[i]
-
-        # use precomputed features if available
-        if precomputed_features is None:
-            image = build_input_image(data, id_cell, method, input_shape,
-                                      augmentation)
-        else:
-            image = build_input_image_precomputed(data, id_cell, method,
-                                                  input_shape, augmentation,
-                                                  precomputed_features)
-
-        batch_data[i] = image
+    if precomputed_features is None:
+        for i in range(batch_size):
+            id_cell = indices[i]
+            image = build_image(
+                data, id_cell,
+                image_shape=input_shape,
+                coord_refinement=True,
+                method=method,
+                augmentation=augmentation)
+            batch_data[i] = image
+    else:
+        for i in range(batch_size):
+            id_cell = indices[i]
+            image = build_image_precomputed(
+                data, id_cell,
+                image_shape=input_shape,
+                precomputed_features=precomputed_features,
+                augmentation=augmentation)
+            batch_data[i] = image
 
     # return images with one-hot labels
     if with_label:
         labels = np.array(data.loc[indices, "label"], dtype=np.int64)
-        batch_label = one_hot_label(labels, nb_classes)
+        batch_label = _one_hot_label(labels, nb_classes)
 
         return batch_data, batch_label
 
@@ -935,7 +817,7 @@ def build_batch(data, indices, method="normal", input_shape=(224, 224),
         return batch_data
 
 
-def one_hot_label(labels, nb_classes):
+def _one_hot_label(labels, nb_classes):
     """Binarize labels in a one-vs-all fashion.
 
     Parameters

From a43391554407ec1845546878156b95180e224fdc Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 6 Apr 2019 16:27:30 +0200
Subject: [PATCH 103/264] add size parameters for classification plots

---
 bigfish/plot/plot_classification.py | 83 ++++++++++-------------------
 1 file changed, 29 insertions(+), 54 deletions(-)

diff --git a/bigfish/plot/plot_classification.py b/bigfish/plot/plot_classification.py
index 3471d4ef..c0ac2b8a 100644
--- a/bigfish/plot/plot_classification.py
+++ b/bigfish/plot/plot_classification.py
@@ -13,25 +13,8 @@
 
 def plot_confusion_matrix(y_true, y_pred, normalize=False, classes_num=None,
                           classes_str=None, title=None, framesize=(8, 8),
-                          path_output=None, ext="png"):
-    """
-
-    Parameters
-    ----------
-    y_true
-    y_pred
-    normalize
-    classes_num
-    classes_str
-    title
-    framesize
-    path_output
-    ext
-
-    Returns
-    -------
-
-    """
+                          size_title=20, size_axes=15, path_output=None,
+                          ext="png"):
     # TODO add documentation
     # compute confusion matrix
     cm = confusion_matrix(y_true=y_true, y_pred=y_pred, labels=classes_num)
@@ -44,16 +27,18 @@ def plot_confusion_matrix(y_true, y_pred, normalize=False, classes_num=None,
                        out=np.zeros_like(cm),
                        where=mask)
 
-    # plot confusion matrix and colorbar
+    # plot confusion matrix
     fig, ax = plt.subplots(figsize=framesize)
     frame = ax.imshow(cm, interpolation='nearest', cmap=plt.get_cmap("Blues"))
+
+    # colorbar
     colorbar = ax.figure.colorbar(frame, ax=ax, fraction=0.0453, pad=0.05)
     if normalize:
         colorbar.ax.set_ylabel("Density", rotation=-90, va="bottom",
-                               fontweight="bold", fontsize=10)
+                               fontweight="bold", fontsize=size_axes-5)
     else:
         colorbar.ax.set_ylabel("Frequency", rotation=-90, va="bottom",
-                               fontweight="bold", fontsize=10)
+                               fontweight="bold", fontsize=size_axes-5)
     # cax = divider.append_axes("right", size=width, pad=pad)
 
     # set ticks
@@ -65,22 +50,25 @@ def plot_confusion_matrix(y_true, y_pred, normalize=False, classes_num=None,
     ax.tick_params(which="minor", bottom=False, left=False)
     if classes_str is not None:
         ax.set_xticklabels(classes_str, rotation=45, ha="right",
-                           rotation_mode="anchor", fontsize=10)
-        ax.set_yticklabels(classes_str, fontsize=10)
+                           rotation_mode="anchor", fontsize=size_axes-5)
+        ax.set_yticklabels(classes_str, fontsize=size_axes-5)
+
+    # title and axes labels
     if title is not None:
-        ax.set_title(title, fontweight="bold", fontsize=20)
-    ax.set_xlabel("Predicted label", fontweight="bold", fontsize=15)
-    ax.set_ylabel("True label", fontweight="bold", fontsize=15)
+        ax.set_title(title, fontweight="bold", fontsize=size_title)
+    ax.set_xlabel("Predicted label", fontweight="bold", fontsize=size_axes)
+    ax.set_ylabel("True label", fontweight="bold", fontsize=size_axes)
 
     # text annotations in the matrix
     fmt = '.2f' if normalize else 'd'
     threshold = np.nanmax(cm) / 2.
     for i in range(cm.shape[0]):
         for j in range(cm.shape[1]):
-            ax.text(j, i, format(cm[i, j], fmt), fontsize=8,
+            ax.text(j, i, format(cm[i, j], fmt), fontsize=size_axes-7,
                     ha="center", va="center",
                     color="white" if cm[i, j] > threshold else "black")
 
+    # show frame
     fig.tight_layout()
     save_plot(path_output, ext)
     fig.show()
@@ -89,27 +77,9 @@ def plot_confusion_matrix(y_true, y_pred, normalize=False, classes_num=None,
 
 
 def plot_2d_projection(x, y, labels_num, labels_str, colors, markers=None,
-                       title=None, framesize=(8, 8), path_output=None,
-                       ext="png"):
-    """
-
-    Parameters
-    ----------
-    x
-    y
-    labels_num
-    labels_str
-    colors
-    markers
-    title
-    framesize
-    path_output
-    ext
-
-    Returns
-    -------
-
-    """
+                       title=None, framesize=(10, 10), size_data=50, alpha=0.8,
+                       size_title=20, size_axes=15, size_legend=15,
+                       path_output=None, ext="png"):
     # TODO add documentation
     # define markers
     if markers is None:
@@ -119,12 +89,17 @@ def plot_2d_projection(x, y, labels_num, labels_str, colors, markers=None,
     plt.figure(figsize=framesize)
     for i, label_num in enumerate(labels_num):
         plt.scatter(x[y == label_num, 0], x[y == label_num, 1],
-                    s=30, c=colors[i], label=labels_str[i], marker=markers[i])
+                    s=size_data, c=colors[i], label=labels_str[i],
+                    marker=markers[i], alpha=alpha)
+
+    # text annotations
     if title is not None:
-        plt.title(title, fontweight="bold", fontsize=20)
-    plt.xlabel("First component", fontweight="bold", fontsize=15)
-    plt.ylabel("Second component", fontweight="bold", fontsize=15)
-    plt.legend(prop={'size': 10})
+        plt.title(title, fontweight="bold", fontsize=size_title)
+    plt.xlabel("First component", fontweight="bold", fontsize=size_axes)
+    plt.ylabel("Second component", fontweight="bold", fontsize=size_axes)
+    plt.legend(prop={'size': size_legend})
+
+    # show frame
     plt.tight_layout()
     save_plot(path_output, ext)
     plt.show()

From fd8011cf055260c8f5e61de23b94beb4c7acfc08 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 6 Apr 2019 18:34:15 +0200
Subject: [PATCH 104/264] add predictions

---
 python_scripts/2d_pattern_classification.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/python_scripts/2d_pattern_classification.py b/python_scripts/2d_pattern_classification.py
index 92b44620..08243ed9 100644
--- a/python_scripts/2d_pattern_classification.py
+++ b/python_scripts/2d_pattern_classification.py
@@ -8,6 +8,8 @@
 import argparse
 import time
 
+import numpy as np
+
 import bigfish.stack as stack
 import bigfish.classification as classification
 
@@ -187,6 +189,14 @@
     print("Loss test: {0:.3f} | Accuracy test: {1:.3f}"
           .format(loss, 100 * accuracy))
 
+    print("--- PREDICTION ---", "\n")
+
+    # make predictions on the testing dataset
+    test_generator.reset()
+    predictions, probabilities = model.predict_generator(test_generator, True)
+    path = os.path.join(args.log_directory, "test_predictions.npz")
+    np.savez(path, predictions=predictions, probabilities=probabilities)
+
     end_time = time.time()
     duration = int(round((end_time - start_time) / 60))
     print("Duration: {0} minutes.".format(duration))

From bae599c3a430ea1d80377090901831b43b4a7504 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 6 Apr 2019 18:37:36 +0200
Subject: [PATCH 105/264] update early stopping parameters

---
 bigfish/classification/squeezenet.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index ee628078..78a95c73 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -77,7 +77,7 @@ def fit(self, train_data, train_label, validation_data, validation_label,
         # define early stopping
         early_stop = EarlyStopping(
             monitor="val_categorical_accuracy",
-            min_delta=0,
+            min_delta=0.5,
             patience=5,
             verbose=1,
             baseline=0.9)
@@ -133,7 +133,7 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs,
         # define early stopping
         early_stop = EarlyStopping(
             monitor='val_categorical_accuracy',
-            min_delta=0,
+            min_delta=0.5,
             patience=5,
             verbose=1,
             baseline=0.9)

From 69c9f6270def595f3b75a6c99cfd2f14aa704dbc Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sun, 7 Apr 2019 13:04:37 +0200
Subject: [PATCH 106/264] update early stopping

---
 bigfish/classification/squeezenet.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 78a95c73..78e8ac3a 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -77,7 +77,7 @@ def fit(self, train_data, train_label, validation_data, validation_label,
         # define early stopping
         early_stop = EarlyStopping(
             monitor="val_categorical_accuracy",
-            min_delta=0.5,
+            min_delta=0.05,
             patience=5,
             verbose=1,
             baseline=0.9)
@@ -133,7 +133,7 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs,
         # define early stopping
         early_stop = EarlyStopping(
             monitor='val_categorical_accuracy',
-            min_delta=0.5,
+            min_delta=0.05,
             patience=5,
             verbose=1,
             baseline=0.9)

From 640831917c107c2a73b372cf55cf19967c701a09 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 8 Apr 2019 12:46:00 +0200
Subject: [PATCH 107/264] update early stopping #2

---
 bigfish/classification/squeezenet.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 78e8ac3a..9abbb163 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -77,9 +77,9 @@ def fit(self, train_data, train_label, validation_data, validation_label,
         # define early stopping
         early_stop = EarlyStopping(
             monitor="val_categorical_accuracy",
-            min_delta=0.05,
+            min_delta=0,
             patience=5,
-            verbose=1,
+            verbose=2,
             baseline=0.9)
         callbacks.append(early_stop)
 
@@ -133,9 +133,9 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs,
         # define early stopping
         early_stop = EarlyStopping(
             monitor='val_categorical_accuracy',
-            min_delta=0.05,
+            min_delta=0,
             patience=5,
-            verbose=1,
+            verbose=2,
             baseline=0.9)
         callbacks.append(early_stop)
 

From 35a3b298d25c449a56602e631e25d7a9aff8a2be Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 8 Apr 2019 21:23:40 +0200
Subject: [PATCH 108/264] add 'get_feature_map'

---
 bigfish/classification/squeezenet.py | 39 ++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 9abbb163..20527739 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -16,12 +16,14 @@
 """
 
 import os
+import warnings
 
 import tensorflow as tf
 import numpy as np
 
 from .base import BaseModel, get_optimizer
 
+from tensorflow.python.keras.backend import function, learning_phase
 from tensorflow.python.keras.models import Model
 from tensorflow.python.keras.callbacks import ModelCheckpoint, EarlyStopping
 from tensorflow.python.keras.layers import (Conv2D, Concatenate, MaxPooling2D,
@@ -297,6 +299,43 @@ def save_training_history(self):
 
         return
 
+    def get_feature_map(self, generator, after_average_pooling=True):
+        # TODO add documentation
+        # TODO ask generator without label
+        # check generator
+        label_back = False
+        if generator.with_label:
+            warnings.warn("Label is disabled from generator during the "
+                          "computation of the feature map.")
+            generator.with_label = False
+            label_back = True
+
+        # get input layer
+        input_ = self.model.input
+
+        # get embedding layer
+        if after_average_pooling:
+            output_ = self.model.layers[-2].output
+        else:
+            output_ = self.model.layers[-3].output
+
+        # define the steps to compute the feature map
+        features_map = function([input_, learning_phase()], [output_])
+
+        # compute the feature map
+        embedding = [features_map([batch, 0])[0] for batch in generator]
+        embedding = np.array(embedding)
+        embedding = np.concatenate(embedding, axis=0)
+
+        if not after_average_pooling:
+            a, b, c, d = embedding.shape
+            embedding = np.reshape(embedding, (a, b * c * d))
+
+        # reset parameter 'with_label' if necessary
+        generator.with_label = label_back
+
+        return embedding
+
 
 # ### Architecture functions ###
 

From 517a8f5de647efd3ede33fa13bf1b3ff7c159a74 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 8 Apr 2019 21:24:21 +0200
Subject: [PATCH 109/264] add experimental data preprocessing

---
 bigfish/stack/__init__.py    |   9 +-
 bigfish/stack/preparation.py | 269 ++++++++++++++++++-----------------
 2 files changed, 145 insertions(+), 133 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 94ce7a57..c53ec36f 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -15,7 +15,9 @@
                          correct_illumination_surface, clean_simulated_data)
 from .preparation import (split_from_background, build_image, get_coordinates,
                           get_distance_layers, get_surface_layers, build_batch,
-                          get_label, Generator, encode_labels, get_map_label)
+                          get_label, Generator, encode_labels, get_map_label,
+                          format_experimental_data, get_label_encoder,
+                          remove_transcription_site)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
 
@@ -57,4 +59,7 @@
            "Generator",
            "encode_labels",
            "get_map_label",
-           "build_image"]
+           "build_image",
+           "format_experimental_data",
+           "get_label_encoder",
+           "remove_transcription_site"]
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 929cdc79..83d17b0a 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -11,7 +11,7 @@
 from scipy import ndimage as ndi
 
 from .augmentation import augment
-from .preprocess import cast_img_float32
+from .preprocess import cast_img_float32, mean_filter
 
 from skimage.draw import polygon_perimeter
 from sklearn.preprocessing import LabelEncoder
@@ -109,51 +109,8 @@ def encode_labels(data, column_name="pattern_name", classes_to_analyse="all"):
         List of the classes to keep and encode.
 
     """
-    # experimental analysis
-    if classes_to_analyse == "experimental":
-        data, encoder, classes = _encode_label_experimental(data, column_name)
-    # 2-d analysis
-    elif classes_to_analyse == "2d":
-        data, encoder, classes = _encode_label_2d(data, column_name)
-    # complete analysis
-    elif classes_to_analyse == "all":
-        data, encoder, classes = _encode_label_all(data, column_name)
-    else:
-        raise ValueError("'classes_to_analyse' can only take three values: "
-                         "'experimental', '2d' or 'all'.")
-
-    return data, encoder, classes
-
-
-def _encode_label_experimental(data, column_name):
-    """Filter the 5 classes included in the experimental dataset, then encode
-    them from a string format to a numerical one.
-
-    Parameters
-    ----------
-    data : pd.DataFrame
-        Dataframe with a feature containing the label in string format.
-    column_name : str
-        Name of the feature to use in the dataframe as label.
-
-    Returns
-    -------
-    data : pd.DataFrame
-        Dataframe with the encoded label in an additional column 'label'. If
-        the original columns label is already named 'label', we rename both
-        columns 'label_str' and 'label_num'.
-    encoder : sklearn.preprocessing.LabelEncoder
-        Fitted encoder to encode of decode a label.
-    classes : List[str]
-        List of the classes to keep and encode.
-
-    """
-    # get classes to use
-    classes = ["random", "foci", "cellext", "inNUC", "nuc2D"]
-
-    # fit a label encoder
-    encoder = LabelEncoder()
-    encoder.fit(classes)
+    # get label encoder
+    encoder, classes = get_label_encoder(classes_to_analyze=classes_to_analyse)
 
     # filter rows
     query = "{0} in {1}".format(column_name, str(classes))
@@ -171,100 +128,30 @@ def _encode_label_experimental(data, column_name):
     return data, encoder, classes
 
 
-def _encode_label_2d(data, column_name):
-    """Filter the 2-d classes, then encode them from a string format to a
-    numerical one.
-
-    Parameters
-    ----------
-    data : pd.DataFrame
-        Dataframe with a feature containing the label in string format.
-    column_name : str
-        Name of the feature to use in the dataframe as label.
-
-    Returns
-    -------
-    data : pd.DataFrame
-        Dataframe with the encoded label in an additional column 'label'. If
-        the original columns label is already named 'label', we rename both
-        columns 'label_str' and 'label_num'.
-    encoder : sklearn.preprocessing.LabelEncoder
-        Fitted encoder to encode of decode a label.
-    classes : List[str]
-        List of the classes to keep and encode.
-
-    """
-    # get classes to use
-    classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
-               "polarized"]
-
-    # fit a label encoder
-    encoder = LabelEncoder()
-    encoder.fit(classes)
-
-    # filter rows
-    query = "{0} in {1}".format(column_name, str(classes))
-    data = data.query(query)
-
-    # encode labels
-    if column_name == "label":
-        data = data.assign(
-            label_str=data.loc[:, column_name],
-            label_num=encoder.transform(data.loc[:, column_name]))
+def get_label_encoder(classes_to_analyze="all"):
+    # TODO add documentation
+    # get set of classes to analyze
+    if classes_to_analyze == "experimental":
+        classes = ["random", "foci", "cellext", "inNUC", "nuc2D"]
+    elif classes_to_analyze == "2d":
+        classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
+                   "polarized"]
+    elif classes_to_analyze == "all":
+        classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
+                   "polarized", "cell3D", "nuc3D"]
     else:
-        data = data.assign(
-            label=encoder.transform(data.loc[:, column_name]))
-
-    return data, encoder, classes
-
-
-def _encode_label_all(data, column_name):
-    """Encode all the classes from a string format to a numerical one.
-
-    Parameters
-    ----------
-    data : pd.DataFrame
-        Dataframe with a feature containing the label in string format.
-    column_name : str
-        Name of the feature to use in the dataframe as label.
-
-    Returns
-    -------
-    data : pd.DataFrame
-        Dataframe with the encoded label in an additional column 'label'. If
-        the original columns label is already named 'label', we rename both
-        columns 'label_str' and 'label_num'.
-    encoder : sklearn.preprocessing.LabelEncoder
-        Fitted encoder to encode of decode a label.
-    classes : List[str]
-        List of the classes to keep and encode.
-
-    """
-    # get classes to use
-    classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
-               "polarized", "cell3D", "nuc3D"]
+        raise ValueError("'classes_to_analyse' can only take three values: "
+                         "'experimental', '2d' or 'all'.")
 
     # fit a label encoder
     encoder = LabelEncoder()
     encoder.fit(classes)
 
-    # filter rows
-    query = "{0} in {1}".format(column_name, str(classes))
-    data = data.query(query)
-
-    # encode labels
-    if column_name == "label":
-        data = data.assign(
-            label_str=data.loc[:, column_name],
-            label_num=encoder.transform(data.loc[:, column_name]))
-    else:
-        data = data.assign(
-            label=encoder.transform(data.loc[:, column_name]))
-
-    return data, encoder, classes
+    return encoder, classes
 
 
 def get_map_label(data, column_num="label", columns_str="pattern_name"):
+    # TODO add documentation
     label_num = list(set(data.loc[:, column_num]))
     label_str = list(set(data.loc[:, columns_str]))
     d = {}
@@ -484,6 +371,7 @@ def get_distance_layers(cyt, nuc):
         A 2-d tensor with shape (x, y) showing distance to the nucleus border.
 
     """
+    # TODO can return NaN
     # compute surfaces from cytoplasm and nucleus
     mask_cyt, mask_nuc = get_surface_layers(cyt, nuc)
     mask_cyt = mask_cyt.astype(np.bool)
@@ -837,3 +725,122 @@ def _one_hot_label(labels, nb_classes):
     label_one_hot = np.eye(nb_classes, dtype=np.float32)[labels]
 
     return label_one_hot
+
+
+# ### Experimental data ###
+
+def format_experimental_data(data, label_encoder=None):
+    # TODO add documentation
+    # initialize the formatted dataset
+    data_formatted = data.copy(deep=True)
+
+    # format coordinates
+    data_formatted.loc[:, 'pos_cell'] = data_formatted.apply(
+        lambda row: _decompose_experimental_coordinate(row["pos"].T)[0],
+        axis=1)
+    data_formatted.loc[:, 'pos_nuc'] = data_formatted.apply(
+        lambda row: _decompose_experimental_coordinate(row["pos"].T)[1],
+        axis=1)
+    data_formatted.loc[:, 'RNA_pos'] = data_formatted.apply(
+        lambda row: _decompose_experimental_coordinate(row["pos"].T)[2],
+        axis=1)
+
+    # format cell indices
+    data_formatted.loc[:, 'cell_ID'] = data_formatted.index
+
+    # format RNA count
+    data_formatted.loc[:, 'nb_rna'] = data_formatted.apply(
+        lambda row: len(row["RNA_pos"]),
+        axis=1)
+
+    # format label
+    if label_encoder is not None:
+        pattern_level = [None] * data_formatted.shape[0]
+        data_formatted.loc[:, 'pattern_level'] = pattern_level
+        data_formatted.loc[:, 'pattern_name'] = data_formatted.apply(
+            lambda row: _label_experimental_num_to_str_(row["labels"]),
+            axis=1)
+        data_formatted.loc[:, 'label'] = data_formatted.apply(
+            lambda row: label_encoder.transform([row["pattern_name"]])[0],
+            axis=1)
+
+    # remove useless columns
+    if label_encoder is not None:
+        features_to_keep = ['gene', 'pos_nuc', 'pos_cell', 'RNA_pos', 'cell_ID',
+                            'nb_rna', 'pattern_level', 'pattern_name', 'label']
+    else:
+        features_to_keep = ['gene', 'pos_nuc', 'pos_cell', 'RNA_pos',
+                            'cell_ID', 'nb_rna']
+    data_formatted = data_formatted.loc[:, features_to_keep]
+
+    return data_formatted
+
+
+def _decompose_experimental_coordinate(positions):
+    # TODO add documentation
+    # get coordinate for each element of the cell
+    nuc_coord = positions[positions[:, 2] == 0]
+    nuc_coord = nuc_coord[:, :2].astype(np.int64)
+    cyt_coord = positions[positions[:, 2] == 1]
+    cyt_coord = cyt_coord[:, :2].astype(np.int64)
+    rna_coord = positions[positions[:, 2] == 2]
+    rna_coord = rna_coord.astype(np.int64)
+    rna_coord[:, 2] = np.zeros((rna_coord.shape[0],), dtype=np.int64)
+
+    return cyt_coord, nuc_coord, rna_coord
+
+
+def _label_experimental_num_to_str_(label_num):
+    # TODO add documentation
+    if label_num == 1:
+        label_str = "foci"
+    elif label_num == 2:
+        label_str = "cellext"
+    elif label_num == 3:
+        label_str = "inNUC"
+    elif label_num == 4:
+        label_str = "nuc2D"
+    elif label_num == 5:
+        label_str = "random"
+    else:
+        raise ValueError("Label value should be comprised between 1 and 5.")
+
+    return label_str
+
+
+def remove_transcription_site(data):
+    # TODO add documentation
+    data_corrected = data.copy(deep=True)
+    for index, row in data_corrected.iterrows():
+        id_cell = row['cell_ID']
+        image = build_image(data, id_cell,
+                            coord_refinement=True,
+                            method="surface")
+        rna, cyt, nuc = image[:, :, 0], image[:, :, 1], image[:, :, 2]
+        transcription_site = _get_transcription_site(rna, nuc, threshold=0.3)
+        rna[transcription_site > 0] = 0
+        rna_pos = np.vstack(list(np.where(rna)) +
+                            [np.zeros(np.sum(rna).astype(np.int),
+                                      dtype=np.int64)]).T
+        data_corrected.at[index, 'RNA_pos'] = rna_pos
+
+    return data_corrected
+
+
+def _get_transcription_site(rna, nuc, threshold=0.3):
+    # TODO add documentation
+    # count RNA inside the nucleus
+    nb_rna_in_nuc = np.sum(rna[nuc > 0])
+
+    # compute a density map
+    density = nb_rna_in_nuc / nuc.sum()
+    rna_in_nuc = 255 * rna.astype(np.uint8)
+    density_img = mean_filter(rna_in_nuc, kernel_shape="disk", kernel_size=4)
+    density_img = cast_img_float32(density_img)
+
+    # get transcription sites
+    transcription_site = density_img > threshold
+
+    return transcription_site
+
+

From e15d2e945e9bf69665fca9568b19aec7419a24bb Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 8 Apr 2019 21:24:44 +0200
Subject: [PATCH 110/264] fix bug plot coordinate

---
 bigfish/plot/plot_coordinates.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
index a8a993bd..39ee9e02 100644
--- a/bigfish/plot/plot_coordinates.py
+++ b/bigfish/plot/plot_coordinates.py
@@ -182,15 +182,16 @@ def plot_cell_coordinates(data, id_cell, title=None, framesize=(5, 10),
 
     """
     # get the cytoplasm, the nuclei and the rna spots
-    cyt, nuc, rna = stack.get_coordinates(data, id_cell)
+    rna_coord, cyt_coord, nuc_coord = stack.get_coordinates(data, id_cell)
 
     # plot
     plt.figure(figsize=framesize)
     if title is not None:
         plt.title(title, fontweight="bold", fontsize=25)
-    plt.plot(cyt[:, 1], cyt[:, 0], c="black", linewidth=2)
-    plt.plot(nuc[:, 1], nuc[:, 0], c="steelblue", linewidth=2)
-    plt.scatter(rna[:, 1], rna[:, 0], s=25, c="firebrick", marker=".")
+    plt.plot(cyt_coord[:, 1], cyt_coord[:, 0], c="black", linewidth=2)
+    plt.plot(nuc_coord[:, 1], nuc_coord[:, 0], c="steelblue", linewidth=2)
+    plt.scatter(rna_coord[:, 1], rna_coord[:, 0], s=25, c="firebrick",
+                marker=".")
     plt.tight_layout()
     save_plot(path_output, ext)
     plt.show()

From df4669619c1dfa2a4c3252b90dd1584ddf070563 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 9 Apr 2019 09:35:18 +0200
Subject: [PATCH 111/264] add filtering and balancing functions

---
 bigfish/stack/__init__.py    |   6 +-
 bigfish/stack/preparation.py | 113 ++++++++++++++++-----
 python_scripts/utils.py      | 191 -----------------------------------
 3 files changed, 92 insertions(+), 218 deletions(-)
 delete mode 100644 python_scripts/utils.py

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index c53ec36f..277b8d14 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,7 +17,7 @@
                           get_distance_layers, get_surface_layers, build_batch,
                           get_label, Generator, encode_labels, get_map_label,
                           format_experimental_data, get_label_encoder,
-                          remove_transcription_site)
+                          remove_transcription_site, filter_data, balance_data)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
 
@@ -62,4 +62,6 @@
            "build_image",
            "format_experimental_data",
            "get_label_encoder",
-           "remove_transcription_site"]
+           "remove_transcription_site",
+           "filter_data",
+           "balance_data"]
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 83d17b0a..43783feb 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -8,6 +8,7 @@
 import threading
 
 import numpy as np
+import pandas as pd
 from scipy import ndimage as ndi
 
 from .augmentation import augment
@@ -78,6 +79,69 @@ def split_from_background(data, p_validation=0.2, p_test=0.2, logdir=None):
     return data_train, data_validation, data_test
 
 
+# ### Filter data ###
+
+def filter_data(data, proportion_to_exclude=0.2):
+    # TODO add documentation
+
+    if (isinstance(proportion_to_exclude, float)
+            and 0 <= proportion_to_exclude <= 1):
+        p = int(proportion_to_exclude * 10)
+    elif (isinstance(proportion_to_exclude, int)
+          and 0 <= proportion_to_exclude <= 100):
+        p = proportion_to_exclude // 10
+    else:
+        raise ValueError("'proportion' must be a float between 0 and 1 or an "
+                         "integer between 0 and 100.")
+
+    # filter inNUC, nuc2D, cell3D, "cell2D" and nuc3D
+    l = ['p10', 'p20', 'p30', 'p40', 'p50', 'p60', 'p70', 'p80', 'p90', 'p100']
+    level_kept = l[:p]
+    query = "pattern_level not in {0}".format(str(level_kept))
+    data_filtered = data.query(query)
+
+    # filter foci
+    l = ['p50', 'p60', 'p70', 'p80', 'p90', 'p100', 'p110', 'p120', 'p130',
+         'p140', 'p150']
+    level_kept = l[:p]
+    query = "pattern_level not in {0} or pattern_name != 'foci'".format(
+        str(level_kept))
+    data_filtered = data_filtered.query(query)
+
+    # reset index
+    data_filtered.reset_index(drop=True, inplace=True)
+
+    return data_filtered
+
+
+# ### Balance data ###
+
+def balance_data(data, column_to_balance, verbose=0):
+    # TODO add documentation
+    # TODO make it consistent for int values
+    values = list(data.loc[:, column_to_balance].value_counts().index)
+    frequencies = list(data.loc[:, column_to_balance].value_counts())
+
+    max_frequency = max(frequencies)
+    diff_frequency = [max_frequency - frequency for frequency in frequencies]
+
+    for i, value in enumerate(values):
+        n = diff_frequency[i]
+        if verbose > 0:
+            print("add {0} new samples {1} to balance the dataset..."
+                  .format(n, value))
+        df = data.query("{0} == '{1}'".format(column_to_balance, value))
+        df = df.sample(n, replace=True, random_state=13)
+        data = pd.concat([data, df])
+    if verbose > 0:
+        print()
+
+    # reset index
+    data.reset_index(drop=True, inplace=True)
+
+    return data
+
+
 # ### Encode labels ###
 
 def encode_labels(data, column_name="pattern_name", classes_to_analyse="all"):
@@ -125,6 +189,10 @@ def encode_labels(data, column_name="pattern_name", classes_to_analyse="all"):
         data = data.assign(
             label=encoder.transform(data.loc[:, column_name]))
 
+    # reset index
+    data.loc[:, "original_index"] = data.index
+    data.reset_index(drop=True, inplace=True)
+
     return data, encoder, classes
 
 
@@ -808,8 +876,9 @@ def _label_experimental_num_to_str_(label_num):
     return label_str
 
 
-def remove_transcription_site(data):
+def remove_transcription_site(data, threshold):
     # TODO add documentation
+    # TODO vectorize it
     data_corrected = data.copy(deep=True)
     for index, row in data_corrected.iterrows():
         id_cell = row['cell_ID']
@@ -817,30 +886,24 @@ def remove_transcription_site(data):
                             coord_refinement=True,
                             method="surface")
         rna, cyt, nuc = image[:, :, 0], image[:, :, 1], image[:, :, 2]
-        transcription_site = _get_transcription_site(rna, nuc, threshold=0.3)
-        rna[transcription_site > 0] = 0
-        rna_pos = np.vstack(list(np.where(rna)) +
-                            [np.zeros(np.sum(rna).astype(np.int),
-                                      dtype=np.int64)]).T
+
+        rna_in = np.copy(rna)
+        rna_in[nuc == 0] = 0
+        rna_out = np.copy(rna)
+        rna_out[nuc > 0] = 0
+        rna_in = 255 * rna_in.astype(np.uint8)
+        density_img = mean_filter(rna_in, kernel_shape="disk", kernel_size=4)
+        density_img = cast_img_float32(density_img)
+        transcription_site = density_img > threshold
+        rna_in[transcription_site] = 0
+
+        rna = rna_in + rna_out
+
+        rna_pos = np.nonzero(rna)
+        rna_pos = np.column_stack(rna_pos).astype(np.int64)
+        rna_pos = np.concatenate(
+            [rna_pos, np.zeros((rna_pos.shape[0], 1), dtype=np.int64)],
+            axis=1)
         data_corrected.at[index, 'RNA_pos'] = rna_pos
 
     return data_corrected
-
-
-def _get_transcription_site(rna, nuc, threshold=0.3):
-    # TODO add documentation
-    # count RNA inside the nucleus
-    nb_rna_in_nuc = np.sum(rna[nuc > 0])
-
-    # compute a density map
-    density = nb_rna_in_nuc / nuc.sum()
-    rna_in_nuc = 255 * rna.astype(np.uint8)
-    density_img = mean_filter(rna_in_nuc, kernel_shape="disk", kernel_size=4)
-    density_img = cast_img_float32(density_img)
-
-    # get transcription sites
-    transcription_site = density_img > threshold
-
-    return transcription_site
-
-
diff --git a/python_scripts/utils.py b/python_scripts/utils.py
deleted file mode 100644
index ae7c01bc..00000000
--- a/python_scripts/utils.py
+++ /dev/null
@@ -1,191 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-Utility functions.
-"""
-
-from sklearn.preprocessing import LabelEncoder
-
-
-def encode_labels(data, column_name="pattern_name", classes_to_analyse="all"):
-    """Filter classes we want to analyze and encode them from a string format
-    to a numerical one.
-
-    Parameters
-    ----------
-    data : pd.DataFrame
-        Dataframe with a feature containing the label in string format.
-    column_name : str
-        Name of the feature to use in the dataframe as label.
-    classes_to_analyse : str
-        Define the set of classe we want to keep and to encode before training
-        a model:
-        - 'experimental' to fit with the experimental data (5 classes).
-        - '2d' to analyze the 2-d classes only (7 classes).
-        - 'all' to analyze all the classes (9 classes).
-
-    Returns
-    -------
-    data : pd.DataFrame
-        Dataframe with the encoded label in an additional column 'label'. If
-        the original columns label is already named 'label', we rename both
-        columns 'label_str' and 'label_num'.
-    encoder : sklearn.preprocessing.LabelEncoder
-        Fitted encoder to encode of decode a label.
-    classes : List[str]
-        List of the classes to keep and encode.
-
-    """
-    # experimental analysis
-    if classes_to_analyse == "experimental":
-        data, encoder, classes = _encode_label_experimental(data, column_name)
-    # 2-d analysis
-    elif classes_to_analyse == "2d":
-        data, encoder, classes = _encode_label_2d(data, column_name)
-    # complete analysis
-    elif classes_to_analyse == "all":
-        data, encoder, classes = _encode_label_all(data, column_name)
-    else:
-        raise ValueError("'classes_to_analyse' can only take three values: "
-                         "'experimental', '2d' or 'all'.")
-
-    return data, encoder, classes
-
-
-def _encode_label_experimental(data, column_name):
-    """Filter the 5 classes included in the experimental dataset, then encode
-    them from a string format to a numerical one.
-
-    Parameters
-    ----------
-    data : pd.DataFrame
-        Dataframe with a feature containing the label in string format.
-    column_name : str
-        Name of the feature to use in the dataframe as label.
-
-    Returns
-    -------
-    data : pd.DataFrame
-        Dataframe with the encoded label in an additional column 'label'. If
-        the original columns label is already named 'label', we rename both
-        columns 'label_str' and 'label_num'.
-    encoder : sklearn.preprocessing.LabelEncoder
-        Fitted encoder to encode of decode a label.
-    classes : List[str]
-        List of the classes to keep and encode.
-
-    """
-    # get classes to use
-    classes = ["random", "foci", "cellext", "inNUC", "nuc2D"]
-
-    # fit a label encoder
-    encoder = LabelEncoder()
-    encoder.fit(classes)
-
-    # filter rows
-    query = "{0} in {1}".format(column_name, str(classes))
-    data = data.query(query)
-
-    # encode labels
-    if column_name == "label":
-        data = data.assign(
-            label_str=data.loc[:, column_name],
-            label_num=encoder.transform(data.loc[:, column_name]))
-    else:
-        data = data.assign(
-            label=encoder.transform(data.loc[:, column_name]))
-
-    return data, encoder, classes
-
-
-def _encode_label_2d(data, column_name):
-    """Filter the 2-d classes, then encode them from a string format to a
-    numerical one.
-
-    Parameters
-    ----------
-    data : pd.DataFrame
-        Dataframe with a feature containing the label in string format.
-    column_name : str
-        Name of the feature to use in the dataframe as label.
-
-    Returns
-    -------
-    data : pd.DataFrame
-        Dataframe with the encoded label in an additional column 'label'. If
-        the original columns label is already named 'label', we rename both
-        columns 'label_str' and 'label_num'.
-    encoder : sklearn.preprocessing.LabelEncoder
-        Fitted encoder to encode of decode a label.
-    classes : List[str]
-        List of the classes to keep and encode.
-
-    """
-    # get classes to use
-    classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
-               "polarized"]
-
-    # fit a label encoder
-    encoder = LabelEncoder()
-    encoder.fit(classes)
-
-    # filter rows
-    query = "{0} in {1}".format(column_name, str(classes))
-    data = data.query(query)
-
-    # encode labels
-    if column_name == "label":
-        data = data.assign(
-            label_str=data.loc[:, column_name],
-            label_num=encoder.transform(data.loc[:, column_name]))
-    else:
-        data = data.assign(
-            label=encoder.transform(data.loc[:, column_name]))
-
-    return data, encoder, classes
-
-
-def _encode_label_all(data, column_name):
-    """Encode all the classes from a string format to a numerical one.
-
-    Parameters
-    ----------
-    data : pd.DataFrame
-        Dataframe with a feature containing the label in string format.
-    column_name : str
-        Name of the feature to use in the dataframe as label.
-
-    Returns
-    -------
-    data : pd.DataFrame
-        Dataframe with the encoded label in an additional column 'label'. If
-        the original columns label is already named 'label', we rename both
-        columns 'label_str' and 'label_num'.
-    encoder : sklearn.preprocessing.LabelEncoder
-        Fitted encoder to encode of decode a label.
-    classes : List[str]
-        List of the classes to keep and encode.
-
-    """
-    # get classes to use
-    classes = ["random", "foci", "cellext", "inNUC", "nuc2D", "cell2D",
-               "polarized", "cell3D", "nuc3D"]
-
-    # fit a label encoder
-    encoder = LabelEncoder()
-    encoder.fit(classes)
-
-    # filter rows
-    query = "{0} in {1}".format(column_name, str(classes))
-    data = data.query(query)
-
-    # encode labels
-    if column_name == "label":
-        data = data.assign(
-            label_str=data.loc[:, column_name],
-            label_num=encoder.transform(data.loc[:, column_name]))
-    else:
-        data = data.assign(
-            label=encoder.transform(data.loc[:, column_name]))
-
-    return data, encoder, classes

From e37e283dd520f389b22890e46f3d6ee80345dea1 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 9 Apr 2019 09:35:36 +0200
Subject: [PATCH 112/264] add filtering and balancing functions

---
 python_scripts/2d_pattern_classification.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/python_scripts/2d_pattern_classification.py b/python_scripts/2d_pattern_classification.py
index 08243ed9..85e7d27b 100644
--- a/python_scripts/2d_pattern_classification.py
+++ b/python_scripts/2d_pattern_classification.py
@@ -85,6 +85,8 @@
                                                column_name="pattern_name",
                                                classes_to_analyse=args.classes)
     nb_classes = len(classes)
+    df = stack.filter_data(df, proportion_to_exclude=0.2)
+    df = stack.balance_data(df, column_to_balance="pattern_name")
     print("Number of classes: {0}".format(nb_classes))
     print("Classes: {0}".format(classes))
     print("Shape input dataframe (after preparation): {0}".format(df.shape))
@@ -187,7 +189,7 @@
                                               args.multiprocessing,
                                               verbose=0)
     print("Loss test: {0:.3f} | Accuracy test: {1:.3f}"
-          .format(loss, 100 * accuracy))
+          .format(loss, 100 * accuracy), "\n")
 
     print("--- PREDICTION ---", "\n")
 

From b7fa30e6294647b3962651ac71e85e98f33a4fdc Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 9 Apr 2019 17:40:28 +0200
Subject: [PATCH 113/264] update early stopping

---
 bigfish/classification/squeezenet.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 20527739..e8b6ab41 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -81,8 +81,7 @@ def fit(self, train_data, train_label, validation_data, validation_label,
             monitor="val_categorical_accuracy",
             min_delta=0,
             patience=5,
-            verbose=2,
-            baseline=0.9)
+            verbose=2)
         callbacks.append(early_stop)
 
         # fit model
@@ -137,8 +136,7 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs,
             monitor='val_categorical_accuracy',
             min_delta=0,
             patience=5,
-            verbose=2,
-            baseline=0.9)
+            verbose=2)
         callbacks.append(early_stop)
 
         # fit model from generator

From 220476b26afdbe73048cd657db436ef09a42f7ad Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 9 Apr 2019 18:31:24 +0200
Subject: [PATCH 114/264] update early stopping

---
 bigfish/classification/squeezenet.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index e8b6ab41..2357d79d 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -80,7 +80,7 @@ def fit(self, train_data, train_label, validation_data, validation_label,
         early_stop = EarlyStopping(
             monitor="val_categorical_accuracy",
             min_delta=0,
-            patience=5,
+            patience=10,
             verbose=2)
         callbacks.append(early_stop)
 
@@ -135,7 +135,7 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs,
         early_stop = EarlyStopping(
             monitor='val_categorical_accuracy',
             min_delta=0,
-            patience=5,
+            patience=10,
             verbose=2)
         callbacks.append(early_stop)
 

From 732e7eb14b236032ddbaaadae7bbf34ab7626773 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 9 Apr 2019 19:03:49 +0200
Subject: [PATCH 115/264] update early stopping

---
 bigfish/classification/squeezenet.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 2357d79d..e8b6ab41 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -80,7 +80,7 @@ def fit(self, train_data, train_label, validation_data, validation_label,
         early_stop = EarlyStopping(
             monitor="val_categorical_accuracy",
             min_delta=0,
-            patience=10,
+            patience=5,
             verbose=2)
         callbacks.append(early_stop)
 
@@ -135,7 +135,7 @@ def fit_generator(self, train_generator, validation_generator, nb_epochs,
         early_stop = EarlyStopping(
             monitor='val_categorical_accuracy',
             min_delta=0,
-            patience=10,
+            patience=5,
             verbose=2)
         callbacks.append(early_stop)
 

From e63e48f15e018f72409e635b891c7895b3cc0ff0 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 10 Apr 2019 11:40:36 +0200
Subject: [PATCH 116/264] update requirements

---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index 6a408165..e6533271 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,7 +7,7 @@ pip >= 18.1
 scikit-learn >= 0.20.2
 scikit-image >= 0.14.2
 scipy >= 1.2.0
-# tensorflow >= 1.12.0, < 2.0
+tensorflow >= 1.12.0, < 2.0
 matplotlib >= 3.0.2
 pandas >= 0.24.0
 joblib >= 0.13.2

From d6ab9d3897fd79842adb5ce9f944da359359de07 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 10 Apr 2019 11:41:06 +0200
Subject: [PATCH 117/264] add gene encoder

---
 bigfish/stack/__init__.py    |  6 ++++--
 bigfish/stack/preparation.py | 12 +++++++++++-
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 277b8d14..fac2cb5b 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,7 +17,8 @@
                           get_distance_layers, get_surface_layers, build_batch,
                           get_label, Generator, encode_labels, get_map_label,
                           format_experimental_data, get_label_encoder,
-                          remove_transcription_site, filter_data, balance_data)
+                          remove_transcription_site, filter_data, balance_data,
+                          get_gene_encoder)
 from .augmentation import augment
 from .utils import check_array, check_features_df, check_range_value
 
@@ -64,4 +65,5 @@
            "get_label_encoder",
            "remove_transcription_site",
            "filter_data",
-           "balance_data"]
+           "balance_data",
+           "get_gene_encoder"]
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 43783feb..61c3d6fe 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -19,6 +19,7 @@
 
 
 # TODO define the requirements for 'data'
+# TODO add logging
 
 # ### Split data ###
 
@@ -142,7 +143,7 @@ def balance_data(data, column_to_balance, verbose=0):
     return data
 
 
-# ### Encode labels ###
+# ### Encode labels and genes ###
 
 def encode_labels(data, column_name="pattern_name", classes_to_analyse="all"):
     """Filter classes we want to analyze and encode them from a string format
@@ -220,6 +221,7 @@ def get_label_encoder(classes_to_analyze="all"):
 
 def get_map_label(data, column_num="label", columns_str="pattern_name"):
     # TODO add documentation
+    # TODO redo with encoder
     label_num = list(set(data.loc[:, column_num]))
     label_str = list(set(data.loc[:, columns_str]))
     d = {}
@@ -230,6 +232,14 @@ def get_map_label(data, column_num="label", columns_str="pattern_name"):
     return d
 
 
+def get_gene_encoder(genes_str):
+    # encode genes
+    encoder_gene = LabelEncoder()
+    encoder_gene.fit(genes_str)
+
+    return encoder_gene
+
+
 # ### Build images ###
 
 def build_image(data, id_cell, image_shape=None, coord_refinement=True,

From c424e5ad1b15604a1a3f7bed959792b172475dd2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 10 Apr 2019 11:41:35 +0200
Subject: [PATCH 118/264] remove warning

---
 bigfish/classification/squeezenet.py | 20 ++++++--------------
 1 file changed, 6 insertions(+), 14 deletions(-)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index e8b6ab41..306fa11c 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -16,7 +16,6 @@
 """
 
 import os
-import warnings
 
 import tensorflow as tf
 import numpy as np
@@ -299,15 +298,6 @@ def save_training_history(self):
 
     def get_feature_map(self, generator, after_average_pooling=True):
         # TODO add documentation
-        # TODO ask generator without label
-        # check generator
-        label_back = False
-        if generator.with_label:
-            warnings.warn("Label is disabled from generator during the "
-                          "computation of the feature map.")
-            generator.with_label = False
-            label_back = True
-
         # get input layer
         input_ = self.model.input
 
@@ -321,7 +311,12 @@ def get_feature_map(self, generator, after_average_pooling=True):
         features_map = function([input_, learning_phase()], [output_])
 
         # compute the feature map
-        embedding = [features_map([batch, 0])[0] for batch in generator]
+        if generator.with_label:
+            embedding = [features_map([batch, 0])[0]
+                         for (batch, _) in generator]
+        else:
+            embedding = [features_map([batch, 0])[0]
+                         for batch in generator]
         embedding = np.array(embedding)
         embedding = np.concatenate(embedding, axis=0)
 
@@ -329,9 +324,6 @@ def get_feature_map(self, generator, after_average_pooling=True):
             a, b, c, d = embedding.shape
             embedding = np.reshape(embedding, (a, b * c * d))
 
-        # reset parameter 'with_label' if necessary
-        generator.with_label = label_back
-
         return embedding
 
 

From b0d147fdded44a22d1bfd9cb789718494636d38f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 18 Apr 2019 18:02:41 +0200
Subject: [PATCH 119/264] add boundary in segmentation plot

---
 bigfish/plot/plot_images.py | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 3a10d670..1bb5d022 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -11,6 +11,9 @@
 
 from .utils import save_plot
 
+from skimage.segmentation import find_boundaries
+from matplotlib.colors import ListedColormap
+
 
 # TODO add title in the plot and remove axes
 
@@ -275,7 +278,8 @@ def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
 
 
 def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
-                      framesize=(15, 15), path_output=None, ext="png"):
+                      bondary=False, framesize=(15, 15),
+                      path_output=None, ext="png"):
     """Plot result of a 2-d segmentation, with labelled instances if available.
 
     Parameters
@@ -310,15 +314,24 @@ def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
     if label is not None:
         stack.check_array(label, ndim=2, dtype=np.int64)
 
+    # TODO clean it
+    boundaries = None
+    if bondary and label is not None:
+        boundaries = find_boundaries(label, mode='thick')
+        boundaries = np.ma.masked_where(boundaries == 0, boundaries)
+
     # plot
     if label is not None:
         fig, ax = plt.subplots(1, 3, sharex='col', figsize=framesize)
         ax[0].imshow(tensor[r, c, z, :, :])
+        ax[0].imshow(boundaries, cmap=ListedColormap(['red']))
         ax[0].set_title("Z-slice: {0}".format(z),
                         fontweight="bold", fontsize=15)
         ax[1].imshow(segmentation)
+        ax[1].imshow(boundaries, cmap=ListedColormap(['red']))
         ax[1].set_title("Segmentation", fontweight="bold", fontsize=15)
         ax[2].imshow(label)
+        ax[2].imshow(boundaries, cmap=ListedColormap(['red']))
         ax[2].set_title("Labels", fontweight="bold", fontsize=15)
 
     else:

From 4952cf0e56d740d6af5d62f8a06c42b2db77ac88 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 18 Apr 2019 18:03:12 +0200
Subject: [PATCH 120/264] add cyt segmentation

---
 bigfish/segmentation/__init__.py     |  5 ++-
 bigfish/segmentation/segmentation.py | 57 +++++++++++++++++++++++++++-
 2 files changed, 59 insertions(+), 3 deletions(-)

diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index 32667544..8ed788bd 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -5,8 +5,9 @@
 cytoplasm and label them, in 2-d and 3-d.
 """
 
-from .segmentation import nuc_segmentation_2d
+from .segmentation import nuc_segmentation_2d, cyt_segmentation_2d
 
 
-__all__ = ["nuc_segmentation_2d"]
+__all__ = ["nuc_segmentation_2d",
+           "cyt_segmentation_2d"]
 
diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/segmentation.py
index 1d4ebca5..a8bd431b 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/segmentation.py
@@ -6,10 +6,13 @@
 
 from bigfish import stack
 
-from skimage.morphology import remove_small_objects
+from skimage.morphology import remove_small_objects, remove_small_holes
 from skimage.measure import label
 from scipy import ndimage as ndi
 import numpy as np
+from skimage.morphology import watershed
+from skimage.filters import threshold_otsu
+from skimage.measure import regionprops
 
 # TODO rename functions
 # TODO complete documentation methods
@@ -53,6 +56,7 @@ def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
                                 c=c)
 
     # apply segmentation
+    # TODO validate the pipeline with this cast
     image_segmented = stack.cast_img_uint8(image_2d)
     if segmentation_method == "threshold":
         image_segmented = filtered_threshold(image_segmented, **kwargs)
@@ -169,3 +173,54 @@ def label_instances(image_segmented):
     """
     image_label, nb_labels = label(image_segmented, return_num=True)
     return image_label, nb_labels
+
+
+def cyt_segmentation_2d(tensor, r, c_nuc, c_cyt, segmentation_method):
+    # TODO add documentation
+    # check tensor dimensions and its dtype
+    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+
+    # apply segmentation
+    # TODO validate the pipeline with this cast
+    image_segmented = stack.cast_img_uint8(tensor)
+    if segmentation_method == "watershed":
+        image_segmented = watershed_2d(image_segmented, r, c_nuc, c_cyt)
+    else:
+        pass
+    return image_segmented
+
+
+def watershed_2d(tensor, r, c_nuc, c_cyt):
+    # TODO add documentation
+    # TODO better integration with nuclei segmentation
+    # nuclei segmentation
+    _, nuc_labelled, _ = nuc_segmentation_2d(
+        tensor,
+        projection_method="mip",
+        r=r, c=c_nuc,
+        segmentation_method="threshold",
+        return_label=True)
+
+    # get source image
+    cyt = tensor[r, c_cyt, :, :, :]
+    cyt_projected = stack.projection(tensor, method="mip", r=r, c=c_cyt)
+
+    # get a mask for the cytoplasm
+    mask = (cyt_projected > threshold_otsu(cyt_projected))
+    mask = remove_small_objects(mask, 200)
+    mask = remove_small_holes(mask, 200)
+
+    # get image to apply watershed on
+    seed = np.sum(cyt, 0)
+    seed = seed.max() - seed
+    seed[nuc_labelled > 0] = 0
+
+    # get the markers from the nuclei
+    markers = np.zeros_like(seed)
+    for r in regionprops(nuc_labelled):
+        markers[tuple(map(int, r.centroid))] = r.label
+
+    # apply watershed
+    cyt_segmented = watershed(seed, markers, mask=mask)
+
+    return cyt_segmented

From ae90fe7684f4cee6681f18bc44766a52cb146267 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Apr 2019 19:47:45 +0200
Subject: [PATCH 121/264] refactoring stack #1

---
 bigfish/stack/filter.py       |  0
 bigfish/stack/illumination.py |  0
 bigfish/stack/preprocess.py   | 24 ++++++++++++++++--------
 bigfish/stack/projection.py   |  0
 4 files changed, 16 insertions(+), 8 deletions(-)
 create mode 100644 bigfish/stack/filter.py
 create mode 100644 bigfish/stack/illumination.py
 create mode 100644 bigfish/stack/projection.py

diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/stack/illumination.py b/bigfish/stack/illumination.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 64c811f5..ba3dd076 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -27,7 +27,7 @@
 
 
 # TODO add safety checks
-
+# TODO add a stack builder without recipe
 
 # ### Simulated data ###
 
@@ -250,6 +250,8 @@ def build_stack(recipe, input_folder, input_dimension=None, normalize=False,
 
     """
     # TODO add sanity checks for the parameters
+    # TODO ensure we can pass a str and not just a list of str in the recipe
+    # TODO allow different patterns for the recipe
     # build stack from recipe and tif files
     tensor = load_stack(recipe, input_folder, input_dimension)
 
@@ -335,6 +337,7 @@ def load_stack(recipe, input_folder, input_dimension=None):
     check_recipe(recipe)
 
     # if the initial dimension of the files is unknown, we read one of them
+    # TODO be sure to read one of the files targeted by the recipe
     if input_dimension is None:
         fov_str = recipe["fov"]
         ext_str = "." + recipe["ext"]
@@ -378,6 +381,7 @@ def check_recipe(recipe):
         recipe.
 
     """
+    # TODO remove the expected dimension ?
     # check recipe is a dictionary with the "fov" key
     if (not isinstance(recipe, dict)
             or "fov" not in recipe
@@ -987,11 +991,15 @@ def cast_img_uint8(tensor):
         Image cast.
 
     """
+    # TODO validate the warnings
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint16,
+    check_array(tensor, dtype=[np.uint8, np.uint16,
                                np.float32, np.float64,
                                np.bool])
 
+    if tensor.dtype == np.uint8:
+        return tensor
+
     # check the range value for float tensors
     if tensor.dtype in [np.float32, np.float64]:
         if not check_range_value(tensor, 0, 1):
@@ -1001,12 +1009,12 @@ def cast_img_uint8(tensor):
                              .format(tensor.dtype, tensor.min(), tensor.max()))
 
     # check the range value for integer tensors
-    elif tensor.dtype == np.uint16:
-        if not check_range_value(tensor, 0, 255):
-            raise ValueError("To cast a tensor from np.uint16 to np.uint8, "
-                             "its values must be between 0 and 255, and not "
-                             "{0} and {1}.Otherwise, the values are clipped."
-                             .format(tensor.min(), tensor.max()))
+    #elif tensor.dtype == np.uint16:
+    #    if not check_range_value(tensor, 0, 255):
+    #        raise ValueError("To cast a tensor from np.uint16 to np.uint8, "
+    #                         "its values must be between 0 and 255, and not "
+    #                         "{0} and {1}. Otherwise, the values are clipped."
+    #                         .format(tensor.min(), tensor.max()))
 
     # cast tensor
     with warnings.catch_warnings():
diff --git a/bigfish/stack/projection.py b/bigfish/stack/projection.py
new file mode 100644
index 00000000..e69de29b

From 3ff36f9535b5ef6ae420a3e9a5081bcb08646660 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Apr 2019 19:48:52 +0200
Subject: [PATCH 122/264] improve sanity checks and loaders

---
 bigfish/stack/loader.py |  21 ++--
 bigfish/stack/utils.py  | 253 +++++++++++++++++++++++++++++++++++-----
 2 files changed, 236 insertions(+), 38 deletions(-)

diff --git a/bigfish/stack/loader.py b/bigfish/stack/loader.py
index 5323fc6a..bbe3901d 100644
--- a/bigfish/stack/loader.py
+++ b/bigfish/stack/loader.py
@@ -11,13 +11,14 @@
 import pandas as pd
 
 from skimage import io
-from .utils import check_array, check_features_df
+from .utils import check_array, check_df
 
 
-def read_tif(path):
-    """Read an image with the .tif or .tiff extension.
+def read_image(path):
+    """Read an image with the .png, .tif or .tiff extension.
 
-    The input image should be in 2-d or 3-d, with unsigned integer 16 bits.
+    The input image should be in 2-d or 3-d, with unsigned integer 8 or 16
+    bits.
 
     Parameters
     ----------
@@ -26,7 +27,7 @@ def read_tif(path):
 
     Returns
     -------
-    tensor : ndarray, np.uint16
+    tensor : ndarray, np.uint
         A 2-d or 3-d tensor with spatial dimensions.
 
     """
@@ -34,7 +35,7 @@ def read_tif(path):
     tensor = io.imread(path)
 
     # check the image is in unsigned integer 16 bits with 2 or 3 dimensions
-    check_array(tensor, dtype=np.uint16, ndim=[2, 3])
+    check_array(tensor, dtype=[np.uint8, np.uint16], ndim=[2, 3])
 
     return tensor
 
@@ -58,7 +59,9 @@ def read_cell_json(path):
     df = pd.read_json(path)
 
     # check the output has the right features
-    check_features_df(df, features=["name_img_BGD", "pos_cell", "pos_nuc"])
+    check_df(df,
+             features=["name_img_BGD", "pos_cell", "pos_nuc"],
+             features_nan=["name_img_BGD", "pos_cell", "pos_nuc"])
 
     return df
 
@@ -91,7 +94,9 @@ def read_rna_json(path):
     expected_features = ['RNA_pos', 'cell_ID', 'mRNA_level_avg',
                          'mRNA_level_label', 'n_RNA', 'name_img_BGD',
                          'pattern_level', 'pattern_name', 'pattern_prop']
-    check_features_df(df, features=expected_features)
+    check_df(df,
+             features=expected_features,
+             features_nan=expected_features)
 
     return df
 
diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 7df222cb..e1dd8c2d 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -4,41 +4,116 @@
 Utility functions for bigfish.stack submodule.
 """
 
+import inspect
+import re
+
 import numpy as np
+import pandas as pd
 
 
-# TODO complete the checks for the dataframe (dtype, missing values).
-# ### Sanity checks ###
+# ### Sanity checks dataframe ###
 
-def check_features_df(df, features):
-    """Check that the dataframe has the right features.
+def check_df(df, features=None, features_nan=None):
+    """Full safety check of a dataframe.
 
     Parameters
     ----------
     df : pd.DataFrame
         Dataframe to check.
     features : List[str]
-        Names of the features expected.
+        Names of the expected features.
+    features_nan : List[str]
+        Names of the features to check for the missing values
+
+    Returns
+    -------
+    _ : bool
+        Assert if the dataframe is well formatted.
+
+    """
+    # check parameters
+    check_parameter(features=(list, type(None)),
+                    features_nan=(list, type(None)))
+
+    # check the dataframe itself
+    if not isinstance(df, pd.DataFrame):
+        raise ValueError("Data should be a pd.DataFrame instead of {0}."
+                         .format(type(df)))
+
+    # check features
+    if features is not None:
+        _check_features_df(df, features)
+
+    # check NaN values
+    if features_nan is not None:
+        _check_features_df(df, features_nan)
+        _check_nan_df(df, features_nan)
+
+    # TODO complete the checks for the dataframe (dtype).
+
+    return True
+
+
+def _check_features_df(df, features):
+    """Check that the dataframe contains expected features.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Dataframe to check.
+    features : List[str]
+        Names of the expected features.
+
+    Returns
+    -------
+
+    """
+    # check columns
+    if not set(features).issubset(df.columns):
+        raise ValueError("The dataframe does not seem to have the right "
+                         "features. {0} instead of {1}"
+                         .format(df.columns, features))
+
+    return
+
+
+def _check_nan_df(df, features_nan=None):
+    """
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Dataframe to check.
+    features_nan : List[str]
+        Names of the checked features.
 
     Returns
     -------
 
     """
-    # get dataframe's features
-    col_names = df.columns
+    # count NaN
+    nan_count = df.isnull().sum()
 
-    # sort the two lists
-    col_names = sorted(col_names)
-    features = sorted(features)
+    # for the full dataframe...
+    if features_nan is None:
+        x = nan_count.sum()
+        if x > 0:
+            raise ValueError("The dataframe has {0} NaN values.".format(x))
 
-    if col_names == features:
-        return
+    # ...or for some features
     else:
-        raise ValueError("The file does not seem to have the right features. "
-                         "{0} instead of {1}".format(col_names, features))
+        nan_count = nan_count[features_nan]
+        x = nan_count.sum()
+        if x > 0:
+            raise ValueError("The dataframe has {0} NaN values for the "
+                             "requested features: \n{1}.".format(x, nan_count))
+
+    return
 
 
-def check_array(array, ndim=None, dtype=None):
+# ### Sanity checks array ###
+
+def check_array(array, ndim=None, dtype=None, allow_nan=True):
     """Full safety check of an array.
 
     Parameters
@@ -49,15 +124,26 @@ def check_array(array, ndim=None, dtype=None):
         Number of dimensions expected.
     dtype : type or List[type]
         Types expected.
+    allow_nan : bool
+        Allow NaN values or not.
+    min_array : int
+        Minimum value allowed.
+    max_array : int
+        Maximum value allowed.
 
     Returns
     -------
+    _ : bool
+        Assert if the array is well formatted.
 
     """
-    # check the array itself
-    if not isinstance(array, np.ndarray):
-        raise ValueError("Data should be a np.ndarray instead of {0}."
-                         .format(type(array)))
+    # check parameters
+    check_parameter(array=np.ndarray,
+                    ndim=(int, list, type(None)),
+                    dtype=(type, type(None)),
+                    allow_nan=bool,
+                    min_array=(int, type(None)),
+                    max_array=(int, type(None)))
 
     # check the dtype
     if dtype is not None:
@@ -67,11 +153,11 @@ def check_array(array, ndim=None, dtype=None):
     if ndim is not None:
         _check_dim_array(array, ndim)
 
-    # TODO check the order of the dimensions
-
-    # TODO check nan
+    # check NaN
+    if not allow_nan:
+        _check_nan_array(array)
 
-    return
+    return True
 
 
 def _check_dtype_array(array, dtype):
@@ -114,7 +200,6 @@ def _check_dim_array(array, ndim):
     -------
 
     """
-
     # enlist the number of expected dimensions
     if isinstance(ndim, int):
         ndim = [ndim]
@@ -125,8 +210,29 @@ def _check_dim_array(array, ndim):
                          "dimensions are: {1}.".format(array.ndim, ndim))
 
 
-def check_range_value(array, min_, max_):
+def _check_nan_array(array):
+    """Check that the array does not have NaN values.
+
+    Parameters
+    ----------
+    array : np.ndarray
+        Array to check.
+
+    Returns
+    -------
+
     """
+    # count nan
+    mask = np.isnan(array)
+    x = mask.sum()
+
+    # check the NaN values of the array
+    if x > 0:
+        raise ValueError("Array has {0} NaN values.".format(x))
+
+
+def check_range_value(array, min_=None, max_=None):
+    """Check the support of the array.
 
     Parameters
     ----------
@@ -140,10 +246,97 @@ def check_range_value(array, min_, max_):
     Returns
     -------
     _ : bool
-        Assert if the array is within the requested bound.
+        Assert if the array has the right range of values.
 
     """
-    if array.min() < min_ or array.max() > max_:
-        return False
-    else:
-        return True
+    # check lowest and highest bounds
+    if min_ is not None and array.min() < min_:
+        raise ValueError("The array should have a lower bound of {0}, but its "
+                         "minimum value is {1}.".format(min_, array.min()))
+    if max_ is not None and array.max() > max_:
+        raise ValueError("The array should have an upper bound of {0}, but "
+                         "its maximum value is {1}.".format(max_, array.max()))
+
+    return True
+
+
+# ### Sanity checks parameters ###
+
+def check_recipe(recipe):
+    """Check and validate a recipe.
+
+    Checking a recipe consist in validating its filename pattern and the
+    content of the dictionary.
+
+    Parameters
+    ----------
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Can only contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
+
+    Returns
+    -------
+
+    """
+    # check recipe is a dictionary
+    if not isinstance(recipe, dict):
+        raise Exception("The recipe is not valid. It should be a dictionary.")
+
+    # check the filename pattern
+    if "pattern" not in recipe:
+        raise ValueError("A recipe should have a filename pattern "
+                         "('pattern' keyword).")
+    recipe_pattern = recipe["pattern"]
+    if not isinstance(recipe_pattern, str):
+        raise ValueError("'pattern' should be a string, not a {0}."
+                         .format(type(recipe_pattern)))
+
+    # count the different dimensions to combinate in the recipe (among
+    # 'fov', 'r', 'c' and 'z')
+    dimensions = re.findall("fov|r|c|z", recipe_pattern)
+
+    # each dimension can only appear once in the filename pattern
+    if len(dimensions) != len(set(dimensions)):
+        raise ValueError("The pattern used in recipe is wrong, a dimension "
+                         "appears several times: {0}".format(recipe_pattern))
+
+    # check keys and values of the recipe
+    for key, value in recipe.items():
+        if key not in ['fov', 'r', 'c', 'z', 'ext', 'opt']:
+            raise ValueError("The recipe can only contain the keys 'fov', "
+                             "'r', 'c', 'z', 'ext' or 'opt'. Not {0}."
+                             .format(key))
+        if not isinstance(value, (list, str)):
+            raise TypeError("A recipe can only contain lists or strings, "
+                            "not {0}.".format(type(value)))
+
+    return
+
+
+def check_parameter(**kwargs):
+    """Check dtype of the function's parameters.
+
+    Parameters
+    ----------
+    kwargs : dict
+        Map of each parameter with its expected dtype.
+
+    Returns
+    -------
+
+    """
+    # get the frame and the parameters of the function
+    frame = inspect.currentframe().f_back
+    _, _, _, values = inspect.getargvalues(frame)
+
+    # compare each parameter with its expected dtype
+    for arg in kwargs:
+        expected_dtype = kwargs[arg]
+        parameter = values[arg]
+        if not isinstance(parameter, expected_dtype):
+            raise ValueError("Parameter {0} should be cast in {1}. It is a {2}"
+                             "instead."
+                             .format(arg, expected_dtype, type(parameter)))
+
+    return

From e05ccafe87c7cc83e7ecfabb007d1b6a7ce73947 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Apr 2019 19:49:42 +0200
Subject: [PATCH 123/264] improve stack building

---
 bigfish/stack/preprocess.py | 1319 ++++++++++++++---------------------
 1 file changed, 523 insertions(+), 796 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index ba3dd076..e330395b 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -5,22 +5,21 @@
 """
 
 import os
+import re
 import warnings
 
 import numpy as np
 import pandas as pd
 
-from .loader import read_tif, read_cell_json, read_rna_json
-from .utils import check_array, check_range_value
+from .loader import read_image, read_cell_json, read_rna_json
+from .utils import (check_array, check_parameter, check_recipe,
+                    check_range_value)
 
 from sklearn.preprocessing import LabelEncoder
 
 from skimage import img_as_ubyte, img_as_float32, img_as_float64, img_as_uint
-from skimage.morphology.selem import square, diamond, rectangle, disk
-from skimage.filters import rank, gaussian
 from skimage.exposure import rescale_intensity
 
-from scipy.ndimage import gaussian_laplace
 from scipy.sparse import coo_matrix
 
 from scipy import ndimage as ndi
@@ -61,6 +60,11 @@ def build_simulated_dataset(path_cell, path_rna, path_output=None):
         pattern used to simulate them and its strength.
 
     """
+    # TODO this function should be updated as soon as we change the simulation
+    #  framework
+    # check parameters
+    check_parameter(path_cell=str, path_rna=str, path_output=(str, type(None)))
+
     # read the cell data (nucleus + cytoplasm)
     df_cell = read_cell_json(path_cell)
 
@@ -92,15 +96,16 @@ def build_simulated_dataset(path_cell, path_rna, path_output=None):
 
 # ### Real data ###
 
-def build_stacks(data_map, input_dimension=None, normalize=False,
+def build_stacks(data_map, input_dimension=None, check=False, normalize=False,
                  channel_to_stretch=None, stretching_percentile=99.9,
                  cast_8bit=False, return_origin=False):
-    """Generator to build several stacks.
+    """Generator to build several stacks from recipe-folder pairs.
 
     To build a stack, a recipe should be linked to a directory including all
     the files needed to build the stack. The content of the recipe allows to
     reorganize the different files stored in the directory in order to build
-    a 5-d tensor.
+    a 5-d tensor. If several fields of view (fov) are store in the recipe,
+    several tensors are generated.
 
     The list 'data_map' takes the form:
 
@@ -115,11 +120,13 @@ def build_stacks(data_map, input_dimension=None, normalize=False,
     The recipe dictionary for one field of view takes the form:
 
         {
-         "fov": str,
+         "fov": str,     (optional)
          "z": List[str], (optional)
          "c": List[str], (optional)
          "r": List[str], (optional)
-         "ext": str
+         "ext": str,     (optional)
+         "opt": str,     (optional)
+         "pattern"
          }
 
     - A field of view is defined by an ID common to every images belonging to
@@ -127,31 +134,49 @@ def build_stacks(data_map, input_dimension=None, normalize=False,
     - At least every images are in 2-d with x and y dimensions. So we need to
     mention the round-dimension, the channel-dimension and the z-dimension to
     add ("r", "c" and "z"). For these keys, we provide a list of
-    strings to identify the images to stack. By default, we assume the filename
-    fit the pattern fov_z_c_r.tif.
+    strings to identify the images to stack.
     - An extra information to identify the files to stack in the input folder
-    can be provided with the file extension "ext" (usually 'tif' or 'tiff').
+    can be provided with the file extension "ext" (usually 'tif' or 'tiff') or
+    an optional morpheme ("opt").
+    - A pattern used to get the filename ("pattern").
 
-    For example, let us assume 3-d images (zyx dimensions) saved as
+    Example 1. Let us assume 3-d images (zyx dimensions) saved as
     "r03c03f01_405.tif", "r03c03f01_488.tif" and "r03c03f01_561.tif". The first
     morpheme "r03c03f01" uniquely identifies a 3-d field of view. The second
     morphemes "405", "488" and "561" identify three different channels we
-    want to stack. There is no round in this experiment. Thus, the recipe is:
+    want to stack. There is no round in this experiment. We need to return a
+    tensor with shape (1, 3, z, y, x). Thus, a valid recipe would be:
 
         {
          "fov": "r03c03f01",
          "c": ["405", "488", "561"],
          "ext": "tif"
+         "pattern": "fov_c.ext"
          }
 
-    The function should return a tensor with shape (1, 3, z, y, x).
+    Example 2. Let us assume 2-d images (yx dimensions) saved as
+    "dapi_1.TIFF", "cy3_1.TIFF", "GFP_1.TIFF", "dapi_2.TIFF", "cy3_2.TIFF" and
+    "GFP_2.TIFF". The first morphemes "dapi", "cy3" and "GFP" identify
+    channels. The second morphemes "1" and "2" identify two different fields of
+    view. There is no round and no z dimension in this experiment. We can
+    build two tensors with shape (1, 3, 1, y, x). Thus, a valid recipe would
+    be:
+
+        {
+         "fov": ["1", "2"],
+         "c": ["dapi", "cy3", "GFP"],
+         "ext": "TIFF"
+         "pattern": "c_fov.ext"
+         }
 
     Parameters
     ----------
     data_map : List[tuple]
         Map between input directories and recipes.
-    input_dimension : str
+    input_dimension : int
         Number of dimensions of the loaded files.
+    check : bool
+        Check the validity of the loaded tensor.
     normalize : bool
         Normalize the different channels of the loaded stack (rescaling).
     channel_to_stretch : int or List[int]
@@ -174,30 +199,79 @@ def build_stacks(data_map, input_dimension=None, normalize=False,
         Recipe used to build the tensor.
 
     """
-    # load and generate tensors
+    # check parameters
+    check_parameter(data_map=list,
+                    return_origin=bool)
+
+    # load and generate tensors for each recipe-folder pair
     for recipe, input_folder in data_map:
-        tensor = build_stack(recipe, input_folder, input_dimension, normalize,
-                             channel_to_stretch, stretching_percentile,
-                             cast_8bit)
-        if return_origin:
-            yield tensor, input_folder, recipe
-        else:
-            yield tensor
 
+        # load and generate tensors for each fov stored in a recipe
+        nb_fov = count_nb_fov(recipe)
+        for i_fov in range(nb_fov):
+            tensor = build_stack(recipe, input_folder, input_dimension, i_fov,
+                                 check, normalize, channel_to_stretch,
+                                 stretching_percentile, cast_8bit)
+            if return_origin:
+                yield tensor, input_folder, recipe, i_fov
+            else:
+                yield tensor
+
+
+def count_nb_fov(recipe):
+    """Count the number of different fields of view that can be defined from
+    the recipe.
+
+    Parameters
+    ----------
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Can only contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
+
+    Returns
+    -------
+    nb_fov : int
+        Number of different fields of view in the recipe.
+
+    """
+    # check recipe is a dictionary
+    if not isinstance(recipe, dict):
+        raise Exception("The recipe is not valid. It should be a dictionary.")
+
+    # check the fov key exists
+    if "fov" not in recipe:
+        return 1
+
+    # case where fov is directly a string
+    elif isinstance(recipe["fov"], str):
+        return 1
 
-def build_stack(recipe, input_folder, input_dimension=None, normalize=False,
-                channel_to_stretch=None, stretching_percentile=99.9,
-                cast_8bit=False):
+    # case where fov is a list of strings
+    elif isinstance(recipe["fov"], list):
+        return len(recipe["fov"])
+
+    # non valid cases
+    else:
+        raise ValueError("'fov' should be a List or a str, not {0}"
+                         .format(type(recipe["fov"])))
+
+
+def build_stack(recipe, input_folder, input_dimension=None, i_fov=0,
+                check=False, normalize=False, channel_to_stretch=None,
+                stretching_percentile=99.9, cast_8bit=False):
     """Build 5-d stack and normalize it.
 
     The recipe dictionary for one field of view takes the form:
 
         {
-         "fov": str,
+         "fov": str,     (optional)
          "z": List[str], (optional)
          "c": List[str], (optional)
          "r": List[str], (optional)
-         "ext": str
+         "ext": str,     (optional)
+         "opt": str,     (optional)
+         "pattern"
          }
 
     - A field of view is defined by an ID common to every images belonging to
@@ -205,34 +279,55 @@ def build_stack(recipe, input_folder, input_dimension=None, normalize=False,
     - At least every images are in 2-d with x and y dimensions. So we need to
     mention the round-dimension, the channel-dimension and the z-dimension to
     add ("r", "c" and "z"). For these keys, we provide a list of
-    strings to identify the images to stack. By default, we assume the filename
-    fit the pattern fov_z_c_r.tif.
+    strings to identify the images to stack.
     - An extra information to identify the files to stack in the input folder
-    can be provided with the file extension "ext" (usually 'tif' or 'tiff').
+    can be provided with the file extension "ext" (usually 'tif' or 'tiff') or
+    an optional morpheme ("opt").
+    - A pattern used to get the filename ("pattern").
 
-    For example, let us assume 3-d images (zyx dimensions) saved as
+    Example 1. Let us assume 3-d images (zyx dimensions) saved as
     "r03c03f01_405.tif", "r03c03f01_488.tif" and "r03c03f01_561.tif". The first
     morpheme "r03c03f01" uniquely identifies a 3-d field of view. The second
     morphemes "405", "488" and "561" identify three different channels we
-    want to stack. There is no round in this experiment. Thus, the recipe is:
+    want to stack. There is no round in this experiment. We need to return a
+    tensor with shape (1, 3, z, y, x). Thus, a valid recipe would be:
 
         {
          "fov": "r03c03f01",
          "c": ["405", "488", "561"],
          "ext": "tif"
+         "pattern": "fov_c.ext"
          }
 
-    The function should return a tensor with shape (1, 3, z, y, x).
+    Example 2. Let us assume 2-d images (yx dimensions) saved as
+    "dapi_1.TIFF", "cy3_1.TIFF", "GFP_1.TIFF", "dapi_2.TIFF", "cy3_2.TIFF" and
+    "GFP_2.TIFF". The first morphemes "dapi", "cy3" and "GFP" identify
+    channels. The second morphemes "1" and "2" identify two different fields of
+    view. There is no round and no z dimension in this experiment. We can
+    build two tensors with shape (1, 3, 1, y, x). Thus, a valid recipe would
+    be:
+
+        {
+         "fov": ["1", "2"],
+         "c": ["dapi", "cy3", "GFP"],
+         "ext": "TIFF"
+         "pattern": "c_fov.ext"
+         }
 
     Parameters
     ----------
     recipe : dict
         Map the images according to their field of view, their round,
-        their channel and their spatial dimensions.
+        their channel and their spatial dimensions. Can only contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
     input_folder : str
         Path of the folder containing the images.
-    input_dimension : str
+    input_dimension : int
         Number of dimensions of the loaded files.
+    i_fov : int
+        Index of the fov to build.
+    check : bool
+        Check the validity of the loaded tensor.
     normalize : bool
         Normalize the different channels of the loaded stack (rescaling).
     channel_to_stretch : int or List[int]
@@ -249,11 +344,22 @@ def build_stack(recipe, input_folder, input_dimension=None, normalize=False,
         Tensor with shape (r, c, z, y, x).
 
     """
-    # TODO add sanity checks for the parameters
-    # TODO ensure we can pass a str and not just a list of str in the recipe
-    # TODO allow different patterns for the recipe
+    # check parameters
+    check_parameter(normalize=bool,
+                    channel_to_stretch=(int, list, type(None)),
+                    stretching_percentile=float,
+                    cast_8bit=bool,
+                    return_origin=bool)
+
     # build stack from recipe and tif files
-    tensor = load_stack(recipe, input_folder, input_dimension)
+    tensor = load_stack(recipe, input_folder, input_dimension, i_fov)
+
+    # check the validity of the loaded tensor
+    if check:
+        check_array(tensor,
+                    ndim=5,
+                    dtype=[np.uint8, np.uint16],
+                    allow_nan=False)
 
     # rescale data and improve contrast
     if normalize:
@@ -266,8 +372,8 @@ def build_stack(recipe, input_folder, input_dimension=None, normalize=False,
     return tensor
 
 
-def load_stack(recipe, input_folder, input_dimension=None):
-    """Build a 5-d tensor from the same field of view (fov).
+def load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
+    """Build a 5-d tensor from the same fields of view (fov).
 
     The function stacks a set of images using a recipe mapping the
     different images with the dimensions they represent. Each stacking step
@@ -281,11 +387,13 @@ def load_stack(recipe, input_folder, input_dimension=None):
     The recipe dictionary for one field of view takes the form:
 
         {
-         "fov": str,
+         "fov": str,     (optional)
          "z": List[str], (optional)
          "c": List[str], (optional)
          "r": List[str], (optional)
-         "ext": str
+         "ext": str,     (optional)
+         "opt": str,     (optional)
+         "pattern"
          }
 
     - A field of view is defined by an ID common to every images belonging to
@@ -293,70 +401,88 @@ def load_stack(recipe, input_folder, input_dimension=None):
     - At least every images are in 2-d with x and y dimensions. So we need to
     mention the round-dimension, the channel-dimension and the z-dimension to
     add ("r", "c" and "z"). For these keys, we provide a list of
-    strings to identify the images to stack. By default, we assume the filename
-    fit the pattern fov_z_c_r.tif.
+    strings to identify the images to stack.
     - An extra information to identify the files to stack in the input folder
-    can be provided with the file extension "ext" (usually 'tif' or 'tiff').
-
-    # TODO generalize with different filename patterns
-    # TODO allow a recipe without 'ext'
+    can be provided with the file extension "ext" (usually 'tif' or 'tiff') or
+    an optional morpheme ("opt").
+    - A pattern used to get the filename ("pattern").
 
-    For example, let us assume 3-d images (zyx dimensions) saved as
+    Example 1. Let us assume 3-d images (zyx dimensions) saved as
     "r03c03f01_405.tif", "r03c03f01_488.tif" and "r03c03f01_561.tif". The first
     morpheme "r03c03f01" uniquely identifies a 3-d field of view. The second
     morphemes "405", "488" and "561" identify three different channels we
-    want to stack. There is no round in this experiment. Thus, the recipe is:
+    want to stack. There is no round in this experiment. We need to return a
+    tensor with shape (1, 3, z, y, x). Thus, a valid recipe would be:
 
         {
          "fov": "r03c03f01",
          "c": ["405", "488", "561"],
          "ext": "tif"
+         "pattern": "fov_c.ext"
          }
 
-    The function should return a tensor with shape (1, 3, z, y, x).
+    Example 2. Let us assume 2-d images (yx dimensions) saved as
+    "dapi_1.TIFF", "cy3_1.TIFF", "GFP_1.TIFF", "dapi_2.TIFF", "cy3_2.TIFF" and
+    "GFP_2.TIFF". The first morphemes "dapi", "cy3" and "GFP" identify
+    channels. The second morphemes "1" and "2" identify two different fields of
+    view. There is no round and no z dimension in this experiment. We can
+    build two tensors with shape (1, 3, 1, y, x). Thus, a valid recipe would
+    be:
 
-    # TODO manage the order of the channel
+        {
+         "fov": ["1", "2"],
+         "c": ["dapi", "cy3", "GFP"],
+         "ext": "TIFF"
+         "pattern": "c_fov.ext"
+         }
 
     Parameters
     ----------
     recipe : dict
         Map the images according to their field of view, their round,
-        their channel and their spatial dimensions.
+        their channel and their spatial dimensions. Can only contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
     input_folder : str
         Path of the folder containing the images.
-    input_dimension : str
+    input_dimension : int
         Number of dimensions of the loaded files.
+    i_fov : int
+        Index of the fov to build.
 
     Returns
     -------
-    tensor : np.ndarray, np.uint
+    stack : np.ndarray, np.uint
         Tensor with shape (r, c, z, y, x).
 
     """
-    # check recipe
+    # check parameters
     check_recipe(recipe)
+    check_parameter(input_folder=str,
+                    input_dimension=(int, type(None)),
+                    i_fov=int)
+
+    # complete the recipe with unused morphemes
+    recipe = fit_recipe(recipe)
 
     # if the initial dimension of the files is unknown, we read one of them
-    # TODO be sure to read one of the files targeted by the recipe
     if input_dimension is None:
-        fov_str = recipe["fov"]
-        ext_str = "." + recipe["ext"]
-        filenames = [filename
-                     for filename in os.listdir(input_folder)
-                     if fov_str in filename and ext_str in filename]
-        path = os.path.join(input_folder, filenames[0])
-        testfile = read_tif(path)
-        input_dimension = testfile.ndim
+        input_dimension = get_input_dimension(recipe, input_folder)
+
+    # get the number of elements to stack per dimension
+    nb_r, nb_c, nb_z = get_nb_element_per_dimension(recipe)
 
     # we stack our files according to their initial dimension
     if input_dimension == 2:
-        stack = _build_stack_from_2d(recipe, input_folder)
+        stack = _build_stack_from_2d(recipe, input_folder, fov=i_fov,
+                                     nb_r=nb_r, nb_c=nb_c, nb_z=nb_z)
     elif input_dimension == 3:
-        stack = _build_stack_from_3d(recipe, input_folder)
+        stack = _build_stack_from_3d(recipe, input_folder, fov=i_fov,
+                                     nb_r=nb_r, nb_c=nb_c)
     elif input_dimension == 4:
-        stack = _build_stack_from_4d(recipe, input_folder)
+        stack = _build_stack_from_4d(recipe, input_folder, fov=i_fov,
+                                     nb_r=nb_r)
     elif input_dimension == 5:
-        stack = _build_stack_from_5d(recipe, input_folder)
+        stack = _build_stack_from_5d(recipe, input_folder, fov=i_fov)
     else:
         raise ValueError("Files do not have the right number of dimensions: "
                          "{0}. The files we stack should be in 2-d, 3-d, 4-d "
@@ -365,96 +491,64 @@ def load_stack(recipe, input_folder, input_dimension=None):
     return stack
 
 
-def check_recipe(recipe):
-    """Check and validate a recipe.
-
-    Parameters
-    ----------
-    recipe : dict
-        Map the images according to their field of view, their round,
-        their channel and their spatial dimensions.
-
-    Returns
-    -------
-    expected_dimension : int
-        The number of dimensions expected in the tensors used with this
-        recipe.
+def fit_recipe(recipe):
+    """Fit a recipe.
 
-    """
-    # TODO remove the expected dimension ?
-    # check recipe is a dictionary with the "fov" key
-    if (not isinstance(recipe, dict)
-            or "fov" not in recipe
-            or "ext" not in recipe):
-        raise Exception("The recipe is not valid.")
-
-    # determine the minimum number of dimensions expected for the tensors
-    if ("r" in recipe and isinstance(recipe["r"], list)
-            and len(recipe["r"]) > 0):
-        return 4
-    if ("c" in recipe and isinstance(recipe["c"], list)
-            and len(recipe["c"]) > 0):
-        return 3
-    if ("z" in recipe and isinstance(recipe["z"], list)
-            and len(recipe["z"]) > 0):
-        return 2
-    raise Exception("The recipe is not valid.")
-
-
-def _extract_recipe(recipe):
-    """Extract morphemes from the recipe to correctly stack the files.
+    Fitting a recipe consists in wrapping every values of 'fov', 'r', 'c' and
+    'z' in a list (an empty one if necessary). Values for 'ext' and 'opt' are
+    also initialized.
 
     Parameters
     ----------
     recipe : dict
         Map the images according to their field of view, their round,
-        their channel and their spatial dimensions.
+        their channel and their spatial dimensions. Can only contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
 
     Returns
     -------
-    l_round : List[str]
-        List of morphemes used to catch the files from the right round.
-    l_channel : List[str]
-        List of morphemes used to catch the files from the right channel.
-    l_z : List[str]
-        List of morphemes used to catch the files from the right z.
+    new_recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' and 'opt', initialized if
+        necessary.
 
     """
-    # we collect the different morphemes we use to identify the images
-    if ("r" in recipe
-            and isinstance(recipe["r"], list)
-            and len(recipe["r"]) > 0):
-        l_round = recipe["r"]
-    else:
-        l_round = [""]
+    # initialize and fit the dimensions 'fov', 'r', 'c' and 'z'
+    for key in ['fov', 'r', 'c', 'z']:
+        if key not in recipe:
+            recipe[key] = list("")
+        value = recipe[key]
+        if isinstance(value, str):
+            recipe[key] = [value]
 
-    if ("c" in recipe
-            and isinstance(recipe["c"], list)
-            and len(recipe["c"]) > 0):
-        l_channel = recipe["c"]
-    else:
-        l_channel = [""]
-
-    if ("z" in recipe
-            and isinstance(recipe["z"], list)
-            and len(recipe["z"]) > 0):
-        l_z = recipe["z"]
-    else:
-        l_z = [""]
+    # initialize the dimensions 'ext', 'opt'
+    for key in ['ext', 'opt']:
+        if key not in recipe:
+            recipe[key] = ""
 
-    return l_round, l_channel, l_z
+    return recipe
 
 
-def _build_stack_from_2d(recipe, input_folder):
+def _build_stack_from_2d(recipe, input_folder, fov=0, nb_r=1, nb_c=1, nb_z=1):
     """Load and stack 2-d tensors.
 
     Parameters
     ----------
     recipe : dict
         Map the images according to their field of view, their round,
-        their channel and their spatial dimensions.
+        their channel and their spatial dimensions. Only contain the keys
+        'fov', 'r', 'c', 'z', 'ext' or 'opt'.
     input_folder : str
         Path of the folder containing the images.
+    fov : int
+        Index of the fov to build.
+    nb_r : int
+        Number of round file to stack in order to get a 5-d tensor.
+    nb_c : int
+        Number of channel file to stack in order to get a 4-d tensor.
+    nb_z : int
+        Number of z file to stack in order to get a 3-d tensor.
 
     Returns
     -------
@@ -462,55 +556,54 @@ def _build_stack_from_2d(recipe, input_folder):
         Tensor with shape (r, c, z, y, x).
 
     """
-    # check we can find the tensors to stack from the recipe
-    l_round, l_channel, l_z = _extract_recipe(recipe)
 
-    # stack images from the same fov
-    fov_str = recipe["fov"]
-    ext_str = "." + recipe["ext"]
-
-    # stack 4-d tensors in 5-d
+    # load and stack successively z, channel then round elements
     tensors_4d = []
-    for round_str in l_round:
-        if round_str != "":
-            round_str = "_" + round_str
+    for r in range(nb_r):
 
-        # stack 3-d tensors in 4-d
+        # load and stack channel elements (3-d tensors)
         tensors_3d = []
-        for channel_str in l_channel:
-            if channel_str != "":
-                channel_str = "_" + channel_str
+        for c in range(nb_c):
 
-            # stack 2-d tensors in 3-d
+            # load and stack z elements (2-d tensors)
             tensors_2d = []
-            for z_str in l_z:
-                if z_str != "":
-                    z_str = "_" + z_str
-                filename = fov_str + z_str + channel_str + round_str + ext_str
-                path = os.path.join(input_folder, filename)
-                tensor_2d = read_tif(path)
+            for z in range(nb_z):
+                path = get_path_from_recipe(recipe, input_folder, fov=fov,
+                                            r=r, c=c, z=z)
+                tensor_2d = read_image(path)
                 tensors_2d.append(tensor_2d)
+
+            # stack 2-d tensors in 3-d
             tensor_3d = np.stack(tensors_2d, axis=0)
             tensors_3d.append(tensor_3d)
 
+        # stack 3-d tensors in 4-d
         tensor_4d = np.stack(tensors_3d, axis=0)
         tensors_4d.append(tensor_4d)
 
+    # stack 4-d tensors in 5-d
     tensor_5d = np.stack(tensors_4d, axis=0)
 
     return tensor_5d
 
 
-def _build_stack_from_3d(recipe, input_folder):
+def _build_stack_from_3d(recipe, input_folder, fov=0, nb_r=1, nb_c=1):
     """Load and stack 3-d tensors.
 
     Parameters
     ----------
     recipe : dict
         Map the images according to their field of view, their round,
-        their channel and their spatial dimensions.
+        their channel and their spatial dimensions. Only contain the keys
+        'fov', 'r', 'c', 'z', 'ext' or 'opt'.
     input_folder : str
         Path of the folder containing the images.
+    fov : int
+        Index of the fov to build.
+    nb_r : int
+        Number of round file to stack in order to get a 5-d tensor.
+    nb_c : int
+        Number of channel file to stack in order to get a 4-d tensor.
 
     Returns
     -------
@@ -518,46 +611,43 @@ def _build_stack_from_3d(recipe, input_folder):
         Tensor with shape (r, c, z, y, x).
 
     """
-    # check we can find the tensors to stack from the recipe
-    l_round, l_channel, l_z = _extract_recipe(recipe)
-
-    # stack images from the same fov
-    fov_str = recipe["fov"]
-    ext_str = "." + recipe["ext"]
-
-    # stack 4-d tensors in 5-d
+    # load and stack successively channel elements then round elements
     tensors_4d = []
-    for round_str in l_round:
-        if round_str != "":
-            round_str = "_" + round_str
+    for r in range(nb_r):
 
-        # stack 3-d tensors in 4-d
+        # load and stack channel elements (3-d tensors)
         tensors_3d = []
-        for channel_str in l_channel:
-            if channel_str != "":
-                channel_str = "_" + channel_str
-            filename = fov_str + channel_str + round_str + ext_str
-            path = os.path.join(input_folder, filename)
-            tensor_3d = read_tif(path)
+        for c in range(nb_c):
+            path = get_path_from_recipe(recipe, input_folder, fov=fov, r=r,
+                                        c=c)
+            tensor_3d = read_image(path)
             tensors_3d.append(tensor_3d)
-        tensor_4d = np.stack(tensors_3d, axis=0)
-        tensors_4d.append(tensor_4d)
 
+            # stack 3-d tensors in 4-d
+            tensor_4d = np.stack(tensors_3d, axis=0)
+            tensors_4d.append(tensor_4d)
+
+    # stack 4-d tensors in 5-d
     tensor_5d = np.stack(tensors_4d, axis=0)
 
     return tensor_5d
 
 
-def _build_stack_from_4d(recipe, input_folder):
+def _build_stack_from_4d(recipe, input_folder, fov=0, nb_r=1):
     """Load and stack 4-d tensors.
 
     Parameters
     ----------
     recipe : dict
         Map the images according to their field of view, their round,
-        their channel and their spatial dimensions.
+        their channel and their spatial dimensions. Only contain the keys
+        'fov', 'r', 'c', 'z', 'ext' or 'opt'.
     input_folder : str
         Path of the folder containing the images.
+    fov : int
+        Index of the fov to build.
+    nb_r : int
+        Number of round file to stack in order to get a 5-d tensor.
 
     Returns
     -------
@@ -565,37 +655,32 @@ def _build_stack_from_4d(recipe, input_folder):
         Tensor with shape (r, c, z, y, x).
 
     """
-    # check we can find the tensors to stack from the recipe
-    l_round, l_channel, l_z = _extract_recipe(recipe)
-
-    # stack images from the same fov
-    fov_str = recipe["fov"]
-    ext_str = "." + recipe["ext"]
-
-    # stack 4-d tensors in 5-d
+    # load each file from a new round element and stack them
     tensors_4d = []
-    for round_str in l_round:
-        if round_str != "":
-            round_str = "_" + round_str
-        filename = fov_str + round_str + ext_str
-        path = os.path.join(input_folder, filename)
-        tensor_4d = read_tif(path)
+    for r in range(nb_r):
+        path = get_path_from_recipe(recipe, input_folder, fov=fov, r=r)
+        tensor_4d = read_image(path)
         tensors_4d.append(tensor_4d)
+
+    # stack 4-d tensors in 5-d
     tensor_5d = np.stack(tensors_4d, axis=0)
 
     return tensor_5d
 
 
-def _build_stack_from_5d(recipe, input_folder):
+def _build_stack_from_5d(recipe, input_folder, fov=0):
     """Load directly a 5-d tensor.
 
     Parameters
     ----------
     recipe : dict
         Map the images according to their field of view, their round,
-        their channel and their spatial dimensions.
+        their channel and their spatial dimensions. Only contain the keys
+        'fov', 'r', 'c', 'z', 'ext' or 'opt'.
     input_folder : str
         Path of the folder containing the images.
+    fov : int
+        Index of the fov to build.
 
     Returns
     -------
@@ -603,318 +688,302 @@ def _build_stack_from_5d(recipe, input_folder):
         Tensor with shape (r, c, z, y, x).
 
     """
-    # stack the images
-    fov_str = recipe["fov"]
-    ext_str = "." + recipe["ext"]
-    filename = fov_str + ext_str
-    path = os.path.join(input_folder, filename)
-    tensor_5d = read_tif(path)
+    # the recipe can only contain one file with a 5-d tensor per fov
+    path = get_path_from_recipe(recipe, input_folder, fov=fov)
+    tensor_5d = read_image(path)
 
     return tensor_5d
 
 
-# ### Projections 2-d ###
-
-def projection(tensor, method="mip", r=0, c=0):
-    """ Project a tensor along the z-dimension.
+def get_path_from_recipe(recipe, input_folder, fov=0, r=0, c=0, z=0):
+    """Build the path of a file from a recipe and the indices of specific
+    elements.
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint
-        A 5-d tensor with shape (r, c, z, y, x).
-    method : str
-        Method used to project ('mip', 'focus').
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Only contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
+    input_folder : str
+        Path of the folder containing the images.
+    fov : int
+        Index of the 'fov' element in the recipe to use in the filename.
     r : int
-        Index of a specific round to project.
+        Index of the 'r' element in the recipe to use in the filename.
     c : int
-        Index of a specific channel to project.
+        Index of the 'c' element in the recipe to use in the filename.
+    z : int
+        Index of the 'z' element in the recipe to use in the filename.
 
     Returns
     -------
-    projected_tensor : np.ndarray
-        A 2-d tensor with shape (y, x).
+    path : str
+        Path of the file to load.
 
     """
-    # check tensor dimensions and its dtype
-    check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+    # build a map of the elements' indices
+    map_element_index = {"fov": fov, "r": r, "c": c, "z": z}
+
+    # get filename pattern and decompose it
+    recipe_pattern = recipe["pattern"]
+    path_elements = re.findall("fov|r|c|z|ext|opt", recipe_pattern)
+    path_separators = re.split("fov|r|c|z|ext|opt", recipe_pattern)
+
+    # get filename recombining elements of the recipe
+    filename = path_separators[0]  # usually an empty string
+    for (element_name, separator) in zip(path_elements, path_separators):
+        # if we need an element from a list of elements of the same dimension
+        # (eg. to pick a specific channel 'c' among a list of channels)
+        if element_name in map_element_index:
+            element_index = map_element_index[element_name]
+            element = recipe[element_name][element_index]
+        # if this element is unique for all the recipe (eg. 'fov')
+        else:
+            element = recipe[element_name]
+        # the filename is built ensuring the order of apparition of the
+        # different morphemes and their separators
+        filename += element
+        filename += separator
 
-    # apply projection along the z-dimension
-    projected_tensor = tensor[r, c, :, :, :]
-    if method == "mip":
-        projected_tensor = maximum_projection(projected_tensor)
-    elif method == "mean":
-        projected_tensor = mean_projection(projected_tensor)
-    elif method == "median":
-        projected_tensor = median_projection(projected_tensor)
-    elif method == "focus":
-        # TODO complete focus projection with different strategies
-        raise ValueError("Focus projection is not implemented yet.")
+    # get path
+    path = os.path.join(input_folder, filename)
 
-    return projected_tensor
+    return path
 
 
-def maximum_projection(tensor):
-    """Project the z-dimension of a tensor, keeping the maximum intensity of
-    each yx pixel.
+def get_nb_element_per_dimension(recipe):
+    """Count the number of element to stack for each dimension ('r', 'c'
+    and 'z').
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint
-        A 3-d tensor with shape (z, y, x).
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Only contain the keys
+        'fov', 'r', 'c', 'z', 'ext' or 'opt'.
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.uint
-        A 2-d tensor with shape (y, x).
+    nb_r : int
+        Number of rounds to be stacked.
+    nb_c : int
+        Number of channels to be stacked.
+    nb_z : int
+        Number of z layers to be stacked.
 
     """
-    # project tensor along the z axis
-    projected_tensor = tensor.max(axis=0, keepdims=True)
-
-    return projected_tensor[0]
+    return len(recipe["r"]), len(recipe["c"]), len(recipe["z"])
 
 
-def mean_projection(tensor):
-    """Project the z-dimension of a tensor, computing the mean intensity of
-    each yx pixel.
+def get_input_dimension(recipe, input_folder):
+    """ Load an arbitrary image to get the original dimension of the files.
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint
-        A 3-d tensor with shape (z, y, x).
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Only contain the keys
+        'fov', 'r', 'c', 'z', 'ext' or 'opt'.
+    input_folder : str
+        Path of the folder containing the images.
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.float
-        A 2-d tensor with shape (y, x).
+    nb_dim : int
+        Number of dimensions of the original file.
 
     """
-    # project tensor along the z axis
-    projected_tensor = tensor.mean(axis=0, keepdims=True)
-
-    return projected_tensor[0]
-
-
-def median_projection(tensor):
-    """Project the z-dimension of a tensor, computing the median intensity of
-    each yx pixel.
-
-    Parameters
-    ----------
-    tensor : np.ndarray, np.uint
-        A 3-d tensor with shape (z, y, x).
+    # get a valid path from the recipe
+    path = get_path_from_recipe(recipe, input_folder)
 
-    Returns
-    -------
-    projected_tensor : np.ndarray, np.uint
-        A 2-d tensor with shape (y, x).
+    # load the image and return the number of dimensions
+    image = read_image(path)
+    nb_dim = image.ndim
 
-    """
-    # project tensor along the z axis
-    projected_tensor = tensor.median(axis=0, keepdims=True)
+    return nb_dim
 
-    return projected_tensor[0]
 
-
-def focus_projection(tensor, channel=0, p=0.75, global_neighborhood_size=30,
-                     method="best"):
-    """
+def build_stack_no_recipe(paths, input_dimension=None, check=False,
+                          normalize=False, channel_to_stretch=None,
+                          stretching_percentile=99.9, cast_8bit=False):
+    """Build 5-d stack and normalize it, without recipe.
 
     Parameters
     ----------
-    tensor
-    channel
-    p
-    global_neighborhood_size
-    method
+    paths : List[str]
+        List of the paths to stack.
+    input_dimension : str
+        Number of dimensions of the loaded files.
+    check : bool
+        Check the validity of the loaded tensor.
+    normalize : bool
+        Normalize the different channels of the loaded stack (rescaling).
+    channel_to_stretch : int or List[int]
+        Channel to stretch.
+    stretching_percentile : float
+        Percentile to determine the maximum intensity value used to rescale
+        the image.
+    cast_8bit : bool
+        Cast the tensor in np.uint8.
 
     Returns
     -------
+    tensor : np.ndarray, np.uint
+        Tensor with shape (r, c, z, y, x).
 
     """
+    # check parameters
+    check_parameter(normalize=bool,
+                    channel_to_stretch=(int, list, type(None)),
+                    stretching_percentile=float,
+                    cast_8bit=bool)
+
+    # build stack from tif files
+    tensor = load_stack_no_recipe(paths, input_dimension)
+
+    # check the validity of the loaded tensor
+    if check:
+        check_array(tensor,
+                    ndim=5,
+                    dtype=[np.uint8, np.uint16],
+                    allow_nan=False)
 
-    # get 3-d image
-    image = tensor[0, channel, :, :, :]
-
-    # measure global focus level for each z-slices
-    ratio, l_focus = focus_measurement_3d(image, global_neighborhood_size)
-
-    # remove out-of-focus slices
-    indices_to_keep = get_in_focus(l_focus, p)
-    in_focus_image = image[indices_to_keep]
-
-    projected_image = None
-    if method == "bast":
-        # for each pixel, we project the z-slice value with the highest focus
-        ratio_2d = np.argmax(ratio[indices_to_keep], axis=0)
-        one_hot = one_hot_3d(ratio_2d, depth=len(indices_to_keep))
-        projected_image = np.multiply(in_focus_image, one_hot).max(axis=0)
-    elif method == "median":
-        # for each pixel, we compute the median value of the in-focus z-slices
-        projected_image = np.median(in_focus_image, axis=0)
-    elif method == "mean":
-        # for each pixel, we compute the mean value of the in-focus z-slices
-        projected_image = np.median(in_focus_image, axis=0)
-
-    return projected_image, ratio, l_focus
-
-
-def focus_measurement_2d(image, neighborhood_size):
-    """Helmli and Scherer’s mean method used as a focus metric.
+    # rescale data and improve contrast
+    if normalize:
+        tensor = rescale(tensor, channel_to_stretch, stretching_percentile)
 
-    For each pixel xy in an image, we compute the ratio:
+    # cast in np.uint8 if necessary, in order to reduce memory allocation
+    if tensor.dtype == np.uint16 and cast_8bit:
+        tensor = cast_img_uint8(tensor)
 
-        R(x, y) = mu(x, y) / I(x, y), if mu(x, y) >= I(x, y)
+    return tensor
 
-    or
 
-        R(x, y) = I(x, y) / mu(x, y), otherwise
+def load_stack_no_recipe(paths, input_dimension=None):
+    """Build a 5-d tensor from the same field of view (fov), without recipe.
 
-    with I(x, y) the intensity of the pixel xy and mu(x, y) the mean intensity
-    of the pixels of its neighborhood.
+    Files with a path listed are stacked together, then empty dimensions are
+    added up to 5.
 
     Parameters
     ----------
-    image : np.ndarray, np.float32
-        A 2-d tensor with shape (y, x).
-    neighborhood_size : int
-        The size of the square used to define the neighborhood of each pixel.
+    paths : List[str]
+        List of the file to stack.
+    input_dimension : str
+        Number of dimensions of the loaded files.
 
     Returns
     -------
-    global_focus : np.float32
-        Mean value of the ratio computed for every pixels of the image. Can be
-        used as a metric to quantify the focus level of an 2-d image.
-    ratio : np.ndarray, np.float32
-        A 2-d tensor with the R(x, y) computed for each pixel of the original
-        image.
-    image_filtered_mean : np.ndarray, np.float32
-        A 2-d tensor with shape (y, x).
+    tensor_5d : np.ndarray, np.uint
+        Tensor with shape (r, c, z, y, x).
 
     """
+    # check parameters
+    check_parameter(paths=str,
+                    input_dimension=(int, type(None)))
 
-    # scikit-image filter use np.uint dtype (so we cast to np.uint8)
-    image_2d = img_as_ubyte(image)
+    # load an image and get the number of dimensions
+    if input_dimension is None:
+        testfile = read_image(paths[0])
+        input_dimension = testfile.ndim
 
-    # filter the image with a mean filter
-    selem = square(neighborhood_size)
-    image_filtered_mean = rank.mean(image_2d, selem)
+    # get stacks
+    stacks = []
+    for path in paths:
+        s = read_image(path)
+        stacks.append(s)
 
-    # cast again in np.float32
-    image_2d = img_as_float32(image_2d)
-    image_filtered_mean = img_as_float32(image_filtered_mean)
+    # we stack our files according to their initial dimension
+    if input_dimension == 2:
+        tensor_3d = np.stack(stacks, axis=0)
+        tensor_5d = tensor_3d[np.newaxis, np.newaxis, :, :, :]
+    elif input_dimension == 3:
+        tensor_4d = np.stack(stacks, axis=0)
+        tensor_5d = tensor_4d[np.newaxis, :, :, :, :]
+    elif input_dimension == 4:
+        tensor_5d = np.stack(stacks, axis=0)
+    elif input_dimension == 5 and len(stacks) == 1:
+        tensor_5d = stacks[0]
+    else:
+        raise ValueError("Files do not have the right number of dimensions: "
+                         "{0}. The files we stack should be in 2-d, 3-d, 4-d "
+                         "or 5-d.".format(input_dimension))
 
-    # case where mu(x, y) >= I(x, y)
-    mask_1 = image_2d != 0
-    out_1 = np.zeros_like(image_filtered_mean, dtype=np.float32)
-    ratio_1 = np.divide(image_filtered_mean, image_2d, out=out_1, where=mask_1)
-    ratio_1 = np.where(image_filtered_mean >= image_2d, ratio_1, 0)
+    return tensor_5d
 
-    # case where I(x, y) > mu(x, y)
-    mask_2 = image_filtered_mean != 0
-    out_2 = np.zeros_like(image_2d, dtype=np.float32)
-    ratio_2 = np.divide(image_2d, image_filtered_mean, out=out_2, where=mask_2)
-    ratio_2 = np.where(image_2d > image_filtered_mean, ratio_2, 0)
 
-    # compute ratio and global focus for the entire image
-    ratio = ratio_1 + ratio_2
-    global_focus = ratio.mean()
+# ### Normalization ###
 
-    return global_focus, ratio, image_filtered_mean
+def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
+    """Rescale tensor values up to its dtype range.
 
+    Each round and each channel is rescaled independently.
 
-def focus_measurement_3d(image, neighborhood_size):
-    """Helmli and Scherer’s mean method used as a focus metric.
+    We can improve the contrast of the image by stretching its range of
+    intensity values. To do that we provide a smaller range of pixel intensity
+    to rescale, spreading out the information contained in the original
+    histogram. Usually, we apply such normalization to smFish channels. Other
+    channels are simply rescale from the minimum and maximum intensity values
+    of the image to those of its dtype.
 
     Parameters
     ----------
-    image : np.ndarray, np.float32
-        A 3-d tensor with shape (z, y, x).
-    neighborhood_size : int
-        The size of the square used to define the neighborhood of each pixel.
+    tensor : np.ndarray, np.uint
+        Tensor to rescale with shape (r, c, z, y, x), (c, z, y, x), (z, y, x)
+        or (y, x).
+    channel_to_stretch : int or List[int]
+        Channel to stretch.
+    stretching_percentile : float
+        Percentile to determine the maximum intensity value used to rescale
+        the image.
 
     Returns
     -------
-    ratio : np.ndarray, np.float32
-        A 3-d tensor with the R(x, y) computed for each pixel of the original
-        3-d image, for each z-slice.
-    l_focus : list
-        List of the global focus computed for each z-slice.
+    tensor : np.ndarray, np.uint
+        Tensor to rescale with shape (r, c, z, y, x).
 
     """
-    # apply focus_measurement_2d for each z-slice
-    l_ratio = []
-    l_focus = []
-    for z in range(image.shape[0]):
-        focus, ratio_2d, _ = focus_measurement_2d(image[z], neighborhood_size)
-        l_ratio.append(ratio_2d)
-        l_focus.append(focus)
-
-    # get 3-d Helmli and Scherer’s ratio
-    ratio = np.stack(l_ratio)
-
-    return ratio, l_focus
+    # check parameters
+    check_array(tensor, ndim=[2, 3, 4, 5], dtype=[np.uint8, np.uint16])
+    check_parameter(channel_to_stretch=(int, list, type(None)),
+                    stretching_percentile=float)
 
+    # format 'channel_to_stretch'
+    if channel_to_stretch is None:
+        channel_to_stretch = []
+    elif isinstance(channel_to_stretch, int):
+        channel_to_stretch = [channel_to_stretch]
 
-def get_in_focus(l_focus, proportion):
-    """ Select the best in-focus z-slices.
-
-    Parameters
-    ----------
-    l_focus : array_like
-        List of the global focus computed for each z-slice.
-    proportion : float or int
-        Proportion of z-slices to keep (float between 0 and 1) or number of
-        z-slices to keep (integer above 1).
-
-    Returns
-    -------
-    indices_to_keep : np.array
-    """
-    # get the number of z-slices to keep
-    if proportion < 1 and isinstance(proportion, float):
-        n = int(len(l_focus) * proportion)
+    # get a 5-d tensor
+    original_ndim = tensor.ndim
+    if original_ndim == 2:
+        tensor_5d = tensor[np.newaxis, np.newaxis, np.newaxis, ...]
+    elif original_ndim == 3:
+        tensor_5d = tensor[np.newaxis, np.newaxis, ...]
+    elif original_ndim == 4:
+        tensor_5d = tensor[np.newaxis, ...]
     else:
-        n = int(proportion)
-
-    # select the best z-slices
-    indices_to_keep = np.argsort(l_focus)[-n:]
-
-    return indices_to_keep
-
-
-def one_hot_3d(tensor_2d, depth):
-    """Build a 3-d one-hot matrix from a 2-d indices matrix.
-
-    Parameters
-    ----------
-    tensor_2d : np.ndarray, int
-        A 2-d tensor with integer indices and shape (y, x).
-    depth : int
-        Depth of the 3-d one-hot matrix.
-
-    Returns
-    -------
-    one_hot : np.ndarray, np.uint8
-        A 3-d binary tensor with shape (depth, y, x)
-
-    """
-    # initialize the 3-d one-hot matrix
-    one_hot = np.zeros((tensor_2d.size, depth), dtype=np.uint8)
-
-    # flatten the matrix to easily one-hot encode it, then reshape it
-    one_hot[np.arange(tensor_2d.size), tensor_2d.ravel()] = 1
-    one_hot.shape = tensor_2d.shape + (depth,)
-
-    # rearrange the axis
-    one_hot = np.moveaxis(one_hot, source=2, destination=0)
-
-    return one_hot
+        tensor_5d = tensor
+
+    # rescale
+    tensor_5d = _rescale_5d(tensor_5d, channel_to_stretch,
+                            stretching_percentile)
+
+    # rebuild the original tensor shape
+    if original_ndim == 2:
+        tensor = tensor_5d[0, 0, 0, :, :]
+    elif original_ndim == 3:
+        tensor = tensor_5d[0, 0, :, :, :]
+    elif original_ndim == 4:
+        tensor = tensor_5d[0, :, :, :, :]
+    else:
+        tensor = tensor_5d
 
+    return tensor
 
-# ### Normalization ###
 
-def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
+def _rescale_5d(tensor, channel_to_stretch, stretching_percentile):
     """Rescale tensor values up to its dtype range.
 
     Each round and each channel is rescaled independently.
@@ -930,7 +999,7 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
     ----------
     tensor : np.ndarray, np.uint
         Tensor to rescale with shape (r, c, z, y, x).
-    channel_to_stretch : int or List[int]
+    channel_to_stretch : List[int]
         Channel to stretch.
     stretching_percentile : float
         Percentile to determine the maximum intensity value used to rescale
@@ -942,15 +1011,6 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
         Tensor to rescale with shape (r, c, z, y, x).
 
     """
-    # check tensor dtype
-    check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-
-    # format 'channel_to_stretch'
-    if channel_to_stretch is None:
-        channel_to_stretch = []
-    elif isinstance(channel_to_stretch, int):
-        channel_to_stretch = [channel_to_stretch]
-
     # rescale each round independently
     rounds = []
     for r in range(tensor.shape[0]):
@@ -977,6 +1037,10 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
 def cast_img_uint8(tensor):
     """Cast the image in np.uint8.
 
+    Negative values (from np.float tensors) are not allowed as the skimage
+    method 'img_as_ubyte' would clip them to 0. Positives values are scaled
+    between 0 and 255.
+
     Casting image to np.uint8 reduce the memory needed to process it and
     accelerate computations.
 
@@ -991,7 +1055,6 @@ def cast_img_uint8(tensor):
         Image cast.
 
     """
-    # TODO validate the warnings
     # check tensor dtype
     check_array(tensor, dtype=[np.uint8, np.uint16,
                                np.float32, np.float64,
@@ -1008,14 +1071,6 @@ def cast_img_uint8(tensor):
                              "and {2}."
                              .format(tensor.dtype, tensor.min(), tensor.max()))
 
-    # check the range value for integer tensors
-    #elif tensor.dtype == np.uint16:
-    #    if not check_range_value(tensor, 0, 255):
-    #        raise ValueError("To cast a tensor from np.uint16 to np.uint8, "
-    #                         "its values must be between 0 and 255, and not "
-    #                         "{0} and {1}. Otherwise, the values are clipped."
-    #                         .format(tensor.min(), tensor.max()))
-
     # cast tensor
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
@@ -1027,6 +1082,10 @@ def cast_img_uint8(tensor):
 def cast_img_uint16(tensor):
     """Cast the data in np.uint16.
 
+    Negative values (from np.float tensors) are not allowed as the skimage
+    method 'img_as_uint' would clip them to 0. Positives values are scaled
+    between 0 and 65535.
+
     Parameters
     ----------
     tensor : np.ndarray
@@ -1039,10 +1098,13 @@ def cast_img_uint16(tensor):
 
     """
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint8,
+    check_array(tensor, dtype=[np.uint8, np.uint16,
                                np.float32, np.float64,
                                np.bool])
 
+    if tensor.dtype == np.uint16:
+        return tensor
+
     # check the range value for float tensors
     if tensor.dtype in [np.float32, np.float64]:
         if not check_range_value(tensor, 0, 1):
@@ -1060,12 +1122,14 @@ def cast_img_uint16(tensor):
 
 
 def cast_img_float32(tensor):
-    """Cast the data in np.float32 and scale it between 0 and 1.
+    """Cast the data in np.float32.
 
-    If the input data is already in np.float, the values are not rescaled.
+    If the input data is in np.uint8 or np.uint16, the values are scale
+    between 0 and 1. When converting from a np.float dtype, values are not
+    modified.
 
     Casting image to np.float32 reduce the memory needed to process it and
-    accelerate computations.
+    accelerate computations (compare to np.float64).
 
     Parameters
     ----------
@@ -1080,7 +1144,8 @@ def cast_img_float32(tensor):
     """
     # check tensor dtype
     check_array(tensor, dtype=[np.uint8, np.uint16,
-                               np.float64, np.bool])
+                               np.float32, np.float64,
+                               np.bool])
 
     # cast tensor
     with warnings.catch_warnings():
@@ -1091,9 +1156,11 @@ def cast_img_float32(tensor):
 
 
 def cast_img_float64(tensor):
-    """Cast the data in np.float64 and scale it between 0 and 1.
+    """Cast the data in np.float64.
 
-    If the input data is already in np.float, the values are not rescaled.
+    If the input data is in np.uint8 or np.uint16, the values are scale
+    between 0 and 1. When converting from a np.float dtype, values are not
+    modified.
 
     Parameters
     ----------
@@ -1108,7 +1175,7 @@ def cast_img_float64(tensor):
     """
     # check tensor dtype
     check_array(tensor, dtype=[np.uint8, np.uint16,
-                               np.float32,
+                               np.float32, np.float64,
                                np.bool])
 
     # cast tensor
@@ -1119,348 +1186,8 @@ def cast_img_float64(tensor):
     return tensor
 
 
-# ### Filters ###
-
-def _define_kernel(shape, size, dtype):
-    """Build a kernel to apply a filter on images.
-
-    Parameters
-    ----------
-    shape : str
-        Shape of the kernel used to compute the filter ('diamond', 'disk',
-        'rectangle' or 'square').
-    size : int or Tuple(int)
-        The size of the kernel. For the rectangle we expect two integers
-        (width, height).
-    dtype : type
-        Dtype used for the kernel (the same as the image).
-
-    Returns
-    -------
-    kernel : skimage.morphology.selem object
-        Kernel to use with a skimage filter.
-
-    """
-    # build the kernel
-    if shape == "diamond":
-        kernel = diamond(size, dtype=dtype)
-    elif shape == "disk":
-        kernel = disk(size, dtype=dtype)
-    elif shape == "rectangle" and isinstance(size, tuple):
-        kernel = rectangle(size[0], size[1], dtype=dtype)
-    elif shape == "square":
-        kernel = square(size, dtype=dtype)
-    else:
-        raise ValueError("Kernel definition is wrong.")
-
-    return kernel
-
-
-def mean_filter(image, kernel_shape, kernel_size):
-    """Apply a mean filter to a 2-d image.
-
-    Parameters
-    ----------
-    image : np.ndarray, np.uint
-        Image with shape (y, x).
-    kernel_shape : str
-        Shape of the kernel used to compute the filter ('diamond', 'disk',
-        'rectangle' or 'square').
-    kernel_size : int or Tuple(int)
-        The size of the kernel. For the rectangle we expect two integers
-        (width, height).
-
-    Returns
-    -------
-    image_filtered : np.ndarray, np.uint
-        Filtered 2-d image with shape (y, x).
-
-    """
-    # check image dtype and ndim
-    check_array(image, ndim=2, dtype=[np.uint8, np.uint16])
-
-    # get kernel
-    kernel = _define_kernel(shape=kernel_shape,
-                            size=kernel_size,
-                            dtype=image.dtype)
-
-    # apply filter
-    image_filtered = rank.mean(image, kernel)
-
-    return image_filtered
-
-
-def median_filter(image, kernel_shape, kernel_size):
-    """Apply a median filter to a 2-d image.
-
-    Parameters
-    ----------
-    image : np.ndarray, np.uint
-        Image with shape (y, x).
-    kernel_shape : str
-        Shape of the kernel used to compute the filter ('diamond', 'disk',
-        'rectangle' or 'square').
-    kernel_size : int or Tuple(int)
-        The size of the kernel. For the rectangle we expect two integers
-        (width, height).
-
-    Returns
-    -------
-    image_filtered : np.ndarray, np.uint
-        Filtered 2-d image with shape (y, x).
-
-    """
-    # check image dtype and ndim
-    check_array(image, ndim=2, dtype=[np.uint8, np.uint16])
-
-    # get kernel
-    kernel = _define_kernel(shape=kernel_shape,
-                            size=kernel_size,
-                            dtype=image.dtype)
-
-    # apply filter
-    image_filtered = rank.median(image, kernel)
-
-    return image_filtered
-
-
-def maximum_filter(image, kernel_shape, kernel_size):
-    """Apply a maximum filter to a 2-d image.
-
-    Parameters
-    ----------
-    image : np.ndarray, np.uint
-        Image with shape (y, x).
-    kernel_shape : str
-        Shape of the kernel used to compute the filter ('diamond', 'disk',
-        'rectangle' or 'square').
-    kernel_size : int or Tuple(int)
-        The size of the kernel. For the rectangle we expect two integers
-        (width, height).
-
-    Returns
-    -------
-    image_filtered : np.ndarray, np.uint
-        Filtered 2-d image with shape (y, x).
-
-    """
-    # check image dtype and ndim
-    check_array(image, ndim=2, dtype=[np.uint8, np.uint16])
-
-    # get kernel
-    kernel = _define_kernel(shape=kernel_shape,
-                            size=kernel_size,
-                            dtype=image.dtype)
-
-    # apply filter
-    image_filtered = rank.maximum(image, kernel)
-
-    return image_filtered
-
-
-def minimum_filter(image, kernel_shape, kernel_size):
-    """Apply a minimum filter to a 2-d image.
-
-    Parameters
-    ----------
-    image : np.ndarray, np.uint
-        Image with shape (y, x).
-    kernel_shape : str
-        Shape of the kernel used to compute the filter ('diamond', 'disk',
-        'rectangle' or 'square').
-    kernel_size : int or Tuple(int)
-        The size of the kernel. For the rectangle we expect two integers
-        (width, height).
-
-    Returns
-    -------
-    image_filtered : np.ndarray, np.uint
-        Filtered 2-d image with shape (y, x).
-
-    """
-    # check image dtype and ndim
-    check_array(image, ndim=2, dtype=[np.uint8, np.uint16])
-
-    # get kernel
-    kernel = _define_kernel(shape=kernel_shape,
-                            size=kernel_size,
-                            dtype=image.dtype)
-
-    # apply filter
-    image_filtered = rank.minimum(image, kernel)
-
-    return image_filtered
-
-
-def log_filter(image, sigma):
-    """Apply a Laplacian of Gaussian filter to a 2-d or 3-d image.
-
-    The function returns the inverse of the filtered image such that the pixels
-    with the highest intensity from the original (smoothed) image have
-    positive values. Those with a low intensity returning a negative value are
-    clipped to zero.
-
-    Parameters
-    ----------
-    image : np.ndarray
-        Image with shape (z, y, x) or (y, x).
-    sigma : float or Tuple(float)
-        Sigma used for the gaussian filter (one for each dimension). If it's a
-        float, the same sigma is applied to every dimensions.
-
-    Returns
-    -------
-    image_filtered : np.ndarray, np.float
-        Filtered image.
-    """
-    # check image dtype and ndim
-    check_array(image, ndim=[2, 3], dtype=[np.uint8, np.uint16,
-                                           np.float32, np.float64])
-
-    # we cast the data in np.float to allow negative values
-    image_float = None
-    if image.dtype == np.uint8:
-        image_float = cast_img_float32(image)
-    elif image.dtype == np.uint16:
-        image_float = cast_img_float64(image)
-
-    # check sigma
-    if isinstance(sigma, (tuple, list)):
-        if len(sigma) != image.ndim:
-            raise ValueError("'Sigma' must be a scalar or a sequence with the "
-                             "same length as 'image.ndim'.")
-
-    # we apply LoG filter
-    image_filtered = gaussian_laplace(image_float, sigma=sigma)
-
-    # as the LoG filter makes the peaks in the original image appear as a
-    # reversed mexican hat, we inverse the result and clip negative values to 0
-    image_filtered = np.clip(-image_filtered, a_min=0, a_max=None)
-
-    return image_filtered
-
-
-def gaussian_filter(image, sigma):
-    """Apply a Gaussian filter to a 2-d or 3-d image.
-
-    Parameters
-    ----------
-    image : np.ndarray, np.uint
-        Image with shape (z, y, x) or (y, x).
-    sigma : float or Tuple(float)
-        Sigma used for the gaussian filter (one for each dimension). If it's a
-        float, the same sigma is applied to every dimensions.
-
-    Returns
-    -------
-    image_filtered : np.ndarray, np.float
-        Filtered image.
-
-    """
-    # TODO check for negative values
-    # check image dtype and ndim
-    check_array(image, ndim=[2, 3], dtype=[np.uint8, np.uint16,
-                                           np.float32, np.float64])
-
-    # we cast the data in np.float to allow negative values
-    image_float = None
-    if image.dtype == np.uint8:
-        image_float = cast_img_float32(image)
-    elif image.dtype == np.uint16:
-        image_float = cast_img_float64(image)
-
-    # we apply gaussian filter
-    image_filtered = gaussian(image_float, sigma=sigma)
-
-    return image_filtered
-
-
-# ### Illumination surface ###
-
-def compute_illumination_surface(stacks, sigma=None):
-    """Compute the illumination surface of a specific experiment.
-
-    Parameters
-    ----------
-    stacks : np.ndarray, np.uint
-        Concatenated 5-d tensors along the z-dimension with shape
-        (r, c, z, y, x). They represent different images acquired during a
-        same experiment.
-    sigma : int
-        Sigma of the gaussian filtering used to smooth the illumination
-        surface.
-
-    Returns
-    -------
-    illumination_surfaces : np.ndarray, np.float
-        A 4-d tensor with shape (r, c, y, x) approximating the average
-        differential of illumination in our stack of images, for each channel
-        and each round.
-
-    """
-    # check stacks dtype and ndim
-    check_array(stacks, ndim=5, dtype=[np.uint8, np.uint16])
-
-    # initialize illumination surfaces
-    r, c, z, y, x = stacks.shape
-    illumination_surfaces = np.zeros((r, c, y, x))
-
-    # compute mean over the z-dimension
-    mean_stacks = np.mean(stacks, axis=2)
-
-    # separate the channels and the rounds
-    for i_round in range(r):
-        for i_channel in range(c):
-            illumination_surface = mean_stacks[i_round, i_channel, :, :]
-
-            # smooth the surface
-            if sigma is not None:
-                illumination_surface = gaussian(illumination_surface, sigma)
-
-            illumination_surfaces[i_round, i_channel] = illumination_surface
-
-    return illumination_surfaces
-
-
-def correct_illumination_surface(tensor, illumination_surfaces):
-    """Correct a tensor with uneven illumination.
-
-    Parameters
-    ----------
-    tensor : np.ndarray, np.uint
-        A 5-d tensor with shape (r, c, z, y, x).
-    illumination_surfaces : np.ndarray, np.float
-        A 4-d tensor with shape (r, c, y, x) approximating the average
-        differential of illumination in our stack of images, for each channel
-        and each round.
-
-    Returns
-    -------
-    tensor_corrected : np.ndarray, np.float
-        A 5-d tensor with shape (r, c, z, y, x).
-
-    """
-    # check dtype and ndim
-    check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-    check_array(illumination_surfaces, ndim=4, dtype=[np.float32, np.float64])
-
-    # initialize corrected tensor
-    tensor_corrected = np.zeros_like(tensor)
-
-    # TODO control the multiplication and the division
-    # correct each round/channel independently
-    r, c, _, _, _ = tensor.shape
-    for i_round in range(r):
-        for i_channel in range(c):
-            image_3d = tensor[i_round, i_channel, ...]
-            s = illumination_surfaces[i_round, i_channel]
-            tensor_corrected[i_round, i_channel] = image_3d * np.mean(s) / s
-
-    return tensor_corrected
-
-
 # ### Coordinates data cleaning ###
-
+# TODO add safety check for these cleaning functions
 def clean_simulated_data(data, data_cell, path_output=None):
     """Clean simulated dataset.
 

From d99234699a4b1a69e223c21f7641d342ddbfce2f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Apr 2019 19:53:01 +0200
Subject: [PATCH 124/264] refactor rescaling

---
 bigfish/stack/preprocess.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index e330395b..41a16956 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -941,7 +941,8 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
     Returns
     -------
     tensor : np.ndarray, np.uint
-        Tensor to rescale with shape (r, c, z, y, x).
+        Tensor to rescale with shape (r, c, z, y, x), (c, z, y, x), (z, y, x)
+        or (y, x).
 
     """
     # check parameters

From 00f69dc10530883559c4c59a183b9137e3d65b0a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Apr 2019 19:54:55 +0200
Subject: [PATCH 125/264] refactor rescaling #2

---
 bigfish/stack/preprocess.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 41a16956..63f6c4e8 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -26,7 +26,6 @@
 
 
 # TODO add safety checks
-# TODO add a stack builder without recipe
 
 # ### Simulated data ###
 
@@ -946,7 +945,10 @@ def rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9):
 
     """
     # check parameters
-    check_array(tensor, ndim=[2, 3, 4, 5], dtype=[np.uint8, np.uint16])
+    check_array(tensor,
+                ndim=[2, 3, 4, 5],
+                dtype=[np.uint8, np.uint16],
+                allow_nan=False)
     check_parameter(channel_to_stretch=(int, list, type(None)),
                     stretching_percentile=float)
 

From e767525c01c313806c0ebc99d99efaf64d309421 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Apr 2019 19:59:28 +0200
Subject: [PATCH 126/264] refactor casting and improve sanity checks

---
 bigfish/stack/preprocess.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 63f6c4e8..9fe39a3b 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -1059,9 +1059,9 @@ def cast_img_uint8(tensor):
 
     """
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint8, np.uint16,
-                               np.float32, np.float64,
-                               np.bool])
+    check_array(tensor,
+                dtype=[np.uint8, np.uint16, np.float32, np.float64, np.bool],
+                allow_nan=False)
 
     if tensor.dtype == np.uint8:
         return tensor
@@ -1101,9 +1101,9 @@ def cast_img_uint16(tensor):
 
     """
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint8, np.uint16,
-                               np.float32, np.float64,
-                               np.bool])
+    check_array(tensor,
+                dtype=[np.uint8, np.uint16, np.float32, np.float64, np.bool],
+                allow_nan=False)
 
     if tensor.dtype == np.uint16:
         return tensor
@@ -1146,9 +1146,9 @@ def cast_img_float32(tensor):
 
     """
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint8, np.uint16,
-                               np.float32, np.float64,
-                               np.bool])
+    check_array(tensor,
+                dtype=[np.uint8, np.uint16, np.float32, np.float64, np.bool],
+                allow_nan=False)
 
     # cast tensor
     with warnings.catch_warnings():
@@ -1177,9 +1177,9 @@ def cast_img_float64(tensor):
 
     """
     # check tensor dtype
-    check_array(tensor, dtype=[np.uint8, np.uint16,
-                               np.float32, np.float64,
-                               np.bool])
+    check_array(tensor,
+                dtype=[np.uint8, np.uint16, np.float32, np.float64, np.bool],
+                allow_nan=False)
 
     # cast tensor
     with warnings.catch_warnings():

From bb831224c96938d8f9fe95372cbe4f0dd63cd3e9 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 4 May 2019 14:29:45 +0200
Subject: [PATCH 127/264] refactor preprocessing

---
 bigfish/stack/preprocess.py | 157 ++++++++++++++++++++----------------
 1 file changed, 86 insertions(+), 71 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 9fe39a3b..ef615dff 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -13,20 +13,17 @@
 
 from .loader import read_image, read_cell_json, read_rna_json
 from .utils import (check_array, check_parameter, check_recipe,
-                    check_range_value)
+                    check_range_value, check_df, complete_coordinates_2d,
+                    from_coord_to_image)
 
 from sklearn.preprocessing import LabelEncoder
 
 from skimage import img_as_ubyte, img_as_float32, img_as_float64, img_as_uint
 from skimage.exposure import rescale_intensity
 
-from scipy.sparse import coo_matrix
-
 from scipy import ndimage as ndi
 
 
-# TODO add safety checks
-
 # ### Simulated data ###
 
 def build_simulated_dataset(path_cell, path_rna, path_output=None):
@@ -206,7 +203,7 @@ def build_stacks(data_map, input_dimension=None, check=False, normalize=False,
     for recipe, input_folder in data_map:
 
         # load and generate tensors for each fov stored in a recipe
-        nb_fov = count_nb_fov(recipe)
+        nb_fov = _count_nb_fov(recipe)
         for i_fov in range(nb_fov):
             tensor = build_stack(recipe, input_folder, input_dimension, i_fov,
                                  check, normalize, channel_to_stretch,
@@ -217,7 +214,7 @@ def build_stacks(data_map, input_dimension=None, check=False, normalize=False,
                 yield tensor
 
 
-def count_nb_fov(recipe):
+def _count_nb_fov(recipe):
     """Count the number of different fields of view that can be defined from
     the recipe.
 
@@ -351,7 +348,7 @@ def build_stack(recipe, input_folder, input_dimension=None, i_fov=0,
                     return_origin=bool)
 
     # build stack from recipe and tif files
-    tensor = load_stack(recipe, input_folder, input_dimension, i_fov)
+    tensor = _load_stack(recipe, input_folder, input_dimension, i_fov)
 
     # check the validity of the loaded tensor
     if check:
@@ -371,7 +368,7 @@ def build_stack(recipe, input_folder, input_dimension=None, i_fov=0,
     return tensor
 
 
-def load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
+def _load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
     """Build a 5-d tensor from the same fields of view (fov).
 
     The function stacks a set of images using a recipe mapping the
@@ -461,14 +458,14 @@ def load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
                     i_fov=int)
 
     # complete the recipe with unused morphemes
-    recipe = fit_recipe(recipe)
+    recipe = _fit_recipe(recipe)
 
     # if the initial dimension of the files is unknown, we read one of them
     if input_dimension is None:
-        input_dimension = get_input_dimension(recipe, input_folder)
+        input_dimension = _get_input_dimension(recipe, input_folder)
 
     # get the number of elements to stack per dimension
-    nb_r, nb_c, nb_z = get_nb_element_per_dimension(recipe)
+    nb_r, nb_c, nb_z = _get_nb_element_per_dimension(recipe)
 
     # we stack our files according to their initial dimension
     if input_dimension == 2:
@@ -490,7 +487,7 @@ def load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
     return stack
 
 
-def fit_recipe(recipe):
+def _fit_recipe(recipe):
     """Fit a recipe.
 
     Fitting a recipe consists in wrapping every values of 'fov', 'r', 'c' and
@@ -751,7 +748,7 @@ def get_path_from_recipe(recipe, input_folder, fov=0, r=0, c=0, z=0):
     return path
 
 
-def get_nb_element_per_dimension(recipe):
+def _get_nb_element_per_dimension(recipe):
     """Count the number of element to stack for each dimension ('r', 'c'
     and 'z').
 
@@ -775,7 +772,7 @@ def get_nb_element_per_dimension(recipe):
     return len(recipe["r"]), len(recipe["c"]), len(recipe["z"])
 
 
-def get_input_dimension(recipe, input_folder):
+def _get_input_dimension(recipe, input_folder):
     """ Load an arbitrary image to get the original dimension of the files.
 
     Parameters
@@ -839,7 +836,7 @@ def build_stack_no_recipe(paths, input_dimension=None, check=False,
                     cast_8bit=bool)
 
     # build stack from tif files
-    tensor = load_stack_no_recipe(paths, input_dimension)
+    tensor = _load_stack_no_recipe(paths, input_dimension)
 
     # check the validity of the loaded tensor
     if check:
@@ -859,7 +856,7 @@ def build_stack_no_recipe(paths, input_dimension=None, check=False,
     return tensor
 
 
-def load_stack_no_recipe(paths, input_dimension=None):
+def _load_stack_no_recipe(paths, input_dimension=None):
     """Build a 5-d tensor from the same field of view (fov), without recipe.
 
     Files with a path listed are stacked together, then empty dimensions are
@@ -1190,8 +1187,8 @@ def cast_img_float64(tensor):
 
 
 # ### Coordinates data cleaning ###
-# TODO add safety check for these cleaning functions
-def clean_simulated_data(data, data_cell, path_output=None):
+
+def clean_simulated_data(data, data_cell, label_encoder=None, path_output=None):
     """Clean simulated dataset.
 
     Parameters
@@ -1202,6 +1199,8 @@ def clean_simulated_data(data, data_cell, path_output=None):
     data_cell : pandas.DataFrame
         Dataframe with the 2D coordinates of the nucleus and the cytoplasm of
         actual cells used to simulate data.
+    label_encoder : sklearn.preprocessing.LabelEncoder
+        Label encoder from string to integer.
     path_output : str
         Path to save the cleaned dataset.
 
@@ -1214,15 +1213,28 @@ def clean_simulated_data(data, data_cell, path_output=None):
     id_volume : List[int]
         Background id from 'data_cell' to remove.
     id_rna : List[int]
-        Cell id to remove from data.
+        Cell id to remove from data because of rna coordinates
+    label_encoder : sklearn.preprocessing.LabelEncoder
+        Label encoder from string to integer.
 
     """
-    # TODO remove the 'SettingWithCopyWarning'
+    # check dataframes and parameters
+    check_parameter(label_encoder=(type(LabelEncoder()), type(None)),
+                    path_output=(str, type(None)))
+    check_df(data,
+             features=["name_img_BGD", "pos_cell", "RNA_pos", "cell_ID",
+                       "pattern_level", "pattern_name"],
+             features_nan=["name_img_BGD", "pos_cell", "RNA_pos", "cell_ID",
+                           "pattern_level", "pattern_name"])
+    check_df(data_cell,
+             features=["name_img_BGD", "pos_cell", "pos_nuc"],
+             features_nan=["name_img_BGD", "pos_cell", "pos_nuc"])
+
     # filter invalid simulated cell backgrounds
-    data_clean, background_to_remove, id_volume = clean_volume(data, data_cell)
+    data_clean, background_to_remove, id_volume = _clean_volume(data, data_cell)
 
     # filter invalid simulated rna spots
-    data_clean, id_rna = clean_rna(data_clean)
+    data_clean, id_rna = _clean_rna(data_clean)
 
     # make the feature 'n_rna' consistent
     data_clean["nb_rna"] = data_clean.apply(
@@ -1230,13 +1242,17 @@ def clean_simulated_data(data, data_cell, path_output=None):
         axis=1)
 
     # remove useless features
-    data_final = data_clean[
-        ['RNA_pos', 'cell_ID', 'pattern_level', 'pattern_name', 'pos_cell',
-         'pos_nuc', "nb_rna"]]
+    data_final = data_clean.loc[:, ['RNA_pos', 'cell_ID', 'pattern_level',
+                                    'pattern_name', 'pos_cell', 'pos_nuc',
+                                    "nb_rna"]]
 
     # encode the label
-    le = LabelEncoder()
-    data_final["label"] = le.fit_transform(data_final["pattern_name"])
+    if label_encoder is None:
+        label_encoder = LabelEncoder()
+        label_str = set(data_final.loc[:, "pattern_name"])
+        label_encoder.fit(label_str)
+    data_final.loc[:, "label"] = label_encoder.transform(
+        data_final.loc[:, "pattern_name"])
 
     # reset index
     data_final.reset_index(drop=True, inplace=True)
@@ -1245,10 +1261,10 @@ def clean_simulated_data(data, data_cell, path_output=None):
     if path_output is not None:
         data_final.to_pickle(path_output)
 
-    return data_final, background_to_remove, id_volume, id_rna
+    return data_final, background_to_remove, id_volume, id_rna, label_encoder
 
 
-def clean_volume(data, data_cell):
+def _clean_volume(data, data_cell):
     """Remove misaligned simulated cells from the dataset.
 
     Parameters
@@ -1271,7 +1287,7 @@ def clean_volume(data, data_cell):
 
     """
     # for each cell, check if the volume is valid or not
-    data_cell["valid_volume"] = data_cell.apply(
+    data_cell.loc[:, "valid_volume"] = data_cell.apply(
         lambda row: _check_volume(row["pos_cell"], row["pos_nuc"]),
         axis=1)
 
@@ -1284,17 +1300,18 @@ def clean_volume(data, data_cell):
             id_to_remove.append(i)
 
     # remove invalid simulated cells
-    data_clean = data[~data["name_img_BGD"].isin(background_to_remove)]
+    invalid_rows = data.loc[:, "name_img_BGD"].isin(background_to_remove)
+    data_clean = data.loc[~invalid_rows, :]
 
     return data_clean, background_to_remove, id_to_remove
 
 
-def _check_volume(cyto_coord, nuc_coord):
+def _check_volume(cyt_coord, nuc_coord):
     """Check nucleus coordinates are not outside the boundary of the cytoplasm.
 
     Parameters
     ----------
-    cyto_coord : pandas.Series
+    cyt_coord : pandas.Series
         Coordinates of the cytoplasm membrane.
     nuc_coord : pandas.Series
         Coordinates of the nucleus border.
@@ -1306,27 +1323,27 @@ def _check_volume(cyto_coord, nuc_coord):
 
     """
     # get coordinates
-    cyto = np.array(cyto_coord)
-    nuc = np.array(nuc_coord)
+    cyt_coord = np.array(cyt_coord)
+    nuc_coord = np.array(nuc_coord)
 
-    max_x = max(cyto[:, 0].max() + 5, nuc[:, 0].max() + 5)
-    max_y = max(cyto[:, 1].max() + 5, nuc[:, 1].max() + 5)
+    # complete coordinates
+    list_coord = complete_coordinates_2d([cyt_coord, nuc_coord])
+    cyt_coord, nuc_coord = list_coord[0], list_coord[1]
 
-    # build the dense representation for the cytoplasm
-    values = [1] * cyto.shape[0]
-    cyto = coo_matrix((values, (cyto[:, 0], cyto[:, 1])),
-                      shape=(max_x, max_y)).todense()
+    # get image shape
+    max_x = max(cyt_coord[:, 0].max() + 5, nuc_coord[:, 0].max() + 5)
+    max_y = max(cyt_coord[:, 1].max() + 5, nuc_coord[:, 1].max() + 5)
+    image_shape = (max_x, max_y)
 
-    # build the dense representation for the nucleus
-    values = [1] * nuc.shape[0]
-    nuc = coo_matrix((values, (nuc[:, 0], nuc[:, 1])),
-                     shape=(max_x, max_y)).todense()
+    # build the dense representation for the cytoplasm and the nucleus
+    cyt = from_coord_to_image(cyt_coord, image_shape=image_shape)
+    nuc = from_coord_to_image(nuc_coord, image_shape=image_shape)
 
     # check if the volume is valid
-    mask_cyto = ndi.binary_fill_holes(cyto)
+    mask_cyt = ndi.binary_fill_holes(cyt)
     mask_nuc = ndi.binary_fill_holes(nuc)
-    frame = np.zeros((max_x, max_y))
-    diff = frame - mask_cyto + mask_nuc
+    frame = np.zeros(image_shape)
+    diff = frame - mask_cyt + mask_nuc
     diff = (diff > 0).sum()
 
     if diff > 0:
@@ -1335,7 +1352,7 @@ def _check_volume(cyto_coord, nuc_coord):
         return True
 
 
-def clean_rna(data):
+def _clean_rna(data):
     """Remove cells with misaligned simulated rna spots from the dataset.
 
     Parameters
@@ -1353,7 +1370,7 @@ def clean_rna(data):
 
     """
     # for each cell we check if the rna spots are valid or not
-    data["valid_rna"] = data.apply(
+    data.loc[:, "valid_rna"] = data.apply(
         lambda row: _check_rna(row["pos_cell"], row["RNA_pos"]),
         axis=1)
 
@@ -1364,18 +1381,18 @@ def clean_rna(data):
             id_to_remove.append(i)
 
     # remove invalid simulated cells
-    data_clean = data[data["valid_rna"]]
+    data_clean = data.loc[data.loc[:, "valid_rna"], :]
 
     return data_clean, id_to_remove
 
 
-def _check_rna(cyto_coord, rna_coord):
+def _check_rna(cyt_coord, rna_coord):
     """Check rna spots coordinates are not outside the boundary of the
     cytoplasm.
 
     Parameters
     ----------
-    cyto_coord : pandas.Series
+    cyt_coord : pandas.Series
         Coordinates of the cytoplasm membrane.
     rna_coord : pandas.Series
         Coordinates of the rna spots.
@@ -1387,34 +1404,32 @@ def _check_rna(cyto_coord, rna_coord):
 
     """
     # get coordinates
-    cyto = np.array(cyto_coord)
+    cyt_coord = np.array(cyt_coord)
     if not isinstance(rna_coord[0], list):
         # it means we have only one spot
         return False
-    rna = np.array(rna_coord)
+    rna_coord = np.array(rna_coord)
 
     # check if the coordinates are positive
-    if rna.min() < 0:
+    if rna_coord.min() < 0:
         return False
 
-    max_x = int(max(cyto[:, 0].max() + 5, rna[:, 0].max() + 5))
-    max_y = int(max(cyto[:, 1].max() + 5, rna[:, 1].max() + 5))
+    # complete coordinates
+    cyt_coord = complete_coordinates_2d([cyt_coord])[0]
 
-    # build the dense representation for the cytoplasm
-    values = [1] * cyto.shape[0]
-    cyto = coo_matrix((values, (cyto[:, 0], cyto[:, 1])),
-                      shape=(max_x, max_y)).todense()
+    # get image shape
+    max_x = int(max(cyt_coord[:, 0].max() + 5, rna_coord[:, 0].max() + 5))
+    max_y = int(max(cyt_coord[:, 1].max() + 5, rna_coord[:, 1].max() + 5))
+    image_shape = (max_x, max_y)
 
-    # build the dense representation for the rna
-    values = [1] * rna.shape[0]
-    rna = coo_matrix((values, (rna[:, 0], rna[:, 1])),
-                     shape=(max_x, max_y)).todense()
-    rna = (rna > 0)
+    # build the dense representation for the cytoplasm and the rna
+    cyt = from_coord_to_image(cyt_coord, image_shape=image_shape)
+    rna = from_coord_to_image(rna_coord, image_shape=image_shape)
 
     # check if the coordinates are valid
-    mask_cyto = ndi.binary_fill_holes(cyto)
-    frame = np.zeros((max_x, max_y))
-    diff = frame - mask_cyto + rna
+    mask_cyt = ndi.binary_fill_holes(cyt)
+    frame = np.zeros(image_shape)
+    diff = frame - mask_cyt + rna
     diff = (diff > 0).sum()
 
     if diff > 0:

From 27e70bb21afdf4541bc114ec4ce96a0533eb5278 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 4 May 2019 14:30:14 +0200
Subject: [PATCH 128/264] add coordinate utilities

---
 bigfish/stack/utils.py | 59 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index e1dd8c2d..73c94670 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -10,6 +10,8 @@
 import numpy as np
 import pandas as pd
 
+from skimage.draw import polygon_perimeter
+
 
 # ### Sanity checks dataframe ###
 
@@ -340,3 +342,60 @@ def check_parameter(**kwargs):
                              .format(arg, expected_dtype, type(parameter)))
 
     return
+
+
+# ### Coordinate utilities ###
+
+def complete_coordinates_2d(list_coord):
+    """Complete a 2-d coordinates array, by generating/interpolating missing
+    points.
+
+    Parameters
+    ----------
+    list_coord : List[np.array]
+        List of the coordinates arrays to complete, with shape (nb_points, 2).
+
+    Returns
+    -------
+
+    """
+    # check parameter
+    check_parameter(list_coord=list)
+
+    # for each array in the list, complete its coordinates using the scikit
+    # image method 'polygon_perimeter'
+    list_coord_completed = []
+    for coord in list_coord:
+        coord_x, coord_y = polygon_perimeter(coord[:, 0], coord[:, 1])
+        coord_x = coord_x[:, np.newaxis]
+        coord_y = coord_y[:, np.newaxis]
+        new_coord = np.concatenate((coord_x, coord_y), axis=-1)
+        list_coord_completed.append(new_coord)
+
+    return list_coord_completed
+
+
+def from_coord_to_image(coord, image_shape=None):
+    """Convert an array of coordinates into a binary matrix.
+
+    Parameters
+    ----------
+    coord : np.ndarray, np.uint64
+        Array of coordinate with shape (nb_points, 2) or (nb_points, 3).
+    image_shape:
+
+    Returns
+    -------
+    image : np.ndarray, np.float32
+        Binary matrix plotting the coordinates values.
+
+    """
+    # build matrices
+    if image_shape is None:
+        max_x = coord[:, 0].max() + 5
+        max_y = coord[:, 1].max() + 5
+        image_shape = (max_x, max_y)
+    image = np.zeros(image_shape, dtype=np.float32)
+    image[coord[:, 0], coord[:, 1]] = 1.0
+
+    return image

From b14fced9a7b49f9cdd52975f18f3adc2195e99d4 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 4 May 2019 14:56:11 +0200
Subject: [PATCH 129/264] refactor filters

---
 bigfish/stack/filter.py | 333 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 333 insertions(+)

diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
index e69de29b..2ba42b9d 100644
--- a/bigfish/stack/filter.py
+++ b/bigfish/stack/filter.py
@@ -0,0 +1,333 @@
+# -*- coding: utf-8 -*-
+
+"""Filter functions."""
+
+import numpy as np
+
+from .utils import check_array, check_parameter
+from .preprocess import cast_img_float32, cast_img_float64
+
+from skimage.morphology.selem import square, diamond, rectangle, disk
+from skimage.filters import rank, gaussian
+
+from scipy.ndimage import gaussian_laplace
+
+
+# ### Filters ###
+
+def _define_kernel(shape, size, dtype):
+    """Build a kernel to apply a filter on images.
+
+    Parameters
+    ----------
+    shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    size : int, Tuple(int) or List(int)
+        The size of the kernel:
+            - For the rectangle we expect two values (width, height).
+            - For the square one value (width).
+            - For the disk and the diamond one value (radius).
+    dtype : type
+        Dtype used for the kernel (the same as the image).
+
+    Returns
+    -------
+    kernel : skimage.morphology.selem object
+        Kernel to use with a skimage filter.
+
+    """
+    # build the kernel
+    if shape == "diamond":
+        kernel = diamond(size, dtype=dtype)
+    elif shape == "disk":
+        kernel = disk(size, dtype=dtype)
+    elif shape == "rectangle" and isinstance(size, tuple):
+        kernel = rectangle(size[0], size[1], dtype=dtype)
+    elif shape == "square":
+        kernel = square(size, dtype=dtype)
+    else:
+        raise ValueError("Kernel definition is wrong.")
+
+    return kernel
+
+
+def mean_filter(image, kernel_shape, kernel_size):
+    """Apply a mean filter to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint
+        Filtered 2-d image with shape (y, x).
+
+    """
+    # check parameters
+    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_parameter(kernel_shape=str,
+                    kernel_size=(int, tuple, list))
+
+    # get kernel
+    kernel = _define_kernel(shape=kernel_shape,
+                            size=kernel_size,
+                            dtype=image.dtype)
+
+    # apply filter
+    image_filtered = rank.mean(image, kernel)
+
+    return image_filtered
+
+
+def median_filter(image, kernel_shape, kernel_size):
+    """Apply a median filter to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint
+        Filtered 2-d image with shape (y, x).
+
+    """
+    # check parameters
+    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_parameter(kernel_shape=str,
+                    kernel_size=(int, tuple, list))
+
+    # get kernel
+    kernel = _define_kernel(shape=kernel_shape,
+                            size=kernel_size,
+                            dtype=image.dtype)
+
+    # apply filter
+    image_filtered = rank.median(image, kernel)
+
+    return image_filtered
+
+
+def maximum_filter(image, kernel_shape, kernel_size):
+    """Apply a maximum filter to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint
+        Filtered 2-d image with shape (y, x).
+
+    """
+    # check parameters
+    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_parameter(kernel_shape=str,
+                    kernel_size=(int, tuple, list))
+
+    # get kernel
+    kernel = _define_kernel(shape=kernel_shape,
+                            size=kernel_size,
+                            dtype=image.dtype)
+
+    # apply filter
+    image_filtered = rank.maximum(image, kernel)
+
+    return image_filtered
+
+
+def minimum_filter(image, kernel_shape, kernel_size):
+    """Apply a minimum filter to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint
+        Filtered 2-d image with shape (y, x).
+
+    """
+    # check parameters
+    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_parameter(kernel_shape=str,
+                    kernel_size=(int, tuple, list))
+
+    # get kernel
+    kernel = _define_kernel(shape=kernel_shape,
+                            size=kernel_size,
+                            dtype=image.dtype)
+
+    # apply filter
+    image_filtered = rank.minimum(image, kernel)
+
+    return image_filtered
+
+
+def log_filter(image, sigma):
+    """Apply a Laplacian of Gaussian filter to a 2-d or 3-d image.
+
+    The function returns the inverse of the filtered image such that the pixels
+    with the highest intensity from the original (smoothed) image have
+    positive values. Those with a low intensity returning a negative value are
+    clipped to zero.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image with shape (z, y, x) or (y, x).
+    sigma : float, int, Tuple(float, int) or List(float, int)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.float
+        Filtered image.
+    """
+    # check parameters
+    check_array(image,
+                ndim=[2, 3],
+                dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                allow_nan=False)
+    check_parameter(sigma=(float, int, tuple, list))
+
+    # we cast the data in np.float to allow negative values
+    if image.dtype == np.uint8:
+        image_float = cast_img_float32(image)
+    elif image.dtype == np.uint16:
+        image_float = cast_img_float64(image)
+    else:
+        image_float = image
+
+    # check sigma
+    if isinstance(sigma, (tuple, list)):
+        if len(sigma) != image.ndim:
+            raise ValueError("'sigma' must be a scalar or a sequence with the "
+                             "same length as 'image.ndim'.")
+
+    # we apply LoG filter
+    image_filtered = gaussian_laplace(image_float, sigma=sigma)
+
+    # as the LoG filter makes the peaks in the original image appear as a
+    # reversed mexican hat, we inverse the result and clip negative values to 0
+    image_filtered = np.clip(-image_filtered, a_min=0, a_max=None)
+
+    return image_filtered
+
+
+def gaussian_filter(image, sigma, allow_negative=False):
+    """Apply a Gaussian filter to a 2-d or 3-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        Image with shape (z, y, x) or (y, x).
+    sigma : float, int, Tuple(float, int) or List(float, int)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+    allow_negative : bool
+        Allow negative values after the filtering or clip them to 0.
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.float
+        Filtered image.
+
+    """
+    # check parameters
+    check_array(image,
+                ndim=[2, 3],
+                dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                allow_nan=False)
+    check_parameter(sigma=(float, int, tuple, list),
+                    allow_negative=bool)
+
+    # we cast the data in np.float to allow negative values
+    image_float = None
+    if image.dtype == np.uint8:
+        image_float = cast_img_float32(image)
+    elif image.dtype == np.uint16:
+        image_float = cast_img_float64(image)
+
+    # we apply gaussian filter
+    image_filtered = gaussian(image_float, sigma=sigma)
+
+    # we clip negative values to 0
+    if not allow_negative:
+        image_filtered = np.clip(image_filtered, a_min=0, a_max=None)
+
+    return image_filtered
+
+
+def remove_background(image, kernel_shape="disk", kernel_size=200):
+    """Remove background noise from a 2-d image, subtracting a mean filtering.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        Image to process. Casting in np.uint8 makes the computation faster.
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_without_back : np.ndarray, np.uint
+        Image processed.
+
+    """
+    # check parameters
+    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_parameter(kernel_shape=str,
+                    kernel_size=(int, tuple, list))
+
+    # compute background noise with a large mean filter
+    background = mean_filter(image,
+                             kernel_shape=kernel_shape,
+                             kernel_size=kernel_size)
+
+    # subtract the background from the original image, clipping negative
+    # values to 0
+    mask = image > background
+    output = np.zeros_like(image, dtype=image.dtype)
+    image_without_back = np.subtract(image, background,
+                                     out=output,
+                                     where=mask)
+
+    return image_without_back

From 3a97c030a30b0edf217a8249580d3a32cc3d768d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 4 May 2019 15:09:14 +0200
Subject: [PATCH 130/264] fix 'remove_background'

---
 bigfish/stack/filter.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
index 2ba42b9d..4b78da50 100644
--- a/bigfish/stack/filter.py
+++ b/bigfish/stack/filter.py
@@ -325,9 +325,8 @@ def remove_background(image, kernel_shape="disk", kernel_size=200):
     # subtract the background from the original image, clipping negative
     # values to 0
     mask = image > background
-    output = np.zeros_like(image, dtype=image.dtype)
     image_without_back = np.subtract(image, background,
-                                     out=output,
+                                     out=np.zeros_like(image),
                                      where=mask)
 
     return image_without_back

From c2923a27efb3bfebd9a10479c329777bb5b17dd8 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 7 May 2019 12:52:00 +0200
Subject: [PATCH 131/264] improve plot images with titles, frames and axes
 removal

---
 bigfish/plot/__init__.py           |  25 ++---
 bigfish/plot/plot_images.py        | 156 +++++++++++++++++++++--------
 bigfish/plot/utils.py              |  63 ++++++++++--
 bigfish/stack/{loader.py => io.py} |  28 ++++++
 4 files changed, 206 insertions(+), 66 deletions(-)
 rename bigfish/stack/{loader.py => io.py} (85%)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index 711620c9..12a94292 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -11,17 +11,14 @@
                                plot_cell_coordinates, plot_layers_coordinates)
 from .plot_classification import plot_confusion_matrix, plot_2d_projection
 
-__all__ = ["plot_yx",
-           "plot_images",
-           "plot_channels_2d",
-           "plot_projection",
-           "plot_segmentation",
-           "plot_spot_detection",
-           "plot_illumination_surface",
-           "plot_volume",
-           "plot_rna",
-           "plot_distribution_rna",
-           "plot_cell_coordinates",
-           "plot_layers_coordinates",
-           "plot_confusion_matrix",
-           "plot_2d_projection"]
+
+_images = ["plot_yx", "plot_images", "plot_channels_2d", "plot_projection",
+           "plot_illumination_surface", "plot_segmentation",
+           "plot_spot_detection"]
+
+_coordinates = ["plot_volume", "plot_rna", "plot_distribution_rna",
+                "plot_cell_coordinates", "plot_layers_coordinates"]
+
+_classification = ["plot_confusion_matrix", "plot_2d_projection"]
+
+__all__ = _images + _coordinates + _classification
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 1bb5d022..83e2b37a 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -9,21 +9,22 @@
 import matplotlib.pyplot as plt
 import numpy as np
 
-from .utils import save_plot
+from .utils import save_plot, get_minmax_values
 
 from skimage.segmentation import find_boundaries
 from matplotlib.colors import ListedColormap
 
 
 # TODO add title in the plot and remove axes
+# TODO add parameter for vmin and vmax
 
 def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
-            path_output=None, ext="png"):
+            remove_frame=False, path_output=None, ext="png"):
     """Plot the selected yx plan of the selected dimensions of an image.
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint
+    tensor : np.ndarray
         A 2-d, 3-d or 5-d tensor with shape (y, x), (z, y, x) or
         (r, c, z, y, x) respectively.
     r : int
@@ -36,6 +37,8 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
         Title of the image.
     framesize : tuple
         Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    remove_frame : bool
+        Remove axes and frame.
     path_output : str
         Path to save the image (without extension).
     ext : str or List[str]
@@ -46,11 +49,19 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
     -------
 
     """
-    # check tensor
-    stack.check_array(tensor, ndim=[2, 3, 5],
+    # check parameters
+    stack.check_array(tensor,
+                      ndim=[2, 3, 5],
                       dtype=[np.uint8, np.uint16,
                              np.float32, np.float64,
-                             bool])
+                             bool],
+                      allow_nan=False)
+    stack.check_parameter(r=int, c=int, z=int,
+                          title=(str, type(None)),
+                          framesize=tuple,
+                          remove_frame=bool,
+                          path_output=(str, type(None)),
+                          ext=(str, list))
 
     # get the 2-d tensor
     xy_tensor = None
@@ -61,31 +72,42 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
     elif tensor.ndim == 5:
         xy_tensor = tensor[r, c, z, :, :]
 
+    # get minimum and maximum value of the image
+    vmin, vmax = get_minmax_values(tensor)
+
     # plot
-    plt.figure(figsize=framesize)
-    plt.imshow(xy_tensor)
-    if title is not None:
+    if remove_frame:
+        fig = plt.figure(figsize=framesize, frameon=False)
+        ax = fig.add_axes([0, 0, 1, 1])
+        ax.axis('off')
+    else:
+        plt.figure(figsize=framesize)
+    plt.imshow(xy_tensor, vmin=vmin, vmax=vmax)
+    if title is not None and not remove_frame:
         plt.title(title, fontweight="bold", fontsize=25)
-    plt.axis('off')
-    plt.tight_layout()
-    save_plot(path_output, ext)
+    if not remove_frame:
+        plt.tight_layout()
+    if path_output is not None:
+        save_plot(path_output, ext)
     plt.show()
 
     return
 
 
-def plot_images(images, framesize=(15, 15), titles=None,
+def plot_images(tensors, titles=None, framesize=(15, 15), remove_frame=False,
                 path_output=None, ext="png"):
     """Plot or subplot of 2-d images.
 
     Parameters
     ----------
-    images : np.ndarray or List[np.ndarray]
+    tensors : np.ndarray or List[np.ndarray]
         Images with shape (y, x).
-    framesize : tuple
-        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
     titles : List[str]
         Titles of the subplots.
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    remove_frame : bool
+        Remove axes and frame.
     path_output : str
         Path to save the image (without extension).
     ext : str or List[str]
@@ -97,49 +119,78 @@ def plot_images(images, framesize=(15, 15), titles=None,
 
     """
     # enlist image if necessary
-    if isinstance(images, np.ndarray):
-        images = [images]
-
-    # check images
-    for image in images:
-        stack.check_array(image, ndim=2,
-                          dtype=[np.uint8, np.uint16, np.float32, np.float64,
-                                 bool])
+    if isinstance(tensors, np.ndarray):
+        tensors = [tensors]
+
+    # check parameters
+    stack.check_parameter(tensors=list,
+                          titles=(str, list, type(None)),
+                          framesize=tuple,
+                          remove_frame=bool,
+                          path_output=(str, type(None)),
+                          ext=(str, list))
+    for tensor in tensors:
+        stack.check_array(tensor,
+                          ndim=2,
+                          dtype=[np.uint8, np.uint16,
+                                 np.float32, np.float64,
+                                 bool],
+                          allow_nan=False)
 
     # we plot 3 images by row maximum
-    nrow = int(np.ceil(len(images)/3))
-    ncol = min(len(images), 3)
+    nrow = int(np.ceil(len(tensors)/3))
+    ncol = min(len(tensors), 3)
 
     # plot one image
-    if len(images) == 1:
-        plot_yx(images[0], framesize=framesize, title=titles,
-                path_output=path_output, ext=ext)
+    if len(tensors) == 1:
+        plot_yx(tensors[0], title=titles[0], framesize=framesize,
+                remove_frame=remove_frame, path_output=path_output, ext=ext)
+
         return
 
     # plot multiple images
     fig, ax = plt.subplots(nrow, ncol, figsize=framesize)
-    if len(images) in [2, 3]:
-        for i, image in enumerate(images):
-            ax[i].imshow(image)
+
+    # one row
+    if len(tensors) in [2, 3]:
+        for i, tensor in enumerate(tensors):
+            if remove_frame:
+                ax[i].axis("off")
+            vmin, vmax = get_minmax_values(tensor)
+            ax[i].imshow(tensor, vmin=vmin, vmax=vmax)
             if titles is not None:
                 ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
+
+    # several rows
     else:
-        for i, image in enumerate(images):
+        # we complete the row with empty frames
+        r = nrow * 3 - len(tensors)
+        tensors_completed = [tensor for tensor in tensors] + [None] * r
+
+        for i, tensor in enumerate(tensors_completed):
             row = i // 3
             col = i % 3
-            ax[row, col].imshow(image)
+            if tensor is None:
+                ax[row, col].set_visible(False)
+                continue
+            if remove_frame:
+                ax[row, col].axis("off")
+            vmin, vmax = get_minmax_values(tensor)
+            ax[row, col].imshow(tensor, vmin=vmin, vmax=vmax)
             if titles is not None:
                 ax[row, col].set_title(titles[i],
                                        fontweight="bold", fontsize=15)
+
     plt.tight_layout()
-    save_plot(path_output, ext)
+    if path_output is not None:
+        save_plot(path_output, ext)
     plt.show()
 
     return
 
 
-def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), titles=None,
-                     path_output=None, ext="png"):
+def plot_channels_2d(tensor, r=0, z=0, titles=None, framesize=(15, 15),
+                     remove_frame=False, path_output=None, ext="png"):
     """Subplot the yx plan of the selected dimensions of an image for all
     channels.
 
@@ -151,10 +202,12 @@ def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), titles=None,
         Index of the round to keep.
     z : int
         Index of the z slice to keep.
-    framesize : tuple
-        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
     titles : List[str]
         Titles of the subplots (one per channel).
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    remove_frame : bool
+        Remove axes and frame.
     path_output : str
         Path to save the image (without extension).
     ext : str or List[str]
@@ -165,20 +218,37 @@ def plot_channels_2d(tensor, r=0, z=0, framesize=(15, 15), titles=None,
     -------
 
     """
-    # check tensor
-    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+    # check parameters
+    stack.check_array(tensor,
+                      ndim=5,
+                      dtype=[np.uint8, np.uint16],
+                      allow_nan=False)
+    stack.check_parameter(r=int,
+                          z=int,
+                          titles=(list, type(None)),
+                          framesize=tuple,
+                          remove_frame=bool,
+                          path_output=(str, type(None)),
+                          ext=(str, list))
 
     # get the number of channels
     nb_channels = tensor.shape[1]
 
+    # get the minimum and maximal values of the tensor dtype
+    vmin, vmax = get_minmax_values(tensor)
+
     # plot
     fig, ax = plt.subplots(1, nb_channels, sharex='col', figsize=framesize)
     for i in range(nb_channels):
-        ax[i].imshow(tensor[r, i, z, :, :])
+        ax[i].imshow(tensor[r, i, z, :, :], vmin=vmin, vmax=vmax)
         if titles is not None:
             ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
+        if remove_frame:
+            ax[i].axis("off")
+
     plt.tight_layout()
-    save_plot(path_output, ext)
+    if path_output is not None:
+        save_plot(path_output, ext)
     plt.show()
 
     return
diff --git a/bigfish/plot/utils.py b/bigfish/plot/utils.py
index c342e519..16f0fe10 100644
--- a/bigfish/plot/utils.py
+++ b/bigfish/plot/utils.py
@@ -5,6 +5,7 @@
 """
 
 import matplotlib.pyplot as plt
+import numpy as np
 
 
 def save_plot(path_output, ext):
@@ -22,15 +23,59 @@ def save_plot(path_output, ext):
     -------
 
     """
+    # add extension at the end of the filename
+    extension = "." + ext
+    if extension not in path_output:
+        path_output += extension
+
     # save the plot
-    if path_output is not None:
-        if isinstance(ext, str):
-            plt.savefig(path_output, format=ext)
-        elif isinstance(ext, list):
-            for ext_ in ext:
-                plt.savefig(path_output, format=ext_)
-        else:
-            Warning("Plot is not saved because the extension is not valid: "
-                    "{0}.".format(ext))
+    if isinstance(ext, str):
+        # add extension at the end of the filename
+        extension = "." + ext
+        if extension not in path_output:
+            path_output += extension
+        plt.savefig(path_output, format=ext)
+    elif isinstance(ext, list):
+        for ext_ in ext:
+            # add extension at the end of the filename
+            extension = "." + ext_
+            if extension not in path_output:
+                path_output += extension
+            plt.savefig(path_output, format=ext_)
+    else:
+        Warning("Plot is not saved because the extension is not valid: "
+                "{0}.".format(ext))
 
     return
+
+
+def get_minmax_values(tensor):
+    """Get the minimum and maximum value of the image according to its dtype.
+
+    Parameters
+    ----------
+    tensor : np.ndarray
+        A 2-d, 3-d or 5-d tensor with shape (y, x), (z, y, x) or
+        (r, c, z, y, x) respectively.
+
+    Returns
+    -------
+    vmin : int
+        Minimum value display in the plot.
+    vmax : int
+        Maximum value display in the plot.
+
+    """
+    vmin, vmax = None, None
+    if tensor.dtype == np.uint8:
+        vmin, vmax = 0, 255
+    elif tensor.dtype == np.uint16:
+        vmin, vmax = 0, 65535
+    elif tensor.dtype == np.float32:
+        vmin, vmax = 0, 1
+    elif tensor.dtype == np.float64:
+        vmin, vmax = 0, 1
+    elif tensor.dtype == bool:
+        vmin, vmax = 0, 1
+
+    return vmin, vmax
diff --git a/bigfish/stack/loader.py b/bigfish/stack/io.py
similarity index 85%
rename from bigfish/stack/loader.py
rename to bigfish/stack/io.py
index bbe3901d..e65836f6 100644
--- a/bigfish/stack/loader.py
+++ b/bigfish/stack/io.py
@@ -14,6 +14,8 @@
 from .utils import check_array, check_df
 
 
+# ### Read ###
+
 def read_image(path):
     """Read an image with the .png, .tif or .tiff extension.
 
@@ -121,3 +123,29 @@ def read_pickle(path):
         data = pickle.load(f)
 
     return data
+
+
+# ### Write ###
+
+def save_image(image, path):
+    """Save a 2-d or 3-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Tensor to save with shape (z, y, x) or (y, x).
+    path : str
+        Path of the saved image.
+
+    Returns
+    -------
+
+    """
+    # check image
+    check_array(image, dtype=[np.uint8, np.uint16, np.float], ndim=[2, 3])
+
+
+    # save image
+    io.imsave(path, arr, plugin=None, check_contrast=True,
+                      **plugin_args)
+    return
\ No newline at end of file

From 1fac63fa799822bc19f89a12cf1561a749cebf3c Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 7 May 2019 12:53:40 +0200
Subject: [PATCH 132/264] add 'save_image'

---
 bigfish/stack/io.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/bigfish/stack/io.py b/bigfish/stack/io.py
index e65836f6..14de5718 100644
--- a/bigfish/stack/io.py
+++ b/bigfish/stack/io.py
@@ -142,10 +142,12 @@ def save_image(image, path):
 
     """
     # check image
-    check_array(image, dtype=[np.uint8, np.uint16, np.float], ndim=[2, 3])
-
+    check_array(image,
+                dtype=[np.uint8, np.uint16, np.float32, np.float64, bool],
+                ndim=[2, 3],
+                allow_nan=False)
 
     # save image
-    io.imsave(path, arr, plugin=None, check_contrast=True,
-                      **plugin_args)
-    return
\ No newline at end of file
+    io.imsave(path, image, check_contrast=False)
+
+    return

From cc7d7158f3c321617a81270924671e1aaf6ed1f9 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 7 May 2019 12:54:16 +0200
Subject: [PATCH 133/264] fix typo

---
 bigfish/stack/filter.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
index 4b78da50..3072afde 100644
--- a/bigfish/stack/filter.py
+++ b/bigfish/stack/filter.py
@@ -298,7 +298,8 @@ def remove_background(image, kernel_shape="disk", kernel_size=200):
     Parameters
     ----------
     image : np.ndarray, np.uint
-        Image to process. Casting in np.uint8 makes the computation faster.
+        Image to process with shape (y, x). Casting in np.uint8 makes the
+        computation faster.
     kernel_shape : str
         Shape of the kernel used to compute the filter ('diamond', 'disk',
         'rectangle' or 'square').

From b09df1ae793e6e99d6684ffbffe1f26345a974b0 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 7 May 2019 12:55:12 +0200
Subject: [PATCH 134/264] fix stack building

---
 bigfish/stack/preprocess.py | 52 +++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 28 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index ef615dff..692f4309 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -11,7 +11,7 @@
 import numpy as np
 import pandas as pd
 
-from .loader import read_image, read_cell_json, read_rna_json
+from .io import read_image, read_cell_json, read_rna_json
 from .utils import (check_array, check_parameter, check_recipe,
                     check_range_value, check_df, complete_coordinates_2d,
                     from_coord_to_image)
@@ -341,11 +341,15 @@ def build_stack(recipe, input_folder, input_dimension=None, i_fov=0,
 
     """
     # check parameters
-    check_parameter(normalize=bool,
+    check_recipe(recipe)
+    check_parameter(input_folder=str,
+                    input_dimension=(int, type(None)),
+                    i_fov=int,
+                    check=bool,
+                    normalize=bool,
                     channel_to_stretch=(int, list, type(None)),
                     stretching_percentile=float,
-                    cast_8bit=bool,
-                    return_origin=bool)
+                    cast_8bit=bool)
 
     # build stack from recipe and tif files
     tensor = _load_stack(recipe, input_folder, input_dimension, i_fov)
@@ -451,12 +455,6 @@ def _load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
         Tensor with shape (r, c, z, y, x).
 
     """
-    # check parameters
-    check_recipe(recipe)
-    check_parameter(input_folder=str,
-                    input_dimension=(int, type(None)),
-                    i_fov=int)
-
     # complete the recipe with unused morphemes
     recipe = _fit_recipe(recipe)
 
@@ -513,7 +511,7 @@ def _fit_recipe(recipe):
     # initialize and fit the dimensions 'fov', 'r', 'c' and 'z'
     for key in ['fov', 'r', 'c', 'z']:
         if key not in recipe:
-            recipe[key] = list("")
+            recipe[key] = [None]
         value = recipe[key]
         if isinstance(value, str):
             recipe[key] = [value]
@@ -564,8 +562,8 @@ def _build_stack_from_2d(recipe, input_folder, fov=0, nb_r=1, nb_c=1, nb_z=1):
             # load and stack z elements (2-d tensors)
             tensors_2d = []
             for z in range(nb_z):
-                path = get_path_from_recipe(recipe, input_folder, fov=fov,
-                                            r=r, c=c, z=z)
+                path = _get_path_from_recipe(recipe, input_folder, fov=fov,
+                                             r=r, c=c, z=z)
                 tensor_2d = read_image(path)
                 tensors_2d.append(tensor_2d)
 
@@ -614,14 +612,14 @@ def _build_stack_from_3d(recipe, input_folder, fov=0, nb_r=1, nb_c=1):
         # load and stack channel elements (3-d tensors)
         tensors_3d = []
         for c in range(nb_c):
-            path = get_path_from_recipe(recipe, input_folder, fov=fov, r=r,
-                                        c=c)
+            path = _get_path_from_recipe(recipe, input_folder, fov=fov, r=r,
+                                         c=c)
             tensor_3d = read_image(path)
             tensors_3d.append(tensor_3d)
 
-            # stack 3-d tensors in 4-d
-            tensor_4d = np.stack(tensors_3d, axis=0)
-            tensors_4d.append(tensor_4d)
+        # stack 3-d tensors in 4-d
+        tensor_4d = np.stack(tensors_3d, axis=0)
+        tensors_4d.append(tensor_4d)
 
     # stack 4-d tensors in 5-d
     tensor_5d = np.stack(tensors_4d, axis=0)
@@ -654,7 +652,7 @@ def _build_stack_from_4d(recipe, input_folder, fov=0, nb_r=1):
     # load each file from a new round element and stack them
     tensors_4d = []
     for r in range(nb_r):
-        path = get_path_from_recipe(recipe, input_folder, fov=fov, r=r)
+        path = _get_path_from_recipe(recipe, input_folder, fov=fov, r=r)
         tensor_4d = read_image(path)
         tensors_4d.append(tensor_4d)
 
@@ -685,13 +683,13 @@ def _build_stack_from_5d(recipe, input_folder, fov=0):
 
     """
     # the recipe can only contain one file with a 5-d tensor per fov
-    path = get_path_from_recipe(recipe, input_folder, fov=fov)
+    path = _get_path_from_recipe(recipe, input_folder, fov=fov)
     tensor_5d = read_image(path)
 
     return tensor_5d
 
 
-def get_path_from_recipe(recipe, input_folder, fov=0, r=0, c=0, z=0):
+def _get_path_from_recipe(recipe, input_folder, fov=0, r=0, c=0, z=0):
     """Build the path of a file from a recipe and the indices of specific
     elements.
 
@@ -728,7 +726,7 @@ def get_path_from_recipe(recipe, input_folder, fov=0, r=0, c=0, z=0):
 
     # get filename recombining elements of the recipe
     filename = path_separators[0]  # usually an empty string
-    for (element_name, separator) in zip(path_elements, path_separators):
+    for (element_name, separator) in zip(path_elements, path_separators[1:]):
         # if we need an element from a list of elements of the same dimension
         # (eg. to pick a specific channel 'c' among a list of channels)
         if element_name in map_element_index:
@@ -791,7 +789,7 @@ def _get_input_dimension(recipe, input_folder):
 
     """
     # get a valid path from the recipe
-    path = get_path_from_recipe(recipe, input_folder)
+    path = _get_path_from_recipe(recipe, input_folder)
 
     # load the image and return the number of dimensions
     image = read_image(path)
@@ -830,7 +828,9 @@ def build_stack_no_recipe(paths, input_dimension=None, check=False,
 
     """
     # check parameters
-    check_parameter(normalize=bool,
+    check_parameter(paths=(str, list),
+                    input_dimension=(int, type(None)),
+                    normalize=bool,
                     channel_to_stretch=(int, list, type(None)),
                     stretching_percentile=float,
                     cast_8bit=bool)
@@ -875,10 +875,6 @@ def _load_stack_no_recipe(paths, input_dimension=None):
         Tensor with shape (r, c, z, y, x).
 
     """
-    # check parameters
-    check_parameter(paths=str,
-                    input_dimension=(int, type(None)))
-
     # load an image and get the number of dimensions
     if input_dimension is None:
         testfile = read_image(paths[0])

From f4b6a0bd8a0cf5e90cce719c528725fc387f8a38 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 7 May 2019 12:56:12 +0200
Subject: [PATCH 135/264] fix recipe and array checking

---
 bigfish/stack/utils.py | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 73c94670..3d7cd550 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -128,10 +128,6 @@ def check_array(array, ndim=None, dtype=None, allow_nan=True):
         Types expected.
     allow_nan : bool
         Allow NaN values or not.
-    min_array : int
-        Minimum value allowed.
-    max_array : int
-        Maximum value allowed.
 
     Returns
     -------
@@ -142,10 +138,8 @@ def check_array(array, ndim=None, dtype=None, allow_nan=True):
     # check parameters
     check_parameter(array=np.ndarray,
                     ndim=(int, list, type(None)),
-                    dtype=(type, type(None)),
-                    allow_nan=bool,
-                    min_array=(int, type(None)),
-                    max_array=(int, type(None)))
+                    dtype=(type, list, type(None)),
+                    allow_nan=bool)
 
     # check the dtype
     if dtype is not None:
@@ -281,6 +275,7 @@ def check_recipe(recipe):
     -------
 
     """
+    # TODO check files exists
     # check recipe is a dictionary
     if not isinstance(recipe, dict):
         raise Exception("The recipe is not valid. It should be a dictionary.")
@@ -305,10 +300,10 @@ def check_recipe(recipe):
 
     # check keys and values of the recipe
     for key, value in recipe.items():
-        if key not in ['fov', 'r', 'c', 'z', 'ext', 'opt']:
+        if key not in ['fov', 'r', 'c', 'z', 'ext', 'opt', 'pattern']:
             raise ValueError("The recipe can only contain the keys 'fov', "
-                             "'r', 'c', 'z', 'ext' or 'opt'. Not {0}."
-                             .format(key))
+                             "'r', 'c', 'z', 'ext', 'opt' or 'pattern'. "
+                             "Not '{0}'.".format(key))
         if not isinstance(value, (list, str)):
             raise TypeError("A recipe can only contain lists or strings, "
                             "not {0}.".format(type(value)))

From 86e2ac44bbdef36c433caf46a1bac96967e3af89 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 7 May 2019 12:56:26 +0200
Subject: [PATCH 136/264] global refactoring

---
 bigfish/stack/__init__.py     |  99 +++++------
 bigfish/stack/illumination.py |  96 +++++++++++
 bigfish/stack/preparation.py  |   4 +-
 bigfish/stack/projection.py   | 312 ++++++++++++++++++++++++++++++++++
 4 files changed, 457 insertions(+), 54 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index fac2cb5b..8e44ab7d 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -5,14 +5,20 @@
 build stack of images.
 """
 
-from .loader import read_tif, read_pickle, read_cell_json, read_rna_json
-from .preprocess import (build_stack, check_recipe, build_simulated_dataset,
-                         projection, rescale, cast_img_uint8, cast_img_uint16,
-                         log_filter, mean_filter, median_filter,
-                         maximum_filter, minimum_filter, load_stack,
-                         gaussian_filter, build_stacks, cast_img_float32,
-                         cast_img_float64, compute_illumination_surface,
-                         correct_illumination_surface, clean_simulated_data)
+from .utils import (check_array, check_df, check_recipe, check_parameter,
+                    check_range_value, complete_coordinates_2d,
+                    from_coord_to_image)
+from .io import (read_image, read_pickle, read_cell_json, read_rna_json,
+                 save_image)
+from .preprocess import (build_simulated_dataset, build_stacks, build_stack,
+                         build_stack_no_recipe, rescale,
+                         cast_img_uint8, cast_img_uint16, cast_img_float32,
+                         cast_img_float64, clean_simulated_data)
+from .filter import (log_filter, mean_filter, median_filter, maximum_filter,
+                     minimum_filter, gaussian_filter, remove_background)
+from .projection import projection
+from .illumination import (compute_illumination_surface,
+                           correct_illumination_surface)
 from .preparation import (split_from_background, build_image, get_coordinates,
                           get_distance_layers, get_surface_layers, build_batch,
                           get_label, Generator, encode_labels, get_map_label,
@@ -20,50 +26,37 @@
                           remove_transcription_site, filter_data, balance_data,
                           get_gene_encoder)
 from .augmentation import augment
-from .utils import check_array, check_features_df, check_range_value
 
 
-__all__ = ["read_tif",
-           "read_pickle",
-           "read_cell_json",
-           "read_rna_json",
-           "build_simulated_dataset",
-           "load_stack",
-           "build_stack",
-           "build_stacks",
-           "check_recipe",
-           "projection",
-           "rescale",
-           "cast_img_uint8",
-           "cast_img_uint16",
-           "cast_img_float32",
-           "cast_img_float64",
-           "log_filter",
-           "gaussian_filter",
-           "mean_filter",
-           "median_filter",
-           "maximum_filter",
-           "minimum_filter",
-           "check_array",
-           "check_features_df",
-           "compute_illumination_surface",
-           "correct_illumination_surface",
-           "clean_simulated_data",
-           "split_from_background",
-           "get_coordinates",
-           "get_distance_layers",
-           "get_surface_layers",
-           "check_range_value",
-           "augment",
-           "build_batch",
-           "get_label",
-           "Generator",
-           "encode_labels",
-           "get_map_label",
-           "build_image",
-           "format_experimental_data",
-           "get_label_encoder",
-           "remove_transcription_site",
-           "filter_data",
-           "balance_data",
-           "get_gene_encoder"]
+_utils = ["check_array", "check_df", "check_recipe", "check_parameter",
+          "check_range_value", "complete_coordinates_2d",
+          "from_coord_to_image"]
+
+_io = ["read_image", "read_pickle", "read_cell_json", "read_rna_json",
+       "save_image"]
+
+_preprocess = ["build_simulated_dataset", "build_stacks", "build_stack",
+               "build_stack_no_recipe", "rescale",
+               "cast_img_uint8", "cast_img_uint16", "cast_img_float32",
+               "cast_img_float64", "clean_simulated_data"]
+
+_filter = ["log_filter", "mean_filter", "median_filter", "maximum_filter",
+           "minimum_filter", "gaussian_filter", "remove_background"]
+
+_projection = ["projection"]
+
+_illumination = ["compute_illumination_surface",
+                 "correct_illumination_surface"]
+
+_augmentation = ["augment"]
+
+_preparation = ["split_from_background", "build_image", "get_coordinates",
+                "get_distance_layers", "get_surface_layers", "build_batch",
+                "get_label", "Generator", "encode_labels", "get_map_label",
+                "format_experimental_data", "get_label_encoder",
+                "remove_transcription_site", "filter_data", "balance_data",
+                "get_gene_encoder"]
+
+__all__ = (_utils + _io + _preprocess +
+           _filter + _projection + _illumination +
+           _augmentation + _preparation)
diff --git a/bigfish/stack/illumination.py b/bigfish/stack/illumination.py
index e69de29b..525197a0 100644
--- a/bigfish/stack/illumination.py
+++ b/bigfish/stack/illumination.py
@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+
+"""Illumination correction functions."""
+
+import numpy as np
+
+from .utils import check_array, check_parameter
+from .filter import gaussian_filter
+
+
+# ### Illumination surface ###
+
+def compute_illumination_surface(stacks, sigma=None):
+    """Compute the illumination surface of a specific experiment.
+
+    Parameters
+    ----------
+    stacks : np.ndarray, np.uint
+        Concatenated 5-d tensors along the z-dimension with shape
+        (r, c, z, y, x). They represent different images acquired during a
+        same experiment.
+    sigma : float, int, Tuple(float, int) or List(float, int)
+        Sigma of the gaussian filtering used to smooth the illumination
+        surface.
+
+    Returns
+    -------
+    illumination_surfaces : np.ndarray, np.float
+        A 4-d tensor with shape (r, c, y, x) approximating the average
+        differential of illumination in our stack of images, for each channel
+        and each round.
+
+    """
+    # check parameters
+    check_array(stacks, ndim=5, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_parameter(sigma=(float, int, tuple, list, type(None)))
+
+    # initialize illumination surfaces
+    r, c, z, y, x = stacks.shape
+    illumination_surfaces = np.zeros((r, c, y, x))
+
+    # compute mean over the z-dimension
+    mean_stacks = np.mean(stacks, axis=2)
+
+    # separate the channels and the rounds
+    for i_round in range(r):
+        for i_channel in range(c):
+            illumination_surface = mean_stacks[i_round, i_channel, :, :]
+
+            # smooth the surface
+            if sigma is not None:
+                illumination_surface = gaussian_filter(illumination_surface,
+                                                       sigma=sigma,
+                                                       allow_negative=False)
+
+            illumination_surfaces[i_round, i_channel] = illumination_surface
+
+    return illumination_surfaces
+
+
+def correct_illumination_surface(tensor, illumination_surfaces):
+    """Correct a tensor with uneven illumination.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint
+        A 5-d tensor with shape (r, c, z, y, x).
+    illumination_surfaces : np.ndarray, np.float
+        A 4-d tensor with shape (r, c, y, x) approximating the average
+        differential of illumination in our stack of images, for each channel
+        and each round.
+
+    Returns
+    -------
+    tensor_corrected : np.ndarray, np.float
+        A 5-d tensor with shape (r, c, z, y, x).
+
+    """
+    # check parameters
+    check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_array(illumination_surfaces, ndim=4, dtype=[np.float32, np.float64],
+                allow_nan=False)
+
+    # initialize corrected tensor
+    tensor_corrected = np.zeros_like(tensor)
+
+    # TODO control the multiplication and the division
+    # correct each round/channel independently
+    r, c, _, _, _ = tensor.shape
+    for i_round in range(r):
+        for i_channel in range(c):
+            image_3d = tensor[i_round, i_channel, ...]
+            s = illumination_surfaces[i_round, i_channel]
+            tensor_corrected[i_round, i_channel] = image_3d * np.mean(s) / s
+
+    return tensor_corrected
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 61c3d6fe..3ef6856b 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -12,7 +12,8 @@
 from scipy import ndimage as ndi
 
 from .augmentation import augment
-from .preprocess import cast_img_float32, mean_filter
+from .preprocess import cast_img_float32
+from .filter import mean_filter
 
 from skimage.draw import polygon_perimeter
 from sklearn.preprocessing import LabelEncoder
@@ -402,6 +403,7 @@ def get_coordinates(data, id_cell, output_shape=None, coord_refinement=True):
 
     # complete cytoplasm and nucleus coordinates
     if coord_refinement:
+        # TODO use util.complete_coordinates_2d
         cyt_x, cyt_y = polygon_perimeter(cyt_coord[:, 0], cyt_coord[:, 1])
         cyt_x = cyt_x[:, np.newaxis]
         cyt_y = cyt_y[:, np.newaxis]
diff --git a/bigfish/stack/projection.py b/bigfish/stack/projection.py
index e69de29b..eb64d318 100644
--- a/bigfish/stack/projection.py
+++ b/bigfish/stack/projection.py
@@ -0,0 +1,312 @@
+# -*- coding: utf-8 -*-
+
+"""2-d projection functions."""
+
+import numpy as np
+
+from .utils import check_array
+
+from skimage import img_as_ubyte, img_as_float32
+from skimage.filters import rank
+from skimage.morphology.selem import square
+
+
+# TODO add safety checks
+
+# ### Projections 2-d ###
+
+def projection(tensor, method="mip", r=0, c=0):
+    """ Project a tensor along the z-dimension.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint
+        A 5-d tensor with shape (r, c, z, y, x).
+    method : str
+        Method used to project ('mip', 'focus').
+    r : int
+        Index of a specific round to project.
+    c : int
+        Index of a specific channel to project.
+
+    Returns
+    -------
+    projected_tensor : np.ndarray
+        A 2-d tensor with shape (y, x).
+
+    """
+    # check tensor dimensions and its dtype
+    check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+
+    # apply projection along the z-dimension
+    projected_tensor = tensor[r, c, :, :, :]
+    if method == "mip":
+        projected_tensor = maximum_projection(projected_tensor)
+    elif method == "mean":
+        projected_tensor = mean_projection(projected_tensor)
+    elif method == "median":
+        projected_tensor = median_projection(projected_tensor)
+    elif method == "focus":
+        # TODO complete focus projection with different strategies
+        raise ValueError("Focus projection is not implemented yet.")
+
+    return projected_tensor
+
+
+def maximum_projection(tensor):
+    """Project the z-dimension of a tensor, keeping the maximum intensity of
+    each yx pixel.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint
+        A 3-d tensor with shape (z, y, x).
+
+    Returns
+    -------
+    projected_tensor : np.ndarray, np.uint
+        A 2-d tensor with shape (y, x).
+
+    """
+    # project tensor along the z axis
+    projected_tensor = tensor.max(axis=0, keepdims=True)
+
+    return projected_tensor[0]
+
+
+def mean_projection(tensor):
+    """Project the z-dimension of a tensor, computing the mean intensity of
+    each yx pixel.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint
+        A 3-d tensor with shape (z, y, x).
+
+    Returns
+    -------
+    projected_tensor : np.ndarray, np.float
+        A 2-d tensor with shape (y, x).
+
+    """
+    # project tensor along the z axis
+    projected_tensor = tensor.mean(axis=0, keepdims=True)
+
+    return projected_tensor[0]
+
+
+def median_projection(tensor):
+    """Project the z-dimension of a tensor, computing the median intensity of
+    each yx pixel.
+
+    Parameters
+    ----------
+    tensor : np.ndarray, np.uint
+        A 3-d tensor with shape (z, y, x).
+
+    Returns
+    -------
+    projected_tensor : np.ndarray, np.uint
+        A 2-d tensor with shape (y, x).
+
+    """
+    # project tensor along the z axis
+    projected_tensor = tensor.median(axis=0, keepdims=True)
+
+    return projected_tensor[0]
+
+
+def focus_projection(tensor, channel=0, p=0.75, global_neighborhood_size=30,
+                     method="best"):
+    """
+
+    Parameters
+    ----------
+    tensor
+    channel
+    p
+    global_neighborhood_size
+    method
+
+    Returns
+    -------
+
+    """
+
+    # get 3-d image
+    image = tensor[0, channel, :, :, :]
+
+    # measure global focus level for each z-slices
+    ratio, l_focus = focus_measurement_3d(image, global_neighborhood_size)
+
+    # remove out-of-focus slices
+    indices_to_keep = get_in_focus(l_focus, p)
+    in_focus_image = image[indices_to_keep]
+
+    projected_image = None
+    if method == "bast":
+        # for each pixel, we project the z-slice value with the highest focus
+        ratio_2d = np.argmax(ratio[indices_to_keep], axis=0)
+        one_hot = one_hot_3d(ratio_2d, depth=len(indices_to_keep))
+        projected_image = np.multiply(in_focus_image, one_hot).max(axis=0)
+    elif method == "median":
+        # for each pixel, we compute the median value of the in-focus z-slices
+        projected_image = np.median(in_focus_image, axis=0)
+    elif method == "mean":
+        # for each pixel, we compute the mean value of the in-focus z-slices
+        projected_image = np.median(in_focus_image, axis=0)
+
+    return projected_image, ratio, l_focus
+
+
+def focus_measurement_2d(image, neighborhood_size):
+    """Helmli and Scherer’s mean method used as a focus metric.
+
+    For each pixel xy in an image, we compute the ratio:
+
+        R(x, y) = mu(x, y) / I(x, y), if mu(x, y) >= I(x, y)
+
+    or
+
+        R(x, y) = I(x, y) / mu(x, y), otherwise
+
+    with I(x, y) the intensity of the pixel xy and mu(x, y) the mean intensity
+    of the pixels of its neighborhood.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        A 2-d tensor with shape (y, x).
+    neighborhood_size : int
+        The size of the square used to define the neighborhood of each pixel.
+
+    Returns
+    -------
+    global_focus : np.float32
+        Mean value of the ratio computed for every pixels of the image. Can be
+        used as a metric to quantify the focus level of an 2-d image.
+    ratio : np.ndarray, np.float32
+        A 2-d tensor with the R(x, y) computed for each pixel of the original
+        image.
+    image_filtered_mean : np.ndarray, np.float32
+        A 2-d tensor with shape (y, x).
+
+    """
+
+    # scikit-image filter use np.uint dtype (so we cast to np.uint8)
+    image_2d = img_as_ubyte(image)
+
+    # filter the image with a mean filter
+    selem = square(neighborhood_size)
+    image_filtered_mean = rank.mean(image_2d, selem)
+
+    # cast again in np.float32
+    image_2d = img_as_float32(image_2d)
+    image_filtered_mean = img_as_float32(image_filtered_mean)
+
+    # case where mu(x, y) >= I(x, y)
+    mask_1 = image_2d != 0
+    out_1 = np.zeros_like(image_filtered_mean, dtype=np.float32)
+    ratio_1 = np.divide(image_filtered_mean, image_2d, out=out_1, where=mask_1)
+    ratio_1 = np.where(image_filtered_mean >= image_2d, ratio_1, 0)
+
+    # case where I(x, y) > mu(x, y)
+    mask_2 = image_filtered_mean != 0
+    out_2 = np.zeros_like(image_2d, dtype=np.float32)
+    ratio_2 = np.divide(image_2d, image_filtered_mean, out=out_2, where=mask_2)
+    ratio_2 = np.where(image_2d > image_filtered_mean, ratio_2, 0)
+
+    # compute ratio and global focus for the entire image
+    ratio = ratio_1 + ratio_2
+    global_focus = ratio.mean()
+
+    return global_focus, ratio, image_filtered_mean
+
+
+def focus_measurement_3d(image, neighborhood_size):
+    """Helmli and Scherer’s mean method used as a focus metric.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.float32
+        A 3-d tensor with shape (z, y, x).
+    neighborhood_size : int
+        The size of the square used to define the neighborhood of each pixel.
+
+    Returns
+    -------
+    ratio : np.ndarray, np.float32
+        A 3-d tensor with the R(x, y) computed for each pixel of the original
+        3-d image, for each z-slice.
+    l_focus : list
+        List of the global focus computed for each z-slice.
+
+    """
+    # apply focus_measurement_2d for each z-slice
+    l_ratio = []
+    l_focus = []
+    for z in range(image.shape[0]):
+        focus, ratio_2d, _ = focus_measurement_2d(image[z], neighborhood_size)
+        l_ratio.append(ratio_2d)
+        l_focus.append(focus)
+
+    # get 3-d Helmli and Scherer’s ratio
+    ratio = np.stack(l_ratio)
+
+    return ratio, l_focus
+
+
+def get_in_focus(l_focus, proportion):
+    """ Select the best in-focus z-slices.
+
+    Parameters
+    ----------
+    l_focus : array_like
+        List of the global focus computed for each z-slice.
+    proportion : float or int
+        Proportion of z-slices to keep (float between 0 and 1) or number of
+        z-slices to keep (integer above 1).
+
+    Returns
+    -------
+    indices_to_keep : np.array
+    """
+    # get the number of z-slices to keep
+    if proportion < 1 and isinstance(proportion, float):
+        n = int(len(l_focus) * proportion)
+    else:
+        n = int(proportion)
+
+    # select the best z-slices
+    indices_to_keep = np.argsort(l_focus)[-n:]
+
+    return indices_to_keep
+
+
+def one_hot_3d(tensor_2d, depth):
+    """Build a 3-d one-hot matrix from a 2-d indices matrix.
+
+    Parameters
+    ----------
+    tensor_2d : np.ndarray, int
+        A 2-d tensor with integer indices and shape (y, x).
+    depth : int
+        Depth of the 3-d one-hot matrix.
+
+    Returns
+    -------
+    one_hot : np.ndarray, np.uint8
+        A 3-d binary tensor with shape (depth, y, x)
+
+    """
+    # initialize the 3-d one-hot matrix
+    one_hot = np.zeros((tensor_2d.size, depth), dtype=np.uint8)
+
+    # flatten the matrix to easily one-hot encode it, then reshape it
+    one_hot[np.arange(tensor_2d.size), tensor_2d.ravel()] = 1
+    one_hot.shape = tensor_2d.shape + (depth,)
+
+    # rearrange the axis
+    one_hot = np.moveaxis(one_hot, source=2, destination=0)
+
+    return one_hot

From 99e94624c525d9dd7be042f589a89c2c3dc266f8 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 7 May 2019 13:03:09 +0200
Subject: [PATCH 137/264] add notebooks for examples

---
 .gitignore                            |   3 +-
 notebooks/Apply filters.ipynb         |  81 +++
 notebooks/Load coordinates data.ipynb | 129 ++++
 notebooks/Load images.ipynb           | 950 +++++++++++++++++++++++++
 notebooks/Normalize images.ipynb      | 972 ++++++++++++++++++++++++++
 5 files changed, 2134 insertions(+), 1 deletion(-)
 create mode 100644 notebooks/Apply filters.ipynb
 create mode 100644 notebooks/Load coordinates data.ipynb
 create mode 100644 notebooks/Load images.ipynb
 create mode 100644 notebooks/Normalize images.ipynb

diff --git a/.gitignore b/.gitignore
index 531d5ccd..f3bf9171 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,7 +9,8 @@ dist/
 big_fish.egg-info/
 
 # Notebooks
-notebooks/*
+notebooks/old
+notebooks/.ipynb_checkpoints
 
 # Data
 data/input/*
diff --git a/notebooks/Apply filters.ipynb b/notebooks/Apply filters.ipynb
new file mode 100644
index 00000000..b421e4f7
--- /dev/null
+++ b/notebooks/Apply filters.ipynb	
@@ -0,0 +1,81 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Apply filters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:bigfish]",
+   "language": "python",
+   "name": "conda-env-bigfish-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/Load coordinates data.ipynb b/notebooks/Load coordinates data.ipynb
new file mode 100644
index 00000000..fd3bb740
--- /dev/null
+++ b/notebooks/Load coordinates data.ipynb	
@@ -0,0 +1,129 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load coordinates data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import import bigfish.stack as stack\n",
+    "import bigfish.plot as plot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_directory = \"/Users/arthur/big-fish/data/input\"\n",
+    "output_directory = \"/Users/arthur/big-fish/data/output\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "read_image, read_cell_json, read_rna_json\n",
+    "build_simulated_dataset, build_stacks, build_stack,\n",
+    "                         build_stack_no_recipe, rescale, cast_img_uint8,\n",
+    "                         cast_img_uint16, cast_img_float32, cast_img_float64,\n",
+    "                         clean_simulated_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:bigfish]",
+   "language": "python",
+   "name": "conda-env-bigfish-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/Load images.ipynb b/notebooks/Load images.ipynb
new file mode 100644
index 00000000..4a7b4a54
--- /dev/null
+++ b/notebooks/Load images.ipynb	
@@ -0,0 +1,950 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T05:49:22.949211Z",
+     "start_time": "2019-05-06T05:49:21.406850Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import bigfish.stack as stack\n",
+    "import bigfish.plot as plot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T05:49:22.962804Z",
+     "start_time": "2019-05-06T05:49:22.956304Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['untitled folder',\n",
+       " 'dapi_1.tif',\n",
+       " 'smFISH_simulations__batch_0003.json.gz',\n",
+       " 'dapi_2.tif',\n",
+       " '.DS_Store',\n",
+       " 'smFISH_simulations__batch_0002.json.gz',\n",
+       " 'smFISH_simulations__batch_0001.json.gz',\n",
+       " 'r03c03f01_405.tif',\n",
+       " 'untitled folder.zip',\n",
+       " 'cy3_1.tif',\n",
+       " 'cy3_2.tif',\n",
+       " 'r03c03f01_561.tif',\n",
+       " 'cellLibrary.json',\n",
+       " 'gfp_2.tif',\n",
+       " 'gfp_1.tif',\n",
+       " 'r03c03f01_488.tif']"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "input_directory = \"/Users/arthur/big-fish/data/input\"\n",
+    "output_directory = \"/Users/arthur/big-fish/data/output\"\n",
+    "os.listdir(input_directory)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "heading_collapsed": true
+   },
+   "source": [
+    "## Load an image from one file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:31:24.632366Z",
+     "start_time": "2019-05-04T14:31:24.167468Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(35, 2160, 2160) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "path = os.path.join(input_directory, \"r03c03f01_405.tif\")\n",
+    "image = stack.read_image(path)\n",
+    "print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "heading_collapsed": true
+   },
+   "source": [
+    "## Load a multidimensional image from multiple files"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "hidden": true
+   },
+   "source": [
+    "### Using a recipe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:31:24.857383Z",
+     "start_time": "2019-05-04T14:31:24.635208Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "The recipe can only contain the keys 'fov', 'r', 'c', 'z', 'ext', 'opt' or 'pattern'. Not 'unexpected_key'.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-4-6d9439535b0f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m                 \u001b[0;34m\"pattern\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"fov_c.ext\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m                 \"unexpected_key\": \"blabla\"}\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mstack\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheck_recipe\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrong_recipe\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/big-fish/bigfish/stack/utils.py\u001b[0m in \u001b[0;36mcheck_recipe\u001b[0;34m(recipe)\u001b[0m\n\u001b[1;32m    303\u001b[0m             raise ValueError(\"The recipe can only contain the keys 'fov', \"\n\u001b[1;32m    304\u001b[0m                              \u001b[0;34m\"'r', 'c', 'z', 'ext', 'opt' or 'pattern'. \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 305\u001b[0;31m                              \"Not '{0}'.\".format(key))\n\u001b[0m\u001b[1;32m    306\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    307\u001b[0m             raise TypeError(\"A recipe can only contain lists or strings, \"\n",
+      "\u001b[0;31mValueError\u001b[0m: The recipe can only contain the keys 'fov', 'r', 'c', 'z', 'ext', 'opt' or 'pattern'. Not 'unexpected_key'."
+     ]
+    }
+   ],
+   "source": [
+    "wrong_recipe = {\"fov\": \"r03c03f01\", \n",
+    "                \"c\": [\"405\", \"488\", \"561\"], \n",
+    "                \"ext\": \"tif\",\n",
+    "                \"pattern\": \"fov_c.ext\",\n",
+    "                \"unexpected_key\": \"blabla\"}\n",
+    "stack.check_recipe(wrong_recipe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:31:24.971453Z",
+     "start_time": "2019-05-04T14:31:24.960080Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "A recipe can only contain lists or strings, not <class 'int'>.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-5-3c7393a220e4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m                 \u001b[0;34m\"ext\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"tif\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m                 \"pattern\": \"fov_c.ext\"}\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mstack\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheck_recipe\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrong_recipe\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/big-fish/bigfish/stack/utils.py\u001b[0m in \u001b[0;36mcheck_recipe\u001b[0;34m(recipe)\u001b[0m\n\u001b[1;32m    306\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    307\u001b[0m             raise TypeError(\"A recipe can only contain lists or strings, \"\n\u001b[0;32m--> 308\u001b[0;31m                             \"not {0}.\".format(type(value)))\n\u001b[0m\u001b[1;32m    309\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    310\u001b[0m     \u001b[0;32mreturn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mTypeError\u001b[0m: A recipe can only contain lists or strings, not <class 'int'>."
+     ]
+    }
+   ],
+   "source": [
+    "wrong_recipe = {\"fov\": \"r03c03f01\", \n",
+    "                \"c\": [\"405\", \"488\", \"561\"],\n",
+    "                \"r\": 0,\n",
+    "                \"ext\": \"tif\",\n",
+    "                \"pattern\": \"fov_c.ext\"}\n",
+    "stack.check_recipe(wrong_recipe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:31:25.372076Z",
+     "start_time": "2019-05-04T14:31:25.369016Z"
+    },
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "recipe = {\"fov\": \"r03c03f01\", \n",
+    "          \"c\": [\"405\", \"488\", \"561\"], \n",
+    "          \"ext\": \"tif\",\n",
+    "          \"pattern\": \"fov_c.ext\"}\n",
+    "stack.check_recipe(recipe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:31:29.568980Z",
+     "start_time": "2019-05-04T14:31:26.565457Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack(recipe, input_directory)\n",
+    "print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:31:42.363823Z",
+     "start_time": "2019-05-04T14:31:39.704277Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack(recipe, input_directory, input_dimension=3)\n",
+    "print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:31:46.456238Z",
+     "start_time": "2019-05-04T14:31:42.366087Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack(recipe, input_directory, check=True)\n",
+    "print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:43:42.381393Z",
+     "start_time": "2019-05-04T14:43:42.378143Z"
+    },
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "recipe = {\"fov\": [\"1\", \"2\"], \n",
+    "          \"c\": [\"dapi\", \"cy3\", \"gfp\"], \n",
+    "          \"ext\": \"tif\", \n",
+    "          \"pattern\": \"c_fov.ext\"}\n",
+    "stack.check_recipe(recipe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:44:32.120944Z",
+     "start_time": "2019-05-04T14:44:27.497492Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 34, 2048, 2048) uint16\n",
+      "(1, 3, 34, 2048, 2048) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_1 = stack.build_stack(recipe, input_directory, i_fov=0)\n",
+    "print(image_1.shape, image_1.dtype)\n",
+    "image_2 = stack.build_stack(recipe, input_directory, i_fov=1)\n",
+    "print(image_2.shape, image_2.dtype)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "hidden": true
+   },
+   "source": [
+    "### Using paths"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:31:54.361584Z",
+     "start_time": "2019-05-04T14:31:54.357991Z"
+    },
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "path_1 = os.path.join(input_directory, \"r03c03f01_405.tif\")\n",
+    "path_2 = os.path.join(input_directory, \"r03c03f01_488.tif\")\n",
+    "path_3 = os.path.join(input_directory, \"r03c03f01_561.tif\")\n",
+    "paths = [path_1, path_2, path_3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:31:58.989244Z",
+     "start_time": "2019-05-04T14:31:56.589989Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack_no_recipe(paths)\n",
+    "print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:33:39.223848Z",
+     "start_time": "2019-05-04T14:33:37.224409Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack_no_recipe(paths, input_dimension=3)\n",
+    "print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:33:42.629393Z",
+     "start_time": "2019-05-04T14:33:39.226158Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack_no_recipe(paths, check=True)\n",
+    "print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "heading_collapsed": true
+   },
+   "source": [
+    "## Load several multidimensional images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:37:22.406086Z",
+     "start_time": "2019-05-04T14:37:22.402319Z"
+    },
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "recipe_1 = {\"fov\": \"r03c03f01\", \"c\": [\"405\", \"488\", \"561\"], \"ext\": \"tif\", \"pattern\": \"fov_c.ext\"}\n",
+    "recipe_2 = {\"fov\": [\"1\", \"2\"], \"c\": [\"dapi\", \"cy3\", \"gfp\"], \"ext\": \"tif\", \"pattern\": \"c_fov.ext\"}\n",
+    "data_map = [(recipe_1, input_directory), (recipe_2, input_directory)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:38:43.799972Z",
+     "start_time": "2019-05-04T14:38:34.224549Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "(1, 3, 34, 2048, 2048) uint16\n",
+      "(1, 3, 34, 2048, 2048) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_generator = stack.build_stacks(data_map)\n",
+    "for image in image_generator:\n",
+    "    print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:40:00.775477Z",
+     "start_time": "2019-05-04T14:39:52.693497Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "(1, 3, 34, 2048, 2048) uint16\n",
+      "(1, 3, 34, 2048, 2048) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_generator = stack.build_stacks(data_map, input_dimension=3)\n",
+    "for image in image_generator:\n",
+    "    print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:40:11.806833Z",
+     "start_time": "2019-05-04T14:40:00.778122Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "(1, 3, 34, 2048, 2048) uint16\n",
+      "(1, 3, 34, 2048, 2048) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_generator = stack.build_stacks(data_map, check=True)\n",
+    "for image in image_generator:\n",
+    "    print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T14:42:52.284641Z",
+     "start_time": "2019-05-04T14:42:44.693485Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "##############################\n",
+      "Input folder: /Users/arthur/big-fish/data/input\n",
+      "Recipe: {'fov': ['r03c03f01'], 'c': ['405', '488', '561'], 'ext': 'tif', 'pattern': 'fov_c.ext', 'r': [None], 'z': [None], 'opt': ''}\n",
+      "Field of view index: 0\n",
+      "Image: (1, 3, 35, 2160, 2160) uint16\n",
+      "##############################\n",
+      "Input folder: /Users/arthur/big-fish/data/input\n",
+      "Recipe: {'fov': ['1', '2'], 'c': ['dapi', 'cy3', 'gfp'], 'ext': 'tif', 'pattern': 'c_fov.ext', 'r': [None], 'z': [None], 'opt': ''}\n",
+      "Field of view index: 0\n",
+      "Image: (1, 3, 34, 2048, 2048) uint16\n",
+      "##############################\n",
+      "Input folder: /Users/arthur/big-fish/data/input\n",
+      "Recipe: {'fov': ['1', '2'], 'c': ['dapi', 'cy3', 'gfp'], 'ext': 'tif', 'pattern': 'c_fov.ext', 'r': [None], 'z': [None], 'opt': ''}\n",
+      "Field of view index: 1\n",
+      "Image: (1, 3, 34, 2048, 2048) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_generator = stack.build_stacks(data_map, return_origin=True)\n",
+    "for (image, input_folder, recipe, i_fov) in image_generator:\n",
+    "    print(\"##############################\")\n",
+    "    print(\"Input folder:\", input_folder)\n",
+    "    print(\"Recipe:\", recipe)\n",
+    "    print(\"Field of view index:\", i_fov)\n",
+    "    print(\"Image:\", image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Vizualise an image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T05:49:27.584232Z",
+     "start_time": "2019-05-06T05:49:23.427482Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n"
+     ]
+    }
+   ],
+   "source": [
+    "recipe = {\"fov\": \"r03c03f01\", \n",
+    "          \"c\": [\"405\", \"488\", \"561\"], \n",
+    "          \"ext\": \"tif\",\n",
+    "          \"pattern\": \"fov_c.ext\"}\n",
+    "image = stack.build_stack(recipe, input_directory, input_dimension=3, check=True)\n",
+    "print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "heading_collapsed": true
+   },
+   "source": [
+    "### Plot a 2D slice of the image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T15:46:38.812122Z",
+     "start_time": "2019-05-04T15:46:37.051889Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "path_output = os.path.join(output_directory, \"image_2D\")\n",
+    "plot.plot_yx(image, r=0, c=0, z=17, \n",
+    "             title=\"Image 2D (18th z-slice)\", \n",
+    "             framesize=(10, 10), remove_frame=False, \n",
+    "             path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T15:46:40.655506Z",
+     "start_time": "2019-05-04T15:46:38.813807Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "path_output = os.path.join(output_directory, \"image_2D_no_frame\")\n",
+    "plot.plot_yx(image, r=0, c=0, z=17, \n",
+    "             title=\"Image 2D (18th z-slice)\", \n",
+    "             framesize=(10, 10), remove_frame=True, \n",
+    "             path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "heading_collapsed": true
+   },
+   "source": [
+    "### Plot several 2D images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T16:30:47.786185Z",
+     "start_time": "2019-05-04T16:30:46.768669Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "images = [image[0, 0, 0, :, :], image[0, 0, 17, :, :], image[0, 0, 34, :, :]]\n",
+    "titles = [\"Image 2D (1st z-slice)\", \"Image 2D (18th z-slice)\", \"Image 2D (35th z-slice)\"]\n",
+    "path_output = os.path.join(output_directory, \"3x_images_2D\")\n",
+    "plot.plot_images(images, \n",
+    "                 titles=titles, \n",
+    "                 framesize=(15, 5), remove_frame=False,\n",
+    "                 path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T16:30:48.496841Z",
+     "start_time": "2019-05-04T16:30:47.788329Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "images = [image[0, 0, 0, :, :], image[0, 0, 17, :, :], image[0, 0, 34, :, :]]\n",
+    "titles = [\"Image 2D (1st z-slice)\", \"Image 2D (18th z-slice)\", \"Image 2D (35th z-slice)\"]\n",
+    "path_output = os.path.join(output_directory, \"3x_images_2D_no_frame\")\n",
+    "plot.plot_images(images, \n",
+    "                 titles=titles, \n",
+    "                 framesize=(15, 5), remove_frame=True,\n",
+    "                 path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T16:30:49.265568Z",
+     "start_time": "2019-05-04T16:30:48.757397Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "images = [image[0, 0, 17, :, :], image[0, 0, 34, :, :]]\n",
+    "titles = [\"Image 2D (18th z-slice)\", \"Image 2D (35th z-slice)\"]\n",
+    "plot.plot_images(images, titles=titles, framesize=(10, 5))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T16:31:37.479009Z",
+     "start_time": "2019-05-04T16:31:36.484266Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "images = [image[0, 0, 0, :, :], image[0, 0, 17, :, :],\n",
+    "          image[0, 0, 22, :, :], image[0, 0, 34, :, :]]\n",
+    "titles = [\"Image 2D (1st z-slice)\", \"Image 2D (18th z-slice)\",\n",
+    "          \"Image 2D (22sd z-slice)\", \"Image 2D (35th z-slice)\"]\n",
+    "plot.plot_images(images, titles=titles, framesize=(15, 10))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-04T16:31:41.501133Z",
+     "start_time": "2019-05-04T16:31:40.135423Z"
+    },
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "images = [image[0, 0, 0, :, :], image[0, 0, 8, :, :], image[0, 0, 17, :, :],\n",
+    "          image[0, 0, 22, :, :], image[0, 0, 28, :, :], image[0, 0, 34, :, :]]\n",
+    "titles = [\"Image 2D (1st z-slice)\", \"Image 2D (9th z-slice)\", \"Image 2D (18th z-slice)\",\n",
+    "          \"Image 2D (22sd z-slice)\", \"Image 2D (29th z-slice)\", \"Image 2D (35th z-slice)\"]\n",
+    "plot.plot_images(images, titles=titles, framesize=(15, 10))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plot 2D slices of every channels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T05:51:18.144715Z",
+     "start_time": "2019-05-06T05:51:16.312086Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "titles = [\"Nucleus\", \"Cytoplasm\", \"RNA\"]\n",
+    "path_output = os.path.join(output_directory, \"image_channels_2D\")\n",
+    "plot.plot_channels_2d(image, r=0, z=17, \n",
+    "                      titles=titles, \n",
+    "                      framesize=(15, 5), remove_frame=False, \n",
+    "                      path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T05:56:38.423163Z",
+     "start_time": "2019-05-06T05:56:36.799193Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAAFqCAYAAADsuaogAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsvWmsbctWHvaNqtmsZu99zj7nnnvOve/e9951/MwD08UkUQIOAdtgBQXHBAuHJA44wY5tEQnsiDQitJItY5k0GNmylQQRxcYdoUmkBCd52FikIRAFMH4Bv+6+e989zT3NblYzm6qRH2POteaae7ar2XvtfeqTtvZac9WcVbOpMau++sYYxMxwcHBwcHBwcHBwcHBwcHBw2Geoq26Ag4ODg4ODg4ODg4ODg4ODQxscgeHg4ODg4ODg4ODg4ODg4LD3cASGg4ODg4ODg4ODg4ODg4PD3sMRGA4ODg4ODg4ODg4ODg4ODnsPR2A4ODg4ODg4ODg4ODg4ODjsPRyB4eDg4ODg4ODg4ODg4ODgsPdwBIbDXoGIfoyIOPv7f0q/fV/ht9+9y7q3fWwHBweHfQMRfTkR/QQRvUNEERG9R0QfI6I/QUS6x3G+NbPP37HL9hbq+/nMVn/6MupzcHBwuO4oja/zv1Mi+kUi+uZS2WKZ7yj99uls+z+pqeeXCvu+S0S0y/NyeDnhCAyHfcaXEtHXXXUjHBwcHG4aiOg/BfAPAfxhAB8AEAB4AOCrAPxlAIc9DvetAL4XwKUQGA4ODg4OW8EhgH8BwF8noj9cU+bPEFHQ5WBE9NsA/DOFTa8D2PqCo4ODIzAc9h3/8VU3wMHBweEmgYi+EcAPACAAjwF8I4AxgNsA/gCAX7y61jk4ODg47BhfDWCA1TH2H68p+waAf7vjcb+p4zYHh43gCAyHfYYB8LuJ6CurfiSiryrI1L61sL3SFYSIfnv22ztEFBPRIyL6aSI6bmoEEX2UiP4GET3M9vsMEf0wER0WynxroS1fVdh+QeqcteMnMmldRERPMgmfI2scHBwuA99T+PwtzPyTzDxl5hNm/lnIitlfyGzXCRGN8sJE9DUFW/cNmZ39l7KfP1T47ccK+3w9Ef39TK48J6JfI6L/oOimUnIR/Eoi+hkimmRuLd/XJkPO6vhfiOhzmV2dENEvE9G/VyrXan9LUusvyyTRMyL6hWz/DxPRz2V1/BoRfe06N8HBwcHhqsDMEYAfLWx6s6KYyf5/FxF1mTPmZMVnAPxC9vkPddzXwaEz3APlsM/429n//2TTAxHRFwH4ZQDfApFL+wBehaw23mrY70sA/BKAfx3A/Wy/DwL4TgAfI6Jwjeb8LES2/TpEtv0KRML3b65xLAcHB4fOIKLXAHxx9vXjzPw/lcswM0PcSADgCMAfKvz8jdn/pwD+xw71/UkAPwPgKyFy5RDAFwL4CwD+es1uPwng6wGMIG4t34t2Nd5XAPi9AF6D2NURgN8F4K9kbcjR1/7+HEQSPYAQOz8N4O8B+Jqsji8E8JNEdLelfQ4ODg77hiIx/Lji918E8C6Aj6BFSUFEHwHwT2dffzb7A8SGVy5EOjisC0dgOOwz/iKACMDvJ6LfteGx/nPIQBwAvh8yaH0NwLcDmDbs98MADgD8FoDfCRnE5gP4LwPwR/s0IhvkfjT7+qchg/kHAL4WwI/3OZaDg4PDGvhg4fP/V1eImX8FwP+Vff13ACBbRfuD2ba/ycwxMxOAv59t+wwzU/b3rZlK7c9nv70L4EsgRPD/lm37pqJirYBfh9jFLwbwuWzbdxVVbxX4KQD/HIC7EKL5QwB+JfvtT2btX8f+/hSAYwA/kX3/AgBnkPfHn862jQH8yw1tc3BwcNgrZAtwf6qw6e9UFIshY3EA+I9aDlkkOH4GSwKj/JuDw8ZwBIbDPuMhgP8m+7y2CoOIhlhKnH+Zmb+PmZ8y80Nm/lFmrmKdkcmm8/0+AuAfAZgD+LuFYl/dszkvAJxmn/8NAN8F4MsB/Doz/1DPYzk4ODj0RZ8sS7kK4yuz4GxfASEgAOC/7bD/l2MZDPSvMfOvZvb2BwplqtwvfpCZHzHzrwH4r7JttyAkch3eAfDvA/hVADOIhDknvn9H9n8d+/tnmfkFliQNAPwlZn6IVQVKlfzawcHBYR/xMch49s8BSAH8ZwD+y5qyfxWiuPsSIvpXGo6ZkxSnAH6emT8OIM9U8o3UI7OVg0MbHIHhsO/4IYhx/QYsV87aUDaSdwrbalccK3Bccawy7vRpCzMbiGrjEUSW/IMQufS7RPTXerTNwcHBYR28Xfj8eS1l/yaA5xCZ8R/FUn32W8z8f3So65XC588WPr9T+HyvYr9i2XcLnz9QVUmmDPkfAPyRrIxXKhICa9vfz2T/54Vt+TWMy3U4ODg4XDMQRGlcCWaeAPgvsq+VrnxE9FEsXRP/bwCfR0RfCHHBBsRl+6u20VgHB8ARGA57Dmb+FES6q7Dqhw2Ie0mOQeHzh0vlnmEZiKhtwF7EcwA2+/xTBWn04g/L1cOubQEz/yTE//pLIYz1fwd5gXwbEX1Fj/Y5ODg49EKmHPjV7OtHqwJQUgZmngH4sWzzt0CIZOCi+qJO1fF+4fMbNZ+LZap+L5IW75YLZvgIxD0lb9vtzD7/3XLBvvaXmdOK+qq2OTg4OFwXfDWEPP4pyELbH4PEdqvDj0Bc574cq/Y5R9FF5PcA+LXs75tryjg4bARHYDhcB/w5yAC5rIYoruJ9bTbm/j0QmfMC2SD857OvX0ZE30NEd4joPhH9CSJ6tapSZp4C+AfZ168noj9CRGMiuk1EX0dEP41lYKJiW34/IJlJUGHoiehHAPyLAN6DBIQrBtGrWo10cHBw2Ca+v/D5x4noDxLRiIiOiOjrIYHb8uDGfwVif9+ExM9gXCQwnmf/XyGiB4Xt/zuA8+zzHyOiLyKiewC+u1Dm5yra992Zff4iAP9utu0E4sZXhaDweQYgJqKvAfB15YLO/jo4ODgAzPw+gG/D0q3uu4moMqh95kaXuxRWKZO7kBP/GhGV1XEODmvBERgOew9m/g3IQLO8/bNYBpn7BogR/l+xKvXN8Z1YGunvh/jzPYQY5FFF+Rx/BsAEYrB/HDIYfw7xff4DWEZw/j+xJDG+g4jOIPE7ZhXH/HYIofIIotzIJwMnALrIsh0cHBzWRqZCyFOp3gfw30Ps3Akk+No/Xyj7m1gG3QSAf8jMny4dMpcJjwG8l6Uf/TZmPsVScvwGRPnxGMDvy7b9HWb+WEUTPx9in38VopYAgB9i5rOaU/o4gE9mn/84JDDz/5wdowxnfx0cHBwAMPNTiLoCAG5jGZi4Cj+MivE1Ef1OLOMTXVArY+l+8gpEneHgsDEcgeFwXfBna7Z/M4S0mECkyN8J4G+VC2XB4L4MQkJ8DkACGUj/LGTgWoksEv8/C+BvQAa8CWTl7mMAvgNZlHtmjgH8qxBCZQYhM/4tLAmWIv48hPB4PzveQ8ik4fdl8m4HBweHnYKZfxCSFvRvYWkTH0GCVf4piFw4x18ufK7K1vEjECLggjsIM/8lCMH8CxACOALwGwD+Q6zKi4v4Roi0eQqx0z8AUeLVnUsCsb+/ALG/n4C4vPyDiuLO/jo4ODgs8cNYLvB9BxEdVxVi5kcA/uuKn4rqi6rU2D9R+OzcSBy2ApJ07w4ODg4ODg4OF0FE3w4hKc4BvMHMtaTvBnV8H4Dvzb6+VaHycHBwcHBwcHBwCgwHBwcHBweHiyCibyeiT2IpMf7RXZAXDg4ODg4ODg5d4YKpODg4ODg4OFThFQBvAXgByejxPc3FHRwcHBwcHBx2C+dC4uDg4ODg4ODg4ODg4ODgsPdwLiQODg4ODg4ODg4ODg4ODg57D0dgODg4ODg4ODg4ODg4ODg47D32PgbG1+hvWvVxuUqXF6Lan/ThIWg8AsIAmEfg+RycpLKb1oDWgFaggzFgLGAt7IsT2Ol0/faUrwXR1V6fYjtWvivoW0fA3dtyHRSBXpwBgQ8OfEApQBFgLChJZf/pDJwkIN8HhgMAAI8GQGqkjLUw7z4Ep8mynuK5N9yrvE2kCNAaKgxBR4cwD45hfQ0AUKkFmEHzdEHzkWHYgXQZ/XwCfv8Z7HQKtgyw3Y9r73At8ffs3255YPcDC3tMSp75/DOw/N4HzNV2q63/ViFvU7Ftl4n8HKranp9nsdxloKotm9yv2npqrnnTNSnuR6W1lL5tK9fvbLHDBrh29rhp7NO3vzf1nXXscpe62uzDJseuOv5V2YeK8/Qe3AenBub9CxmoW461hh2vut7ZNdaHhzBnZ+sfu9w8rRfH4iRe+zgODnX2eO8JDDUayQdjwGkKNka+1xmgq57EM2MRVyQftKrsjxSQpIDvLX9vOdbKoLfu3PLtVcapab/LACno41vA3WPA06DpHOxpISWiGGQZSFPw4Rj21ggUp/IXxUCaCuExj+RYnoY5HkOfzABPQ7/5OuznHsJG2e9dz5MUSGtQ4INeexX2+AAm1NCTBAgAVgSjNcgw4Gt4JzMAACsFEIESIwRLHDvywuHlxLYmv9siLy4c9xJJjE42h1Y/79ouNx17nevSdj3XnmRUkBfletvqaNrfweFlQZPdXJe8KNuR3G5ty77Wjmmz41eRkm3vhy4LWXUk8xUgffho+aXvdd3GPchs8IK82NJxF3M1mMZyDg7rYu8JjAWL53sgG4CZwbOZdI4qg7NtI1Q0sEVC4UK1DFKFgZS92A4ahECSANYCSi0UGhcM7uIlUTHorWtfm6Eukxq7Qqkd5HvAndtSZ2qEtEg1kN+/rDxNZtCzCPOP3Id/GoF8DZpG4MAHTefAPALNImgAZCzYGJhbYyj/DdCnPwuOOzK8JfIi+tAdAIAJFeLjAN7UiPoCQHLgI3g2BwceYC048KDO5qCTM9izc3Cabu2yOThcW+ST0N6Drxq7tS6hkdd92eqLtdQiBbu8i3dW8f/Kbz2UM8Wy5TJd73WXa1MkMcrHLP5WrrOO3HBksoPDEpvYw1pCwy5/X5dwbtq3rKRbh7zI0YUELR57F/aj7zts22U3PBZpXSAkHBz2A9dj6UJlnd/3QIEPdTAWYmPbcrYqFI1sU31J5spgWdweiihsY2aZbFu7NAhViolyG6pIjRwd3CUWf3n5XVy7MnmhNdTBWBQnvie/Bz7gaXBqgNEQyNUYSgHWIvzsc6gXEwAAHwxF0TIMxTXH06DUgLUCGQs1jwFmqDdfB3l+ZRsqm6kV1J1jxG8cgzWBCfBmBjqyMAOFZOSBUkb4dA4berCBqDH0kxPg6fMFebFQXzg4OKyHtsHiZdj4TZDb5k0Gvdu2x01tKZIX5RXOprI56oiGdVUQxfdS3TGr2lielDgVhsPLik1IhOIxutiwcl1bUctdPAZpLS6+LeUWbSr+ryvfxU5s41qW0Yek3rUdq3Iv6lBnkbxYjLUdHK4Ye6/AYGbAMMjzAKUXRkiNRhJ/oE6Jsd1GtBaxcSJskCIAMlEnANAaNBrKBD5JQURAEMgE/sKArWU1snWwn6kLtBJFCBEoCEDHt0QRwgyOYvB0Co6i1Qn4pgPwqs2eBzo8AKdGYl14QlKAGTTK4lr4npAS80hiY0zn4DSFSlIhNQDwIAAHPjgMQMxAnMi1tBYcBgAR9JuvI/30Z7Pno96fkrQGHYwx+/wHgGVYj6DSbLeUoSyDNWH+SoDwaQz/8RloIvE4OE3B8wgcJ9lzt4Vr5+Bw3XFVMSduGrahxuhCZlcRF033sMu93ThmRVX8jBbiYpP6HRxuCspuxrusp8U+kdbdF3Ya2nphtb/pvHKXFhRceQvK5BX1QFc7sU1lXJ/7chl2rNQWNQhhZ7POu6/EnQPalXxufOywI+w9gUFaAZ4nRAAROF0Ovmg4BE+mWDFcO2lEhTErGyW24MkEdOsIiBPQ4YG4TDCLyiBJwVEEGgxkMlz0NyvWUefq0eIrroZDqHt3hSgAhLxIDdjT4LycteI6MQglvoRSsC9OhMxoiy3Sdm0qmF0ahIBSoPw6+J5cCyKJBRLFIE+Lm8ggBDwNe2sM9eSFHCM14GEImsdg3wM8JUE2Bx6Up+X6AkJiMEMF/jIexoV2StBOCnykH3kDyVhDzy28mQErgjIWlDJgGWboIR0T4uMAKh3BOzkDZnOJeWGsk9I5OBSxq0HXdVBfANudQOza1W8TkqJPuSbUBe7sUu+mwT4drh+uIvjtdUKNOpeCoIdrbYcJe1UsjJLN02+8DvPO58B9h0iNBGrFuPhCe+3F9uUfy4He28iQOtX1Bs9fr3tRRN25bwtse5EXdcdoxFXHJXS4Ouz43u+97pLjRLJ2AGBjZeJNauFOQnlAzF25RQCrRqPBF8+cnos6YBBKOVvo2NYuXUtmc9i4xGIWZXDFOppe3otyCur+PSELMrcKMEuwzJLcj3WW8WMQgm8dQN05hjo87OWCcaENVRJARaDDQ7CiZXt8LUoQYwHLyxgSnhZygxnqxbnEx1BKtgPgLPgnUguK5Lpx4IFHIezhANAE1gT14NXmtmoN+tAHMH19AJUy2COkAw09TUGxRTr2kBz5UIncN5Uwpq8Pkbz1AHwhiGzV6uCeT7gcHPYNjYHnNnTN2DYu292l6/F2uuq6gyFCWXnRV2lR3Me5jtwsFCeOVXHAyhNL986tvQadJ8x97WzVBD/bP/3MZ6sXeNpcFepi2xTrKH6vWlAsl+nrbl0e21fVuw6I1iMvttmGq8Q+vcMduqPq2SMSTwilK200eV7JZqudPrP7//a3VhQC0xmQxJkrROYmYBkUBJcziKlabbtQxsI8eR88nWWKAb0sG/hCGiQJzPmknbVs860uPDg6D5KZxdegWSQET5yAzqfyF0ncDTJW2gaICsLToKMD6LvHci2L59gFdS9PuyRw2NNAGIBmYsQpTsCDADgci2KkyHoTieJmHi0ytnAYZLEzFChKoWYJKE4XhAwrJUFRx8PqZyFzHdF3jnH6BccIzgwoZZBlmIFCdDfE9PUBpvc8sCLM7gdIRsvzio8D0Ov3iydXfS2coXZwaEeFzHfxvc6N7ir6Vp3i7TLb08UWd2lL13dkMWAmUE8udPSdrq2/1Re9bVWvjuBwNvhGoNjH6vph1f+6zw7d0GchsE0hvFK2Jd5OuWxdfZ1s3fpEQ32bOgYR3VZb+mJf7d6+tsuhGnWEWcnboG4BdyWkQx7yId9/B31h/wmMLLgjjBHyQhdIAUUgrZaZSoDdGYyOMkY2BubJU/DDJ6I00ErabCz4+QuYJ0+3KntVYQg6GMuXPKuJMaDnpxlblsWRCAPYWyMhL7RexKLgYSjfByHU4UEhd/MaL7HyT1EkbizDAOntIXiQZRTJiAl7ewweD8BKwd4aw9w9BPuekBvDgbSNGWQtkge3JH2pp4WgUQo20GBfg8PsfKxdfRYykCKo4QDzL/gAAMCbpPCncq2SEUHPDcgCrAnD9ya49SuPMHhmkBwoqJgBBszxWNjFHufvsKfo8mwX2WU3AN4uyquqVdvqiIy166x51TVNhLfRhm2Q623PX5eJWtMKZ7lcl5Spfd9hXWNcbHI8h+uLLmqLOtQFlixPsG+6HW9TJaxzDKDZDpav8bZRrucq3BGq1NFdcJnPW69FxxJJ3YY6IrHt+A7XD1VEXdfxcpXnALCck9X8vgn2PgZGcRIOQNwfbCZLyTuKqnhhbRtt8rKVshb2/Bz2/Bx57IVdZaxQx7eFlMhiTdAglGCXydI9gwdD2EGmrrAW8D2YO0egxEggTE+DYgsaj6A9D/b0DHYeoTW2SNuAOXP/oSiFxhyUWvDhSGJXpAaUWthAQycGiFPQJAUPA5hxCBtqeGeRqC3mMbwnmeJiJLEy2FNQsQGdzABjJGNJGi+fhUUbhUCiW0eY3vfhzRhkLOKjECZQGLwwCJ7P4Z8qeMehKDsAhM8i2GAA/zyFCRXY16JQiZP2Ab7DfqPsv1s3OOrqylW1r8PmqJMKr/PyWyf2Q6Wv9Zbq7YtG5V+fQXXX9KcdynVJv7rNNpX3KbfB9b/rhbICq7g9R5f+Xvd70/ab/qzUxKhY+b0Km6pW1rDPjfEhroJ0qiPEir93xL6lH1VhuIgTR4q6xSrp80y4sfH1xib97UI/yUM/lLJtbjGOy/4TGMxLxYDK/G9gVlg+IgLLh+U+u2zPsuL2m8G2u5FYp92el10jJQEvZxHs0RBm4ME7nYMMA1EMPhwsJvd0cg5NBL51AA48EAC2WXyJQQg1CIGHj7M4HQ0kRousjuNYYmEkqShRUgNK0iyriAeKErl3vgZSCz4aglILYkY61NBTBXMQAgdhljY1BRNJJhIA6nQKJCnMfXGhocytqGxEyfNgjw+gUsCEhNmDAeKxwuBZdmOUghn58OZGlCJ6DJUYeOcGeppAxQrpyIMXuPRRNwJ1q/5V26rky3WEx8swMN4VquxoF2JpV8jr7HI/t/hCXhtd3kVdUQywuc6AtJyqdaWdFVlQ1hnwukHy9UbXSdG2+1WlJPqa2+w6EqjJHpTHylXfy+59a44DW5vfJT5EH3u8Kbb1zDHvFXkBYCXIfee21b2bK4kxRyhfW2yBoCLPv5ilpvxbHTm4xvOy91ofCvxl5oxcwm8MYI1MyMsKjUtr2BYHjGu3Qa20gcMAPAyhZlmgy9CXTB9RAhWlUPNU0pTGCXg2k9gY00hiSPiekAwAoBTUg1eFyACaz7HhNxsnkh7VGHGnIQKPBuDAk2CdqQEZI24gAw/mIEByR8iX4XsTqGkCSoS4sgMfdhQAmmBvjUCJkfgXoY/kKAQsQHFyYXBMKns+lIJKGP7EggwAAuJbGv55CopTeOcx1CxFchRAz1NYT8EMNGygYYYebKCWLiQufer1RFfpWpMsthirpfi7exZ2g0Zy+BLjUFw1QZGjrh1dr0WTaqJLuT7onLJw74chDjcZ+9K318G6KrGyurBIDhSP14c0uCwXg6u+X/k1W6cdm8QNuipc9fV22D063GPy/NZ3eh15UfnbFp6rPekh9aDBYElcMAtxEYZy8nkWC3sFqzHbHDxvwiwTiUuFr0HM4PEAYBb1RbKazUOdTheZPygIwJMpaDKDOptIVpDRQIJqMgPGQt2/1z8mxsp5WdhnL0QVAUh8C08BhiUwJ4Rkmd8bYP7qEMlI7jMZBqyFms6hJnPoZxN4z6dQ01jOiQh2HMq5EsF/LufKJ2fiqrNyfbJHPLVIxgT/LIU3NQjOLbyZBaUW6WGI+b0hktshVGIR3QkxfS1EOpI4G8mBhg0I8H0hRByuJ9pks132rypbNZjZVIr7sqGL2qUKl7EqV9Wupu/7hr4BNIvlGrMDNBynKYtI8fd1UqpWHtcRiA5r4CY8N3U2sitZX+UqWfzf5OrTxz1l8XtRHdtN1SrB+jssFlz2gkJf2980ASwHRt6xyqwqXlz3nVvO+yb0q5cNLfeMjVkmesjRIZh3pz6eZyvp2Z/2nsDgKMs8QiQr+YC4CiwKbCFwURldL2KRua4aSO9KflwsryV1Ks2yLCPZBJ/SzPXD0+CRTPQRi8sGeRo8j8BRDD47l2wuWVpXStJM1UJg3wOFYb+2lU8vTWCfvC9tixOR1Q192KMheBhgdn+IdKigUgYx4J0nIMugKJXYHszggb9IpQsAZuwjOQxgBx54GICsuJ3Y6bTmctHi/KI7PpgAq0kyjrw2wPT1AdgjJGMN6yuYgQIrgvUA6xNUyjC+3OsLBInD9UHXlaom2e0m+zs0o44c6oI6G7yN9tS5sFwV+jxfVZLPIolQFUuivK34vesAu+p4VfWV//fBvqxQOvTHVfehHNfdVtepAZqub1Fd0eQiUuUuWayryd52vL9NK7Yr5fqkhAXWIzI6vdvrgkFv/hxtRCisga27t/TNTOWwP+gyD2ULzmMr9jl01scbn++V8UL3vrT/TxtbUVoYK7EwiMD5ZDZ3negsXeu4KrqJZK7q5dClTX2Qx4AYiBKFB8GCyECUpVElgg09mKMBWJO4ioyHgJ8pLNguiaA0FeVFkgKzuRBF2QtLHR32b18JNopgP/X2Mq0qQQJ6ag1vajB8P4Y3SaHnBrAW+jxCemcMHgbg8QDqVNLA0nQOGIb3fIbg2UyUGkoCbOLdh9K5yoNzRVngV4vhkxRMQHLkwQSE+ECBFRAfEJKRktgazPAmBjpm+FNxezGhgsrj0DgFxsuNPj7b5VWs6z5Yvmqs4wK0jTr3ZbJVRGdip0QklEmEuhgVxfLl4/UZqFYpLLY1yHVxMBy2hZtkn9cdD7cRyOXPXcbRRZJjA4K5lxK4yQW0eKwLP3Rwz6uL8bCFdwSnSX+bVs4ocpUEwjrZqRz2A+uMJ/LvdanWi/+Bfou/He3x/gfxLGYasQyAAU8tDYYxC2VGu3StQUJeJBw2NUab+CP2WOGlUNKM2nEowS+nc9BsDgwHsIEHSiwoV61EMXg0gL1zKMEvmZcERhhIitNZLO46WoO9LHBq4Fev4hXa0ekUjYH55Nsg34M+PACNJaVrGKewgcS/IMNgrZAeyvmwL23g0UDUI1ECSlLYwwFongK+xKjQn3oIO5mVKswGzVmnIcvwJimSQw3jEXTC8OYMlTL8ify3HkFpgjc38N+dAoowvzcAE8CawEmy7IT7OKlxaMdVDVKvOl7OTUKTAq9q+66u+3W5n8XAmWWCAmgnGMokSJ9BapXCYp1BdlO9zhY7OAhIAWyqbdNl2MQ6VCkjeo4fO6PtuFov5wyNlfLFidSK/aTVDCp1C5q7vNabKNgcHDZF3Xu56rlcJzNZS9/ZfwJDqyzWhV4GmcwvhGUJSNmV2aljk/PvZQO/DSKjyWCv6/6yCNxkJVbF6UzcLLQGhgNxvdAE/exc0n4GvigVQvFFMncOgLuHYJVlAGGG9/hU3Ec8LdsDX8gPy1CBvxK9uPL8OrXbguMY5tkL4OmzlYGsViTpToMA+s3XJPsIABt4sKEHFQdQswRmHEgKVSJQnEK9+xj2xUl1mlq2AItih5ihIwP/3CIdKXgTA29qYIYaZFlcRRKGii2SsQePCHou8TImDwKEJww+n7gXhUN/lPvJvq7q7yPqbEzVYLyNzOhlqzq8C9YdnO4y1VyskMUYAAAgAElEQVTle6ZAXJRJjLw9tU0lsFXV+62DdVcInd11uAxcF1KyDraFvOhxfp1SgPZd9Os9xuVV+9tVgdFQjuO4m+0u/V6V7jX/Tlov4ss1HrLTNVVZitM1XDz2wU66sc31Q1X/qhsnbJpBrA3lehuep70nMCgMl4ahaHQsg+M4M0YNqT4rZXEK5HvL4xjTzPZsMuGoYnHr0LcenZE6RKJeUARAjqGfngHzCGCWOCIA+M4BQCRZSlJx18gzetAskmCfSQpSSoJtWgv2NOjWEfDkKSrzwa4ziK9g59gAMEbu58c/AVIEdfsW1L07SG+PYAYebCDSP0ot9OMXsI+ewMQFH8oK/2y2DEoSYB6BCVCJBSAxN/Q8BaUW0SshvKlF8GQGdTaFPT7A2VtjDB8DJlBIRoRbn4g7vaAc9hhXpYJokube5Jf9Nq53V5u87evYReWxLi57kFlWV/Sony0vSIwVMqN43Do3lLLaoyg33RaJc5P7z03HZdrjXZKG1xEdrn3rBHrT+1e3qFceL/ft42VFdV2ZzsdTi8W3OjQuohba0oWUUIMwizWwgxgVTS6D24CzxzcHdbGzMqhsbr7tWCr6zm2AGebZc9nQ0Ff3nsDgfOXfGHFvWPjT2eXF69hpSGvQcAgKfEDpxXHkRwVEEexsvkpobDsw3EqDNhyEWwaiGMgyepBlcOjDjkOokymQJKDhEIgmgCLod98HGwu+fxcYiBpDzRKJfZEHzByG8jm1QnIwSwrbqvbuCmzBBjBPnwHPXkBl6oz8nNkYpFm5BRqkTGzk5aPPI1BioSIf0IT0wId3FkPPJCXv7I0xRp8y4pYSW8zv+vBmFkdvGwx+8yFMV1clh/3FVbtyVCm/HNbDpva5U+CqDm6J+3QPK1dfC3ErugTmLKkk8sH5QuVWFcizKkNJG7HhJpUOu+g/TcTZTQYpAFVjoAobtuE1v6Ak2ISQL6st2sp2Pd620OXZ2eLzZWez9kLroEnq7+AA9Oo7NopEDNBFVVSBPC1rWT1vnj5bLdcQ/HPvCQyYwkAnTRcpVTlJmyOiluVfng91MAYCX2I/EIGtBWxh4DUcQI9H4m5xdg5zdrZdV5JtT3xz8kYrMJG4fwQezNCHmnoAKck2kqYgrcDZPup8ivTBbQCA9+hE0psGQmjwKATFqYR3LciKRNJWqv+SCA22DNhchVPnB11viNkY8DyCOpuC1AHIekgOfMyPNfRdHyphDB5HCB9GoCSFig2SoYI3Z8yPNcbvJbDPnvcLQuNwM7HtNGf7NgHeJi7jvMouek2uJWVbVSdN7mKvd2n7uk7sq9pQJ7WuSlValoK2uXc0+VtXkRVNv9dtc3j5sIkNrJM5v4zkWGUfu3htO084Gtz3Kvdfl7yo23dTl+6q9hefi8t89za5wOzyWa3qHy9bv3DYHbLF5nWeq84ZiBps1f5nIcmDdJICDQbZhZLYF7UXrIq8ODoAjYaLwJVsC1k4FIG0AuWkBhHo+Bb0raPVY24qlyu3cUPjmd9Yms4lg4bvAUTwziLYoQ8aDwG2IE/IDCSp/DdWCA/LEiPDZi44uVuNydKxqiw3rypKkHcora48Sbv6V4eWwTenKXgeSTBTLdlHyAKsJAPJ5M0hzDiEPRpi8sYIAGACwuhRgsFvvNPuquRwfbDOPcyY5sWfImGGN436fVPJC+Dy+0pVoLj8e5PypcqmVfqE1tjslYH2Bs9DnUvGurhAbtT4rrYFgltnBbv23bzFAbSzxTcD27CBVf2uKn1vXdmbgI4x1VrJh6bJdhO529XGVqFrHKOuqCVfipP5PXn37pJQuEzywtnjm4uuixtZWQqCi3Z30zoqsP8KDEAykGglKUBNJKqCJjl/wXiR1lAHY3GlyMmLNJWJexiIO0lx4s68IE1oOISaR8sAluuuyDUFgVvneNm+HEXA4cGCkOBQ0syqszn4cAB7aww1j8CcMV1MywdNEfSz2TLTSBZLguJUFBm+FhJDE5i53ccvb/NVockws+Qv5skEajyEdyb3U6WMZKwBEKwHxHcCsCIQM7wIGD6cw/vNd2BOzrafM9vheiAnLgJfCAvfE/ezNBU7Mo+WyqSmSVvd706BsRnqFBdl95L8tzrVQtNgu21gntdDtNkAcRe+yJvEKAL6D0DazmETYqO8eupwM7CJDSySb23P6gaxYPYedYRCEyFbhy6xI7oQEnWkSNtYuOu4uGkx7apiXe2TXboQDHGHKg/rxsc3BlWqrXL8q8b9Zb4FtqL26rhfrzoy7D+BkadPZQZPp+A4gZ3Nu62Gk5KYF2EgZY0BJ8nyc5qCgGxSIsoE6EzhkUowS3V8G/bho/Z21smTy/9r21oTzKhhX3GNmIM8D+p8CjM4As1TUBRDJymS+7dg3noA79kEeHEKjhO5FmkKPYnl2g4kFaukTlWgxICHPsCM9GAIKEBP09V21bW/jy/jZYMt7DwCHr8PxQwvtYAawnoE1gomUPCmBvM7Pry5xehTL4B3Hi5joji8dKAsK466e0diw2gldiI1oHkEzCOQ50kw4SgS45vvq2gRAHE5cNZY+PwBWMTZcdgemmxQ1fZNY5J0eAdd+URpXXu8bsrUXeGqr6PDfqMuHku5zE1UYFTFAyoTum37r4MGN5MLbat0n6hoY9XYt464KNdV3tblvPbFlaQP+pLFeayCjrL9Tk3wfDmes8s3Hr3nQHkShR77ceZp0Qf7T2CQAvIYHkkKns3a2b5cfeF7MsFgFncRzwPGQ8m44RsJDEkkmTYmM3ErUUqUGYAoMXx/6TPYhWGtGhzXsdZdme4qA5u1w5yeQwOg8RhqloA1yWTLMryn51Iuj/uhlbiTeJ7EuUhEbUFRItcgMWClQFEiEzVmAAQ1iZbxkNsY9E1W/naNjMTgd9+DGo0QvDiEd/cI7GukhwHIMg4+fQ719mPw2dnFCLtdiCiH64G255MUKAyh7t0Fe5JqGFnMHTIWPBoAgxCUpKDZHPZcAXEsZGt+CJ9AJLni4XsZEStBZfOMO44c2xBd5cxt26vQ+ox0cKfbl8Fd1cSmdZ8NItZ36F+tq4O1gZmd/XVoQBNJsW03ratG2U2uSX2W/7ZNUrVNBVFWVnRRcJTHvFVj4fLvdefa9xw2RdfxYRVhs3IcBX18a5mJoVyN71VnRSkfazEeN+Biit0tjM8bVfAO1xul50OF4dITYaf19stStv8EhudJ8E5jYKfT5gH/CnmQ+eF4nhARQQAeiBKDh6FMQrS8zMiyKDOMhU1T0GwmqUMDH7ASQ6K23k0UB1m+Z2gtE5pSNNbK8wJKLwUrJAYpUVf4nqwUewp24EFNYyA1sPfvQD09BQJfCI5YSApKjaROjWLZ1/cknSpZ6AmBrAWdTUtsbg8i57KIjK4SwjzDyfkEOJ+AHj4CSMFbKH0sTHGFvK0eh+uJNvLC95bkRRiAdVbeAgyAYlFysVbAwQiKWdy40lTcsrSW/pURhmALaAKgQF5Wh+c5hc820KSo6H2sYgaDqhXDPVBUFLEOobruKmAf8qL4P8fKwLqDK4mzvw7bQhWpsW99eR1UKS/aVBhNxGSToqJtTNdki9psdNfFvSYCpE7FvK+oI3eYQZ6GeX5Sv2tdSte2821Uga+huHP2+KXApZAXRXR8DvefwEhicJKK20iT8qKi45JWoMCXSUWSAHEMUgpsrUxCxiMJ6Ogp+Tydi/KCrXweDeQ4h4dA8QbWMcSV7cpIEq2z9gRCjAAyufF9ceXI3FfssxfZeSfdc+yyhTk5hZrNoO69Ag598CCUjFpEsAeBTLxGAyE3CtlbOPTBo4GsJMeJnItl2IMAZBjsKdgn77e34UKbaozzrtBnIF8w1BJBl1dTbpc7jzPSNw91rgYZqagOD2DuHkocGAuQyRRP4wB6EoNSI+RFvvI1CCVtsSKwsSCtFgqvRfakLKAup6n0+eEAajhYtS0Om2FTW7N2DIcNiGxgs8nUuqqwbcmZt9Ue4PpPKB3Ww7bHCDlhkf+v6l835Vkr97fsOqqDA9hJtvjUdG3LcWXa3O+aXEaKbbmMcVNVm1ZUKVdAUm1qjwFwEm+nP/Rpy03pDw67wRb7UmUmpDWOv/cEhjk5lQ9tnbBkdBe+57mCIook2GUW4wJKA1EM8jR4NACPh+I+EidZXIls8mEsaDRYveAtL9vcd56GA5Dvy+TF01kWkMygeJlfDC3JC2gN9codcefIZeaTKeyLk4s5t3PWvcCq2yiCfedd8dsPQ6g7t8FhANYKKkpk0uVpqcsu92dfI74/RvD+FDSLC77+KdRnHsHEW/Cb2zWJUX4+muprirbv8PKgzqZoDX79HigyEsyWLJAKmacnMRDJH/kekBrA98BhAEy0uGelKcj3wcxZP0tXVgDJ88C3DsV9yxjp/9cR+7jCdZXtqV01bHgx5791sT3FCdkuJOCd97milWtHJN9s7MKe3OTAnTlq4k0QUb/zbbv2Xdw+ykTGNl326oiVurYA2YJC9yZsBZvYqV28vzYhlJvg7PHNR5NyqwcW8VLyw1YlhVjj+HtPYHTqJHWdPicrjFlk2VgEBbWpsJxe5jYRBuJakhpJ1xoGQjhk5SkMwdNpSzsU1HgEdXQoKou8XdYKIaBU5p5Bso1IJjGn58BwAB4EsKMA+ulZJl33gTCAPjqEefudiyRG3SWLY5g4Bs7OkAfvQSCqDDJj8MEIduxDzUQGr6IE3kQDhgHfQ3p7CO/5FPyZd2HygKlV17yPAbsMBUaOWhljTU7sJr8rZ6SvB8r3v2pVqmOsBPI82IEPfR6BIisqpMCTpNOGJXORsdKHPQ0OfIkvMxosj5caUWFEMTjNAgR7SoIDHx2KbQIkHs91xT6QF/tIopRRJh2KREQdymRFsew2JmHbVqn0mRze1Imkg6Ack6DOL3/XeBmesaqFm+y/OTtr37fqvdm13rJLSY0SZGvocrxSuzq7Z26bFF7nGd+leq+mTSoMYePugTglq0SNq7vD/qLYV7uULS+QNxUvkRNVuPB7p2wm7fXvP4HRBVVS2Fw2mG9TBE5SWTXVEqDPnp6B/GxgGMUgmykjUmSkQ0YwGEkH0wQKAqjDA0nX6mkhIPI2WZKYG6EvJIZWMnGJE0nbmp+GlweYYlCSygqulgCC+rUHSN99r7/hYAtOrTxA0ynw/GShTrGApIcchPCeZYSLUvDefQg7mYnxb6qvi6HeigyuNNBvTJnaIIsuTyTaJKWOvNhv1A2OmySuVdvL5ZUS1zJfg+YJkPfL/LHxhIgkQ7AHGWlhGDgYgWaRKKgAITbmkfR3X9zG2GZBdplBzOK+NZltdh0uG00vlsuenF41edE1/We5fHlbEVU+6vn2uvq6DFC2da2q2nuBpGl4N6zzfDhbvJ8okxXF7V32KWPbhOTLRJa1qIIvTDy7qBm61NWH9MjLt7mplKtrmySVXUk6jU0rArqu+7yss9+WxsZqEK4dELwPeQHABe7cd5RJxbrfc1Tdx57u/2vHcGs7dof+cTMIjCr5GiDqCUBIAM8TF5LJFBQEsFEMIpJV0ty1JJNzcxRLQEytlsE+Vf3FVGEIdfuW+MEDMjmJE0Br2IMBaBotyAHkfvNKiSoizxDCDJonUjZJhUjReqnUGIbQ9+7CPHm62Qs5C2KZB31YEBu7wGXLk7sY1b6B6Bz2C+VBTt0grC+Rsfg9U1YQwL6okmiegLTJlFuZmgrIyE2W2DxZelUehmCijAg1oPFIyioSdVdqYDWBUpZ+bu1K5pK9R6vMt0JtUPztpqELedFGWHQ53qauI63y8I7HbiJbbuL9dWjHOq4Hl0VivGzPZM0CTq9JxkaxfFqIg7r3dvn3xXeVjVnNxUwITeOALuRFne1ax85eIJ1bCOWa81x8BrqlPWUrilCipUK8V7aoDdV0DlePqj7Xtf+Wx8tV6uWVflZB+u1qTNIBNyshdpGBBSSGRJKAkwQ0HoFGQ9AgXBrzwAcfjjOCQkngS09L/AtjwBnBAKUuTjJyHzutJcinlgnL4sanBohiqPO57G8MKElle5yAFYEHAdj3VtpOeT1GFCDwPckSkqSg4QDeh94oPER7MPGpG5x0eThzlUzxe3F7+feq/fvWWzxm3bH34bo6rA5OyqsrXfftsr10v0lrqCiFGXgwhyHsYRbMtxD8lowFzSPJPOIL0Zj3ZcrIVMr7ue8tspKAGerpqewDSPrm+TVzI+kkQ+yhmrrJqFJ5NaraKtQaTVk5Luy/5qpqMdhhsR1VtriuPVX2uG87Ktvm7PHeoes7/rKO06mumzXcXUFNX2tTDtceq7gguElbumxvQsHWXMiEUDzPIOhXXxNRvM13VV0bVlxt1Op9WgSYN4vfq48t283JKWwFeaHCsH+7CvXX/+7s8V6hrD7K0bJoQp5f+FJSMdfWtWH/2LINvr4KjCqGs8wcay3xK4Jg8Z+NkUwjWkvmkcCXldNQVlMZgUxAssnGImtHkWgoNiMIFoQHPE+IDl9L+SwQJwFyvEx5wb4nCg1jxVXE90SJYSTIJrGfKUKskCh3DmXiczoFDwJ4rz9A+rmHWGjarxp9ff6qYk8Ai5SypHWWocUDx4lM8NiuBn5ZlyV+WSdS1xW7GNy2rY68elcyj1gJ3IlUSbYerZeUr6dhDkNQakFxmgXi1UJMpFayHfkeFgF7mWH9AZSV549SC3CWvjlNq9uxj+hyP4qKg6b4MjcJbedX9VtdHIyqgUdV/IyufqRdUEckV7WzjgDexf11g+X9w9ZckUqT7qrVv23iJtufHKWJSJXyotIdoyqmRW0dDbanSgHSVdFRVa7LvswX04pepmvhpu4jmZv3CrqscNfEcyPPr1bcrLh79XyPLOp09nhv0NovmsdeleqeOiXTOvFxKvvzdm3w9SQwihenYVWWiMBswLOZTIyDQAJ0aplcMCCxL/IsIMYKsQAIgRD4kmI15mqZNynQaChEiRH1BQ8CUFrILGAZHGRkSL4Cez4F5pGkUwSA+6/A3BrAezYRQkMr0DyWVdxZBHv3CHaYsWUWwNEY6vlgybruG7o+7FnKSmgNNRqBDsZIXzuG9RRsoKESC/YIFFv4n3sG++iJ+Oy1sXh9Vh2r2u5wdWgjF7ZdV4WBJsuAAlRiJYmIJrD2oOapPJexAVsLSi3U6QwgAgc+7EEAM/Cgpwn0Waa8sjZzKVHLOgGJf3M+BbepjPYNfV5kTfFm9hXbJlrq3Gl2eZx1JoF1ZEqTzHrXcLZ4v7DrSWGNPXZoQU/FQ6tbQteJUVf0lbP33beOeLmsZ2gH77bKNJMrBWrUcKQW9/eCYgUoXKsO7+Wbvuhwg9AYI2YT96h1bHKbW9cKcd2hPQ3jgOtJYDQxPEUQyermijxLyAhKUkl9aK1MJvLy80gyiGRlKZUYFKhishWJUoBIyI55BEp05o4iRAZrBR6FixVXGCuB+6J4kT6VZhHUIIvRMQhAL85kZVYqgXr4FMr3ZRV4PACYoO4c7xeBscLudiQvfA9qNEL60Q9idjeEnss1JgbSocb4UydgT4EDD8nrd6CPD6E/+xD25FTUGM7A3ixsS3K+Tp3FYLqnZ+BXj0RdkblyUZoREVksHIoTqOlcSMtMPQUAZFj2yQICMy2zl6jpfOFqIsdVgI2X9uY6o8o3sstv+4a14++0rJLVqRXaiIO2AKBd0INMXqjcqlZvquKZtN3bdfuxIy/2A5dNIhTt8ToT0JdxTNB0nTpcw7bJ8oXYE40Hu0LSaV33uX0DqfaYJevGSqoMnlpT/oL7o7PJV4oGhVTnGDdrBajdkiqu0n17DbfYAq4ngQG0S95yd4TBQFw7mLOYEsHSXz0LkClEhxEZmjGAtaLeAJYB+8oSNUCIEd+XSYzvy4sgS5NK07lkHQl8yWSQ15UH8RyEQpqEAczxWLb5Huh8KsedzWQSFIai1EgSYEagswlw55Yc+7q9rAuuIhQEoA88QPL6LcACwYsYyaEPHVvEtzzoSIgleKHcDwPYgQf7+R9E8NmnMO++dzkkxi4lrQ5LXOVgo3R/+XwixCMRWBNUKqlUVRwDEYTIGIWg0+ni+WDtQb9/Bg1k7mMmIyoMWHuABjCbA8NBRlwYsQ2Bv4yDc51RFeuh+Pk6qUy2iaK73IUYER3j+3QlCzZpI3DRRa+ItgFzE/pORJ293Q9c1wmgwxId7uFKZomK8l3Ii0WWE6Be2dp35fVCJW1ueuu5oLSqHXriwmp4eQzZ0J6V67gu2Iq7fGHOsnQrsct6Fvf9Gs0hXmbUxbqoQp+g3E2BXLv0OaD7u2LLqqgbMHJG/QUxRjKDZLEoYBU4UFiU1lqUEGkKNnZ1P+ZFFhCaRbBVfuo2WyXwRYXBngIPfKRHA/hPSdxHvKw+RaAoAVsLhIEE8DwayT6+hprGoNOJEByZSoSNAVkj7SEFgEGet2grKcoyiuwRauWMGXmhNWgQgt58DdO3bmHwWFalzdCHDQk20GAFeBMDczzOJo4G8XEIVgRvbhB/+BUEqUH63qPttdsNmq8G+zBIzgcYmXFlYxcqCs7UWxRlCouMiLSBBt8aQ8WpxMnIDXMW8JcsA1EsZOYsln6ttQTktRY8DGEHAdRkfpVnvh66+EgDbmAErA4CmtQYXcmMumu77oSgqR21qopSXW1t2Yc+7tCOfSTre5NfL5nN2eY9W6efLt6Z5sK2C59X9ttB/LI695GWZ2gj8qLC7lbGF+mIjYmUnIxOVucrK21ibidJVtw/98wmvCzo4mWQo2kBqW2/qrHDBdekGjtT6fbVMBbZ8ljg5i6LLdjg5X+OY9AsElIiy+wBImA4kHSqAMjzQL5IuilJZb/JtLLDszHiojKbLydAFvCfTmSiEidQZzPJNBB4sIdDwPdgAw/sa/Ghn6fQJzPQLAYPAlGCFMmSIkuqlRAyWXyOvUMHppt8D+qVO5i+dWuxwg0LxLcD6JmF9QlMgA0UbLgkhpKDbCKZWMAw0g/cXS/Cdl84470bdGWSex2zJrhgn/Ywg9ME3uNTAICeJYBlqCgBLMBKwYwDIS08UWmAxMVk0SetpF4mU7AzRkgL+J4E6o0SIS+IJMjndUHX+1YVL+FlVWE0udWUP7ftWxcF/AKJ0LNvVdVTbmPX+/eyTSJvEvL+fdWk0z604Tpg14FPu9Td5fdt3Ms+7486//uW469kZuiC3E7u8N3We5zblCli8by42Bd7j0uK4aIGy2w1ajhsLtwlO9ElPjvXf0RZd0HZLjN/eOLqQbmhNxaIYvDZRFZTD4fye+ADYQAMwkUGAZrMYM8nFQM8BtiC53NxB8l82tnXoLkQJTydiT/9+QTq0TNQnMrvzKBE0qnSLAKdTiR4qFJCTgCFyRCL4iJzl+BssmNHwWpsj31GbtwVgcIQZ198H9YjqMRmq9UWNhB1xfBRDH9qETyZwXs+g57EIMPwphbezEBPEkAT0oMA6uhgO+1zJMX1xjYHENkLwz58DBWlQlpkbl9kDOzIl8CylkGzJCMosqC9uZsaEchYcPYZ1oKijDxN0ixbSWZfklS23yRcdrDHy8A2zqOonmgiIsq/NZWvQx+5adtgtk+2kU2uU5fBkcP1w0bBax2J0Yg+BME6E/Qiyn2zVm27RdIC2EzR15GQoyCQ8XxbgNOKtlHJBbSScCjUr4bD9olidmwA1WqJuj7VRaXSZQLKpQVgh8tHVayStY5T4bpa2GZns8XnylAJ5fbskU2+/qPLonEqBuKzDHt6tiynlZATWeBOns3A8zn49Azq+Tn4YCikgWUgXfoE2tOzxpRTdjKT8iSBPlWcSoaR+VzUGYn88XwOOptKqlZNsp15ocoAAIpiCfDp+8vUilqDwkBUIuMhaB5LqkauyYxylWgwdnlqVP7AfYAAlTD88xR26CE9GoAVYD0FSi2CZ9KJ1HQOSgzMwIMNCelIA5qgz2Oo2MC+9bq8PNbt2G7AfPnYZGUtM7zyLPnLvzz1rtZbmzDb2Qz08CnIGImB4WvYQQAmiOrCMsgYUVdEsbii5bJNa4VozAcyUQzEiSi5zieg86nsl8XKwOwaupF0wa7Ii67uFpseq4iu/qSbHmOT8hf2b7BtdSlSq4iT4vZtXvtiO50dvhpsa1DapChyq7n7gS4T9Eab0TOOTflvXWzr+WloR+PErQWk9Yp9vOAGUuxjRLCz2WLSWDtmIQU1HGSN66C4q23cGjbZkRdXj+yZWSHDNukH5YWImvc5L8IVNLer87PRSpZt9oxdrxgYZR+34ueCBDyXSHEcC7ngS4YPWLlpPJ/LBIRIJhYAcDSWbAKpEVcOZvCzF7AtkwtOE/D5OWg8Bnl6mT4VAMeJ1KG1EChpCnp2Arp3W9qUpCI9VwqsZFV3kaXEGMA3EuRvNMhOkyXwn2FQEsNsMfDQVlDjD0WKQFqBRiOktwbwzg10ZBHf9pEOFECAf26hZylmDwYITlJZwR4EYF9j+iAAMRC8SJEeBvBeRFCphQ09+K/c3W4sDIfdYZ1BciHwK0iJSkpJ+mLKlVJZulI6n8JOpotgvGx5I6NvHj+BPhzDDnzwwAMTQc8SyU6SGImP4bMQj1kcHCSpZCRS4mJCGanBcZy5gWUpl+NE+rnWe8Vob4yq4E/bJjIag0pdMklQday+kd7bAmnln9vKr9PW8udiHcXfOqU7cxPVa4lN7E85vgvgnoPrjK2pJjq6luwS6wT97Au2KyvYF+LSlWNJlOqrjXnBdntZBqtiEnXJ4OgIjCtHr5godUqltgDrpWN0iq1Y9QxVjnta+lfHODV1uF4EBrDsVCsRjas/c5KCo3gR34LTFKSUZCYJLHgeLW4gTeeSQjUU8gLvP4Opch0p1pFddDuZQflBFhzUiFrC8wBzBoQhiAgcxWAtDDBlK7r56i0A+ay1ECi+B3v3NqCA+O4IwaNzIJXVXnuQ+St96rPXZ6BAWQDD4yMAQHASw4w8hE8jhABYEczAQ3QnhMkpxkIAACAASURBVPWA5FCD2AdZhg09DJ7KJFDFkpb29PMOMXycAAR4R2PgvTXa5Izz/qEiTeSCuPA9qKND2FePYQfZs+FrkLHQZ0Iy8t3bwKvH0OeirLInZ0tDvGZfMZ98G1q/BXgadpiRh3EKOwgABXH9MhakshgXSQo7CqAmkTxjsznYWCEzs5TLbCxooAEFiYcRBpteueuFvhPwrhGxd1H3use+8HLvSLqsHKOF1Kg9XkfbdmFgW+p/Te1wuD7oE4DtQpm2SaB7Nq49LotQyLGDuopZNRYZN4quEFX17qAdFyac5TaUset4E5WkeV1g1dJCsMNu0HR9N3gmhXioYB76PGNsuyeG6B1nq8HOND2PDbheBEZVwKKmk2QLPjuTCYJWoEEobhe+Bz47F391aNBwKEoNpURB8exFPXlRrDf7z2kiqg5FIN8Xn/nBCKQVeDID21SOZVlWjQGQkXaTsZISVYVIbw/hPZ+KMmMegZIU4fl8oQiBUlCTGex7j7rn5b4stDxs5HvgYSDX31roaQqKU6izGXgQQCsFb+Tj/MNjqMQiHWhQ6suKd2KyLC4GJx89hDdnsAJYE+w47J+NxRnn3aLYR9eJpMx2Ia0k3wONhuDX7yE5HEh/UwQdiWsHrJU+q5X0mwSihrh9BO37MM+eX4jI3QtsYX7zE9Cv3gO99opkDdIBbOiJaioxS5UFEYgZ+snJIhgvWwasKKkkuxEBd45gB5kvsu8tXdauM6pWYquyb1T5Y3Zd2e8ycW97zjaVYVasWFxww9gEtcHXOqpZOqbrW5Yptb/tfmxzwO3s8NVi1/2lCtskIx0WoCCQ99y6cSK2jbp4GeUFyC2RJ8WJW20K0+L8oVTnhdSnZbxMz6uzy1eDDfvBxuRFV9QqRuli/27CFvr+9SIwchSNUMsFsHECPH8BdfsW4GkhCwDQwRg8mQp5oYW44CjKVm1N+00vGUY7mUJrJeSEVmBm2IMRFBH4xalMxrSS+olk0hL48tJJxGVCe0rShs6tTHa0XmQmoSSFffocdjJtJ1auQpJe4z4CQIiiMER6lPn0zSGr1/kEFABZCxUb+OcGs7segomFjhX0DFBzCXBqBx6UAYLTFCoyYD8L0koKQMdJ4DrG2THS/bDutSq4i5DnSWCtN1+DHQWwgYYNFChlqMQsAuKqWSJBelOzIPmgCGAFPhxDD0KYzz1cf3CXwTx+AnU+AX7Hh+UU1dL28CDI/ntQL84WfRcAYI2QdlqBDg4AT8McDmADD3oagzWWgXuvC6psTJ1Mcd0AbH1fvLuye3WKiLLPf5VEdxdt2kaQtqp7UpxUNl37dSaflc+Ls6eXhk1W+7Y9AK7rS+uqjV52ZPd2kxgOO0edWrrqe9Xunr94DjZOM1oXA6OBvMjjEPRaJKuqr8KtkHxvO/euqa/0WoF3dnnnaFLDVb2by66k2QJfp76wI/tJWle7aDcRk3Xf68ZJHWzD9SQwymhRYdjZHDAGNBxmagwtfvSeB57NgDQFzyMhO9bt6CwuKeR5i+Ca6mwCHoTAvTugJAVrBXt8ADWNkd4Zi7rAyuox+zKhZ02wo4FI04kkC8qTpzAFd5fe1+CqkHU0IgKNR0gOPKjEQk8B9fwcZFlk99m58tCHiouD6myiGMhq9/yVAbyphYoMbKCh8swPux7kOKO+PnpeO8oy1ajDAyRvPQAZCxtokGXoSQJKLIjz/jUHzSOACPZgBA411DxTWyglKojAh/ptH4T95Nsbkxh2OgX9+m9B378H9u/I6fkarLX0Y5bnmc4msLcPQe89BjxPYt94HuydQ4Bo2cb8nK+bAqNXMLeSOqEcU6GKFChv32abek++KxQXK19JXuR1gTAvExdUTy1xN4poc10plmtCpUrFkRfXFrtSS1Qpf/L6inU7XC66jCNLz4MKw2ZFcHbMzpOu8u5psnQLWQd1pG6X1eI8E0jfuru4Y+QT0W3HNALq7bkjk/cThdiNjWrInMi76gQObYvGfcaIG8xbry+B0cTqlsEWNopAaQqaecv0qsZIYMwtBPwDM2ycQJMCkgQYBBIUNE7AwxB2FIr8nAD2lKRSjdOFkWMva5OV+BhQgHp6CvPocTfjuW/kBbDsiFrDHGeuIQca4UMJrGrGIdSLidwP34M6mSIAoFKGCSW4Z3IUQM8NyDJMSEiHBP9cgT1C6mt4JxF6dWWnprhc9JhYktagQQh17y7swQB2oEGpEqJLK3GvsiyKiySVeDGBL6lI5xHswSFMpmZQ0wQYBkAqfVq/eg/mvYfrraIUwGmC9HMP4aUpzBv3hAhNstUbpYDnJ2Bjhby0LOScImA4gDqbwR4OwURQn/wc7D/1Aen76Us4UK8jLqrQqAiocCsEGgntTsetakPl4bh6kle1utCHZO7atroBaT4Yqt2v5TrUBfHceKDtbO+Voo9LX45dkxjlz03ldoXrqvao9Slf83z6uHpmWJAXTSvLzBupJ3qnN61qR9n1vPi5yQ193WZ3sHXFAKBbRe0Kfs1Kt7PLV4uqeFlNCwpbtlX61XuwT591VnWwQTfb3celpOv7oIDrR2D0uSDlXY3ZTILWmhLGAkkMBGOZXHl6IS+nKAHNGPYgBMUpdJK1I1t9pZRgbg2hYkDFKeh0Itk11n1Q90GRwRZsFUgpJLcHYE3wT42QN1ECpdSCvKCpBGJUJ1ME5xHs0RDJYQCdKTJsoBEfCKkR3fHhn6awAw318CnSfAW064Df4XLQ4/kjRRKj5kMfQHx3CFjA+gpelAAMeOfRoq+wH4haZxJJMNw4kedpGkvGEF+DhwDFqSgjiMCHI+BxlgFkU7BF+ugx1OkZzJd8BIo9qNMZaBavpk71PAkgHAqZCWMAC8BT4NkM9I8/BXX/3sJG3Fi0reznE6QmxUAdmlbXdunfn7VZFBiZ61NZVlkmV/pOGlvL1AzI+6DrNe+sTNyCi4vDbrAySF6DxNhKGyqUP8XPxRXILoqgbeE6khdAvW1pWpHfEjopKi4olfvbwnWVG90O3tCOQh9RwyFgbbvSZJ16do3y+2jlt8I2Z5svFyUyuVXJtEOYJ0972YfFuKdJRQus947pGo8L15HAAKovSlvn3GbdDZ3czuZQngciAo+HC4k7zSLwaCBuJKMAlBiok4nEucj86dVcAlbS+QzmvYfrM+gNwYq2iq4vI2OgpylUoECJRXI8hB4FUOdz0CyS1JOAXJvDEdQ8hhl48E/mMpEdeCBjEJ5mZIZPsIGCSizs2XnWFkde7B16PH8UBKA3X0N0fwwmUeGo2ErKUmNFtRT4YC2BM9mTeDI0iyUN8XwGevQM3ngEc/dwEVsFAOh8KilLNwl0VgE7m0H90j+C+vCbMK8cQj89l4CjWoHDADSZAVEMHoTggQ9KlKRWnUYwcQJwBH77ndrV/ZcK69yTy+rPVfcnlxYXpJwXVHybSJc7t23DY7S5i2wam6BsA5wNvjp0jBvWC+tMjKtcmKqIi8vGdVVh1GFF/VV/Xq0EweK5Wb0/K/t06ddr9v2tkRdt9rhctlgkjpe2vmp8XXbf2wOsZGMBqucE5fmCw+WhdL2vNDFDT7vXlP6XgmAZ12Xd90NHXM+RcxWru8sO2GOli+MYPJ0BzFBnE1Aep8HTALN8JwIswIEvGRN8LyM5YsAyzMOObiNd2pwHkyt+38Zxc7T5D7IFmzxjBKBPI/jPZ0iOgkVwQ/Y9+RuFgCZZVTcyebVDDypOoRKD4eMIyZgQnBqQYYw+/ggcdYgNUjz/m4yrVtyU0ZW80Bo0HCB+9QB6lkLPDcxAIx1q2EAUDWQYduiDtRYXjGksCovpXPqVUqDxSPrd6SzLDmLASsgEABIYVNHFwfMGYGNgPvFpqF/7BOytEZIHt2HuHMAGHszdQ/DBSIJ0EoGVkuCjb7+7MgjcWB57mdiXftRJYbGFtlY9K22T/pVV5dLkfVPyomzH17FtxTZWZYbZJvbNJr3M2MW96DM4bcrY0/UZ3Ha5YvmbRF4Ane1j61izJG+noKAY3HRsVUco7Oo9kxN4ZeKhqV25+0uZCKjaf1/ej0B1MoK6+Bd71O6XAnuoelGj0VbGAheC0u5wfHE9CQxg9abXqQ228cLu08Ezw8txLGlV4wSwVnz4A8l+ok5nUGdzQBPSVw5lcqMUeOCLO8V7j7fj71f8n3/uYmw7GvRO1yU3nsZAnUwBBfDQB3sKwftTiT0S+LJaTgTWGvrpGWgWQ59HUGcz6EksLgGeApgRnFlYj+CfJUL0tAWzuaRgMhuhzi+xL/bEEC5Q156SbJg8D7hzGyZUULGQU5yHT5mJawisBSsC+wp2JG4iNvQlq4+x4CyIJqwVxYWvJZaMlsEKRVksih3BTqfgX/nH8D7+NvTJTJ51rWBvjWCHviiunp/C/uYn9y8Fcl9c9XN21YOuphdyVZyIOsVgeaBe3FZFQG+NhC5JNZtce4rYdIX8qp+blx1XReb3CdBZJtfKqCNAqsr1wXUmL5om1G37dcHi2BnpnqRQYdjvGFV1VikY8jJdfeZbflej0cXtffpAkx3ec6jxckKaZ1JZ4Bqdx41E8bnaA5KftAZ++wdBvtfJvlb2qypsI25WA66nC0kVurhM9P19nQ5OJMxnkgK+LyoDI5MnSo1kRhiGUKdTsFo+KDRPQNM5zHTav846lAfH+TWqe3FUlc3OqbZssXwRhU7AlsHvPgTuH8GMPChNsL6GZxgUZXEDrIXKg5p6GjRPZGV9FkMxg7VGcm8IlTLAgP5//wlskqIRfe/fVRn0PkTSdUHVs5ajZNDoYAx7awT/PAUrAhmL4ETuv5qngLFQUSJpU+cpzGGI5HgI7zwWFyRPy6oQkbhk+Z6oLwJPyA+twJwpObKsIAv/vW2CLcyLF8CLFyDPhxqEkjo5SWGjaHd+vC8LeisNNhwYdJ0o1WX02DQuT5fzXXcFp0xiLI7XFJBrg2CO192evWxou8+93Igq3EO6ZrNpiMTvkGHXhO4FFZmBna/5Lqtd1FhnwablOWALWzWe3qNV742VPw1ufnYyXZJOxtxMlZHDeig9C2wZ9Ml3OrtYV/ardZpR5b7Wg9S5OQRGHYqT8Dbyovh/k/qIYKMIypdYGNAalMjknMfDbELF0E9eAIG/mLTZ95/u1t+veC2qXEE22VZGKbCLnc3h//qnEX/pW9Cnc9A4RHo8hA3GYP3/s/dmPa4kaZreY2a+kIz9nDwnT2ZW1tZVpUF3CyNAgjSDAXSjC13pn+pWdwNB0gxUaA00M+oedE9PV3dlVeV+tlhJ+mJmujAywsPDdy5BRtgDBCKC9MXodP/c/LXve00QXGcEF3PM0Ri0xY4iZJKBNu5hNFTkY0lwoxn9P/+Ans27HwvP41IncNnFNGI/+ZT5p2NGP7jSKzMK3e9ILfxiFEYJzChEaOt+rHUZGZOR25w26JMDZJKhD+OFYGhcCckoQN4kzlRzFMOczYkYy4+cZ9jr7O7zPzWqxM2NpKjbYR3ObXgAQf2D2ANhYEOd5r6ictXDYNcpVKuWH9o+z+PSOpjT4TzoStldvgtNpSYrme9WnI87MAK6MuUsjIGGrQ+MiIvbWLVdxdeKvx+DdcXjrtup+w5W9hiqyZKreE+dHLsBFh+Td4uu9+o1US0aGMz19Ub2V4u12LxmELqckVXDfgsYXR6km4x71hHEarbhykgW3hZSukwMayB0qe5iWfqgNSKz2ItLTLrmWvg+pkXlrIyy2FEcUa/bR92JtuiM6ItLov/3d/CTNy4TY5ajZha0RR9HmPGizCZNsKOA+edHzrRRW/IDxdHf/Ij+5jv0MvPCq8m7S1sAWnx3QkmmPzkE4WaacV4RLkNHzXNMICGUWCnQI4UVkRMwcje1av7J0cJfxbjz5GSMzA1GSeehMglRNylinsJk7Mq04hiubyBJNipiPDgOdTyVDvQ6KWePte27shOwgriySt1m3UP+Y4/8tZWK1E1jVv4sPu7uP5uMOVXny9CMjartrZun8EDXdL/tUSpSORo6lHIJc3Gb6zj/Vs5e6JFlXEdbNnPlfhezVzUYIS6XW2cplD4/X2x3hzJQPI4HouMa411p2+XzTsaxe/bc9n293D8bkIm63wIG1CvPxb/rAszAEpHW15ZZGNMpIs+RgBiNsFnmMjLCwE2pqCQkKebqGjObdzuB+ga1PsGq7sZSDvRdSlMebHshYlzfIP7xD4Rvj+GTU5LPj93bSjhj00Bgj2MQ7jVhIbxMif/qK/RsVnCCbjHufAoPhc+ApSGYyC35JEDNNelJiIkEwY0guMkJrlP0xHmnmAiEsZhAILXLwhA3GSiFHkuEdueHM/AUyGkGWX6XqQGILEccHWKkhNmM5TSYGwngXa6/fe5MtImXbevWrde3lK9p/9sUL7b54LVJ1iVYlAVwz26wyXtk06hwF5q8Vla9nur6gk/p/CyLGV1j9NCH+OJ+qsTkOg+gVc+/dZZe9PnM5ePUW/Qw2MUzpAhClkb3tW3rQ2Hde7NB+Bi822wyA6PtOgtD59fYup31nJeVDDwv91/AaCqTqFtmHftsCspFtStNMRdXyMUJYrWGGc73IUkws3m/qR3X3SFuC8Z1N8OqZdoulIIJlH7/AXF+QfTHEHl6gj2ckL88QOSAFKirOfL9JebyCjtPMMsA30nk8eLFXiAk4ugQlbrsCZkbVzYSCg5+f838zcQJgZFC5AaZGqQ2mEBiYomYO0NXwM1KErrlTBxglURY6ww/T0aoi7nz0LAx9mDsZgiyFrIMu+7Mpwef8xl0HPp2SLuMXK1TlOhKn4et8khxXa1/cQR62+dCn++lPFLe5EPQ19/jqZ//+8Q2zsHyjCNVGRnFv6uupfK2PMNo6qv2fXBvitvFAcMu4nTHNPFBdD1nhlwLQ6+dimMiwuDhrA3Fcr7y52jzVyr6GhS3WyUo+Zi8G3QtLdoQnUtHNiVerMD+Cxh1bKI0pGtgLjclz9BXi4ekhhq17m0bkIUBzeLDOujaWV4KGbnB5pnLPgHEP3A7zaW1hrw4w0jvVDofnHeClvMh//ITjBKo3KJjxfRVgJWC7M+POPw2RccSYRQyyZGpJj2NOPjPbxE3M+zRAeZgRH4aY2JFcJE4M9xAghTIWYaeRMgkx8YKDJhJ5DxWDicwihFaIy6uNm+w+dRFjE7XvX3Yye2yfJUYvakR5HKtfl0t/nKZ4vtNU67e64Ru4wGy5V5VR9fU//LoZV25zlM/7/eVTT4wdikhqRM06ra7zk5w+eH9qZ6jVSna5azkPvSJJ11GlEvHXb04Q3/4CIAcjzGzWf82wu2MG7bhlu5KOKrbsU3ufcaq41sW+OrEjU0KNp7NsUqZ65ap9M7oQt/zssc5+nQFjFXYZAdsHTfhxxqNaDoOVTWOPQUNWN50VnyYXCUF0rN+as4DIQXJiSshUXMnUFgxuv0uRG4xE4W4zpzoEEjij27mETtPYJ6gphPkfELy2bGbNtWGIMSihESibhJsHKIPQoLzuduOWkzLKwTy6BAxm0NiGjs8a+Epn2NVI3N1N+dVb9bbOI51Zpflv6syMOri82OMJNeNklYdvyEjQXXbr3vf8/isUvZVu80KcaLpgatpG8upVK15sHytyWQf2kqLnwpVMXnVz1o8d/r28epEjAVL8QIYLF4AnR6ytj4jWLHMuomqrJQqEbz8/+0yTWXcT/Q832can6l2K/Os8poZ2sZ74tvwPoMXMJqoSrvacZWskU2X1VT9PyQ9fF1t2Na6+8q2HqgbvmuZWWSmUdMMPXazjMTvpk6ACCRWjckOQ8QkBAHJYYScnqG+09gkxSYpHE0Q1jpjWIETMoxFzVzWk5hlhDcJZhwiEo0QBjFLIVCYozFydohOkvsPqJvgOZ1jVYr6OvwQthmH686H8mhxU8lF3Qwfm354qttul/21CdXPZQT7qbKt76uc+r783ZrRUyEQLrM2q8SLHevoP3na/C3qVitmPay0/xYTzEHb3PA1sa6+aZe4ay1IBcZP277X7ENMa2pjU+lp7SBPv+twBbeyJ84m6/N2gV36TEtlusl/o2m9LsvuMo/1XWz7mNXsz0QSkWSoWYawIG7miOsp8sMV4bspSIENBFhQc032YkT668/h1QvEwRgbh5jFTCUmDhCZRk1TbKiwUYAwLljOP51gx26KVsIAK10WBqN48+LFU6dO7C3ekPYtpjbdaMvvVz2gVdX2r8omj1ufEcLicvsce58z6/zeupzjy+tlmWHRtK0uo85Nr3XhKZy3246jK+yvk+DQSWA1vcULGcftCw35bOUSx3XT1CduOlZevNgftn4N10xPveo2yvSJ1bflwv3asf8ZGGVFEtaTJlc1avjU6KJ2bTvNsipgt2WO9GnbLo4W7lp71klD3a01FivBKoGNQ8QsJf7DDDFLwBgIAkSaEVxlJC9j4htnSpWcRTBRwDHZcYDILSo1yLkTLlz5icFGgcvikM7QEyA9i4m/zdzrkRM7bBiAFCtXLj0LytdPn7hYTKPtut4uxd46U8Kq/4vLr9OQcBdixS7GUE93NvHdtZYaFa6FNlGvqt5/ndx2lnckrqxCn5KEde1vk8dtQ9s2SfLgNXl4+NDAcEhs23YWnedpUZXRuNH9rUEEXndMvu0b9hQm19uKLVKur35gGrTCDeo5iBdL2j5bl1G5ITRlTlSN5q6rHUP9MdbNUz6numINo//4FSaSWCUwRyOIQjfFcBxhjyZusUA6gWKaoa7mxB9TossMJAjtylCEsU6kWEyjqg9jdKwQ2mJDhYkCovOU4DrDhgqRaUSyMNYNXMmJZ0Os62HhMTt0VbOLlB/Cql5rEzp2KQ70EZU8+8su+JT0MiFvydjoS11W2FOhLt4uX181HvfJfF3le9vwd/NAvBiyv022cZfuDZ7NsQ7xYt0xcmgbmv7fAPuTgVEXkNuWHZJB0DBqPJhdTVF/zBt4XT188fVd6GBsUsB5qpQ7iTXXkTm/QGhLfhSDABkqwssbsBYrJfnrCelpSPQxBQkmDLFSIFKDDSTBLHelI0pCYFFZDsZgD2KyoxBhgXB57YFMc4QxLisj0yAMYjrf/PF4St93ZSzu6Ijed4Rr3SMTQzMguny2qpHlLvvblYyGXWiDZ/OU09C39aDU9bqr8b9Yf3ue2PnepY9cZ57XNyYv12kdAFuD2eq22JU4vGSX2uLZHFVlQX3P/W08VwqJjMLKbKZObdiAV9F+CBhrExF6BKh1dZqFRCiFCAP3YGUtaL26k/Y62OUAuctt87TTsczAas346ytmPzlCaIsJJfLTU5ASPQlIzkJMINAjhZ4EYCzCgrSW6E/vIdfYcYw5PSA/CF02RWqQmUZqixW45TNDdhwRXM4hyzHHY0hxIgY8/rW475RTxJsoisNtGVj39jHwYavNXLPr+tAtVb7pf49nl9jFUV5/zXSn6fsrvCfjGJMkbhaX/H5J2z1DzE4eFFvomz3WgN+uiRie58O2y/X7Yg0mzXotD3S7lgd+5t0XMNZ5gx2aItbWhorOsFAKeXIML8+w44j8dISc5Zg4IHx3Dd/9iLm+eVwhoylYbyvNdFcvVs/6aBED7d/+jvD4L90sIplBj0NsKMkOA9JDSTC7O0eEhfB8jnp/hT2/wGqDuAmQgJickJ+MUJcCkRtGf7rAKoXIcuzYTdeKMWDtIvtCuBlL5jWK8ro//1On6oZVO+uAfShk9IlHQ9rV9lqXGRL60FUkeS7nh2f3KJ97G/U32IHZQp7JtSaUAiGxeQZC3o6a2rz0AGIX04d3OS5DH+7LZsadYuIjzjSzSpagx7MK5dKsHROYyzMJCaXaDXWrMlPXdL3srwdGXzbpMFwyaRNRhPz1LzC//IL8k0NXc59bstMYE0rMQUz2l79AffkFMgofr3apyj9k3Z4THg+0ZmGov/pbd40cBm4mEmORqSG+MMjcZV2oaY5MC9eaUk6QAJd5AdhQYiYhZhSAEMjzK8T1FIxBJnqRsRFh4oXBp1Iwm69fSHzKNdZwP2atGr/qjlVVamXf41msDe1qNFhcdxW6ihd9jVB3rFPj2VOqzqNV4lXb9bKOGXl22FPh0SiU3IjICfVW6zuxoksc6tTPHSheFH8PZRPixTp8A3ws9qyTTQ8cr3K+C4nV2omjgAhC12/usu0Hfav1XDe7n4FRx+JgCCnuDuJj1hoLiRzFyNefoM+OMBLELEMlIHKDCRXZgWL8Y+IerFJN/ukJajJC/fAOc36x3nmtu9J1RgGvMns2iM0zwv/r/yP6y98w/fIQmTkBQ2jtBIzckB2FqMTAJMKGp6jZHKFyN1vJ1RQ1ccKE0AYThphJhAgk8uLGCRVKYOPIzXhiLBgQWmNmG/LAeIrXS90Dft+puZriSXH0oTwSsena0OLy2xrxG+rP5PHsEkNG1qtoEhwfO4Nj1xASOR5hplOXTZGmlcvUls7dK6/r2f/sOrhXLlPZFeoyA6H6/uT7wJ5Nsa3ykZVmQLu/7oPruWt57Ro/434JGItAKIIAMR5DFCKixQPJPMV8+IhN0+bR1HUHoYWxiXz5AvPJCVqWOu0GsBY1TYkuA9KTEJkqwusMEyuEjuDnnyG/YvsiRhcT1LbUbo+nC8UHrxrRzGqN/eu/5/DdG6Z/8Rl6JAkvM2SqERb0SIFwgiCAffMS+e4Ce3yAiQL0JLp7Twqy4xiZBshJhNAWkRnsyIU8keYIbeGHd9guvg19PudzpMpjYkld+m+bidxjmQ32QUgwenjbupTPlJd9rueYZ700CYiPfa1tMh4/sf5MqwBfOJYiDO6JHLcp4UVjz3Ufm2WZyoo8SFevO087nr9LX5D7O+n5IPmEziPPI9J0Hu1CPC5w55fz+GLy3ggYQink4QFiNIIwxI5cqpwZR2DATmJkGGAvrzAXl1jT4oQPKwcfoRTqk5fozz4hPQiRuXEzIsQKdZMh0zk2CjGjCBsr1DQHArJD1w+MfQAAIABJREFURXoacPj7azfFY6AQP/kUkaTYm+n2R/46GkF5KnhinaGN0uV8s4b82++J375D//d/Tn4QIGOFMBYbSMgNehxgQoEaBfBijMgtVglkdtcJU7MMmUlEbpA3CeZwhLpJQQisEM4b44e3mIur+2lw6/h8T5260bymUb62GuZ9vY6s6RcjqzojbZ+9KFzs63Hy7Bfr7jRv08Og7T7zhK4fdXKMPj/vvHw5Q8NqvboIuyUe3Ke7DMA1YJKk+3leZzy968aLnqfBY4oYtQNQHWJ6ud1rvk523wNj6SlxcuzECyFASVfzHihEpjGHbuTVBgpxcoycTBBSrF7f1tIueXqCeX0GShBcJVjhxAsrBUIbCANs7NooZxlyniMTjVgIWPNPJyRnMSZW5IcR8pMXrt3boq2e2gfldvwxWj+LVFj1279h/McLdCzJJwo9EuixwgYClRpM4M5doZ2/RfDjJTLNsYFE3iTu/5tkIVqAlRKrBGYUoN6eYy8uXQduHR3r53QetAkSVSnKdTfATvvbY9+HNpPEqvfLP1XreTybZp0xrU+MXTUeL6+bZxCT9cXl6hvpK8Jug8qMvJ6GyF2NSZfLFn+qlin+v8GHMo+nksc6z7r08zptZ/3t33kBQ45HyNMTCBbJIlKCNoipmw4RIVBXyb2gIo4Ou3WOqzqKXVjWHf7sjRvhvZojbubIRfq6zI3LCgmka28gsVKiD1ztvdAWLCAgO5SYQLgpJI/GiCDYjPCyysnjA7RnnXQ8n6zW6L//Jya//Z3Lslhco0YJgusMlRiCywSZ5ARvL921JqUTNQ9izGSEORyRn47JjiPMJESPQ4K3l5iP59g89+LFEPo+jNTFsypjp7qY/FjHeB0mb02d4+JyTSPGz+0c8zwe5etuH8+9fWzzEFYWewrxrZxZMKRv/Ji0jVK3GUFXicbPIIvHs0dUlsTt+GP8Bu8hO19CIj95AdpgswxGsTsQaQbjESLXmFGMSFxanJgl2HGMiCOEknfpcV2DfMdALaRAnp1itMUcxG6Gg3nu0tgXsyQIY9yDVBxgDqLb7cskI/5okVkIQJRboosUoa1La1cK6DHXbhtVM410ZZs3rmcyYuIp0CUtzhr0xSWj//M/wW9+zvSnx9hAkB1FCGPRkwg1y9CfHDlPmcyAlSCAULnXrHXmn0D49hrefcAmyWp+M881nb9upo668pHiOlXTqtaW+S2Wk+pxRwi7pEguKY7mlWd26jsyWKSPT4bHsyr7fI7tc9sfg3vZcg3ZXtsWk4f2V4vlQ+V43NVzqWt/2cdjz2PwoCzj8b0oHrClkpedFzBQChuFiEBhJyNIM0SuIcudeWeaIWYJhAHm9MjllOSb/UJFFKFfnWLGATaUBO9nYC1ynpMfxVgl4MA9YC3LSUyoyCcKmUgwFhNK0hPF0T/dAGACSXCTsJZwWDx5VjmJthmcu9SAe54OfQwarcEkCeJvf8fk92PEZ68xJxNMpDChJDuOEdZilMCOFCo1YHHmn7nBxIrwwxz5p+8xV9fYbGDmRfEhcl9GpdZNH7W/ygujK02ixzbp4t1RpK/Q0Nc/w+N5DLr4F22LqpkidqFdz4Whx3pd982mmNxWotfWz+yDj8eex2KTcW9of6vPtbYmdl/AmM3h9AgbBthQuRRxbVz5SBjAwtjHBgobKzc14jTB6oEd3tYOq0R8/ilW4sSLjzPkxTVIAVmICtXt6LCcuswQMwqRmSafRFg1cjMraEt0pd1nWWBDBVWjwkNOqLY6vi7sinCwC23w3Gdd50YxrbPlHLVaY6+v4XdThBSoKCKIY8Tp8a2pb/b60MWA3BBczhGXN252oiRBl2cnaruumkZp6t5/DpQzKIqeGFWCQ5UQcS91uaM/xmMIGeX9NXp/bFC88Hh2gVU6zqtev3XCxb6WuewaNdPXPpj9Y/D21xTvmkTt4mcoxuO288PHYs8+UpUBuvI2e2SdPjI7L2DYgzHi/MplYpweOT+JKEQY40ou0KAkdnw3hSI/vh9+o2xZTyiFPRyznM2A5bSpSYowFvXeIG8ixDyFNMMejGESYUKFzJz3hcwN8jwhO47Ij2JgMVr8YY7J8+Y2VaZo24c39fJ7nufJpkSoTW2zy7m6mJbNzmYwm8H5+W3HRf793WJ6sWzTdlrbUHf8diiIb5UuZSB1WRfldZvEgbIwUrX8rtE1zvp47Hkq9OlfDBmEqZr1oexlsCsDLXuCCEJsXipTrhEvEHLYLF1DZijoQycD6Y6ld/s8uOfxwP1yqfL/6+hv9MmQ3+K1sePuHyBuZtg0xSYpcjp3M30cxtjJCHkzcxkYxiLmGWiL+PadWy+O+83osewsF3+qFgsDrBBuloObDD0JXfaFEGDcNKqAK3HJMjAGdTlHZho114y/uSL48RKRGfRYkR0F6FgiUw3vz93NomqUckml6lxKay8axvnO8tNglbTNTbGpc2tIm5ej/+WfPvssdozrDL+e+/W0jEl1GRLFv6sEiuJ75ThbjHvlbZXj8jaMq4buo+kcGXr+PPfzzvO4VKXml0e415WR1xR/u/oZPDd6HIPKbAprEGGFgbw1CCmcN1vfEsA2thHThGhud0sb5Hhc/YY/5zy7RNfB67rztul8bjvXH6F0ZMnuZ2Dki2Arhcty0COwzkfCTkZumaMJWIv8eOmmWD06RAQK8+4DdjZv3sEiuAmlEFEI1rpU9SyvTXMWmWuTM+3U2FHsMjMC5RZY+nNkmZtsZJagck1y9oLsxYRoniGsJZhq1CzHSoE8v8Fc3zSPbDZ+DtH8//Kz9h0F8Urz6qzjGO7id7DpzI5N1vkNabu/FqpFhraMiopO8b1120pLyiUo23Ld7jodbFdW9SMqj7J4PNui6zlXt1zb7BB9YusjjfbtNHVePMu3i2UgFfFXhEGtN1RnM3whEVKsp9xkFTobRbfHYzOb1a/rzzvPLtFU3lz3XtErcQ/P550XMJACWAgDi5k9FsnhkGvsOMJEiuCb9yAlNs8RQmAPxkh9ipl9X7/tZdr5wQT58syVhUxGEEjU+0v0D2/BGpcVsQiKNk2RWmNDhZymWKXIXxwQvLtyU7tGbnYRtAYhENdTiELsJEalBhMI7CTGRMpNtyoEweXczYzQ5H/RVXxoMUMcxD6d3Jts69Btd6m/3Jfjuy3qRt7q/u+z3aEO4/47qhcj2gSGqplLln+3xbcm0WITvhhVIsqqwm+doFzeTxPF0Wd/Lnp2gSbBoosYXZdpser+nzul4ywnE/TV1d0LpQd8m6bN2+sUn1xp56PTlKW8/LuKKlG9LK7vehmjx1Okrcxuz+Pn7peQRG5KVBEEMB7dvT5PEGmGDSTqH77GnF9gjyaYz1+596fzh4aYxfTjxd/q5QvEm1fYcUz25hQzCrBSYscx6svPQal769/WAy78L+Q0IbiYOc8La90Ur7M5JKkTVIyBJMUqgQkl4XXmZioJJCK3pKehm271ZlYdHDdV/91QJrPXtN6kdjAVe8+DyMYpl3a0iRB1pSB9Osv+O6mmGI/KfhVQH1OaYlu5tKS47bra7E2yaqZFkS5T8nUVpncxdnk8fVhnuYmnmUIsvideVC33FPqDbe3vG4vbMjl8PPbsC0803u58xDJnhzAZY0+PyD49wUwil3lxMMaOY8Tf/wFzdYVdTKcqp4mbkUAbzGUpaJdG8mQUIo4OsHGEDRVqmiK0dbOZCIGNQ9TrV67+r4CYp07kUMKVrCzVrTBwfysFQQBaI6SEUUz6coyaa9RVgrpOsXIhaFxk2K+/v5990TTa2Jd9vjGtmnLd5/Uu+92nINB27Pb95lslatSlyTUJHvt+HPaRJo+fqgyP5etVYu6mhI0Ksbv/Njp0lv2Inucp4kXix6cpzpaXqxKT9406z6Uqyu/V+TetQxTxeDwbYeejlJgmmKMxZuymInVTJLryDH5872YiwNXp2fcfEfPEZT7MZtgkKWzoriMqpECEAfLNa2wYoI9jbKgQN3NsILFSkL86whw4s1Ch5D1DUHt17X4rSX4ydkJGFGLjCAKFHcfOl0MpsNbNpJJbJ44EEpnmCGNBQPTNR/cZunTKu3Z2y4p63ejnKh4b2+CxOjhPoWPV13hnH+mTEreKoOW5T43XxTJGCinuGyiXS0CasjSaYlIxrnXtYPalXNaxDZGhz0PDJn1hPB7Ps+U2Zov7/V3AecQFYZeNbKBlAyjcIyrbXfZyKmcULn/XGUvfbsf3Hzyex2L3PTDiyP3WFqE1NgrQp4fIJMNOF+LFoqxDX98gptPbVe/KPZxJkTw9QQQBdj6HF6eYSYyVEjXNyA8j5DRAXkyRQmCj0E3ZOo6cEJHnzqDIWMzFFfLTT8jHI2RmMKOQ/GxM+KMTNkSuMQcjRByBMeijmJvPQuJLFwzVPMeGEjXLMT+8vdfORcO7H58uN4y62r2N1I/7+myP58lSFTMWAsUyjt2bdq/L6F9ff4tNZ2Bsylejrpa6T5mgN/L0eDx96Nj3W5p1ijBws/uhS+91yarZkB9R3+0Wln8wZWzNcq3bq8wY9P1dj+ex2H0BI9cQSGSSuSlVJyPMQcxy2tIy1tgH6rE6PIAvP3OZEplGaCcwFAk/OjFEzFzWhri6wb44cTOKwL2Ab7VGXE+RYzdrCUoSfJwx++kJ8fs5ItOIWYo5HIEQCG05/MaVjWAtVoDIDMGf3pHPC1kiXc2CKszyiup5eXtFE9LSwarfR5muTuE+mO8PT+Xm+1Q+xz4wxGizy7baPDKaapPX5ZOxSZO2vqJ00/L+XPd4PEvaZv/o2ferNfQcGBvleFw/m0cXyveBdRtslvvTnUWNgUbiHo9nLey+gGEtYpZC4HwpxHSOXPpPUBrtW65SeE1GIeLFKXocYqVAhAqpD5EXN87nYhxjRgGgEKl1+0lSGMVkn0xQ1ylSKSz3VVz9zXfIgzH56RgTK2SSE31MyI8ihLGoaYC8nCGyHIxBXsdknxy6EhULwdsr9I/vHqZCd01ZLqb5LUtjlAS52I4xgMRai0DXixjL9dv2uQuBep8fVNva/hifbReP5ZDjsIuf4zkwtNO47CwWU3frHOCXr9Xte52iw7b8KNoMSrtmYvjz3uPxtM3+0Wugag0xsCSo1E9F2iF2l0XuppmuOrSrvD+h1N3zQp+2wMM+sY/JHs9W2ZGCtXrE1Q18vETczDCHE+wohjRD5AbbEiyEFIijIxACOU1RFzPnQzGOXKAxxgkhQmBDhRmHoI3LklASo6RbvrCfpWhgjcX+4RtEbhCZQR9EWCUJLhNE7pY3k9j5YcQRNgqc7wUQfvsR84ev7yvmXYSLRadfSOGMRYUEpZxHRxhAGCKCABGFiFHsfqLIvVaVodFHcd4F5/DH3v8q+MyVbvjjsD+0+VDUxZVyzXHdelXGco8xK8lQ6oxAq+qu++KvE4/H04GyCf0S9fpV/411iDtyFNdng9zb1vAYLqToX0pYsYzV+q4v3bzDDtv3Mdnj2Sa7n4ExHiEWYoMwBhsGiCRFXDmvi6UvxS2FICUPjxGHE2wYuFKQg5GbJlUIl9WhJDYOMaEz7hRaIicjxFxgD0ZE726Qb88x2f3si1svjNkc+df/gP1v/5krDxECeZljlURPAkRmMKMAYS0mdFka8R/eor//oVuAv9vh7X4REqRALGc7kdJlXiyXkwKCACFdNoYIA2c6OptDmt7326hKwy4dQ/e/D8ydeE4K/HP6rJ5mmoSK5fvl+FIWIqpKRLoYfxaXf0yq4medK37xs60rDdrj8TxvhCT49BX59z/ce7mur6l/fDtgH+2ZuGaebC6WFcq417bJOo8MH489np1m5wUMO1qYeC4yAOR07jIkrq7A2MoSEsBlKowWPheLoGtGASZWGCWRRyM3o0maI5RzKVZTV/tnTg4Q8wxxcYW5un6Q6VFMOTNphvjt3xB++TnJL1+RnY0xkXLZFlJw/eWIg+9TgqsU+ftvyT9e9K+HxqnoQsnbLAuUdL+DwlcYKGc+qiR64o6bDRVqMkK8P8eeX4DJmwNzlXjhjePa6fNA/xQe/ve9/Z71UWdKWXy/ilU6h3XiSN9trFI3XaZYGlNuW5tAU16mDn/deTyeKqzBXF65v5sGpLbQjlv2WQTokuHh47HH82jsvIBh4hCh3bSpItOu7OPqGjObt9YO28MJRIuykEAhtEVdpqjABXcbSsRUI+c5NnAP/eHFDSJJXcbGfP4gQD1w2F/sM//j1wTffIf69DX6zZkrSQkVo4+a+Kv36G+/R9eZI7UglEKEASKOEQcT7Dh2x2YcYZVyxwWwsVocswAbSkwg0SMJL2Mm2iDzHHN5/VC9bqw1H/iwvc6H9H144C+3r6nNu/5Z+rAP341nM3Qxh6vrSNd1cktTij7IsCuuXxQLhnhirNKx7uhTVLlsVXbJvnbyPR7PzmCWs/B1MYHfBpvcj5DIUbyaQejKbfD9H4/nsdh5AUO9u3BlEUpBlkOeu981ZSNLhBQIY7H5QvyYp5iTMUIJrBRkxyPCqwzIMJF78FezDOYJNsucgJE7A07qsjxKWK3Jv/0OvvsBEQYEQhAAeZoNC+RC3okX4xHi8AB7MMYcxJhQInKDGQeoyxR9GN0am5pIomOJzCwmFKi5JXt1SDRPEGkGsxnWFG5iq4xiQnUQX2dQ38cbxD62eQirfE5/899PqsoeugoIVQ/1VaaWi7+bMuwa27Vp6j5vH/Gk/Bn2yd/D4/HsNjXisTPY3NL+NxTLRBQhoghbnMXP4/E8K3ZewDDnF4g4Am1uBQWb52BNfed2gVXSlVVI91vOc5CgrhOCd9fYcYQ+ipFpDstn+SxzQVHr+6UjVYG4oQzDpikrPZrdmnVKxHgEZyfos0Oy4wgdSYSxBHONCSTmxQgdSZBgpcAqUDNDchZgJchUkx+GiC9eEExG8Ps/YdNsfR3mx34IfQoPwnWf4Sl8tjqe6ud6yjRlVFRlUpSpm1Gk/P6qouomESXxdyhV3iAej8czhBrBoCxYrNM/orINwEoGxU3bXnpgpGn9dK+r7mOJL+nzeHaanRcw7GzmBIXlLBrG3hcvaoKMNRaRa7JPjpCLGUtEppHvrlzgMxZ5E2K+eIm8mGLODhELD4x74kWTSLIphXkZRJVCHB7AqxfkpxOyk4jgOkMYi1mUiOQTRXooEQZkbglmBhDYQBB/zJm/CLBSoOaa7ChEmDFqFCPy3B3DTqOmO/4Qvctt60pTucmuH//H5LGPTdnU7Kl/T3WZA02lJF2FiAozy9oSki7tql225OtT9XeZTWZ39PJE8rHA46mleP0+t+ukKpMNHmZb7EosWyCUAqVcv7wqBt/2gXqWCA6h7T7ywPzex2OPp5bl9bGh62T3BQytQVioEo1bApn57gfU8YTsxZjgKkXMF9kVywwOQE4zNzWrMdhAIqMIO5tDhUrdqSPdh4YOs1AKEUVwekz2yaH7PIFA5gb1cUZ+PCI9izCBIL7QyNQQTHOXgbH0+FCC+FKTjyXCSkwgsJdulpK6mVtq27mP7NPN5bl4Zqybxzo2D+aAX3Z6nsEMPnViRVN2RVPns0H86BVzK7fdYEK8/L9qmQed6AFlIm2U/D78iJ/HswIPYvIzMB8vx46WWCKiCJvlW2hYDRXx1Wp919+ueuC5J0qtaPzcKcY+ERNSj+cxWV635d+wtpi8ozm6JYod5OJPFQX11OY54o/fE5wv6uQC5dZbBEsxGaGPYsxhhIkDZ4YZR84zo8N0UeX93W/zwC+oUDoiDw/IXx1jA4GJJMFUoz7cQJoRnE9Rc4OOBPlYEl5nqGnmfDwEZIcB2aHz9hi9z1Bzg5obbCTvt1nI+s+w7+xKx6XLubQrbfU0I0QhIMs7nxqlFtetKplLim7f/z7RNV7UTYNaFX+q3i9kYRT/b93fg9k9bL14Uf5/m99X8T7mO8keTz+W12rbNdt1uT1Ejkd3/3SIyzbLb8VkodQGW3aHPDysaIh9+LsYp6vEi1Xb3DXGFu9JbSbVvt/m8dynKc7eXlvricU7n4FxywBneRFF2C8+BeUOlokC1PERTGdYa7FxhExzTBSgRwHieITCZT/c1glKcVtG0jmdGR6qTVUjfBVfoJACEQTI0xOyX3yKyA3hxwyMQV4vMkOEwEpJ9GGGSjTJWYSVAn3gpk5NTwKSY4UVMHnnsjKEsVgpyQ4DwvLxarrxbbqEYZeyJFbxoWhKldqVz/ccqBu5KdP3O6nIuBBSuN+jGCHEnemvta4MzTzR0ZsG083GDIsuy1Qs3xpzq0xEq1J9ofl7f6yHG19C4vH0O7efmBAxlNtZRyj0T5viydDsthUw19cPX2wbja35frfV5tt7SJcMQo9nHyn3la0FuRjkHzrzZBvl62fF/sz+CBgDkMdHZEcxwlpMIBGRQmQjOBxhl0quEFglkNpgl6KCFCAlwpj7Rp70FDGaRvmaUArz+gw9Coh+vAEJIjfYOEQskknsKERPQkwkia4yNyVsbsnHCjUz6JcKmTszT5lqZ+Q5VmDBFm56a/e/eIwO9rr2uUoJR9XIQdvD0r4/iKzyGdb9+bsKF8Xll3QRp+Ce0Hc7O9BkjBiNsEmKiEI3zfE8QYxizLsP2CRZxIvlSPuef+dFmsoqhqTrtlElmBRfL27vVgQRD6/Nym3v4ANRZQr1Ezp/PM+DorjfddlNtwee1rUkZLt4UVh2Hfvrsi+h1P12Lb/frrG4IEgLpUCKweadIooervtA6G6Yxnv5YLeL9wqPpyt1nl9Ln5niMsvlNt2egfvYfQGj62hqxfvWWtRNghmFyFSDFIg0QyQp2Rcv0OMAmRtkolEfE2yoFtuSzhNj1S+ufOPuGPiEUuhJhJUgsrtRXTFLsOMYkeWIeYYYu1wKo1ywlVpjYud1EV1b4gtNeJkgMk1+OiKfSA7/8RqbLFWQDdRcF5fvO6Iy9HjvykN0kbbt7kLnadWO3CqfYROfvyltDepHUcoBvaVtQgpEFCJfnLnV0tSJni9foseh24a2iNND5B+/x1zfOCM1a56GcNVEUwdv3d4Rda93Vfn3oSPqxQvPvlLuHHehywDAuq7bpyBkFA0um96HDoNVHUVnIZGjGDOb3b1UFiqWu6+a8aRPPL5XPi6waWl7PbIi7okXy/XKfYKlWLIQLh6038djTxO73L8rt62zTUJLnFxHPG7KYG9gf80PyjVzVWiNVQp1NUddJ8hpio1CbBggcoOa5YjcZWfogwg9DrFR8HAK1eJuq7Iv1u2DEQZkhyFSW+wodOJFriEMsJPYOTaPQqxyWRfBNEMlGhtKdCSZfH3D5IcUEwjS05jrXx6TjxRqbpG//7q7Ut+HypvPgMyFPtvvywNjvh0NNNui7frZB8qlWAVfikZ/l6rXq86xiuwLhAS5+F8KRBgiJmNsqBDaIuY5BBKsxX7xKeqLN8hRXBjd2YMH576Uz6W26VQ7bbNnjOozdV/5pryL14HvLHv2kVXqm7v4WaybfY7HTf2uBxnApYy5Nn+HOqy5Ey8KZX5yFN+9VjVTVbl9Panqe6uzk2H3mLrswa5lix5PFbt6n64aRK/LYq1aXalBcV0EYftCtwv3G+iHfcjAWDLEiyHN3KqhQiQ5QgjIcuzBCHWTkh+PXJaDsQiL84pIssZ5sitLSOrc78tt74A1izokKdCBxL6cEEaBK3OZZUx/ekT8YQTWkp6GqJkhuJiRn4zJDgKiyxx5nRAYyI4C9MiVymRHipN/9y36+qZDIwYc601fuJssEdkWu6rODm3XY36e0r6FUsjDA8TZKfqTY0Sao95dYOdz7DxZZB25a8GaltkfKvwuivtxvjjGlYocHWDDAKIQ+eHKiYzjGGtctoWNJTo8QsYR6rsfMdNpY3zZS5pU/VVd4x/sq1Q+smpt8oCb5lbZxXjh8VQx5H7QdO3u6jW5q5T7nFXUeQTVLdf2eiFz4VbUqJrFo2nq0c7ZOffbI5RCf/jYbd0udDk2Ph579oW20r2iX6QUQHUWFZQyqepKUO42drsNm2dDW9+J/REwoF8KizWY6RR5PYPQfUwxSyDLEblGnx0QXMywoUIfxogkI7iYIqbz+19WSazoJF7Utakj9uaGfCIRGqyUyFQRXLv0t9EPM4Q22FBhQoGViugdqGlKqATRN+cgJWYUYCXI3JKPJC/+zZ/Q3//Q7eFpFx+0t9mmTe1rVz0xdu27LlLV2SmVlYkoQvz6F7z7786YvM1Rc4NMFIE9xsYvyQ9Dwo9zxDSB799iZnOwpvcoi5DOH0cEASIM3DZups7v4nAMowiRa7IXE2SSI/JFbJBgjkbI4DPEV1+7aZoZaJS0azR1RPtMD1qm2JlcbqPKVG0d+3pMvDGc5ynQx+eiyK6c+/teTlI36FQnKLdNFVr7AN9B1Kgoyej9PXdY52F5R52Bc4f9ty3jvS88+0jXgfMhg2p1pWmrxnQh6do/3t8SkiIN5R7mq68R07kz/1ESAoVd/G2jABsFzF9F6IPYlZck6V35SNG8h5q0sg1MQWrTlMO/+4BVgAUbOk8OkeZYJTFRgJxlxB8zgql2hqMLLw87jjBHI6ZfjMjHEgyc/e//RP7t991O0l0tK1jF52Jb+xpKXwPKbdLmPdO0zDo+S3EfDzxlJDKOyf/lXzD9+TFCg8wswU3mPG/AXTe5JT+MyF8ewptXyIOxEyEWU582XsMV7wmlII4RBxPEZIw5PcQKgTkeY0cRIjfkRxH6MEZPIkSiEZl2WVSvP7mbFnTXvusulEv3msoc+pR0VFG8MZZH8soCR3GdqjYX27oLx72L4LKLcdjjqcI/4D0e5ZKRJi+o4lSk5f8H778Qk6umsr73cFNz76jbZgERRfXLN86k19NMulKk2cFBPY+nji3F4mLs6FUu0mW7HT7DfmVgtFG+iVqD1WC+/xHxk88wZ4fImwRyjbBueXk5Y5IbzCTEHEaorxdGP11LpIEzAAAgAElEQVRGZ9tKR4Y8mFqDNRLz1Z8IfnaKjiT5RJFPjggvc2SSYyLlvDoAqwTzNwfI1CC1QYsYPXLvnf77t5g/fI1ezv3duu8nFqDXddPZ9M2rKfXzMW6cxX328THp+voqFK4jEQZk/+LPufoyJro2nPzj1JWD5QZ55URLhEBNU5JXE9Rcg5KI8RiUgnmCTTNA13e4lvtaTpm6zPoIAueDIYQz1NUaYVznLHinCaIQEwVkL0Zc/+aE8FoTXqaIebbYl777PPt63VUZ7q1biGsbHewjAGyqjUO4HaGsOIb+QdCzT/jz9fGounfU9icWA3HFcSxrsHkPkbnSBLvGELOtrcV43CGDx2Z5fTv6jgCXBY8uJqgezy4zNAtuBW4H9YVcX2n04hm4C09HwKgLgtZg8xy++xFlLPrFoXs/N25UdBw58SKUxN98QM/mTrwoBLTehj7LdpQ7p31EjCwn/rd/y/x//AtEbjCxZP4qQs0DZG7RkwA1086ENBbosUReuzbHP1wT/dXXmCRpP6mecoCuurl3eWAsL7PpB8ymNj3Gw+0ePFALpZC/+jnJWYjKLMJYTKwQmSH8cOMyraIAEynSsxgdC4KZRSSZ+3xSIcYjbJ4jrDv/+5jb2tSJFgSBmykIsKMIwoD8bEI+VkTnCcFVikw0wVWCSHPEVcmDZg+OdSNt5+4qsaVsBFruIK9afjGkDnsTVB3DfT8vPE+fTYqUXdP+YbUY8JToI4aXy++6PvRXDto1f3dCqW790OXvppr9Kk+NobSJFrts8OzxlFnTs1zldMO1+7xf5rvMwrB5hgjC4R4YHa/vpyNgQO0ImzUWkgTz/Y/Imym8OHHlI6HCCkHwcYq4uEa/ew+lQNvZ86Jq/8XXB4gYZjYj/tf/AfXZG+a/+RQrBTI1IAUmEIhI3mZeqJsMeTlzNf5djAK3+YBe5jEzI+oyZOqWqdpnl2X6iCe7fIOsq6vdph/Jg9ck8vSE6c+PiS5zdCQRFvKJQuSSYBSClNhQIVONCSWjdynZUUgoBeT5nYgRBK3CxW3JxwKrNcJoLCDGAfrFITZUZIehKxPJLcFMkx9FqFlOcD5HH8cEucFm2dPqcLcJb0OzCppqrbt0YleNC5uiy/W/y/HA41knxZKDqpKwquXLPg5eyHiYwdUaZwZmLFQd65Ya+M6+a8V2djAerG1PF8oZcFVt8Hj2iabSsR7XR2fx4naFwmB/4Vq3ebb6IFMLT0vAKHMbhFwpiZ0niDSFD+fOjE8pBGC0dlOnNmVadLm5dmlLm8lSeTWtyb/+huj9B0YnxzCK3TrLGVaSFDufQ5Zh8ry7z0UV23owXdc+Vt3OkPV3raSizKrfYZfsky4iUNv7XdtZ8QAslEL/8nPSQ0UoBcGNJp8odCwYvc+cMKmk8704UKRHkuhCuBKSOHLlI0nixMrF9luzrMrTwBkLuPVt6OoATSQxkYCZQR+Hi3IWhf5kQj5RqJsUkVYo0k81A6rIUIGgj8Hcum6W68pK63OdeDye9n5Wk7nkOjOy9o2+A1Jd4nGFqFQ5C9+97Q6cvaNOxG2Lw32+77bPvM/fv8dTx6aF3SpReUs8bQFjSUnIWNaf26o6uDqX++Vr66RHJ9nMZph54mY/gNtMkcrR46oO+CoP3p71sI6HmLZt9Nl+39T1daa6r3AcRBgwez1G5hYsqHmOlRCda4LLufOkSFKEPmb65ojo0mBCSfR+6kw9w9CVlWU5mI7pqNY44WP5b54johByjZy77Yxyw/z1GIDoMsMKkLlh9nJEMDXIy6kTGW/NgZ9w+VYTfcSMXh3UwqjaOgWDPttrGv30IobH8zCTqsvsEW0j7X42n+HUiQUVmS73+pt9sh+GzvIyOIPPNu/zud57PU+TXfDz6vpe0zV9TwxpjxXPQ8BYUj5wbfV8fdXdvh3ULh35e4HY3E/vadqn7yg7hnherHv7S1YtxWhafhveHkMyKVY5rsv1i9eGkMhXL5G5872I382d74WxqHdXbpGbGUQhehLh6jwWm5ISlHIi4Aystdiu7SuLmeYuyIqbOTaOQAg3hWvmBBMAUs3oh4TwT+8wF5fu+i27sj9nNtWRXHeW19BrvOt7Hs8+sQ5vm6pRu7oBpLrZh4rmkeX1i9sc4rHx3GgTC7pmwlVtc1XaBIkh+/bx2PPUWTXOLdZfyc+i3Ja2e0ePNj8vAWNJ33TmpsA+JLB2adMqD5qeO/qWKXQdZV2uN1SAKO+r6Rwqm8JW0UUcWWdpSXGbvczDepaO3FtXIqQg+eUrklOFlZCcHHD0hxkmVthPTwjeXcN4hD47wCpBkFhEbhHWgsQZbi7bbAxCCKyQCGnc6FKjUZm6nXkEWehcS0l+OiI7CQmvc0RuEMtJRowl+NMPmOsb7Dzpbwj8HBhyXm56xMHHXI+nnnULj1UeGFWmveX36ta919Ya8cKLGNVU9UX79o3K66+zXT6TzeO5T108XjG+yYMJ5vr6oXgxJP53zXTuwfMUMIoMCYQPMjnWHEz7jKQ/pUD+2DemrhkGfdtYJUB03eZQE811Hcch4smQ7de9Xg6SSnHzJiKYW1Ri0LHk+ssx4Y0hfSM5lAJhLNPPYnQoUKklnOYE72fYWKHPJqgP1pl3SulKSe59loYU5XvNE843J88R8wQ1HzF/HaPmkvAmQx+EyEQjz2+wxsDSvLNHepyngXJndlOx2OPxbJYuQoS13DOehPosizavsirxwseNalbNQNvl7DqP56mwvM7WLMqa6+uaDLayUFmz38WgY+8pVjte4yu4Uj5D+o64b7IdQ9j1mr9Vbn5CdFt+SC1l1T76bKdPdkL578cuDxpag1qm/Hnq/l8e44bPGF0Z8rGb7UNYiwkhn0jiC40eK5KzCJlZ4ktNMDUYJdEnI2fseRCSvT7CvHmJCAInRADF+azrP4Jrm1AKpIAwcq/lGn0QMnqbEr2fYQOJFQI9DhDGQpq5chWffbF+ih3sXYjNHo/nIW3GnHVTI9++vqa+S1WJiY8bm8MfW49nv6n0gyw+FzXH9k2JF+AzMFZj34LzU25vXZbCuspx6so/qkpBurzX9hn6rLcuqtpel4HRdjzqjnudt0XxvfLfJYKZRo8WwoMURFcGHQkufhEy+mAIZwaZWW5eBwRzi7AKmQVMvp2TjxX2SGEiRfxdiJ1OWxVrayxC4cpGFj4aSIGII+w4xhyPuf4i5vCPc8QsRaU5ch4g0ny5gcWsJaVj4fF4PPvIDqQP31uvyi9jnfvweDyeXWdT8a0tA2MdJXkD1vcZGM+RVhOVR8zUWMe+VymxaTJTLf5dlyExpEykz7670HQMm96ryoZoW6e4XvnvumX7+maUiL+7QuaW4CYn/pCRHCuyiYTF5tIDSXKskBp0LLASEGBGimCmiS5ywssEXpzcZmDcta9hmr6FZwZSgFRgLXYSM389IZwabCDde4ttmoMYshyrzf1RRo/H4/G003Xq+q6xtev2PB6Pp4pllnDxZ1cQEnVyfO//jfBgQFM6c/wO+5NxjByPK7Zpej8T+Gj+HNmWf8IQ1rHvVQzGqow125ZbF03b7FO6sim/iqrt1LWryzk25DsyFvHxEpla1MWc6OuPjN/nIGD83iA1mEAgLKjUMvkxR0eCYGrQkST+7orgOiM/isheH96bGrW+rc7g02pz2wby3PlnWEt0kRJeaawSmEmEVQKRadS377GLmUfuTZ3q8Xg8XSmX1z1lqqau71Ie1tRxbkxx9vHY4/E8HfTl9d0/mxg0q4mZNssRsv3+ZNKsuqxkQCz2AoZnP1jFu2IoxYfsqv339ehY93tD2zKEstrcxzRx1WNXxBrM9Q1Cu/3mn54QTDXjdxoduWyLybuc0Yecg28STCiIrg16JFGJIXsxwQqQc034bvpg21X7W/62C9NOtHY/xiKmye1n0bHExAFWLbIzpjNMkrhlffaFx+NZB/sqYpSFhEqzzrJRZ1fzyI5lI977wuPxPFU2nenbODja0e/CGmyWP3x9wH3NCxiex2FVQWJbD/ZNpShNM4d0WbZJBKjLaKjb5zo7Y10yOLqUxzQZdQ5tmrGQZUz+y1vk1Q3zVxGz1xHCWsKZQRhIDxVWCmSmCa+dkSfW+WWkZxEyyQm/P4cf3jmhoexP0fD5beYyL+xiGaENMsmdKJJbt99pgpjOsQvxwmdfeDyewZRLFvc1jjwQJwrGnbUzjzT8v1Jb9vQYejyex2WTcamOPtl3dfG01/5k9d9VDBFNqoTqAcfRm3h6HodVL/qh03qtmz7zo/cJfE2mmV3+L7+2DiPQOpGiTVTpMhVrl9G45cvaYN59QAQB8ceMj78ZYYVCpRZhLKO3KTefx5hgBIAJBflIMPpgOPjdpRMXbqbY2fxOCa4KqOWpqazB6uVHEogoxCqJvJozmmWQa1AScT3FnF84scPYQbV9Ho/Hc8sqZZFD6CrCr7SPu7h62+le9+hh1TZ9LPZ4PKtQ9HHblsk+3N/nsh3lRcKgOsOhD1VZa1XPL4+cDegFDM9u0XfmjqHb7bMe1Lepa2bG0M/QNeOhbZ9D9l8OUMW/u26vLKI8eF8W/rz/vjXVHVqrNaQpGEP4zTnyF28Ip4bwKid6e8P8iyMmP6S3yydnIYffJkS/+8GVdaSpy7zIcretWuPO5c3p/hR/VoOwAQQKO4mRH68hy7DzuRNX0vQu88KXjng8nnXw2A/e5c7zqtSVdkA3UbzvPpq26/F4PH0YOlFAF5r6zS3/2zSllqWgKyRCim591CZhuel+0FWQXuH4eQHDM4xNqY5D07OqyhW6ZDG07aNJGOh7DDat1K5z+20d1S5ZFeXlH7wmF7+E+7soYBiLkAZQ1UF2KRB89yOv/g+NPRhjQwVJSnCTM/8kQqaWYK4Z/zAn+NuvMGkGxtzOCtIavOtmKLEGm6aYD+eImylmNnftWZh83tYB+swLj8ezT6xzhrKlON07vbhDzNyB0T+Px+PZGF3iW12/ujytaVlMsMYNEDZuu5Ah1/aMVJmxt1nxAryA4RnKrj2YtaU3tWUoNJVb1AkDfY/BkKyFqtfX1Z4udOkodikjebCOvCdciCAAuQioZhEwl2ID+kGJiV0IHDbNMG/fI84DxGJGkeD9OYdRiBjFkGvM+QUmX6TUGducdVHV9orPb7XG3kwRs9m9Ni3+aN+2x+PxrMI6sxMfvDZQfCiyzTjYdp/atf6Kx+PZb4oDoEOyk9u2O5TCQNtyetPKrIy2+FxXOrIO1rRNL2B4HNus4xqyzy7LlpfpU5/WVG5RJybUvdeXqnZXsUoJTNX6VfV0dcabVW3pmoXxIOXtTrxwc0cLxGSCmIwg19g0c8FTG0gSt7sKd2MnGGhIjJsdpMh0uWuBtdbNBLJcp3K2kQrBqvj5ahRmq6nv7PtOs8fj2QSbzj6oipGb8KiouicNwYsXHo9nm9T1nVctV4fVY23Rt60oXhQzM4qDguXZmfqWC1YtW/cZ1hiPvYDhcTzGTb7PPvuKF8X12jIa2qgSK5rW66LGtvloNK3Ttc1ty1btv+rvpmlQm45hzciekAKUQgQB8vQEAsX1f/0ZH/5ZwPEfNCf/6QPiaqFAKAnXN3clH1Ufw1gw1XNQ2+IybeUiVcej/HpbqpzvLHs8nk2zrjjTlILcaf01ixp97vNNAwtdtuXxeDyr0ORTsXImRkMJSGu77tYTUtwfAOziPTTE3+NBv3nz/WIvYHjaeYzsjL77bRIomjIamjIp6tZva1db5sfQ91bt3HVZr+q9dWwH7mdeKIU4PODH//lnXP9EEH+E9Mzy3ZeC+YtP+PTffkBcXINS7qecYVFBncDRaEBUbHvd+0WxZvl63XnzWNeKx+N5PqwjA7BuxKwu+6KKTfhbLNs2pEzSx16Px7NN1pENV9rGrcFm3eJKgZDYPGvebmHmvKr31pYB35ZFvqF+8YqTxXpWZh+MqB6jtGS531WOT9fSkb6CQd+SlFXeE+L+z/K1rtu9l5bWY70+dOlMl8pGRBQioggTQHZsuPjnKWomGL2VTN8I9EHktqv14jxoCFW3RkM1P5XrDMh6qVLbHxh99tjuPlz7Ho9ntyjHn3XEkrYRvuJIYDEWL/8v/tyuYx/+7DI+Hns8nnXRNZ5UeayVxYtSbBZxDP/8N/3bNDQeryocbyj2ewHjsdn1m/pj0LVUow9Nnbyq9K8+2+27XB934aqA0+VBekmdCFT1mYd24NqEEyhkXkhEHCOOjjBnh7z6D9e8/ncgrwJMZJl8bzn+J4ucZthRhBiPXQbGchuF34WNd2tjU+DuIlZViRldsmLKf5fVaN9x9ng8fSnfJ4fet5bxsy2OFjvRXWLuKgy57zfd3+vugavc+z0ez/NmU/GiJbPNTKfYf/939QuUxWR4ks+avoTEsxm2lUpfNlyso897fco7+pS4NJW01KVgdS0paVq+6mG76XP0NfDpUDoCuGlSwxD70zfc/PSI7/+FIv4gOPjWoBJB/EGQHUF2BGYSIsYhJjomzDJMlmFzU9hkKcWuyTCoj7lSl+PdN327TsQov+fxeDxtLGNaVfZX1xgHD2NmWaBoEizKJnBVr227nK5LqWhXMd/j8XjaaOsndym9qN12k2dbQ3y25s734p6Pxo6UN1e1Y2DM9QLGc2QbJ/KqtblDhIGq9cvlKFW/u7ZlaL1YUbio2/cq5SqrLF+3jdrRrIbp9So7h3eje0IIxGjEV//LGdmxRY8M2REkpxKZCK5/Zph8JwmvLEIb1Idr5CiqbqKxrXWCt23q+l3DastUnXcej8ezaYbGmy7TpXbKcCu52+/aVNKrlqN6PB5Pmbo+7z1xoWPfs0/cLCwngvCBF8Ztv3jX4jB0G5ztiC8heY5sUrxo6yR06UQMeWgvbrdOGCgLEcULqa4co+8DaZOYUrXvqvW77KMvVXXTTdQKKjUBsWF7QgqXfaEUnB4RXoF+nSJygcwE0YXgs99myEQwfWNITwRynmN+fAff/IBNUpDyblul38ufZp+MDZzzXdOS4Talb2m+tPxdmern8Xg8daxyj+167yhnZpTjfjlmFctQyp33x6btfudjsMfj2RSdB2OHiQ11Rp4iCCtefMR4XPWMJdVKbfIZGJ71sk0zl6rsiPIoeJtZTVU5QHnEvk+K2NASk6q21imUndTciuPQ5XiU91OVbtx3lO02+yIm+fKMq19pgu8iTGiJ30uiS8vkv7zl1/8oef8vP+XqZ5C+OiD4XY5NM4SSWN3SgV6mzZlyWrSt/o7XkYXUpiQvjEtFHCN+/hNnTKoNUrvvQM4z+O5HzGy+Wjs8Hs/zYJ0d0KoykNv9lDIzhjzgP3YmRlNGYNNUgh6Px9OHcv/43nuPULphzb2S652gIgtOjmLMPBkcg72A4dkcq164Q3wt6sSEvmJAkygxpKykjbq21fkt1NWRNfldrNLWcme3bn7qulRdpUAqbj4PCa4Eai7IXmWYq4jX//dH9ItD1HcfePm//T2fHB1izy8wxj4MxIs2CCVBSkQUYrMcm+dgLEKa+yJGnZ/Hqt9bU930IsNCnp6Q/flPyCYBNhCI3GIDARZkZkhPAsJfnTH+09VqbfF4PJ4ivcowG8ThvsJFlTCw7Q780Lpyj8fjGUJDXBFKOT+K2qzrgULv4PW2GI9b/PTMbLbS5r2A4dkc6xrhrqKtVKPt9VXb1cecpyk7pGqdLh4LfQWPvtuv4oFJW0XacFWgkgKhFCJQWCkwseWz32q+m4TkBxZ5M8OmAQQKO0+wN1OstbfbXNbzCaWccBGGiM9ec/Obl9gADr66Rn71DTbNsFnuRIzi3NfbCtgL4UK9PCP9rz7n8k2M1Jbw2mAtSG0xEqwU2EAQXWqCmxwbV6T6eTwez6ZYxuzaaaarszMafYeaTEC3wQNRuUJw93g8nk1Q4wF0Gy9rB1EHxqZKH7qWuHvbxi30ibdgVO8FDM9u0SREQP+LbujDetsydUJEU0lJVZlK8fWumQJNxpRtok7d+23OwMXU2741w8ZirUVISXyhEZkiOZH85F+nXP48wk5nkGbuwT7PQet7q99OmyoF4uiI63/1C8IrzcUvApIzOP+zU778X6/g8hrMImOjrhZ73ZkXd41EhAHyz37G1W9OMYFbTmYWq0Boi0wNIhcgwITyrpzH+M61x+NZM53ucTVu9jXZdp3Ei7ptbxIvXng8nsekKpOtUUzYwIN9W6y7LXPZcknLhvAChme36FLS0eV/qM9YaHtwb2tLcb26dnQJEH39Lcrb7pqh0sX7orNXR0PNdNNoXpZh85yDr64Y/9kZ6RGc/ccbXsw0aI2ZTsHY2o6wiELEz75g9tMTPv46QMcBk+8s+UQwf2XJvnhBcDCGP30H2gD64XaGBu1W07yFKedf/orrLw/IY4mwMPkhxQSCYKZR1wlilmInMflRTD5WmEiSHivCqc/A8Hg8HWhIx618b8ioX12mXd2yXV5f94hfmylnXTuqlvUCh8fjWRO3Xmzun4cDaU0DltUbrMzsWK2RG4jH5WesLeAFjKfIY5jG9GnHukbD2yg+wBf/b/K36LvtKuou5i6iSdf3+viDDM3W6EpLZ9gaCdogkgT5/pI3v42wSiCvbpDXU2diqSsEhwXy5z/hw//wmnzs/CPijxYrYfapQGaAgfzQiQDB2xE2TSv1i3t0/bwdA7H85U+ZfjpxbZgbsgOJiRZ+HdpgpUTmGpIMcRAhjMUELgtDzXwH2uPxrEjfTmObgWcdPcybtzriV2Hs3IoXLzye3WBXnltWQUjnd9Hw/m19cx/xAnY7VpWftbaEFzCeItsOAn0DT9fSjXUFtC4GmEP33yYMlP/vIzx0LUfpwhDB5fb/UvlI5TaazTyt1th5AsYSvB9hjseQa8zHc2yW16vLQjL7s5d8/GeC+KMg/mD5+JeW6FwiNAQzePGfNfG31witwbQpFzWft6l8pnY77lgErz/h5ldnmPCubCS8MWAsJpaYWKEPQ4JxQHYcEZ0nBDONMKDmGpl2aLPH4/GsQrkksE85YFPsb1pn3XQ16PTTono8+8U+ixdVnkJVmRN9M8LK65ezyzpkZYggXJiIlvrn62DLgkUZL2B4VmeVEoym9TYV0NrMLvv6TlTRddaTLn4WfTIvulA2GG37XG0d3XK68dIkqLyZPMdqg/juR+TFGJsk9Wp1YbaR0ddXBNMXXP1FSv5PEdEHgR45bwkQxO8SRJrBxdWtSNLpsxePQV+W7QsDLv7Vz11GSWaRuSW8zBAWPv5mzPiDJh8pTCgRBoKbfJF5AaNvr8heTjCx6r9/j8fjaaMY2+/dQxqmxK6K81Uxftv0KRvZ5dFKj8ez/9zrR1fEmzrRtyoeN1Ge8a+DICLH49sZPmye1bdhFR5ZvADwMrXnIes6MRtHS9acctTmeFtljtlUg1aX/VBep02EaQ1OJbGm7QG7qbyk6f/y9h50aDt4ijTRNEK36FDa5bSosxnm/AJzM3OlIzUdTqEk4vAAeXHNJ3+dIy8DZr9I0WOLiSG8EqSnFj0JEFkOada4vXufvQ4h2jvKhc8pv/wcHQmMgvBGE17nmFgh5xkv/u6G+EOGSg0ytyAgnyjS08hlXUiJTA3qpuIG4/F4PGV6l4n0EGz7ZC1sO8Ohq3gxePu+K+zxeAZSjh/FfmKfkrvC30Kp6u12yIZbdXrSRjp4wm0Ln4Gx6zxGXdi69jfUyHLIZ67L2ihmWvR5UO/6cL+ucpch61cZAlX9rlpvuU7Ta7fvrakmGu6mRG01qQBxeID52Rsuf3XEwbcJn/2biPlZyOyVgKkrHZm+koSXKfbqGpumLsujLgNjle+qZkrBy//mNcKCUZAeK4RWBDODGYXkY4VVguQsYPQuwwSC2auA9EgQXUjywwg1z5HnN/3a4vF4niddjd/K1N4LSh3iLrG+odyvMoV6kyN9beWNXacVrNqmx+PxdKEcQxbx6NbQ80EJiKnou5t78cxWdZHLsXrwFKwrxOTyPaicGbJuw9EGvICx6+xzXVgX1jH630TbA3yTH0KXB92mcpcuXgt122kSH9pKbPqut6oAU6cSP2jXw07mraCxnCpVKYRSiPGI8//p13z4c0nyJgMZEHyQ/P/svdmPJUt+3/eJiMw8a6293mXuMvsMyRmKFEFSlClIsmnIi2w9GXr2o9/89xjwkwDbgOAHw4AXGZAoi5JoasThiMO7DO/efXutruVsuUX4IetUZ2VF5HLOqaVvxwdoVNU5mRGRp6t+GfmN7+8Xeb9I0xh9Kdn+swdsjQfw7BAzm9cXTzrXacvrbAjCIoqY3ZHIDAbPNHlPICRkSBb7fbQShHNN1hNM3oronWiSLYFRgpN3e2x9HpMPQsSi1248Ho/n9WZTjsXypBnOvgqlXgrA1XjdtZjcJiawTeJF9cHA9iBRh+2afPqJx+PpgmPnIxEEmCS9+F65mGeZpt2heDlXbj3f3SS2+njXGEO9gOG5Xq7SteBKCSm31ZSusU4BUFf9C1u71TZs4+tSELSJaj+rTJRthYZsxwhpd0kIibpzm+zNfQ5+bYyOIO8Z1HFAfjsh7xuQBplKhk80ZjKFkxNMkhbBPM/P0lRqr/FCv45rbbgeefc20YkhmhTHRUe6SMrTkI4Uw6cZeU+w9WXC8bsRWoGKIdkCI1/2mW97AcPj8Vwxljh/Trwof70O2uSG+y1TPR7PdVCKn4XTojrf1+gkdS/mdeU0fp0JF1cdz1ziRWkcZwJ4l3F1TbUp4QUMz3psckvULoLEWtt+Wh7Wmx5um1wP1bbb9FEnltTtQGJ7/5ylq6OrZVNpSm0LvdXk8JntESfvj1jcFggN258YhIGTRQQSZCp581/G9D/4Gp0kxbi1ri/ceTamdX5nzosZQgqO/uYbYCDrSZKxYO+jBUIbjACjBEIbeocZyXaIzCGPBIt9wfBJsUtJfCskOspQk2y1MXk8Hk9bGsX3NYbkyvYAACAASURBVFInqqko51JJLjEN1payUje+JrzI4fF4OmLy/GIMhPr4ZHNFu3YArLZl+/kqsDguhFJnZpLO4kWpnVXwyX6ebriKYW4C28p/9cG8fGwb2hT1XPZrKwS6vL51847rrq1NAc42AoVN5Kj20VTsdBP1PMASbC+q07ZzzJdfEx3nbH2pkSkYBf0XGh1C+nZMvJ+TbimQRegyeY7JzxcJdV5X3efjwmFTVrdvoQOBzGD6hkRHkG4HyCRHZpr+kznhYYycZ6hYI3KDDgXDx4Y8BBUb8kiSDRXpfr9+DB6Px7MKjTUtSnFxU7t3NMX+JtrEZWgWzNvW9SjjxQuPx7MqdfWBrMdbnqfO/azPx+Xrqs9ztpB78dpMVnKZXHH89A4MTzfWLbq5ibSPLrStE9HUz6p9d6l7YeurbWqL7Vibqmvr01UT4+zn5qrHF46rrsQ5JqRCnn9dCMHgyxOC+ZCTt/tM34ZwIrn/bzXJVo9wqhl/dIiZzYodR5Y7m7RJHamm5LTBdu1Csvjx2yz2BP0DAwZkBjoUpFsRvccTMAYTKrLtPvNbAdlAMHpcyNRqnhNOUtSLGfnOgPi2FzA8Hs8lcOGhvuP9t60jwZoHvcI9s8tCgcvxYRvTJgrfeTwej42qmApncUaOx+jprH3ccSyYLnclMZm+8Hqrehgr17izLaha4m7XtJENxGEvYLxOXJaVs0t6QtsUjMumqcCmK/WjKd2kbU2NNkU6bcc0nbdKUVRXm2fOlJaqb1d12OiiQvPZ6QKTJCAh7yvu/iwGAeFRUexy/Ndz5GSBOT7BLOJ2zovq9UD7SbKr9kUUcvxeRDgt0kJkBr1DjYwNJhDoKCC+NySYZizuRKQjwfBZTu9ZTHC8QEznkGvIMlSeo98YtBuPx+PxXAblSfO6E8tVhYuVFgk6FhT14oXH49k01Z03SnNHPZ0Vc9uqxtDlIf6sblzueL1NGx3S/au18CpjFWEA2lwQU1pjc+mt4HL3AsbrxFWJA+v2udaOGC0FgLbFMdu4I1zfr1IfpEnwaOvq6FrXo278DQgpLgS4s6DaFKQrDgeTZYhPHzA82sX0e2AM4mSKMqbYIjXLMGlWVHZuI160FZ9ajO2smdEQDEQTjUwMeU+RR4JQglxoZu+MkJlhfjdiek8xfJoz/ugQcTTBxC+FF4SENEUtbrUfk8fj8axDk2B97rVrLBLn8Xg8rwI2B4btGJtjoW7RsSwqW4pmtnJHr5IWbnNhl99OEve5Xd0Vq6bo4wUMz01kU6JHm4dX2wP/JoQeW7rCOu3axIU2aSBN51XH3AEhBSKKEKMR5o1bGKWQkzk8e4GezTBptjywm4ixiMkfPUEEASIM0Lku0kUAtH7pvGi7jVTb4nUtC8KJ7S1kDiI3hJOM0WMIpjkyKcYTTHPS7YB0JOkda8ZfzgvxYrF4mfYiRSHWGEkw9UU8PR7PDaDNZNK5Tfaa9zcvYHg8nleNqvPCaNTWFvlkWrxmdLP7oo2o7HCRydHQnaKyyWeatnQVvTsumJbxAobnm0HbP1SbI6PNea62XHUVyu/ViSS2/pucHa7rqI6n7pjyOJuuxYKQArm7w+K33icbSEQOCNDBGLjD4EmM+vOP0fOFvQGLwrtMJxFSQ164OExWerhvU++ijrog2aXwEoCBxZ4iPMnBQDZSRLkmDyXH70ck24LR15rxlzHq+aRwjJwWHBVKQq+HiGMQkmBSo2Z7PB7Pkk096Ld18VnfX7NIp2s8K5/r61p4PJ5rpuSQyCfT5kW75WlNNSwa4rGeTNznrEpdPL4gvlicIZvsrwa/C4nnZlHdbcP1nus81w4eVYGg/LrtvaaxtB2PbQyNlYctk9Smsbiur/y1mtZyVuNCNDs6Kshb+zz7z79PHkl6BynDryb0nscYCdlAcPjdAbO/+2vIwWmByguFMG2OmZfOCqNNEdRL/5avt653YRNy2gb2uor8xhDEhmBhiPcC1CInmOVkgwAdSoyEYGowkiLCSlk4LnJdbPkKxTUFAdzZ5+Q7W+3G5PF4Xm+u0qWwjKG2f+X3PR6P53WmqUhwzWJYayexLQa7jrlMXNu5blpEbnEdXsDwXD8u8aEuJaR6bpMDw+U6qB7j6qNptapuvF3EC9cYXQ/kyzbLIoTt3HK7tp/L4kZDHrQcDTn6w/dRqUFoQz5Q6EiRbkfoQJCORCFkDCXx7/8Q2e/Zr7FuMr4UM7Q5+9d6mz/XKuXyM7L1ZR2fu8J9OhSo2BCd5GRjhVECmRbHDZ5phk81QkM6ChBJigiCQryQEpQCpRCDAfNv75MNvHXa4/G0YJOT03XEEC9ceDye1x1Tmpcu/zmKeZ7RdkvVVn23EDVeVVp8Hl7AeJX5puSM1q3oNF2j6/iqYNG13abj6lI7qoJAdbxVMaPJyVH+5xqH6xpdKSqu66u6U+BcwBVKsfiDH5JHguhEkw0lyZbi4NfH5H1B/0XGrV9M2XqQkkdFakX6uz882wLK+nlUx3fu/co+2E24hJiuRYzKfVfGbQ6PkJlBGEM6Vqi5xkhBME3pP1swfLggOsoIZ5rpvQCjJCaOEWFQ1PUYDDD3bzH/wT0whv7zlgq8x+PxfBNZZ/K9yZW/rjtpeW4235Q5sudmU44btkKdbbcbfRV+X68yRjb05WtgvMpcluK2ihNhk/2UqRtHlzzeNtfTxvHRFpvjo9xnU9FQW3pL3Zir9S1ctS1sr7n6sqDefoP5bYUOBEfvBajY0DsybH+WEB4tkMdzRJohJ0PS8Q46ECTbAb1vvUn22ZfnG3OJKl2pikW261h3glzeFmu+IJgbtBIEc40JBL3ncfFeKBGnO7CkA4nQMPvBbYafRYjJjHx/G4D5W8VOJb1nc8SHn68+No/H41mVTd/Tbypt87N9LY1vFq/D77bn+qgW2GwdZxwLnDeFuvGt4FhefRz1bXkBw3ORNukSl9kPNIsTzj+uFmkcTX27xmB7SLalh9hcFraH7JVcARYxpNqeK03F5QipOjVqAuvk1+4RzE1RpHOWINIcMYshCjFSFufGCWLYZ/A45vB7A4K54cXv3Gfn8dOiqGd5+6h1qI69St3/XxvKxYmg2C4WMGnG1odHHP94l7wnUQtNuh3Rf3CC7geku0XdD6EhWBhmtwNEvo0OdzAKjBSMPp8g/upT9CLGT7E8Hs9rzWVP5ttMqn0xUI/Hsw5t40eT6/q6hbdV4nGbLV03jPfLeW4mTbUs2goQLR/MWxXGrKaH2EQRm4BSFhfaiCh1aR21dSNaqLoud4JtXJVjhVIcvxsQLDTBiznq+QnyyQvEPEbMFsjDE8RsAUGAkRKR5vRf5ETHOSo1xH/wI3cqSd04mq7DlUKz7k2guvf1shYHIB48JjrO0aHAqOIzj++P0f0QI0AYCGeaaJIz/joFY8j6gmCm2f7Xn8PPP0TP59Z+PB6P58q4ySuBV4GQPnXE4/Gszqbix02JQ7WLy3W7813tXPaGfFqebzydV79rHBY28cB1rOuBuE0xzSaxoKn/OmdAHS7HRJu0mLpaH9U6Hcv3q+05anPInS10ANFh+vL4QR+EwPQizKCH2RpixgNQgnwY0jtM6T+ZYSSFW+HWnvu66wSnqqhSJ0xVx99F9LJhqcGhT04YfvQUrUAYQx5J0i1FshMiNCQ7AWqekw0keSQRBnb/9CHRv/gF2eOnLytPe/HC4/G05TLFhldZyOg68V+KFkvXRTnGX/fqp8fjebXY1DxuU+7kdWkqsG895xLkhIY2vYDhuRrWSZUo06Few9rjaSt+uBwStroTdX2Xi3W6UlS6XLurhobtGFfBT3gZsJRCpvDi+wNEnECWQ5KSvbmP3uqjd0fM390l3xmgByHzO2FxnpRnboXke2+epWJcGIdrnNX0mKr4Uv5sm9Jquv7eOAKo0Yb8y4fs/8kDjBTEuxKRFe9N3ooQ2qBijUwNvRcJ/Z9/Qf7wMSZJzt8ANvG77PF4Xg/OYt8luAauMw5t2C3X6viqMO1jscfj6cK554IV4/GmdiXZJKvEwcvYRlXntWPxNTA8F7kJOVg2rmJcdX1UBYSmtJO27ZW/ryvu6ap/0URdm64Hflsz/R7BwpANBPmtMXLURx7PUC+mAKT3d0jHknQ84Og9hUognASIzKBmGdlAMnujx3YQXNz7umt6j+39Nk6MsmDTBltQPs31M3lO/vAxo8mUwftvEt/qk40Uw6cZwTxDpjnjD07g8VP0ZHrxmm/i35jH47n5bHqyeFPv+V1i9br9eDweTxfOLbStGJOr5525wurn499oWl6zFzA8F7msPxjXarjrj7TJidD2j9t2nOtc12p/9T3Xz13GVz7GNVFrU4jS9rnaHAy2MbraqYg0Qimmv36fra9SdCCK4p3TBXp7iAkkJpDM70YkY4lKDMEcdARGFccSKmRmyPogb99CP3x0MXDXCUPl19tMaJva6DoxdhR4M3mOPjpG/HLBYGsM+zsgJWI6xxydYOZzTJadFy9exxuSx+O52TSJ7UsuK37VpQNeVn8ej8ezKmfu5VLB93XF5TZpJG0cxbZnh+uIeV0+k47j8wKG5yLr/KLXnet60HeJF7Zzbe00jcMlVLQ5r/pQX+eKKL/mclS0+XzKY3GNrW7c5bZsgc722TT0LccjFruK3rFm+OkxQmuQErRm9taYrC8JFprh04zjbwXoAIaPNeE0Q00T8lFEOBFkA8n8h/eJHj3GVAwJG2MdgcN67PndSKoYbTCLGJEk8Pzg3OsX8qqvO7fR4/F4utJmIvyqrBa+CmP0eDyvDmfzvBXFC9dDft2zUdfF265xr26Rr5Mo0WKL2RVjshcwXjfaTDIu4wZv67ftw3hTu7b2bE6CNoKHbYwWR0JjW7YxtTmv6bpdY3GtXK3yf1ltT0jE9hgdCKIXCSZUZKM+ap5y/N0thDaMv5iTDwPivYC8Jwinht5RTjBJMYEk2e+jQ0EeCtKtgP5wSD6Znn/Av4kP9+Wga7P6LTG6EGSqQbrp//9VmfR7PJ5vNm3jkEuI7+KuvC5u0lg8Ho8H1ndtVDk3f2+YV9sc2673wLmQVzscpc528LvQ9xp4AeN147LTQ9q6C+qoS+No267LkdDUjk30cDkbmlwNdce0EVSq4z6zqzkcFG0+s6aUFJeQoA3pliAbhyzu9jh5SyE0IGDwVJNuh8R7AelQgIDoxBAeFbuVLO6PyAYSFWsQEMxyuH8HfjV1j6MLm7DtWdoUUlysW2GjbB2sihdt04g8Ho/nOllFbGhK1bO123TvvIx46IULj8dzHSwf+FeZozYJxbbjV+2jnKJtfe6wzHFbcln137yA4dkMm5wgrGN7Wp6/Ki4XR5Mg4jqmGhyq59etZpWvx/Z5uM5pI15UxZmGyauZzYiODSdvBwyf5gyfaqKTnHhbcfy+BBMh0yJtZPtzTe8wRcU5yV6PeDegd5QTHifIJED3JCYKTwUCZ5ftWN4cNpmDCC8dFeW2q9+fEyscrou2Th2Px+N5lWgbv1wrfE2ux03hxQuPx3NdrDsfbeNer0v1WI6hbm7cJl29fG7bebbtuA3GY7+Nqufm0eUXfOlIsLXRNAlanltto/yzKz2jrFYuv5YdEtXjl23Zxly3+lTtx/Za3Tm2a7Fdq2vsyyFOZ2QD6B9qRA7Rcc7gqwnjLxeMHhiMBJWAkQIjAQM6UshUM3qwIJhnZMMAHUowINYJYsstBKtWtrKYsUmqQkVdP6ukPnk8Hs9NoIsosWqb1fun7Z60CeocoR6Px7MuS2fCZdImrdz6umPhrfw+IJSyfu98vgBkv9dq6BsRL2ruB96B4blZ2JQ/lzvA9XqTA8GV7lFts26FqPp9nQjRZYxNbo8mu5frOspfbf03TBpNrgnmIE5dCdFRigkVx+8POPw+7H2oCaeG8CRDxZpkJ0SHApkZgllOcJIAAel2gEwMYjKr7c/JMtCGAXI8gr0dRJphpjPMfHF2XSZJXubcbdKZsWyv/BX8RNnj8VwNl5121uZ+exn9uxyMq+DjscfjuQps88p10kbKbdSdX7fI6hpf1UFsXQQs2aKrzwxCIHs99HzebtzlLWEvAS9geNajS12HunPrqJtM1dV9cD34txEvXP22uQ7XJKxLakeTA6T8nu0c27hs51Q/E1cgNJroRJP1BSISiDxE6IDZPcHwa9AKBk8W6FAyfbNHvCPYepChFhqZaYQBNcuIlCTvydMmu/yunAoXUqDu3eXg77zD7I4kmBt0JJCpQaYgNKRDwZ0/nxL88jP0dG5PBelC081olbzxy34I8Xg8nq7UxbKriFlN98omNjFR9nHZ4/G0wRUTN5TG3Iqz55dqAXnbriYVMQPO1acwWdrYj47jly8pZalvUepDr5kj3hCLfQqJZz3WmTB0cSbYjnPVhgC7C6LOseGymzalaZTbLr9XPa9OyHCNvSqEuJwftv7L31cdG+Xx2MQPS+6b0YbxpydkfUGw0MR7imCWM3xs0CHsfLZALlKS3YB4V5BsC+IdhTltNt2OWNzpk/ckQhuIE1pTsrfJ99/h4T96j+N3JUKDDgTBtEhhyYaCeFeQbsGznwx59I9/TP67P0aOhsW/fu+8Ra4tdYWLVkkZqftd9Hg8nutgVavyTWFT8dTHZY/Hsy5t5pmrpp+4RJMu7ZXntbaU7DZN2Ircny34bSCONqQBegeGZzOs8kC2zkNc27SSqsjhcozUnbc8t66vOgeELdjUiSkuR0ZVrLC13+S+KPfves3FR5+hf/enzPcVO5/GhAcztiXIvMf0jR6jB9B/ErPYHSL7hRMi+U6EWsDOJwvyfuG+ULFGH5/U93U2ppfOC/ne2zz5w3voEGReuC16R5pwZoh3JFoZAsOpsAF5T/Dsp0P67/waeSgwCgbPc8YfH2I++QKdpOsp5V1+d5tEK4/H47mJ2O49V9FnF3w89Xg814W1WGX93FLt76GPjjdXyH7FHULOzt0Ul5gyUsULGK86l5W20fWcVX5hm1JPmsSIpratKqXjPJejo0nUqHvN9dBal/biSiGpmzza3qtLn6lLT6npxyQJ4dScFuos2sp7xXaq4VSTbgdEBwnbn8eIzHD43T7B3JCOBDqUiMxAD8Jphkmz5qBZFi++/S6f/uN7jL80qIUhmILMYOurGBnnhCchQkMwSUj2eixuBWdChlaCdCQIFobFriL+m7dQv7HP7j//BP38oN1WqRc+DMf/2yrt3PSVTY/H8/qyyRi1blttUjI9Ho/nKjiLRd0FgPzgRakdR5pyk7O8Td+brP9WxzU4i30KyatO11+WdYSGy6JOVGhznCudo8F+VCsw1B3vcl7YxtXkhLBdQ3nsrtdtfdelstj6rROELGM02rD913PSEczuh6T7QxZ7AcmWIB0VAkW2FSIXOeHzKdtfJMgMxg9z0i3F5K2QrC+IPvq6k2gg9/Z48A/u0X9aOC72P4jpHxrCmSHrK+K9HnlfIbQhvt0vxBINeVSkmCxuC4J5kWaiIxDakPUFT/7hd5Dvv4MIwtZjaf272gU/Efd4PDeVTU5KVxUvyvfDpvu6x+PxXAUrO8hLu37Aeu6JJi6j3Q7PDZeJd2B4bjZ1LoUltj+iLpOurhO0OneHzV3R9hrqxA5Xoc06R4ot3aTaZnk8rrGWUD//GPnjn5KHgnQrLOpZ6KKIJkIgMs3ibg+1E2EE9A4zTCDIT0WF8YOY/OkzZ/svxyMRUoCQTP7gfUaPikKgOhBoJRg9WHD8Xp94L2B+SyJTw+CgGEeyVWzVmvcFamEYfW1QsSGPBEFcbAOb9QXBc8Phb99lfHcb9e8+aE4puQaF2ePxeC5wGc4t132q/PW6cAkXPh57PJ5XAYsTwlrI/twuHq+A2+wax+YdGJ6bSV2NhjZ/MG0meFWHgu3c5THlf8tjyhOqqtvC5oao9tF2bE21OqqTzKrAURUsXM6Q8rgujLcIqCZJ2P/lDCPBBAIdCMK5ofcio/d8QTZULHYVR+8H6J5AR5JkrFjsSG7/6XPUn/xl4b5oqQqru7eZ3VIYVaSDCAPJbsD0rT7TNyQn35IMnmlGj3Om9xSDxwt2//KkSBe5ZUjHAhUbVKwJZ5o8ksTbEplBsi3JI8HRtwfon3zvpRpuo04ocv0eeTwez2Vw2fHmJsa06j0YbvbE3uPxvB4I+bJAfJtimOWtTF3vnWv/Yjyuna9umqVjJIpejqf89ZrwAobnemkjMiypCgtN57ge9MvtVVd1bOeWH15dx9aJAdXvXeNt6t82Ftd7dYJJNT2l6XMqN6MN6ucfk/fh5C1FvCOIdwTzOyHzewMwECwM259lRa0MBUbC7Z8doz/6pF3qSOkG8OzvvUs2KoQSI4rCoPN9yeQtiVHQf2YYPkkYPphx65cLRJpjeor+85StzwEByZYk3imCvVaQjgWzO4VrQ+SGYKGZvTVE3d5333xsk+fq5+nxeDyvIk3pkzcJH2s9Hs8NQkgB5XQQG3WLdq55Z02sW6l225qYNLv44jXeM7yA4enGJn9ZXS6ANrUZutS2KL9WfQhd9XuX26F8XNnp4Hr4rV5r1WnR5ASp9lcdW1O/XVa0TgOwXsTc/yd/iVHFecEMdAjxrmSxVwTxfCAxAmRq2Pu/PoJffGi3y10Y12nqCIBS6BD6zzXBXNN/kZNsC8YPc0YPNcNHhq0HKdHDY+TxnOjRCSLTyEUGAmRajCvvgUoM0/sKI4vxpluC43cVCNChQGaG7Ft3ztJWlmOxj/EGrk56PB7PurwK4sANWf3zeDwejMHkOSZJVq83cRVFNtehzjFyjfgaGJ5urFy0pqa+g6uPVfK/6nJibTUMbHUoyq/XjaWuxoXtvGpKSF3OcdNxba632mbTtVbHb3UbFHtN55Mp9//HP0f/5Lu8+MEImRV1JfKo2OJUTTSjnz8kf/wUbXQhXrTcdWQpdIgoon+oySOBzMBIwejrnOgkZfA4KxwZ2xFIQbY3ItmNCE8ygpOYbKCIphr5uWBxSxaOixz2//1B0UcU8Pw3d8hDQe9Eo0PB9J0hW38RYJL05bXaeBUm+R6P55vLJmtg1NVGusn4OOzxeG4qXXb/OD1WKHWaYt0Qi69qZ5G2XFOtDi9geK6GVX+xu57XdHyTEGBLEVme53KG2FwTdekudWMo92Ubn+3YpvddIkzZgWGrk9GAXsSIP/sl+38GotdDDPqY+QKTZZDnZG0cF2fjlaVvBUYbRC9ivl/UqxC5IetLRo8SwkcnZPsjwsdHyGSImC0wd8cE8xyZ5uSjiGCWc/ReyOhJjkyLrV9HDzJIUsQ8hp0xvSPN/JYkDwVBbAgnGsIQlgKGc6zXE6w9Ho8H2Lx4sel2Lwsfcz0ez03GJi40CQ7LGnNl8cJxvlCqnZv5OrjiubFPIfG85DInL04l0ZHeAO3rRnTpy5VC4prIletFtK0VUXU3uApptl1FK4/BlT5STQdxpcy4WDEtwmiD0QY9X5AfHGLiGPJ8MwE2SUm3itoXRgpkDuk4QA97BMcLjJKYUGGGfcJnMzAgMo2OJCff6tE71qdpLDB8mtM7SBBpBlJiooCtDw6IJoZwplGL4lihOoTEVf9ebvpDgsfjudlcxgTxVYhLTamUHo/Hc9nULfSV0y2WC3Nnu4qU5pe2VGXHAupZarOQnYrgf9PxAobnJetMipomEm3TRVzHdnEx1PVVV2fCdmz557ox2tqqBiObGFLn5LA5J8qv1wkgNgdG+Rzb57mBSfFS0LC80XTihZfE1hgoaljoEIyE43cDFm8Oi1MGEY9/d4vk/hYYQ3gwI749INkJkHmxbWr/ICNYGFRikHGG3h1jBj3EZI7phegAECA0yNxAV+Gl6ffe9bvl8Xg8XbDVK1onltjSHl/F2ORFDI/Hc9XULqJWhIu6986+Otzf8FK0KLfXZreTJpa7pzQc4+pL9nqOcxwLxRvGp5B4NsMqE58mp0X1Qd/mgnD90ducCNWx2kQEW9rI8vu6Ohe2lBFXSkmdQGNzUtiEClsaSLktl7hRF1Q2EGSW6R/nx9pCLS4FyLPzpUScFj0eP0hOt0ANefJbIbvjPYyCZAu+/Ps9dj/q0T/IiXcl6UjQf2HY+iLBKMH8TrFdqkwHiNzQeyYxSrK4O+Dou5LtvxYM0qxwYWTZ+TG1Gruw/36C+//6VXxQ8Hg8V0+b+8Ym2WR9javAx1KPx3NV1KWWn8Vqi9Bg9FmBeuPaQKRxQawkfmzChWG0eyyV42zoOLYc2z0dfVW8gOG5PmzuA9f7y5/rHha7nFv3GjQ7Qmx92YJZdZy29rv0YwuW1ffL77lSYdp+jtZx6JcP9xVl1uq+aCME2NqazzESwinIRBO+WBDMekxOehy/J9Eh7H+Qkw4lx+8JZvcDBk8M44c5ap4THcbEtweEJ4bZPUH/UDL8akY+CJFJEbXHnxt6xzk6FERfH6PL20R1uUG0/RzX+dw9Hs/rRZdUwy7U3QteJfECfEz1eDyXT90iYh2l9BGT527nRNu4W55/r0KdO8TVX6f2LYupl4QXMDw3F9vEpC5o2B7gbeJB1TlRfa2uH9sfpOuPtOyOcDlHXI4I23hcgoVr7NV2m9JNumDL81sHSxtmMiUbQhqDkQKRZIgsZPg4RZiQeEcwva8IJwYERQ2L5bCU4OTbY6b3Jea06WQs6Y1Csr5CRxEyNex8FqNPt4PlyfPL2Vv7EpwuHo/nNcI1CawTxF3HV+9JtvvmVbOOcOLFC4/Hc9nUpHjUstxhRIp2bofaMTi2M20paIgoKrZ7vYk0OfIteAHDc/Np+wvtcju0ObZ8juuB0xbAbDUm6sZTFWVcbVbPaSuC2NqpXtNVT/bqAmtN4DW5ZvDEkG4L8p5EDSOSvYhkSzHfl0QTg4kNRsLeBxqZG4KZJpjnJNvBaQHP5WcgCBaGR7/bRwcweGpQMQyfwuxOwM6nC8x8vrogs8rN7VVd8fR4PFeDK02xECVp5QAAIABJREFU/F71+Lp44pokdhVCNs06/XrxwuPxXDUuR0aV8g4jpZ+d57ZJI6m20dKVYcoO447IwQA9n18Yw9nWr2edWBaIXbhc8eV26sbU5QI8HiddHtqaXlu1LVeqRpt0jbqJoU1oKKdklP819WFzdtjSPGzXZ3utPLamVJW6NB1XsGh6mG96f4XinWdv5Tl3/qe/QCYwfSMi3e7Rf7ogOslRicEIiCaanU9iRg8WDJ4m5D2JDiXxtiJYaEaPNBjI+6AVyAREDvM7gsGzHCME0UQTPpkU9S9Wtea5fgfanOfxeDxN2O6TdamPLpyx/hUUAsr3v/J90xaLfaz1eDyXRZu087r5chvhAtyLbHWLb13TRiyUxQsZhZzbFeVsDI5Y7Pq+ziHfAu/A8HSnuvpffcCvo+4huvpzm5oQdWNr04btuLpUjDqHhe2Pstxe+Rxbekxduki1vzZpI1Vxo25Cd+E9y3ZPYFd+beetEihtdTDimP0PYg6/G6EjSbzfIxtIwpkhDwUyNcT7IQDJSBLEhpO3i59ndxW7H8dAiJEKmRl2P8mQiSEdSfKeKGpfnOTw6FlRv+M6tqd61R4aPB7P1dH2vmBbvWq7Sti2r5tEm/um7WfX/dfj8XiaaBMXzx7UKwtide4L19yeU5dDub6ca55a97plcU7t7mKSBD2bua7kAkKKYrHvwrOAxSFoW4xt833LmOwFDE93VhEIqmxi4tAkKKzSb1tbv0t4KP9cfq3O/msTgVyTM5vlyjYG22vVidsq1IkZjsKerai0tdzNxGhD+Me/oHfnt5jdDQgWhsWuwEgQBl58L2D0SGOEII8gHQuMEMjcoANBshugAxh/ndN7kRJMEsgN4ThicSdC5IbBVxP0yckKH4bH4/FcInUis+u45c+2hQHX/c92n3kVaPv52M5x3Us9Ho/HhlVArlm0W9XNa13o1VxwYbi2aW05lvzw8OVWqC0XH5114jbteGvxPOdTSDzXw6bFi2WbTS6DJqtt24f76sTH9nO1T5u9yjXW8s91ros2wsXytepYXM6ZtgJEdX9oV4GhFSirzSbP2f6nP6N3lHPytkTFIDOYvSFY3DbEu5JkS6BDCCcQLIr0kulbhqc/CXjy25KDHyqEMaQ7PRZvDEnHAelAEE40fPjp9bkvPB6P57KwxXjb/c12v7qs8WyKTYgsr5LjxOPx3CzW2Q3krI1ml9zZ7iXL7VPL/Vbc0nLQ77SIeLYVatfr6JjyoXa227fdMhZ7B4bn+lll0uRyHtRNxFzv1VmX6qymdas3NqeDLfXGNj7XsS57lm2cLrHmMiZpG8ivO8Pi4CiqN+cM//efMR4OSX/6HSZv9xh/UQgZKtYk2wKZwHI3Eh0JRl+BjiAbFe0cv9tHZoZ0IOidGLY/maP+wyfoJF1/3KviV/08Ho+NTa5gtXFNtolF607YV7mm6n32Uu5hPpXE4/HUIMTFuW45FnaNjU1O8AvHN6SNCIkaj0AKmLvabRhjqS2hFCarmRu7FmId5MeT+gNWiO1ewPBcLU1pH10nEm1qP5TfW75mc0/UOSVsYkJTakb1WurcHy7hoXotrjHZ2nWJGuumkbjYhBptYenGMNqQT6aof/0LdpZK8xt30Vt94tsD5rcUOhRkQwEGVGwIFqADgUpgsScIZxDMDaMHC+TPPkCnllw+j8fjuQmsG6erove6D+lXHSur9z7vkvB4PFfFhTl8TcrGUtywzYNXFTcc8U72ey+LapbIJ1OELD+D1Agutf1rTFZTr2MlIbqh7xZOlCpewPCsThuxwfUQ3/bnrrjye201Jlx/hDZxotp+nUBSPs/m0KhzVtiuw5WqUr6uJidI9VouayLY1o3huu5qoLdY4QpBIyefTOHjTxFK0e/3GO7vMvvhPYwMSUeCdCyQGchTEdkEsPurmOgvPkMfHZ8vilR3PZuatF+4mTicPR6Px7NpVqn1sKqAsom46bq3rotPF/F4PF24sDhYim9ttzS9kPZRmge6cMQqm3hxtl2rlqjtMXoyPZ8avW5MXke86ICIIkyStDrWCxivM+s+PLU5tym3tm4MmyquVfdQ7zqm7XvlY1zpLE3tNn0uZTGkLMS4BBLbz01pMmffb7AsTl3AdNYg6V4E1OQ5ZjpDT2f0HnxNP4oQUYjY3yO7vYWOFOGjI8zXTzBxTL4ULtoG87LCXv3aOLiGXVu8eOHxeKp0EZq7Tkzr7gV1x3ZhHWv1psZwoZ1l3G5YMPB4PB6oWWC01J9Y/rysU2H7+fS1Ij1jeUxDPF5BOMiPJ81zz6qgUlcY9LLEC0t/bcUL8ALG681V3LRt7oe2Y+jq7mh7jCv1o0l4aJtK0uZY1/hsaSTVMbles4kotrSZS8onXu4ccvrD+a/gnsTWjaONUFA6xmiDWcSwiOF4Ap+BUoq8Wjm5LljbqF7P6dczu54tEFcdHj5VxePxbJp1xALXPXQTzot1hIvLmDD7+OvxeNbFNqe1CRkujMbkXFwIK4urdc81m3IF27Z3rVtwrLq9m2gzzurug0FYFCzVjp1OKngB46bzqlvM1x173cN/F2dFXTvl88vn2dqyCTKuOh51aR3VPmzCg6vNVSaXdULGBjgnXtQfaFGCq7lvpZvCqluyls472/apKU/RNtbqS0ohwqBweGxtofe3MFGADiUy1WAMIs2RhxP0swNMHLfbv9vj8XjWZdX40pTq2KX/6qrjqtXtl99v4j51SfWZPB7PN5xKDBJhAHl+cV5XFTYsMUcoVcxHq8JFFdezjBDNgvUm4lx5bLbF0zap4l0dzlBfNNSCFzBuOq+yeGGjqyDTNh2j6ZhqO66CMTbhwHVMnchQG4Ask7Kq4FFXT6NOzLD93DTms+/dYsG5wkAVjDYYbZpFjE2kp9gcGXU/V28kbZwXNuFCCuTONtn3v8XJ+wMWu5LBc002EKikuGYjil1RECDTbYLFfaLDFPUXf42ezl62fe4G9IoLlB6PZ7Ns6oEd2k0iz90DOtxbXGxSKKjrr4so4cULj8ezCpUYZFyF36tuDMsxF7ZDPeujzcKezSnX4HZrug+4UkeanM+bjKdrtOUFjE3hH0SaWcU10JTOUZeW4RIYoJ17Y4lNBFi+XpdK4krnqGunfFx5bNUx16WMOAUKx/cNCClAKUQUIcfFnqQmSTDzBSbNEFKfiRhnx59iFTbapJW4B7P+8R37FEqhvvUmz//WfWZ3JUKDTEAlhrwnkKkhHUqMBJkbjCx2PknGiundgNH2Dxn9xQP04VHhyCi74zacxuPxeF5x2jjtXEXioJtYa227Ji3ysnHdu6zHelHC4/FcMR3TIqysE5ddNTmc9Sss77XZnaTsvugqJLeZ125g7usFjE3hxYtmmlI3mlJElseWUy/aCBHOSaBF0KirPdEklNhSQ6pjdk0G68QTm/BQd41NQaGjeCGCAHlrn/zNWxy+NyScabK+RIeCwdOU3r/7VVF3AhBbW7C/gx720P0ANUuQT14Uu34kyUWHRl0gX6Gg56YRYYD+rR/y/IdDdASjR5rpfYnQBgT0jnJkYjj8rmL42LDYFUQTQ+8wJzzJmLzdIxtKXvztd+i/yBj84iuyx0/95Nvj8dRTF6fbrABWv65T6POqxQuPx+P5pmITE9os7DXO7S1OClt7y7l1WyHFdg+wOUnajrPtMQ14AcOzWVZ1otgcBG3rXpRftwkOdec0ORhsYyq3XxUkbLZbl1OkfHybY2ztV8fuOsbWVwNCisJ1sbNN+t5dZvd7heMgl+hAoBXM74TM/9MfMb8tCeYGIyCcG4QGoUEHA/RPdtEhDJ/mjP/sC/JnBy/rUrSkdY2NdSndREQYkPxHv87sXkiwMMR9gQ4E/QND/0WOUYLhV1NEprkVbfHiewEyhzwGmRmENoy/XJDsRehAML8dELx/D/nswF6B2uPxeFpN/hqE36sezyrUOkx8XPR4PDeMZfH2MCh2y1jFSeESE9YZk9Hdx3R6jFCKc9utLtssF9J0uT42yQpC+fUub3puNqtMIrq4H2znNDkebP3V2Zxc/ZfFjSY3Q1XcqNa5KP+zuTBsrovqdbpED9f5defarq/JCmwLoEIi794mff8e8V6EDgXB3JBHAh1ANhDM7kiSLcHgmSaYG3rHGiNAKwjmmuGjlGiiCWeG+S3Fo//yffjNHxSFkMp9NwRwZyFMlwJcPa7jDUJIgfkbP+Dgxz3SkcBIUIvive3PY3oHKTIx6Ki4jv6zhN6RITw2jL/OSLYU8X5UDENCONOo2JCNw1InfpLu8XgqtFkA+KY5uMr3ys6ppn4a6/F4roDT+aZJs5c/r4MtlaOulkXlNdnrnR3v3H7U5vAocVZU9NyLpQW2q5qnrtCPj/weN5uwdDbVldhEW7b3XakWruOq35fpUmdieZxNkHC5SaoiSVkcqYoktnGVv6/76nKkOBBRSPKtW0zf6pOOJDIzyNwQTjQ6FGAgG0IeCcKZZvzlgv7zjP6LnMGzjN5Bgkw16VAwvS9RsWH8dc7k3SHH//XfOC9iQP1EtBrY2+YhLs+zWq4t6SynyN0dnv10hIoNKoGsLxh/nRHONMlOgJqnDB5MEbkmvjdicTsiOjaMnuT0H54QHWUsdhXTt/sgIJjlBAuNqRZD9bZpj8dT5lUTNteJYdX72krzAsdWhh6PZ7Nc5QPtTaDtYl+rtqT9+yUNTgwRhBfSTHQc29uhcFY4i3Q20fFZYeO0/B3zEd9zkass2rUqtjG2rf3Q9fpsgoTLTeHqtxz4rflkFjdHte22DpO6Why2c1zBTZ7WegBUakhGRepIvCsJFoZwZgjmMHvDsNhV5MMANc/AQD6QoIs0it6RJhvC4pYk6xdFL4U2qDu3a3c3Ka6hpcOizetVHP//Qgqmv/8dRFYU40yHgmwkSEcStTCouUZ99RT5xdeowxnBJAUBw8cJo48OkMczBp88Z/fDCToADIRHMdFBQjqSFffJDf4b83g8V89lTRrXecC3CejrUNfWqv1cdkFoj8dT8Co8I1wWq7ouutSmKCGUKlwfWVo6r0U8ru6+V33POsY14/ymYmrLMfgIfpO4KcHgutW3Olw1L1y1M9qkb7Tt09ZGm0DeRkgop6XU9d2mhoXLzeE83qH8ao0JBFlfstiVDJ9lqIUh6wvCaeGsMApkJsgGEO8o5vf7zO8EJCOJyDXZKGD4xTG7H+cMn2hGD2PCSU440zz7e++AUu5xNY21WvRoFYXZguj1iHckizuCcGpAgloUu4vEu5LFflB8ptog5jEyyZGpIXo6RUznkGZgDOrFFBWboh5GkqH7CiPpfs0ej+f1oGmFcy0RYtWJ94piQ917tdd4RfOg6nbWHo+nPR3qqX3jqM6ZL1EMNXl+3n1RlzJfPi9L7W90HWspjp+5Olztbiq10TswXkFuomCwSbraz2zuijaOgjZpK656EnXYUkBsRTjLX6vXXFd7ozq+anu2sbtSS2yiSdffrzwnOFwgtEFmkPckKtH0X2jyXuFKyPoQzMFICBZF+zqA2X2JTHKCkxQ0DJ6mjL6aoybxmatDByAH/XZjsVVorqvE76JF8BfvvAkGegfmdKtU0KEo/gWiKNT55i3E9pjsrX10pF6mhgiByTKYLxDzmOGTBJEZ8lEPrYr/U6FKN6JNr2x6PN9EXsdJcpkWdYIut/8aV19d6qVtseAmxrybNh6P5ybSlJL9TcfpXNjgjnmWOexZnQoh10/juZCO3X4eaq2XUW73ivEChmezNKV0uP5Imo51PXhW+2sSM2z1LLqM0dZftUBm+eeqK6QqbiyPcY29yeHRJZg523AV99GIJCOPBNGkcFwcvRcSzDRCQzAvhI3ec8PwWRG8krFk8rZAzWH29hjdU+hxhMiK+g/zt8acfKuHDgX9w0rQrwuAlx0cl9WlpWD2/i7qVLxWsWH8QKMSw/BxUZA06wmOv7fF/Ht3yUYh4nRHkee/vc/kp28iBv3isw4U4dMpvecL8mFAvB+S9Qrnxst+X/MHM4+nDa/TJNlGV4fZZVh5q/cs23E2Z6SrPRs2ob3rtfjUEI/nanhd5y+uGhYrIIfDeoHalgqyqfthFwf6VdLy+vw2qp7u1K3m16VndLGbuvpom/5hnQiJ+vfKjoqmcVaFjDZjdaWMlNXP8iSxTmypvlZt39ZXAxe2KjWa2Xu7RerEtjxzW8R7Cq0Ei31BeAIqKXYcScaKeE+QDw3CQLIl0WFIMCtUYyNBRwKZGYwQGAGcuRGuSL1t+BxEELDYV8gUookhGUuiqaZ3aMh7kjwUqNTQe5Gho9PCposUmfYZPM+Y3g0I37+NjHMwIHKNmibIfkAehYRzb1v2eDwr0jZObtLK61qdc90Lq++v0ue5fja9LWzF6iwkmG7bens8Hr7ZwrJ1cbPG/bsiejY77a/G3XHu5xXTdmwLq13ZZJrIBvAChufq6JLGUOeCaCNcVFMvbCkYXWthlM+te70pVcU1KWxyYFSvySZe2L5vGezOiRcAQpKOi6CabAmyEYAhWMD4ccL+L+Yc/GSH4dMMHQryXrGdanQs6L/IiY6LraZEqkEJjt/pE02L7VaL+hkC0e+f9XXpgbFF+oi8d4esJxgd5WR9QbAoCo7KpKhlEcQGkRvyvkTkYIQh3R+SbCswhmiiWdwKSQc9dADbXyTIOCPvK+a3JMOnGpZFPF/X/FGPx/PNwXaPvU7a7lDV9niPx/OS12neUt3mdPlal5092h7X6hiLw831bONKXV+Doui+KlJJLnPO3vJZ0QsYnu6s8kewSg2GVfouP+Tbjq1zXyy/b2q7CZfTo01KyPK4aju2r9X+6r5fkWwgT3fggOgE+oeGwdMUtciIbw/QCowoakQMnmb0ni9I9vv0H00xSoDmLFFNZj3UQrPYV8TbxU4m+sXh6TVfvwNDSIHeGaHS4rqXu6XoUCAyULMUHQim9wPSkUAlht6hZPAsZfAkQWSa8GCGCSTx/TGzuwGLWyHBNARg60FOMNeQl1b7XqfJgMfjcXMT48AqKR8ej+ebzevyN++alzalqdXtALJJXC53V/28dbvTphAxbogTwwsYnnquQnjo0ofLieB6rXqu7b2mdIzq+V2oqqC2tm21MZrSba5wspv3YfjYMDjIzx7qk52IdCyZvimIpqoo7vlkhpzE9Bcp8mSOCQMIFGQ5ph+yuFWIFnkkyPvwxv/8Ifl80W4Qm7jmhvONNqS3R+TRaX2P1BBOM/KeQqYakRvC45RgRxWFPZUgj0AmmvDREXp3hDieIpRkcDSl/9WAkx/scfCjEdufJ6iFAQ0mv/7A7/F4PLW0uSe3WSRoui97PJ5vLuumLVwHHevFXTimi0OjLV0+vybHeVss6XxG3wzxAryA4WniKoJOF3HDZoWyFRBzFRxrW2tjU9hqU9iEl+rP1vy7bikha2OKh3YjioKbvWcJ+TAg3QpIxhIdCEYPDbPbksFz0FGA1HPkkxeYLEMEAWZrhJgtEGnG7scJIjfMb0fc/7cz9NFxQ/8tHSsbRIfF1rCLfUk4MWSDkHCmCQ5TRG44fmeEUWCkQOQGYQzpVkB4ECI/e4RJk6L4qZKwiBn/tSS8PyaYpQhtyAYK0sr2Vq/Sjd3j8VwOmxamu0ygL3NFrUvdqqsak8fj2RyuefSrKF6AOxa32G2kqCUnUeMR+WR6fTHM5tRus9BrO77MDYrJvlyz52bQdeJWd3zXQmLlILuJQjeusZQfxl3BoW1bl4g43RLUaMPuL09QCxC6KMypA0G8I0mHgrxXuDNkZhh/MUfNEkSSFg4DpTBbI5ASehEmDFCJRsWacGIInp4UNTds1fVtjpj2g1/runUoi2KjoSAbCLK+JI8k2Shk9uYAYSheH4BMIY8E81sBOgpeXofWxWeQZcjnx0QHC/J+gDAGmRvMq3Yz93huClcp4L7qdJlobrLoZ/n7LimNF+zQN2ei7PF4LLSJx1e98LYua451udXotYkXbZ6Nqs8gdQum63KJ810vYHiujjYFMKu4fvmbCmXWnVs9x+aC2ORqWFOe2vK1G1IPoVzMU3z4KdkQsr7k5J0+yVaxA0k0MfRfaHpHxbFqniKSDJIU9ncQwwHp/R1EmqHHfZK3dsj6inQrKBwMXz9xdG75DNp+JhtYsQtmOUJDODGEM8P0LcHkTcWL70XM7iiyviA6MagY8oFgcJAzfpigDo4h1+fTQ7SBPEcsMtKtgHQYoENxfhtVj8fjaZM6eBVsqiBntQ7Vdd3X/JaqHs/lU52Plx+KN5WOfRXUOhJKBT03VZSz1ZhktxT78ldbW7bj685ZnrdqLO20SNutDx/dPVeHS3RwFdy0Hes6v20/5e/r2tioldcillQFixuqUJskYedTzeyuPEuviKaa0cOY/kFa1MQwkA/C4sE8CIrrSjPC51P09pCT7+9w8IMe8Z4iHUl6Rxozn9sDfGcnjrz4tRxsOwREow3R8xnBDKKJJpxp9v8qKxwmj3KMKtwm831JMDfF9rJbCgwvrx0K14nWIAX0IoTWyEST9yUyrtz8buD/ucfzytJm8nwTuSkCdmuxWFy8d9mEZ5sLw3U8bF7AaXqI8AKHx7M+beKtkJuf5246XjYVvizHi5p0EqHU5mJLYwyriacVZBQ2tiVHo4vu57aizRXjo7fnemhT3Xyd8225XhdyuYxb7GiLTZmsC1yXJViUH9yr/9Zk9//+CCNBaINKis9LxhkyzgnmhmBm0H2F6YeYXoiYLTCDHhhTCBsGxl/nhDPN7I5i9P9+fHHL1lWvExBBiBz0UTvbyNEQ2e+tfgP58FOMgnhLEm8rZrcLx8nkDUV0XIx58FwjNARTAwJm90LM1hAx7CO3txBRiAgDkAqUIr01QkcSHYBa5C+v/SasuHo8rxI2sbvO/npZosBlCQ03JR50ETLW7ec6RZsbOCn3eF4ZmubP1Qf+c+9d0t99nYO3qc9aN7gt3dkuYpjyTnOXQQfRooyO4+ZjZrPzL1zlPels55Z2ffoinq87toeotg9WXR7Aqsc2/exyS3QZV1Pqhq3PVSdUq2ybtO7kevkAL8W5n8tjMNpcDLAtg/DyfH10zM5nGXkkUXGxC0m6HZH3Fb3nMdGh4Pj9AbvTFCkGhQMhUEy/s0veE8jMEE5yZvdC7v3bI/Kj424TR5fKLQXy1j6T33uPxa4i2Sm2OxXaMHyq2fmzh+QPH2OW95IWfZos4/b/d8Dz39pnsS/oHRqCWCMzil1IZppglpP1FbonUAvD5M2A4x/tsfOzGDMMEXmOkQoRKEw/Yn43Ok1L0YTPp1zyrc3jeb2w1cy5bAdGGwH+pogRXajbVcR1TTfBObLEF/70eK6Wur//Nu4BKP5udYeZUVOKWpOI0SY1vbb/FvP9TcWhNiLROVdvw89d+lzBEV0UMTXrX3+Le6gXMF53XBOSVc9te2zTz137avplt/1B1lXirQvKrpX9JqGgbfsuSu2XRQsRBqBOd7c4TV8wpqi1INT58ZwJGjYRw3YNFCLG+J9/yFf/7a+x/bkhnBjyviLvCbKtkGCasfOrGZ/+ozEyEex9oOm/yAlPMoKpIN4LSLcU27+aws8/bBfYmio9hwH57/yIZz8akA0KoWH4WKNDiLclx+8ppve/xc6n9xn+yUfo6bxeyDgVcYw26F99xuI/uYUOIZxpouMco4pdR2RmCCYp4fMZpheSbkWMH2ZM3gjI98fI4zn0oqJwqZKkt0aMv5iRDwOSrRAePPYTbI9nU9jS82zOC5v7btP9t3mvyaK8PKZN+5vEtpjQNnd9U2O0pVa2PreUn+7xeK6X8hyzxQO1UApjdLe43JSuAhfHcDavdBSOX7bb+Dyi66/RNp5ORZUrzvF1RKJVdqKy3Vdtx1WbUAoRBkWK+Dq0XADwAobn+ui6StVWOW0bjFwq7qZWlOomVV3atwkXSiEHfbi9z9M/vE+yLXj7n36BOTouai/k+qWgcXqdJs8RlFIYbFRvNKfoyZQ3/tWE4/eHBAryvkArQd6TiEwRzFJu/9yglWHriwUizUl3e2gl0IEgnGrEv/+wnbXuws2m8nYYkPyd3+D5jyJUYpCpIVgYVKwRUzBCkBqIjg2zuwHpH/2IcJoz/JcfFpWh665dSEya8eY/O+Dhf7xPOpLIHEafT5CzhGx3WPx+SIlRApnkCG0I54qjH2wxfNQnejJl/s4WQsPgy2OynT55KOk/W1y0572qK7Uez3WzilW460S1qc+ulJ0hbfq+CneDy3VR9/Nl0/W6r2C1z+PxtMQ1f3M5fbPU+vrF82sWFcsxwLVA54oT5b//6tcm4eAy6ujYHOoXjnE8X1zbtq0Sk6Xt/y9Pz2ktAlnwNTA8m6dVQR9H6kodbSZatj5cq291KSauPlcJVuvUoyiliQgpztpR+3sc//0f8uF/d4/sv3rBybdz8rs7iO0teOMu4v4dCEMQAhFFiEG/+BoEL9tpopTzZ7RB/NkvGX2dMLsTgIFkSyAyQ7wfcPSdIcmWQCUGHUnyUYhWgmRbMXiW0v/nv6gPbNXPpyZthN/4HsfvhvQPDL1Dg0ygd5CiFsVYo4kmOjHkveL/MesLpvcCDv+zHxO8eb9VfQzzwa9QC0MeQR4KdBSweGsbc3ptRgiyYcj0rT6zexH61OmiFhn5Th+ZFGM5+vEuyU5EuhWgPvj88nMjPZ7XhXUeODuv8DekFnaJ7WcFhmsEl7p70GVxnWkg152C4sULj2czVB6sz+Zb1YdVW+24pjjrXMDU59ts65Iuv1buuxp/bSnp5b7r+iwf0zSmtu67uof9VQWVNuJO3XE1i46t+jS6+F3pgHdgeDaPSyCwHbOpvqrU5evWHVcNIBfEjxX+SFfBkS6CLASJ7Ft3ePBfZDBXbP8P27z5i68xkyn6zTvM3t0mPMmIDg4xSQpBgOhFiDBEn0wKd0aXSgxLESMH9cc/5/bPt5n+wfdIdgTzOADRqiKpAAAgAElEQVQByVgQzA3pSIKIULEmG0i2PzyB//Axukm8sH1vQd2+xeOfbiGyQqiQmSGcQzZS9J4niNyge4rBo5xsFBDvBQRzgw4FWV/w9O+/w+0/6aE//eJlSontWrXkjf/tc1787XcwCrKtkGwoicOAbCCBPtGJxkiKOh+pQcUGDAitAUW8q8ij4v9u58+fkh9Pzt/c/aTZ47k6bGL2plbeO9mDLbsQtU2x3MSDfp2L8bqFBNf/h23C3mXFrtHi7R0YHs/GKM1zzs2zyvOfsthQLZDZdYGz2q4tVizfr3IhHaTGJeca0zquh1XOrU1P3+T2rWWBocX9oc2uTxt0iHgBw3O5dJkYrGvvdbVlUzXbFC61TRrXFS/a/gFXhRIhEf0eIgqL3S2AW/8qYv8vZ4QPD4pDBgO0UqRDSe9AF+4LJc+KSYpMIRYLTJYhjMDoFfKGjSY/Ombwf/yM4T8LEKMhIgwx+zss3t4mj4pUCXU0h0fP0Ccnza4DR9rKshjQ8quMQg7/8H10CMEC+gcJ8W7h9FCJQeQGYQzBUUy+HRFOUoJpRjYKyPsB4vS/88XfvMvewSH5i6Paa8++fszW57d5/msj+lIgcohvS6KJIesLsoEAw1kKi8wMi3s95vsKI2FwoDECtj8+QX/2lb2T635g8HheF5z24yt+eLVOsDuklFxor0UMqRY2XbWdq8CWyul68GiL7R7j62V4PJvBWTNnRVcCdHx2aJmyUieErhKXz8Wohgd8Wy2Q5dirzytN9feqKTGXUbzYJrRfMl0dyl7A8KxOq2I3K04M6yZYda6L5ftNK1uugmFNxd4cgVJIAUqdWaBMnkPuqDfRJthUxYsw4OAf/TpH34XBE8Hwcc6df/MCOZ1jRgNOfrjHs99QvPdPD9j+1QlylhRtKAVRiBn2EJPFZtwjp6q6yXNYbsv05BnhB7DcZTovHdu17eUYl5/dUsTgh9/GSBg/ylFzTTYIyHsSFRdOiPkb/WKnkElOOlbEO/1i21fDmRNCZoZ0KJj93ncY/PEH6OnMPs7lOP70L7l79G1e/OYtoomm/6LYQjUPC0HDqKLtrC+IJgYdwPRNQXQM8pFh/0+/In/81J4+c1MeGDye14W64pRN95U2tKkA32TVXVVQKZ+7SkpK9bxNuj5W4cI1bGiS7p0YHs/lcTp3OtuNwvH+2ffVn8u0+Xu0ndumoL6tbsY6O3Y0HreBWhUuweKqxNh1XXobHqcXMDyrc9U3+iYLsMt14TredmzHaxKnxTT1d77F0Y+2yHoCoaF/mLP180foR08wWXYxkLcMlEIKkAK5s82Tv5Xz+7/xMZ+f7HH4x/eJTrYYfJKS3hrx1R8Z3v32Q45/eY/h1zHZVo/e8RQz3CLbG6FOFpBmUFI4nTcY22dRV5UYWrpKWgY/i0gkgoAXv74NgJprhIHZHUUyFowfwWKnEI7yPoRTSTIWRdrIUBCeAAJUYohOoH+omd0JyP7ox2z/Px+8TO1wiBj5h5+w+/kDst/5Acfv9pFp8bnooGhXGBg8y5GJITpM2P0gQz18Tn7wgizNmq/X4/GsRtcJ1Sq1L6yvO+L3upPUVR6g6+5fm1hAuKrUEtdq5pkw03G10fVgU2u/vgFpNB7Pq8zp35jRDSJG+Xgodq9Is9Xdaa62XY4LW2FP27mrusiXY7e93yQoW+ejDkf4VTrJXAL5Rtqu7hzT/Ll7AcOzWdZdwWhj2ar7uYkuxzeMRYQB6d/+dV58L8IEgujYIAzI3DC9r5jee4vR4/uM/8WH6Mm0s4ghlEKoUxeFLP64j9M+ANlPJzz8KYT//h6Dx4bwAPT7ghc/VDz8BwFo+M4/uc+n/zCC2zFv/y97jH8ROzpyjKPOcr0pWtp5xXjE/I4kOiw+YxXnyCzASMFiR6ED2P48YX4nJB0J9j5KCCYJOlIIA09+e0g6FKgYVGwQeVHcc/b732f4rz8qRAwbpyKGXsTIf/kX7P2bADkewd4OYpGAMZgkxSwWmCQ5c91klfOv/Ebj8bwObDQWWVx7VtH8kv+WN+ECWOX8q4j3Zercj9X/C1s6Sdu6GNXVXhdlV6bH41mNkpPBWmfMlrJhNCbNiu1Us6pDo+bvsVGQ7Jh6tun6di4neaNz3SHCnMbAs89p+X71nMukq4hRl6JTpeM1+F1IPJvlOiZeNuostBs4T0hB/ns/5tlv9BAGtj/PGD5OGT7JiCaa3mFxHdN7isf/zY9R9+6+LMZ5viHra0Ip+Mn3OP6Hv4kYj0BKgkOFNoJQapKjHr1eSvZbJxx9H8ITweH/+QYA/a0YOQl4/qM+w/eO2d+b8uj3FIvv3IEwQAjRLVDXVWHuKghdON8yqbSl6PT7xW4jJ5o8kojMkA4ERkE4N/SONf2vJ+x8PGH8MCscFycLwoMZwdMT7v/JMTIDDOhQIHNDNNGYQDD7W99H3dq32A6Xk+eX4zNpRv7iiPyTL8gePiL7+jH58wP0dIZJG5w2V1H81eN5nbiKh83L7ONKCkK3vPfZVg+bcrHXoc24lmOwOidLcdW2q4FrlXUT4/J4PPVYdxmRtX+TJs9Zpp+8PK/m7/EyHtqNvjhXv+qYcE5EL4kXy/TqckpykzB7GdQVW3Zhm+ef24GlJrXSgXdgfNN5HXI6XbnDdTnF1VoYrtUfxx+PHA559v0+wcygI0E6kowPEmScke700IFgcGAIZprFvuL5332HW/8sJ3/+4tReVx7nRWVS7mzx0X8fcXvvGeaj28zvjzCB4a/++k3ETLH1uSLdC0jjgCCHcArJDiTbBr4YMf5KkuyC/vkuJwKyLc3j3+nxzuc7sIhPdyKhOY2k/HnYPrsmNbZLkaPyZ1EJhCZNyUaQDiXBLOPwuwPyHmQjENowfLgg3RsQHswY/dUJeqcQfTAGkWboXsDgmSaPxKkTw5Bsnd4MpGDxR99h73+dohfxBbW7OKhBhHAVZyoHae/A8Hg2z6Ytrbb7yLn+Nvh3fBUxoZP9ukOa33WwSvriZeW0ezye/7+9N+2xJUnv+34RkZlnqb3u2vvCmW6aoyFmRjRlUpAsgYIgQbAhv/YXsL+QF8CAIdiwYcAGZNOWTdC0JY5ocedwmuT0TE/3dM90992qbm1nyyUi/CKr6p7KysyTZ6s6VfX8gItblSeXyDyVTz75j2e5zCRxs6o+xfhEkSvWErqiKLjTfXrnl2fjZrAvypjLY5omsmFRlHVrGce7y2OdlMJTRYPrJFOCt53reBgvS62sCjet6jJSrI0xXoW9bNsp8n7V/V1sqNAp5+0zR/cj0s0WNtL0Hxm8VkRHKcHQk2woXv7D9zCvP2o2e6U0QZhhnWb0qEvns5e09jXhWorKFK0Dz+iohTae5FFG+I/3iI7g3kcQ9BUn7zrav7FHsu1oHUDn3ROyDhCF5b2Wm4yprqhbVYTGpTzmqvVK2muN7/7oGDOCrJNHUET93PjZCPAweK2NTiw+CnLRoj8iebAGSYrvtNCJJe0qRvcU3Wd5tIwzinhT50JIW8E338mV9yYqcp2aXJz5qzPW4iwLwmyU2fNF73vu/TSz9Us7/qxc9/GraCKAS6SbIFw/k+oBFQt4QvPJnrqCnfNQd/xrtIne2svX6jpE5IpjquC0fL/Sr8Z6+vul/xtEXF88ZrWPLBEYws1hUrHNaTuiFKMHir9XzMIpY0gfbRH283oMZKA8DHcNWUfz4juKYATRicK2Da3DDK8DgpHn2T96k4f/so87Oq6NwvCjEdEfbfDyuwH7/7HB7GyQnaToJx185Bntaj547ylbrSF/+oNvAHkay9rPjgkHW+z9qubD3Rd8lAX07rV4f+uYn30zpPfBNhuDETx5NtYqpAFlUSp1RT6LyydV2J8Q4eCSlM6e4/gdTfeFor2fgg8ZPja091OCfkr/rS5B39IZJnB4TGsYg1L4MEAfD2kfdenueaKjBK/zNBJtQVkIRp7972xz75MIP4rrVe1i0adxJXxaNXxVXxQEYdW5LQUXVykya5WvZ5Pc6woBfKpjCIIwPcViu5Xr1YgPZfVtZqlzUcck364Y2bBK9cvKrsk1jU1FUV73bXyZMXndk6rrVra8LnVkgr0XAUOYncqX0SlnlcsEg6pjTUqJKft8giBxiUlpD1qRrQW0Thw68SSbGp15lFckG4ruM8X2Jxmt/Zjha22CgaN1kOEijfKQffgW+s8+RmEvixjkaR2qFZF1wfVCFPBw9xh24cmzbaJOymjX8LM/fgsUPP6B50XvHg9+sgfP94kerxO/bsm8JjSWdjfh2ck6PGnz/LsaeMzai/3qkLSq61q8Pk2LvtWl61zYrt7x3PlXP+L4P/8Wx28ZWhuadF0RDGB0L6TjPWtf9HBRANaiggACkx8rs9idNZI1TThwDB+1Ud4TnThMrHIRw3nSewa9s4178qx2HJcYf5DI7J8gXB3LFjHm2fe8tqDJc3HR1EXZ3RTmcehviygmCKvCmF+ZpyyP/W5MXs+hIFhc6EjSVMhoOpZJlEU6zNKRZNHUCSpXJbKMHcePddg7q8nhx7ocNpoArOJCmnr1dybetjA7897IZekek441bZTF+PLi8Yr7LL6YVzgzSilM7FDW034+ZOOLEaNtzfCBIusoHv75kLVPD9CZY/0nRwweBti2QWcek3h6b3XQG+sX93mhaJHGxwndJx7T07ReGOx/95Cvv9plbXNE3I94tHsMCr7xL/bY/uFL3vmdGNUbojbWaf/sJaab0UtbDEYR7+wekGWG7R8pXMuTtV/d9qVFJ6dhmqrtTSov1xg3e9zjnf/5KVkXkk1FdOJZ/9LRf2Ty9qa9mPDZERiDu7eJ77bxYa7Rxg/aRH1H6zAj6yjiDYMLcvGi/Tym+0Ufk0Lvu2+iwoa6bplgsSpKvSAI8zHvi2xZiPRNYJXrZi1TXFjVcxaEW8KF9AJevfgWZ+T9MtrPT/OSX5f+smyBc5JwfSb+nKVtjC1b+rOmSXTNaR2MxumTdSmU3oOrDhW/YU9W4VYxb7vVqmVVEQB1NRrOfm4YUaLjDBcokt02tmUIRp6tzywP/2xA+KKP3WijjwaoUczunx+gU8fgYYCJPS4A/+ajPErg7BCnQoLSCnXaKeTR//kF7mHCg994wot/EvP49QPW2zEMDc9/8AgPfP2PHvD5f3Kf4DBvkZo93sZ3W9jjiE+ePCSNA47iNsOXHbY/jdn6CWx+2sdnubp9qdryNIV1yiIxip8XU3TqaJC/bD/9gte/P8C283oYJvZ09xxew/O/94D47V3ShxvYtRbDtzbxUUj6eIvhboBXYNuatScJWz8d0HkWo1OPch67HuEVZB114XuZON7x/wVBuHoW/eK5kA4bU9S+KMsBv7DsGiIC6uoVXSd1HbHmpS6qUBCEydSlBzelSmiYY3JIRdGF7UvrwBXHUPv5FdmJsm4kZ7+eiT91dTGW5ZtO2G9RqCqvKTJ/cXvxvIWbSZ3QME07uLK6GmXRGRc28XkaSTvvPnL4jYjo2LH+eQ89SLHrLXxoUGmGb7dQcULn0312/2yfta9jkk3F3ve2UJ1OeWtVgDCAMODxv4roJyF/9xuf8s/f/CGhdux8ZHj932ToDNr/9DnplgcNPknQo1y5fvv/gOijLv4w4usvd3n/f3KEf/xjHvyvP0Z99AnYClWzSkQohhaXCRVV6579PCmKplFomcP84V+x/anFjGDwUBP2LN0XGSaG/V9p03urhQ80ynr639hk71c7uBCUB5V5guOY4GUf009p7cfEuy3SzYDOS0vW1qhud/I4zsZ7U2dZBeG2sMiCm3WiwjhNosnGt52mvVzVsqui2GVqlVjWmFZNqBGEm8gi7s2qGhmn9jl49+3JAkRxl4VaDb7o/463Yi7W37jqiapJtqg4pkXWB2lKky4iZTTtytcw3V9qYAirx6JDWIs1GOqOU1anoWQsynpMCsqBsqC8R2UOvMeHGj1I8YFBn/TBeXynheoNCeOU7bWA47dC1FoXen2K1TS9tag0A6UY7mrM/3aPH2X3+P7f+WUevf2Sb/ynP+Gzf/EBb/x+ys/fXycYKp78/S3e+O+foz7/CsKItS++Zu3fBfDoPurlEXbvJd47fBy/Os6k9qlVVIkRVde54hpOzalQ4J1n7bf/gpP/7NdwEWRdTXsvZef5iGw9JN4JGTyO8FqhnCfseWwbvIb2Vz30UY/knfsExyOybpvRrqGzl+E1BLFHrXdh/2XDa9GwJZQgCKtP0yJjdY561fZN9jupoNmqcV0F7hYpYqzidRWEu06xMPrp79kXX85ncybZ3aoX7EvRDddsk1epuGhTJl3TIhPsvEwbCqtHlVG41Au6oq1q1XZl4kXxs7IX88K+fZqBc5jE4Q1sfJXR+aqPPhmieyNML0alFsIA327l6u/LQ9zOOniPTh3phsK+tguFCAzvfC54ZBn+8BgXQfLPDhn+R8e0ngXs/c19Mqc5eRvan+3j9lps/O09Tt63oBVuOMKfnOCGI9zRCe7Hn2Jf7F0OP5tVvJioDlcU6qxLNbk4sOplYwq4t5bX/8cfoxykXU3vzQjbDsg6hvZ+wtrXMWtPYzY+H6Bt3sZ27cshynuyN3Yxp5EqyVaQF/BcN/ReMyRrCrfWGRv3hLSWWR8g4jQLwmJY5L00PrNVvPcnhhWXOL5l3YlmnclbtWiI60TspyDcHcpa1M+yj2L0QtEW1xayn5zivHTKrsO0Y6o7/1n2s2imsO0iYAg3gzLnbZ7ikeMdTcrCUsdzgC+JGw7z1V5eBDL1BL2UbKOFb4W4bhvSDAJNttUhfbCO6rRBafTzA3ynxcEHLZJtePobG+iN9dI6FN5afJbxxv/+hJOvN+hEKfEbCeatAX/xyTvc/8jDwRFv/a4n/n/u8+F/c4w/Os7FD+vyFJESQ+ydvyBeVKawXMirK3R/qbvudZEZ49e2Kse6tKBP+UPFvjyk8zwvphoMPaP7EcHQYo4Tso7B9BLSjYjhPY1ycPjBGtlmG3MSowcJ3hj6jw3De6fdXzxoC9l2++Jxl6Fyy8uIICyGRd1L492EylrUzZLLXWZDmuznuh3lxs/WinBvQRDuHosWFif5X3U2p0p8PisyWXW8s/ULgkelr7xsLkUzF4SLmSfR5vRtZ9xWt1rnP18oRDrLvubaWhCuikmFu6Ztf1aMBijm/ZalQIxtY/cP8FqRbGgOP+hgWxqUQnmPX2vz4t/f4uTdDifvtnFba7C9AWGI3WyjLHS/9igHw197v7xopLX5v6Mev/xfHLP2X26x+ychW+tDSDVbf32AT1K6v/dXvPFf/yX+489y4QIqhQuYwwjXtj+tiYwp20fxel8caMUxykWM3T96xuieJu1qgqEjOElI7rWJjhKU9YRHI9afOJQFG4KPNNlmGzKbp/qknvZLj049ZgQuABeZi8ddJKtYGE8QbjLLKOI5aSaubNnEkOMKW1LMsb6JocFws8a8zGKggiAsnhJRobb+WEnqXvD642aix1k3jfByof3rQBlD8PgRut0qjxqZhkWJzjNu65K8ba4yBvP6o8uTpef7n/yuIgKGcHuY1hmpqn/R4Cby1hL2LTZUtI4dx+9FJA/X8UaR7HaITvJ9tA8sxx9s4tfa2PtbHP1Sl/aBY+uzhLUnFttWqPfeKjWUPs0gjtH7h6z94Cse/f4evX/3gDd/R8HTF5CmeaRGksKZca0QL86EizIjPFHUGI9QaSpWXBpERfRGVdXqspeBEsfeP9vDK9DWM3gQkOy2CQYZ2VrI8QeboBRrX43Y/IVl+FAx2o3QmYMwwLUCki1F6zj/Lk3i0emEcSwCib4QhNVk1tDcKqdw3MGucrbHoz1uYmejadJsFskiu5iJTRaE1aDKRo7/49XsvdKqWlQuiMLZ10/PI5ybCMyX2rnWRW8sE2NI37vYufDaI/nmOf7pd2C/fjb2/JtOvAAp4incBZoU26kq8FlTq2HtL79m8Ftv47UCBwcftNj5CdiWJllXeZ2LlsJGkHxvi2RTsf1pRtjLUJlHZ55403DyWw94/WSAffYiv7FP0zyUdrg4RlmbCxz9Pu/+Vy8hy/CjOI+4aPiCXRQuJgkaF5YXU0gu7LikcOekWiOzFD86Ey8KBtEnCTqDeFNhEoi3DC5UtJ8NSd5r0X97jbCXC02dPc/z72keqi6tlyHxboiy0HqZ5l1cTICNoPXzlzit8NXtp2dDZvsE4WYwbWX3aXK0i07dtIXNVo150mxmOt6cdlTssCAsn1kjyYp+XlEcPrWxZ/7ZhY4i435i4X9lzOXuI1XjrhmXd35sv1dTyNMnCfqP/xrr/HTPi0nXv6rA9CRK6z2VRGlPKJh63gp2BvECJAJDWFVmmSFp0ip1fNl4VMEMXTPs02d09zKSNUX70LH5RUrQSwhGFmUh68DJ24pkK//nAlDWYyNNcDwCoHVsaR04nv3Tt9HbWyUHySMs3HCUixa9fv5zjXjRpM5FcZ3iZ6cbXrweZde3rEDqhZ1NqInR9AFQNXtpLTrzhH1QDlyoUJnHhYbNnyf4001cCGYEJlHsfdvw9D9oM9zVbHzpUNZhW4Zg5AliD8/3Xz2kys5lHkqvoZhhQZiL634pHauSf86kHOWybeasyr5QrjLN4iq/P4m+EITroWnhyLJIuEnFN8ui18ai2y74tWXrl0R5XNjHMmuiTcL7C1EjulWSSgLnQk0jxrafKrW8eB3K6gTWHGuRiOcsrCaztOEsSwlpsn7xhbrqRb2wf+88az98QjjwuFDhTb5O+HLI9mcjNj93tPfydZMt8Ab2vxViO5pso4VOPeGJJernhuDoH7yP7nZRWp1HQfgzxfW0qGexQOfZOudpJ2OiRNmyS6dVZbhKldMJQtDZdapyEOsiOCaNoWbWMux50nXI2mASj9eKdDMk2QrQqccrUBbibUUwgNYBtPc8tqXQmSfrBthIYyNFZ8/ihqPFP6jKznPeIkyCICyfps5XRZTYJcpsyyqLmFfxgj9NKuIixyPihSAslrFi9zPbtbqItqJfOOkYRVF52tSHurS/a8LFcf5DUdQ5S4+ZgtrIlGnPvcKems31qcbUlBV+ago3kmU5F7Psdxpnp/jiXfcifr5/h336nO0f7qPTvAbDy29v0n9vg97rLfDQfWEJTzw6gWCY/wtPLP032vQf5Rlcna+HdPZdnm7yK+++ClM7P8wrkcJbe0m0GF/v0iWYUHio8vNxQ18l6pRdm7IZuyYC0bScGlbvPLt/8oJ0TbH23NF5GqNt3hZ1uKNBgU7zgqkm8URHHm/yaI3oOB/X8EHIaMegM2j/wce5MS9GnyzCcW5asFQQhNVhGoe3Lpqi6DxPKha6CjRpfX1VNOlwNc1+BEFYPBdsRkmEWRN7V7KOWV+rF0WK+66YIDK7O+WRFpOKgZ4du2kUybLx7lX9j7rrWtONBZgseCzgXO3RcfkHc0b4SQ0MYbEs0jmYN+1gfL26barqNJx9Vnb8s2FlKe6nX7C21SH5cA2deUbbeQhX2He0X2ZExwr3pcYH0NpLSLYj0jXF4LHCtiK6LwJ05jExZN2Q1voa7uRkovjQhEv1LKbZ5pLDXVLHonjtisvHt62tKVIhEDRQ8d3PfkEwfMRwR2OGIWEvI34zZPC6Il0PuPfXlvZ+CoRo61FOY2KPCxTxhibrgk7g/v/7C7L+4NVxy8Y+q5AmCMJyWfTs/CTG7WNTR7hgU3NbW5G3XTzGdVBm41eJaccktlgQlkuxw9yC7Jc9Obm4v6oI1tNCmxdrVbyyo/bg6PLyMptbEKWVVq8mt64pjaRo7y6JD2VjmySk1x5zUg2NksnKaQv7n49r+ufLCshIwo1kVmemSSvOafdd1SFjmpma4kvqeP7v2bKK6AGfpZiPv6Dz0pK1FcpBOPDoDHTmaH/Vo/NsSOsgPd/++H2w7TyNYXhP47XChYp4N4DXHuRDqslLa5qztvDWT8VZsLL/J4lFTZY14LwQqbW89rvPSLYV8bYhvhfiQsCD8nmHkmCQ0T7IMKN8XIcfKl7+LYh3FJtfZDz8X/4mr1ANJQ+AwgN5GubZVhCE1aWutsU4EyqxX3Kgr7oo5iQWJV7MKh7UphlOkVq6AIdZEIQGNI58btDBqEnERbG4+1nqdVObeip61KVMXPClryMC41JE+IR6S3XdXBZBaVp0PsaFdmqpudYiYAizsWhnpC7aok6YGP991pfFS4px4fcG+7PHPdY/egr+rBaDw4wc8U5I/Po6ZI7w6QnB0RAfgBkpVKbwBpJtxclbhmQ9P87ozU04U5BrmKrwzhQ0Fj3K2qsWo14mFfkc/6ym48ukcbrPvuDhn48Y7WjiDUMwhI0vPO19h9cKnVi8gqyj8BqSXUd0nHeFaf/eD7HHvXLjPk+4sogXgnB3qAotHp/NK7NlZaklZT/D9UYQzHvsOjtYt+95K/1fUacAQRCmpCrqoWydIuP2dnw/xboQdWLDeFrI+Ev3eFpGMTpjfLur5NJ7T0Wh0bplyxpLYXltWsoCC0NLColw9UzjUFxVjmuZiDHlzJP98ms2f/GQo/dCspZGG0+8qekAaqeN6QTYdkDW1rjIE/QVWQe8gejQk2wrTKwJhg6lFHVncfbyPkuKSGMa5SpWRGKM/1xXH2P88yqKRrnEIHvnCb7/Q+67b/P01zsEfVDOEwwVyVZA1jEkmxqT5JExu3+h2f14gP7TH13u9V0c/yyIwywIV8t1C4V1aR91tnSaz5oIwstg2akk03QQmxaxxYJwvZTZxLL0jWXtr/CZjsJXhTBP8Wl22b88Sx85m1AsFQ2WLJCO73+S/a2ILsn3s4DUlyb2f8HPCLO+VvmZRGAIV8+sN/usqSXTMp4yMoVa6J2n/cef0Dry6CzfJog9NlScvBVx/F4H285fojvPFOm6J9vwdF54+m+CDSHZVJihy7uNNDzmlVFnmCbNrk2TUnJp+8mFmfJFHgdj3CQAACAASURBVPMHH/H2//A5JvXYjiLdUAzua3pvGEbbmv5jAx4e/uFL9B//zauHVunM6IQiroIgrA6r8qLapJha2WdNuhJd1zlOEY1YSl1h56rfFzHJMc9zRxCExVAVIVB8qZ7mBbsYXVGWLlIxDhfH1WkXxfFcR7RFkRJ7pTudsc8XOL6ygtTjLGPyucYen9c+KUEiMISbQ1kOa92yaW+guuiBiWPLjZw97rHzb39B8ksPiXdCdN/nBSNDhVcQDCzRYUIwiHBRSNrNIzDu/9DijGLwSBMM0mazckswqucRHVUv9FURFFVFVpt8R/M4k4WHi3ee7Mkz7v+3z9HdLrzxiPj1TVygCEaW6KfPsHv72LOoi8o89pLzbDrWVXmREoS7wryFdq+CWaMwzteZ4bm2KOZNh5skBs/b7aT4vYsNFoTroXBvX2jTOU1kWh3FlJFpogzK0k7Ofq9IETkff3Hbq7AzFYUy3XB4ed2ydMSisFPXKYuzd4AFFyqd9PyY8bktAoZwc6l6yTyj6Qv3+HZzVdXNb/js66dEWYZ6/zEn73ZIu4CH9pFFZfk6KnNsf5Jx9H5AZy9v/zl83EJlEHz+jKwuRaSqbdKk6vfFn8tWbdpDelLERVn0SlVES9O0kmLVaCg32ORChu314cefEfz41cfZ+L6qxl4cR1HYmsbQrnIFf0G4LYzfYzeh9sxUleAbPNOuilW2ZU0mOARBWA4V91tjn7LRMSbUyGhQWPm8+LsrvNxPm/oHq2Njyvz6YirM2Lnqbhc3GJR+XjqBOUs0RakPP0MKeQ0iYAi3h6ooiknrVs3czHFjZc/3MMcnbMXvcfThBjr19B8F6N2AZFPRfunwGsKTPMUk2Y7IWortz1Ls/sGr4UyTItJ0hm8eZbVpWs24iFFcdvZz2b4r91d40IwvO9++XlmeSNWYp91HkVV1+AXhNjJLEedF3aNVNq64zNtXy+sElzKbdJ0s+jot47ymTP0UBGFBNLEPpy/LpXUlSta7wKR0jjph+NTmXBJU3Nnv09QtGrPZq2Kfy65Nhd98QbwYX6/4M8wXEVdMx6+jSQplAamBIdwepsnNKjqaVdECTajIxXOjGP7yx+z8zk9Y+3KEziDeVoT9vH1quq5IthW2BYOHhs3PhrT/9UeTb+BFhnY1pZjyUdZ9pGqb4rKyF4YmqT/jBq5OaZ/1+kz6zuv+Xs6WC4JwNZzZobJOVdPuZxGM26+mNR3KxNI6u3LdNqapMDCpLsUyI9PmHZ8gCM2YpgD7Gaf+mQqC+nabdR2bvHvVha9q4qpJennRthb/XRqTL9/mqqk65qSJyqprevZjFI352SXvRNOMre55WLrd9H67RGAIq0lTAaFJmkjVOk22u/R5TUeMiu4Y9uAI9UdH7Px5gHn4gOy1HVxksN0AZT2tL4/gyXPcYIBrEnExKfy4eN5lodV1zmOlcVxAhELVdouIfJnGABbPv6nTO+nvQxCE5bHq99y8s3GrJFbMw/gzp/jzKtSqWPW/I0G4KVT5yRMmk1yS5iLEpNafxfoWp/9fqksxaVx14kUVq54yNz62SbVAGqTX+CSpP96ymVLEEAFDuB4mOXrTRFNMWl45o18jfjThrMWSVrma3G6h1tYgMGAd7uAQH8fnaSA+zci+egJfPUHzKvxp6gzBaXOnxw3d+P9Nzn1SEc4ylhVSt8jIk1md6GlfMFb5ASgIN4myl+JVYpF2b9XFi2kF8GleGq6CMmFFEITJnPuQdekaDdqjepdn0in9qi7F6e8Xj5d/Pp76cZ5+MrbOhWNXjXvWdIgqrjt95IIdmzNN/LrOY8KEoArCyk1FwBCuh6u+WYqGpi4qo6Ezo7TKi+F88y2O318HpTCJQ1mwkQL1Jp0XCeEPP8f1+s2LGc2b5wf1wsM0wk3Z9ZgkCM0TObNsZ7LsmtRx3Q8oQRBuxgtmnW29jTR17FftehTF65vwtyUIq8K5nWtQu2KCiGE2NrBF37gsCkNplCFfz7vyLhlN/OJFcx227VI9JV++vLj+2WdVEdnXgTYF4aXsfaP670cEDOF6uOqbpnizlqUDTHJmxnPFtMLcv8fgO28TbxmCkSM6TrEtgwsV7f0UgGQzhF99F3OcoH/yOW44mjzWqrzBMyV6UprJpCiKMsM1TURMlRAyayRD2VgX6WTWpQpNGvO00Sd1+1lm3rcgCMKqsGqixTiTHH5BEKop8V/OW6UWu8RNEDnsyUn1cS682Bb83kn1HS7US7tl93cxFW+SD16Xrl21zVVRbEdb8rdVN/ErRTxvK6v+krSMm6bJOVfd7JNmzwrihf7gfY5/810GDwO8gfbzmPDFgGCYEfQtKPBG4Q3YliF50MF+55uYzfVm53KWP3j2T2mCd99i+E++h9nZqt7uQk5cidI6/lmd4asTEOpSUyYxab1pIkOqfi47l7KCf7MU/5s3BHHV70tBWHWu8x6qiipY1WiDRXEb7VbVs+Y2nqsgLIrS+0a/CvUvq39RUuhet1rND1nsVlIXoXy6/2spdn+VNIkoX3WK/vrZ7w3PRQSM28pN/GOel6apC8WX2Gm2B8yD+xx9awdlPTr1RCcOZR3Ke1Ti6L0RMXwQka4bosOM8DgB50nXA9wvvYnutEvGXhAsLoz5NPLCaDrPhvi6KI7xm79JnnJTZ61qX5Mc92mdwToHcty4FSNpxsc4yzGvgrKXnrt4nwrCtNSmK1yBG1O0l6tQiPKquQsv93fluxSEBeKtrZ0pV+HlYH+XpFMcYIoWp3A99/FV28ZFP4PKJvmukwZihggYwt2ieFNMeePrdouj33yH0Y7GtjRrTxLaz4boxOI6IclORLytcIY8EgNQqQWtcKHGdiP0xvqrFlBwMeSudMynxvrFPuqvP83bs5adF1wWZ6pSR8aZFOFQt6xuH2XrNKlB0eQ7qYoqWXXKjLI4zYIwO1cx0zYuko4/O+7KvTvlzFgtZVFw00byLZO78p0KwqzUphtfnoDzaTZ5vbH156boF16FXbnqlPhZjjdub7UpFyyK7xKrYJMrkBoYwvUyKfRp1UKjvvkOLlC0Dxw6AzNIMf2EbLvD4HGLsGd57fuHqN4QgOzRFi4KwHlcpMi6hqjTPjXSdrJ4cYq3FtcfnhcxuvhhSXREVW2LJqkj86ZJVC1vmp9XrM1RXG8ZBvUuzqgKgjCZacVc4TJlNruJkC4IwupxQSC43DXkUiHO05QRF5dMvhUp62BSVlOjyu8tq9F2W23LNM+hpsUxi4U1VxiJwBCul2mLKMJijVFx5qfU0XrVLvXlr26f17dQ3uMiQ/xonWQ7ZLSj8y4kwwSVWVRmCZ8colNLdDAi6FtsR+M2u5f2ff5zMVdwDJ+l5eLF+M9Vs/uLLFi27BSNWSI9qq5j1TUtLZTaQNW+rQ9CQVhVrnsWqOz41z2mVWeaqIomUXmCIKwGVS/CVSnQp7+Xihfjvtn4/2X7KE72jacRl/m8EuVaSAupfrd4tX5FJ5cVtckSgSHcPBZpjIpKbek6ueHUGxvYFkQ9jwsVgwcGHYckmwYU4EGP8nQRHxgwBoxG92OGb2+RdU/XA9AK6rqqlhmSOuNSF4VR/HkeytTtScwa6na2bVNHWGmUMagoRHXa+bbW4pMUn2Z5j3Eof8ie7f+uPugEYVWpq+VzlYzbB7ETl2kSZdF0O0EQVpMqe1zpnzZcPi6EFAp+XigMeiHCQ3y2S9TZ07J3ivHPmnSQWSFEwBBecVeMQTEaoS5iYewGd++/fhp9AVt/uUf6cIP4Xkg4cJihZeuv+qg0w7cC9GCE67bAge+E+ECRbGjSLmz8KKPRVS6opUqrsZfwmrDmSWkjdd9z04iYZf+d1BXNg8vXxhjMvR1G33qT4f2QZEMRDD3ByOctbl8mhF+/xD178ap41DQGelztFwThall0KHCVUz1xuzvyjGzKssQHuc6CsPqUvewWX4qraGJ/y1Ksb8CL9bUwMdKtovVsaTRySRrPCiIpJMIrbqvDUBaZUJWacqmgTX4DK61wrQA8hD0HRuONIt406NTT/uo4X18rsp0OuFyl1r0B2VqIbWmU9aw9c6jBCIoVm0sMhdIKs7lO8PA+Zn3tYh/s8bFOK1bMkyaxzIJrU+5PaZX/CwP0O2/w8h++x+BhiEk8wdDjAoVtKWykGbzR5vlvvcnwt759sQ3tpdSSijHc1ntDEG4Ki7Q38zhmEjGQI6KuINxNTu95ZQx6rVs62VZYUL6fYvrI+f7d5eWV+5B0vrnOvxiRvOKixTgSgSFcD/POsCwrhaFmpi/dCMGDyhyuGzG6H+IMuECB1qAh3VnH9FPQCpVa7M5GXi/DetoHjvbzIf7ouOR8LhtnFUXYD94GrTA/ewq9/uRzGg/vm9W5nOa6zvI9VhVZqiu8dFaHxBj05jru7dfItloMHkWYxJN2FVknL66qvMdrTfvI4rXCxA4TO3RmyNqa/m9+g7Xv/xh73LtRxloQhBVhkTWFbhrFCv+LYlVShQRBqOf0PvXW4vuD02Wv0jx8MT26zs+qqk9WFQVQFxlw3ZFbV338ZdrLG5CuIwKGcD3MeyMs40aa4ECFvYyoF2BSx+hRB4D1Jxkmzq21fnFItH+Mu7+Fb0X4QDN4Z43RlqF9aGntjTBf7eFGMd75PCXEVZ+HG8Xov/4MvMclSSFMr8KBXqaRKR6zrh5GkzSVqjSYknQRvdaFX3qL+GGX47dCXAStI4+NFMqDjRRH3wQ+0fl3knqCgUOnDh1bsvUQlYGx+Ta9f/Aha//XD/N0kqsSMe7yS48grCI3IEx2JbgKYUHEC0G4ucyadlCVfqL0xbTpm1Cb4Sp8u2nqj8x1HL3yqSQiYAhCw5d+2zZkbQUObEsTDBztr09QcYY6OsFbBz5FP3sJYYjbaGMjTevY0f15H/3lc1y/j8/ynth14sUZbjiq/nDa9n7zihtFcaEuAqNJmkqD6vPKGPR7b3P0nQcEQ0+6pukc5BEVykIwzMjahu7XGSZts/5lgk4dwcAyeBjROszQI4uJLVlXgwdvFA6w3/sQ9Yd/Nf11aEJZKk/NeQqCMIFFz9AvwjFbwVmphSLnJwjCOMUU66Y1L8p2FQb4NKuJqNCg/OU0h6q6DbedkqjkyqL0i+Iqr2vZ873GPksNDEGYgu5ehrIO5TzdL47BkXcU6bRR7VZuVIzBd9s8//VNgoFj46Pn6F88xff7eTeMBsJFI6atRbEIR61pPY2q1oNl69S0RjX37/Hy7zxEeci6mmDkMMNcoDiLfEEpku2I9oHFBQoXnqabOM/wfkB8r0XWNigLyYYG79HWc/JuB332nS0Lyc8UhNWlSWu5Om7ry29ZF6jbRFktp0nPI0EQLlOS4qGCsJFdrRQvTpd5a6tTSMZe3C/V3LgtXGiDWqzlt0Rh4aqiLurOb3ydCiQCQ1hdFjk70rTzRoXD5p3HG4VtabJuQHSY4boROIfeH+DXOvhA44MtvNGkmxHRsSc6SlHDGBcn4GYMrasyJk06glzVDNN4Oklxed3vlfvLW6Ie/v33yFqKcOAJBrlgER0mKOuw3RA9zKBtiLcM6ZrCJNA6cpiRw2sFKhc+dKpwAQweaXQKG7+wZC2FevM1+Onnr447z7Wc9VwFQZjMIjuQjNPUUSuLQLttjBfmvO7ohEUcv6rOkiAIs1F2DxWLQHrVzK4W1ynuZ1xgLuuYceobX6q5cROY1x41ERlmFSKWKo4szv5KBIawuizSeVrAvkxs8xfjQOMiTbzbIt1uk7x1D7sWkW23sesR2XqECzXrXyWE+32wFnU+ozWFYlw1O9jkXOY1EtNuv4jvqlCRWq+vMbivifqetV8MiA4SdOZR1pFtRARHMeZkhIs0yYZidF+Rrp+2q13XhH3H5mfDvBZG5kk2NOr02WpbinDo6X94D2XM2LFrznuaaBNBEBbLop4HZTN6TaIwbotAWZXOVuZQX+c5Lkq8aNI566Z+l4JwHVxIjx3z207/zRRlXFXME8ptNqC+9++V2+5Vv5+bRk+XPZua1gJZpdoVS4puEwFDuNuUOWuX0iRyIxDuDbCtPAUB5wl7GS5QnLzTwq6FeK2Id0JcpNHWE/SSfPsggDDIO5WcFiY6P2QTIeOS8W4wM9UkOqPJ9ldFWTutx/cxsSfsOdQwBcAMLel2C9vWuE6AW2uhMk/ryLP2lSfsefC5QBEdJijnae+NcIFi8FjhDHgDaVcRDB2jbYP68P2L38PEh0qDsLcJ56o7Hcy9XYLHjzD370+/D0G4SyzC+SmzMfM4eDc9AqPuBX/VXwDqmCRY3PTvTRCum9L76mJax7igMd5FrlIsbhqxMb7/H3xciNqY0++9SpqMsay+RVkkStW218kVPEskhUS4mTQJ5y+GjpZ9VkwfqcH99HPst7+LbQWYxGPbJm/ZqRSDRxHByKFTn7dZDTW2E6LS0+iLIEAFQZ7Td1a64fSlubYbybKqAF97ePDkc7IbbUwKOnWk97sEJzGqbwlONNlGC51Y4vsdwkFG1tWsPU3wSpF1DcHA4iKDaxlsS6O8J93w6BS2PgEUhCcW5WD/13a4/2QTe3DUQNWewxgrndfc+OY7pDsddOrIOga1IiK5IKwsywr9H6+0flcYv5arKlQU24HPu49xVvWcBeEmUuczFT7ztiLXY8wf1N1uXry+zvc9r5FR2P66/dqmNB1jVbrjNK1ly3YbRfgkabx+4/1PiFJUxlT/DZyNq66oawERMISbyaRWnnXCRCPl87Lz49OMrd/+iIN//m18W5HuanQG3WcZtqPzmguntTIA0o0A5Vrok2EudGQZKjst4jl2g56JF5eEjCoDPquBrhJumm7TdN0mDuKkitKAHqTYCGxb0/nsJRz3UErhdzYJe0OU80RaMXizS+dZTLIToRNH2M+Id0JsqPAmTxnZ+DJm81OTH855OnsZOnUoqwlGHvfua6ij4/yBuOgH4GnUjXn8iN533sj/FrQiGFiCQZb/3QiCMJl5hIy6SvezCMU3xVkep2zM48/PVXm5n2YcVT7AqpyLINw2LqWazdEVZNzuKo1aX4PB4LI9Lqx3qV7G2bhuCjXF6y8JFZME9gnXWgUhPktfRcIoxVRX6nwcNc+8Bukw5+83FVGQU4kqSAqJcNNpWshy/P+ZjpPfZG44YudffoSNFLalaB05gpHN6yykp4U+OxofqFeCRhjg2xEqDFFRiAqDsd36yz/XtUUqO8+m5zWLcZ9mm2nEkWJxprJVnIOzry7N4EzoiVNoRXCq5IbHGaOHLcKTjKxrGO2GhMcZ2z/cZ+cv9tn5qyNU5ln/Ksu/s+O8i4ntGHSSH3v0qDsWYl4xazdzukgb+xvf5vjX30S5vBipThw20ijnMf10+v0Kwl1jUXV2ZipqNkOr6FWkSryA2/HCfxvOQRBuAmfFfqE8zQFqX7x1p3N5W++wL/Zf/T5N/YebaI8LqCB8lc5cfMlvKmaU4LMxH9M7XBzPMcqqg0xKa3eXvut5I8slAkO4HpY1e9U0XWQerKV15Mjamt7rhtZhStBL0ZnDdgJsK5/p9wq8USSvb2KGGXq9gz7q45/vLTYtZNUMd5PCRONh21UG+fk+KrtHsqFx2+uowOCVgiiEOAGlSHZaKOtzYeAoN8rxbkjYS1GDEcQJqhWhjwck2w9Ze2rRaX69vM7FprSrAEPHaHw2dg7zVogGzIN7DP72O6Cg/SIhOBjiOyGs5bVSvNHo84MKglDLvC+odTNb03QjuckU0yvHWaUoDJh8rW+T+CIIN40LXZlKothq7Kwb1bxEF6Mtxvdftt5NtMllUd72PL+8PNpk/PxneYeY551j0vGKETlTpBbNikRgCNfDsgzOLOkiTfc1hgsABckmpGsBKIVXinQ9wLYUQT9/KVUuf7kePm5z9MubZA82UVFUf9zxwkdlBYoWxbKcvnFlvvTzsZeIGkPnDo8YPFbE25rDX9kEYyAwZJttfLtF9nibrGvQmaf9LAYNWcfQeTJCpRa3vY73Hj8YQWZpvRgR9iw6dQRHQ6LDGJ16gqE/FzUWwulDJnh4n5O/+16eLtK3hPt9fGhQcYo7jdDJOgYXmcUdWxBuOwvtTtVwZmtVOnMsgrL0yipB47qp6xpyE1N4BOE2UyUyjH9et27Vdme/17VdvamUXZ+qa3P2vFpShxHdauWFVptSJSBf0fciAoawuly3M1VxU3rr0Bm0Dj27H1t05nGhJtsIsS1F1tFkXQMa4t1W3pnEKHTmyTYiMK9uu8YdSZbhqC3b+WtaZbnyI8/bv/0SlXl0Bv0Pdknvr+PahsNvb/P819ZJ1jW2bTDDlGSnTbquCfZOMF/vo/eOwHlUFOKTBHM4yLuXhBoV57UnXKRyIWpd44uO/Rx/f3qty+Hfe5dkXYOCoJ+iTgYo73HtEOXBjCxohetIIJwgNGKZEQJ3JQIDLqfEXfezdhpu6rgF4a5xHiFRlRJ9ebnSCrO5nvvDZSLGpcKWN9gee1//3Cm2qD37edp0kobruSTNU9nrappciLqZ7nmsW63y77BpK/Pi/qbeQhCuikUaplkcnarje0f3qwEoiDc1XoFtaZxRuEChHNiOJt4yoEDHnrBnMbFHWZ9HEpzvqqQGxm1iYghw2QPp1QPPf/xT2geerK0YbRv6b+SCEMDOxzHdFxnhSUq63aa1NyQYetQwxo9ifL8PWZbXysgy1DAmPLEM7xnSxxskW3kkjE49W5+Nzmtq5OOa3TFWxjD8e7+MchD2HeFJhjeK7LUd0p02ypPX3lAQHi4hF1EQbjNnEV7X4bjeZGd5nKYFrwVBEJpS1TVjCry12ONefU24GV94V5JLUeNjURhVPwNnxeEXOxZXfr2bUvKdKGPOhQsXxxX1S2Y7pkz9CXeDRbVi8w4wmIM+OlujdZhhTgtBpuuGYOiINw1Z29DZz/BKEYwsZyV/VeYuvijXHnsst+8mhMvOOsaaUELvPFu//UOO/9m3CYYebyDeNOdRLzp16EFK/OYayrdI1zQE5pUx1AqfnhYwCgzJdkDWVsTbIUHfkmzm0RDRZ8/IFiEgKY15eB8XKoKho/1skKeztEPM0RBzMkL1hhij8VGISlLc1tr8xxUEYXqmCcVddfs7LWWzZ6sY0VDWYWwVxykId41L9ebc5fTnSVEYdTUuJtUqui02uYlNK3lWjU96KmMudTgcW3ERoywZ0+S6F955fJIWF9Zu0xQRMIS7w6QX7KrPC8bFOw97B7jgITrzRHsDvNboOMRF5rS+AWQdTTDIu03o1BMepwSHAzi9mWsjLorhWrMY6nm2nYXKiJUG+dXjBq3wEHOjmK3f/Zjef/gh7rQ1qjWK/msBOiUXKTQ8/24HF8L6L3YIjk5OhSILjx6gjk4ACPoWf18z2jb4XYNtweYXGXZvn0WgtGL4rdcxI0fQz3CtAK0UwfOj/DrECX40glYLpRT2/ibmxdFCji0Id4pFvMTehhzqebgJYsA8z68l5YoLgjBGWTHPceGi7j4sq4tRtQ+42YU76ygVlCtafJeIPpXixSK40Np1rGX1+JhnKdo553hvSQyOcOtYhlM1sc1Pw/7G3uEGA8K+I94OOP5wi8HbayjncZFGZx6vFWlHY0aOZNNgOxozTOHlUd7ruMnNPm+o9HWFWZ8xU9pOedicPe6x8UdfoCzEOwqTeHQKtgXHb4f0XjMoB92nntGDFqp1Wig1CFDHvbyYZ3habNVAvKsY3VcoD90/+QyfZgsJm9Pra6RrhmBg8aHGtgP00QDSDPSYuU1SSHOBg2mKJgmCcPXcNmd5nFmeE1cVvl106qd5ptyWEHNBuIlM608VO2xU7e+2CpKVBYsn2LEFtCOdyAUBqaaLVdW2sBR7LBZeWE1W3GH0acb673+CSVwuXITqvJuEchAOHFufDnCRxiSe6DBF7x/je318ll2OvqjKPbsJIb5VNOkIUwwbLEZgnP6stCJ7vsfG73/Czscp0Ymjs5/RPnAEI0/ryGNGHheCjU6vkVZgHT5JUFrjOxFmZAl7oJP8n4nBD4YXjjX9eebfmTKG0a99g7BvUZkj3g5BgUozfJblIkYYnm/j44Tw53v4/mC24wqCsFyuWwReVa7yJaIsfWRS3Y7xGUpBEJbLxMnBijagRcrasI535Wt6vJtI8VlTTJtROu8QUpWS08TWzSMiXIgAaRbdfaGjyRJssaSQCMIkytRG77BHx6z93o+wf+t9+m+2STcCOC3QqDOPN5roMMYcj+DFAe7kpFy8mMS4w3YrDfcEw+Yd3uWG1x33iI4S+m+0UV7hFegMknVFuq7Y+tzmLVFbEaRpnkbiNN45VOYYPghpH1pMcqYm52JUo3HUoTTm8aN8NwqGj9uY2KHj03onWYYfji5uE8f5OJvWRBEE4Wq5CbWH5qH4bJlWIF92ikaVo9wkKkPEC0G4HqrSHupqH1SJHHfpPj6zx2f1RApceneY9vos+lo2fV4s6XsUAUO4mVy1Y1l2o3qH6w/Qf/ojtn66Rfztt/EabNsQnsQEh0N4tofr9cHaauGiNp3kljnP4zNoFde0MnzwLBojc4R9R7JhCAeOZCPfz9pTR9izeAU+CvP9G5OnkXQ7JDsdgqGndZCgk4De6yH3PjrBWzt/Lt5al+EvP8YbhW1rTOxO/1nszgZ6OAJ9Wlw0y/JxpRn++ARarbmOLQh3kqW2VL1ldreKurpF04QHXxVNv++79NIjCKtIXYRAXVpBsQ7Gpc9vsW0uiskNIsmUMbkPe2HhgiPQyvbXoOjohU4yS0AEDOFmct3ixfk4HD5z2P2XhN8/QhmN9x6cx3l3+QauqqZ8YZ8Nzu0mzwxO++Ixds2U0cS7bZKNvEXt4L4hGOX1MMK+I9ofcvL+Ou1OhGILtEYNRri1DqOHLZTzHL/bJhx4WscO/elXzBv/oIzBfes9bNugrCcYOnTqUKlDH/YhDHBvPgCt0T9/lgsY7rSd8/7UuQAADQJJREFUrneoQGpgCMKVMUlEvctMk9u8bKrSRVZhbIIgXGTSvVksSFn1kn36uQrCiy/mN9XfnYcq0Wfs2nlLfq2ytHy7eSmLnlAanJ34brRsRMAQhDqaOrqnQoa3JW2gSnLZLqvTJc5a7fFuuDEvtt+68FmN4QtDsk5eVyRfF9aexgQHQ3xoQClaBxmH39oGBSb2hD2L8hAMHPG2yQusdmH3//4Me3Q8f/TFzg6jzQgXKYKBJzhJ0ZnDhRo1SnCtCNuNsC1N9PYj9NEAlaT44QilFO7R7lzHF4Q7yywv3GfrlkaA3XC7ughWRSAoq/8k348grC51vnLR953QmeI8Mvau3vNlz7bTdwkdhbg4frVsUqeXWalKA1pkZIe0URWEGahyiOapOdGkB3OZeDHLsW47JeGDqhXlBVMD6D5LyboGHVvix+uYQYYPNcOHIcqCST3K+ly86KX03u6gM49OPTZSuJeHixnjgx28VkSHGcr7vK2rUZh+AmGA8h6VOdx6QHyvjXvcof1ihB5lZGsRepBOPo4gCJOZJ4JA7G/OhdZ41xDxMP4dTht9cddy5gVhxbkQHXCd9RpuA6dChUsuRlt4y3wFOqceR7E7VEWURtPCojN+1yJgCHeXuvzfumWLcujuusNc1kv6/LNCwacxbARRz+EVhL0MrxThYUy63crrXyjQnrwGxciBB280wdCBAmcU0cliHo5KK+LXNgDQqUPHGT7QuXAyTPDtCNeN8IGm/WKISjJUnIHJzykYJnm3FEEQ5qNJFFvVy7FwkfMc7GtItSkr0Nk4MlFeegRhlbiQ2tB4I7HNtf7xMqMi6pgQNXNp2SRxouyzsqiPCqSNqnC3WGbRt2mMrhjonCkLxfk4Oe06okk3ArxSFwQArxXhII+y0KnHtjTKe+LdvKVpvg5Eh0l9IammGINXoJxHWYfyoOMM2w3w7RDXCXGBxowykt02rh2iBiNUf4jqD/HtMG+vKgjCbFzoDjUWzVYW2Tb+Ui6sPuMO/KqktgiCUM3ZPVu0xU2E5eLPd5liJNwpSqv5fNamVB2jaSQczCaqTNEeVgQM4W4xrXGszOcrcZSXNYbbTlU3kpLf/XAIHuItjdeQrZ0KCB6CkxTXUrlAcZShU0d4kqETR9bR6NijsrztavAXn+QFVpuGuFUYc6UULtTYSGPbAbZlcK2AtBugBjEqc2QbIYM3OrS+7hE8OcCPYnx/gB/FqNSSPdqa9ooJgnBGnQ0uc4zF/lZzJhQUoyDkmgmCMC1FuzHJVouduUzBHpd2zavxUWc75pgAcaGGX4V4UXb8KxBZRMAQVpdVmHGpSycpDe3yk/9VUXW+q3AdlsEMDyvvPNv/+jPCvidd03kti8hgWwa0whlFsq7pvRkR74TEuyHZWkDYc6TrGp15Nn/wFDccvXoITBIxasLzvM0Lg568ZUi2ApTz6NTR/ek+ynmyjRYuVOBBxQmkr8IpVRDgA41tSxcSQVgqIl40p0ycnzaVo8n+BUG4mzT1iYXJjPuxixINxn3eSf5xVQqLdCER7jSrZNiqZqEWOcZpanLcVhpUsXb7L9n62Rscv90mXdN4HaCzADNyKAfa5kU6AbxReAUuUigP3b/8BfbF3nRjqsnj89bSPrC0X3rCXpYLFWneXsq3wjx1ZDtCZ3mKCcbkbVQBn2Vkm21sW3RkQRBWhDJRvq5zy7z7r2KVWroKgiBcJ9dtD6t887JokPH/q9ZbAOI5C0ITmogI8xqW2+qozdLisArv8NZi/uAjNn82xJlcpBjuagYPA3Tq8UqhzwIdPIzuBejEs/VvPyd79iJPHZmGOmXbO1rPBigPOI/px5C5vEhnZtH9mLCfkXU0vhWCc+ezDkopdGKxLTHDgiCsCMuKvJjmuGdIq1tBEO4qk+zhuF+66A5MZ2kh00Z1lERjqGkK1U9h3yUCQxAWxbyO1W11zJoWbxpngpDhnUf/fx9x708CzGuP6H37McmGxkWKIPYEQ4cZWsJeirIe8/U+2fO92Q18zXbqxz/Dvf4tso0Q2wmIXg7PC3Om99fBgxl5Dr57j82ftgmeHOQbBgYXGcKenW1MgiAIi6QsZ33Zx2sS3bHoKBBBEISbQG2B04o0j1nFjPHtLu2zxu5OOJ63JT5u1TZT2HcRMARBWByLKPg2vo9JQkaakf38K9o//4rOmcp7ZhiVRkUhWEuWpEvLyXOjGDN0eccTrUi32wRBrlp7k48pOkmx7YjBG106RmOGaR6F4TzRQbyUcQmCICyMslbii2ixWlVLqvjZtMe66vavgiAIq0BVWsd4a9MyAWEaH7lO7GiyrwX44xK7LAjC4riqIm8lYWreeby1+b/Tn91whFuieHE2lugPfwQKbEvhIk2y3cK1Aswgz2VxRhMMHCY+M/gerzWuZbBd0ZEFQbhBLCofu9jWtiyNZFYhQsQLQRBuM41S20tampalhdS1Tb2UyjJFhMcSu5GIgCEIws2lKGRcaPnkajuI5OssJkTaDYd0P9k/Ldbp80KibUO6GeWHCRQ6cejM41qG+EEXux6hUocXR1sQhJvGNF0E6rrANO0QI/UwBEEQLlImLozXrhj3gcuWne+nLIqiQqguTf24ejlBpv4E4TawiNSNVaTpTN+4gW6qDC/4etlPv2CtN6D/nbcIT1J8yxAMLV7n4gWAsg7lPKDRqUVlDn08XOg4BEEQrowmAuz4OsW0kLr1i+LGpSJ2Iv4KgnDHuWBTSyb0pm21Oo1vPMnnLvPNF1RwVAQMQVhlmgoTt1G8GKdpGHETo1iWy70IvCN7+ozOvzlGvfcWycM10vWAYJQXMNKxxUea4OUQvnqK6/XxzmOvoF+2IAjClbCouhhnnD0DRawQBEEop7SW0Cy1KSqi5Ko6oNTVwag8xmJ8XhEwBGFRLDoKomx/tzXSogmLyLuuq7K/IAfZDYfwo59ifgSBVqA0utPGe49PEmyaLbcmhyAIwlUxS6HNaQSJqhQTETQEQRBeUfSRm0Y6nK03zbvFtD7sFNEXKorwDfxkETAEoSmTxINFCwt1+cJNucuCx7Qscpbv1PB6C2CxJ+li9isIgrBqnNnOMiGjSoRfxvNyEfZbnpeCINxkzmxh43TqBuLFogo3NxiTT5JGu5IinoLQlJvo2NzEMU9i1nNqmopTrIjftMjcrGO5jd+RIAh3i7LotkWI8E2OW7SnRZu9DBsuCIJw05lWTB73i+u6RzVhzsKfEoEhCMLNo3FxzwWJHWXF5Mp+Hv+9avm8YxMEQVhFymzasqIAJ4kjImIIgnBXaRKRtghbWLS5dQWaq2p0lPnLDRABQxCEelY5DWXc8F1lTnSdEFHlKK/qNRQEQVgG4zZ5lZ8jgiAIt41lFaxvesxFfVaBpJAIwl3kNhVAqzJ84iwLgiBcPyJeCIIgCAtEBAxBuItMm/N2E1hWvQpBEARhesQOC4IgXD/LKJx8zYiAIQjC7aAYrjxeFV8QBEG4es4cZ7HFgiAIq8MNt8kiYAiCcHu44QZZEAThVlBmi8U+C4IgXA+3zP6KgCEIwu1gmW1PBUEQhObUdWASBEEQrpZb5htLFxJBEG4ft8xQC4Ig3FhmbJMnCIIgLJBb5BtLBIYgCLePWxYqJwiCcKO5BQ6zIAjCreGG+8kiYAiCcPs4c5ZvuIEWBEEQBEEQBOEVImAIgnB7kVk/QRAEQRAEQXjFDfePRcAQBEEQBEEQBEEQBGHlEQFDEARBEARBEARBEISVRwQMQRAEQRAEQRAEQRBWHhEwBEEQBEEQBEEQBEFYeUTAEARBEARBEARBEARh5REBQxAEQRAEQRAEQRCElUcEDEEQBEEQBEEQBEEQVh4RMARBEARBEARBEARBWHlEwBAEQRAEQRAEQRAEYeURAUMQBEEQBEEQBEEQhJVHBAxBEARBEARBEARBEFYeETAE4TpQ6rpHIAiCIAiCIAiCcKNQ3vvrHoMgCIIgCIIgCIIgCEItEoEhCIIgCIIgCIIgCMLKIwKGIAiCIAiCIAiCIAgrjwgYgiAIgiAIgiAIgiCsPCJgCIIgCIIgCIIgCIKw8oiAIQiCIAiCIAiCIAjCyiMChiAIgiAIgiAIgiAIK48IGIIgCIIgCIIgCIIgrDwiYAiCIAiCIAiCIAiCsPKIgCEIgiAIgiAIgiAIwsojAoYgCIIgCIIgCIIgCCuPCBiCIAiCIAiCIAiCIKw8ImAIgiAIgiAIgiAIgrDyiIAhCIIgCIIgCIIgCMLKIwKGIAiCIAiCIAiCIAgrjwgYgiAIgiAIgiAIgiCsPCJgCIIgCIIgCIIgCIKw8oiAIQiCIAiCIAiCIAjCyiMChiAIgiAIgiAIgiAIK48IGIIgCIIgCIIgCIIgrDwiYAiCIAiCIAiCIAiCsPKIgCEIgiAIgiAIgiAIwsojAoYgCIIgCIIgCIIgCCuPCBiCIAiCIAiCIAiCIKw8/z+nIGXV6m86ZAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "titles = [\"Nucleus\", \"Cytoplasm\", \"RNA\"]\n",
+    "path_output = os.path.join(output_directory, \"image_channels_2D_no_frame\")\n",
+    "plot.plot_channels_2d(image, r=0, z=17, \n",
+    "                      titles=titles, \n",
+    "                      framesize=(15, 5), remove_frame=True, \n",
+    "                      path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:bigfish]",
+   "language": "python",
+   "name": "conda-env-bigfish-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/Normalize images.ipynb b/notebooks/Normalize images.ipynb
new file mode 100644
index 00000000..dbe914fe
--- /dev/null
+++ b/notebooks/Normalize images.ipynb	
@@ -0,0 +1,972 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Normalize images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:05:21.460742Z",
+     "start_time": "2019-05-06T06:05:20.631471Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import bigfish.stack as stack\n",
+    "import bigfish.plot as plot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:05:21.468840Z",
+     "start_time": "2019-05-06T06:05:21.463260Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['untitled folder',\n",
+       " 'dapi_1.tif',\n",
+       " 'smFISH_simulations__batch_0003.json.gz',\n",
+       " 'dapi_2.tif',\n",
+       " '.DS_Store',\n",
+       " 'smFISH_simulations__batch_0002.json.gz',\n",
+       " 'smFISH_simulations__batch_0001.json.gz',\n",
+       " 'r03c03f01_405.tif',\n",
+       " 'untitled folder.zip',\n",
+       " 'cy3_1.tif',\n",
+       " 'cy3_2.tif',\n",
+       " 'r03c03f01_561.tif',\n",
+       " 'cellLibrary.json',\n",
+       " 'gfp_2.tif',\n",
+       " 'gfp_1.tif',\n",
+       " 'r03c03f01_488.tif']"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "input_directory = \"/Users/arthur/big-fish/data/input\"\n",
+    "output_directory = \"/Users/arthur/big-fish/data/output\"\n",
+    "os.listdir(input_directory)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Rescale images"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Loading with recipe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:08:30.930755Z",
+     "start_time": "2019-05-06T06:08:30.927532Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "recipe = {\"fov\": \"r03c03f01\", \n",
+    "          \"c\": [\"405\", \"488\", \"561\"], \n",
+    "          \"ext\": \"tif\",\n",
+    "          \"pattern\": \"fov_c.ext\"}\n",
+    "stack.check_recipe(recipe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:13:55.385818Z",
+     "start_time": "2019-05-06T06:13:51.969008Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 22 | maximum value: 54687\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack(recipe, input_directory, input_dimension=3)\n",
+    "print(image.shape, image.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image.min(), image.max()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:13:33.646838Z",
+     "start_time": "2019-05-06T06:13:15.450971Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_rescaled = stack.build_stack(recipe, input_directory, input_dimension=3, normalize=True)\n",
+    "print(image_rescaled.shape, image_rescaled.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image_rescaled.min(), image_rescaled.max()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:14:04.961639Z",
+     "start_time": "2019-05-06T06:14:03.269705Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "images = [image[0, 0, 17, :, :], image[0, 1, 17, :, :], image[0, 2, 17, :, :], \n",
+    "          image_rescaled[0, 0, 17, :, :], image_rescaled[0, 1, 17, :, :], image_rescaled[0, 2, 17, :, :]]\n",
+    "titles = [\"Nucleus\", \"Cytoplasm\", \"RNA\", \"Nucleus_rescaled\", \"Cytoplasm_rescaled\", \"RNA_rescaled\"]\n",
+    "path_output = os.path.join(output_directory, \"image_rescaled\")\n",
+    "plot.plot_images(images, \n",
+    "                 titles=titles, \n",
+    "                 framesize=(15, 10), remove_frame=True,\n",
+    "                 path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Loading with recipes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:14:56.475567Z",
+     "start_time": "2019-05-06T06:14:56.471780Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "recipe_1 = {\"fov\": \"r03c03f01\", \"c\": [\"405\", \"488\", \"561\"], \"ext\": \"tif\", \"pattern\": \"fov_c.ext\"}\n",
+    "recipe_2 = {\"fov\": [\"1\", \"2\"], \"c\": [\"dapi\", \"cy3\", \"gfp\"], \"ext\": \"tif\", \"pattern\": \"c_fov.ext\"}\n",
+    "data_map = [(recipe_1, input_directory), (recipe_2, input_directory)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:16:37.798856Z",
+     "start_time": "2019-05-06T06:15:55.795801Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n",
+      "(1, 3, 34, 2048, 2048) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n",
+      "(1, 3, 34, 2048, 2048) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_generator = stack.build_stacks(data_map, input_dimension=3, normalize=True)\n",
+    "for image_rescaled in image_generator:\n",
+    "    print(image_rescaled.shape, image_rescaled.dtype)\n",
+    "    print(\"minimum value: {0} | maximum value: {1}\".format(image_rescaled.min(), image_rescaled.max()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Loading with paths"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:18:37.778707Z",
+     "start_time": "2019-05-06T06:18:37.775048Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "path_1 = os.path.join(input_directory, \"r03c03f01_405.tif\")\n",
+    "path_2 = os.path.join(input_directory, \"r03c03f01_488.tif\")\n",
+    "path_3 = os.path.join(input_directory, \"r03c03f01_561.tif\")\n",
+    "paths = [path_1, path_2, path_3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:18:54.450102Z",
+     "start_time": "2019-05-06T06:18:38.052436Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_rescaled = stack.build_stack_no_recipe(paths, input_dimension=3, normalize=True)\n",
+    "print(image_rescaled.shape, image_rescaled.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image_rescaled.min(), image_rescaled.max()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### With stack.rescale function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:21:59.181998Z",
+     "start_time": "2019-05-06T06:21:59.178714Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "recipe = {\"fov\": \"r03c03f01\", \n",
+    "          \"c\": [\"405\", \"488\", \"561\"], \n",
+    "          \"ext\": \"tif\",\n",
+    "          \"pattern\": \"fov_c.ext\"}\n",
+    "stack.check_recipe(recipe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:22:05.302395Z",
+     "start_time": "2019-05-06T06:21:59.673171Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 22 | maximum value: 54687\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack(recipe, input_directory, input_dimension=3)\n",
+    "print(image.shape, image.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image.min(), image.max()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:22:18.048248Z",
+     "start_time": "2019-05-06T06:22:05.304773Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_rescaled = stack.rescale(image)\n",
+    "print(image_rescaled.shape, image_rescaled.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image_rescaled.min(), image_rescaled.max()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Contrast images"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Loading with recipe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:25:23.342643Z",
+     "start_time": "2019-05-06T06:25:23.339252Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "recipe = {\"fov\": \"r03c03f01\", \n",
+    "          \"c\": [\"405\", \"488\", \"561\"], \n",
+    "          \"ext\": \"tif\",\n",
+    "          \"pattern\": \"fov_c.ext\"}\n",
+    "stack.check_recipe(recipe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:28:37.216104Z",
+     "start_time": "2019-05-06T06:28:31.775530Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 22 | maximum value: 54687\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack(recipe, input_directory, input_dimension=3)\n",
+    "print(image.shape, image.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image.min(), image.max()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:28:56.033960Z",
+     "start_time": "2019-05-06T06:28:37.218481Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_rescaled = stack.build_stack(recipe, input_directory, input_dimension=3, normalize=True)\n",
+    "print(image_rescaled.shape, image_rescaled.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image_rescaled.min(), image_rescaled.max()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:29:13.360933Z",
+     "start_time": "2019-05-06T06:28:56.036872Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_stretched = stack.build_stack(recipe, input_directory, input_dimension=3, normalize=True,\n",
+    "                                    channel_to_stretch=[0, 1, 2], stretching_percentile=99.9)\n",
+    "print(image_stretched.shape, image_stretched.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image_stretched.min(), image_stretched.max()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:29:16.508015Z",
+     "start_time": "2019-05-06T06:29:13.363335Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x1080 with 9 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "images = [image[0, 0, 17, :, :], image[0, 1, 17, :, :], image[0, 2, 17, :, :], \n",
+    "          image_rescaled[0, 0, 17, :, :], image_rescaled[0, 1, 17, :, :], image_rescaled[0, 2, 17, :, :],\n",
+    "          image_stretched[0, 0, 17, :, :], image_stretched[0, 1, 17, :, :], image_stretched[0, 2, 17, :, :]]\n",
+    "titles = [\"Nucleus\", \"Cytoplasm\", \"RNA\", \"Nucleus_rescaled\", \"Cytoplasm_rescaled\", \"RNA_rescaled\",\n",
+    "          \"Nucleus_stretched\", \"Cytoplasm_stretched\", \"RNA_stretched\"]\n",
+    "path_output = os.path.join(output_directory, \"image_normalized\")\n",
+    "plot.plot_images(images, \n",
+    "                 titles=titles, \n",
+    "                 framesize=(15, 15), remove_frame=True,\n",
+    "                 path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Loading with recipes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:14:56.475567Z",
+     "start_time": "2019-05-06T06:14:56.471780Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "recipe_1 = {\"fov\": \"r03c03f01\", \"c\": [\"405\", \"488\", \"561\"], \"ext\": \"tif\", \"pattern\": \"fov_c.ext\"}\n",
+    "recipe_2 = {\"fov\": [\"1\", \"2\"], \"c\": [\"dapi\", \"cy3\", \"gfp\"], \"ext\": \"tif\", \"pattern\": \"c_fov.ext\"}\n",
+    "data_map = [(recipe_1, input_directory), (recipe_2, input_directory)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:16:37.798856Z",
+     "start_time": "2019-05-06T06:15:55.795801Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n",
+      "(1, 3, 34, 2048, 2048) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n",
+      "(1, 3, 34, 2048, 2048) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_generator = stack.build_stacks(data_map, input_dimension=3, normalize=True)\n",
+    "for image_rescaled in image_generator:\n",
+    "    print(image_rescaled.shape, image_rescaled.dtype)\n",
+    "    print(\"minimum value: {0} | maximum value: {1}\".format(image_rescaled.min(), image_rescaled.max()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Loading with paths"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:18:37.778707Z",
+     "start_time": "2019-05-06T06:18:37.775048Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "path_1 = os.path.join(input_directory, \"r03c03f01_405.tif\")\n",
+    "path_2 = os.path.join(input_directory, \"r03c03f01_488.tif\")\n",
+    "path_3 = os.path.join(input_directory, \"r03c03f01_561.tif\")\n",
+    "paths = [path_1, path_2, path_3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:18:54.450102Z",
+     "start_time": "2019-05-06T06:18:38.052436Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_rescaled = stack.build_stack_no_recipe(paths, input_dimension=3, normalize=True)\n",
+    "print(image_rescaled.shape, image_rescaled.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image_rescaled.min(), image_rescaled.max()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### With stack.rescale function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:21:59.181998Z",
+     "start_time": "2019-05-06T06:21:59.178714Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "recipe = {\"fov\": \"r03c03f01\", \n",
+    "          \"c\": [\"405\", \"488\", \"561\"], \n",
+    "          \"ext\": \"tif\",\n",
+    "          \"pattern\": \"fov_c.ext\"}\n",
+    "stack.check_recipe(recipe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:22:05.302395Z",
+     "start_time": "2019-05-06T06:21:59.673171Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 22 | maximum value: 54687\n"
+     ]
+    }
+   ],
+   "source": [
+    "image = stack.build_stack(recipe, input_directory, input_dimension=3)\n",
+    "print(image.shape, image.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image.min(), image.max()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-05-06T06:22:18.048248Z",
+     "start_time": "2019-05-06T06:22:05.304773Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 3, 35, 2160, 2160) uint16\n",
+      "minimum value: 0 | maximum value: 65535\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_rescaled = stack.rescale(image)\n",
+    "print(image_rescaled.shape, image_rescaled.dtype)\n",
+    "print(\"minimum value: {0} | maximum value: {1}\".format(image_rescaled.min(), image_rescaled.max()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cast images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "titles = [\"Nucleus\", \"Cytoplasm\", \"RNA\"]\n",
+    "path_output = os.path.join(output_directory, \"image_channels_2D\")\n",
+    "plot.plot_channels_2d(image, r=0, z=17, \n",
+    "                      titles=titles, \n",
+    "                      framesize=(15, 5), remove_frame=False, \n",
+    "                      path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "build_stack(recipe, input_folder, input_dimension=None, i_fov=0,\n",
+    "                check=False, normalize=False, channel_to_stretch=None,\n",
+    "                stretching_percentile=99.9, cast_8bit=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "recipe_1 = {\"fov\": \"r03c03f01\", \"c\": [\"405\", \"488\", \"561\"], \"ext\": \"tif\", \"pattern\": \"fov_c.ext\"}\n",
+    "recipe_2 = {\"fov\": [\"1\", \"2\"], \"c\": [\"dapi\", \"cy3\", \"gfp\"], \"ext\": \"tif\", \"pattern\": \"c_fov.ext\"}\n",
+    "data_map = [(recipe_1, input_directory), (recipe_2, input_directory)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "build_stacks(data_map, input_dimension=None, check=False, normalize=False,\n",
+    "                 channel_to_stretch=None, stretching_percentile=99.9,\n",
+    "                 cast_8bit=False, return_origin=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_generator = stack.build_stacks(data_map)\n",
+    "for image in image_generator:\n",
+    "    print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path_1 = os.path.join(input_directory, \"r03c03f01_405.tif\")\n",
+    "path_2 = os.path.join(input_directory, \"r03c03f01_488.tif\")\n",
+    "path_3 = os.path.join(input_directory, \"r03c03f01_561.tif\")\n",
+    "paths = [path_1, path_2, path_3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image = stack.build_stack_no_recipe(paths)\n",
+    "print(image.shape, image.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "build_stack_no_recipe(paths, input_dimension=None, check=False,\n",
+    "                          normalize=False, channel_to_stretch=None,\n",
+    "                          stretching_percentile=99.9, cast_8bit=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rescale(tensor, channel_to_stretch=None, stretching_percentile=99.9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "titles = [\"Nucleus\", \"Cytoplasm\", \"RNA\"]\n",
+    "path_output = os.path.join(output_directory, \"image_channels_2D\")\n",
+    "plot.plot_channels_2d(image, r=0, z=17, \n",
+    "                      titles=titles, \n",
+    "                      framesize=(15, 5), remove_frame=False, \n",
+    "                      path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "read_image, read_pickle, read_cell_json, read_rna_json\n",
+    "build_simulated_dataset, build_stacks, build_stack,\n",
+    "                         build_stack_no_recipe, rescale, cast_img_uint8,\n",
+    "                         cast_img_uint16, cast_img_float32, cast_img_float64,\n",
+    "                         clean_simulated_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = [image[0, 0, 0, :, :], image[0, 0, 17, :, :], image[0, 0, 34, :, :]]\n",
+    "titles = [\"Image 2D (1st z-slice)\", \"Image 2D (18th z-slice)\", \"Image 2D (35th z-slice)\"]\n",
+    "path_output = os.path.join(output_directory, \"3x_images_2D\")\n",
+    "plot.plot_images(images, \n",
+    "                 titles=titles, \n",
+    "                 framesize=(15, 5), remove_frame=False,\n",
+    "                 path_output=path_output, ext=\"png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:bigfish]",
+   "language": "python",
+   "name": "conda-env-bigfish-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 255af565f6561976abc347e8019b849e84398305 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 7 May 2019 20:02:39 +0200
Subject: [PATCH 138/264] refactor segmentation

---
 bigfish/segmentation/__init__.py              |  12 +-
 bigfish/segmentation/cyt_segmentation.py      |  69 +++++++++++
 .../{segmentation.py => nuc_segmentation.py}  | 116 +-----------------
 bigfish/segmentation/utils.py                 |  28 +++++
 4 files changed, 111 insertions(+), 114 deletions(-)
 create mode 100644 bigfish/segmentation/cyt_segmentation.py
 rename bigfish/segmentation/{segmentation.py => nuc_segmentation.py} (51%)
 create mode 100644 bigfish/segmentation/utils.py

diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index 8ed788bd..f692164e 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -5,9 +5,15 @@
 cytoplasm and label them, in 2-d and 3-d.
 """
 
-from .segmentation import nuc_segmentation_2d, cyt_segmentation_2d
+from .utils import label_instances
+from .nuc_segmentation import nuc_segmentation_2d, filtered_threshold
+from .cyt_segmentation import cyt_segmentation_2d, watershed_2d
 
 
-__all__ = ["nuc_segmentation_2d",
-           "cyt_segmentation_2d"]
+_nuc = ["nuc_segmentation_2d", "filtered_threshold"]
 
+_cyt = ["cyt_segmentation_2d", "watershed_2d"]
+
+_utils = ["label_instances"]
+
+__all__ = _utils + _nuc + _cyt
diff --git a/bigfish/segmentation/cyt_segmentation.py b/bigfish/segmentation/cyt_segmentation.py
new file mode 100644
index 00000000..088b1c68
--- /dev/null
+++ b/bigfish/segmentation/cyt_segmentation.py
@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+"""
+Class and functions to segment nucleus and cytoplasm in 2-d and 3-d.
+"""
+
+from bigfish import stack
+from .nuc_segmentation import nuc_segmentation_2d
+
+from skimage.morphology import remove_small_objects, remove_small_holes
+import numpy as np
+from skimage.morphology import watershed
+from skimage.filters import threshold_otsu
+from skimage.measure import regionprops
+
+
+# TODO rename functions
+# TODO complete documentation methods
+
+
+def cyt_segmentation_2d(tensor, r, c_nuc, c_cyt, segmentation_method):
+    # TODO add documentation
+    # check tensor dimensions and its dtype
+    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+
+    # apply segmentation
+    # TODO validate the pipeline with this cast
+    image_segmented = stack.cast_img_uint8(tensor)
+    if segmentation_method == "watershed":
+        image_segmented = watershed_2d(image_segmented, r, c_nuc, c_cyt)
+    else:
+        pass
+    return image_segmented
+
+
+def watershed_2d(tensor, r, c_nuc, c_cyt):
+    # TODO add documentation
+    # TODO better integration with nuclei segmentation
+    # nuclei segmentation
+    _, nuc_labelled, _ = nuc_segmentation_2d(
+        tensor,
+        projection_method="mip",
+        r=r, c=c_nuc,
+        segmentation_method="threshold",
+        return_label=True)
+
+    # get source image
+    cyt = tensor[r, c_cyt, :, :, :]
+    cyt_projected = stack.projection(tensor, method="mip", r=r, c=c_cyt)
+
+    # get a mask for the cytoplasm
+    mask = (cyt_projected > threshold_otsu(cyt_projected))
+    mask = remove_small_objects(mask, 200)
+    mask = remove_small_holes(mask, 200)
+
+    # get image to apply watershed on
+    seed = np.sum(cyt, 0)
+    seed = seed.max() - seed
+    seed[nuc_labelled > 0] = 0
+
+    # get the markers from the nuclei
+    markers = np.zeros_like(seed)
+    for r in regionprops(nuc_labelled):
+        markers[tuple(map(int, r.centroid))] = r.label
+
+    # apply watershed
+    cyt_segmented = watershed(seed, markers, mask=mask)
+
+    return cyt_segmented
diff --git a/bigfish/segmentation/segmentation.py b/bigfish/segmentation/nuc_segmentation.py
similarity index 51%
rename from bigfish/segmentation/segmentation.py
rename to bigfish/segmentation/nuc_segmentation.py
index a8bd431b..3a066e15 100644
--- a/bigfish/segmentation/segmentation.py
+++ b/bigfish/segmentation/nuc_segmentation.py
@@ -10,13 +10,12 @@
 from skimage.measure import label
 from scipy import ndimage as ndi
 import numpy as np
-from skimage.morphology import watershed
-from skimage.filters import threshold_otsu
 from skimage.measure import regionprops
 
+
 # TODO rename functions
 # TODO complete documentation methods
-
+# TODO add sanity functions
 
 def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
                         return_label=False, **kwargs):
@@ -104,9 +103,9 @@ def filtered_threshold(image, kernel_shape="disk", kernel_size=200,
 
     """
     # remove background noise from image
-    image = _remove_background(image,
-                               kernel_shape=kernel_shape,
-                               kernel_size=kernel_size)
+    image = stack.remove_background(image,
+                                    kernel_shape=kernel_shape,
+                                    kernel_size=kernel_size)
 
     # discriminate nuclei from background, applying a threshold.
     image_segmented = image >= threshold
@@ -119,108 +118,3 @@ def filtered_threshold(image, kernel_shape="disk", kernel_size=200,
 
     return image_segmented
 
-
-def _remove_background(image, kernel_shape="disk", kernel_size=200):
-    """Remove background noise from a 2-d image.
-
-    Parameters
-    ----------
-    image : np.ndarray, np.uint
-        Image to process. Casting in np.uint8 makes the computation faster.
-    kernel_shape : str
-        Shape of the kernel used to compute the filter ('diamond', 'disk',
-        'rectangle' or 'square').
-    kernel_size : int or Tuple(int)
-        The size of the kernel. For the rectangle we expect two integers
-        (width, height).
-
-    Returns
-    -------
-    image_without_back : np.ndarray, np.uint
-        Image processed.
-
-    """
-    # compute background noise with a large mean filter
-    background = stack.mean_filter(image,
-                                   kernel_shape=kernel_shape,
-                                   kernel_size=kernel_size)
-    # subtract the background from the original image, clipping negative
-    # values to 0
-    mask = image > background
-    image_without_back = np.subtract(image, background,
-                                     out=np.zeros_like(image, dtype=np.uint8),
-                                     where=mask)
-
-    return image_without_back
-
-
-def label_instances(image_segmented):
-    """Count and label the different instances previously segmented in an
-    image.
-
-    Parameters
-    ----------
-    image_segmented : np.ndarray, bool
-        Binary segmented image with shape (y, x).
-
-    Returns
-    -------
-    image_label : np.ndarray, np.uint64
-        Labelled image. Each object is characterized by the same pixel value.
-    nb_labels : int
-        Number of different instances counted in the image.
-
-    """
-    image_label, nb_labels = label(image_segmented, return_num=True)
-    return image_label, nb_labels
-
-
-def cyt_segmentation_2d(tensor, r, c_nuc, c_cyt, segmentation_method):
-    # TODO add documentation
-    # check tensor dimensions and its dtype
-    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-
-    # apply segmentation
-    # TODO validate the pipeline with this cast
-    image_segmented = stack.cast_img_uint8(tensor)
-    if segmentation_method == "watershed":
-        image_segmented = watershed_2d(image_segmented, r, c_nuc, c_cyt)
-    else:
-        pass
-    return image_segmented
-
-
-def watershed_2d(tensor, r, c_nuc, c_cyt):
-    # TODO add documentation
-    # TODO better integration with nuclei segmentation
-    # nuclei segmentation
-    _, nuc_labelled, _ = nuc_segmentation_2d(
-        tensor,
-        projection_method="mip",
-        r=r, c=c_nuc,
-        segmentation_method="threshold",
-        return_label=True)
-
-    # get source image
-    cyt = tensor[r, c_cyt, :, :, :]
-    cyt_projected = stack.projection(tensor, method="mip", r=r, c=c_cyt)
-
-    # get a mask for the cytoplasm
-    mask = (cyt_projected > threshold_otsu(cyt_projected))
-    mask = remove_small_objects(mask, 200)
-    mask = remove_small_holes(mask, 200)
-
-    # get image to apply watershed on
-    seed = np.sum(cyt, 0)
-    seed = seed.max() - seed
-    seed[nuc_labelled > 0] = 0
-
-    # get the markers from the nuclei
-    markers = np.zeros_like(seed)
-    for r in regionprops(nuc_labelled):
-        markers[tuple(map(int, r.centroid))] = r.label
-
-    # apply watershed
-    cyt_segmented = watershed(seed, markers, mask=mask)
-
-    return cyt_segmented
diff --git a/bigfish/segmentation/utils.py b/bigfish/segmentation/utils.py
new file mode 100644
index 00000000..700c87d1
--- /dev/null
+++ b/bigfish/segmentation/utils.py
@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+"""
+Utilities function for nuclei and cytoplasm segmentation.
+"""
+
+from skimage.measure import label
+
+
+def label_instances(image_segmented):
+    """Count and label the different instances previously segmented in an
+    image.
+
+    Parameters
+    ----------
+    image_segmented : np.ndarray, bool
+        Binary segmented image with shape (y, x).
+
+    Returns
+    -------
+    image_label : np.ndarray, np.uint64
+        Labelled image. Each object is characterized by the same pixel value.
+    nb_labels : int
+        Number of different instances counted in the image.
+
+    """
+    image_label, nb_labels = label(image_segmented, return_num=True)
+    return image_label, nb_labels

From a557cb2abddd54a990a88a89bbb977ffc992cc32 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 13 May 2019 15:56:17 +0200
Subject: [PATCH 139/264] add rescale parameter in the plot

---
 bigfish/plot/plot_images.py | 75 +++++++++++++++++++++++++++----------
 1 file changed, 56 insertions(+), 19 deletions(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 83e2b37a..5eece46d 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -15,11 +15,9 @@
 from matplotlib.colors import ListedColormap
 
 
-# TODO add title in the plot and remove axes
-# TODO add parameter for vmin and vmax
-
-def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
-            remove_frame=False, path_output=None, ext="png"):
+def plot_yx(tensor, r=0, c=0, z=0, rescale=False, title=None,
+            framesize=(15, 15), remove_frame=False, path_output=None,
+            ext="png"):
     """Plot the selected yx plan of the selected dimensions of an image.
 
     Parameters
@@ -33,6 +31,8 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
         Index of the channel to keep.
     z : int
         Index of the z slice to keep.
+    rescale : bool
+        Rescale pixel values of the image (made by default in matplotlib).
     title : str
         Title of the image.
     framesize : tuple
@@ -57,6 +57,7 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
                              bool],
                       allow_nan=False)
     stack.check_parameter(r=int, c=int, z=int,
+                          rescale=bool,
                           title=(str, type(None)),
                           framesize=tuple,
                           remove_frame=bool,
@@ -73,7 +74,9 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
         xy_tensor = tensor[r, c, z, :, :]
 
     # get minimum and maximum value of the image
-    vmin, vmax = get_minmax_values(tensor)
+    vmin, vmax = None, None
+    if not rescale:
+        vmin, vmax = get_minmax_values(tensor)
 
     # plot
     if remove_frame:
@@ -82,7 +85,10 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
         ax.axis('off')
     else:
         plt.figure(figsize=framesize)
-    plt.imshow(xy_tensor, vmin=vmin, vmax=vmax)
+    if not rescale:
+        plt.imshow(xy_tensor, vmin=vmin, vmax=vmax)
+    else:
+        plt.imshow(xy_tensor)
     if title is not None and not remove_frame:
         plt.title(title, fontweight="bold", fontsize=25)
     if not remove_frame:
@@ -94,14 +100,16 @@ def plot_yx(tensor, r=0, c=0, z=0, title=None, framesize=(15, 15),
     return
 
 
-def plot_images(tensors, titles=None, framesize=(15, 15), remove_frame=False,
-                path_output=None, ext="png"):
+def plot_images(tensors, rescale=False, titles=None, framesize=(15, 15),
+                remove_frame=False, path_output=None, ext="png"):
     """Plot or subplot of 2-d images.
 
     Parameters
     ----------
     tensors : np.ndarray or List[np.ndarray]
         Images with shape (y, x).
+    rescale : bool
+        Rescale pixel values of the image (made by default in matplotlib).
     titles : List[str]
         Titles of the subplots.
     framesize : tuple
@@ -124,6 +132,7 @@ def plot_images(tensors, titles=None, framesize=(15, 15), remove_frame=False,
 
     # check parameters
     stack.check_parameter(tensors=list,
+                          rescale=bool,
                           titles=(str, list, type(None)),
                           framesize=tuple,
                           remove_frame=bool,
@@ -143,8 +152,13 @@ def plot_images(tensors, titles=None, framesize=(15, 15), remove_frame=False,
 
     # plot one image
     if len(tensors) == 1:
-        plot_yx(tensors[0], title=titles[0], framesize=framesize,
-                remove_frame=remove_frame, path_output=path_output, ext=ext)
+        plot_yx(tensors[0],
+                rescale=rescale,
+                title=titles[0],
+                framesize=framesize,
+                remove_frame=remove_frame,
+                path_output=path_output,
+                ext=ext)
 
         return
 
@@ -156,8 +170,11 @@ def plot_images(tensors, titles=None, framesize=(15, 15), remove_frame=False,
         for i, tensor in enumerate(tensors):
             if remove_frame:
                 ax[i].axis("off")
-            vmin, vmax = get_minmax_values(tensor)
-            ax[i].imshow(tensor, vmin=vmin, vmax=vmax)
+            if not rescale:
+                vmin, vmax = get_minmax_values(tensor)
+                ax[i].imshow(tensor, vmin=vmin, vmax=vmax)
+            else:
+                ax[i].imshow(tensor)
             if titles is not None:
                 ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
 
@@ -175,8 +192,11 @@ def plot_images(tensors, titles=None, framesize=(15, 15), remove_frame=False,
                 continue
             if remove_frame:
                 ax[row, col].axis("off")
-            vmin, vmax = get_minmax_values(tensor)
-            ax[row, col].imshow(tensor, vmin=vmin, vmax=vmax)
+            if not rescale:
+                vmin, vmax = get_minmax_values(tensor)
+                ax[row, col].imshow(tensor, vmin=vmin, vmax=vmax)
+            else:
+                ax[row, col].imshow(tensor)
             if titles is not None:
                 ax[row, col].set_title(titles[i],
                                        fontweight="bold", fontsize=15)
@@ -189,8 +209,9 @@ def plot_images(tensors, titles=None, framesize=(15, 15), remove_frame=False,
     return
 
 
-def plot_channels_2d(tensor, r=0, z=0, titles=None, framesize=(15, 15),
-                     remove_frame=False, path_output=None, ext="png"):
+def plot_channels_2d(tensor, r=0, z=0, rescale=False, titles=None,
+                     framesize=(15, 15), remove_frame=False, path_output=None,
+                     ext="png"):
     """Subplot the yx plan of the selected dimensions of an image for all
     channels.
 
@@ -202,6 +223,8 @@ def plot_channels_2d(tensor, r=0, z=0, titles=None, framesize=(15, 15),
         Index of the round to keep.
     z : int
         Index of the z slice to keep.
+    rescale : bool
+        Rescale pixel values of the image (made by default in matplotlib).
     titles : List[str]
         Titles of the subplots (one per channel).
     framesize : tuple
@@ -225,6 +248,7 @@ def plot_channels_2d(tensor, r=0, z=0, titles=None, framesize=(15, 15),
                       allow_nan=False)
     stack.check_parameter(r=int,
                           z=int,
+                          rescale=bool,
                           titles=(list, type(None)),
                           framesize=tuple,
                           remove_frame=bool,
@@ -235,12 +259,17 @@ def plot_channels_2d(tensor, r=0, z=0, titles=None, framesize=(15, 15),
     nb_channels = tensor.shape[1]
 
     # get the minimum and maximal values of the tensor dtype
-    vmin, vmax = get_minmax_values(tensor)
+    vmin, vmax = None, None
+    if not rescale:
+        vmin, vmax = get_minmax_values(tensor)
 
     # plot
     fig, ax = plt.subplots(1, nb_channels, sharex='col', figsize=framesize)
     for i in range(nb_channels):
-        ax[i].imshow(tensor[r, i, z, :, :], vmin=vmin, vmax=vmax)
+        if not rescale:
+            ax[i].imshow(tensor[r, i, z, :, :], vmin=vmin, vmax=vmax)
+        else:
+            ax[i].imshow(tensor[r, i, z, :, :], vmin=vmin, vmax=vmax)
         if titles is not None:
             ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
         if remove_frame:
@@ -281,6 +310,8 @@ def plot_illumination_surface(illumination_surface, r=0, framesize=(15, 15),
     -------
 
     """
+    # TODO add title in the plot and remove axes
+    # TODO add parameter for vmin and vmax
     # check tensor
     stack.check_array(illumination_surface, ndim=4,
                       dtype=[np.float32, np.float64])
@@ -329,6 +360,8 @@ def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
     -------
 
     """
+    # TODO add title in the plot and remove axes
+    # TODO add parameter for vmin and vmax
     # check tensor
     stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
     stack.check_array(projection, ndim=2, dtype=[np.uint8, np.uint16,
@@ -378,6 +411,8 @@ def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
     -------
 
     """
+    # TODO add title in the plot and remove axes
+    # TODO add parameter for vmin and vmax
     # check tensor
     stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
     stack.check_array(segmentation, ndim=2, dtype=bool)
@@ -453,6 +488,8 @@ def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
     -------
 
     """
+    # TODO add title in the plot and remove axes
+    # TODO add parameter for vmin and vmax
     # TODO check coordinates shape
     # check tensor
     stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])

From e01ae12f9cacea8d019c48bb218d9df229dbe7cc Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 13 May 2019 15:57:02 +0200
Subject: [PATCH 140/264] remove 'plot_projection'

---
 bigfish/plot/__init__.py    |  4 ++--
 bigfish/plot/plot_images.py | 48 -------------------------------------
 2 files changed, 2 insertions(+), 50 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index 12a94292..9eb36a6d 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -5,14 +5,14 @@
 """
 
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
-                          plot_projection, plot_images, plot_spot_detection,
+                          plot_images, plot_spot_detection,
                           plot_illumination_surface)
 from .plot_coordinates import (plot_volume, plot_rna, plot_distribution_rna,
                                plot_cell_coordinates, plot_layers_coordinates)
 from .plot_classification import plot_confusion_matrix, plot_2d_projection
 
 
-_images = ["plot_yx", "plot_images", "plot_channels_2d", "plot_projection",
+_images = ["plot_yx", "plot_images", "plot_channels_2d",
            "plot_illumination_surface", "plot_segmentation",
            "plot_spot_detection"]
 
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 5eece46d..d7148ff2 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -332,54 +332,6 @@ def plot_illumination_surface(illumination_surface, r=0, framesize=(15, 15),
     return
 
 
-def plot_projection(tensor, projection, r=0, c=0, z=0, framesize=(15, 15),
-                    path_output=None, ext="png"):
-    """Plot result of a 2-d projection.
-
-    Parameters
-    ----------
-    tensor : np.ndarray, np.uint
-        A 5-d tensor with shape (r, c, z, y, x).
-    projection : np.ndarray
-        A 2-d image with shape (y, x).
-    r : int
-        Index of the round to keep.
-    c : int
-        Index of the channel to keep.
-    z : int
-        Index of the z-slice to keep.
-    framesize : tuple
-        Size of the frame used to plot (plt.figure(figsize=framesize).
-    path_output : str
-        Path to save the image (without extension).
-    ext : str or List[str]
-        Extension used to save the plot. If it is a list of strings, the plot
-        will be saved several times.
-
-    Returns
-    -------
-
-    """
-    # TODO add title in the plot and remove axes
-    # TODO add parameter for vmin and vmax
-    # check tensor
-    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-    stack.check_array(projection, ndim=2, dtype=[np.uint8, np.uint16,
-                                                 np.float32, np.float64])
-
-    # plot
-    fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
-    ax[0].imshow(tensor[r, c, z, :, :])
-    ax[0].set_title("Z-slice: {0}".format(z), fontweight="bold", fontsize=15)
-    ax[1].imshow(projection)
-    ax[1].set_title("Projected image", fontweight="bold", fontsize=15)
-    plt.tight_layout()
-    save_plot(path_output, ext)
-    plt.show()
-
-    return
-
-
 def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
                       bondary=False, framesize=(15, 15),
                       path_output=None, ext="png"):

From 74402863bd508b6c01f847712481073b0799a854 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 13 May 2019 16:19:25 +0200
Subject: [PATCH 141/264] improve 'plot_segmentation'

---
 bigfish/plot/__init__.py    |   4 +-
 bigfish/plot/plot_images.py | 107 +++++++++++++++++++++++++++++++++---
 2 files changed, 100 insertions(+), 11 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index 9eb36a6d..d7a16d44 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -5,14 +5,14 @@
 """
 
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
-                          plot_images, plot_spot_detection,
+                          plot_images, plot_spot_detection, plot_boundaries,
                           plot_illumination_surface)
 from .plot_coordinates import (plot_volume, plot_rna, plot_distribution_rna,
                                plot_cell_coordinates, plot_layers_coordinates)
 from .plot_classification import plot_confusion_matrix, plot_2d_projection
 
 
-_images = ["plot_yx", "plot_images", "plot_channels_2d",
+_images = ["plot_yx", "plot_images", "plot_channels_2d", "plot_boundaries",
            "plot_illumination_surface", "plot_segmentation",
            "plot_spot_detection"]
 
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index d7148ff2..f30fe683 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -16,7 +16,7 @@
 
 
 def plot_yx(tensor, r=0, c=0, z=0, rescale=False, title=None,
-            framesize=(15, 15), remove_frame=False, path_output=None,
+            framesize=(8, 8), remove_frame=False, path_output=None,
             ext="png"):
     """Plot the selected yx plan of the selected dimensions of an image.
 
@@ -100,7 +100,7 @@ def plot_yx(tensor, r=0, c=0, z=0, rescale=False, title=None,
     return
 
 
-def plot_images(tensors, rescale=False, titles=None, framesize=(15, 15),
+def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
                 remove_frame=False, path_output=None, ext="png"):
     """Plot or subplot of 2-d images.
 
@@ -210,7 +210,7 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 15),
 
 
 def plot_channels_2d(tensor, r=0, z=0, rescale=False, titles=None,
-                     framesize=(15, 15), remove_frame=False, path_output=None,
+                     framesize=(15, 5), remove_frame=False, path_output=None,
                      ext="png"):
     """Subplot the yx plan of the selected dimensions of an image for all
     channels.
@@ -269,7 +269,7 @@ def plot_channels_2d(tensor, r=0, z=0, rescale=False, titles=None,
         if not rescale:
             ax[i].imshow(tensor[r, i, z, :, :], vmin=vmin, vmax=vmax)
         else:
-            ax[i].imshow(tensor[r, i, z, :, :], vmin=vmin, vmax=vmax)
+            ax[i].imshow(tensor[r, i, z, :, :])
         if titles is not None:
             ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
         if remove_frame:
@@ -332,11 +332,102 @@ def plot_illumination_surface(illumination_surface, r=0, framesize=(15, 15),
     return
 
 
-def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
-                      bondary=False, framesize=(15, 15),
-                      path_output=None, ext="png"):
+def plot_segmentation(tensor, mask, rescale=False, title=None,
+                      framesize=(15, 5), remove_frame=False, path_output=None,
+                      ext="png"):
     """Plot result of a 2-d segmentation, with labelled instances if available.
 
+    Parameters
+    ----------
+    tensor : np.ndarray
+        A 2-d tensor with shape (y, x).
+    mask : np.ndarray
+        A 2-d image with shape (y, x).
+    rescale : bool
+        Rescale pixel values of the image (made by default in matplotlib).
+    title : str
+        Title of the image.
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    remove_frame : bool
+        Remove axes and frame.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # check parameters
+    stack.check_array(tensor,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16,
+                             np.float32, np.float64,
+                             bool],
+                      allow_nan=False)
+    stack.check_array(mask,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64, bool],
+                      allow_nan=False)
+    stack.check_parameter(rescale=bool,
+                          title=(str, type(None)),
+                          framesize=tuple,
+                          remove_frame=bool,
+                          path_output=(str, type(None)),
+                          ext=(str, list))
+
+    # get minimum and maximum value of the image
+    vmin, vmax = None, None
+    if not rescale:
+        vmin, vmax = get_minmax_values(tensor)
+
+    # plot
+    fig, ax = plt.subplots(1, 3, sharex='col', figsize=framesize)
+
+    # image
+    if not rescale:
+        ax[0].imshow(tensor, vmin=vmin, vmax=vmax)
+    else:
+        ax[0].imshow(tensor)
+    if title is not None:
+        ax[0].set_title(title, fontweight="bold", fontsize=10)
+    if remove_frame:
+        ax[0].axis("off")
+
+    # label
+    ax[1].imshow(mask)
+    if title is not None:
+        ax[1].set_title("Segmentation", fontweight="bold", fontsize=10)
+    if remove_frame:
+        ax[1].axis("off")
+
+    # superposition
+    if not rescale:
+        ax[2].imshow(tensor, vmin=vmin, vmax=vmax)
+    else:
+        ax[2].imshow(tensor)
+    masked = np.ma.masked_where(mask == 0, mask)
+    ax[2].imshow(masked, cmap='autumn', alpha=0.5)
+    if title is not None:
+        ax[2].set_title("Superposition", fontweight="bold", fontsize=10)
+    if remove_frame:
+        ax[2].axis("off")
+
+    plt.tight_layout()
+    if path_output is not None:
+        save_plot(path_output, ext)
+    plt.show()
+
+    return
+
+
+def plot_boundaries(tensor, segmentation, r=0, c=0, z=0, label=None,
+                    bondary=False, framesize=(15, 15),
+                    path_output=None, ext="png"):
+    """Plot result of a 2-d segmentation, with labelled instances if available.
     Parameters
     ----------
     tensor : np.ndarray, np.uint
@@ -358,10 +449,8 @@ def plot_segmentation(tensor, segmentation, r=0, c=0, z=0, label=None,
     ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
-
     Returns
     -------
-
     """
     # TODO add title in the plot and remove axes
     # TODO add parameter for vmin and vmax

From 27383508d43ab9e69274b6cf28613b6eacbf4d88 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 13 May 2019 16:29:01 +0200
Subject: [PATCH 142/264] improve 'plot_segmentation' #2

---
 bigfish/plot/__init__.py    |  4 +-
 bigfish/plot/plot_images.py | 94 +++++++------------------------------
 2 files changed, 18 insertions(+), 80 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index d7a16d44..9eb36a6d 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -5,14 +5,14 @@
 """
 
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
-                          plot_images, plot_spot_detection, plot_boundaries,
+                          plot_images, plot_spot_detection,
                           plot_illumination_surface)
 from .plot_coordinates import (plot_volume, plot_rna, plot_distribution_rna,
                                plot_cell_coordinates, plot_layers_coordinates)
 from .plot_classification import plot_confusion_matrix, plot_2d_projection
 
 
-_images = ["plot_yx", "plot_images", "plot_channels_2d", "plot_boundaries",
+_images = ["plot_yx", "plot_images", "plot_channels_2d",
            "plot_illumination_surface", "plot_segmentation",
            "plot_spot_detection"]
 
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index f30fe683..250505f8 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -332,9 +332,9 @@ def plot_illumination_surface(illumination_surface, r=0, framesize=(15, 15),
     return
 
 
-def plot_segmentation(tensor, mask, rescale=False, title=None,
-                      framesize=(15, 5), remove_frame=False, path_output=None,
-                      ext="png"):
+def plot_segmentation(tensor, mask, rescale=False, plot_surface=False,
+                      title=None, framesize=(15, 5), remove_frame=False,
+                      path_output=None, ext="png"):
     """Plot result of a 2-d segmentation, with labelled instances if available.
 
     Parameters
@@ -345,6 +345,8 @@ def plot_segmentation(tensor, mask, rescale=False, title=None,
         A 2-d image with shape (y, x).
     rescale : bool
         Rescale pixel values of the image (made by default in matplotlib).
+    plot_surface : bool
+        Plot the surface of the segmented object (or its boundary).
     title : str
         Title of the image.
     framesize : tuple
@@ -409,10 +411,17 @@ def plot_segmentation(tensor, mask, rescale=False, title=None,
         ax[2].imshow(tensor, vmin=vmin, vmax=vmax)
     else:
         ax[2].imshow(tensor)
-    masked = np.ma.masked_where(mask == 0, mask)
-    ax[2].imshow(masked, cmap='autumn', alpha=0.5)
-    if title is not None:
-        ax[2].set_title("Superposition", fontweight="bold", fontsize=10)
+    if not plot_surface:
+        boundaries = find_boundaries(mask, mode='thick')
+        boundaries = np.ma.masked_where(boundaries == 0, boundaries)
+        ax[2].imshow(boundaries, cmap=ListedColormap(['red']))
+        if title is not None:
+            ax[2].set_title("Boundary", fontweight="bold", fontsize=10)
+    else:
+        masked = np.ma.masked_where(mask == 0, mask)
+        ax[2].imshow(masked, cmap=ListedColormap(['cyan']), alpha=0.5)
+        if title is not None:
+            ax[2].set_title("Surface", fontweight="bold", fontsize=10)
     if remove_frame:
         ax[2].axis("off")
 
@@ -424,77 +433,6 @@ def plot_segmentation(tensor, mask, rescale=False, title=None,
     return
 
 
-def plot_boundaries(tensor, segmentation, r=0, c=0, z=0, label=None,
-                    bondary=False, framesize=(15, 15),
-                    path_output=None, ext="png"):
-    """Plot result of a 2-d segmentation, with labelled instances if available.
-    Parameters
-    ----------
-    tensor : np.ndarray, np.uint
-        A 5-d tensor with shape (r, c, z, y, x).
-    segmentation : np.ndarray, bool
-        A 2-d image with shape (y, x).
-    r : int
-        Index of the round to keep.
-    c : int
-        Index of the channel to keep.
-    z : int
-        Index of the z-slice to keep.
-    label : np.ndarray, np.int64
-        A 2-d image with shape (y, x).
-    framesize : tuple
-        Size of the frame used to plot (plt.figure(figsize=framesize).
-    path_output : str
-        Path to save the image (without extension).
-    ext : str or List[str]
-        Extension used to save the plot. If it is a list of strings, the plot
-        will be saved several times.
-    Returns
-    -------
-    """
-    # TODO add title in the plot and remove axes
-    # TODO add parameter for vmin and vmax
-    # check tensor
-    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-    stack.check_array(segmentation, ndim=2, dtype=bool)
-    if label is not None:
-        stack.check_array(label, ndim=2, dtype=np.int64)
-
-    # TODO clean it
-    boundaries = None
-    if bondary and label is not None:
-        boundaries = find_boundaries(label, mode='thick')
-        boundaries = np.ma.masked_where(boundaries == 0, boundaries)
-
-    # plot
-    if label is not None:
-        fig, ax = plt.subplots(1, 3, sharex='col', figsize=framesize)
-        ax[0].imshow(tensor[r, c, z, :, :])
-        ax[0].imshow(boundaries, cmap=ListedColormap(['red']))
-        ax[0].set_title("Z-slice: {0}".format(z),
-                        fontweight="bold", fontsize=15)
-        ax[1].imshow(segmentation)
-        ax[1].imshow(boundaries, cmap=ListedColormap(['red']))
-        ax[1].set_title("Segmentation", fontweight="bold", fontsize=15)
-        ax[2].imshow(label)
-        ax[2].imshow(boundaries, cmap=ListedColormap(['red']))
-        ax[2].set_title("Labels", fontweight="bold", fontsize=15)
-
-    else:
-        fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
-        ax[0].imshow(tensor[r, c, z, :, :])
-        ax[0].set_title("Z-slice: {0}".format(z),
-                        fontweight="bold", fontsize=15)
-        ax[1].imshow(segmentation)
-        ax[1].set_title("Segmentation", fontweight="bold", fontsize=15)
-
-    plt.tight_layout()
-    save_plot(path_output, ext)
-    plt.show()
-
-    return
-
-
 def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
                         framesize=(15, 15), projection_2d=False,
                         path_output=None, ext="png"):

From eecec7d25b64b082544a612dd360c8e075a3c76f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 13 May 2019 16:38:58 +0200
Subject: [PATCH 143/264] add 'plot_segmentation_boundary'

---
 bigfish/plot/__init__.py    |   5 +-
 bigfish/plot/plot_images.py | 101 ++++++++++++++++++++++++++++++------
 2 files changed, 89 insertions(+), 17 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index 9eb36a6d..ae3c2f62 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -6,7 +6,8 @@
 
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
                           plot_images, plot_spot_detection,
-                          plot_illumination_surface)
+                          plot_illumination_surface,
+                          plot_segmentation_boundary)
 from .plot_coordinates import (plot_volume, plot_rna, plot_distribution_rna,
                                plot_cell_coordinates, plot_layers_coordinates)
 from .plot_classification import plot_confusion_matrix, plot_2d_projection
@@ -14,7 +15,7 @@
 
 _images = ["plot_yx", "plot_images", "plot_channels_2d",
            "plot_illumination_surface", "plot_segmentation",
-           "plot_spot_detection"]
+           "plot_spot_detection", "plot_segmentation_boundary"]
 
 _coordinates = ["plot_volume", "plot_rna", "plot_distribution_rna",
                 "plot_cell_coordinates", "plot_layers_coordinates"]
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 250505f8..eaff7316 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -332,8 +332,8 @@ def plot_illumination_surface(illumination_surface, r=0, framesize=(15, 15),
     return
 
 
-def plot_segmentation(tensor, mask, rescale=False, plot_surface=False,
-                      title=None, framesize=(15, 5), remove_frame=False,
+def plot_segmentation(tensor, mask, rescale=False, title=None,
+                      framesize=(15, 5), remove_frame=False,
                       path_output=None, ext="png"):
     """Plot result of a 2-d segmentation, with labelled instances if available.
 
@@ -345,8 +345,6 @@ def plot_segmentation(tensor, mask, rescale=False, plot_surface=False,
         A 2-d image with shape (y, x).
     rescale : bool
         Rescale pixel values of the image (made by default in matplotlib).
-    plot_surface : bool
-        Plot the surface of the segmented object (or its boundary).
     title : str
         Title of the image.
     framesize : tuple
@@ -411,17 +409,10 @@ def plot_segmentation(tensor, mask, rescale=False, plot_surface=False,
         ax[2].imshow(tensor, vmin=vmin, vmax=vmax)
     else:
         ax[2].imshow(tensor)
-    if not plot_surface:
-        boundaries = find_boundaries(mask, mode='thick')
-        boundaries = np.ma.masked_where(boundaries == 0, boundaries)
-        ax[2].imshow(boundaries, cmap=ListedColormap(['red']))
-        if title is not None:
-            ax[2].set_title("Boundary", fontweight="bold", fontsize=10)
-    else:
-        masked = np.ma.masked_where(mask == 0, mask)
-        ax[2].imshow(masked, cmap=ListedColormap(['cyan']), alpha=0.5)
-        if title is not None:
-            ax[2].set_title("Surface", fontweight="bold", fontsize=10)
+    masked = np.ma.masked_where(mask == 0, mask)
+    ax[2].imshow(masked, cmap=ListedColormap(['cyan']), alpha=0.5)
+    if title is not None:
+        ax[2].set_title("Surface", fontweight="bold", fontsize=10)
     if remove_frame:
         ax[2].axis("off")
 
@@ -433,6 +424,86 @@ def plot_segmentation(tensor, mask, rescale=False, plot_surface=False,
     return
 
 
+def plot_segmentation_boundary(tensor, mask, rescale=False, title=None,
+                               framesize=(10, 10), remove_frame=False,
+                               path_output=None, ext="png"):
+    """Plot the boundary of the segmented objects.
+
+    Parameters
+    ----------
+    tensor : np.ndarray
+        A 2-d tensor with shape (y, x).
+    mask : np.ndarray
+        A 2-d image with shape (y, x).
+    rescale : bool
+        Rescale pixel values of the image (made by default in matplotlib).
+    title : str
+        Title of the image.
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    remove_frame : bool
+        Remove axes and frame.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # TODO compute boundary separately
+    # check parameters
+    stack.check_array(tensor,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16,
+                             np.float32, np.float64,
+                             bool],
+                      allow_nan=False)
+    stack.check_array(mask,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64, bool],
+                      allow_nan=False)
+    stack.check_parameter(rescale=bool,
+                          title=(str, type(None)),
+                          framesize=tuple,
+                          remove_frame=bool,
+                          path_output=(str, type(None)),
+                          ext=(str, list))
+
+    # get minimum and maximum value of the image
+    vmin, vmax = None, None
+    if not rescale:
+        vmin, vmax = get_minmax_values(tensor)
+
+    # get boundary
+    boundaries = find_boundaries(mask, mode='thick')
+    boundaries = np.ma.masked_where(boundaries == 0, boundaries)
+
+    # plot
+    if remove_frame:
+        fig = plt.figure(figsize=framesize, frameon=False)
+        ax = fig.add_axes([0, 0, 1, 1])
+        ax.axis('off')
+    else:
+        plt.figure(figsize=framesize)
+    if not rescale:
+        plt.imshow(tensor, vmin=vmin, vmax=vmax)
+    else:
+        plt.imshow(tensor)
+    plt.imshow(boundaries, cmap=ListedColormap(['red']))
+    if title is not None and not remove_frame:
+        plt.title(title, fontweight="bold", fontsize=25)
+    if not remove_frame:
+        plt.tight_layout()
+    if path_output is not None:
+        save_plot(path_output, ext)
+    plt.show()
+
+    return
+
+
 def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
                         framesize=(15, 15), projection_2d=False,
                         path_output=None, ext="png"):

From 08e20c2ac57b3c4c7fd1acb5bef3403d2c7d7e31 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 13 May 2019 16:48:29 +0200
Subject: [PATCH 144/264] change color plot

---
 bigfish/plot/plot_images.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index eaff7316..3aaf5bda 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -410,7 +410,7 @@ def plot_segmentation(tensor, mask, rescale=False, title=None,
     else:
         ax[2].imshow(tensor)
     masked = np.ma.masked_where(mask == 0, mask)
-    ax[2].imshow(masked, cmap=ListedColormap(['cyan']), alpha=0.5)
+    ax[2].imshow(masked, cmap=ListedColormap(['red']), alpha=0.5)
     if title is not None:
         ax[2].set_title("Surface", fontweight="bold", fontsize=10)
     if remove_frame:

From c3ce58c3fd8a0b564c6442ca656c464cdaf19093 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 13 May 2019 18:39:35 +0200
Subject: [PATCH 145/264] fix title bug

---
 bigfish/plot/plot_images.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 3aaf5bda..5d352241 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -152,9 +152,13 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
 
     # plot one image
     if len(tensors) == 1:
+        if titles is not None:
+            title = titles[0]
+        else:
+            title = None
         plot_yx(tensors[0],
                 rescale=rescale,
-                title=titles[0],
+                title=title,
                 framesize=framesize,
                 remove_frame=remove_frame,
                 path_output=path_output,

From d73c3eef70a515d8302cc3bdd03a9669dc18d8cd Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 17 May 2019 14:23:17 +0200
Subject: [PATCH 146/264] start unet script

---
 bigfish/segmentation/unet.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 bigfish/segmentation/unet.py

diff --git a/bigfish/segmentation/unet.py b/bigfish/segmentation/unet.py
new file mode 100644
index 00000000..e69de29b

From 64fc161008247dde14eea0b1a919c0fa8071a41a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 17 May 2019 14:24:07 +0200
Subject: [PATCH 147/264] add 'reconstruct_image'

---
 bigfish/stack/preprocess.py | 201 +++++++++++++++++++++++++++++++++++-
 1 file changed, 200 insertions(+), 1 deletion(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 692f4309..ea925fce 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -1182,9 +1182,208 @@ def cast_img_float64(tensor):
     return tensor
 
 
+# ### Resize and rescale ###
+# TODO debug
+def deconstruct_image(image, target_size):
+    """Deconstruct an image in a sequence of smaller or larger images in order
+    to fit with a segmentation method, while preserving image scale.
+
+    If the image need to be enlarged to reach the target size, we pad it. If
+    the current size is a multiple of the target size, image is cropped.
+    Otherwise, it is padded (to multiply the target size) then cropped.
+    Information about the deconstruction process are returned in order to
+    easily reconstruct the original image after transformation.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image to deconstruct with shape (y, x).
+    target_size : int
+        Size of the elements to return.
+
+    Returns
+    -------
+    images : List[np.ndarray]
+        List of images to analyse independently.
+    deconstruction : dict
+        Dictionary with deconstruction information to help the reconstruction
+        of the original image.
+
+    """
+    # TODO adapt to non squared images
+    # TODO add an overlap in the crop
+    # check parameters
+    check_array(image,
+                ndim=2,
+                dtype=[np.uint8, np.uint16,
+                       np.float32, np.float64,
+                       bool],
+                allow_nan=False)
+    check_parameter(target_size=int)
+
+    # initialize metadata
+    (width, height) = image.shape
+    deconstruction = {"cropped": False, "padded": False,
+                      "original_width": width, "original_height": height}
+
+    # check if the image is squared
+    if width != height:
+        raise ValueError("Non-squared image are not supported yet.")
+
+    # case where the image is too small
+    if width < target_size:
+
+        # padding
+        to_add = target_size - width
+        right = int(to_add / 2)
+        left = to_add - right
+        pad_width = ((left, right), (left, right))
+        images = [np.pad(image, pad_width, mode="symmetric")]
+        deconstruction["padded"] = True
+        deconstruction["pad_left"] = left
+        deconstruction["pad_right"] = right
+
+    # case where the image is too large
+    elif width > target_size:
+
+        # current size is not a multiple of the target size
+        if width % target_size != 0:
+
+            # padding
+            to_add = target_size * (1 + width // target_size) - width
+            right = int(to_add / 2)
+            left = to_add - right
+            pad_width = ((left, right), (left, right))
+            image = np.pad(image, pad_width, mode="symmetric")
+            deconstruction["padded"] = True
+            deconstruction["pad_left"] = left
+            deconstruction["pad_right"] = right
+            (width, height) = image.shape
+
+        # cropping
+        nb_row = height // target_size
+        nb_col = width // target_size
+        images = []
+        for i_row in range(nb_row):
+            row_start = i_row * target_size
+            row_end = (i_row + 1) * target_size
+            for i_col in range(nb_col):
+                col_start = i_col * target_size
+                col_end = (i_col + 1) * target_size
+                image_ = image[row_start:row_end, col_start:col_end]
+                images.append(image_)
+        deconstruction["cropped"] = True
+        deconstruction["nb_row"] = nb_row
+        deconstruction["nb_col"] = nb_col
+
+    else:
+        images = [image.copy()]
+
+    # store number of images created from the original one
+    deconstruction["nb_images"] = len(images)
+
+    return images, deconstruction
+
+
+def reconstruct_image(images, deconstruction):
+    """Reconstruct an image based on the information stored during the
+    deconstruction process (padding and cropping).
+
+    Parameters
+    ----------
+    images : List[np.ndarray] or np.ndarray
+        Images used to reconstruct an image with the original width and height.
+    deconstruction : dict
+        Information of the deconstruction process.
+
+    Returns
+    -------
+    reconstructed_image : np.ndarray
+        Image with the original width and height.
+
+    """
+    # TODO adapt to non squared images
+    # TODO add an overlap in the crop
+    # TODO handle the different overlapped label values
+    # check parameters
+    check_parameter(images=(np.ndarray, list),
+                    deconstruction=dict)
+    if isinstance(images, np.ndarray):
+        images = [images]
+    for image_ in images:
+        check_array(image_,
+                    ndim=2,
+                    dtype=[np.uint8, np.uint16,
+                           np.float32, np.float64,
+                           bool],
+                    allow_nan=False)
+
+    # case where the original image was padded then cropped
+    if deconstruction["padded"] and deconstruction["cropped"]:
+
+        # reconstruct the padded image (cropped => padded - original)
+        nb_row = deconstruction["nb_row"]
+        nb_col = deconstruction["nb_col"]
+        image_ = images[0]
+        (cropped_width, cropped_height) = image_.shape
+        reconstructed_image = np.zeros(
+            (nb_row * cropped_height, nb_col * cropped_width),
+            dtype=image_.dtype)
+        i = 0
+        for i_row in range(nb_row):
+            row_ = i_row * cropped_height
+            _row = (i_row + 1) * cropped_height
+            for i_col in range(nb_col):
+                col_ = i_col * cropped_width
+                _col = (i_col + 1) * cropped_width
+                reconstructed_image[row_:_row, col_:_col] = images[i]
+                i += 1
+
+        # reconstruct the original image (cropped - padded => original)
+        left = deconstruction["pad_left"]
+        right = deconstruction["pad_right"]
+        reconstructed_image = reconstructed_image[left:-right, left:-right]
+
+    # case where the original image was padded only
+    elif deconstruction["padded"] and not deconstruction["cropped"]:
+
+        # reconstruct the original image from a padding (padded => original)
+        left = deconstruction["pad_left"]
+        right = deconstruction["pad_right"]
+        reconstructed_image = images[0][left:-right, left:-right]
+
+    # case where the original image was cropped only
+    elif not deconstruction["padded"] and deconstruction["cropped"]:
+
+        # reconstruct the original image from a cropping (cropped => original)
+        nb_row = deconstruction["nb_row"]
+        nb_col = deconstruction["nb_col"]
+        image_ = images[0]
+        (cropped_width, cropped_height) = image_.shape
+        reconstructed_image = np.zeros(
+            (nb_row * cropped_height, nb_col * cropped_width),
+            dtype=image_.dtype)
+        i = 0
+        for i_row in range(nb_row):
+            row_ = i_row * cropped_height
+            _row = (i_row + 1) * cropped_height
+            for i_col in range(nb_col):
+                col_ = i_col * cropped_width
+                _col = (i_col + 1) * cropped_width
+                reconstructed_image[row_:_row, col_:_col] = images[i]
+                i += 1
+
+    # case where no deconstruction happened
+    else:
+        reconstructed_image = images[0].copy()
+
+    return reconstructed_image
+
+
 # ### Coordinates data cleaning ###
 
-def clean_simulated_data(data, data_cell, label_encoder=None, path_output=None):
+def clean_simulated_data(data, data_cell, label_encoder=None,
+                         path_output=None):
     """Clean simulated dataset.
 
     Parameters

From 5b837088ebf03e5cb0d1cb6d0c82017beffcf654 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 17 May 2019 14:24:39 +0200
Subject: [PATCH 148/264] fix 'save-image'

---
 bigfish/stack/io.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/io.py b/bigfish/stack/io.py
index 14de5718..0da925f3 100644
--- a/bigfish/stack/io.py
+++ b/bigfish/stack/io.py
@@ -6,6 +6,7 @@
 """
 
 import pickle
+import warnings
 
 import numpy as np
 import pandas as pd
@@ -143,11 +144,15 @@ def save_image(image, path):
     """
     # check image
     check_array(image,
-                dtype=[np.uint8, np.uint16, np.float32, np.float64, bool],
+                dtype=[np.uint8, np.uint16, np.int64,
+                       np.float32, np.float64,
+                       bool],
                 ndim=[2, 3],
                 allow_nan=False)
 
     # save image
-    io.imsave(path, image, check_contrast=False)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        io.imsave(path, image)
 
     return

From e5f46ed840bb43d0a7819b25b218a57a50900007 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 17 May 2019 14:25:14 +0200
Subject: [PATCH 149/264] improve focus projection

---
 bigfish/stack/__init__.py   |  16 +-
 bigfish/stack/projection.py | 408 +++++++++++++++++++++++++-----------
 2 files changed, 293 insertions(+), 131 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 8e44ab7d..6d722691 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -13,10 +13,14 @@
 from .preprocess import (build_simulated_dataset, build_stacks, build_stack,
                          build_stack_no_recipe, rescale,
                          cast_img_uint8, cast_img_uint16, cast_img_float32,
-                         cast_img_float64, clean_simulated_data)
+                         cast_img_float64, clean_simulated_data,
+                         deconstruct_image, reconstruct_image)
 from .filter import (log_filter, mean_filter, median_filter, maximum_filter,
                      minimum_filter, gaussian_filter, remove_background)
-from .projection import projection
+from .projection import (maximum_projection, mean_projection,
+                         median_projection, in_focus_selection,
+                         focus_measurement, get_in_focus_indices,
+                         focus_projection, focus_projection_fast)
 from .illumination import (compute_illumination_surface,
                            correct_illumination_surface)
 from .preparation import (split_from_background, build_image, get_coordinates,
@@ -38,12 +42,16 @@
 _preprocess = ["build_simulated_dataset", "build_stacks", "build_stack",
                "build_stack_no_recipe", "rescale",
                "cast_img_uint8", "cast_img_uint16", "cast_img_float32",
-               "cast_img_float64", "clean_simulated_data"]
+               "cast_img_float64", "clean_simulated_data", "deconstruct_image",
+               "reconstruct_image"]
 
 _filter = ["log_filter", "mean_filter", "median_filter", "maximum_filter",
            "minimum_filter", "gaussian_filter", "remove_background"]
 
-_projection = ["projection"]
+_projection = ["maximum_projection", "mean_projection", "median_projection",
+               "in_focus_selection", "focus_measurement",
+               "get_in_focus_indices", "focus_projection",
+               "focus_projection_fast"]
 
 _illumination = ["compute_illumination_surface",
                  "correct_illumination_surface"]
diff --git a/bigfish/stack/projection.py b/bigfish/stack/projection.py
index eb64d318..aabbb7f8 100644
--- a/bigfish/stack/projection.py
+++ b/bigfish/stack/projection.py
@@ -4,57 +4,39 @@
 
 import numpy as np
 
-from .utils import check_array
+from .utils import check_array, check_parameter
+from .preprocess import cast_img_uint8
+from .filter import mean_filter
 
-from skimage import img_as_ubyte, img_as_float32
-from skimage.filters import rank
-from skimage.morphology.selem import square
-
-
-# TODO add safety checks
 
 # ### Projections 2-d ###
 
-def projection(tensor, method="mip", r=0, c=0):
-    """ Project a tensor along the z-dimension.
+def maximum_projection(tensor):
+    """Project the z-dimension of a tensor, keeping the maximum intensity of
+    each yx pixel.
 
     Parameters
     ----------
     tensor : np.ndarray, np.uint
-        A 5-d tensor with shape (r, c, z, y, x).
-    method : str
-        Method used to project ('mip', 'focus').
-    r : int
-        Index of a specific round to project.
-    c : int
-        Index of a specific channel to project.
+        A 3-d tensor with shape (z, y, x).
 
     Returns
     -------
-    projected_tensor : np.ndarray
+    projected_tensor : np.ndarray, np.uint
         A 2-d tensor with shape (y, x).
 
     """
-    # check tensor dimensions and its dtype
-    check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-
-    # apply projection along the z-dimension
-    projected_tensor = tensor[r, c, :, :, :]
-    if method == "mip":
-        projected_tensor = maximum_projection(projected_tensor)
-    elif method == "mean":
-        projected_tensor = mean_projection(projected_tensor)
-    elif method == "median":
-        projected_tensor = median_projection(projected_tensor)
-    elif method == "focus":
-        # TODO complete focus projection with different strategies
-        raise ValueError("Focus projection is not implemented yet.")
+    # check parameters
+    check_array(tensor, ndim=3, dtype=[np.uint8, np.uint16], allow_nan=False)
+
+    # project tensor along the z axis
+    projected_tensor = tensor.max(axis=0)
 
     return projected_tensor
 
 
-def maximum_projection(tensor):
-    """Project the z-dimension of a tensor, keeping the maximum intensity of
+def mean_projection(tensor):
+    """Project the z-dimension of a tensor, computing the mean intensity of
     each yx pixel.
 
     Parameters
@@ -64,18 +46,21 @@ def maximum_projection(tensor):
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.uint
+    projected_tensor : np.ndarray, np.float
         A 2-d tensor with shape (y, x).
 
     """
+    # check parameters
+    check_array(tensor, ndim=3, dtype=[np.uint8, np.uint16], allow_nan=False)
+
     # project tensor along the z axis
-    projected_tensor = tensor.max(axis=0, keepdims=True)
+    projected_tensor = tensor.mean(axis=0)
 
-    return projected_tensor[0]
+    return projected_tensor
 
 
-def mean_projection(tensor):
-    """Project the z-dimension of a tensor, computing the mean intensity of
+def median_projection(tensor):
+    """Project the z-dimension of a tensor, computing the median intensity of
     each yx pixel.
 
     Parameters
@@ -85,19 +70,27 @@ def mean_projection(tensor):
 
     Returns
     -------
-    projected_tensor : np.ndarray, np.float
+    projected_tensor : np.ndarray, np.uint
         A 2-d tensor with shape (y, x).
 
     """
+    # check parameters
+    check_array(tensor, ndim=3, dtype=[np.uint8, np.uint16], allow_nan=False)
+
     # project tensor along the z axis
-    projected_tensor = tensor.mean(axis=0, keepdims=True)
+    projected_tensor = np.median(tensor, axis=0)
+    projected_tensor = projected_tensor.astype(tensor.dtype)
 
-    return projected_tensor[0]
+    return projected_tensor
 
 
-def median_projection(tensor):
-    """Project the z-dimension of a tensor, computing the median intensity of
-    each yx pixel.
+def focus_projection(tensor):
+    """Project the z-dimension of a tensor as describe in Aubin's thesis
+    (part 5.3, strategy 5).
+
+    1) We keep 75% best in-focus z-slices.
+    2) Compute a focus value for each voxel zyx with a 7x7 neighborhood window.
+    3) Keep the median pixel intensity among the top 5 best focus z-slices.
 
     Parameters
     ----------
@@ -110,64 +103,167 @@ def median_projection(tensor):
         A 2-d tensor with shape (y, x).
 
     """
-    # project tensor along the z axis
-    projected_tensor = tensor.median(axis=0, keepdims=True)
+    # check parameters
+    check_array(tensor, ndim=3, dtype=[np.uint8, np.uint16], allow_nan=False)
 
-    return projected_tensor[0]
+    # remove out-of-focus z-slices
+    in_focus_image = in_focus_selection(tensor,
+                                        proportion=0.75,
+                                        neighborhood_size=30)
 
+    # compute focus value for each voxel with a smaller window.
+    local_focus, _ = focus_measurement(in_focus_image, neighborhood_size=7)
 
-def focus_projection(tensor, channel=0, p=0.75, global_neighborhood_size=30,
-                     method="best"):
-    """
+    # for each yx pixel, get the indices of the 5 best focus values
+    top_local_focus_indices = np.argsort(local_focus, axis=0)
+    top_local_focus_indices = top_local_focus_indices[-5:, :, :]
+
+    # build a binary matrix with the same shape of our in-focus image to keep
+    # the top focus pixels only
+    mask = [mask_ for mask_ in map(
+        lambda indices: _one_hot_3d(indices, depth=in_focus_image.shape[0]),
+        top_local_focus_indices)]
+    mask = np.sum(mask, axis=0, dtype=in_focus_image.dtype)
+
+    # filter top focus pixels in our in-focus image
+    in_focus_image = np.multiply(in_focus_image, mask)
+
+    # project tensor
+    in_focus_image = in_focus_image.astype(np.float32)
+    in_focus_image[in_focus_image == 0] = np.nan
+    projected_tensor = np.nanmedian(in_focus_image, axis=0)
+    projected_tensor = projected_tensor.astype(tensor.dtype)
+
+    return projected_tensor
+
+
+def focus_projection_fast(tensor, proportion=0.75, neighborhood_size=7):
+    """Project the z-dimension of a tensor.
+
+    Inspired from Aubin's thesis (part 5.3, strategy 5). Compare to the
+    original algorithm we use the same focus levels to select the in-focus
+    z-slices and project our tensor.
+
+    1) Compute a focus value for each voxel zyx with a fixed neighborhood size.
+    2) We keep 75% best in-focus z-slices (based on a global focus score).
+    3) Keep the median pixel intensity among the top 5 best focus z-slices.
 
     Parameters
     ----------
-    tensor
-    channel
-    p
-    global_neighborhood_size
-    method
+    tensor : np.ndarray, np.uint
+        A 3-d tensor with shape (z, y, x).
+    proportion : float or int
+        Proportion of z-slices to keep (float between 0 and 1) or number of
+        z-slices to keep (integer above 1).
+    neighborhood_size : int
+        The size of the square used to define the neighborhood of each pixel.
 
     Returns
     -------
+    projected_tensor : np.ndarray, np.uint
+        A 2-d tensor with shape (y, x).
 
     """
+    # check parameters
+    check_array(tensor, ndim=3, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_parameter(proportion=(float, int),
+                    neighborhood_size=int)
+    if isinstance(proportion, float) and 0 <= proportion <= 1:
+        pass
+    elif isinstance(proportion, int) and 0 <= proportion:
+        pass
+    else:
+        raise ValueError("'proportion' should be a float between 0 and 1 or a "
+                         "positive integer, but not {0}.".format(proportion))
+
+    # compute focus value for each voxel.
+    local_focus, global_focus = focus_measurement(tensor, neighborhood_size)
+
+    # select and keep best z-slices
+    indices_to_keep = get_in_focus_indices(global_focus, proportion)
+    in_focus_image = tensor[indices_to_keep]
+    local_focus = local_focus[indices_to_keep]
+
+    # for each yx pixel, get the indices of the 5 best focus values
+    top_local_focus_indices = np.argsort(local_focus, axis=0)
+    n = min(local_focus.shape[0], 5)
+    top_local_focus_indices = top_local_focus_indices[-n:, :, :]
+
+    # build a binary matrix with the same shape of our in-focus image to keep
+    # the top focus pixels only
+    mask = [mask_ for mask_ in map(
+        lambda indices: _one_hot_3d(indices, depth=in_focus_image.shape[0]),
+        top_local_focus_indices)]
+    mask = np.sum(mask, axis=0, dtype=in_focus_image.dtype)
+
+    # filter top focus pixels in our in-focus image
+    in_focus_image = np.multiply(in_focus_image, mask)
+
+    # project tensor
+    in_focus_image = in_focus_image.astype(np.float32)
+    in_focus_image[in_focus_image == 0] = np.nan
+    projected_tensor = np.nanmedian(in_focus_image, axis=0)
+    projected_tensor = projected_tensor.astype(tensor.dtype)
 
-    # get 3-d image
-    image = tensor[0, channel, :, :, :]
+    return projected_tensor
 
-    # measure global focus level for each z-slices
-    ratio, l_focus = focus_measurement_3d(image, global_neighborhood_size)
 
-    # remove out-of-focus slices
-    indices_to_keep = get_in_focus(l_focus, p)
-    in_focus_image = image[indices_to_keep]
+# ### Focus selection ###
 
-    projected_image = None
-    if method == "bast":
-        # for each pixel, we project the z-slice value with the highest focus
-        ratio_2d = np.argmax(ratio[indices_to_keep], axis=0)
-        one_hot = one_hot_3d(ratio_2d, depth=len(indices_to_keep))
-        projected_image = np.multiply(in_focus_image, one_hot).max(axis=0)
-    elif method == "median":
-        # for each pixel, we compute the median value of the in-focus z-slices
-        projected_image = np.median(in_focus_image, axis=0)
-    elif method == "mean":
-        # for each pixel, we compute the mean value of the in-focus z-slices
-        projected_image = np.median(in_focus_image, axis=0)
+def in_focus_selection(image, proportion, neighborhood_size=30):
+    """Select and keep the slices with the highest level of focus.
 
-    return projected_image, ratio, l_focus
+    Helmli and Scherer’s mean method used as a focus metric.
 
+    Parameters
+    ----------
+    image : np.ndarray
+        A 3-d tensor with shape (z, y, x).
+    proportion : float or int
+        Proportion of z-slices to keep (float between 0 and 1) or number of
+        z-slices to keep (integer above 1).
+    neighborhood_size : int
+        The size of the square used to define the neighborhood of each pixel.
+
+    Returns
+    -------
+    in_focus_image : np.ndarray
+        A 3-d tensor with shape (z_in_focus, y, x), with out-of-focus z-slice
+        removed.
+
+    """
+    # check parameters
+    check_array(image,
+                ndim=3,
+                dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                allow_nan=False)
+    check_parameter(proportion=(float, int),
+                    neighborhood_size=int)
+    if isinstance(proportion, float) and 0 <= proportion <= 1:
+        pass
+    elif isinstance(proportion, int) and 0 <= proportion:
+        pass
+    else:
+        raise ValueError("'proportion' should be a float between 0 and 1 or a "
+                         "positive integer, but not {0}.".format(proportion))
+
+    # measure focus level
+    _, global_focus = focus_measurement(image, neighborhood_size)
+
+    # select and keep best z-slices
+    indices_to_keep = get_in_focus_indices(global_focus, proportion)
+    in_focus_image = image[indices_to_keep]
 
-def focus_measurement_2d(image, neighborhood_size):
+    return in_focus_image
+
+
+def focus_measurement(image, neighborhood_size=30):
     """Helmli and Scherer’s mean method used as a focus metric.
 
     For each pixel xy in an image, we compute the ratio:
 
         R(x, y) = mu(x, y) / I(x, y), if mu(x, y) >= I(x, y)
-
     or
-
         R(x, y) = I(x, y) / mu(x, y), otherwise
 
     with I(x, y) the intensity of the pixel xy and mu(x, y) the mean intensity
@@ -175,60 +271,99 @@ def focus_measurement_2d(image, neighborhood_size):
 
     Parameters
     ----------
-    image : np.ndarray, np.float32
-        A 2-d tensor with shape (y, x).
+    image : np.ndarray
+        A 2-d or 3-d tensor with shape (y, x) or (z, y, x).
     neighborhood_size : int
         The size of the square used to define the neighborhood of each pixel.
 
     Returns
     -------
-    global_focus : np.float32
-        Mean value of the ratio computed for every pixels of the image. Can be
-        used as a metric to quantify the focus level of an 2-d image.
     ratio : np.ndarray, np.float32
-        A 2-d tensor with the R(x, y) computed for each pixel of the original
-        image.
-    image_filtered_mean : np.ndarray, np.float32
-        A 2-d tensor with shape (y, x).
+        A 2-d or 3-d tensor with the R(x, y) computed for each pixel of the
+        original image.
+    global_focus : np.ndarray, np.float32
+        Mean value of the ratio computed for every pixels of each 2-d slice.
+        Can be used as a metric to quantify the focus level this slice. Shape
+        is (z,) for a 3-d image or (,) for a 2-d image.
 
     """
+    # check parameters
+    check_array(image,
+                ndim=[2, 3],
+                dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                allow_nan=False)
+    check_parameter(neighborhood_size=int)
+
+    # cast image in np.uint8
+    image = cast_img_uint8(image)
+
+    if image.ndim == 2:
+        ratio, global_focus = _focus_measurement_2d(image, neighborhood_size)
+    else:
+        ratio, global_focus = _focus_measurement_3d(image, neighborhood_size)
 
-    # scikit-image filter use np.uint dtype (so we cast to np.uint8)
-    image_2d = img_as_ubyte(image)
+    return ratio, global_focus
 
-    # filter the image with a mean filter
-    selem = square(neighborhood_size)
-    image_filtered_mean = rank.mean(image_2d, selem)
 
-    # cast again in np.float32
-    image_2d = img_as_float32(image_2d)
-    image_filtered_mean = img_as_float32(image_filtered_mean)
+def _focus_measurement_2d(image, neighborhood_size):
+    """Helmli and Scherer’s mean method used as a focus metric.
+
+    For each pixel xy in an image, we compute the ratio:
+
+        R(x, y) = mu(x, y) / I(x, y), if mu(x, y) >= I(x, y)
+    or
+        R(x, y) = I(x, y) / mu(x, y), otherwise
+
+    with I(x, y) the intensity of the pixel xy and mu(x, y) the mean intensity
+    of the pixels of its neighborhood.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.np.uint8
+        A 2-d tensor with shape (y, x).
+    neighborhood_size : int
+        The size of the square used to define the neighborhood of each pixel.
+
+    Returns
+    -------
+    ratio : np.ndarray, np.float32
+        A 2-d tensor with the R(x, y) computed for each pixel of the
+        original image.
+    global_focus : np.ndarray, np.float32
+        Mean value of the ratio computed for every pixels of each 2-d slice.
+        Can be used as a metric to quantify the focus level this slice. Shape
+        is () for a 2-d image.
+
+    """
+    # filter the image with a mean filter
+    image_filtered_mean = mean_filter(image, "square", neighborhood_size)
 
     # case where mu(x, y) >= I(x, y)
-    mask_1 = image_2d != 0
+    mask_1 = (image != 0)
     out_1 = np.zeros_like(image_filtered_mean, dtype=np.float32)
-    ratio_1 = np.divide(image_filtered_mean, image_2d, out=out_1, where=mask_1)
-    ratio_1 = np.where(image_filtered_mean >= image_2d, ratio_1, 0)
+    ratio_1 = np.divide(image_filtered_mean, image, out=out_1, where=mask_1)
+    ratio_1 = np.where(image_filtered_mean >= image, ratio_1, 0)
 
     # case where I(x, y) > mu(x, y)
     mask_2 = image_filtered_mean != 0
-    out_2 = np.zeros_like(image_2d, dtype=np.float32)
-    ratio_2 = np.divide(image_2d, image_filtered_mean, out=out_2, where=mask_2)
-    ratio_2 = np.where(image_2d > image_filtered_mean, ratio_2, 0)
+    out_2 = np.zeros_like(image, dtype=np.float32)
+    ratio_2 = np.divide(image, image_filtered_mean, out=out_2, where=mask_2)
+    ratio_2 = np.where(image > image_filtered_mean, ratio_2, 0)
 
     # compute ratio and global focus for the entire image
     ratio = ratio_1 + ratio_2
+    ratio = ratio.astype(np.float32)
     global_focus = ratio.mean()
 
-    return global_focus, ratio, image_filtered_mean
+    return ratio, global_focus
 
 
-def focus_measurement_3d(image, neighborhood_size):
+def _focus_measurement_3d(image, neighborhood_size):
     """Helmli and Scherer’s mean method used as a focus metric.
 
     Parameters
     ----------
-    image : np.ndarray, np.float32
+    image : np.ndarray, np.uint8
         A 3-d tensor with shape (z, y, x).
     neighborhood_size : int
         The size of the square used to define the neighborhood of each pixel.
@@ -236,59 +371,78 @@ def focus_measurement_3d(image, neighborhood_size):
     Returns
     -------
     ratio : np.ndarray, np.float32
-        A 3-d tensor with the R(x, y) computed for each pixel of the original
-        3-d image, for each z-slice.
-    l_focus : list
-        List of the global focus computed for each z-slice.
+        A 3-d tensor with the R(x, y) computed for each pixel of the
+        original image.
+    global_focus : np.ndarray, np.float32
+        Mean value of the ratio computed for every pixels of each 2-d slice.
+        Can be used as a metric to quantify the focus level this slice. Shape
+        is (z,) for a 3-d image.
 
     """
     # apply focus_measurement_2d for each z-slice
     l_ratio = []
     l_focus = []
     for z in range(image.shape[0]):
-        focus, ratio_2d, _ = focus_measurement_2d(image[z], neighborhood_size)
-        l_ratio.append(ratio_2d)
-        l_focus.append(focus)
+        ratio, global_focus = _focus_measurement_2d(image[z],
+                                                    neighborhood_size)
+        l_ratio.append(ratio)
+        l_focus.append(global_focus)
 
-    # get 3-d Helmli and Scherer’s ratio
+    # get a 3-d results
     ratio = np.stack(l_ratio)
+    global_focus = np.stack(l_focus)
 
-    return ratio, l_focus
+    return ratio, global_focus
 
 
-def get_in_focus(l_focus, proportion):
+def get_in_focus_indices(global_focus, proportion):
     """ Select the best in-focus z-slices.
 
     Parameters
     ----------
-    l_focus : array_like
-        List of the global focus computed for each z-slice.
+    global_focus : np.ndarray, np.float32
+        Mean value of the ratio computed for every pixels of each 2-d slice.
+        Can be used as a metric to quantify the focus level this slice. Shape
+        is (z,) for a 3-d image or () for a 2-d image.
     proportion : float or int
         Proportion of z-slices to keep (float between 0 and 1) or number of
         z-slices to keep (integer above 1).
 
     Returns
     -------
-    indices_to_keep : np.array
+    indices_to_keep : List[int]
+        Sorted indices of slices with the best focus score (decreasing score).
+
     """
-    # get the number of z-slices to keep
-    if proportion < 1 and isinstance(proportion, float):
-        n = int(len(l_focus) * proportion)
-    else:
+    # check parameters
+    check_parameter(global_focus=(np.ndarray, np.float32),
+                    proportion=(float, int))
+    if isinstance(global_focus, np.ndarray):
+        check_array(global_focus,
+                    ndim=[0, 1],
+                    dtype=np.float32,
+                    allow_nan=False)
+    if isinstance(proportion, float) and 0 <= proportion <= 1:
+        n = int(len(global_focus) * proportion)
+    elif isinstance(proportion, int) and 0 <= proportion:
         n = int(proportion)
+    else:
+        raise ValueError("'proportion' should be a float between 0 and 1 or a "
+                         "positive integer, but not {0}.".format(proportion))
 
     # select the best z-slices
-    indices_to_keep = np.argsort(l_focus)[-n:]
+    n = min(n, global_focus.size)
+    indices_to_keep = list(np.argsort(-global_focus)[:n])
 
     return indices_to_keep
 
 
-def one_hot_3d(tensor_2d, depth):
+def _one_hot_3d(indices, depth):
     """Build a 3-d one-hot matrix from a 2-d indices matrix.
 
     Parameters
     ----------
-    tensor_2d : np.ndarray, int
+    indices : np.ndarray, int
         A 2-d tensor with integer indices and shape (y, x).
     depth : int
         Depth of the 3-d one-hot matrix.
@@ -300,11 +454,11 @@ def one_hot_3d(tensor_2d, depth):
 
     """
     # initialize the 3-d one-hot matrix
-    one_hot = np.zeros((tensor_2d.size, depth), dtype=np.uint8)
+    one_hot = np.zeros((indices.size, depth), dtype=np.uint8)
 
     # flatten the matrix to easily one-hot encode it, then reshape it
-    one_hot[np.arange(tensor_2d.size), tensor_2d.ravel()] = 1
-    one_hot.shape = tensor_2d.shape + (depth,)
+    one_hot[np.arange(indices.size), indices.ravel()] = 1
+    one_hot.shape = indices.shape + (depth,)
 
     # rearrange the axis
     one_hot = np.moveaxis(one_hot, source=2, destination=0)

From 7c27d572cfca1024ff4f5ccb735b33f21fb93e27 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 17 May 2019 14:25:57 +0200
Subject: [PATCH 150/264] fix typo in doc

---
 bigfish/stack/filter.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
index 3072afde..e71c9148 100644
--- a/bigfish/stack/filter.py
+++ b/bigfish/stack/filter.py
@@ -297,7 +297,7 @@ def remove_background(image, kernel_shape="disk", kernel_size=200):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint
+    image : np.ndarray, np.uint8
         Image to process with shape (y, x). Casting in np.uint8 makes the
         computation faster.
     kernel_shape : str
@@ -314,7 +314,7 @@ def remove_background(image, kernel_shape="disk", kernel_size=200):
 
     """
     # check parameters
-    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_array(image, ndim=2, dtype=[np.uint8], allow_nan=False)
     check_parameter(kernel_shape=str,
                     kernel_size=(int, tuple, list))
 

From db2ad9cf6b572e48f95141a18271e0626b156923 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 17 May 2019 14:26:32 +0200
Subject: [PATCH 151/264] reduce size title

---
 bigfish/plot/plot_images.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 5d352241..57c6ee7a 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -180,7 +180,7 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
             else:
                 ax[i].imshow(tensor)
             if titles is not None:
-                ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
+                ax[i].set_title(titles[i], fontweight="bold", fontsize=10)
 
     # several rows
     else:
@@ -203,7 +203,7 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
                 ax[row, col].imshow(tensor)
             if titles is not None:
                 ax[row, col].set_title(titles[i],
-                                       fontweight="bold", fontsize=15)
+                                       fontweight="bold", fontsize=10)
 
     plt.tight_layout()
     if path_output is not None:
@@ -275,7 +275,7 @@ def plot_channels_2d(tensor, r=0, z=0, rescale=False, titles=None,
         else:
             ax[i].imshow(tensor[r, i, z, :, :])
         if titles is not None:
-            ax[i].set_title(titles[i], fontweight="bold", fontsize=15)
+            ax[i].set_title(titles[i], fontweight="bold", fontsize=10)
         if remove_frame:
             ax[i].axis("off")
 

From c719fb025e25d338f017993d04f901ecfb50e899 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 17 May 2019 14:27:47 +0200
Subject: [PATCH 152/264] functions to remove nuclei already segmented

---
 bigfish/segmentation/nuc_segmentation.py |  88 +++++++++++++++++++-
 bigfish/segmentation/utils.py            | 101 +++++++++++++++++++++--
 2 files changed, 181 insertions(+), 8 deletions(-)

diff --git a/bigfish/segmentation/nuc_segmentation.py b/bigfish/segmentation/nuc_segmentation.py
index 3a066e15..0ee254c8 100644
--- a/bigfish/segmentation/nuc_segmentation.py
+++ b/bigfish/segmentation/nuc_segmentation.py
@@ -5,18 +5,20 @@
 """
 
 from bigfish import stack
+from .utils import label_instances
 
-from skimage.morphology import remove_small_objects, remove_small_holes
-from skimage.measure import label
 from scipy import ndimage as ndi
 import numpy as np
-from skimage.measure import regionprops
 
+from skimage.morphology.selem import disk
+from skimage.morphology import (reconstruction, binary_dilation,
+                                remove_small_objects)
 
 # TODO rename functions
 # TODO complete documentation methods
 # TODO add sanity functions
 
+
 def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
                         return_label=False, **kwargs):
     """Segment nuclei from a 2-d projection.
@@ -118,3 +120,83 @@ def filtered_threshold(image, kernel_shape="disk", kernel_size=200,
 
     return image_segmented
 
+
+def remove_segmented_nuc(image, mask, nuclei_size=500):
+    """Remove the nuclei we have already segmented in an image.
+
+    1) We only keep the segmented nuclei. The missed ones and the background
+    are set to 0 and removed from the original image, using a dilated mask.
+    2) We reconstruct the missing nuclei by small dilatation. As we used the
+    original image as a mask (the maximum allowed value at each pixel), the
+    background pixels remain unchanged. However, pixels from the missing
+    nuclei are partially reconstructed by the dilatation. This reconstructed
+    image only differs from the original one where the nuclei have been missed.
+    3) We substract the reconstructed image from the original one.
+    4) From the few pixels kept and restored from the missing nuclei, we build
+    a binary mask (dilatation, small object removal).
+    5) We apply this mask to the original image to get the original pixel
+    intensity of the missing nuclei.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Original image with shape (y, x).
+    mask : np.ndarray,
+        Result of the segmentation (with instance differentiation or not).
+    nuclei_size : int
+        Threshold above which we detect a nuclei.
+
+    Returns
+    -------
+    unsegmented_nuclei : np.ndarray
+        Image with shape (y, x) and the same dtype of the original image.
+        Nuclei previously detected in the mask are removed.
+
+    """
+    # TODO fix the dtype of the mask
+    # check parameters
+    stack.check_array(image,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16,
+                             np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_array(mask,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64, bool],
+                      allow_nan=False)
+
+    # cast mask in np.int64 if it is binary
+    if mask.dtype == bool or mask.dtype == np.uint16:
+        mask = mask.astype(np.int64)
+
+    # store original dtype
+    original_dtype = image.dtype
+
+    # dilate the mask
+    s = disk(10, bool)
+    dilated_mask = binary_dilation(mask, selem=s)
+
+    # remove the unsegmented nuclei from the original image
+    diff = image.copy()
+    diff[dilated_mask == 0] = 0
+
+    # reconstruct the missing nuclei by dilatation
+    s = disk(1)
+    image_reconstructed = reconstruction(diff, image, selem=s)
+    image_reconstructed = image_reconstructed.astype(original_dtype)
+
+    # substract the reconstructed image from the original one
+    image_filtered = image.copy()
+    image_filtered -= image_reconstructed
+
+    # build the binary mask for the missing nuclei
+    missing_mask = image_filtered > 0
+    missing_mask = remove_small_objects(missing_mask, nuclei_size)
+    s = disk(20, bool)
+    missing_mask = binary_dilation(missing_mask, selem=s)
+
+    # get the original pixel intensity of the unsegmented nuclei
+    unsegmented_nuclei = image.copy()
+    unsegmented_nuclei[missing_mask == 0] = 0
+
+    return unsegmented_nuclei
diff --git a/bigfish/segmentation/utils.py b/bigfish/segmentation/utils.py
index 700c87d1..cd95c559 100644
--- a/bigfish/segmentation/utils.py
+++ b/bigfish/segmentation/utils.py
@@ -4,25 +4,116 @@
 Utilities function for nuclei and cytoplasm segmentation.
 """
 
-from skimage.measure import label
+import bigfish.stack as stack
 
+import numpy as np
+from skimage.measure import label, regionprops
 
-def label_instances(image_segmented):
+
+def label_instances(mask):
     """Count and label the different instances previously segmented in an
     image.
 
     Parameters
     ----------
-    image_segmented : np.ndarray, bool
+    mask : np.ndarray, bool
         Binary segmented image with shape (y, x).
 
     Returns
     -------
-    image_label : np.ndarray, np.uint64
+    image_label : np.ndarray, np.int64
         Labelled image. Each object is characterized by the same pixel value.
     nb_labels : int
         Number of different instances counted in the image.
 
     """
-    image_label, nb_labels = label(image_segmented, return_num=True)
+    # check parameters
+    stack.check_array(mask, ndim=2, dtype=bool, allow_nan=False)
+
+    # get labels
+    image_label, nb_labels = label(mask, return_num=True)
     return image_label, nb_labels
+
+
+def compute_mean_size_object(image_labelled):
+    """Compute the averaged size of the segmented objects.
+
+    For each object, we compute the diameter of an object with an equivalent
+    surface. Then, we average the diameters.
+
+    Parameters
+    ----------
+    image_labelled : np.ndarray, np.uint
+        Labelled image with shape (y, x).
+
+    Returns
+    -------
+    mean_diameter : float
+        Averaged size of the segmented objects.
+
+    """
+    # check parameters
+    stack.check_array(image_labelled,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64],
+                      allow_nan=False)
+
+    # compute properties of the segmented object
+    props = regionprops(image_labelled)
+
+    # get equivalent diameter and average it
+    diameter = []
+    for prop in props:
+        diameter.append(prop.equivalent_diameter)
+    mean_diameter = np.mean(diameter)
+
+    return mean_diameter
+
+
+def merge_labels(label_1, label_2):
+    """Combine two partial labels of the same image.
+
+    To prevent merging conflict, labels should not be rescale.
+
+    Parameters
+    ----------
+    label_1 : np.ndarray, np.uint or np.int
+        Labelled image with shape (y, x).
+    label_2 : np.ndarray, np.uint or np.int
+        Labelled image with shape (y, x).
+
+    Returns
+    -------
+    label : np.ndarray, np.int64
+        Labelled image with shape (y, x).
+
+    """
+    # check parameters
+    stack.check_array(label_1,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64],
+                      allow_nan=False)
+    stack.check_array(label_2,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64],
+                      allow_nan=False)
+
+    # count number of label
+    nb_label_1 = label_1.max()
+    nb_label_2 = label_2.max()
+
+    # cast labels in np.int64
+    label_1 = label_1.astype(np.int64)
+    label_2 = label_2.astype(np.int64)
+
+    # check if labels can be merged
+    if nb_label_1 + nb_label_2 > np.iinfo(nb_label_1.dtype).max:
+        raise ValueError("Labels can not be merged (labels could overlapped).")
+
+    # merge labels
+    label_2[label_2 > 0] += nb_label_1
+    label = np.maximum(label_1, label_2)
+
+    return label
+
+

From 48dff52114243dff16091ff7571d140cf0657b20 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 17 May 2019 14:28:06 +0200
Subject: [PATCH 153/264] functions to remove nuclei already segmented #2

---
 bigfish/segmentation/__init__.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index f692164e..5ef01d7e 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -5,15 +5,16 @@
 cytoplasm and label them, in 2-d and 3-d.
 """
 
-from .utils import label_instances
-from .nuc_segmentation import nuc_segmentation_2d, filtered_threshold
+from .utils import label_instances, compute_mean_size_object, merge_labels
+from .nuc_segmentation import (nuc_segmentation_2d, filtered_threshold,
+                               remove_segmented_nuc)
 from .cyt_segmentation import cyt_segmentation_2d, watershed_2d
 
 
-_nuc = ["nuc_segmentation_2d", "filtered_threshold"]
+_nuc = ["nuc_segmentation_2d", "filtered_threshold", "remove_segmented_nuc"]
 
 _cyt = ["cyt_segmentation_2d", "watershed_2d"]
 
-_utils = ["label_instances"]
+_utils = ["label_instances", "compute_mean_size_object", "merge_labels"]
 
 __all__ = _utils + _nuc + _cyt

From 759aec34f70080e6e4735a03df3bfc810d1bd789 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 24 May 2019 14:49:56 +0200
Subject: [PATCH 154/264] initialize cytoplasm segmentation script

---
 python_scripts/2d_cytoplasm_segmentation.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 python_scripts/2d_cytoplasm_segmentation.py

diff --git a/python_scripts/2d_cytoplasm_segmentation.py b/python_scripts/2d_cytoplasm_segmentation.py
new file mode 100644
index 00000000..e69de29b

From 06cfd2ae6f7b5c7fee85cd5ec515765dc3396aac Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 24 May 2019 14:50:18 +0200
Subject: [PATCH 155/264]  update doc for recipe with several fovs

---
 bigfish/stack/preprocess.py | 45 ++++++++++++++++++++-----------------
 1 file changed, 24 insertions(+), 21 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index ea925fce..1fead4ec 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -116,17 +116,17 @@ def build_stacks(data_map, input_dimension=None, check=False, normalize=False,
     The recipe dictionary for one field of view takes the form:
 
         {
-         "fov": str,     (optional)
-         "z": List[str], (optional)
-         "c": List[str], (optional)
-         "r": List[str], (optional)
-         "ext": str,     (optional)
-         "opt": str,     (optional)
+         "fov": List[str], (optional)
+         "z": List[str],   (optional)
+         "c": List[str],   (optional)
+         "r": List[str],   (optional)
+         "ext": str,       (optional)
+         "opt": str,       (optional)
          "pattern"
          }
 
     - A field of view is defined by an ID common to every images belonging to
-    the field of view ("fov").
+    the same field of view ("fov").
     - At least every images are in 2-d with x and y dimensions. So we need to
     mention the round-dimension, the channel-dimension and the z-dimension to
     add ("r", "c" and "z"). For these keys, we provide a list of
@@ -135,6 +135,7 @@ def build_stacks(data_map, input_dimension=None, check=False, normalize=False,
     can be provided with the file extension "ext" (usually 'tif' or 'tiff') or
     an optional morpheme ("opt").
     - A pattern used to get the filename ("pattern").
+    - The fields "fov", "z", "c" and "r" can be strings instead of lists.
 
     Example 1. Let us assume 3-d images (zyx dimensions) saved as
     "r03c03f01_405.tif", "r03c03f01_488.tif" and "r03c03f01_561.tif". The first
@@ -261,17 +262,17 @@ def build_stack(recipe, input_folder, input_dimension=None, i_fov=0,
     The recipe dictionary for one field of view takes the form:
 
         {
-         "fov": str,     (optional)
-         "z": List[str], (optional)
-         "c": List[str], (optional)
-         "r": List[str], (optional)
-         "ext": str,     (optional)
-         "opt": str,     (optional)
+         "fov": List[str], (optional)
+         "z": List[str],   (optional)
+         "c": List[str],   (optional)
+         "r": List[str],   (optional)
+         "ext": str,       (optional)
+         "opt": str,       (optional)
          "pattern"
          }
 
     - A field of view is defined by an ID common to every images belonging to
-    the field of view ("fov").
+    the same field of view ("fov").
     - At least every images are in 2-d with x and y dimensions. So we need to
     mention the round-dimension, the channel-dimension and the z-dimension to
     add ("r", "c" and "z"). For these keys, we provide a list of
@@ -280,6 +281,7 @@ def build_stack(recipe, input_folder, input_dimension=None, i_fov=0,
     can be provided with the file extension "ext" (usually 'tif' or 'tiff') or
     an optional morpheme ("opt").
     - A pattern used to get the filename ("pattern").
+    - The fields "fov", "z", "c" and "r" can be strings instead of lists.
 
     Example 1. Let us assume 3-d images (zyx dimensions) saved as
     "r03c03f01_405.tif", "r03c03f01_488.tif" and "r03c03f01_561.tif". The first
@@ -387,17 +389,17 @@ def _load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
     The recipe dictionary for one field of view takes the form:
 
         {
-         "fov": str,     (optional)
-         "z": List[str], (optional)
-         "c": List[str], (optional)
-         "r": List[str], (optional)
-         "ext": str,     (optional)
-         "opt": str,     (optional)
+         "fov": List[str], (optional)
+         "z": List[str],   (optional)
+         "c": List[str],   (optional)
+         "r": List[str],   (optional)
+         "ext": str,       (optional)
+         "opt": str,       (optional)
          "pattern"
          }
 
     - A field of view is defined by an ID common to every images belonging to
-    the field of view ("fov").
+    the same field of view ("fov").
     - At least every images are in 2-d with x and y dimensions. So we need to
     mention the round-dimension, the channel-dimension and the z-dimension to
     add ("r", "c" and "z"). For these keys, we provide a list of
@@ -406,6 +408,7 @@ def _load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
     can be provided with the file extension "ext" (usually 'tif' or 'tiff') or
     an optional morpheme ("opt").
     - A pattern used to get the filename ("pattern").
+    - The fields "fov", "z", "c" and "r" can be strings instead of lists.
 
     Example 1. Let us assume 3-d images (zyx dimensions) saved as
     "r03c03f01_405.tif", "r03c03f01_488.tif" and "r03c03f01_561.tif". The first

From a16ae198268e07274853b084117b7c38657b9450 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 24 May 2019 15:18:20 +0200
Subject: [PATCH 156/264] check if files described by a recipe exist

---
 bigfish/stack/preprocess.py | 183 +++-------------------------------
 bigfish/stack/utils.py      | 192 +++++++++++++++++++++++++++++++++++-
 2 files changed, 201 insertions(+), 174 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index 1fead4ec..bc3e1dd5 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -5,7 +5,6 @@
 """
 
 import os
-import re
 import warnings
 
 import numpy as np
@@ -14,7 +13,8 @@
 from .io import read_image, read_cell_json, read_rna_json
 from .utils import (check_array, check_parameter, check_recipe,
                     check_range_value, check_df, complete_coordinates_2d,
-                    from_coord_to_image)
+                    from_coord_to_image, fit_recipe, get_path_from_recipe,
+                    get_nb_element_per_dimension, count_nb_fov)
 
 from sklearn.preprocessing import LabelEncoder
 
@@ -204,7 +204,7 @@ def build_stacks(data_map, input_dimension=None, check=False, normalize=False,
     for recipe, input_folder in data_map:
 
         # load and generate tensors for each fov stored in a recipe
-        nb_fov = _count_nb_fov(recipe)
+        nb_fov = count_nb_fov(recipe)
         for i_fov in range(nb_fov):
             tensor = build_stack(recipe, input_folder, input_dimension, i_fov,
                                  check, normalize, channel_to_stretch,
@@ -215,45 +215,6 @@ def build_stacks(data_map, input_dimension=None, check=False, normalize=False,
                 yield tensor
 
 
-def _count_nb_fov(recipe):
-    """Count the number of different fields of view that can be defined from
-    the recipe.
-
-    Parameters
-    ----------
-    recipe : dict
-        Map the images according to their field of view, their round,
-        their channel and their spatial dimensions. Can only contain the keys
-        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
-
-    Returns
-    -------
-    nb_fov : int
-        Number of different fields of view in the recipe.
-
-    """
-    # check recipe is a dictionary
-    if not isinstance(recipe, dict):
-        raise Exception("The recipe is not valid. It should be a dictionary.")
-
-    # check the fov key exists
-    if "fov" not in recipe:
-        return 1
-
-    # case where fov is directly a string
-    elif isinstance(recipe["fov"], str):
-        return 1
-
-    # case where fov is a list of strings
-    elif isinstance(recipe["fov"], list):
-        return len(recipe["fov"])
-
-    # non valid cases
-    else:
-        raise ValueError("'fov' should be a List or a str, not {0}"
-                         .format(type(recipe["fov"])))
-
-
 def build_stack(recipe, input_folder, input_dimension=None, i_fov=0,
                 check=False, normalize=False, channel_to_stretch=None,
                 stretching_percentile=99.9, cast_8bit=False):
@@ -459,14 +420,14 @@ def _load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
 
     """
     # complete the recipe with unused morphemes
-    recipe = _fit_recipe(recipe)
+    recipe = fit_recipe(recipe)
 
     # if the initial dimension of the files is unknown, we read one of them
     if input_dimension is None:
         input_dimension = _get_input_dimension(recipe, input_folder)
 
     # get the number of elements to stack per dimension
-    nb_r, nb_c, nb_z = _get_nb_element_per_dimension(recipe)
+    nb_r, nb_c, nb_z = get_nb_element_per_dimension(recipe)
 
     # we stack our files according to their initial dimension
     if input_dimension == 2:
@@ -488,45 +449,6 @@ def _load_stack(recipe, input_folder, input_dimension=None, i_fov=0):
     return stack
 
 
-def _fit_recipe(recipe):
-    """Fit a recipe.
-
-    Fitting a recipe consists in wrapping every values of 'fov', 'r', 'c' and
-    'z' in a list (an empty one if necessary). Values for 'ext' and 'opt' are
-    also initialized.
-
-    Parameters
-    ----------
-    recipe : dict
-        Map the images according to their field of view, their round,
-        their channel and their spatial dimensions. Can only contain the keys
-        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
-
-    Returns
-    -------
-    new_recipe : dict
-        Map the images according to their field of view, their round,
-        their channel and their spatial dimensions. Contain the keys
-        'pattern', 'fov', 'r', 'c', 'z', 'ext' and 'opt', initialized if
-        necessary.
-
-    """
-    # initialize and fit the dimensions 'fov', 'r', 'c' and 'z'
-    for key in ['fov', 'r', 'c', 'z']:
-        if key not in recipe:
-            recipe[key] = [None]
-        value = recipe[key]
-        if isinstance(value, str):
-            recipe[key] = [value]
-
-    # initialize the dimensions 'ext', 'opt'
-    for key in ['ext', 'opt']:
-        if key not in recipe:
-            recipe[key] = ""
-
-    return recipe
-
-
 def _build_stack_from_2d(recipe, input_folder, fov=0, nb_r=1, nb_c=1, nb_z=1):
     """Load and stack 2-d tensors.
 
@@ -565,8 +487,8 @@ def _build_stack_from_2d(recipe, input_folder, fov=0, nb_r=1, nb_c=1, nb_z=1):
             # load and stack z elements (2-d tensors)
             tensors_2d = []
             for z in range(nb_z):
-                path = _get_path_from_recipe(recipe, input_folder, fov=fov,
-                                             r=r, c=c, z=z)
+                path = get_path_from_recipe(recipe, input_folder, fov=fov,
+                                            r=r, c=c, z=z)
                 tensor_2d = read_image(path)
                 tensors_2d.append(tensor_2d)
 
@@ -615,8 +537,8 @@ def _build_stack_from_3d(recipe, input_folder, fov=0, nb_r=1, nb_c=1):
         # load and stack channel elements (3-d tensors)
         tensors_3d = []
         for c in range(nb_c):
-            path = _get_path_from_recipe(recipe, input_folder, fov=fov, r=r,
-                                         c=c)
+            path = get_path_from_recipe(recipe, input_folder, fov=fov, r=r,
+                                        c=c)
             tensor_3d = read_image(path)
             tensors_3d.append(tensor_3d)
 
@@ -655,7 +577,7 @@ def _build_stack_from_4d(recipe, input_folder, fov=0, nb_r=1):
     # load each file from a new round element and stack them
     tensors_4d = []
     for r in range(nb_r):
-        path = _get_path_from_recipe(recipe, input_folder, fov=fov, r=r)
+        path = get_path_from_recipe(recipe, input_folder, fov=fov, r=r)
         tensor_4d = read_image(path)
         tensors_4d.append(tensor_4d)
 
@@ -686,93 +608,12 @@ def _build_stack_from_5d(recipe, input_folder, fov=0):
 
     """
     # the recipe can only contain one file with a 5-d tensor per fov
-    path = _get_path_from_recipe(recipe, input_folder, fov=fov)
+    path = get_path_from_recipe(recipe, input_folder, fov=fov)
     tensor_5d = read_image(path)
 
     return tensor_5d
 
 
-def _get_path_from_recipe(recipe, input_folder, fov=0, r=0, c=0, z=0):
-    """Build the path of a file from a recipe and the indices of specific
-    elements.
-
-    Parameters
-    ----------
-    recipe : dict
-        Map the images according to their field of view, their round,
-        their channel and their spatial dimensions. Only contain the keys
-        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
-    input_folder : str
-        Path of the folder containing the images.
-    fov : int
-        Index of the 'fov' element in the recipe to use in the filename.
-    r : int
-        Index of the 'r' element in the recipe to use in the filename.
-    c : int
-        Index of the 'c' element in the recipe to use in the filename.
-    z : int
-        Index of the 'z' element in the recipe to use in the filename.
-
-    Returns
-    -------
-    path : str
-        Path of the file to load.
-
-    """
-    # build a map of the elements' indices
-    map_element_index = {"fov": fov, "r": r, "c": c, "z": z}
-
-    # get filename pattern and decompose it
-    recipe_pattern = recipe["pattern"]
-    path_elements = re.findall("fov|r|c|z|ext|opt", recipe_pattern)
-    path_separators = re.split("fov|r|c|z|ext|opt", recipe_pattern)
-
-    # get filename recombining elements of the recipe
-    filename = path_separators[0]  # usually an empty string
-    for (element_name, separator) in zip(path_elements, path_separators[1:]):
-        # if we need an element from a list of elements of the same dimension
-        # (eg. to pick a specific channel 'c' among a list of channels)
-        if element_name in map_element_index:
-            element_index = map_element_index[element_name]
-            element = recipe[element_name][element_index]
-        # if this element is unique for all the recipe (eg. 'fov')
-        else:
-            element = recipe[element_name]
-        # the filename is built ensuring the order of apparition of the
-        # different morphemes and their separators
-        filename += element
-        filename += separator
-
-    # get path
-    path = os.path.join(input_folder, filename)
-
-    return path
-
-
-def _get_nb_element_per_dimension(recipe):
-    """Count the number of element to stack for each dimension ('r', 'c'
-    and 'z').
-
-    Parameters
-    ----------
-    recipe : dict
-        Map the images according to their field of view, their round,
-        their channel and their spatial dimensions. Only contain the keys
-        'fov', 'r', 'c', 'z', 'ext' or 'opt'.
-
-    Returns
-    -------
-    nb_r : int
-        Number of rounds to be stacked.
-    nb_c : int
-        Number of channels to be stacked.
-    nb_z : int
-        Number of z layers to be stacked.
-
-    """
-    return len(recipe["r"]), len(recipe["c"]), len(recipe["z"])
-
-
 def _get_input_dimension(recipe, input_folder):
     """ Load an arbitrary image to get the original dimension of the files.
 
@@ -792,7 +633,7 @@ def _get_input_dimension(recipe, input_folder):
 
     """
     # get a valid path from the recipe
-    path = _get_path_from_recipe(recipe, input_folder)
+    path = get_path_from_recipe(recipe, input_folder)
 
     # load the image and return the number of dimensions
     image = read_image(path)
diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 3d7cd550..9d816316 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -6,6 +6,8 @@
 
 import inspect
 import re
+import os
+import copy
 
 import numpy as np
 import pandas as pd
@@ -256,9 +258,9 @@ def check_range_value(array, min_=None, max_=None):
     return True
 
 
-# ### Sanity checks parameters ###
+# ### Recipe management (sanity checks, fitting) ###
 
-def check_recipe(recipe):
+def check_recipe(recipe, data_directory=None):
     """Check and validate a recipe.
 
     Checking a recipe consist in validating its filename pattern and the
@@ -270,12 +272,14 @@ def check_recipe(recipe):
         Map the images according to their field of view, their round,
         their channel and their spatial dimensions. Can only contain the keys
         'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
+    data_directory : str
+        Path of the directory with the files describes in the recipe. If it is
+        provided, the function check that the files exist.
 
     Returns
     -------
 
     """
-    # TODO check files exists
     # check recipe is a dictionary
     if not isinstance(recipe, dict):
         raise Exception("The recipe is not valid. It should be a dictionary.")
@@ -308,9 +312,191 @@ def check_recipe(recipe):
             raise TypeError("A recipe can only contain lists or strings, "
                             "not {0}.".format(type(value)))
 
+    # check that requested files exist
+    if data_directory is not None:
+        if not os.path.isdir(data_directory):
+            raise ValueError("Directory does not exist: {0}."
+                             .format(data_directory))
+        recipe = fit_recipe(recipe)
+        nb_r, nb_c, nb_z = get_nb_element_per_dimension(recipe)
+        nb_fov = count_nb_fov(recipe)
+        for fov in range(nb_fov):
+            for r in range(nb_r):
+                for c in range(nb_c):
+                    for z in range(nb_z):
+                        path = get_path_from_recipe(recipe, data_directory,
+                                                    fov=fov, r=r, c=c, z=z)
+                        if not os.path.isfile(path):
+                            raise ValueError("File does not exist:{0}."
+                                             .format(path))
+
     return
 
 
+def fit_recipe(recipe):
+    """Fit a recipe.
+
+    Fitting a recipe consists in wrapping every values of 'fov', 'r', 'c' and
+    'z' in a list (an empty one if necessary). Values for 'ext' and 'opt' are
+    also initialized.
+
+    Parameters
+    ----------
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Can only contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
+
+    Returns
+    -------
+    new_recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' and 'opt', initialized if
+        necessary.
+
+    """
+    # initialize recipe
+    new_recipe = copy.deepcopy(recipe)
+
+    # initialize and fit the dimensions 'fov', 'r', 'c' and 'z'
+    for key in ['fov', 'r', 'c', 'z']:
+        if key not in new_recipe:
+            new_recipe[key] = [None]
+        value = new_recipe[key]
+        if isinstance(value, str):
+            new_recipe[key] = [value]
+
+    # initialize the dimensions 'ext', 'opt'
+    for key in ['ext', 'opt']:
+        if key not in new_recipe:
+            new_recipe[key] = ""
+
+    return new_recipe
+
+
+def get_path_from_recipe(recipe, input_folder, fov=0, r=0, c=0, z=0):
+    """Build the path of a file from a recipe and the indices of specific
+    elements.
+
+    Parameters
+    ----------
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Only contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
+    input_folder : str
+        Path of the folder containing the images.
+    fov : int
+        Index of the 'fov' element in the recipe to use in the filename.
+    r : int
+        Index of the 'r' element in the recipe to use in the filename.
+    c : int
+        Index of the 'c' element in the recipe to use in the filename.
+    z : int
+        Index of the 'z' element in the recipe to use in the filename.
+
+    Returns
+    -------
+    path : str
+        Path of the file to load.
+
+    """
+    # build a map of the elements' indices
+    map_element_index = {"fov": fov, "r": r, "c": c, "z": z}
+
+    # get filename pattern and decompose it
+    recipe_pattern = recipe["pattern"]
+    path_elements = re.findall("fov|r|c|z|ext|opt", recipe_pattern)
+    path_separators = re.split("fov|r|c|z|ext|opt", recipe_pattern)
+
+    # get filename recombining elements of the recipe
+    filename = path_separators[0]  # usually an empty string
+    for (element_name, separator) in zip(path_elements, path_separators[1:]):
+        # if we need an element from a list of elements of the same dimension
+        # (eg. to pick a specific channel 'c' among a list of channels)
+        if element_name in map_element_index:
+            element_index = map_element_index[element_name]
+            element = recipe[element_name][element_index]
+        # if this element is unique for all the recipe (eg. 'fov')
+        else:
+            element = recipe[element_name]
+        # the filename is built ensuring the order of apparition of the
+        # different morphemes and their separators
+        filename += element
+        filename += separator
+
+    # get path
+    path = os.path.join(input_folder, filename)
+
+    return path
+
+
+def get_nb_element_per_dimension(recipe):
+    """Count the number of element to stack for each dimension ('r', 'c'
+    and 'z').
+
+    Parameters
+    ----------
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Only contain the keys
+        'fov', 'r', 'c', 'z', 'ext' or 'opt'.
+
+    Returns
+    -------
+    nb_r : int
+        Number of rounds to be stacked.
+    nb_c : int
+        Number of channels to be stacked.
+    nb_z : int
+        Number of z layers to be stacked.
+
+    """
+    return len(recipe["r"]), len(recipe["c"]), len(recipe["z"])
+
+
+def count_nb_fov(recipe):
+    """Count the number of different fields of view that can be defined from
+    the recipe.
+
+    Parameters
+    ----------
+    recipe : dict
+        Map the images according to their field of view, their round,
+        their channel and their spatial dimensions. Can only contain the keys
+        'pattern', 'fov', 'r', 'c', 'z', 'ext' or 'opt'.
+
+    Returns
+    -------
+    nb_fov : int
+        Number of different fields of view in the recipe.
+
+    """
+    # check recipe is a dictionary
+    if not isinstance(recipe, dict):
+        raise Exception("The recipe is not valid. It should be a dictionary.")
+
+    # check the fov key exists
+    if "fov" not in recipe:
+        return 1
+
+    # case where fov is directly a string
+    elif isinstance(recipe["fov"], str):
+        return 1
+
+    # case where fov is a list of strings
+    elif isinstance(recipe["fov"], list):
+        return len(recipe["fov"])
+
+    # non valid cases
+    else:
+        raise ValueError("'fov' should be a List or a str, not {0}"
+                         .format(type(recipe["fov"])))
+
+
+# ### Sanity checks parameters ###
+
 def check_parameter(**kwargs):
     """Check dtype of the function's parameters.
 

From 7fa0e45121510f0fefdd46c9ee0d23889d5605f0 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 24 May 2019 16:59:17 +0200
Subject: [PATCH 157/264] fix typo

---
 bigfish/stack/utils.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 9d816316..29819084 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -315,7 +315,7 @@ def check_recipe(recipe, data_directory=None):
     # check that requested files exist
     if data_directory is not None:
         if not os.path.isdir(data_directory):
-            raise ValueError("Directory does not exist: {0}."
+            raise ValueError("Directory does not exist: {0}"
                              .format(data_directory))
         recipe = fit_recipe(recipe)
         nb_r, nb_c, nb_z = get_nb_element_per_dimension(recipe)
@@ -327,7 +327,7 @@ def check_recipe(recipe, data_directory=None):
                         path = get_path_from_recipe(recipe, data_directory,
                                                     fov=fov, r=r, c=c, z=z)
                         if not os.path.isfile(path):
-                            raise ValueError("File does not exist:{0}."
+                            raise ValueError("File does not exist: {0}"
                                              .format(path))
 
     return

From 2418649084fe609a61ca91a6ca0f8537d02910c2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 28 May 2019 18:43:13 +0200
Subject: [PATCH 158/264] filter pixel by intensity while removing segmented
 nuclei

---
 bigfish/segmentation/nuc_segmentation.py | 67 ++++--------------------
 1 file changed, 9 insertions(+), 58 deletions(-)

diff --git a/bigfish/segmentation/nuc_segmentation.py b/bigfish/segmentation/nuc_segmentation.py
index 0ee254c8..0e861ac9 100644
--- a/bigfish/segmentation/nuc_segmentation.py
+++ b/bigfish/segmentation/nuc_segmentation.py
@@ -5,7 +5,6 @@
 """
 
 from bigfish import stack
-from .utils import label_instances
 
 from scipy import ndimage as ndi
 import numpy as np
@@ -19,59 +18,6 @@
 # TODO add sanity functions
 
 
-def nuc_segmentation_2d(tensor, projection_method, r, c, segmentation_method,
-                        return_label=False, **kwargs):
-    """Segment nuclei from a 2-d projection.
-
-    Parameters
-    ----------
-    tensor : nd.ndarray, np.uint
-        Tensor with shape (r, c, z, y, x).
-    projection_method : str
-        Method used to project the image in 2-d.
-    r : int
-        Round index to process.
-    c : int
-        Channel index of the dapi image.
-    segmentation_method : str
-        Method used to segment the nuclei.
-    return_label : bool
-        Condition to count and label the instances segmented in the image.
-
-    Returns
-    -------
-    image_segmented : np.ndarray, bool
-        Binary 2-d image with shape (y, x).
-    image_labelled : np.ndarray, np.int64
-        Image with labelled segmented instances and shape (y, x).
-    nb_labels : int
-        Number of different instances segmented.
-    """
-    # check tensor dimensions and its dtype
-    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-
-    # get a 2-d dapi image
-    image_2d = stack.projection(tensor,
-                                method=projection_method,
-                                r=r,
-                                c=c)
-
-    # apply segmentation
-    # TODO validate the pipeline with this cast
-    image_segmented = stack.cast_img_uint8(image_2d)
-    if segmentation_method == "threshold":
-        image_segmented = filtered_threshold(image_segmented, **kwargs)
-    else:
-        pass
-
-    # labelled and count segmented instances
-    if return_label:
-        image_labelled, nb_labels = label_instances(image_segmented)
-        return image_segmented, image_labelled, nb_labels
-    else:
-        return image_segmented
-
-
 def filtered_threshold(image, kernel_shape="disk", kernel_size=200,
                        threshold=2, small_object_size=2000):
     """Segment a 2-d image to discriminate object from background.
@@ -121,7 +67,7 @@ def filtered_threshold(image, kernel_shape="disk", kernel_size=200,
     return image_segmented
 
 
-def remove_segmented_nuc(image, mask, nuclei_size=500):
+def remove_segmented_nuc(image, mask, nuclei_size=2000):
     """Remove the nuclei we have already segmented in an image.
 
     1) We only keep the segmented nuclei. The missed ones and the background
@@ -136,10 +82,11 @@ def remove_segmented_nuc(image, mask, nuclei_size=500):
     a binary mask (dilatation, small object removal).
     5) We apply this mask to the original image to get the original pixel
     intensity of the missing nuclei.
+    6) We remove pixels with a too low intensity (using Otsu thresholding).
 
     Parameters
     ----------
-    image : np.ndarray
+    image : np.ndarray, np.uint
         Original image with shape (y, x).
     mask : np.ndarray,
         Result of the segmentation (with instance differentiation or not).
@@ -154,11 +101,11 @@ def remove_segmented_nuc(image, mask, nuclei_size=500):
 
     """
     # TODO fix the dtype of the mask
+    # TODO start from the original image to manage the potential rescaling
     # check parameters
     stack.check_array(image,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16,
-                             np.float32, np.float64],
+                      dtype=[np.uint8, np.uint16],
                       allow_nan=False)
     stack.check_array(mask,
                       ndim=2,
@@ -198,5 +145,9 @@ def remove_segmented_nuc(image, mask, nuclei_size=500):
     # get the original pixel intensity of the unsegmented nuclei
     unsegmented_nuclei = image.copy()
     unsegmented_nuclei[missing_mask == 0] = 0
+    if original_dtype == np.uint8:
+        unsegmented_nuclei[unsegmented_nuclei < 40] = 0
+    else:
+        unsegmented_nuclei[unsegmented_nuclei < 10000] = 0
 
     return unsegmented_nuclei

From 7cd4412efd7a907153524a978ef459851b56862f Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 28 May 2019 18:43:54 +0200
Subject: [PATCH 159/264] refactor watershed cyt segmentation

---
 bigfish/segmentation/__init__.py         |  12 +-
 bigfish/segmentation/cyt_segmentation.py | 206 ++++++++++++++++++-----
 2 files changed, 167 insertions(+), 51 deletions(-)

diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index 5ef01d7e..0b1b3916 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -6,14 +6,16 @@
 """
 
 from .utils import label_instances, compute_mean_size_object, merge_labels
-from .nuc_segmentation import (nuc_segmentation_2d, filtered_threshold,
-                               remove_segmented_nuc)
-from .cyt_segmentation import cyt_segmentation_2d, watershed_2d
+from .nuc_segmentation import (filtered_threshold, remove_segmented_nuc)
+from .cyt_segmentation import (build_cyt_relief, build_cyt_binary_mask,
+                               cyt_watershed)
+from .unet import get_input_size_unet
 
+_nuc = ["filtered_threshold", "remove_segmented_nuc"]
 
-_nuc = ["nuc_segmentation_2d", "filtered_threshold", "remove_segmented_nuc"]
+_cyt = ["build_cyt_relief", "build_cyt_binary_mask", cyt_watershed]
 
-_cyt = ["cyt_segmentation_2d", "watershed_2d"]
+_unet = ["get_input_size_unet"]
 
 _utils = ["label_instances", "compute_mean_size_object", "merge_labels"]
 
diff --git a/bigfish/segmentation/cyt_segmentation.py b/bigfish/segmentation/cyt_segmentation.py
index 088b1c68..e50a1a55 100644
--- a/bigfish/segmentation/cyt_segmentation.py
+++ b/bigfish/segmentation/cyt_segmentation.py
@@ -4,66 +4,180 @@
 Class and functions to segment nucleus and cytoplasm in 2-d and 3-d.
 """
 
-from bigfish import stack
-from .nuc_segmentation import nuc_segmentation_2d
+import numpy as np
+
+import bigfish.stack as stack
 
 from skimage.morphology import remove_small_objects, remove_small_holes
-import numpy as np
 from skimage.morphology import watershed
 from skimage.filters import threshold_otsu
 from skimage.measure import regionprops
+from scipy import ndimage as ndi
 
 
 # TODO rename functions
-# TODO complete documentation methods
 
 
-def cyt_segmentation_2d(tensor, r, c_nuc, c_cyt, segmentation_method):
-    # TODO add documentation
-    # check tensor dimensions and its dtype
-    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
+def build_cyt_relief(image_projected, nuc_labelled, alpha=0.8):
+    """Compute a 2-d representation of the cytoplasm to be used by watershed
+    algorithm.
+
+    Cells are represented as watershed, with a low values to the center and
+    maximum values at their borders.
+
+    The equation used is:
+        relief = alpha * relief_pixel + (1 - alpha) * relief_distance
+
+    - 'relief_pixel' exploit the differences in pixel intensity values.
+    - 'relief_distance' use the distance from the nuclei.
+
+    Parameters
+    ----------
+    image_projected : np.ndarray, np.uint
+        Projected image of the cytoplasm with shape (y, x).
+    nuc_labelled : np.ndarray,
+        Result of the nuclei segmentation with shape (y, x).
+    alpha : float or int
+        Weight of the pixel intensity values to compute the relief. A value of
+        0 and 1 respectively return 'relief_distance' and 'relief_pixel'.
+
+    Returns
+    -------
+    relief : np.ndarray, np.uint
+        Relief image of the cytoplasm with shape (y, x).
+
+    """
+    # TODO use distance map from bigfish.stack
+    # check parameters
+    stack.check_array(image_projected,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16],
+                      allow_nan=False)
+    stack.check_array(nuc_labelled,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64, bool],
+                      allow_nan=False)
+    stack.check_parameter(alpha=(float, int))
+
+    # use pixel intensity of the cytoplasm channel to compute the seed.
+    if alpha == 1:
+        relief = image_projected.copy()
+        max_intensity = np.iinfo(image_projected.dtype).max
+        relief = max_intensity - relief
+        relief[nuc_labelled > 0] = 0
+
+    # use distance from the nuclei
+    elif alpha == 0:
+        binary_mask_nuc = nuc_labelled > 0
+        relief = ndi.distance_transform_edt(~binary_mask_nuc)
+        relief = np.true_divide(relief, relief.max(), dtype=np.float32)
+        if image_projected.dtype == np.uint8:
+            relief = stack.cast_img_uint8(relief)
+        else:
+            relief = stack.cast_img_uint16(relief)
+
+    # use both previous methods
+    elif 0 < alpha < 1:
+        relief_pixel = image_projected.copy()
+        max_intensity = np.iinfo(image_projected.dtype).max
+        relief_pixel = max_intensity - relief_pixel
+        relief_pixel[nuc_labelled > 0] = 0
+        relief_pixel = stack.cast_img_float32(relief_pixel)
+        binary_mask_nuc = nuc_labelled > 0
+        relief_distance = ndi.distance_transform_edt(~binary_mask_nuc)
+        relief_distance = np.true_divide(relief_distance,
+                                         relief_distance.max(),
+                                         dtype=np.float32)
+        relief = alpha * relief_pixel + (1 - alpha) * relief_distance
+        if image_projected.dtype == np.uint8:
+            relief = stack.cast_img_uint8(relief)
+        else:
+            relief = stack.cast_img_uint16(relief)
 
-    # apply segmentation
-    # TODO validate the pipeline with this cast
-    image_segmented = stack.cast_img_uint8(tensor)
-    if segmentation_method == "watershed":
-        image_segmented = watershed_2d(image_segmented, r, c_nuc, c_cyt)
     else:
-        pass
-    return image_segmented
-
-
-def watershed_2d(tensor, r, c_nuc, c_cyt):
-    # TODO add documentation
-    # TODO better integration with nuclei segmentation
-    # nuclei segmentation
-    _, nuc_labelled, _ = nuc_segmentation_2d(
-        tensor,
-        projection_method="mip",
-        r=r, c=c_nuc,
-        segmentation_method="threshold",
-        return_label=True)
-
-    # get source image
-    cyt = tensor[r, c_cyt, :, :, :]
-    cyt_projected = stack.projection(tensor, method="mip", r=r, c=c_cyt)
-
-    # get a mask for the cytoplasm
-    mask = (cyt_projected > threshold_otsu(cyt_projected))
-    mask = remove_small_objects(mask, 200)
-    mask = remove_small_holes(mask, 200)
-
-    # get image to apply watershed on
-    seed = np.sum(cyt, 0)
-    seed = seed.max() - seed
-    seed[nuc_labelled > 0] = 0
-
-    # get the markers from the nuclei
-    markers = np.zeros_like(seed)
+        raise ValueError("Parameter 'alpha' is wrong. Must be comprised "
+                         "between 0 and 1. Currently 'alpha' is {0}"
+                         .format(alpha))
+
+    return relief
+
+
+def build_cyt_binary_mask(image_projected, threshold=None):
+    """Compute a binary mask of the cytoplasm.
+
+    Parameters
+    ----------
+    image_projected : np.ndarray, np.uint
+        A 2-d projection of the cytoplasm with shape (y, x).
+    threshold : int
+        Intensity pixel threshold to compute the binary mask. If None, an Otsu
+        threshold is computed.
+
+    Returns
+    -------
+    mask : np.ndarray, bool
+        Binary mask of the cytoplasm with shape (y, x).
+
+    """
+    # check parameters
+    stack.check_array(image_projected,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16],
+                      allow_nan=False)
+    stack.check_parameter(threshold=(int, type(None)))
+
+    # get a threshold
+    if threshold is None:
+        threshold = threshold_otsu(image_projected)
+
+    # compute a binary mask
+    mask = (image_projected > threshold)
+    mask = remove_small_objects(mask, 3000)
+    mask = remove_small_holes(mask, 2000)
+
+    return mask
+
+
+def cyt_watershed(relief, nuc_labelled, mask):
+    """Apply watershed algorithm on the cytoplasm to segment cell instances.
+
+    Parameters
+    ----------
+    relief : np.ndarray, np.uint
+        Relief image of the cytoplasm with shape (y, x).
+    nuc_labelled : np.ndarray
+        Result of the nuclei segmentation with shape (y, x).
+    mask : np.ndarray, bool
+        Binary mask of the cytoplasm with shape (y, x).
+
+    Returns
+    -------
+    cyt_segmented : np.ndarray, np.int64
+        Segmentation of the cytoplasm with instance differentiation and shape
+        (y, x).
+
+    """
+    # check parameters
+    stack.check_array(relief,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16],
+                      allow_nan=False)
+    stack.check_array(nuc_labelled,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64, bool],
+                      allow_nan=False)
+    stack.check_array(mask,
+                      ndim=2,
+                      dtype=[bool],
+                      allow_nan=False)
+
+    # get markers
+    markers = np.zeros_like(relief)
     for r in regionprops(nuc_labelled):
         markers[tuple(map(int, r.centroid))] = r.label
 
-    # apply watershed
-    cyt_segmented = watershed(seed, markers, mask=mask)
+    # segment cytoplasm
+    cyt_segmented = watershed(relief, markers, mask=mask)
+    cyt_segmented = cyt_segmented.astype(np.int64)
 
     return cyt_segmented

From 83558c1fa14c07a091aed669e1824fab5c5dcb93 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 28 May 2019 18:44:39 +0200
Subject: [PATCH 160/264] remove small objects while merging labels

---
 bigfish/segmentation/utils.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/bigfish/segmentation/utils.py b/bigfish/segmentation/utils.py
index cd95c559..b9ad559a 100644
--- a/bigfish/segmentation/utils.py
+++ b/bigfish/segmentation/utils.py
@@ -8,6 +8,7 @@
 
 import numpy as np
 from skimage.measure import label, regionprops
+from skimage.morphology import remove_small_objects
 
 
 def label_instances(mask):
@@ -102,6 +103,10 @@ def merge_labels(label_1, label_2):
     nb_label_1 = label_1.max()
     nb_label_2 = label_2.max()
 
+    # clean masks
+    label_1 = remove_small_objects(label_1, 3000)
+    label_2 = remove_small_objects(label_2, 3000)
+
     # cast labels in np.int64
     label_1 = label_1.astype(np.int64)
     label_2 = label_2.astype(np.int64)

From 831c338a530f60bb792fbb51e1f67a06c9345a64 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 28 May 2019 18:45:07 +0200
Subject: [PATCH 161/264] update spot detection __init__

---
 bigfish/spot_detection/__init__.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/bigfish/spot_detection/__init__.py b/bigfish/spot_detection/__init__.py
index cc9036a6..b3f82c6e 100644
--- a/bigfish/spot_detection/__init__.py
+++ b/bigfish/spot_detection/__init__.py
@@ -5,9 +5,10 @@
 3-d.
 """
 
-from .detection import (detection, compute_snr, get_sigma)
+from .detection import (detection, compute_snr, get_sigma, detection_log_lm)
 
 
 __all__ = ["detection",
            "compute_snr",
-           "get_sigma"]
+           "get_sigma",
+           "detection_log_lm"]

From 2833e4be2080ff32c8d8e2f03980b4faac6b32a5 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 28 May 2019 18:45:30 +0200
Subject: [PATCH 162/264] improve spot detection plot

---
 bigfish/plot/plot_images.py | 131 ++++++++++++++++++------------------
 1 file changed, 65 insertions(+), 66 deletions(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 57c6ee7a..2a7ac50a 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -508,30 +508,28 @@ def plot_segmentation_boundary(tensor, mask, rescale=False, title=None,
     return
 
 
-def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
-                        framesize=(15, 15), projection_2d=False,
+def plot_spot_detection(tensor, coordinates, radius, rescale=False, title=None,
+                        framesize=(15, 5), remove_frame=False,
                         path_output=None, ext="png"):
-    """
+    """Plot detected spot on a 2-d image.
 
     Parameters
     ----------
-    tensor : np.ndarray, np.uint
-        A 5-d tensor with shape (r, c, z, y, x).
+    tensor : np.ndarray
+        A 2-d tensor with shape (y, x).
     coordinates : np.ndarray, np.int64
         Coordinate of the spots with shape (nb_spots, 3) or
         (nb_spots, 2) for 3-d or 2-d images respectively.
     radius : float
         Radius of the detected spots.
-    r : int
-        Index of the round to keep.
-    c : int
-        Index of the channel to keep.
-    z : int
-        Index of the z-slice to keep.
+    rescale : bool
+        Rescale pixel values of the image (made by default in matplotlib).
+    title : str
+        Title of the image.
     framesize : tuple
         Size of the frame used to plot (plt.figure(figsize=framesize).
-    projection_2d : bool
-        Project the image in 2-d and plot the spot detected on the projection.
+    remove_frame : bool
+        Remove axes and frame.
     path_output : str
         Path to save the image (without extension).
     ext : str or List[str]
@@ -542,62 +540,63 @@ def plot_spot_detection(tensor, coordinates, radius, r=0, c=0, z=0,
     -------
 
     """
-    # TODO add title in the plot and remove axes
-    # TODO add parameter for vmin and vmax
     # TODO check coordinates shape
-    # check tensor
-    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-    stack.check_array(coordinates, ndim=2, dtype=np.int64)
-
-    # projection 2d
-    if projection_2d:
-        image_2d = stack.projection(tensor,
-                                    method="mip",
-                                    r=r,
-                                    c=c)
-
-        # plot
-        fig, ax = plt.subplots(1, 2, figsize=framesize)
-        ax[0].imshow(image_2d)
-        ax[1].set_title("Projected image", fontweight="bold", fontsize=15)
-        ax[1].imshow(image_2d)
-        ax[1].set_title("All detected spots", fontweight="bold", fontsize=15)
-        for spot_coordinate in coordinates:
-            _, y, x = spot_coordinate
-            c = plt.Circle((x, y), radius,
-                           color="red",
-                           linewidth=1,
-                           fill=False)
-            ax[1].add_patch(c)
-        plt.tight_layout()
-        save_plot(path_output, ext)
-        plt.show()
+    # check parameters
+    stack.check_array(tensor,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16,
+                             np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_array(coordinates,
+                      ndim=2,
+                      dtype=[np.int64],
+                      allow_nan=False)
+    stack.check_parameter(radius=float,
+                          rescale=bool,
+                          title=(str, type(None)),
+                          framesize=tuple,
+                          remove_frame=bool,
+                          path_output=(str, type(None)),
+                          ext=(str, list))
 
-    # a specific z-slice
+    # get minimum and maximum value of the image
+    vmin, vmax = None, None
+    if not rescale:
+        vmin, vmax = get_minmax_values(tensor)
+
+    # plot
+    fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
+
+    # image
+    if not rescale:
+        ax[0].imshow(tensor, vmin=vmin, vmax=vmax)
     else:
-        # keep spot detected for a specific height
-        if coordinates.shape[1] == 3:
-            coordinates = coordinates[coordinates[:, 0] == z]
-            coordinates = coordinates[:, 1:]
-
-        image_2d = tensor[r, c, z, :, :]
-
-        # plot
-        fig, ax = plt.subplots(1, 2, figsize=framesize)
-        ax[0].imshow(image_2d)
-        ax[0].set_title("Z-slice: {0}".format(z),
-                        fontweight="bold", fontsize=15)
-        ax[1].imshow(image_2d)
-        ax[1].set_title("Detected spots", fontweight="bold", fontsize=15)
-        for spot_coordinate in coordinates:
-            y, x = spot_coordinate
-            c = plt.Circle((x, y), radius,
-                           color="red",
-                           linewidth=1,
-                           fill=False)
-            ax[1].add_patch(c)
-        plt.tight_layout()
+        ax[0].imshow(tensor)
+    if title is not None:
+        ax[0].set_title(title, fontweight="bold", fontsize=10)
+    if remove_frame:
+        ax[0].axis("off")
+
+    # spots
+    if not rescale:
+        ax[1].imshow(tensor, vmin=vmin, vmax=vmax)
+    else:
+        ax[1].imshow(tensor)
+    for spot_coordinate in coordinates:
+        _, y, x = spot_coordinate
+        c = plt.Circle((x, y), radius,
+                       color="red",
+                       linewidth=1,
+                       fill=False)
+        ax[1].add_patch(c)
+    if title is not None:
+        ax[1].set_title("All detected spots", fontweight="bold", fontsize=10)
+    if remove_frame:
+        ax[1].axis("off")
+
+    plt.tight_layout()
+    if path_output is not None:
         save_plot(path_output, ext)
-        plt.show()
+    plt.show()
 
     return

From 1d514416049f97c6f09ef5e13fb2e83319e70ec9 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 28 May 2019 18:45:54 +0200
Subject: [PATCH 163/264] add a TODO

---
 bigfish/classification/squeezenet.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bigfish/classification/squeezenet.py b/bigfish/classification/squeezenet.py
index 306fa11c..602146df 100644
--- a/bigfish/classification/squeezenet.py
+++ b/bigfish/classification/squeezenet.py
@@ -35,6 +35,7 @@
 # TODO add cache routines
 # TODO manage multiprocessing
 # TODO improve logging
+# TODO use last version of the model
 # ### 2D models ###
 
 class SqueezeNet0(BaseModel):

From 071fff84f7b4f93ade3fd89345de25c75c6c6106 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 28 May 2019 18:46:47 +0200
Subject: [PATCH 164/264] remove script segmentation from the package

---
 python_scripts/2d_cytoplasm_segmentation.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 python_scripts/2d_cytoplasm_segmentation.py

diff --git a/python_scripts/2d_cytoplasm_segmentation.py b/python_scripts/2d_cytoplasm_segmentation.py
deleted file mode 100644
index e69de29b..00000000

From 2f9adf55ce8c67a56a521a99aa953dc522b729b2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 11:28:44 +0200
Subject: [PATCH 165/264] initialize gaussian fitting

---
 bigfish/spot_detection/gaussian_fit.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 bigfish/spot_detection/gaussian_fit.py

diff --git a/bigfish/spot_detection/gaussian_fit.py b/bigfish/spot_detection/gaussian_fit.py
new file mode 100644
index 00000000..e69de29b

From f251df47306fc3c8f9d187d7d0061a3ccfd8b496 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 11:29:12 +0200
Subject: [PATCH 166/264] improve normalization of watershed relief

---
 bigfish/segmentation/cyt_segmentation.py | 86 +++++++++++++-----------
 1 file changed, 47 insertions(+), 39 deletions(-)

diff --git a/bigfish/segmentation/cyt_segmentation.py b/bigfish/segmentation/cyt_segmentation.py
index e50a1a55..8c2de62e 100644
--- a/bigfish/segmentation/cyt_segmentation.py
+++ b/bigfish/segmentation/cyt_segmentation.py
@@ -15,10 +15,43 @@
 from scipy import ndimage as ndi
 
 
-# TODO rename functions
+def build_cyt_binary_mask(image_projected, threshold=None):
+    """Compute a binary mask of the cytoplasm.
 
+    Parameters
+    ----------
+    image_projected : np.ndarray, np.uint
+        A 2-d projection of the cytoplasm with shape (y, x).
+    threshold : int
+        Intensity pixel threshold to compute the binary mask. If None, an Otsu
+        threshold is computed.
 
-def build_cyt_relief(image_projected, nuc_labelled, alpha=0.8):
+    Returns
+    -------
+    mask : np.ndarray, bool
+        Binary mask of the cytoplasm with shape (y, x).
+
+    """
+    # check parameters
+    stack.check_array(image_projected,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16],
+                      allow_nan=False)
+    stack.check_parameter(threshold=(int, type(None)))
+
+    # get a threshold
+    if threshold is None:
+        threshold = threshold_otsu(image_projected)
+
+    # compute a binary mask
+    mask = (image_projected > threshold)
+    mask = remove_small_objects(mask, 3000)
+    mask = remove_small_holes(mask, 2000)
+
+    return mask
+
+
+def build_cyt_relief(image_projected, nuc_labelled, mask_cyt, alpha=0.8):
     """Compute a 2-d representation of the cytoplasm to be used by watershed
     algorithm.
 
@@ -37,6 +70,8 @@ def build_cyt_relief(image_projected, nuc_labelled, alpha=0.8):
         Projected image of the cytoplasm with shape (y, x).
     nuc_labelled : np.ndarray,
         Result of the nuclei segmentation with shape (y, x).
+    mask_cyt : np.ndarray, bool
+        Binary mask of the cytoplasm with shape (y, x).
     alpha : float or int
         Weight of the pixel intensity values to compute the relief. A value of
         0 and 1 respectively return 'relief_distance' and 'relief_pixel'.
@@ -47,7 +82,6 @@ def build_cyt_relief(image_projected, nuc_labelled, alpha=0.8):
         Relief image of the cytoplasm with shape (y, x).
 
     """
-    # TODO use distance map from bigfish.stack
     # check parameters
     stack.check_array(image_projected,
                       ndim=2,
@@ -57,6 +91,10 @@ def build_cyt_relief(image_projected, nuc_labelled, alpha=0.8):
                       ndim=2,
                       dtype=[np.uint8, np.uint16, np.int64, bool],
                       allow_nan=False)
+    stack.check_array(mask_cyt,
+                      ndim=2,
+                      dtype=[bool],
+                      allow_nan=False)
     stack.check_parameter(alpha=(float, int))
 
     # use pixel intensity of the cytoplasm channel to compute the seed.
@@ -65,11 +103,14 @@ def build_cyt_relief(image_projected, nuc_labelled, alpha=0.8):
         max_intensity = np.iinfo(image_projected.dtype).max
         relief = max_intensity - relief
         relief[nuc_labelled > 0] = 0
+        relief[mask_cyt == 0] = max_intensity
+        relief = stack.rescale(relief)
 
     # use distance from the nuclei
     elif alpha == 0:
         binary_mask_nuc = nuc_labelled > 0
         relief = ndi.distance_transform_edt(~binary_mask_nuc)
+        relief[mask_cyt == 0] = relief.max()
         relief = np.true_divide(relief, relief.max(), dtype=np.float32)
         if image_projected.dtype == np.uint8:
             relief = stack.cast_img_uint8(relief)
@@ -82,9 +123,12 @@ def build_cyt_relief(image_projected, nuc_labelled, alpha=0.8):
         max_intensity = np.iinfo(image_projected.dtype).max
         relief_pixel = max_intensity - relief_pixel
         relief_pixel[nuc_labelled > 0] = 0
+        relief_pixel[mask_cyt == 0] = max_intensity
+        relief_pixel = stack.rescale(relief_pixel)
         relief_pixel = stack.cast_img_float32(relief_pixel)
         binary_mask_nuc = nuc_labelled > 0
         relief_distance = ndi.distance_transform_edt(~binary_mask_nuc)
+        relief_distance[mask_cyt == 0] = relief_distance.max()
         relief_distance = np.true_divide(relief_distance,
                                          relief_distance.max(),
                                          dtype=np.float32)
@@ -102,42 +146,6 @@ def build_cyt_relief(image_projected, nuc_labelled, alpha=0.8):
     return relief
 
 
-def build_cyt_binary_mask(image_projected, threshold=None):
-    """Compute a binary mask of the cytoplasm.
-
-    Parameters
-    ----------
-    image_projected : np.ndarray, np.uint
-        A 2-d projection of the cytoplasm with shape (y, x).
-    threshold : int
-        Intensity pixel threshold to compute the binary mask. If None, an Otsu
-        threshold is computed.
-
-    Returns
-    -------
-    mask : np.ndarray, bool
-        Binary mask of the cytoplasm with shape (y, x).
-
-    """
-    # check parameters
-    stack.check_array(image_projected,
-                      ndim=2,
-                      dtype=[np.uint8, np.uint16],
-                      allow_nan=False)
-    stack.check_parameter(threshold=(int, type(None)))
-
-    # get a threshold
-    if threshold is None:
-        threshold = threshold_otsu(image_projected)
-
-    # compute a binary mask
-    mask = (image_projected > threshold)
-    mask = remove_small_objects(mask, 3000)
-    mask = remove_small_holes(mask, 2000)
-
-    return mask
-
-
 def cyt_watershed(relief, nuc_labelled, mask):
     """Apply watershed algorithm on the cytoplasm to segment cell instances.
 

From 6c3ee64064725f76423dbcb6d448565a17913fd2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 11:35:38 +0200
Subject: [PATCH 167/264] manage output dtype of gaussian and log filters

---
 bigfish/stack/filter.py | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
index e71c9148..e565f1b6 100644
--- a/bigfish/stack/filter.py
+++ b/bigfish/stack/filter.py
@@ -5,7 +5,8 @@
 import numpy as np
 
 from .utils import check_array, check_parameter
-from .preprocess import cast_img_float32, cast_img_float64
+from .preprocess import (cast_img_float32, cast_img_float64, cast_img_uint8,
+                         cast_img_uint16)
 
 from skimage.morphology.selem import square, diamond, rectangle, disk
 from skimage.filters import rank, gaussian
@@ -196,7 +197,7 @@ def minimum_filter(image, kernel_shape, kernel_size):
     return image_filtered
 
 
-def log_filter(image, sigma):
+def log_filter(image, sigma, keep_dtype=False):
     """Apply a Laplacian of Gaussian filter to a 2-d or 3-d image.
 
     The function returns the inverse of the filtered image such that the pixels
@@ -211,11 +212,14 @@ def log_filter(image, sigma):
     sigma : float, int, Tuple(float, int) or List(float, int)
         Sigma used for the gaussian filter (one for each dimension). If it's a
         float, the same sigma is applied to every dimensions.
+    keep_dtype : bool
+        Cast output image as input image.
 
     Returns
     -------
-    image_filtered : np.ndarray, np.float
+    image_filtered : np.ndarray
         Filtered image.
+
     """
     # check parameters
     check_array(image,
@@ -245,10 +249,19 @@ def log_filter(image, sigma):
     # reversed mexican hat, we inverse the result and clip negative values to 0
     image_filtered = np.clip(-image_filtered, a_min=0, a_max=None)
 
+    # cast filtered image
+    if keep_dtype:
+        if image.dtype == np.uint8:
+            image_filtered = cast_img_uint8(image_filtered)
+        elif image.dtype == np.uint16:
+            image_filtered = cast_img_uint16(image_filtered)
+        else:
+            pass
+
     return image_filtered
 
 
-def gaussian_filter(image, sigma, allow_negative=False):
+def gaussian_filter(image, sigma, allow_negative=False, keep_dtype=False):
     """Apply a Gaussian filter to a 2-d or 3-d image.
 
     Parameters
@@ -260,6 +273,9 @@ def gaussian_filter(image, sigma, allow_negative=False):
         float, the same sigma is applied to every dimensions.
     allow_negative : bool
         Allow negative values after the filtering or clip them to 0.
+    keep_dtype : bool
+        Cast output image as input image. Integer output can't allow negative
+        values.
 
     Returns
     -------
@@ -289,6 +305,15 @@ def gaussian_filter(image, sigma, allow_negative=False):
     if not allow_negative:
         image_filtered = np.clip(image_filtered, a_min=0, a_max=None)
 
+    # cast filtered image
+    if keep_dtype and not allow_negative:
+        if image.dtype == np.uint8:
+            image_filtered = cast_img_uint8(image_filtered)
+        elif image.dtype == np.uint16:
+            image_filtered = cast_img_uint16(image_filtered)
+        else:
+            pass
+
     return image_filtered
 
 

From 67e1710cd6183ccd0407f8a6bcc5fa923b5b19d2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 11:57:18 +0200
Subject: [PATCH 168/264] refactor spot detection

---
 bigfish/detection/__init__.py                 |  25 +
 bigfish/detection/gaussian_fit.py             | 571 ++++++++++++++++++
 .../spot_detection.py}                        | 193 +++---
 bigfish/spot_detection/__init__.py            |  14 -
 bigfish/spot_detection/gaussian_fit.py        |   0
 5 files changed, 674 insertions(+), 129 deletions(-)
 create mode 100644 bigfish/detection/__init__.py
 create mode 100644 bigfish/detection/gaussian_fit.py
 rename bigfish/{spot_detection/detection.py => detection/spot_detection.py} (63%)
 delete mode 100644 bigfish/spot_detection/__init__.py
 delete mode 100644 bigfish/spot_detection/gaussian_fit.py

diff --git a/bigfish/detection/__init__.py b/bigfish/detection/__init__.py
new file mode 100644
index 00000000..d6513c70
--- /dev/null
+++ b/bigfish/detection/__init__.py
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+"""
+The bigfish.detection module includes function to detect RNA spot in 2-d and
+3-d.
+"""
+
+from .detection import (detection, compute_snr, get_sigma, detection_log_lm,
+                        detection_log_lm, log_lm, non_maximum_suppression_mask,
+                        from_threshold_to_spots, from_threshold_to_snr)
+from .gaussian_fit import (get_spot_volume, get_spot_surface, build_grid,
+                           compute_background_amplitude, get_spot_parameter,
+                           objective_function, fit_gaussian,
+                           simulate_fitted_gaussian, gaussian_3d)
+
+_detection = ["detection", "compute_snr", "get_sigma", "detection_log_lm",
+              "detection_log_lm", "log_lm", "non_maximum_suppression_mask",
+              "from_threshold_to_spots", "from_threshold_to_snr"]
+
+_fit = ["get_spot_volume", "get_spot_surface", "build_grid",
+        "compute_background_amplitude", "get_spot_parameter",
+        "objective_function", "fit_gaussian",
+        "simulate_fitted_gaussian", "gaussian_3d"]
+
+__all__ = _detection + _fit
diff --git a/bigfish/detection/gaussian_fit.py b/bigfish/detection/gaussian_fit.py
new file mode 100644
index 00000000..9d30a833
--- /dev/null
+++ b/bigfish/detection/gaussian_fit.py
@@ -0,0 +1,571 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions to fit gaussian functions to the detected RNA spots.
+"""
+
+from .detection import get_sigma
+
+import numpy as np
+
+from scipy.special import erf
+from scipy.optimize import curve_fit
+
+
+# TODO complete documentation methods
+# TODO add sanity check functions
+
+# ### Gaussian function ###
+
+def _rescaled_erf(low, high, mu, sigma):
+    """Rescaled the Error function along a specific axis.
+
+    # TODO add equations
+
+    Parameters
+    ----------
+    low : np.ndarray, np.float
+        Lower bound of the voxel along a specific axis.
+    high : np.ndarray, np.float
+        Upper bound of the voxel along a specific axis.
+    mu : float
+        Estimated mean of the gaussian signal along a specific axis.
+    sigma : float
+        Estimated standard deviation of the gaussian signal along a specific
+        axis.
+
+    Returns
+    -------
+    new_erf : np.ndarray, np.float
+        Rescaled erf along a specific axis.
+
+    """
+    low_ = (low - mu) / (np.sqrt(2) * sigma)
+    high_ = (high - mu) / (np.sqrt(2) * sigma)
+    new_erf = sigma * np.sqrt(np.pi / 2) * (erf(high_) - erf(low_))
+    return new_erf
+
+
+def gaussian_3d(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, resolution_z,
+                resolution_yx, psf_amplitude, psf_background):
+    """Compute the gaussian function over the grid 'xdata' representing a
+    volume V with shape (V_z, V_y, V_x).
+
+    # TODO add equations
+
+    Parameters
+    ----------
+    grid : np.ndarray, np.float
+        Grid data to compute the gaussian function for different voxel within
+        a volume V. In nanometer, with shape (3, V_z * V_y * V_x).
+    mu_z : float
+        Estimated mean of the gaussian signal along z axis, in nanometer.
+    mu_y : float
+        Estimated mean of the gaussian signal along y axis, in nanometer.
+    mu_x : float
+        Estimated mean of the gaussian signal along x axis, in nanometer.
+    sigma_z : float
+        Estimated standard deviation of the gaussian signal along z axis, in
+        nanometer.
+    sigma_yx : float
+        Estimated standard deviation of the gaussian signal along y and x axis,
+        in nanometer.
+    resolution_z : float
+        Height of a voxel, in nanometer.
+    resolution_yx : float
+        size of a voxel, in nanometer.
+    psf_amplitude : float
+        Estimated pixel intensity of a spot.
+    psf_background : float
+        Estimated pixel intensity of the background.
+
+    Returns
+    -------
+    values : np.ndarray, np.float
+        Value of each voxel within the volume V according to the 3-d gaussian
+        parameters. Shape (V_z * V_y * V_x,).
+
+    """
+    # get grid data to design a volume V
+    meshgrid_z = grid[0]
+    meshgrid_y = grid[1]
+    meshgrid_x = grid[2]
+
+    # get voxel coordinates
+    meshgrid_z_minus = meshgrid_z - resolution_z / 2
+    meshgrid_z_plus = meshgrid_z + resolution_z / 2
+    meshgrid_y_minus = meshgrid_y - resolution_yx / 2
+    meshgrid_y_plus = meshgrid_y + resolution_yx / 2
+    meshgrid_x_minus = meshgrid_x - resolution_yx / 2
+    meshgrid_x_plus = meshgrid_x + resolution_yx / 2
+
+    # compute gaussian function for each voxel (i, j, k) volume V
+    factor = psf_amplitude / (resolution_yx ** 2 * resolution_z)
+    voxel_integral_z = _rescaled_erf(low=meshgrid_z_minus,
+                                     high=meshgrid_z_plus,
+                                     mu=mu_z,
+                                     sigma=sigma_z)
+    voxel_integral_y = _rescaled_erf(low=meshgrid_y_minus,
+                                     high=meshgrid_y_plus,
+                                     mu=mu_y,
+                                     sigma=sigma_yx)
+    voxel_integral_x = _rescaled_erf(low=meshgrid_x_minus,
+                                     high=meshgrid_x_plus,
+                                     mu=mu_x,
+                                     sigma=sigma_yx)
+    voxel_integral = voxel_integral_z * voxel_integral_y * voxel_integral_x
+    values = psf_background + factor * voxel_integral
+
+    return values
+
+
+# ### Spot parameter ###
+
+def get_spot_volume(image, spot_z, spot_y, spot_x, radius_z, radius_yx,
+                    return_center=False):
+    """Get a subimage of a detected spot in 3-d.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    spot_z : np.int64
+        Coordinate of the detected spot along the z axis.
+    spot_y : np.int64
+        Coordinate of the detected spot along the y axis.
+    spot_x : np.int64
+        Coordinate of the detected spot along the x axis.
+    radius_z : float
+        Estimated radius of the spot along the z-dimension.
+    radius_yx : float
+        Estimated radius of the spot on the yx-plan.
+    return_center : bool
+        Return center of the detected spot in the new volume.
+
+    Returns
+    -------
+    image_spot : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (radius_z * 2, radius_yx * 2,
+        radius_yx * 2).
+    center_z : float
+        Estimated centroid of the spot, in nanometer, along the z axis.
+    center_y : float
+        Estimated centroid of the spot, in nanometer, along the y axis.
+    center_x : float
+        Estimated centroid of the spot, in nanometer, along the x axis.
+
+    """
+    # get boundaries of the volume surrounding the spot
+    z_spot_min = max(0, int(spot_z - 2 * radius_z))
+    z_spot_max = min(image.shape[0], int(spot_z + 2 * radius_z) + 1)
+    y_spot_min = max(0, int(spot_y - 2 * radius_yx))
+    y_spot_max = min(image.shape[1], int(spot_y + 2 * radius_yx) + 1)
+    x_spot_min = max(0, int(spot_x - 2 * radius_yx))
+    x_spot_max = min(image.shape[2], int(spot_x + 2 * radius_yx) + 1)
+
+    # get the volume of the spot
+    image_spot = image[z_spot_min:z_spot_max + 1,
+                       y_spot_min:y_spot_max + 1,
+                       x_spot_min:x_spot_max + 1]
+
+    # get center of the detected spot in the new volume
+    if return_center:
+        center_z = spot_z - z_spot_min
+        center_y = spot_y - y_spot_min
+        center_x = spot_x - x_spot_min
+
+        return image_spot, center_z, center_y, center_x
+
+    else:
+
+        return image_spot
+
+
+def get_spot_surface(image, z_spot, spot_y, spot_x, radius_yx):
+    """Get a subimage of a detected spot from its supposed yx plan.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    spot_z : np.int64
+        Coordinate of the detected spot along the z axis.
+    spot_y : np.int64
+        Coordinate of the detected spot along the y axis.
+    spot_x : np.int64
+        Coordinate of the detected spot along the x axis.
+    radius_yx : float
+        Estimated radius of the spot on the yx-plan.
+
+    Returns
+    -------
+    image_spot_2d : np.ndarray, np.uint
+        A 2-d image with detected spot and shape (radius_yx * 2,
+        radius_yx * 2).
+
+    """
+    # get boundaries of the volume surrounding the spot
+    y_spot_min = max(0, int(spot_y - 2 * radius_yx))
+    y_spot_max = min(image.shape[1], int(spot_y + 2 * radius_yx) + 1)
+    x_spot_min = max(0, int(spot_x - 2 * radius_yx))
+    x_spot_max = min(image.shape[2], int(spot_x + 2 * radius_yx) + 1)
+
+    # get the detected yx plan for the spot
+    image_spot_2d = image[z_spot,
+                          y_spot_min:y_spot_max + 1,
+                          x_spot_min:x_spot_max + 1]
+
+    return image_spot_2d
+
+
+def build_grid(image_spot, resolution_z, resolution_yx, return_centroid=False):
+    """Build a grid in nanometer to compute gaussian function over a full
+    volume.
+
+    Parameters
+    ----------
+    image_spot : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    resolution_z : float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : float
+        Size of a voxel on the yx plan, in nanometer.
+    return_centroid : bool
+        Compute centroid estimation of the grid.
+    Returns
+    -------
+    grid : np.ndarray, np.float32
+        A grid with the shape (3, z * y * x), in nanometer.
+    centroid_z : float
+        Estimated centroid of the spot, in nanometer, along the z axis.
+    centroid_y : float
+        Estimated centroid of the spot, in nanometer, along the y axis.
+    centroid_x : float
+        Estimated centroid of the spot, in nanometer, along the x axis.
+
+    """
+    # get targeted size
+    nb_z, nb_y, nb_x = image_spot.shape
+    nb_pixels = image_spot.size
+
+    # build meshgrid
+    zz, yy, xx = np.meshgrid(np.arange(nb_z), np.arange(nb_y), np.arange(nb_x),
+                             indexing="ij")
+    zz *= resolution_z
+    yy *= resolution_yx
+    xx *= resolution_yx
+
+    # format result
+    grid = np.zeros((3, nb_pixels), dtype=np.float32)
+    grid[0] = np.reshape(zz, (1, nb_pixels)).astype(np.float32)
+    grid[1] = np.reshape(yy, (1, nb_pixels)).astype(np.float32)
+    grid[2] = np.reshape(xx, (1, nb_pixels)).astype(np.float32)
+
+    # compute centroid of the grid
+    if return_centroid:
+        area = np.sum(image_spot)
+        dz = image_spot * zz
+        dy = image_spot * yy
+        dx = image_spot * xx
+        centroid_z = np.sum(dz) / area
+        centroid_y = np.sum(dy) / area
+        centroid_x = np.sum(dx) / area
+
+        return grid, centroid_z, centroid_y, centroid_x
+
+    else:
+
+        return grid
+
+
+def compute_background_amplitude(image_spot):
+    """Compute amplitude of a spot and background minimum value.
+
+    Parameters
+    ----------
+    image_spot : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+
+    Returns
+    -------
+    psf_amplitude : float
+        Amplitude of the spot.
+    psf_background : float
+        Background minimum value of the voxel.
+
+    """
+    image_min, image_max = image_spot.min(), image_spot.max()
+    psf_amplitude = image_max - image_min
+    psf_background = image_min
+
+    return psf_amplitude, psf_background
+
+
+def get_spot_parameter(image, spot_z, spot_y, spot_x, psf_z=400, psf_yx=200,
+                       resolution_z=300, resolution_yx=103,
+                       compute_centroid=False):
+    """Initialize parameters to fit gaussian function on a spot.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    spot_z : np.int64
+        Coordinate of the detected spot along the z axis.
+    spot_y : np.int64
+        Coordinate of the detected spot along the y axis.
+    spot_x : np.int64
+        Coordinate of the detected spot along the x axis.
+    psf_z : int or float
+        Theoretical height of the spot PSF along the z axis, in nanometer.
+    psf_yx : int or float
+        Theoretical diameter of the spot PSF on the yx plan, in nanometer.
+    resolution_z : int or float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : int or float
+        Size of a voxel on the yx plan, in nanometer.
+    compute_centroid : bool
+        Compute an estimation of the centroid of the spot from pixel intensity
+        or use the center of the subimage.
+
+    Returns
+    -------
+    image_spot : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    grid : np.ndarray, np.float32
+        A grid with the shape (3, z * y * x), in nanometer.
+    center_z : float
+        Estimated centroid of the spot, in nanometer, along the z axis.
+    center_y : float
+        Estimated centroid of the spot, in nanometer, along the y axis.
+    center_x : float
+        Estimated centroid of the spot, in nanometer, along the x axis.
+    psf_amplitude : float
+        Amplitude of the spot.
+    psf_background : float
+        Background minimum value of the voxel.
+
+    """
+    # compute estimated radius of the spot
+    sigma_z, sigma_yx = get_sigma(resolution_z=resolution_z,
+                                  resolution_yx=resolution_yx,
+                                  psf_z=psf_z,
+                                  psf_yx=psf_yx)
+    radius_z = np.sqrt(3) * sigma_z
+    radius_yx = np.sqrt(3) * sigma_yx
+
+    if compute_centroid:
+        # get subimage of the spot
+        image_spot = get_spot_volume(
+            image=image,
+            spot_z=spot_z,
+            spot_y=spot_y,
+            spot_x=spot_x,
+            radius_z=radius_z,
+            radius_yx=radius_yx)
+
+        # build a grid to fit the gaussian values
+        grid, center_z, center_y, center_x = build_grid(
+            image_spot=image_spot,
+            resolution_z=resolution_z,
+            resolution_yx=resolution_yx,
+            return_centroid=True)
+
+    else:
+        # get subimage of the spot
+        image_spot, center_z, center_y, center_x = get_spot_volume(
+            image=image,
+            spot_z=spot_z,
+            spot_y=spot_y,
+            spot_x=spot_x,
+            radius_z=radius_z,
+            radius_yx=radius_yx,
+            return_center=True)
+        center_z = float(center_z * resolution_z)
+        center_y = float(center_y * resolution_yx)
+        center_x = float(center_x * resolution_yx)
+
+        # build a grid to fit the gaussian values
+        grid = build_grid(
+            image_spot=image_spot,
+            resolution_z=resolution_z,
+            resolution_yx=resolution_yx,
+            return_centroid=False)
+
+    # compute amplitude and background values
+    psf_amplitude, psf_background = compute_background_amplitude(image_spot)
+
+    return (image_spot, grid, center_z, center_y, center_x, psf_amplitude,
+            psf_background)
+
+
+# ### Gaussian fitting ###
+
+def objective_function(resolution_z=300, resolution_yx=103, sigma_z=400,
+                       sigma_yx=200,  psf_amplitude=None):
+    """Design the objective function used to fit the gaussian function.
+
+    Parameters
+    ----------
+    resolution_z : int or float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : int or float
+        Size of a voxel on the yx plan, in nanometer.
+    sigma_z : float
+        Theoretical height of the spot PSF along the z axis, in nanometer.
+    sigma_yx : float
+        Theoretical diameter of the spot PSF on the yx plan, in nanometer.
+    psf_amplitude : float
+        Amplitude of the spot.
+
+    Returns
+    -------
+    f : func
+        A 3-d gaussian function with some parameters fixed.
+
+    """
+    # sigma is a fixed and known parameter
+    if (sigma_z is not None
+            and sigma_yx is not None
+            and psf_amplitude is None):
+        def f(grid, mu_z, mu_y, mu_x, psf_amplitude, psf_background):
+            values = gaussian_3d(grid=grid,
+                                 mu_z=mu_z,
+                                 mu_y=mu_y,
+                                 mu_x=mu_x,
+                                 sigma_z=sigma_z,
+                                 sigma_yx=sigma_yx,
+                                 resolution_z=resolution_z,
+                                 resolution_yx=resolution_yx,
+                                 psf_amplitude=psf_amplitude,
+                                 psf_background=psf_background)
+            return values
+
+    # amplitude is a fixed and known parameter
+    elif (psf_amplitude is not None
+          and sigma_z is None
+          and sigma_yx is None):
+        def f(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, psf_background):
+            values = gaussian_3d(grid=grid,
+                                 mu_z=mu_z,
+                                 mu_y=mu_y,
+                                 mu_x=mu_x,
+                                 sigma_z=sigma_z,
+                                 sigma_yx=sigma_yx,
+                                 resolution_z=resolution_z,
+                                 resolution_yx=resolution_yx,
+                                 psf_amplitude=psf_amplitude,
+                                 psf_background=psf_background)
+            return values
+
+    # amplitude and sigma are fixed and known parameters
+    elif (psf_amplitude is not None
+          and sigma_z is not None
+          and sigma_yx is not None):
+        def f(grid, mu_z, mu_y, mu_x, psf_background):
+            values = gaussian_3d(grid=grid,
+                                 mu_z=mu_z,
+                                 mu_y=mu_y,
+                                 mu_x=mu_x,
+                                 sigma_z=sigma_z,
+                                 sigma_yx=sigma_yx,
+                                 resolution_z=resolution_z,
+                                 resolution_yx=resolution_yx,
+                                 psf_amplitude=psf_amplitude,
+                                 psf_background=psf_background)
+            return values
+
+    elif (psf_amplitude is None
+          and sigma_z is None
+          and sigma_yx is None):
+        def f(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, psf_amplitude,
+              psf_background):
+            values = gaussian_3d(grid=grid,
+                                 mu_z=mu_z,
+                                 mu_y=mu_y,
+                                 mu_x=mu_x,
+                                 sigma_z=sigma_z,
+                                 sigma_yx=sigma_yx,
+                                 resolution_z=resolution_z,
+                                 resolution_yx=resolution_yx,
+                                 psf_amplitude=psf_amplitude,
+                                 psf_background=psf_background)
+            return values
+
+    else:
+        raise ValueError("Parameters 'sigma_z' and 'sigma_yx' should be "
+                         "fixed or optimized together.")
+
+    return f
+
+
+def fit_gaussian(f, grid, image_spot, p0, lower_bound=None, upper_bound=None):
+    """Fit a gaussian function to a 3-d image.
+
+    # TODO add equations and algorithm
+
+    Parameters
+    ----------
+    f : func
+        A 3-d gaussian function with some parameters fixed.
+    grid : np.ndarray, np.float
+        Grid data to compute the gaussian function for different voxel within
+        a volume V. In nanometer, with shape (3, V_z * V_y * V_x).
+    image_spot : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    p0 : List
+        List of parameters to estimate.
+    lower_bound : List
+        List of lower bound values for the different parameters.
+    upper_bound : List
+        List of upper bound values for the different parameters.
+
+    Returns
+    -------
+    popt : np.ndarray
+        Fitted parameters.
+    pcov : np.ndarray
+        Estimated covariance of 'popt'.
+
+    """
+    # compute lower bound and upper bound
+    if lower_bound is None:
+        lower_bound = [-np.inf for _ in p0]
+    if upper_bound is None:
+        upper_bound = [np.inf for _ in p0]
+    bounds = (lower_bound, upper_bound)
+
+    # Apply non-linear least squares to fit a gaussian function to a 3-d image
+    y = np.reshape(image_spot, (image_spot.size,)).astype(np.float32)
+    popt, pcov = curve_fit(f=f, xdata=grid, ydata=y, p0=p0, bounds=bounds)
+
+    return popt, pcov
+
+
+def simulate_fitted_gaussian(f, grid, popt, original_shape=None):
+    """Use the optimized parameter to simulate a gaussian signal.
+
+    Parameters
+    ----------
+    f : func
+        A 3-d gaussian function with some parameters fixed.
+    grid : np.ndarray, np.float
+        Grid data to compute the gaussian function for different voxel within
+        a volume V. In nanometer, with shape (3, V_z * V_y * V_x).
+    popt : np.ndarray
+        Fitted parameters.
+    original_shape : Tuple
+        Shape of the spot image to reshape the simulation.
+
+    Returns
+    -------
+    values : np.ndarray, np.float
+        Value of each voxel within the volume V according to the 3-d gaussian
+        parameters. Shape (V_z, V_y, V_x,) or (V_z * V_y * V_x,).
+
+    """
+    values = f(grid, *popt)
+    if original_shape is not None:
+        values = np.reshape(values, original_shape).astype(np.float32)
+
+    return values
diff --git a/bigfish/spot_detection/detection.py b/bigfish/detection/spot_detection.py
similarity index 63%
rename from bigfish/spot_detection/detection.py
rename to bigfish/detection/spot_detection.py
index f2c9b6e5..3a5982c8 100644
--- a/bigfish/spot_detection/detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -11,47 +11,11 @@
 
 
 # TODO complete documentation methods
+# TODO add sanity check functions
 
 # ### Spot detection ###
 
-def detection(tensor, r, c, detection_method, **kwargs):
-    """Apply spot detection.
-
-    Parameters
-    ----------
-    tensor : nd.ndarray, np.uint
-        Tensor with shape (r, c, z, y, x).
-    r : int
-        Round index to process.
-    c : int
-        Channel index of the smfish image.
-    detection_method : str
-        Method used to detect spots.
-
-    Returns
-    -------
-    peak_coordinates : np.ndarray, np.int64
-        Coordinate of the local peaks with shape (nb_peaks, 3) or
-        (nb_peaks, 2) for 3-d or 2-d images respectively.
-    radius : float
-        Radius of the detected peaks.
-
-    """
-    # check tensor dimensions and its dtype
-    stack.check_array(tensor, ndim=5, dtype=[np.uint8, np.uint16])
-
-    # get the smfish image
-    image = tensor[r, c, :, :, :]
-
-    # apply spot detection
-    peak_coordinates, radius = None, None
-    if detection_method == "log_lm":
-        peak_coordinates, radius = detection_log_lm(image, **kwargs)
-
-    return peak_coordinates, radius
-
-
-def detection_log_lm(image, sigma, minimum_distance=1, threshold=None):
+def log_lm(image, sigma, minimum_distance=1, threshold=None):
     """Apply LoG filter followed by a Local Maximum algorithm to detect spots
     in a 2-d or 3-d image.
 
@@ -76,57 +40,35 @@ def detection_log_lm(image, sigma, minimum_distance=1, threshold=None):
 
     Returns
     -------
-    peak_coordinates : np.ndarray, np.int64
-        Coordinate of the local peaks with shape (nb_peaks, 3) or
-        (nb_peaks, 2) for 3-d or 2-d images respectively.
-    radius : float
+    spots : np.ndarray, np.int64
+        Coordinate of the spots with shape (nb_spots, 3) or (nb_spots, 2)
+        for 3-d or 2-d images respectively.
+    radius : float, Tuple[float]
         Radius of the detected peaks.
 
     """
-    # cast image in np.float, apply LoG filter and find local maximum
-    mask = _log_lm(image, sigma, minimum_distance)
-
-    # remove peak with a low intensity and return coordinates and radius
-    peak_coordinates, radius = _from_threshold_to_spots(image, sigma, mask,
-                                                        threshold)
-
-    return peak_coordinates, radius
-
-
-def _log_lm(image, sigma, minimum_distance=1):
-    """Find local maximum in a 2-d or 3-d image.
-
-    1) We smooth the image with a LoG filter.
-    2) We apply a multidimensional maximum filter.
-    3) A pixel which has the same value in the original and filtered images
-    is a local maximum.
-
-    Parameters
-    ----------
-    image : np.ndarray, np.uint
-        Image to process with shape (z, y, x) or (y, x).
-    sigma : float or Tuple(float)
-        Sigma used for the gaussian filter (one for each dimension). If it's a
-        float, the same sigma is applied to every dimensions.
-    minimum_distance : int
-        Minimum distance (in number of pixels) between two local peaks.
+    # check parameters
+    stack.check_array(image,
+                      ndim=[2, 3],
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_parameter(sigma=(float, int, tuple),
+                          minimum_distance=(float, int),
+                          threshold=(float, int))
 
-    Returns
-    -------
-    mask : np.ndarray, bool
-        Mask with shape (z, y, x) or (y, x) indicating the local peaks.
-
-    """
     # cast image in np.float and apply LoG filter
-    image_filtered = stack.log_filter(image, sigma)
+    image_filtered = stack.log_filter(image, sigma, keep_dtype=False)
 
     # find local maximum
-    mask = _non_maximum_suppression_mask(image_filtered, minimum_distance)
+    mask = local_maximum_detection(image_filtered, minimum_distance)
 
-    return mask
+    # remove spots with a low intensity and return coordinates and radius
+    spots, radius = spots_thresholding(image, sigma, mask, threshold)
 
+    return spots, radius
 
-def _non_maximum_suppression_mask(image, minimum_distance):
+
+def local_maximum_detection(image, minimum_distance):
     """Compute a mask to keep only local maximum, in 2-d and 3-d.
 
     1) We apply a multidimensional maximum filter.
@@ -135,9 +77,9 @@ def _non_maximum_suppression_mask(image, minimum_distance):
 
     Parameters
     ----------
-    image : np.ndarray, np.float
+    image : np.ndarray, np.uint
         Image to process with shape (z, y, x) or (y, x).
-    minimum_distance : int
+    minimum_distance : int, float
         Minimum distance (in number of pixels) between two local peaks.
 
     Returns
@@ -146,12 +88,18 @@ def _non_maximum_suppression_mask(image, minimum_distance):
         Mask with shape (z, y, x) or (y, x) indicating the local peaks.
 
     """
-    # compute the kernel size (centered around our pixel because it is uneven
-    kernel_size = 2 * minimum_distance + 1
+    # check parameters
+    stack.check_array(image,
+                      ndim=[2, 3],
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_parameter(minimum_distance=(float, int))
+
+    # compute the kernel size (centered around our pixel because it is uneven)
+    kernel_size = int(2 * minimum_distance + 1)
 
     # apply maximum filter to the original image
-    image_filtered = ndi.maximum_filter(image, size=kernel_size,
-                                        mode='constant')
+    image_filtered = ndi.maximum_filter(image, size=kernel_size)
 
     # we keep the pixels with the same value before and after the filtering
     mask = image == image_filtered
@@ -159,8 +107,8 @@ def _non_maximum_suppression_mask(image, minimum_distance):
     return mask
 
 
-def _from_threshold_to_spots(image, sigma, mask, threshold):
-    """Filter detected local maximum and get coordinates of the remaining
+def spots_thresholding(image, sigma, mask, threshold):
+    """Filter detected spots and get coordinates of the remaining
     spots.
 
     Parameters
@@ -181,19 +129,37 @@ def _from_threshold_to_spots(image, sigma, mask, threshold):
     peak_coordinates : np.ndarray, np.int64
         Coordinate of the local peaks with shape (nb_peaks, 3) or
         (nb_peaks, 2) for 3-d or 2-d images respectively.
-    radius : float
+    radius : float or Tuple(float)
         Radius of the detected peaks.
 
     """
+    # check parameters
+    stack.check_array(image,
+                      ndim=[2, 3],
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_array(mask,
+                      ndim=[2, 3],
+                      dtype=[bool],
+                      allow_nan=False)
+    stack.check_parameter(sigma=(float, int, tuple),
+                          threshold=(float, int))
+
     # remove peak with a low intensity
     if isinstance(threshold, float):
         threshold *= image.max()
     mask_ = (mask & (image > threshold))
 
-    # get peak coordinates and radius
+    # get peak coordinates
     peak_coordinates = np.nonzero(mask_)
     peak_coordinates = np.column_stack(peak_coordinates)
-    radius = np.sqrt(image.ndim) * sigma[-1]
+
+    # compute radius
+    if isinstance(sigma, tuple):
+        radius = [np.sqrt(image.ndim) * sigma_ for sigma_ in sigma]
+        radius = tuple(radius)
+    else:
+        radius = np.sqrt(image.ndim) * sigma
 
     return peak_coordinates, radius
 
@@ -225,17 +191,17 @@ def compute_snr(image, sigma, minimum_distance=1,
 
     """
     # cast image in np.float, apply LoG filter and find local maximum
-    mask = _log_lm(image, sigma, minimum_distance)
+    mask = log_lm(image, sigma, minimum_distance)
 
     # apply a specific threshold to filter the detected spots and compute snr
-    l_snr = _from_threshold_to_snr(image, sigma, mask,
-                                   threshold_signal_detection,
-                                   neighbor_factor)
+    l_snr = from_threshold_to_snr(image, sigma, mask,
+                                  threshold_signal_detection,
+                                  neighbor_factor)
 
     return l_snr
 
 
-def _from_threshold_to_snr(image, sigma, mask, threshold=2000,
+def from_threshold_to_snr(image, sigma, mask, threshold=2000,
                            neighbor_factor=3):
     """
 
@@ -327,34 +293,31 @@ def _from_threshold_to_snr(image, sigma, mask, threshold=2000,
 
 # ### Utils ###
 
-def get_sigma(resolution_xy=103, resolution_z=300, psf_xy=200, psf_z=400):
-    """Compute the optimal sigma to use gaussian models with spots.
+def get_sigma(resolution_z=300, resolution_yx=103, psf_z=400, psf_yx=200):
+    """Compute the standard deviation of the PSF of the spots.
 
     Parameters
     ----------
-    resolution_xy : int
-        Distance, in nanometer, between two pixels along the XY dimension.
-    resolution_z : int
-        Distance, in nanometer, between two pixels along the Z dimension.
-
-    psf_xy : int
-        Theoretical size (in nanometer) of the signal emitted by a spot in
-        the XY plan.
+    resolution_z : float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : float
+        Size of a voxel on the yx plan, in nanometer.
+    psf_yx : int
+        Theoretical size of the PSF emitted by a spot in
+        the yx plan, in nanometer.
     psf_z : int
-        Theoretical size (in nanometer) of the signal emitted by a spot in
-        the Z plan.
+        Theoretical size of the PSF emitted by a spot in
+        the z plan, in nanometer.
 
     Returns
     -------
-    sigma : Tuple
-        A Tuple with 3 items corresponding to the sigma used by a gaussian
-        filter in each direction of the image (approximately the same size of
-        the spot in the image).
-
+    sigma_z : float
+        Standard deviation of the PSF, along the z axis, in pixel.
+    sigma_xy : float
+        Standard deviation of the PSF, along the yx plan, in pixel.
     """
     # compute sigma
-    sigma_xy = psf_xy / resolution_xy
     sigma_z = psf_z / resolution_z
-    sigma = (sigma_z, sigma_xy, sigma_xy)
+    sigma_yx = psf_yx / resolution_yx
 
-    return sigma
+    return sigma_z, sigma_yx
diff --git a/bigfish/spot_detection/__init__.py b/bigfish/spot_detection/__init__.py
deleted file mode 100644
index b3f82c6e..00000000
--- a/bigfish/spot_detection/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-The bigfish.detection module includes function to detect RNA spot in 2-d and
-3-d.
-"""
-
-from .detection import (detection, compute_snr, get_sigma, detection_log_lm)
-
-
-__all__ = ["detection",
-           "compute_snr",
-           "get_sigma",
-           "detection_log_lm"]
diff --git a/bigfish/spot_detection/gaussian_fit.py b/bigfish/spot_detection/gaussian_fit.py
deleted file mode 100644
index e69de29b..00000000

From b6f5c9d934e827d88fb5be20c887fe2e9938992c Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 12:01:38 +0200
Subject: [PATCH 169/264] refactor spot detection #2

---
 bigfish/detection/spot_detection.py | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index 3a5982c8..cbbc7240 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -15,7 +15,7 @@
 
 # ### Spot detection ###
 
-def log_lm(image, sigma, minimum_distance=1, threshold=None):
+def log_lm(image, sigma, threshold, minimum_distance=1, return_log=False):
     """Apply LoG filter followed by a Local Maximum algorithm to detect spots
     in a 2-d or 3-d image.
 
@@ -32,11 +32,13 @@ def log_lm(image, sigma, minimum_distance=1, threshold=None):
     sigma : float or Tuple(float)
         Sigma used for the gaussian filter (one for each dimension). If it's a
         float, the same sigma is applied to every dimensions.
-    minimum_distance : int
-        Minimum distance (in number of pixels) between two local peaks.
     threshold : float or int
         A threshold to detect peaks. Considered as a relative threshold if
         float.
+    minimum_distance : int
+        Minimum distance (in number of pixels) between two local peaks.
+    return_log : bool
+        Return the LoG filtered image.
 
     Returns
     -------
@@ -57,7 +59,7 @@ def log_lm(image, sigma, minimum_distance=1, threshold=None):
                           threshold=(float, int))
 
     # cast image in np.float and apply LoG filter
-    image_filtered = stack.log_filter(image, sigma, keep_dtype=False)
+    image_filtered = stack.log_filter(image, sigma, keep_dtype=True)
 
     # find local maximum
     mask = local_maximum_detection(image_filtered, minimum_distance)
@@ -65,7 +67,11 @@ def log_lm(image, sigma, minimum_distance=1, threshold=None):
     # remove spots with a low intensity and return coordinates and radius
     spots, radius = spots_thresholding(image, sigma, mask, threshold)
 
-    return spots, radius
+    if return_log:
+        return spots, radius, image_filtered
+
+    else:
+        return spots, radius
 
 
 def local_maximum_detection(image, minimum_distance):

From d6ac714ff4ef34f045025a0dc256255edf778a63 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 12:09:08 +0200
Subject: [PATCH 170/264] add function to remove background with gaussian
 gilter

---
 bigfish/stack/__init__.py | 10 ++++++----
 bigfish/stack/filter.py   | 42 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 47 insertions(+), 5 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 6d722691..81d5ea28 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -7,7 +7,7 @@
 
 from .utils import (check_array, check_df, check_recipe, check_parameter,
                     check_range_value, complete_coordinates_2d,
-                    from_coord_to_image)
+                    from_coord_to_image, get_offset_value)
 from .io import (read_image, read_pickle, read_cell_json, read_rna_json,
                  save_image)
 from .preprocess import (build_simulated_dataset, build_stacks, build_stack,
@@ -16,7 +16,8 @@
                          cast_img_float64, clean_simulated_data,
                          deconstruct_image, reconstruct_image)
 from .filter import (log_filter, mean_filter, median_filter, maximum_filter,
-                     minimum_filter, gaussian_filter, remove_background)
+                     minimum_filter, gaussian_filter, remove_background_mean,
+                     remove_background_gaussian)
 from .projection import (maximum_projection, mean_projection,
                          median_projection, in_focus_selection,
                          focus_measurement, get_in_focus_indices,
@@ -34,7 +35,7 @@
 
 _utils = ["check_array", "check_df", "check_recipe", "check_parameter",
           "check_range_value", "complete_coordinates_2d",
-          "from_coord_to_image"]
+          "from_coord_to_image", "get_offset_value"]
 
 _io = ["read_image", "read_pickle", "read_cell_json", "read_rna_json",
        "save_image"]
@@ -46,7 +47,8 @@
                "reconstruct_image"]
 
 _filter = ["log_filter", "mean_filter", "median_filter", "maximum_filter",
-           "minimum_filter", "gaussian_filter", "remove_background"]
+           "minimum_filter", "gaussian_filter", "remove_background_mean",
+           "remove_background_gaussian"]
 
 _projection = ["maximum_projection", "mean_projection", "median_projection",
                "in_focus_selection", "focus_measurement",
diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
index e565f1b6..2235225a 100644
--- a/bigfish/stack/filter.py
+++ b/bigfish/stack/filter.py
@@ -317,7 +317,7 @@ def gaussian_filter(image, sigma, allow_negative=False, keep_dtype=False):
     return image_filtered
 
 
-def remove_background(image, kernel_shape="disk", kernel_size=200):
+def remove_background_mean(image, kernel_shape="disk", kernel_size=200):
     """Remove background noise from a 2-d image, subtracting a mean filtering.
 
     Parameters
@@ -356,3 +356,43 @@ def remove_background(image, kernel_shape="disk", kernel_size=200):
                                      where=mask)
 
     return image_without_back
+
+
+def remove_background_gaussian(image, sigma):
+    """Remove background noise from a 2-d or 3-d image, subtracting a gaussian
+    filtering.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image to process with shape (z, y, x) or (y, x).
+    sigma : float, int, Tuple(float, int) or List(float, int)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+
+    Returns
+    -------
+    image_no_background : np.ndarray
+        Image processed with shape (z, y, x) or (y, x).
+
+    """
+    # check parameters
+    check_array(image,
+                ndim=[2, 3],
+                dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                allow_nan=False)
+    check_parameter(sigma=(float, int, tuple, list))
+
+    # apply a gaussian filter
+    image_filtered = gaussian_filter(image, sigma,
+                                     allow_negative=False,
+                                     keep_dtype=True)
+
+    # substract the gaussian filter
+    out = np.zeros_like(image)
+    image_no_background = np.subtract(image, image_filtered,
+                                      out=out,
+                                      where=(image > image_filtered),
+                                      dtype=image.dtype)
+
+    return image_no_background

From 4678703a5a0c88d6ad1d5dd3fde50d937873ac46 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 12:30:32 +0200
Subject: [PATCH 171/264] build reference spot from detected spots

---
 bigfish/detection/__init__.py       |  13 ++--
 bigfish/detection/spot_detection.py | 110 ++++++++++++++++++++++++++++
 2 files changed, 117 insertions(+), 6 deletions(-)

diff --git a/bigfish/detection/__init__.py b/bigfish/detection/__init__.py
index d6513c70..e9a1a0a2 100644
--- a/bigfish/detection/__init__.py
+++ b/bigfish/detection/__init__.py
@@ -5,17 +5,18 @@
 3-d.
 """
 
-from .detection import (detection, compute_snr, get_sigma, detection_log_lm,
-                        detection_log_lm, log_lm, non_maximum_suppression_mask,
-                        from_threshold_to_spots, from_threshold_to_snr)
+from .spot_detection import (log_lm, local_maximum_detection,
+                             spots_thresholding, compute_snr,
+                             from_threshold_to_snr, get_sigma,
+                             build_reference_spot)
 from .gaussian_fit import (get_spot_volume, get_spot_surface, build_grid,
                            compute_background_amplitude, get_spot_parameter,
                            objective_function, fit_gaussian,
                            simulate_fitted_gaussian, gaussian_3d)
 
-_detection = ["detection", "compute_snr", "get_sigma", "detection_log_lm",
-              "detection_log_lm", "log_lm", "non_maximum_suppression_mask",
-              "from_threshold_to_spots", "from_threshold_to_snr"]
+_detection = ["log_lm", "local_maximum_detection", "spots_thresholding",
+              "compute_snr", "from_threshold_to_snr", "get_sigma",
+              "build_reference_spot"]
 
 _fit = ["get_spot_volume", "get_spot_surface", "build_grid",
         "compute_background_amplitude", "get_spot_parameter",
diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index cbbc7240..5c69c190 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -327,3 +327,113 @@ def get_sigma(resolution_z=300, resolution_yx=103, psf_z=400, psf_yx=200):
     sigma_yx = psf_yx / resolution_yx
 
     return sigma_z, sigma_yx
+
+
+def build_reference_spot(image, spots, radius, method="median"):
+    """Build a
+
+    Parameters
+    ----------
+    image : np.ndarray,
+        Image with shape (z, y, x) or (y, x).
+    spots : np.ndarray, np.int64
+        Coordinate of the spots with shape (nb_spots, 3) or (nb_spots, 2)
+        for 3-d or 2-d images respectively.
+    radius : Tuple[float]
+        Radius of the detected peaks, one for each dimension.
+    method : str
+        Method use to compute the reference spot (a 'mean' or 'median' spot).
+
+    Returns
+    -------
+    reference_spot : np.ndarray
+        Reference spot with shape (2*radius_z+1, 2*radius_y+1, 2*radius_x+1) or
+        (2*radius_y+1, 2*radius_x+1).
+
+    """
+    # check parameters
+    stack.check_array(image,
+                      ndim=[2, 3],
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_array(spots,
+                      ndim=2,
+                      dtype=[np.int64],
+                      allow_nan=False)
+    stack.check_parameter(radius=(float, int, tuple),
+                          method=str)
+    if method not in ['mean', 'median']:
+        raise ValueError("'{0}' is not a valid value for parameter 'method'. "
+                         "Use 'mean' or 'median' instead.".format(method))
+
+    # process a 3-d image
+    if image.ndim == 3:
+        # get a rounded radius for each dimension
+        radius_z = int(radius[0]) + 1
+        radius_yx = int(radius[1]) + 1
+        z_shape = radius_z * 2 + 1
+        yx_shape = radius_yx * 2 + 1
+
+        # collect area around each spot
+        volume_spot = []
+        for i_spot in range(spots.shape[0]):
+
+            # get spot coordinates
+            spot_z, spot_y, spot_x = spots[i_spot, :]
+
+            # get boundaries of the volume surrounding the spot
+            z_spot_min = max(0, int(spot_z - radius_z))
+            z_spot_max = min(image.shape[0], int(spot_z + radius_z))
+            y_spot_min = max(0, int(spot_y - radius_yx))
+            y_spot_max = min(image.shape[1], int(spot_y + radius_yx))
+            x_spot_min = max(0, int(spot_x - radius_yx))
+            x_spot_max = min(image.shape[2], int(spot_x + radius_yx))
+
+            # get the volume of the spot
+            image_spot = image[z_spot_min:z_spot_max + 1,
+                               y_spot_min:y_spot_max + 1,
+                               x_spot_min:x_spot_max + 1]
+
+            # remove the cropped images
+            if image_spot.shape != (z_shape, yx_shape, yx_shape):
+                continue
+
+            volume_spot.append(image_spot)
+
+    # process a 2-d image
+    else:
+        # get a rounded radius for each dimension
+        radius_yx = int(radius[1]) + 1
+        yx_shape = radius_yx * 2 + 1
+
+        # collect area around each spot
+        volume_spot = []
+        for i_spot in range(spots.shape[0]):
+
+            # get spot coordinates
+            spot_y, spot_x = spots[i_spot, :]
+
+            # get boundaries of the volume surrounding the spot
+            y_spot_min = max(0, int(spot_y - radius_yx))
+            y_spot_max = min(image.shape[1], int(spot_y + radius_yx))
+            x_spot_min = max(0, int(spot_x - radius_yx))
+            x_spot_max = min(image.shape[2], int(spot_x + radius_yx))
+
+            # get the volume of the spot
+            image_spot = image[y_spot_min:y_spot_max + 1,
+                               x_spot_min:x_spot_max + 1]
+
+            # remove the cropped images
+            if image_spot.shape != (yx_shape, yx_shape):
+                continue
+
+            volume_spot.append(image_spot)
+
+    # project the different spot images
+    volume_spot = np.stack(volume_spot, axis=0)
+    if method == "mean":
+        reference_spot = np.mean(volume_spot, axis=0)
+    else:
+        reference_spot = np.median(volume_spot, axis=0)
+
+    return reference_spot

From 5dc1f3856fdd6b9b2586a31b446e9c60961a6d34 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 12:32:07 +0200
Subject: [PATCH 172/264] build reference spot from detected spots #2

---
 bigfish/detection/spot_detection.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index 5c69c190..ea4bf651 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -429,6 +429,10 @@ def build_reference_spot(image, spots, radius, method="median"):
 
             volume_spot.append(image_spot)
 
+    # if no spot where detected
+    if len(volume_spot) == 0:
+        return None
+
     # project the different spot images
     volume_spot = np.stack(volume_spot, axis=0)
     if method == "mean":

From 963428e0fb9afbfbabcc7c9b8f814c5c49a1f12d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:05:30 +0200
Subject: [PATCH 173/264] add functions to fit gaussians

---
 bigfish/detection/__init__.py       |  21 +-
 bigfish/detection/gaussian_fit.py   | 672 +++++++++++++++++++---------
 bigfish/detection/spot_detection.py | 114 -----
 3 files changed, 468 insertions(+), 339 deletions(-)

diff --git a/bigfish/detection/__init__.py b/bigfish/detection/__init__.py
index e9a1a0a2..f6859e11 100644
--- a/bigfish/detection/__init__.py
+++ b/bigfish/detection/__init__.py
@@ -7,20 +7,17 @@
 
 from .spot_detection import (log_lm, local_maximum_detection,
                              spots_thresholding, compute_snr,
-                             from_threshold_to_snr, get_sigma,
-                             build_reference_spot)
-from .gaussian_fit import (get_spot_volume, get_spot_surface, build_grid,
-                           compute_background_amplitude, get_spot_parameter,
-                           objective_function, fit_gaussian,
-                           simulate_fitted_gaussian, gaussian_3d)
+                             from_threshold_to_snr, get_sigma)
+from .gaussian_fit import (gaussian_3d, precompute_erf, build_reference_spot,
+                           get_spot_volume, get_spot_surface,
+                           initialize_spot_parameter_3d, objective_function,
+                           fit_gaussian_3d, simulate_fitted_gaussian_3d)
 
 _detection = ["log_lm", "local_maximum_detection", "spots_thresholding",
-              "compute_snr", "from_threshold_to_snr", "get_sigma",
-              "build_reference_spot"]
+              "compute_snr", "from_threshold_to_snr", "get_sigma"]
 
-_fit = ["get_spot_volume", "get_spot_surface", "build_grid",
-        "compute_background_amplitude", "get_spot_parameter",
-        "objective_function", "fit_gaussian",
-        "simulate_fitted_gaussian", "gaussian_3d"]
+_fit = ["gaussian_3d", "precompute_erf", "build_reference_spot",
+        "get_spot_volume", "get_spot_surface", "initialize_spot_parameter_3d",
+        "objective_function", "fit_gaussian_3d", "simulate_fitted_gaussian_3d"]
 
 __all__ = _detection + _fit
diff --git a/bigfish/detection/gaussian_fit.py b/bigfish/detection/gaussian_fit.py
index 9d30a833..12cf6731 100644
--- a/bigfish/detection/gaussian_fit.py
+++ b/bigfish/detection/gaussian_fit.py
@@ -4,7 +4,8 @@
 Functions to fit gaussian functions to the detected RNA spots.
 """
 
-from .detection import get_sigma
+import bigfish.stack as stack
+from .spot_detection import get_sigma
 
 import numpy as np
 
@@ -17,37 +18,9 @@
 
 # ### Gaussian function ###
 
-def _rescaled_erf(low, high, mu, sigma):
-    """Rescaled the Error function along a specific axis.
-
-    # TODO add equations
-
-    Parameters
-    ----------
-    low : np.ndarray, np.float
-        Lower bound of the voxel along a specific axis.
-    high : np.ndarray, np.float
-        Upper bound of the voxel along a specific axis.
-    mu : float
-        Estimated mean of the gaussian signal along a specific axis.
-    sigma : float
-        Estimated standard deviation of the gaussian signal along a specific
-        axis.
-
-    Returns
-    -------
-    new_erf : np.ndarray, np.float
-        Rescaled erf along a specific axis.
-
-    """
-    low_ = (low - mu) / (np.sqrt(2) * sigma)
-    high_ = (high - mu) / (np.sqrt(2) * sigma)
-    new_erf = sigma * np.sqrt(np.pi / 2) * (erf(high_) - erf(low_))
-    return new_erf
-
-
 def gaussian_3d(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, resolution_z,
-                resolution_yx, psf_amplitude, psf_background):
+                resolution_yx, psf_amplitude, psf_background,
+                precomputed=None):
     """Compute the gaussian function over the grid 'xdata' representing a
     volume V with shape (V_z, V_y, V_x).
 
@@ -55,7 +28,7 @@ def gaussian_3d(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, resolution_z,
 
     Parameters
     ----------
-    grid : np.ndarray, np.float
+    grid : np.ndarray, np.float32
         Grid data to compute the gaussian function for different voxel within
         a volume V. In nanometer, with shape (3, V_z * V_y * V_x).
     mu_z : float
@@ -78,6 +51,8 @@ def gaussian_3d(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, resolution_z,
         Estimated pixel intensity of a spot.
     psf_background : float
         Estimated pixel intensity of the background.
+    precomputed : List[np.ndarray] or Tuple[np.ndarray]
+        Precomputed tables values of erf for the different axis.
 
     Returns
     -------
@@ -86,49 +61,286 @@ def gaussian_3d(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, resolution_z,
         parameters. Shape (V_z * V_y * V_x,).
 
     """
+    # check parameters
+    stack.check_array(grid,
+                      ndim=2,
+                      dtype=np.float32,
+                      allow_nan=False)
+    stack.check_parameter(mu_z=(float, int),
+                          mu_y=(float, int),
+                          mu_x=(float, int),
+                          sigma_z=(float, int),
+                          sigma_yx=(float, int),
+                          resolution_z=(float, int),
+                          resolution_yx=(float, int),
+                          psf_amplitude=(float, int),
+                          psf_background=(float, int),
+                          precomputed=(type(None), tuple, list))
+
     # get grid data to design a volume V
     meshgrid_z = grid[0]
     meshgrid_y = grid[1]
     meshgrid_x = grid[2]
 
-    # get voxel coordinates
-    meshgrid_z_minus = meshgrid_z - resolution_z / 2
-    meshgrid_z_plus = meshgrid_z + resolution_z / 2
-    meshgrid_y_minus = meshgrid_y - resolution_yx / 2
-    meshgrid_y_plus = meshgrid_y + resolution_yx / 2
-    meshgrid_x_minus = meshgrid_x - resolution_yx / 2
-    meshgrid_x_plus = meshgrid_x + resolution_yx / 2
+    # use precomputed tables
+    if precomputed is not None:
+        # get tables
+        table_erf_z = precomputed[0]
+        table_erf_y = precomputed[1]
+        table_erf_x = precomputed[2]
+
+        # get indices for the tables
+        i_z = np.around(np.abs(meshgrid_z - mu_z) / 5).astype(np.int64)
+        i_y = np.around(np.abs(meshgrid_y - mu_y) / 5).astype(np.int64)
+        i_x = np.around(np.abs(meshgrid_x - mu_x) / 5).astype(np.int64)
 
-    # compute gaussian function for each voxel (i, j, k) volume V
+        # get precomputed values
+        voxel_integral_z = table_erf_z[i_z]
+        voxel_integral_y = table_erf_y[i_y]
+        voxel_integral_x = table_erf_x[i_x]
+
+    # compute erf value
+    else:
+        # get voxel coordinates
+        meshgrid_z_minus = meshgrid_z - resolution_z / 2
+        meshgrid_z_plus = meshgrid_z + resolution_z / 2
+        meshgrid_y_minus = meshgrid_y - resolution_yx / 2
+        meshgrid_y_plus = meshgrid_y + resolution_yx / 2
+        meshgrid_x_minus = meshgrid_x - resolution_yx / 2
+        meshgrid_x_plus = meshgrid_x + resolution_yx / 2
+
+        # compute gaussian function for each voxel (i, j, k) of volume V
+        voxel_integral_z = _rescaled_erf(low=meshgrid_z_minus,
+                                         high=meshgrid_z_plus,
+                                         mu=mu_z,
+                                         sigma=sigma_z)
+        voxel_integral_y = _rescaled_erf(low=meshgrid_y_minus,
+                                         high=meshgrid_y_plus,
+                                         mu=mu_y,
+                                         sigma=sigma_yx)
+        voxel_integral_x = _rescaled_erf(low=meshgrid_x_minus,
+                                         high=meshgrid_x_plus,
+                                         mu=mu_x,
+                                         sigma=sigma_yx)
+
+    # compute 3-d gaussian values
     factor = psf_amplitude / (resolution_yx ** 2 * resolution_z)
-    voxel_integral_z = _rescaled_erf(low=meshgrid_z_minus,
-                                     high=meshgrid_z_plus,
-                                     mu=mu_z,
-                                     sigma=sigma_z)
-    voxel_integral_y = _rescaled_erf(low=meshgrid_y_minus,
-                                     high=meshgrid_y_plus,
-                                     mu=mu_y,
-                                     sigma=sigma_yx)
-    voxel_integral_x = _rescaled_erf(low=meshgrid_x_minus,
-                                     high=meshgrid_x_plus,
-                                     mu=mu_x,
-                                     sigma=sigma_yx)
     voxel_integral = voxel_integral_z * voxel_integral_y * voxel_integral_x
     values = psf_background + factor * voxel_integral
 
     return values
 
 
+def _rescaled_erf(low, high, mu, sigma):
+    """Rescaled the Error function along a specific axis.
+
+    # TODO add equations
+
+    Parameters
+    ----------
+    low : np.ndarray, np.float
+        Lower bound of the voxel along a specific axis.
+    high : np.ndarray, np.float
+        Upper bound of the voxel along a specific axis.
+    mu : float
+        Estimated mean of the gaussian signal along a specific axis.
+    sigma : float
+        Estimated standard deviation of the gaussian signal along a specific
+        axis.
+
+    Returns
+    -------
+    rescaled_erf : np.ndarray, np.float
+        Rescaled erf along a specific axis.
+
+    """
+    # check parameters
+    stack.check_parameter(low=np.ndarray,
+                          high=np.ndarray,
+                          mu=(float, int),
+                          sigma=(float, int))
+
+    # compute erf and normalize it
+    low_ = (low - mu) / (np.sqrt(2) * sigma)
+    high_ = (high - mu) / (np.sqrt(2) * sigma)
+    rescaled_erf = sigma * np.sqrt(np.pi / 2) * (erf(high_) - erf(low_))
+
+    return rescaled_erf
+
+
+def precompute_erf(resolution_z, resolution_yx, sigma_z, sigma_yx,
+                   max_grid=200):
+    """Precompute different values for the erf with a resolution of 5 nm.
+
+    Parameters
+    ----------
+    resolution_z : float, int
+        Height of a voxel, in nanometer.
+    resolution_yx : float, int
+        size of a voxel, in nanometer.
+    sigma_z : float, int
+        Estimated standard deviation of the gaussian signal along z axis, in
+        nanometer.
+    sigma_yx : float, int
+        Estimated standard deviation of the gaussian signal along y and x axis,
+        in nanometer.
+    max_grid : int
+        Maximum size of the grid on which we precompute the erf, in pixel.
+
+    Returns
+    -------
+    table_erf_z : np.ndarray, np.float64
+        Table of precomputed values for the erf along the z axis with shape
+        (nb_value, 2).
+    table_erf_y : np.ndarray, np.float64
+        Table of precomputed values for the erf along the y axis with shape
+        (nb_value, 2).
+    table_erf_x : np.ndarray, np.float64
+        Table of precomputed values for the erf along the x axis with shape
+        (nb_value, 2).
+
+    """
+    # check parameters
+    stack.check_parameter(resolution_z=(float, int),
+                          resolution_yx=(float, int),
+                          sigma_z=(float, int),
+                          sigma_yx=(float, int),
+                          max_grid=int)
+
+    # build a grid with a spatial resolution of 5 nm and a size of
+    # max_grid * resolution nm
+    zz = np.array([i for i in range(0, max_grid * resolution_z, 5)])
+    yy = np.array([i for i in range(0, max_grid * resolution_yx, 5)])
+    xx = np.array([i for i in range(0, max_grid * resolution_yx, 5)])
+    mu_z, mu_y, mu_x = 0, 0, 0
+
+    # compute erf values for this grid
+    erf_z = _rescaled_erf(low=zz - resolution_z/2,
+                          high=zz + resolution_z/2,
+                          mu=mu_z,
+                          sigma=sigma_z)
+    erf_y = _rescaled_erf(low=yy - resolution_yx/2,
+                          high=yy + resolution_yx/2,
+                          mu=mu_y,
+                          sigma=sigma_yx)
+    erf_x = _rescaled_erf(low=xx - resolution_yx/2,
+                          high=xx + resolution_yx/2,
+                          mu=mu_x,
+                          sigma=sigma_yx)
+    table_erf_z = np.array([zz, erf_z]).T
+    table_erf_y = np.array([yy, erf_y]).T
+    table_erf_x = np.array([xx, erf_x]).T
+
+    return table_erf_z, table_erf_y, table_erf_x
+
+
 # ### Spot parameter ###
 
-def get_spot_volume(image, spot_z, spot_y, spot_x, radius_z, radius_yx,
-                    return_center=False):
+def build_reference_spot(image, spots, radius, method="median"):
+    """Build a
+
+    Parameters
+    ----------
+    image : np.ndarray,
+        Image with shape (z, y, x) or (y, x).
+    spots : np.ndarray, np.int64
+        Coordinate of the spots with shape (nb_spots, 3) or (nb_spots, 2)
+        for 3-d or 2-d images respectively.
+    radius : Tuple[float]
+        Radius of the detected peaks, one for each dimension.
+    method : str
+        Method use to compute the reference spot (a 'mean' or 'median' spot).
+
+    Returns
+    -------
+    reference_spot : np.ndarray
+        Reference spot with shape (2*radius_z+1, 2*radius_y+1, 2*radius_x+1) or
+        (2*radius_y+1, 2*radius_x+1).
+
+    """
+    # check parameters
+    stack.check_array(image,
+                      ndim=[2, 3],
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_array(spots,
+                      ndim=2,
+                      dtype=[np.int64],
+                      allow_nan=False)
+    stack.check_parameter(radius=(float, int, tuple),
+                          method=str)
+    if method not in ['mean', 'median']:
+        raise ValueError("'{0}' is not a valid value for parameter 'method'. "
+                         "Use 'mean' or 'median' instead.".format(method))
+
+    # process a 3-d image
+    if image.ndim == 3:
+        # get a rounded radius for each dimension
+        radius_z = int(radius[0]) + 1
+        radius_yx = int(radius[1]) + 1
+        z_shape = radius_z * 2 + 1
+        yx_shape = radius_yx * 2 + 1
+
+        # collect area around each spot
+        l_reference_spot = []
+        for i_spot in range(spots.shape[0]):
+
+            # get spot coordinates
+            spot_z, spot_y, spot_x = spots[i_spot, :]
+
+            # get the volume of the spot
+            image_spot = get_spot_volume(image, spot_z, spot_y, spot_x,
+                                         radius_z, radius_yx)
+
+            # remove the cropped images
+            if image_spot.shape != (z_shape, yx_shape, yx_shape):
+                continue
+
+            l_reference_spot.append(image_spot)
+
+    # process a 2-d image
+    else:
+        # get a rounded radius for each dimension
+        radius_yx = int(radius[1]) + 1
+        yx_shape = radius_yx * 2 + 1
+
+        # collect area around each spot
+        l_reference_spot = []
+        for i_spot in range(spots.shape[0]):
+
+            # get spot coordinates
+            spot_y, spot_x = spots[i_spot, :]
+
+            # get the surface of the spot
+            image_spot = get_spot_surface(image, spot_y, spot_x, radius_yx)
+
+            # remove the cropped images
+            if image_spot.shape != (yx_shape, yx_shape):
+                continue
+
+            l_reference_spot.append(image_spot)
+
+    # if no spot where detected
+    if len(l_reference_spot) == 0:
+        return None
+
+    # project the different spot images
+    l_reference_spot = np.stack(l_reference_spot, axis=0)
+    if method == "mean":
+        reference_spot = np.mean(l_reference_spot, axis=0)
+    else:
+        reference_spot = np.median(l_reference_spot, axis=0)
+
+    return reference_spot
+
+
+def get_spot_volume(image, spot_z, spot_y, spot_x, radius_z, radius_yx):
     """Get a subimage of a detected spot in 3-d.
 
     Parameters
     ----------
     image : np.ndarray, np.uint
-        A 3-d image with detected spot and shape (z, y, x).
+        A 3-d image with detected spot and shape (z, y, x)).
     spot_z : np.int64
         Coordinate of the detected spot along the z axis.
     spot_y : np.int64
@@ -139,50 +351,86 @@ def get_spot_volume(image, spot_z, spot_y, spot_x, radius_z, radius_yx,
         Estimated radius of the spot along the z-dimension.
     radius_yx : float
         Estimated radius of the spot on the yx-plan.
-    return_center : bool
-        Return center of the detected spot in the new volume.
 
     Returns
     -------
-    image_spot : np.ndarray, np.uint
-        A 3-d image with detected spot and shape (radius_z * 2, radius_yx * 2,
-        radius_yx * 2).
-    center_z : float
-        Estimated centroid of the spot, in nanometer, along the z axis.
-    center_y : float
-        Estimated centroid of the spot, in nanometer, along the y axis.
-    center_x : float
-        Estimated centroid of the spot, in nanometer, along the x axis.
+    image_spot : np.ndarray
+        Reference spot with shape (2*radius_z+1, 2*radius_y+1, 2*radius_x+1).
 
     """
+    # check parameters
+    stack.check_array(image,
+                      ndim=3,
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_parameter(spot_z=np.int64,
+                          spot_y=np.int64,
+                          spot_x=np.int64,
+                          radius_z=np.int64,
+                          radius_yx=np.int64)
+
     # get boundaries of the volume surrounding the spot
-    z_spot_min = max(0, int(spot_z - 2 * radius_z))
-    z_spot_max = min(image.shape[0], int(spot_z + 2 * radius_z) + 1)
-    y_spot_min = max(0, int(spot_y - 2 * radius_yx))
-    y_spot_max = min(image.shape[1], int(spot_y + 2 * radius_yx) + 1)
-    x_spot_min = max(0, int(spot_x - 2 * radius_yx))
-    x_spot_max = min(image.shape[2], int(spot_x + 2 * radius_yx) + 1)
+    z_spot_min = max(0, int(spot_z - radius_z))
+    z_spot_max = min(image.shape[0], int(spot_z + radius_z))
+    y_spot_min = max(0, int(spot_y - radius_yx))
+    y_spot_max = min(image.shape[1], int(spot_y + radius_yx))
+    x_spot_min = max(0, int(spot_x - radius_yx))
+    x_spot_max = min(image.shape[2], int(spot_x + radius_yx))
 
     # get the volume of the spot
     image_spot = image[z_spot_min:z_spot_max + 1,
                        y_spot_min:y_spot_max + 1,
                        x_spot_min:x_spot_max + 1]
 
-    # get center of the detected spot in the new volume
-    if return_center:
-        center_z = spot_z - z_spot_min
-        center_y = spot_y - y_spot_min
-        center_x = spot_x - x_spot_min
+    return image_spot
 
-        return image_spot, center_z, center_y, center_x
 
-    else:
+def get_spot_surface(image, spot_y, spot_x, radius_yx):
+    """Get a subimage of a detected spot from its supposed yx plan.
 
-        return image_spot
+    Parameters
+    ----------
+    image : np.ndarray
+        A 2-d image with detected spot and shape (y, x).
+    spot_y : np.int64
+        Coordinate of the detected spot along the y axis.
+    spot_x : np.int64
+        Coordinate of the detected spot along the x axis.
+    radius_yx : float
+        Estimated radius of the spot on the yx-plan.
 
+    Returns
+    -------
+    image_spot : np.ndarray
+        Reference spot with shape (2*radius_y+1, 2*radius_x+1).
 
-def get_spot_surface(image, z_spot, spot_y, spot_x, radius_yx):
-    """Get a subimage of a detected spot from its supposed yx plan.
+    """
+    # check parameters
+    stack.check_array(image,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_parameter(spot_y=np.int64,
+                          spot_x=np.int64,
+                          radius_yx=np.int64)
+
+    # get boundaries of the volume surrounding the spot
+    y_spot_min = max(0, int(spot_y - radius_yx))
+    y_spot_max = min(image.shape[1], int(spot_y + radius_yx))
+    x_spot_min = max(0, int(spot_x - radius_yx))
+    x_spot_max = min(image.shape[2], int(spot_x + radius_yx))
+
+    # get the volume of the spot
+    image_spot = image[y_spot_min:y_spot_max + 1,
+                       x_spot_min:x_spot_max + 1]
+
+    return image_spot
+
+
+def initialize_spot_parameter_3d(image, spot_z, spot_y, spot_x, psf_z=400,
+                                 psf_yx=200, resolution_z=300,
+                                 resolution_yx=103):
+    """Initialize parameters to fit a 3-d gaussian function on a spot.
 
     Parameters
     ----------
@@ -194,41 +442,89 @@ def get_spot_surface(image, z_spot, spot_y, spot_x, radius_yx):
         Coordinate of the detected spot along the y axis.
     spot_x : np.int64
         Coordinate of the detected spot along the x axis.
-    radius_yx : float
-        Estimated radius of the spot on the yx-plan.
+    psf_z : int or float
+        Theoretical height of the spot PSF along the z axis, in nanometer.
+    psf_yx : int or float
+        Theoretical diameter of the spot PSF on the yx plan, in nanometer.
+    resolution_z : int or float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : int or float
+        Size of a voxel on the yx plan, in nanometer.
 
     Returns
     -------
-    image_spot_2d : np.ndarray, np.uint
-        A 2-d image with detected spot and shape (radius_yx * 2,
-        radius_yx * 2).
+    image_spot : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    grid : np.ndarray, np.float32
+        A grid with the shape (3, z * y * x), in nanometer.
+    center_z : float
+        Estimated centroid of the spot, in nanometer, along the z axis.
+    center_y : float
+        Estimated centroid of the spot, in nanometer, along the y axis.
+    center_x : float
+        Estimated centroid of the spot, in nanometer, along the x axis.
+    psf_amplitude : float
+        Amplitude of the spot.
+    psf_background : float
+        Background minimum value of the voxel.
 
     """
-    # get boundaries of the volume surrounding the spot
-    y_spot_min = max(0, int(spot_y - 2 * radius_yx))
-    y_spot_max = min(image.shape[1], int(spot_y + 2 * radius_yx) + 1)
-    x_spot_min = max(0, int(spot_x - 2 * radius_yx))
-    x_spot_max = min(image.shape[2], int(spot_x + 2 * radius_yx) + 1)
+    # check parameters
+    stack.check_array(image,
+                      ndim=3,
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_parameter(spot_z=np.int64,
+                          spot_y=np.int64,
+                          spot_x=np.int64,
+                          psf_z=(float, int),
+                          psf_yx=(float, int),
+                          resolution_z=(float, int),
+                          resolution_yx=(float, int))
 
-    # get the detected yx plan for the spot
-    image_spot_2d = image[z_spot,
-                          y_spot_min:y_spot_max + 1,
-                          x_spot_min:x_spot_max + 1]
+    # compute estimated radius of the spot
+    sigma_z, sigma_yx = get_sigma(resolution_z=resolution_z,
+                                  resolution_yx=resolution_yx,
+                                  psf_z=psf_z,
+                                  psf_yx=psf_yx)
+    radius_z = np.sqrt(3) * sigma_z
+    radius_yx = np.sqrt(3) * sigma_yx
 
-    return image_spot_2d
+    # get subimage of the spot
+    image_spot = get_spot_volume(
+        image=image,
+        spot_z=spot_z,
+        spot_y=spot_y,
+        spot_x=spot_x,
+        radius_z=radius_z,
+        radius_yx=radius_yx)
+
+    # build a grid to fit the gaussian values
+    grid, center_z, center_y, center_x = _initialize_grid_3d(
+        image_spot=image_spot,
+        resolution_z=resolution_z,
+        resolution_yx=resolution_yx,
+        return_centroid=True)
 
+    # compute amplitude and background values
+    psf_amplitude, psf_background = _compute_background_amplitude(image_spot)
 
-def build_grid(image_spot, resolution_z, resolution_yx, return_centroid=False):
+    return (image_spot, grid, center_z, center_y, center_x, psf_amplitude,
+            psf_background)
+
+
+def _initialize_grid_3d(image_spot, resolution_z, resolution_yx,
+                        return_centroid=False):
     """Build a grid in nanometer to compute gaussian function over a full
     volume.
 
     Parameters
     ----------
-    image_spot : np.ndarray, np.uint
+    image_spot : np.ndarray
         A 3-d image with detected spot and shape (z, y, x).
-    resolution_z : float
+    resolution_z : float or int
         Height of a voxel, along the z axis, in nanometer.
-    resolution_yx : float
+    resolution_yx : float or int
         Size of a voxel on the yx plan, in nanometer.
     return_centroid : bool
         Compute centroid estimation of the grid.
@@ -244,6 +540,15 @@ def build_grid(image_spot, resolution_z, resolution_yx, return_centroid=False):
         Estimated centroid of the spot, in nanometer, along the x axis.
 
     """
+    # check parameters
+    stack.check_array(image_spot,
+                      ndim=3,
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_parameter(resolution_z=(float, int),
+                          resolution_yx=(float, int),
+                          return_centroid=bool)
+
     # get targeted size
     nb_z, nb_y, nb_x = image_spot.shape
     nb_pixels = image_spot.size
@@ -270,15 +575,13 @@ def build_grid(image_spot, resolution_z, resolution_yx, return_centroid=False):
         centroid_z = np.sum(dz) / area
         centroid_y = np.sum(dy) / area
         centroid_x = np.sum(dx) / area
-
         return grid, centroid_z, centroid_y, centroid_x
 
     else:
-
         return grid
 
 
-def compute_background_amplitude(image_spot):
+def _compute_background_amplitude(image_spot):
     """Compute amplitude of a spot and background minimum value.
 
     Parameters
@@ -288,12 +591,19 @@ def compute_background_amplitude(image_spot):
 
     Returns
     -------
-    psf_amplitude : float
+    psf_amplitude : float or int
         Amplitude of the spot.
-    psf_background : float
+    psf_background : float or int
         Background minimum value of the voxel.
 
     """
+    # check parameters
+    stack.check_array(image_spot,
+                      ndim=[2, 3],
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+
+    # compute values
     image_min, image_max = image_spot.min(), image_spot.max()
     psf_amplitude = image_max - image_min
     psf_background = image_min
@@ -301,108 +611,10 @@ def compute_background_amplitude(image_spot):
     return psf_amplitude, psf_background
 
 
-def get_spot_parameter(image, spot_z, spot_y, spot_x, psf_z=400, psf_yx=200,
-                       resolution_z=300, resolution_yx=103,
-                       compute_centroid=False):
-    """Initialize parameters to fit gaussian function on a spot.
-
-    Parameters
-    ----------
-    image : np.ndarray, np.uint
-        A 3-d image with detected spot and shape (z, y, x).
-    spot_z : np.int64
-        Coordinate of the detected spot along the z axis.
-    spot_y : np.int64
-        Coordinate of the detected spot along the y axis.
-    spot_x : np.int64
-        Coordinate of the detected spot along the x axis.
-    psf_z : int or float
-        Theoretical height of the spot PSF along the z axis, in nanometer.
-    psf_yx : int or float
-        Theoretical diameter of the spot PSF on the yx plan, in nanometer.
-    resolution_z : int or float
-        Height of a voxel, along the z axis, in nanometer.
-    resolution_yx : int or float
-        Size of a voxel on the yx plan, in nanometer.
-    compute_centroid : bool
-        Compute an estimation of the centroid of the spot from pixel intensity
-        or use the center of the subimage.
-
-    Returns
-    -------
-    image_spot : np.ndarray, np.uint
-        A 3-d image with detected spot and shape (z, y, x).
-    grid : np.ndarray, np.float32
-        A grid with the shape (3, z * y * x), in nanometer.
-    center_z : float
-        Estimated centroid of the spot, in nanometer, along the z axis.
-    center_y : float
-        Estimated centroid of the spot, in nanometer, along the y axis.
-    center_x : float
-        Estimated centroid of the spot, in nanometer, along the x axis.
-    psf_amplitude : float
-        Amplitude of the spot.
-    psf_background : float
-        Background minimum value of the voxel.
-
-    """
-    # compute estimated radius of the spot
-    sigma_z, sigma_yx = get_sigma(resolution_z=resolution_z,
-                                  resolution_yx=resolution_yx,
-                                  psf_z=psf_z,
-                                  psf_yx=psf_yx)
-    radius_z = np.sqrt(3) * sigma_z
-    radius_yx = np.sqrt(3) * sigma_yx
-
-    if compute_centroid:
-        # get subimage of the spot
-        image_spot = get_spot_volume(
-            image=image,
-            spot_z=spot_z,
-            spot_y=spot_y,
-            spot_x=spot_x,
-            radius_z=radius_z,
-            radius_yx=radius_yx)
-
-        # build a grid to fit the gaussian values
-        grid, center_z, center_y, center_x = build_grid(
-            image_spot=image_spot,
-            resolution_z=resolution_z,
-            resolution_yx=resolution_yx,
-            return_centroid=True)
-
-    else:
-        # get subimage of the spot
-        image_spot, center_z, center_y, center_x = get_spot_volume(
-            image=image,
-            spot_z=spot_z,
-            spot_y=spot_y,
-            spot_x=spot_x,
-            radius_z=radius_z,
-            radius_yx=radius_yx,
-            return_center=True)
-        center_z = float(center_z * resolution_z)
-        center_y = float(center_y * resolution_yx)
-        center_x = float(center_x * resolution_yx)
-
-        # build a grid to fit the gaussian values
-        grid = build_grid(
-            image_spot=image_spot,
-            resolution_z=resolution_z,
-            resolution_yx=resolution_yx,
-            return_centroid=False)
-
-    # compute amplitude and background values
-    psf_amplitude, psf_background = compute_background_amplitude(image_spot)
-
-    return (image_spot, grid, center_z, center_y, center_x, psf_amplitude,
-            psf_background)
-
-
 # ### Gaussian fitting ###
 
 def objective_function(resolution_z=300, resolution_yx=103, sigma_z=400,
-                       sigma_yx=200,  psf_amplitude=None):
+                       sigma_yx=200, psf_amplitude=None):
     """Design the objective function used to fit the gaussian function.
 
     Parameters
@@ -411,11 +623,11 @@ def objective_function(resolution_z=300, resolution_yx=103, sigma_z=400,
         Height of a voxel, along the z axis, in nanometer.
     resolution_yx : int or float
         Size of a voxel on the yx plan, in nanometer.
-    sigma_z : float
+    sigma_z : int or float
         Theoretical height of the spot PSF along the z axis, in nanometer.
-    sigma_yx : float
+    sigma_yx : int or float
         Theoretical diameter of the spot PSF on the yx plan, in nanometer.
-    psf_amplitude : float
+    psf_amplitude : int or float
         Amplitude of the spot.
 
     Returns
@@ -424,7 +636,15 @@ def objective_function(resolution_z=300, resolution_yx=103, sigma_z=400,
         A 3-d gaussian function with some parameters fixed.
 
     """
-    # sigma is a fixed and known parameter
+    # TODO add precomputation
+    # check parameters
+    stack.check_parameter(resolution_z=(float, int),
+                          resolution_yx=(float, int),
+                          sigma_z=(float, int),
+                          sigma_yx=(float, int),
+                          psf_amplitude=(float, int))
+
+    # sigma is known, we fit mu, amplitude and background
     if (sigma_z is not None
             and sigma_yx is not None
             and psf_amplitude is None):
@@ -441,7 +661,7 @@ def f(grid, mu_z, mu_y, mu_x, psf_amplitude, psf_background):
                                  psf_background=psf_background)
             return values
 
-    # amplitude is a fixed and known parameter
+    # amplitude is known, we fit sigma, mu and background
     elif (psf_amplitude is not None
           and sigma_z is None
           and sigma_yx is None):
@@ -458,7 +678,7 @@ def f(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, psf_background):
                                  psf_background=psf_background)
             return values
 
-    # amplitude and sigma are fixed and known parameters
+    # amplitude and sigma are known, we fit mu and background
     elif (psf_amplitude is not None
           and sigma_z is not None
           and sigma_yx is not None):
@@ -475,6 +695,7 @@ def f(grid, mu_z, mu_y, mu_x, psf_background):
                                  psf_background=psf_background)
             return values
 
+    # we fit mu, sigma, amplitude and background
     elif (psf_amplitude is None
           and sigma_z is None
           and sigma_yx is None):
@@ -499,7 +720,8 @@ def f(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, psf_amplitude,
     return f
 
 
-def fit_gaussian(f, grid, image_spot, p0, lower_bound=None, upper_bound=None):
+def fit_gaussian_3d(f, grid, image_spot, p0, lower_bound=None,
+                    upper_bound=None):
     """Fit a gaussian function to a 3-d image.
 
     # TODO add equations and algorithm
@@ -528,6 +750,19 @@ def fit_gaussian(f, grid, image_spot, p0, lower_bound=None, upper_bound=None):
         Estimated covariance of 'popt'.
 
     """
+    # check parameters
+    stack.check_array(grid,
+                      ndim=3,
+                      dtype=np.float32,
+                      allow_nan=False)
+    stack.check_array(image_spot,
+                      ndim=3,
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_parameter(p0=list,
+                          lower_bound=(list, type(None)),
+                          upper_bound=(list, type(None)))
+
     # compute lower bound and upper bound
     if lower_bound is None:
         lower_bound = [-np.inf for _ in p0]
@@ -542,7 +777,7 @@ def fit_gaussian(f, grid, image_spot, p0, lower_bound=None, upper_bound=None):
     return popt, pcov
 
 
-def simulate_fitted_gaussian(f, grid, popt, original_shape=None):
+def simulate_fitted_gaussian_3d(f, grid, popt, original_shape=None):
     """Use the optimized parameter to simulate a gaussian signal.
 
     Parameters
@@ -564,7 +799,18 @@ def simulate_fitted_gaussian(f, grid, popt, original_shape=None):
         parameters. Shape (V_z, V_y, V_x,) or (V_z * V_y * V_x,).
 
     """
+    # check parameters
+    stack.check_array(grid,
+                      ndim=3,
+                      dtype=np.float32,
+                      allow_nan=False)
+    stack.check_parameter(popt=list,
+                          original_shape=(tuple, type(None)))
+
+    # compute gaussian values
     values = f(grid, *popt)
+
+    # reshape values if necessary
     if original_shape is not None:
         values = np.reshape(values, original_shape).astype(np.float32)
 
diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index ea4bf651..cbbc7240 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -327,117 +327,3 @@ def get_sigma(resolution_z=300, resolution_yx=103, psf_z=400, psf_yx=200):
     sigma_yx = psf_yx / resolution_yx
 
     return sigma_z, sigma_yx
-
-
-def build_reference_spot(image, spots, radius, method="median"):
-    """Build a
-
-    Parameters
-    ----------
-    image : np.ndarray,
-        Image with shape (z, y, x) or (y, x).
-    spots : np.ndarray, np.int64
-        Coordinate of the spots with shape (nb_spots, 3) or (nb_spots, 2)
-        for 3-d or 2-d images respectively.
-    radius : Tuple[float]
-        Radius of the detected peaks, one for each dimension.
-    method : str
-        Method use to compute the reference spot (a 'mean' or 'median' spot).
-
-    Returns
-    -------
-    reference_spot : np.ndarray
-        Reference spot with shape (2*radius_z+1, 2*radius_y+1, 2*radius_x+1) or
-        (2*radius_y+1, 2*radius_x+1).
-
-    """
-    # check parameters
-    stack.check_array(image,
-                      ndim=[2, 3],
-                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
-    stack.check_array(spots,
-                      ndim=2,
-                      dtype=[np.int64],
-                      allow_nan=False)
-    stack.check_parameter(radius=(float, int, tuple),
-                          method=str)
-    if method not in ['mean', 'median']:
-        raise ValueError("'{0}' is not a valid value for parameter 'method'. "
-                         "Use 'mean' or 'median' instead.".format(method))
-
-    # process a 3-d image
-    if image.ndim == 3:
-        # get a rounded radius for each dimension
-        radius_z = int(radius[0]) + 1
-        radius_yx = int(radius[1]) + 1
-        z_shape = radius_z * 2 + 1
-        yx_shape = radius_yx * 2 + 1
-
-        # collect area around each spot
-        volume_spot = []
-        for i_spot in range(spots.shape[0]):
-
-            # get spot coordinates
-            spot_z, spot_y, spot_x = spots[i_spot, :]
-
-            # get boundaries of the volume surrounding the spot
-            z_spot_min = max(0, int(spot_z - radius_z))
-            z_spot_max = min(image.shape[0], int(spot_z + radius_z))
-            y_spot_min = max(0, int(spot_y - radius_yx))
-            y_spot_max = min(image.shape[1], int(spot_y + radius_yx))
-            x_spot_min = max(0, int(spot_x - radius_yx))
-            x_spot_max = min(image.shape[2], int(spot_x + radius_yx))
-
-            # get the volume of the spot
-            image_spot = image[z_spot_min:z_spot_max + 1,
-                               y_spot_min:y_spot_max + 1,
-                               x_spot_min:x_spot_max + 1]
-
-            # remove the cropped images
-            if image_spot.shape != (z_shape, yx_shape, yx_shape):
-                continue
-
-            volume_spot.append(image_spot)
-
-    # process a 2-d image
-    else:
-        # get a rounded radius for each dimension
-        radius_yx = int(radius[1]) + 1
-        yx_shape = radius_yx * 2 + 1
-
-        # collect area around each spot
-        volume_spot = []
-        for i_spot in range(spots.shape[0]):
-
-            # get spot coordinates
-            spot_y, spot_x = spots[i_spot, :]
-
-            # get boundaries of the volume surrounding the spot
-            y_spot_min = max(0, int(spot_y - radius_yx))
-            y_spot_max = min(image.shape[1], int(spot_y + radius_yx))
-            x_spot_min = max(0, int(spot_x - radius_yx))
-            x_spot_max = min(image.shape[2], int(spot_x + radius_yx))
-
-            # get the volume of the spot
-            image_spot = image[y_spot_min:y_spot_max + 1,
-                               x_spot_min:x_spot_max + 1]
-
-            # remove the cropped images
-            if image_spot.shape != (yx_shape, yx_shape):
-                continue
-
-            volume_spot.append(image_spot)
-
-    # if no spot where detected
-    if len(volume_spot) == 0:
-        return None
-
-    # project the different spot images
-    volume_spot = np.stack(volume_spot, axis=0)
-    if method == "mean":
-        reference_spot = np.mean(volume_spot, axis=0)
-    else:
-        reference_spot = np.median(volume_spot, axis=0)
-
-    return reference_spot

From eb679d0574f3fa725e7a0aeaad7d80cf594137bd Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:06:11 +0200
Subject: [PATCH 174/264] add 'get_offset_value'

---
 bigfish/stack/utils.py | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 29819084..9b43c590 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -540,8 +540,12 @@ def complete_coordinates_2d(list_coord):
     -------
 
     """
+    # TODO improve documentation
+    # TODO remove the list
     # check parameter
-    check_parameter(list_coord=list)
+    check_parameter(list_coord=(list, np.ndarray))
+    if isinstance(list_coord, np.ndarray):
+        list_coord = [list_coord]
 
     # for each array in the list, complete its coordinates using the scikit
     # image method 'polygon_perimeter'
@@ -580,3 +584,16 @@ def from_coord_to_image(coord, image_shape=None):
     image[coord[:, 0], coord[:, 1]] = 1.0
 
     return image
+
+
+def get_offset_value():
+    """Return the margin pixel around a cell coordinate used to define its
+    bounding box.
+
+    Returns
+    -------
+    _ : int
+        Margin value (in pixels).
+
+    """
+    return 5

From ebf8885a4639a75c9c191dd283364e50890781d3 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:06:57 +0200
Subject: [PATCH 175/264] improve 'focus_projection_fast'

---
 bigfish/stack/projection.py | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/bigfish/stack/projection.py b/bigfish/stack/projection.py
index aabbb7f8..ae481691 100644
--- a/bigfish/stack/projection.py
+++ b/bigfish/stack/projection.py
@@ -137,7 +137,8 @@ def focus_projection(tensor):
     return projected_tensor
 
 
-def focus_projection_fast(tensor, proportion=0.75, neighborhood_size=7):
+def focus_projection_fast(tensor, proportion=0.75, neighborhood_size=7,
+                          method="median"):
     """Project the z-dimension of a tensor.
 
     Inspired from Aubin's thesis (part 5.3, strategy 5). Compare to the
@@ -146,7 +147,8 @@ def focus_projection_fast(tensor, proportion=0.75, neighborhood_size=7):
 
     1) Compute a focus value for each voxel zyx with a fixed neighborhood size.
     2) We keep 75% best in-focus z-slices (based on a global focus score).
-    3) Keep the median pixel intensity among the top 5 best focus z-slices.
+    3) Keep the median/maximum pixel intensity among the top 5 best
+    focus z-slices.
 
     Parameters
     ----------
@@ -157,6 +159,8 @@ def focus_projection_fast(tensor, proportion=0.75, neighborhood_size=7):
         z-slices to keep (integer above 1).
     neighborhood_size : int
         The size of the square used to define the neighborhood of each pixel.
+    method : str
+        Projection method applied on the selected pixel values.
 
     Returns
     -------
@@ -202,7 +206,13 @@ def focus_projection_fast(tensor, proportion=0.75, neighborhood_size=7):
     # project tensor
     in_focus_image = in_focus_image.astype(np.float32)
     in_focus_image[in_focus_image == 0] = np.nan
-    projected_tensor = np.nanmedian(in_focus_image, axis=0)
+    if method == "median":
+        projected_tensor = np.nanmedian(in_focus_image, axis=0)
+    elif method == "max":
+        projected_tensor = np.nanmax(in_focus_image, axis=0)
+    else:
+        raise ValueError("Parameter 'method' should be 'median' or 'max', not "
+                         "'{0}'.".format(method))
     projected_tensor = projected_tensor.astype(tensor.dtype)
 
     return projected_tensor

From 651c3a7c2f23a5a407a7d9370395fa7054845d51 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:07:34 +0200
Subject: [PATCH 176/264] use 'get_offset_value'

---
 bigfish/stack/preparation.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 3ef6856b..ae77724b 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -11,6 +11,7 @@
 import pandas as pd
 from scipy import ndimage as ndi
 
+from .utils import get_offset_value
 from .augmentation import augment
 from .preprocess import cast_img_float32
 from .filter import mean_filter
@@ -21,6 +22,7 @@
 
 # TODO define the requirements for 'data'
 # TODO add logging
+# TODO generalize the use of 'get_offset_value'
 
 # ### Split data ###
 
@@ -269,8 +271,8 @@ def build_image(data, id_cell, image_shape=None, coord_refinement=True,
 
     # build matrices
     if image_shape is None:
-        max_x = cyt_coord[:, 0].max() + 5
-        max_y = cyt_coord[:, 1].max() + 5
+        max_x = cyt_coord[:, 0].max() + get_offset_value()
+        max_y = cyt_coord[:, 1].max() + get_offset_value()
         image_shape = (max_x, max_y)
     rna = np.zeros(image_shape, dtype=np.float32)
     rna[rna_coord[:, 0], rna_coord[:, 1]] = 1.0
@@ -347,8 +349,8 @@ def _build_rna(data, id_cell, output_shape=None):
     # get current shape
     cyt_coord = data.loc[id_cell, "pos_cell"]
     cyt_coord = np.array(cyt_coord, dtype=np.int64)
-    max_x = cyt_coord[:, 0].max() + 5
-    max_y = cyt_coord[:, 1].max() + 5
+    max_x = cyt_coord[:, 0].max() + get_offset_value()
+    max_y = cyt_coord[:, 1].max() + get_offset_value()
     input_shape = (max_x, max_y)
 
     if output_shape is not None:

From 6203c8e1fb891a98246dd801ef320a16010a59f8 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:08:07 +0200
Subject: [PATCH 177/264] add one todo

---
 bigfish/stack/preprocess.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index bc3e1dd5..f5712fe3 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -24,6 +24,8 @@
 from scipy import ndimage as ndi
 
 
+# TODO be able to build only one channel
+
 # ### Simulated data ###
 
 def build_simulated_dataset(path_cell, path_rna, path_output=None):

From de32fb6a2194754b1613de7bc9e4f912bc8de2d2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:08:40 +0200
Subject: [PATCH 178/264] add one todo

---
 bigfish/segmentation/nuc_segmentation.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bigfish/segmentation/nuc_segmentation.py b/bigfish/segmentation/nuc_segmentation.py
index 0e861ac9..60a300a7 100644
--- a/bigfish/segmentation/nuc_segmentation.py
+++ b/bigfish/segmentation/nuc_segmentation.py
@@ -102,6 +102,7 @@ def remove_segmented_nuc(image, mask, nuclei_size=2000):
     """
     # TODO fix the dtype of the mask
     # TODO start from the original image to manage the potential rescaling
+    # TODO improve the threshold
     # check parameters
     stack.check_array(image,
                       ndim=2,

From 353e19082e3120a8a6b9bfc1c2e8e45f9ce1806d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:09:19 +0200
Subject: [PATCH 179/264] architecture unet

---
 bigfish/segmentation/unet.py | 362 +++++++++++++++++++++++++++++++++++
 1 file changed, 362 insertions(+)

diff --git a/bigfish/segmentation/unet.py b/bigfish/segmentation/unet.py
index e69de29b..6871ff2f 100644
--- a/bigfish/segmentation/unet.py
+++ b/bigfish/segmentation/unet.py
@@ -0,0 +1,362 @@
+# -*- coding: utf-8 -*-
+
+"""
+Models based on U-net.
+
+Paper: "U-Net: Convolutional Networks for Biomedical Image Segmentation"
+Authors: Ronneberger, Olaf
+         Fischer, Philipp
+         Brox, Thomas
+Year: 2015
+
+Page: Deconvolution and Checkerboard Artifacts
+Authors: Odena, Augustus
+         Dumoulin, Vincent
+         Olah, Chris
+Year: 2016
+Link: http://doi.org/10.23915/distill.00003
+"""
+
+import os
+
+import tensorflow as tf
+import numpy as np
+
+#from .base import BaseModel, get_optimizer
+
+from tensorflow.python.keras.backend import function, learning_phase
+from tensorflow.python.keras.models import Model
+from tensorflow.python.keras.callbacks import ModelCheckpoint, EarlyStopping
+from tensorflow.python.keras.layers import (Conv2D, Concatenate, MaxPooling2D,
+                                            Dropout, GlobalAveragePooling2D,
+                                            Add, Input, Activation,
+                                            ZeroPadding2D, BatchNormalization,
+                                            Cropping2D)
+
+# TODO add logging routines
+# TODO add cache routines
+# TODO manage multiprocessing
+# TODO improve logging
+# ### 2D models ###
+
+
+# ### Architecture functions ###
+
+def unet_network(input_tensor, nb_classes):
+    """Original architecture of the network.
+
+    Parameters
+    ----------
+    input_tensor : Keras tensor, float32
+        Input tensor with shape (batch_size, ?, ?, 1).
+    nb_classes : int
+        Number of final classes.
+
+    Returns
+    -------
+    tensor : Keras tensor, float32
+        Output tensor with shape (batch_size, ?, ?, nb_classes)
+
+    """
+    # contraction 1
+    conv1 = Conv2D(
+        filters=64,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv1')(
+        input_tensor)  # (batch_size, ?, ?, 64)
+    conv2 = Conv2D(
+        filters=64,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv2')(
+        conv1)  # (batch_size, ?, ?, 64)
+    crop2 = Cropping2D(
+        cropping=((88, 88), (88, 88)),
+        name="crop2")(
+        conv2)  # (batch_size, ?, ?, 64)
+    maxpool2 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool2")(
+        conv2)  # (batch_size, ?, ?, 64)
+
+    # contraction 2
+    conv3 = Conv2D(
+        filters=128,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv3')(
+        maxpool2)  # (batch_size, ?, ?, 128)
+    conv4 = Conv2D(
+        filters=128,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv4')(
+        conv3)  # (batch_size, ?, ?, 128)
+    crop4 = Cropping2D(
+        cropping=((40, 40), (40, 40)),
+        name="crop4")(
+        conv4)  # (batch_size, ?, ?, 128)
+    maxpool4 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool4")(
+        conv4)  # ((batch_size, ?, ?, 128)
+
+    # contraction 3
+    conv5 = Conv2D(
+        filters=256,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv5')(
+        maxpool4)  # (batch_size, ?, ?, 256)
+    conv6 = Conv2D(
+        filters=256,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv6')(
+        conv5)  # (batch_size, ?, ?, 256)
+    crop6 = Cropping2D(
+        cropping=((16, 16), (16, 16)),
+        name="crop6")(
+        conv6)  # (batch_size, ?, ?, 256)
+    maxpool6 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool6")(
+        conv6)  # (batch_size, ?, ?, 256)
+
+    # contraction 4
+    conv7 = Conv2D(
+        filters=512,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv7')(
+        maxpool6)  # (batch_size, ?, ?, 512)
+    conv8 = Conv2D(
+        filters=512,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv8')(
+        conv7)  # (batch_size, ?, ?, 512)
+    crop8 = Cropping2D(
+        cropping=((4, 4), (4, 4)),
+        name="crop8")(
+        conv8)  # (batch_size, ?, ?, 512)
+    maxpool8 = MaxPooling2D(
+        pool_size=(3, 3),
+        strides=(2, 2),
+        name="maxpool8")(
+        conv8)  # (batch_size, ?, ?, 512)
+
+    # bottom
+    conv9 = Conv2D(
+        filters=1024,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv9')(
+        maxpool8)  # (batch_size, ?, ?, 1024)
+    conv10 = Conv2D(
+        filters=1024,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv10')(
+        conv9)  # (batch_size, ?, ?, 1024)
+
+    # expansion 1
+    upconv11 = up_conv_2d(
+        input_tensor=conv10,
+        nb_filters=512,
+        name='upconv11')  # (batch_size, ?, ?, 512)
+    concat11 = tf.concat(
+        values=[crop8, upconv11],
+        axis=-1,
+        name='concat11')  # (batch_size, ?, ?, 1024)
+    conv12 = Conv2D(
+        filters=512,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv12')(
+        concat11)  # (batch_size, ?, ?, 512)
+    conv13 = Conv2D(
+        filters=512,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv13')(
+        conv12)  # (batch_size, ?, ?, 512)
+
+    # expansion 2
+    upconv14 = up_conv_2d(
+        input_tensor=conv13,
+        nb_filters=256,
+        name='upconv14')  # (batch_size, ?, ?, 256)
+    concat14 = tf.concat(
+        values=[crop6, upconv14],
+        axis=-1,
+        name='concat14')  # (batch_size, ?, ?, 512)
+    conv15 = Conv2D(
+        filters=256,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv15')(
+        concat14)  # (batch_size, ?, ?, 256)
+    conv16 = Conv2D(
+        filters=256,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv16')(
+        conv15)  # (batch_size, ?, ?, 256)
+
+    # expansion 3
+    upconv17 = up_conv_2d(
+        input_tensor=conv16,
+        nb_filters=128,
+        name='upconv17')  # (batch_size, ?, ?, 128)
+    concat17 = tf.concat(
+        values=[crop4, upconv17],
+        axis=-1,
+        name='concat17')  # (batch_size, ?, ?, 256)
+    conv18 = Conv2D(
+        filters=128,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv18')(
+        concat17)  # (batch_size, ?, ?, 128)
+    conv19 = Conv2D(
+        filters=128,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv19')(
+        conv18)  # (batch_size, ?, ?, 128)
+
+    # expansion 4
+    upconv20 = up_conv_2d(
+        input_tensor=conv19,
+        nb_filters=64,
+        name='upconv20')  # (batch_size, ?, ?, 64)
+    concat20 = tf.concat(
+        values=[crop2, upconv20],
+        axis=-1,
+        name='concat20')  # (batch_size, ?, ?, 128)
+    conv21 = Conv2D(
+        filters=64,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv21')(
+        concat20)  # (batch_size, ?, ?, 64)
+    conv22 = Conv2D(
+        filters=64,
+        kernel_size=(3, 3),
+        activation='relu',
+        name='conv22')(
+        conv21)  # (batch_size, ?, ?, 64)
+    conv23 = Conv2D(
+        filters=nb_classes,
+        kernel_size=(1, 1),
+        activation='sigmoid',
+        name='conv23')(
+        conv22)  # (batch_size, ?, ?, nb_classes)
+
+    return conv23
+
+
+#norm10 = BatchNormalization(
+#        name="batchnorm10")(
+#        conv10)  # (batch_size, 13, 13, nb_classes)
+
+#dropout10 = Dropout(
+#        rate=0.5,
+#        name="dropout10")(
+#        fire9)
+
+
+def up_conv_2d(input_tensor, nb_filters, name):
+    """Fire module.
+
+    1) Tensor is resized by a factor 2 using nearest neighbors.
+    2) Tensor is padded with a symmetric mode to avoid boundary artifacts.
+    3) A 2-d convolution with a 3x3 filter is applied. In the original article
+    the convolution has a 2x2 filter.
+
+    Parameters
+    ----------
+    input_tensor : Keras tensor, float32
+        Input tensor with shape (batch_size, height, width, channels).
+    nb_filters : int
+        Number of filters of the convolution layer.
+    name : str
+        Name of these layers.
+
+    Returns
+    -------
+    output_layer : Keras tensor, float32
+        Output tensor with shape (batch_size, 2 * height, 2 * width, channels).
+
+    """
+    resize = UpSampling2D(size=(2, 2), interpolation='nearest')(input_tensor)
+    paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
+    resize = tf.pad(resize, paddings, "SYMMETRIC")
+    output_layer = Conv2D(
+        filters=nb_filters,
+        kernel_size=(3, 3),
+        activation='relu',
+        name=name)(
+        resize)
+
+    return output_layer
+
+
+def get_input_size_unet(bottom_size):
+    """Compute the input size required to have a specific bottom size.
+
+    Parameters
+    ----------
+    bottom_size : int
+        Tensor size at the bottom of the U-net model.
+
+    Returns
+    -------
+    input_size : int
+        Input size required to get the specified bottom size.
+
+    """
+    # compute the relation between the input size and the bottom size
+    input_size = 4 + 2 * (4 + 2 * (4 + 2 * (4 + 2 * bottom_size)))
+
+    return input_size
+
+
+
+########################################
+
+
+
+
+def depthwise_softmax(x):
+    exp_tensor = K.exp(x - K.max(x, axis=-1, keepdims=True))
+    # softmax_tensor = exp_tensor / K.sum(exp_tensor, axis=-1, keepdims=True)
+
+    return exp_tensor / K.sum(exp_tensor, axis=-1, keepdims=True)
+
+
+def channelwise_structure(radiuses):
+    np_structure = numpy.ones(
+        (2 * max(radiuses) + 1, 2 * max(radiuses) + 1, len(radiuses)))
+    structures = []
+    np_structure = numpy.stack([erosion(disk(radius), disk(radius)),
+                                erosion(disk(radius), disk(radius)),
+                                disk(radius)], axis=-1)
+    structure = tf.constant(np_structure, dtype='float32')
+    return structure
+
+
+def binary_closing(input, structure):
+    dilated = tf.nn.dilation2d(input, structure, [1, 1, 1, 1], [1, 1, 1, 1],
+                               padding="SAME")
+
+    eroded = tf.nn.erosion2d(dilated, structure, [1, 1, 1, 1], [1, 1, 1, 1],
+                             padding="SAME")
+
+    return eroded
+

From bd140f74ce73e9e8d8346b868a04134fdef4fedb Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:11:30 +0200
Subject: [PATCH 180/264] add 'get_boundaries'

---
 bigfish/segmentation/utils.py | 42 +++++++++++++++++++++++++++++++++--
 1 file changed, 40 insertions(+), 2 deletions(-)

diff --git a/bigfish/segmentation/utils.py b/bigfish/segmentation/utils.py
index b9ad559a..8f5a9701 100644
--- a/bigfish/segmentation/utils.py
+++ b/bigfish/segmentation/utils.py
@@ -4,12 +4,17 @@
 Utilities function for nuclei and cytoplasm segmentation.
 """
 
+import warnings
+
 import bigfish.stack as stack
 
 import numpy as np
 from skimage.measure import label, regionprops
 from skimage.morphology import remove_small_objects
+from skimage.segmentation import find_boundaries
+
 
+# TODO homogenize the dtype of masks
 
 def label_instances(mask):
     """Count and label the different instances previously segmented in an
@@ -104,8 +109,10 @@ def merge_labels(label_1, label_2):
     nb_label_2 = label_2.max()
 
     # clean masks
-    label_1 = remove_small_objects(label_1, 3000)
-    label_2 = remove_small_objects(label_2, 3000)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        label_1 = remove_small_objects(label_1, 3000)
+        label_2 = remove_small_objects(label_2, 3000)
 
     # cast labels in np.int64
     label_1 = label_1.astype(np.int64)
@@ -122,3 +129,34 @@ def merge_labels(label_1, label_2):
     return label
 
 
+def get_boundaries(mask):
+    """Get the boundaries coordinates of a mask
+
+    Parameters
+    ----------
+    mask : np.ndarray, np.uint or np.int or bool
+        Labelled image with shape (y, x).
+
+    Returns
+    -------
+    boundaries : np.ndarray, np.int64
+        Coordinate of the boundaries with shape (nb_points, 2).
+
+    """
+    # check parameters
+    stack.check_array(mask,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64, bool],
+                      allow_nan=False)
+
+    # get boundaries mask
+    boundary_mask = find_boundaries(mask, mode='inner')
+
+    # get peak coordinates and radius
+    boundary_coordinates = np.nonzero(boundary_mask)
+    boundary_coordinates = np.column_stack(boundary_coordinates)
+
+    # complete coordinates if necessary
+    boundary_coordinates = stack.complete_coordinates_2d(boundary_coordinates)
+
+    return boundary_coordinates

From 199f5bd39a156af69fa7877870d8f5e2882867ce Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:11:44 +0200
Subject: [PATCH 181/264] add 'get_boundaries'

---
 bigfish/segmentation/__init__.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index 0b1b3916..443b8f14 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -5,7 +5,8 @@
 cytoplasm and label them, in 2-d and 3-d.
 """
 
-from .utils import label_instances, compute_mean_size_object, merge_labels
+from .utils import (label_instances, compute_mean_size_object, merge_labels,
+                    get_boundaries)
 from .nuc_segmentation import (filtered_threshold, remove_segmented_nuc)
 from .cyt_segmentation import (build_cyt_relief, build_cyt_binary_mask,
                                cyt_watershed)
@@ -17,6 +18,7 @@
 
 _unet = ["get_input_size_unet"]
 
-_utils = ["label_instances", "compute_mean_size_object", "merge_labels"]
+_utils = ["label_instances", "compute_mean_size_object", "merge_labels",
+          "get_boundaries"]
 
 __all__ = _utils + _nuc + _cyt

From 03ec12f3d3a04b4f3cb6522c2221ea94d457e39d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:12:33 +0200
Subject: [PATCH 182/264] improve 'plot_segmentation_boundary'

---
 bigfish/plot/plot_images.py | 31 ++++++++++++++++++++-----------
 1 file changed, 20 insertions(+), 11 deletions(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 2a7ac50a..9ed3556c 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -141,7 +141,7 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
     for tensor in tensors:
         stack.check_array(tensor,
                           ndim=2,
-                          dtype=[np.uint8, np.uint16,
+                          dtype=[np.uint8, np.uint16, np.int64,
                                  np.float32, np.float64,
                                  bool],
                           allow_nan=False)
@@ -428,16 +428,19 @@ def plot_segmentation(tensor, mask, rescale=False, title=None,
     return
 
 
-def plot_segmentation_boundary(tensor, mask, rescale=False, title=None,
-                               framesize=(10, 10), remove_frame=False,
-                               path_output=None, ext="png"):
+def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
+                               title=None, framesize=(10, 10),
+                               remove_frame=False, path_output=None,
+                               ext="png"):
     """Plot the boundary of the segmented objects.
 
     Parameters
     ----------
     tensor : np.ndarray
         A 2-d tensor with shape (y, x).
-    mask : np.ndarray
+    mask_nuc : np.ndarray
+        A 2-d image with shape (y, x).
+    mask_cyt : np.ndarray
         A 2-d image with shape (y, x).
     rescale : bool
         Rescale pixel values of the image (made by default in matplotlib).
@@ -457,7 +460,6 @@ def plot_segmentation_boundary(tensor, mask, rescale=False, title=None,
     -------
 
     """
-    # TODO compute boundary separately
     # check parameters
     stack.check_array(tensor,
                       ndim=2,
@@ -465,7 +467,11 @@ def plot_segmentation_boundary(tensor, mask, rescale=False, title=None,
                              np.float32, np.float64,
                              bool],
                       allow_nan=False)
-    stack.check_array(mask,
+    stack.check_array(mask_nuc,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64, bool],
+                      allow_nan=False)
+    stack.check_array(mask_cyt,
                       ndim=2,
                       dtype=[np.uint8, np.uint16, np.int64, bool],
                       allow_nan=False)
@@ -481,9 +487,11 @@ def plot_segmentation_boundary(tensor, mask, rescale=False, title=None,
     if not rescale:
         vmin, vmax = get_minmax_values(tensor)
 
-    # get boundary
-    boundaries = find_boundaries(mask, mode='thick')
-    boundaries = np.ma.masked_where(boundaries == 0, boundaries)
+    # get boundaries
+    boundaries_nuc = find_boundaries(mask_nuc, mode='inner')
+    boundaries_nuc = np.ma.masked_where(boundaries_nuc == 0, boundaries_nuc)
+    boundaries_cyt = find_boundaries(mask_cyt, mode='inner')
+    boundaries_cyt = np.ma.masked_where(boundaries_cyt == 0, boundaries_cyt)
 
     # plot
     if remove_frame:
@@ -496,7 +504,8 @@ def plot_segmentation_boundary(tensor, mask, rescale=False, title=None,
         plt.imshow(tensor, vmin=vmin, vmax=vmax)
     else:
         plt.imshow(tensor)
-    plt.imshow(boundaries, cmap=ListedColormap(['red']))
+    plt.imshow(boundaries_nuc, cmap=ListedColormap(['blue']))
+    plt.imshow(boundaries_cyt, cmap=ListedColormap(['red']))
     if title is not None and not remove_frame:
         plt.title(title, fontweight="bold", fontsize=25)
     if not remove_frame:

From cb10b2be7f5811aa108ac5ccf348f51744885204 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 14:19:39 +0200
Subject: [PATCH 183/264] add function to build a grid

---
 bigfish/detection/__init__.py     | 6 ++++--
 bigfish/detection/gaussian_fit.py | 6 +++---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/bigfish/detection/__init__.py b/bigfish/detection/__init__.py
index f6859e11..6e90593a 100644
--- a/bigfish/detection/__init__.py
+++ b/bigfish/detection/__init__.py
@@ -11,13 +11,15 @@
 from .gaussian_fit import (gaussian_3d, precompute_erf, build_reference_spot,
                            get_spot_volume, get_spot_surface,
                            initialize_spot_parameter_3d, objective_function,
-                           fit_gaussian_3d, simulate_fitted_gaussian_3d)
+                           fit_gaussian_3d, simulate_fitted_gaussian_3d,
+                           initialize_grid_3d)
 
 _detection = ["log_lm", "local_maximum_detection", "spots_thresholding",
               "compute_snr", "from_threshold_to_snr", "get_sigma"]
 
 _fit = ["gaussian_3d", "precompute_erf", "build_reference_spot",
         "get_spot_volume", "get_spot_surface", "initialize_spot_parameter_3d",
-        "objective_function", "fit_gaussian_3d", "simulate_fitted_gaussian_3d"]
+        "objective_function", "fit_gaussian_3d", "simulate_fitted_gaussian_3d",
+        "initialize_grid_3d"]
 
 __all__ = _detection + _fit
diff --git a/bigfish/detection/gaussian_fit.py b/bigfish/detection/gaussian_fit.py
index 12cf6731..295229df 100644
--- a/bigfish/detection/gaussian_fit.py
+++ b/bigfish/detection/gaussian_fit.py
@@ -500,7 +500,7 @@ def initialize_spot_parameter_3d(image, spot_z, spot_y, spot_x, psf_z=400,
         radius_yx=radius_yx)
 
     # build a grid to fit the gaussian values
-    grid, center_z, center_y, center_x = _initialize_grid_3d(
+    grid, center_z, center_y, center_x = initialize_grid_3d(
         image_spot=image_spot,
         resolution_z=resolution_z,
         resolution_yx=resolution_yx,
@@ -513,8 +513,8 @@ def initialize_spot_parameter_3d(image, spot_z, spot_y, spot_x, psf_z=400,
             psf_background)
 
 
-def _initialize_grid_3d(image_spot, resolution_z, resolution_yx,
-                        return_centroid=False):
+def initialize_grid_3d(image_spot, resolution_z, resolution_yx,
+                       return_centroid=False):
     """Build a grid in nanometer to compute gaussian function over a full
     volume.
 

From 4b033a281548725d66ec9f9ba3fc9080b74c4e92 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 6 Jun 2019 16:55:13 +0200
Subject: [PATCH 184/264] add connected components functions

---
 bigfish/detection/__init__.py       |   6 +-
 bigfish/detection/spot_detection.py | 218 +++++++++++++++++++++++++---
 2 files changed, 199 insertions(+), 25 deletions(-)

diff --git a/bigfish/detection/__init__.py b/bigfish/detection/__init__.py
index 6e90593a..17747ddf 100644
--- a/bigfish/detection/__init__.py
+++ b/bigfish/detection/__init__.py
@@ -7,7 +7,8 @@
 
 from .spot_detection import (log_lm, local_maximum_detection,
                              spots_thresholding, compute_snr,
-                             from_threshold_to_snr, get_sigma)
+                             from_threshold_to_snr, get_sigma, log_cc, get_cc,
+                             filter_cc)
 from .gaussian_fit import (gaussian_3d, precompute_erf, build_reference_spot,
                            get_spot_volume, get_spot_surface,
                            initialize_spot_parameter_3d, objective_function,
@@ -15,7 +16,8 @@
                            initialize_grid_3d)
 
 _detection = ["log_lm", "local_maximum_detection", "spots_thresholding",
-              "compute_snr", "from_threshold_to_snr", "get_sigma"]
+              "compute_snr", "from_threshold_to_snr", "get_sigma", "log_cc",
+              "get_cc", "filter_cc"]
 
 _fit = ["gaussian_3d", "precompute_erf", "build_reference_spot",
         "get_spot_volume", "get_spot_surface", "initialize_spot_parameter_3d",
diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index cbbc7240..2ac243de 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -9,13 +9,16 @@
 import scipy.ndimage as ndi
 import numpy as np
 
+from skimage.measure import label, regionprops
+
 
 # TODO complete documentation methods
 # TODO add sanity check functions
+# TODO improve documentation with optional output
 
-# ### Spot detection ###
+# ### LoG detection ###
 
-def log_lm(image, sigma, threshold, minimum_distance=1, return_log=False):
+def log_lm(image, sigma, threshold, minimum_distance=1):
     """Apply LoG filter followed by a Local Maximum algorithm to detect spots
     in a 2-d or 3-d image.
 
@@ -27,18 +30,15 @@ def log_lm(image, sigma, threshold, minimum_distance=1, return_log=False):
 
     Parameters
     ----------
-    image : np.ndarray, np.uint
+    image : np.ndarray
         Image with shape (z, y, x) or (y, x).
     sigma : float or Tuple(float)
         Sigma used for the gaussian filter (one for each dimension). If it's a
         float, the same sigma is applied to every dimensions.
     threshold : float or int
-        A threshold to detect peaks. Considered as a relative threshold if
-        float.
+        A threshold to detect peaks.
     minimum_distance : int
         Minimum distance (in number of pixels) between two local peaks.
-    return_log : bool
-        Return the LoG filtered image.
 
     Returns
     -------
@@ -65,13 +65,9 @@ def log_lm(image, sigma, threshold, minimum_distance=1, return_log=False):
     mask = local_maximum_detection(image_filtered, minimum_distance)
 
     # remove spots with a low intensity and return coordinates and radius
-    spots, radius = spots_thresholding(image, sigma, mask, threshold)
-
-    if return_log:
-        return spots, radius, image_filtered
+    spots, radius, _ = spots_thresholding(image, sigma, mask, threshold)
 
-    else:
-        return spots, radius
+    return spots, radius
 
 
 def local_maximum_detection(image, minimum_distance):
@@ -113,7 +109,7 @@ def local_maximum_detection(image, minimum_distance):
     return mask
 
 
-def spots_thresholding(image, sigma, mask, threshold):
+def spots_thresholding(image, sigma, mask_lm, threshold):
     """Filter detected spots and get coordinates of the remaining
     spots.
 
@@ -124,11 +120,12 @@ def spots_thresholding(image, sigma, mask, threshold):
     sigma : float or Tuple(float)
         Sigma used for the gaussian filter (one for each dimension). If it's a
         float, the same sigma is applied to every dimensions.
-    mask : np.ndarray, bool
+    mask_lm : np.ndarray, bool
         Mask with shape (z, y, x) or (y, x) indicating the local peaks.
     threshold : float or int
-        A threshold to detect peaks. Considered as a relative threshold if
-        float.
+        A threshold to detect peaks.
+    return_mask : bool
+        Return the final mask with the spots.
 
     Returns
     -------
@@ -137,6 +134,8 @@ def spots_thresholding(image, sigma, mask, threshold):
         (nb_peaks, 2) for 3-d or 2-d images respectively.
     radius : float or Tuple(float)
         Radius of the detected peaks.
+    mask : np.ndarray, bool
+        Mask with shape (z, y, x) or (y, x) indicating the spots.
 
     """
     # check parameters
@@ -144,7 +143,7 @@ def spots_thresholding(image, sigma, mask, threshold):
                       ndim=[2, 3],
                       dtype=[np.uint8, np.uint16, np.float32, np.float64],
                       allow_nan=False)
-    stack.check_array(mask,
+    stack.check_array(mask_lm,
                       ndim=[2, 3],
                       dtype=[bool],
                       allow_nan=False)
@@ -152,12 +151,10 @@ def spots_thresholding(image, sigma, mask, threshold):
                           threshold=(float, int))
 
     # remove peak with a low intensity
-    if isinstance(threshold, float):
-        threshold *= image.max()
-    mask_ = (mask & (image > threshold))
+    mask = (mask_lm & (image > threshold))
 
     # get peak coordinates
-    peak_coordinates = np.nonzero(mask_)
+    peak_coordinates = np.nonzero(mask)
     peak_coordinates = np.column_stack(peak_coordinates)
 
     # compute radius
@@ -167,7 +164,182 @@ def spots_thresholding(image, sigma, mask, threshold):
     else:
         radius = np.sqrt(image.ndim) * sigma
 
-    return peak_coordinates, radius
+    return peak_coordinates, radius, mask
+
+
+def log_cc(image, sigma, threshold):
+    """Find connected regions above a fixed threshold on a LoG filtered image.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image with shape (z, y, x) or (y, x).
+    sigma : float or Tuple(float)
+        Sigma used for the gaussian filter (one for each dimension). If it's a
+        float, the same sigma is applied to every dimensions.
+    threshold : float or int
+        A threshold to detect peaks. Considered as a relative threshold if
+        float.
+
+    Returns
+    -------
+    cc : np.ndarray, np.int64
+        Image labelled with shape (z, y, x) or (y, x).
+
+    """
+    # check parameters
+    stack.check_array(image,
+                      ndim=[2, 3],
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_parameter(sigma=(float, int, tuple),
+                          threshold=(float, int))
+
+    # cast image in np.float and apply LoG filter
+    image_filtered = stack.log_filter(image, sigma, keep_dtype=True)
+
+    # find connected components
+    cc = get_cc(image_filtered, threshold)
+
+    # TODO return coordinate of the centroid
+
+    return cc
+
+
+def get_cc(image, threshold):
+    """Find connected regions above a fixed threshold.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image with shape (z, y, x) or (y, x).
+    threshold : float or int
+        A threshold to detect peaks.
+
+    Returns
+    -------
+    cc : np.ndarray, np.int64
+        Image labelled with shape (z, y, x) or (y, x).
+
+    """
+    # check parameters
+    stack.check_array(image,
+                      ndim=[2, 3],
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_parameter(threshold=(float, int))
+
+    # Compute binary mask of the filtered image
+    mask = image > threshold
+
+    # find connected components
+    cc = label(mask)
+
+    return cc
+
+
+def filter_cc(image, cc, spots, min_area, min_nb_spots, min_intensity_factor):
+    """Filter connected regions.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image with shape (z, y, x) or (y, x).
+    cc : np.ndarray, np.int64
+        Image labelled with shape (z, y, x) or (y, x).
+    spots : np.ndarray, np.int64
+        Coordinate of the spots with shape (nb_spots, 3) or (nb_spots, 2)
+        for 3-d or 2-d images respectively.
+    min_area : int
+        Minimum number of pixels in the connected region.
+    min_nb_spots : int
+        Minimum number of spot detected in this region.
+    min_intensity_factor : int or float
+        Minimum pixel intensity in the connected region is equal to
+        median(intensity) * min_intensity_factor.
+
+    Returns
+    -------
+    regions_filtered : np.ndarray
+        Array with filtered skimage.measure._regionprops._RegionProperties.
+    cc_filtered : np.ndarray, np.int64
+        Image labelled with shape (z, y, x) or (y, x).
+
+    """
+    # TODO manage the difference between 2-d and 3-d data
+
+    # check parameters
+    stack.check_array(image,
+                      ndim=[2, 3],
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_array(cc,
+                      ndim=[2, 3],
+                      dtype=[np.int64],
+                      allow_nan=False)
+    stack.check_array(spots,
+                      ndim=2,
+                      dtype=[np.int64],
+                      allow_nan=False)
+    stack.check_parameter(min_area=int,
+                          min_nb_spots=int,
+                          min_intensity_factor=(float, int),
+                          return_cc=bool)
+
+    # get properties of the different connected regions
+    regions = regionprops(cc, intensity_image=image, cache=True)
+
+    # get different features of the regions
+    area = []
+    intensity = []
+    bbox = []
+    label = []
+    for i, region in enumerate(regions):
+        area.append(region.area)
+        intensity.append(region.max_intensity)
+        bbox.append(region.bbox)
+        label.append(region.label)
+    regions = np.array(regions)
+    area = np.array(area)
+    intensity = np.array(intensity)
+    bbox = np.array(bbox)
+    label = np.array(label)
+
+    # TODO make this part faster
+    # keep regions with a minimum number of spots
+    nb_spots_in = []
+    for box in bbox:
+        (min_z, min_y, min_x, max_z, max_y, max_x) = box
+        spots_in = spots.copy()
+        spots_in = spots_in[spots_in[:, 0] <= max_z]
+        spots_in = spots_in[spots_in[:, 1] <= max_y]
+        spots_in = spots_in[spots_in[:, 2] <= max_x]
+        spots_in = spots_in[min_z <= spots_in[:, 0]]
+        spots_in = spots_in[min_y <= spots_in[:, 1]]
+        spots_in = spots_in[min_x <= spots_in[:, 2]]
+        nb_spots_in.append(spots_in.shape[0])
+    nb_spots_in = np.array(nb_spots_in)
+    multiple_spots = nb_spots_in > min_nb_spots
+
+    # keep regions which reach a minimum intensity value
+    high_intensity = intensity > np.median(intensity) * min_intensity_factor
+
+    # keep regions with a minimum size
+    big_area = area > min_area
+
+    # filter regions and labels
+    mask = (multiple_spots + high_intensity) * big_area
+    regions_filtered = regions[mask]
+    labels_filtered = label[mask]
+
+    # filter the cc image
+    mask_cc = np.zeros_like(cc).astype(bool)
+    for i in labels_filtered:
+        mask_cc = (mask_cc | (cc == i))
+    cc_filtered = cc.copy()
+    cc_filtered[~mask_cc] = 0
+
+    return regions_filtered, cc_filtered
 
 
 # ### Signal-to-Noise ratio ###

From b492b885806b723f6932b31de65fee3501fbd469 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 7 Jun 2019 10:41:02 +0200
Subject: [PATCH 185/264] misc

---
 bigfish/detection/spot_detection.py | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index 2ac243de..957e6e91 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -124,12 +124,10 @@ def spots_thresholding(image, sigma, mask_lm, threshold):
         Mask with shape (z, y, x) or (y, x) indicating the local peaks.
     threshold : float or int
         A threshold to detect peaks.
-    return_mask : bool
-        Return the final mask with the spots.
 
     Returns
     -------
-    peak_coordinates : np.ndarray, np.int64
+    spots : np.ndarray, np.int64
         Coordinate of the local peaks with shape (nb_peaks, 3) or
         (nb_peaks, 2) for 3-d or 2-d images respectively.
     radius : float or Tuple(float)
@@ -154,8 +152,8 @@ def spots_thresholding(image, sigma, mask_lm, threshold):
     mask = (mask_lm & (image > threshold))
 
     # get peak coordinates
-    peak_coordinates = np.nonzero(mask)
-    peak_coordinates = np.column_stack(peak_coordinates)
+    spots = np.nonzero(mask)
+    spots = np.column_stack(spots)
 
     # compute radius
     if isinstance(sigma, tuple):
@@ -164,7 +162,7 @@ def spots_thresholding(image, sigma, mask_lm, threshold):
     else:
         radius = np.sqrt(image.ndim) * sigma
 
-    return peak_coordinates, radius, mask
+    return spots, radius, mask
 
 
 def log_cc(image, sigma, threshold):
@@ -380,7 +378,7 @@ def compute_snr(image, sigma, minimum_distance=1,
 
 
 def from_threshold_to_snr(image, sigma, mask, threshold=2000,
-                           neighbor_factor=3):
+                          neighbor_factor=3):
     """
 
     Parameters

From 786c9d78bc3d096d90c9ee2ef710243b4e233b5b Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 8 Jun 2019 21:24:11 +0200
Subject: [PATCH 186/264] add plot decomposition foci

---
 bigfish/plot/__init__.py    |   5 +-
 bigfish/plot/plot_images.py | 123 +++++++++++++++++++++++++++++++++---
 2 files changed, 117 insertions(+), 11 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index ae3c2f62..a9e639ec 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -7,7 +7,7 @@
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
                           plot_images, plot_spot_detection,
                           plot_illumination_surface,
-                          plot_segmentation_boundary)
+                          plot_segmentation_boundary, plot_foci_decomposition)
 from .plot_coordinates import (plot_volume, plot_rna, plot_distribution_rna,
                                plot_cell_coordinates, plot_layers_coordinates)
 from .plot_classification import plot_confusion_matrix, plot_2d_projection
@@ -15,7 +15,8 @@
 
 _images = ["plot_yx", "plot_images", "plot_channels_2d",
            "plot_illumination_surface", "plot_segmentation",
-           "plot_spot_detection", "plot_segmentation_boundary"]
+           "plot_spot_detection", "plot_segmentation_boundary",
+           "plot_foci_decomposition"]
 
 _coordinates = ["plot_volume", "plot_rna", "plot_distribution_rna",
                 "plot_cell_coordinates", "plot_layers_coordinates"]
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 9ed3556c..6d29f3ed 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -517,8 +517,8 @@ def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
     return
 
 
-def plot_spot_detection(tensor, coordinates, radius, rescale=False, title=None,
-                        framesize=(15, 5), remove_frame=False,
+def plot_spot_detection(tensor, spots, radius_yx, rescale=False,
+                        title=None, framesize=(15, 5), remove_frame=False,
                         path_output=None, ext="png"):
     """Plot detected spot on a 2-d image.
 
@@ -526,11 +526,11 @@ def plot_spot_detection(tensor, coordinates, radius, rescale=False, title=None,
     ----------
     tensor : np.ndarray
         A 2-d tensor with shape (y, x).
-    coordinates : np.ndarray, np.int64
+    spots : np.ndarray, np.int64
         Coordinate of the spots with shape (nb_spots, 3) or
         (nb_spots, 2) for 3-d or 2-d images respectively.
-    radius : float
-        Radius of the detected spots.
+    radius_yx : float or int
+        Radius yx of the detected spots.
     rescale : bool
         Rescale pixel values of the image (made by default in matplotlib).
     title : str
@@ -556,11 +556,11 @@ def plot_spot_detection(tensor, coordinates, radius, rescale=False, title=None,
                       dtype=[np.uint8, np.uint16,
                              np.float32, np.float64],
                       allow_nan=False)
-    stack.check_array(coordinates,
+    stack.check_array(spots,
                       ndim=2,
                       dtype=[np.int64],
                       allow_nan=False)
-    stack.check_parameter(radius=float,
+    stack.check_parameter(radius_yx=(float, int),
                           rescale=bool,
                           title=(str, type(None)),
                           framesize=tuple,
@@ -591,9 +591,9 @@ def plot_spot_detection(tensor, coordinates, radius, rescale=False, title=None,
         ax[1].imshow(tensor, vmin=vmin, vmax=vmax)
     else:
         ax[1].imshow(tensor)
-    for spot_coordinate in coordinates:
+    for spot_coordinate in spots:
         _, y, x = spot_coordinate
-        c = plt.Circle((x, y), radius,
+        c = plt.Circle((x, y), radius_yx,
                        color="red",
                        linewidth=1,
                        fill=False)
@@ -609,3 +609,108 @@ def plot_spot_detection(tensor, coordinates, radius, rescale=False, title=None,
     plt.show()
 
     return
+
+
+def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
+                            rescale=False, title=None, framesize=(15, 10),
+                            remove_frame=False, path_output=None, ext="png"):
+    """Plot detected spots and foci on a 2-d image.
+
+    Parameters
+    ----------
+    tensor : np.ndarray
+        A 2-d tensor with shape (y, x).
+    spots : np.ndarray, np.int64
+        Coordinate of the spots with shape (nb_spots, 3).
+    foci : List[tuple]
+        Coordinate of the foci with shape (nb_spots, 3).
+    radius_spots_yx : float or int
+        Radius yx of the detected spots.
+    rescale : bool
+        Rescale pixel values of the image (made by default in matplotlib).
+    title : str
+        Title of the image.
+    framesize : tuple
+        Size of the frame used to plot (plt.figure(figsize=framesize).
+    remove_frame : bool
+        Remove axes and frame.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # TODO check coordinates shape
+    # check parameters
+    stack.check_array(tensor,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16,
+                             np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_array(spots,
+                      ndim=2,
+                      dtype=[np.int64],
+                      allow_nan=False)
+    stack.check_parameter(foci=list,
+                          radius_spots_yx=(float, int),
+                          rescale=bool,
+                          title=(str, type(None)),
+                          framesize=tuple,
+                          remove_frame=bool,
+                          path_output=(str, type(None)),
+                          ext=(str, list))
+
+    # get minimum and maximum value of the image
+    vmin, vmax = None, None
+    if not rescale:
+        vmin, vmax = get_minmax_values(tensor)
+
+    # plot
+    fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
+
+    # image
+    if not rescale:
+        ax[0].imshow(tensor, vmin=vmin, vmax=vmax)
+    else:
+        ax[0].imshow(tensor)
+    if title is not None:
+        ax[0].set_title(title, fontweight="bold", fontsize=10)
+    if remove_frame:
+        ax[0].axis("off")
+
+    # spots and foci
+    if not rescale:
+        ax[1].imshow(tensor, vmin=vmin, vmax=vmax)
+    else:
+        ax[1].imshow(tensor)
+    for spot_coordinate in spots:
+        _, y, x = spot_coordinate
+        c = plt.Circle((x, y), radius_spots_yx,
+                       color="red",
+                       linewidth=1,
+                       fill=False)
+        ax[1].add_patch(c)
+    for (foci_coordinates, nb_rna, radius_foci) in foci:
+        _, y, x = foci_coordinates
+        c = plt.Circle((x, y), radius_foci,
+                       color="blue",
+                       linewidth=2,
+                       fill=False)
+        ax[1].add_patch(c)
+    if title is not None:
+        ax[1].set_title("Detected spots and foci",
+                        fontweight="bold",
+                        fontsize=10)
+    if remove_frame:
+        ax[1].axis("off")
+
+    plt.tight_layout()
+    if path_output is not None:
+        save_plot(path_output, ext)
+    plt.show()
+
+    return

From 4b1c2f97493ec197142b3cf884581106d17cd9e1 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 8 Jun 2019 21:24:40 +0200
Subject: [PATCH 187/264] add TODO

---
 bigfish/stack/utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 9b43c590..30b25e07 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -116,7 +116,7 @@ def _check_nan_df(df, features_nan=None):
 
 
 # ### Sanity checks array ###
-
+# TODO fix the problem with _check_nan_array (too many calls, too slow)
 def check_array(array, ndim=None, dtype=None, allow_nan=True):
     """Full safety check of an array.
 
@@ -518,6 +518,7 @@ def check_parameter(**kwargs):
         expected_dtype = kwargs[arg]
         parameter = values[arg]
         if not isinstance(parameter, expected_dtype):
+            # TODO improve the error: raise 'Parameter array' when it comes from 'check_array'.
             raise ValueError("Parameter {0} should be cast in {1}. It is a {2}"
                              "instead."
                              .format(arg, expected_dtype, type(parameter)))

From d0b1b423d4ae3e986f76a8d89260a3f7abb91929 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 8 Jun 2019 21:25:13 +0200
Subject: [PATCH 188/264] add decomposition foci

---
 bigfish/detection/__init__.py       |  12 +-
 bigfish/detection/gaussian_fit.py   | 398 ++++++++++++++++++++++------
 bigfish/detection/spot_detection.py |  87 +++---
 3 files changed, 385 insertions(+), 112 deletions(-)

diff --git a/bigfish/detection/__init__.py b/bigfish/detection/__init__.py
index 17747ddf..93fea9bd 100644
--- a/bigfish/detection/__init__.py
+++ b/bigfish/detection/__init__.py
@@ -9,19 +9,21 @@
                              spots_thresholding, compute_snr,
                              from_threshold_to_snr, get_sigma, log_cc, get_cc,
                              filter_cc)
-from .gaussian_fit import (gaussian_3d, precompute_erf, build_reference_spot,
-                           get_spot_volume, get_spot_surface,
+from .gaussian_fit import (gaussian_3d, build_reference_spot_3d,
+                           get_spot_volume, get_spot_surface, precompute_erf,
                            initialize_spot_parameter_3d, objective_function,
                            fit_gaussian_3d, simulate_fitted_gaussian_3d,
-                           initialize_grid_3d)
+                           initialize_grid_3d, compute_background_amplitude,
+                           fit_gaussian_mixture, foci_decomposition)
 
 _detection = ["log_lm", "local_maximum_detection", "spots_thresholding",
               "compute_snr", "from_threshold_to_snr", "get_sigma", "log_cc",
               "get_cc", "filter_cc"]
 
-_fit = ["gaussian_3d", "precompute_erf", "build_reference_spot",
+_fit = ["gaussian_3d", "precompute_erf", "build_reference_spot_3d",
         "get_spot_volume", "get_spot_surface", "initialize_spot_parameter_3d",
         "objective_function", "fit_gaussian_3d", "simulate_fitted_gaussian_3d",
-        "initialize_grid_3d"]
+        "initialize_grid_3d", "compute_background_amplitude",
+        "fit_gaussian_mixture", "foci_decomposition"]
 
 __all__ = _detection + _fit
diff --git a/bigfish/detection/gaussian_fit.py b/bigfish/detection/gaussian_fit.py
index 295229df..8c3e17bd 100644
--- a/bigfish/detection/gaussian_fit.py
+++ b/bigfish/detection/gaussian_fit.py
@@ -5,7 +5,7 @@
 """
 
 import bigfish.stack as stack
-from .spot_detection import get_sigma
+from .spot_detection import get_sigma, get_cc, filter_cc
 
 import numpy as np
 
@@ -65,7 +65,7 @@ def gaussian_3d(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, resolution_z,
     stack.check_array(grid,
                       ndim=2,
                       dtype=np.float32,
-                      allow_nan=False)
+                      allow_nan=True)
     stack.check_parameter(mu_z=(float, int),
                           mu_y=(float, int),
                           mu_x=(float, int),
@@ -95,9 +95,9 @@ def gaussian_3d(grid, mu_z, mu_y, mu_x, sigma_z, sigma_yx, resolution_z,
         i_x = np.around(np.abs(meshgrid_x - mu_x) / 5).astype(np.int64)
 
         # get precomputed values
-        voxel_integral_z = table_erf_z[i_z]
-        voxel_integral_y = table_erf_y[i_y]
-        voxel_integral_x = table_erf_x[i_x]
+        voxel_integral_z = table_erf_z[i_z, 1]
+        voxel_integral_y = table_erf_y[i_y, 1]
+        voxel_integral_x = table_erf_x[i_x, 1]
 
     # compute erf value
     else:
@@ -236,16 +236,15 @@ def precompute_erf(resolution_z, resolution_yx, sigma_z, sigma_yx,
 
 # ### Spot parameter ###
 
-def build_reference_spot(image, spots, radius, method="median"):
-    """Build a
+def build_reference_spot_3d(image, spots, radius, method="median"):
+    """Build a median or mean spot volume/surface as reference.
 
     Parameters
     ----------
     image : np.ndarray,
-        Image with shape (z, y, x) or (y, x).
+        Image with shape (z, y, x).
     spots : np.ndarray, np.int64
-        Coordinate of the spots with shape (nb_spots, 3) or (nb_spots, 2)
-        for 3-d or 2-d images respectively.
+        Coordinate of the spots with shape (nb_spots, 3).
     radius : Tuple[float]
         Radius of the detected peaks, one for each dimension.
     method : str
@@ -254,13 +253,12 @@ def build_reference_spot(image, spots, radius, method="median"):
     Returns
     -------
     reference_spot : np.ndarray
-        Reference spot with shape (2*radius_z+1, 2*radius_y+1, 2*radius_x+1) or
-        (2*radius_y+1, 2*radius_x+1).
+        Reference spot with shape (2*radius_z+1, 2*radius_y+1, 2*radius_x+1).
 
     """
     # check parameters
     stack.check_array(image,
-                      ndim=[2, 3],
+                      ndim=3,
                       dtype=[np.uint8, np.uint16, np.float32, np.float64],
                       allow_nan=False)
     stack.check_array(spots,
@@ -273,52 +271,36 @@ def build_reference_spot(image, spots, radius, method="median"):
         raise ValueError("'{0}' is not a valid value for parameter 'method'. "
                          "Use 'mean' or 'median' instead.".format(method))
 
-    # process a 3-d image
-    if image.ndim == 3:
-        # get a rounded radius for each dimension
-        radius_z = int(radius[0]) + 1
-        radius_yx = int(radius[1]) + 1
-        z_shape = radius_z * 2 + 1
-        yx_shape = radius_yx * 2 + 1
-
-        # collect area around each spot
-        l_reference_spot = []
-        for i_spot in range(spots.shape[0]):
-
-            # get spot coordinates
-            spot_z, spot_y, spot_x = spots[i_spot, :]
-
-            # get the volume of the spot
-            image_spot = get_spot_volume(image, spot_z, spot_y, spot_x,
-                                         radius_z, radius_yx)
-
-            # remove the cropped images
-            if image_spot.shape != (z_shape, yx_shape, yx_shape):
-                continue
-
-            l_reference_spot.append(image_spot)
-
-    # process a 2-d image
-    else:
-        # get a rounded radius for each dimension
-        radius_yx = int(radius[1]) + 1
-        yx_shape = radius_yx * 2 + 1
-
-        # collect area around each spot
-        l_reference_spot = []
-        for i_spot in range(spots.shape[0]):
-
-            # get spot coordinates
-            spot_y, spot_x = spots[i_spot, :]
-
-            # get the surface of the spot
-            image_spot = get_spot_surface(image, spot_y, spot_x, radius_yx)
-
-            # remove the cropped images
-            if image_spot.shape != (yx_shape, yx_shape):
-                continue
-
-            l_reference_spot.append(image_spot)
+    # get a rounded radius for each dimension
+    radius_z = int(radius[0]) + 1
+    radius_yx = int(radius[1]) + 1
+    z_shape = radius_z * 2 + 1
+    yx_shape = radius_yx * 2 + 1
+    # randomly choose some spots to aggregate
+    indices = [i for i in range(spots.shape[0])]
+    np.random.shuffle(indices)
+    indices = indices[:min(2000, spots.shape[0])]
+    candidate_spots = spots[indices, :]
+    # TODO add a warning if not enough spots are detected
+
+    # collect area around each spot
+    l_reference_spot = []
+    nb_spots = 0
+    for i_spot in range(candidate_spots.shape[0]):
+
+        # get spot coordinates
+        spot_z, spot_y, spot_x = candidate_spots[i_spot, :]
+
+        # get the volume of the spot
+        image_spot = get_spot_volume(image, spot_z, spot_y, spot_x,
+                                     radius_z, radius_yx)
+
+        # remove the cropped images
+        if image_spot.shape != (z_shape, yx_shape, yx_shape):
+            continue
+        else:
+            nb_spots += 1
+        l_reference_spot.append(image_spot)
 
     # if no spot where detected
     if len(l_reference_spot) == 0:
@@ -330,6 +312,7 @@ def build_reference_spot(image, spots, radius, method="median"):
         reference_spot = np.mean(l_reference_spot, axis=0)
     else:
         reference_spot = np.median(l_reference_spot, axis=0)
+    reference_spot = reference_spot.astype(image.dtype)
 
     return reference_spot
 
@@ -347,9 +330,9 @@ def get_spot_volume(image, spot_z, spot_y, spot_x, radius_z, radius_yx):
         Coordinate of the detected spot along the y axis.
     spot_x : np.int64
         Coordinate of the detected spot along the x axis.
-    radius_z : float
+    radius_z : float or int
         Estimated radius of the spot along the z-dimension.
-    radius_yx : float
+    radius_yx : float or int
         Estimated radius of the spot on the yx-plan.
 
     Returns
@@ -362,12 +345,12 @@ def get_spot_volume(image, spot_z, spot_y, spot_x, radius_z, radius_yx):
     stack.check_array(image,
                       ndim=3,
                       dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
+                      allow_nan=True)
     stack.check_parameter(spot_z=np.int64,
                           spot_y=np.int64,
                           spot_x=np.int64,
-                          radius_z=np.int64,
-                          radius_yx=np.int64)
+                          radius_z=(float, int),
+                          radius_yx=(float, int))
 
     # get boundaries of the volume surrounding the spot
     z_spot_min = max(0, int(spot_z - radius_z))
@@ -409,7 +392,7 @@ def get_spot_surface(image, spot_y, spot_x, radius_yx):
     stack.check_array(image,
                       ndim=2,
                       dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
+                      allow_nan=True)
     stack.check_parameter(spot_y=np.int64,
                           spot_x=np.int64,
                           radius_yx=np.int64)
@@ -507,7 +490,7 @@ def initialize_spot_parameter_3d(image, spot_z, spot_y, spot_x, psf_z=400,
         return_centroid=True)
 
     # compute amplitude and background values
-    psf_amplitude, psf_background = _compute_background_amplitude(image_spot)
+    psf_amplitude, psf_background = compute_background_amplitude(image_spot)
 
     return (image_spot, grid, center_z, center_y, center_x, psf_amplitude,
             psf_background)
@@ -544,7 +527,7 @@ def initialize_grid_3d(image_spot, resolution_z, resolution_yx,
     stack.check_array(image_spot,
                       ndim=3,
                       dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
+                      allow_nan=True)
     stack.check_parameter(resolution_z=(float, int),
                           resolution_yx=(float, int),
                           return_centroid=bool)
@@ -581,7 +564,7 @@ def initialize_grid_3d(image_spot, resolution_z, resolution_yx,
         return grid
 
 
-def _compute_background_amplitude(image_spot):
+def compute_background_amplitude(image_spot):
     """Compute amplitude of a spot and background minimum value.
 
     Parameters
@@ -640,9 +623,9 @@ def objective_function(resolution_z=300, resolution_yx=103, sigma_z=400,
     # check parameters
     stack.check_parameter(resolution_z=(float, int),
                           resolution_yx=(float, int),
-                          sigma_z=(float, int),
-                          sigma_yx=(float, int),
-                          psf_amplitude=(float, int))
+                          sigma_z=(float, int, type(None)),
+                          sigma_yx=(float, int, type(None)),
+                          psf_amplitude=(float, int, type(None)))
 
     # sigma is known, we fit mu, amplitude and background
     if (sigma_z is not None
@@ -752,7 +735,7 @@ def fit_gaussian_3d(f, grid, image_spot, p0, lower_bound=None,
     """
     # check parameters
     stack.check_array(grid,
-                      ndim=3,
+                      ndim=2,
                       dtype=np.float32,
                       allow_nan=False)
     stack.check_array(image_spot,
@@ -801,10 +784,10 @@ def simulate_fitted_gaussian_3d(f, grid, popt, original_shape=None):
     """
     # check parameters
     stack.check_array(grid,
-                      ndim=3,
+                      ndim=2,
                       dtype=np.float32,
                       allow_nan=False)
-    stack.check_parameter(popt=list,
+    stack.check_parameter(popt=np.ndarray,
                           original_shape=(tuple, type(None)))
 
     # compute gaussian values
@@ -815,3 +798,270 @@ def simulate_fitted_gaussian_3d(f, grid, popt, original_shape=None):
         values = np.reshape(values, original_shape).astype(np.float32)
 
     return values
+
+
+def fit_gaussian_mixture(image, region, resolution_z, resolution_yx, sigma_z,
+                         sigma_yx, amplitude, background,
+                         precomputed_gaussian):
+    """Fit a mixture of gaussian to a potential foci region.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    region : skimage.measure._regionprops._RegionProperties
+        Properties of a foci region.
+    resolution_z : int or float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : int or float
+        Size of a voxel on the yx plan, in nanometer.
+    sigma_z : int or float
+        Theoretical height of the spot PSF along the z axis, in nanometer.
+    sigma_yx : int or float
+        Theoretical diameter of the spot PSF on the yx plan, in nanometer.
+    amplitude : int or float
+        Amplitude of the spot.
+    background : int of float
+        Background intensity level of the spot.
+    precomputed_gaussian : List[np.ndarray] or Tuple[np.ndarray]
+        Precomputed tables values of erf for the different axis.
+
+    Returns
+    -------
+    image_region : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    best_simulation : np.ndarray, np.uint
+        A 3-d image with detected spot and shape (z, y, x).
+    positions_gaussian : List[List]
+        List of positions (as a list [z, y, x]) for the different gaussian
+        simulations used in the mixture.
+
+    """
+    # TODO improve documentation
+    # TODO make this function consistent
+    # check parameters
+    stack.check_array(image,
+                      ndim=3,
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=True)
+    stack.check_parameter(resolution_z=(float, int),
+                          resolution_yx=(float, int),
+                          sigma_z=(float, int),
+                          sigma_yx=(float, int),
+                          amplitude=(float, int),
+                          background=(float, int),
+                          precomputed_gaussian=(list, tuple))
+
+    # get an image of the region
+    box = tuple(region.bbox)
+    image_region = image[box[0]:box[3], box[1]:box[4], box[2]:box[5]]
+    image_region_raw = np.reshape(image_region, image_region.size)
+
+    # build a grid to represent this image
+    grid = initialize_grid_3d(image_region, resolution_z, resolution_yx)
+
+    # add a gaussian for each local maximum while the RSS decreases
+    simulation = np.zeros(image_region_raw.shape, dtype=np.float64)
+    residual = image_region_raw - simulation
+    ssr = np.sum(residual ** 2)
+    diff_ssr = -1
+    nb_gaussian = 0
+    best_simulation = simulation.copy()
+    positions_gaussian = []
+    while diff_ssr < 0 or nb_gaussian == 1000:
+        position_gaussian = np.argmax(residual)
+        positions_gaussian.append(list(grid[:, position_gaussian]))
+        simulation += gaussian_3d(grid=grid,
+                                  mu_z=float(positions_gaussian[-1][0]),
+                                  mu_y=float(positions_gaussian[-1][1]),
+                                  mu_x=float(positions_gaussian[-1][2]),
+                                  sigma_z=sigma_z,
+                                  sigma_yx=sigma_yx,
+                                  resolution_z=resolution_z,
+                                  resolution_yx=resolution_yx,
+                                  psf_amplitude=amplitude,
+                                  psf_background=background,
+                                  precomputed=precomputed_gaussian)
+        residual = image_region_raw - simulation
+        new_ssr = np.sum(residual ** 2)
+        diff_ssr = new_ssr - ssr
+        ssr = new_ssr
+        nb_gaussian += 1
+        background = 0
+        # print("NB spots {0} | Difference SSR {1} | SSR {2}"
+        #       .format(nb_gaussian, int(diff_ssr), int(ssr)))
+
+        if diff_ssr < 0:
+            best_simulation = simulation.copy()
+
+    if 1 < nb_gaussian < 1000:
+        positions_gaussian.pop(-1)
+
+    best_simulation = np.reshape(best_simulation, image_region.shape)
+    best_simulation = best_simulation.astype(image_region_raw.dtype)
+
+    return image_region, best_simulation, positions_gaussian
+
+
+# ### Foci decomposition ###
+
+
+def foci_decomposition(image_filtered_log, image_filtered_background,
+                       threshold_spot, spots, radius, min_area, min_nb_spots,
+                       min_intensity_factor, resolution_z=300,
+                       resolution_yx=103, psf_z=400, psf_yx=200):
+    """Detect regions with clustered spots (foci) and fit a mixture of
+    gaussian to them.
+
+    Parameters
+    ----------
+    image_filtered_log
+    image_filtered_background
+    threshold_spot
+    spots
+    radius
+    min_area
+    min_nb_spots
+    min_intensity_factor
+    resolution_z
+    resolution_yx
+    psf_z
+    psf_yx
+
+    Returns
+    -------
+    spots_out_foci
+    spots_in_foci
+    foci
+    reference_spot
+
+    """
+    # check parameters
+    stack.check_array(image_filtered_log,
+                      ndim=3,
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_array(image_filtered_background,
+                      ndim=3,
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
+                      allow_nan=False)
+    stack.check_array(spots,
+                      ndim=2,
+                      dtype=[np.int64],
+                      allow_nan=False)
+    stack.check_parameter(threshold_spot=(float, int),
+                          radius=(tuple, list),
+                          min_area=(float, int),
+                          min_nb_spots=(float, int),
+                          min_intensity_factor=(float, int),
+                          resolution_z=(float, int),
+                          resolution_yx=(float, int),
+                          psf_z=(float, int),
+                          psf_yx=(float, int))
+
+    # case where no spot were detected
+    if spots.size == 0:
+        foci = []
+        radius_z = int(radius[0]) + 1
+        radius_yx = int(radius[1]) + 1
+        z_shape = radius_z * 2 + 1
+        yx_shape = radius_yx * 2 + 1
+        reference_spot = np.zeros((z_shape, yx_shape, yx_shape),
+                                  dtype=image_filtered_background.dtype)
+
+        return spots, spots, foci, reference_spot
+
+    # build a reference median spot
+    reference_spot = build_reference_spot_3d(
+        image_filtered_background,
+        spots,
+        radius,
+        method="median")
+
+    # initialize a grid representing the reference spot
+    grid, centroid_z, centroid_y, centroid_x = initialize_grid_3d(
+        image_spot=reference_spot,
+        resolution_z=resolution_z,
+        resolution_yx=resolution_yx,
+        return_centroid=True)
+
+    # compute amplitude and background of the reference spot
+    amplitude, background = compute_background_amplitude(reference_spot)
+
+    # TODO initialize the function multiple times
+    # fit a 3-d gaussian function on this reference spot
+    f = objective_function(
+        resolution_z=resolution_z,
+        resolution_yx=resolution_yx,
+        sigma_z=None,
+        sigma_yx=None,
+        psf_amplitude=None)
+    p0 = [centroid_z, centroid_y, centroid_x, psf_z, psf_yx, amplitude,
+          background]
+    popt, pcov = fit_gaussian_3d(f, grid, reference_spot, p0)
+
+    # get reference parameters
+    sigma_z = popt[3]
+    sigma_yx = popt[4]
+    amplitude = popt[5]
+    background = popt[6]
+
+    # use connected components to detect potential foci
+    cc = get_cc(image_filtered_log, threshold_spot)
+    regions_filtered, spots_out_foci = filter_cc(
+        image_filtered_background,
+        cc,
+        spots,
+        min_area=min_area,
+        min_nb_spots=min_nb_spots,
+        min_intensity_factor=min_intensity_factor)
+
+    # case where no foci where detected
+    if regions_filtered.size == 0:
+        spots_in_foci = np.array([], dtype=np.int64).reshape((0, 2))
+        foci = []
+        return spots, spots_in_foci, foci, reference_spot
+
+    # precompute gaussian function values
+    table_erf_z, table_erf_y, table_erf_x = precompute_erf(
+        resolution_z,
+        resolution_yx,
+        sigma_z,
+        sigma_yx,
+        max_grid=200)
+    precomputed_gaussian = (table_erf_z, table_erf_y, table_erf_x)
+
+    # fit gaussian mixtures in the foci regions
+    spots_in_foci = []
+    foci = []
+    for region in regions_filtered:
+        (image_region,
+         best_simulation,
+         pos_gaussian) = fit_gaussian_mixture(
+            image_filtered_background,
+            region,
+            resolution_z,
+            resolution_yx,
+            sigma_z,
+            sigma_yx,
+            amplitude,
+            background,
+            precomputed_gaussian)
+
+        # get coordinates of spots and foci in the original image
+        foci_diameter = region.equivalent_diameter
+        box = region.bbox
+        (min_z, min_y, min_x, _, _, _) = box
+        pos_gaussian = np.array(pos_gaussian, dtype=np.float64)
+        pos_gaussian[:, 0] = (pos_gaussian[:, 0] / resolution_z) + min_z
+        pos_gaussian[:, 1] = (pos_gaussian[:, 1] / resolution_yx) + min_y
+        pos_gaussian[:, 2] = (pos_gaussian[:, 2] / resolution_yx) + min_x
+        pos_gaussian = pos_gaussian.astype(np.int64)
+        centroid_region = tuple(pos_gaussian[0])
+        nb_rna_foci = pos_gaussian.shape[0]
+        foci.append((centroid_region, nb_rna_foci, foci_diameter / 2))
+        spots_in_foci.append(pos_gaussian)
+
+    spots_in_foci = np.concatenate(spots_in_foci, axis=0)
+
+    return spots_out_foci, spots_in_foci, foci, reference_spot
diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index 957e6e91..e91da884 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -136,6 +136,7 @@ def spots_thresholding(image, sigma, mask_lm, threshold):
         Mask with shape (z, y, x) or (y, x) indicating the spots.
 
     """
+    # TODO make 'radius' output more consistent
     # check parameters
     stack.check_array(image,
                       ndim=[2, 3],
@@ -224,7 +225,7 @@ def get_cc(image, threshold):
     stack.check_array(image,
                       ndim=[2, 3],
                       dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
+                      allow_nan=True)
     stack.check_parameter(threshold=(float, int))
 
     # Compute binary mask of the filtered image
@@ -246,8 +247,7 @@ def filter_cc(image, cc, spots, min_area, min_nb_spots, min_intensity_factor):
     cc : np.ndarray, np.int64
         Image labelled with shape (z, y, x) or (y, x).
     spots : np.ndarray, np.int64
-        Coordinate of the spots with shape (nb_spots, 3) or (nb_spots, 2)
-        for 3-d or 2-d images respectively.
+        Coordinate of the spots with shape (nb_spots, 3).
     min_area : int
         Minimum number of pixels in the connected region.
     min_nb_spots : int
@@ -260,8 +260,8 @@ def filter_cc(image, cc, spots, min_area, min_nb_spots, min_intensity_factor):
     -------
     regions_filtered : np.ndarray
         Array with filtered skimage.measure._regionprops._RegionProperties.
-    cc_filtered : np.ndarray, np.int64
-        Image labelled with shape (z, y, x) or (y, x).
+    spots_out_region : np.ndarray, np.int64
+        Coordinate of the spots outside the regions with shape (nb_spots, 3).
 
     """
     # TODO manage the difference between 2-d and 3-d data
@@ -270,19 +270,18 @@ def filter_cc(image, cc, spots, min_area, min_nb_spots, min_intensity_factor):
     stack.check_array(image,
                       ndim=[2, 3],
                       dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
+                      allow_nan=True)
     stack.check_array(cc,
                       ndim=[2, 3],
                       dtype=[np.int64],
-                      allow_nan=False)
+                      allow_nan=True)
     stack.check_array(spots,
                       ndim=2,
                       dtype=[np.int64],
-                      allow_nan=False)
+                      allow_nan=True)
     stack.check_parameter(min_area=int,
                           min_nb_spots=int,
-                          min_intensity_factor=(float, int),
-                          return_cc=bool)
+                          min_intensity_factor=(float, int))
 
     # get properties of the different connected regions
     regions = regionprops(cc, intensity_image=image, cache=True)
@@ -291,53 +290,75 @@ def filter_cc(image, cc, spots, min_area, min_nb_spots, min_intensity_factor):
     area = []
     intensity = []
     bbox = []
-    label = []
     for i, region in enumerate(regions):
         area.append(region.area)
         intensity.append(region.max_intensity)
         bbox.append(region.bbox)
-        label.append(region.label)
     regions = np.array(regions)
     area = np.array(area)
     intensity = np.array(intensity)
     bbox = np.array(bbox)
-    label = np.array(label)
 
-    # TODO make this part faster
-    # keep regions with a minimum number of spots
+    # keep regions with a minimum size
+    big_area = area > min_area
+    regions = regions[big_area]
+    intensity = intensity[big_area]
+    bbox = bbox[big_area]
+
+    # case where no region big enough were detected
+    if regions.size == 0:
+        regions_filtered = np.array([])
+        spots_out_region = np.array([], dtype=np.int64).reshape((0, 2))
+        return regions_filtered, spots_out_region
+
+    # TODO remove copy()?
+    # count spots in the regions
     nb_spots_in = []
     for box in bbox:
         (min_z, min_y, min_x, max_z, max_y, max_x) = box
+        mask_spots_in = spots[:, 0] <= max_z
+        mask_spots_in = (mask_spots_in & (spots[:, 1] <= max_y))
+        mask_spots_in = (mask_spots_in & (spots[:, 2] <= max_x))
+        mask_spots_in = (mask_spots_in & (min_z <= spots[:, 0]))
+        mask_spots_in = (mask_spots_in & (min_y <= spots[:, 1]))
+        mask_spots_in = (mask_spots_in & (min_x <= spots[:, 2]))
         spots_in = spots.copy()
-        spots_in = spots_in[spots_in[:, 0] <= max_z]
-        spots_in = spots_in[spots_in[:, 1] <= max_y]
-        spots_in = spots_in[spots_in[:, 2] <= max_x]
-        spots_in = spots_in[min_z <= spots_in[:, 0]]
-        spots_in = spots_in[min_y <= spots_in[:, 1]]
-        spots_in = spots_in[min_x <= spots_in[:, 2]]
+        spots_in = spots_in[mask_spots_in]
         nb_spots_in.append(spots_in.shape[0])
+
+    # keep regions with a minimum number of spots
     nb_spots_in = np.array(nb_spots_in)
     multiple_spots = nb_spots_in > min_nb_spots
 
     # keep regions which reach a minimum intensity value
     high_intensity = intensity > np.median(intensity) * min_intensity_factor
 
-    # keep regions with a minimum size
-    big_area = area > min_area
-
     # filter regions and labels
-    mask = (multiple_spots + high_intensity) * big_area
+    mask = multiple_spots | high_intensity
     regions_filtered = regions[mask]
-    labels_filtered = label[mask]
+    bbox = bbox[mask]
 
-    # filter the cc image
-    mask_cc = np.zeros_like(cc).astype(bool)
-    for i in labels_filtered:
-        mask_cc = (mask_cc | (cc == i))
-    cc_filtered = cc.copy()
-    cc_filtered[~mask_cc] = 0
+    # case where no foci were detected
+    if regions.size == 0:
+        spots_out_region = np.array([], dtype=np.int64).reshape((0, 2))
+        return regions_filtered, spots_out_region
 
-    return regions_filtered, cc_filtered
+    # TODO make it in a separate function
+    # count spots outside the regions
+    mask_spots_out = np.ones(spots[:, 0].shape, dtype=bool)
+    for box in bbox:
+        (min_z, min_y, min_x, max_z, max_y, max_x) = box
+        mask_spots_in = spots[:, 0] <= max_z
+        mask_spots_in = (mask_spots_in & (spots[:, 1] <= max_y))
+        mask_spots_in = (mask_spots_in & (spots[:, 2] <= max_x))
+        mask_spots_in = (mask_spots_in & (min_z <= spots[:, 0]))
+        mask_spots_in = (mask_spots_in & (min_y <= spots[:, 1]))
+        mask_spots_in = (mask_spots_in & (min_x <= spots[:, 2]))
+        mask_spots_out = mask_spots_out & (~mask_spots_in)
+    spots_out_region = spots.copy()
+    spots_out_region = spots_out_region[mask_spots_out]
+
+    return regions_filtered, spots_out_region
 
 
 # ### Signal-to-Noise ratio ###

From 6b17928a753b68ac49c9f411a49146d8c318a55a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:37:48 +0200
Subject: [PATCH 189/264] add features

---
 bigfish/classification/__init__.py |   3 +-
 bigfish/classification/features.py | 444 +++++++++++++++++++++++++++++
 bigfish/stack/postprocess.py       |   0
 3 files changed, 446 insertions(+), 1 deletion(-)
 create mode 100644 bigfish/classification/features.py
 create mode 100644 bigfish/stack/postprocess.py

diff --git a/bigfish/classification/__init__.py b/bigfish/classification/__init__.py
index b7276b76..2855eb38 100644
--- a/bigfish/classification/__init__.py
+++ b/bigfish/classification/__init__.py
@@ -6,8 +6,9 @@
 """
 
 from .squeezenet import SqueezeNet0
+from .features import get_features, get_features_name
 
 # ### Load models ###
 
 
-__all__ = ["SqueezeNet0"]
+__all__ = ["SqueezeNet0", "get_features", "get_features_name"]
diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
new file mode 100644
index 00000000..172b0d4e
--- /dev/null
+++ b/bigfish/classification/features.py
@@ -0,0 +1,444 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions to craft features.
+"""
+
+from bigfish import stack
+
+import numpy as np
+from scipy import ndimage as ndi
+
+from skimage.measure import regionprops
+from skimage.morphology import binary_opening
+from skimage.morphology.selem import disk
+
+from scipy.spatial import distance_matrix
+from scipy.stats import spearmanr
+
+
+def from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord):
+    """
+
+    Parameters
+    ----------
+    cyt_coord
+    nuc_coord
+    rna_coord
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get size of the frame
+    max_y = cyt_coord[:, 0].max() + 1
+    max_x = cyt_coord[:, 1].max() + 1
+    image_shape = (max_y, max_x)
+
+    # cytoplasm
+    cyt = np.zeros(image_shape, dtype=bool)
+    cyt[cyt_coord[:, 0], cyt_coord[:, 1]] = True
+
+    # nucleus
+    nuc = np.zeros(image_shape, dtype=bool)
+    nuc[nuc_coord[:, 0], nuc_coord[:, 1]] = True
+
+    # rna
+    rna = np.zeros(image_shape, dtype=bool)
+    rna[rna_coord[:, 0], rna_coord[:, 1]] = True
+
+    return cyt, nuc, rna
+
+
+def get_centroid(mask):
+    """
+
+    Parameters
+    ----------
+    mask
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get centroid
+    region = regionprops(mask.astype(np.uint8))[0]
+    centroid = np.array(region.centroid, dtype=np.int64)
+
+    return centroid
+
+
+def get_centroid_distance_map(centroid_coordinate, mask_cyt):
+    """
+
+    Parameters
+    ----------
+    centroid_coordinate
+    mask_cyt
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get mask centroid
+    mask_centroid = np.zeros_like(mask_cyt)
+    mask_centroid[centroid_coordinate[0], centroid_coordinate[1]] = True
+
+    # compute distance map
+    distance_map = ndi.distance_transform_edt(~mask_centroid)
+    distance_map = distance_map.astype(np.float32)
+
+    return distance_map
+
+
+def features_distance(mask_rna, distance_cyt, distance_nuc,
+                      distance_cyt_centroid, distance_nuc_centroid):
+    """
+
+    Parameters
+    ----------
+    mask_rna
+    distance_cyt
+    distance_nuc
+    distance_cyt_centroid
+    distance_nuc_centroid
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute average distances to cytoplasm and quantiles
+    factor = distance_cyt[distance_cyt > 0].mean()
+    mean_distance_cyt = distance_cyt[mask_rna].mean() / factor
+    quantile_5_distance_cyt = np.percentile(distance_cyt[mask_rna], 5)
+    quantile_5_distance_cyt /= factor
+    quantile_10_distance_cyt = np.percentile(distance_cyt[mask_rna], 10)
+    quantile_10_distance_cyt /= factor
+    quantile_20_distance_cyt = np.percentile(distance_cyt[mask_rna], 20)
+    quantile_20_distance_cyt /= factor
+    quantile_50_distance_cyt = np.percentile(distance_cyt[mask_rna], 50)
+    quantile_50_distance_cyt /= factor
+
+    # compute average distances to cytoplasm centroid
+    factor = distance_cyt_centroid[distance_cyt > 0].mean()
+    mean_distance_cyt_centroid = distance_cyt_centroid[mask_rna].mean()
+    mean_distance_cyt_centroid /= factor
+
+    # compute average distances to nucleus
+    factor = distance_nuc[distance_cyt > 0].mean()
+    mean_distance_nuc = distance_nuc[mask_rna].mean() / factor
+
+    # compute average distances to nucleus centroid
+    factor = distance_nuc_centroid[distance_cyt > 0].mean()
+    mean_distance_nuc_centroid = distance_nuc_centroid[mask_rna].mean()
+    mean_distance_nuc_centroid /= factor
+
+    features = [mean_distance_cyt, quantile_5_distance_cyt,
+                quantile_10_distance_cyt, quantile_20_distance_cyt,
+                quantile_50_distance_cyt, mean_distance_cyt_centroid,
+                mean_distance_nuc, mean_distance_nuc_centroid]
+
+    return features
+
+
+def feature_in_out_nucleus(mask_nuc, distance_nuc, mask_rna):
+    """
+
+    Parameters
+    ----------
+    mask_nuc
+    distance_nuc
+    mask_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute the ratio between rna in and out nucleus
+    rna_in = mask_rna[mask_nuc].sum()
+    rna_out = mask_rna[distance_nuc > 0].sum()
+    feature = rna_in / rna_out
+
+    return feature
+
+
+def features_opening(opening_sizes, mask_cyt, mask_rna):
+    """
+
+    Parameters
+    ----------
+    opening_sizes
+    mask_cyt
+    mask_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get number of rna
+    nb_rna = mask_rna.sum()
+
+    # apply opening operator and count the loss of rna
+    features = []
+    for size in opening_sizes:
+        s = disk(size, dtype=bool)
+        mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
+        nb_rna__after_opening = mask_rna[mask_cyt_transformed > 0].sum()
+        diff_opening = (nb_rna - nb_rna__after_opening) / nb_rna
+        features.append(diff_opening)
+
+    return features
+
+
+def ripley_values(radii, mask_cyt, rna_coord, mask_rna):
+    """
+
+    Parameters
+    ----------
+    radii
+    mask_cyt
+    rna_coord
+    mask_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # sort rna coordinates
+    sorted_indices = np.lexsort((rna_coord[:, 1], rna_coord[:, 0]))
+    rna_coord = rna_coord[sorted_indices]
+
+    # compute distance matrix between rna and rna density
+    distances = distance_matrix(rna_coord, rna_coord, p=2)
+    factor = len(rna_coord) ** 2 / mask_cyt.sum()
+
+    # cast cytoplasm mask in np.uint8
+    mask_cyt_8bit = stack.cast_img_uint8(mask_cyt)
+
+    # for each radius, get neighbors and weight
+    values = []
+    for r in radii:
+        mask_distance = distances.copy()
+        mask_distance = mask_distance <= r
+        nb_neighbors = np.sum(mask_distance, axis=0) - 1
+        weights = stack.mean_filter(mask_cyt_8bit, kernel_shape="disk",
+                                    kernel_size=r)
+        weights = weights.astype(np.float32) / 255.
+        rna_weights = weights[mask_rna]
+        nb_neighbors_weighted = np.multiply(nb_neighbors, rna_weights)
+        value = nb_neighbors_weighted.sum() / factor
+        values.append(value)
+    values = np.array(values, dtype=np.float32)
+    values_corrected = np.sqrt(values / np.pi) - np.array(radii)
+
+    return values_corrected
+
+
+def moving_average(a, n=4):
+    """
+
+    Parameters
+    ----------
+    a
+    n
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    res = np.cumsum(a, dtype=np.float32)
+    res[n:] = res[n:] - res[:-n]
+    averaged_array = res[n - 1:] / n
+
+    return averaged_array
+
+
+def features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
+    """
+
+    Parameters
+    ----------
+    radii
+    cyt_coord
+    mask_cyt
+    rna_coord
+    mask_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute corrected Ripley values for different radii
+    values = ripley_values(radii, mask_cyt, rna_coord, mask_rna)
+
+    # smooth them using moving average
+    smoothed_values = moving_average(values, n=4)
+
+    # compute the gradients of these values
+    gradients = np.gradient(smoothed_values)
+
+    # compute features
+    index_max = np.argmax(smoothed_values)
+    max_value = smoothed_values[index_max]
+    if index_max == 0:
+        max_gradient = gradients[0]
+    else:
+        max_gradient = max(gradients[:index_max])
+    if index_max == len(gradients) - 1:
+        min_gradient = gradients[-1]
+    else:
+        min_gradient = min(gradients[index_max:])
+    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
+    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
+    max_size_cell = np.max(distances_cell)
+    big_radius = int(max_size_cell / 4)
+    big_value = ripley_values([big_radius], mask_cyt, rna_coord, mask_rna)[0]
+    features = [max_value, max_gradient, min_gradient, monotony, big_value]
+
+    return features
+
+
+def feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna):
+    """
+
+    Parameters
+    ----------
+    distance_cyt
+    distance_cyt_centroid
+    rna_coord
+    centroid_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute polarization index
+    factor = np.mean(distance_cyt_centroid[distance_cyt > 0])
+    distance_rna_cell = distance_cyt_centroid[centroid_rna[0], centroid_rna[1]]
+    feature = distance_rna_cell / factor
+
+    return feature
+
+
+def feature_dispersion(cyt_coord, rna_coord, centroid_rna):
+    """
+
+    Parameters
+    ----------
+    cyt_coord
+    rna_coord
+    centroid_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute dispersion index
+    sigma_rna = np.sum((rna_coord - centroid_rna) ** 2, axis=0)
+    sigma_rna = np.sum(sigma_rna / len(rna_coord))
+    sigma_cell = np.sum((cyt_coord - centroid_rna) ** 2, axis=0)
+    sigma_cell = np.sum(sigma_cell / len(cyt_coord))
+    feature = sigma_rna / sigma_cell
+
+    return feature
+
+
+def get_features(cyt_coord, nuc_coord, rna_coord):
+    """Compute cell features.
+
+    Parameters
+    ----------
+    cyt_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    nuc_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    rna_coord : np.ndarray, np.int64
+        Coordinate yx of the detected rna with shape (nb_rna, 2).
+
+    Returns
+    -------
+    features : List[float]
+        List of features (cf. features.get_features_name()).
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # TODO filter features
+    # get a binary representation of the coordinates
+    cyt, nuc, mask_rna = from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord)
+
+    # fill in masks
+    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
+
+    # compute distance maps for the cytoplasm and the nucleus
+    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
+
+    # get centroids
+    centroid_cyt = get_centroid(mask_cyt)
+    centroid_nuc = get_centroid(mask_nuc)
+    centroid_rna = np.mean(rna_coord, axis=0, dtype=np.int64)
+
+    # get centroid distance maps
+    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
+    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+
+    # compute features
+    a = features_distance(mask_rna, distance_cyt, distance_nuc,
+                          distance_cyt_centroid, distance_nuc_centroid)
+    b = feature_in_out_nucleus(mask_nuc, distance_nuc, mask_rna)
+    opening_sizes = [15, 30, 45, 60]
+    c = features_opening(opening_sizes, mask_cyt, mask_rna)
+    radii = [r for r in range(40)]
+    d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
+    e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
+    f = feature_dispersion(cyt_coord, rna_coord, centroid_rna)
+    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
+
+    return features
+
+
+def get_features_name():
+    """Return the current list of features names.
+
+    Returns
+    -------
+    features_name : List[str]
+        List of features name returned by features.get_features().
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # TODO filter features
+    features_name = ["average_dist_cyt", "quantile_5_dist_cyt",
+                     "quantile_10_dist_cyt", "quantile_20_dist_cyt",
+                     "quantile_50_dist_cyt", "average_dist_cyt_centroid",
+                     "average_dist_nuc", "average_dist_nuc_centroid",
+                     "ratio_in_out_nuc", "diff_opening_15", "diff_opening_30",
+                     "diff_opening_45", "diff_opening_60", "ripley_max",
+                     "ripley_max_gradient", "ripley_min_gradient",
+                     "ripley_monotony", "ripley_large", "polarization_index",
+                     "dispersion_index"]
+
+    return features_name
diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
new file mode 100644
index 00000000..e69de29b

From 962e2faae3f267f6d716f2245c1ec59598a545a6 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:38:43 +0200
Subject: [PATCH 190/264] add binary dilation

---
 bigfish/stack/__init__.py | 17 +++++++++-----
 bigfish/stack/filter.py   | 47 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 6 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 81d5ea28..d2b10e69 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,19 +17,21 @@
                          deconstruct_image, reconstruct_image)
 from .filter import (log_filter, mean_filter, median_filter, maximum_filter,
                      minimum_filter, gaussian_filter, remove_background_mean,
-                     remove_background_gaussian)
+                     remove_background_gaussian, dilation)
 from .projection import (maximum_projection, mean_projection,
                          median_projection, in_focus_selection,
                          focus_measurement, get_in_focus_indices,
                          focus_projection, focus_projection_fast)
 from .illumination import (compute_illumination_surface,
                            correct_illumination_surface)
+from .postprocess import (remove_transcription_site, extract_spots,
+                          extract_coordinates_image)
 from .preparation import (split_from_background, build_image, get_coordinates,
                           get_distance_layers, get_surface_layers, build_batch,
                           get_label, Generator, encode_labels, get_map_label,
                           format_experimental_data, get_label_encoder,
-                          remove_transcription_site, filter_data, balance_data,
-                          get_gene_encoder)
+                          remove_transcription_site_bis, filter_data,
+                          balance_data, get_gene_encoder)
 from .augmentation import augment
 
 
@@ -48,7 +50,7 @@
 
 _filter = ["log_filter", "mean_filter", "median_filter", "maximum_filter",
            "minimum_filter", "gaussian_filter", "remove_background_mean",
-           "remove_background_gaussian"]
+           "remove_background_gaussian", "dilation"]
 
 _projection = ["maximum_projection", "mean_projection", "median_projection",
                "in_focus_selection", "focus_measurement",
@@ -58,15 +60,18 @@
 _illumination = ["compute_illumination_surface",
                  "correct_illumination_surface"]
 
+_postprocess = ["remove_transcription_site", "extract_spots",
+                "extract_coordinates_image"]
+
 _augmentation = ["augment"]
 
 _preparation = ["split_from_background", "build_image", "get_coordinates",
                 "get_distance_layers", "get_surface_layers", "build_batch",
                 "get_label", "Generator", "encode_labels", "get_map_label",
                 "format_experimental_data", "get_label_encoder",
-                "remove_transcription_site", "filter_data", "balance_data",
+                "remove_transcription_site_bis", "filter_data", "balance_data",
                 "get_gene_encoder"]
 
-__all__ = (_utils + _io + _preprocess +
+__all__ = (_utils + _io + _preprocess + _postprocess +
            _filter + _projection + _illumination +
            _augmentation + _preparation)
diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
index 2235225a..be82c4a4 100644
--- a/bigfish/stack/filter.py
+++ b/bigfish/stack/filter.py
@@ -9,6 +9,7 @@
                          cast_img_uint16)
 
 from skimage.morphology.selem import square, diamond, rectangle, disk
+from skimage.morphology import binary_dilation, dilation
 from skimage.filters import rank, gaussian
 
 from scipy.ndimage import gaussian_laplace
@@ -396,3 +397,49 @@ def remove_background_gaussian(image, sigma):
                                       dtype=image.dtype)
 
     return image_no_background
+
+
+def dilation(image, kernel_shape=None, kernel_size=None):
+    """Apply a dilation to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint
+        Filtered 2-d image with shape (y, x).
+
+    """
+    # TODO check dtype
+    # check parameters
+    check_array(image,
+                ndim=2,
+                dtype=[np.uint8, np.uint16, bool],
+                allow_nan=False)
+    check_parameter(kernel_shape=(str, type(None)),
+                    kernel_size=(int, tuple, list, type(None)))
+
+    # get kernel
+    if kernel_shape is None or kernel_size is None:
+        kernel = None
+    else:
+        kernel = _define_kernel(shape=kernel_shape,
+                                size=kernel_size,
+                                dtype=image.dtype)
+
+    # apply filter
+    if image.dtype == bool:
+        image_filtered = binary_dilation(image, kernel)
+    else:
+        image_filtered = dilation(image, kernel)
+
+    return image_filtered

From 61874f86348aee3f03c1eba8dfd384190fa3dec0 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:39:58 +0200
Subject: [PATCH 191/264] refactor foci manipulation (np.ndarray)

---
 bigfish/detection/gaussian_fit.py   | 81 +++++++++++++++++++----------
 bigfish/detection/spot_detection.py |  1 +
 2 files changed, 55 insertions(+), 27 deletions(-)

diff --git a/bigfish/detection/gaussian_fit.py b/bigfish/detection/gaussian_fit.py
index 8c3e17bd..f960e37f 100644
--- a/bigfish/detection/gaussian_fit.py
+++ b/bigfish/detection/gaussian_fit.py
@@ -241,7 +241,7 @@ def build_reference_spot_3d(image, spots, radius, method="median"):
 
     Parameters
     ----------
-    image : np.ndarray,
+    image : np.ndarray
         Image with shape (z, y, x).
     spots : np.ndarray, np.int64
         Coordinate of the spots with shape (nb_spots, 3).
@@ -915,25 +915,48 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
 
     Parameters
     ----------
-    image_filtered_log
-    image_filtered_background
-    threshold_spot
-    spots
-    radius
-    min_area
-    min_nb_spots
-    min_intensity_factor
-    resolution_z
-    resolution_yx
-    psf_z
-    psf_yx
+    image_filtered_log : np.ndarray
+        Image with shape (z, y, x) and filter with LoG operator.
+    image_filtered_background : np.ndarray
+        Image with shape (z, y, x) and filter with gaussian operator to
+        estimate then remove background.
+    threshold_spot : float or int
+        A threshold to detect spots.
+    spots : np.ndarray, np.int64
+        Coordinate of the spots with shape (nb_spots, 3).
+    radius : Tuple[float]
+        Radius of the detected peaks, one for each dimension.
+    min_area : int
+        Minimum number of pixels in the connected region.
+    min_nb_spots : int
+        Minimum number of spot detected in this region.
+    min_intensity_factor : int or float
+        Minimum pixel intensity in the connected region is equal to
+        median(intensity) * min_intensity_factor.
+    resolution_z : int or float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : int or float
+        Size of a voxel on the yx plan, in nanometer.
+    psf_z : int or float
+        Theoretical height of the spot PSF along the z axis, in nanometer.
+    psf_yx : int or float
+        Theoretical diameter of the spot PSF on the yx plan, in nanometer.
 
     Returns
     -------
-    spots_out_foci
-    spots_in_foci
-    foci
-    reference_spot
+    spots_out_foci : np.ndarray, np.int64
+        Coordinate of the spots detected out of foci, with shape (nb_spots, 3).
+        One coordinate per dimension (zyx coordinates).
+    spots_in_foci : np.ndarray, np.int64
+        Coordinate of the spots detected inside foci, with shape (nb_spots, 4).
+        One coordinate per dimension (zyx coordinates) plus the index of the
+        foci.
+    foci : np.ndarray, np.int64
+        Array with shape (nb_foci, 5). One coordinate per dimension for the
+        foci centroid (zyx coordinates), the number of RNAs detected in the
+        foci and its index.
+    reference_spot : np.ndarray
+        Reference spot with shape (2*radius_z+1, 2*radius_y+1, 2*radius_x+1).
 
     """
     # check parameters
@@ -961,7 +984,9 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
 
     # case where no spot were detected
     if spots.size == 0:
-        foci = []
+        spots_out_foci = np.array([], dtype=np.int64).reshape((0, 3))
+        spots_in_foci = np.array([], dtype=np.int64).reshape((0, 4))
+        foci = np.array([], dtype=np.float32).reshape((0, 5))
         radius_z = int(radius[0]) + 1
         radius_yx = int(radius[1]) + 1
         z_shape = radius_z * 2 + 1
@@ -969,7 +994,7 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
         reference_spot = np.zeros((z_shape, yx_shape, yx_shape),
                                   dtype=image_filtered_background.dtype)
 
-        return spots, spots, foci, reference_spot
+        return spots_out_foci, spots_in_foci, foci, reference_spot
 
     # build a reference median spot
     reference_spot = build_reference_spot_3d(
@@ -1018,8 +1043,8 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
 
     # case where no foci where detected
     if regions_filtered.size == 0:
-        spots_in_foci = np.array([], dtype=np.int64).reshape((0, 2))
-        foci = []
+        spots_in_foci = np.array([], dtype=np.int64).reshape((0, 4))
+        foci = np.array([], dtype=np.float32).reshape((0, 5))
         return spots, spots_in_foci, foci, reference_spot
 
     # precompute gaussian function values
@@ -1034,7 +1059,7 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
     # fit gaussian mixtures in the foci regions
     spots_in_foci = []
     foci = []
-    for region in regions_filtered:
+    for i_foci, region in enumerate(regions_filtered):
         (image_region,
          best_simulation,
          pos_gaussian) = fit_gaussian_mixture(
@@ -1049,19 +1074,21 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
             precomputed_gaussian)
 
         # get coordinates of spots and foci in the original image
-        foci_diameter = region.equivalent_diameter
         box = region.bbox
         (min_z, min_y, min_x, _, _, _) = box
         pos_gaussian = np.array(pos_gaussian, dtype=np.float64)
         pos_gaussian[:, 0] = (pos_gaussian[:, 0] / resolution_z) + min_z
         pos_gaussian[:, 1] = (pos_gaussian[:, 1] / resolution_yx) + min_y
         pos_gaussian[:, 2] = (pos_gaussian[:, 2] / resolution_yx) + min_x
-        pos_gaussian = pos_gaussian.astype(np.int64)
-        centroid_region = tuple(pos_gaussian[0])
+        spots_in_foci_ = np.zeros((pos_gaussian.shape[0], 4), dtype=np.int64)
+        spots_in_foci_[:, :3] = pos_gaussian
+        spots_in_foci_[:, 3] = i_foci
+        spots_in_foci.append(spots_in_foci_)
+        foci_z, foci_y, foci_x = tuple(pos_gaussian[0])
         nb_rna_foci = pos_gaussian.shape[0]
-        foci.append((centroid_region, nb_rna_foci, foci_diameter / 2))
-        spots_in_foci.append(pos_gaussian)
+        foci.append([foci_z, foci_y, foci_x, nb_rna_foci, i_foci])
 
     spots_in_foci = np.concatenate(spots_in_foci, axis=0)
+    foci = np.array(foci, dtype=np.int64)
 
     return spots_out_foci, spots_in_foci, foci, reference_spot
diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index e91da884..a5ee0b7b 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -513,6 +513,7 @@ def get_sigma(resolution_z=300, resolution_yx=103, psf_z=400, psf_yx=200):
     sigma_xy : float
         Standard deviation of the PSF, along the yx plan, in pixel.
     """
+    # TODO rename "resolution"
     # compute sigma
     sigma_z = psf_z / resolution_z
     sigma_yx = psf_yx / resolution_yx

From 589804554540c644c28dd967643f5fe36343c185 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:40:33 +0200
Subject: [PATCH 192/264] misc

---
 bigfish/stack/preparation.py | 34 ++++++++++++++++++----------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index ae77724b..28301072 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -23,6 +23,7 @@
 # TODO define the requirements for 'data'
 # TODO add logging
 # TODO generalize the use of 'get_offset_value'
+# TODO move the script to the classification submodule
 
 # ### Split data ###
 
@@ -243,7 +244,7 @@ def get_gene_encoder(genes_str):
     return encoder_gene
 
 
-# ### Build images ###
+# ### Build images from coordinates ###
 
 def build_image(data, id_cell, image_shape=None, coord_refinement=True,
                 method="normal", augmentation=False):
@@ -440,24 +441,22 @@ def get_distance_layers(cyt, nuc):
     Parameters
     ----------
     cyt : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
+        A 2-d binary image with shape (y, x).
     nuc : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
+        A 2-d binary image with shape (y, x).
 
     Returns
     -------
     distance_cyt : np.ndarray, np.float32
-        A 2-d tensor with shape (x, y) showing distance to the cytoplasm
+        A 2-d tensor with shape (y, x) showing distance to the cytoplasm
         border.
     distance_nuc : np.ndarray, np.float32
-        A 2-d tensor with shape (x, y) showing distance to the nucleus border.
+        A 2-d tensor with shape (y, x) showing distance to the nucleus border.
 
     """
     # TODO can return NaN
     # compute surfaces from cytoplasm and nucleus
-    mask_cyt, mask_nuc = get_surface_layers(cyt, nuc)
-    mask_cyt = mask_cyt.astype(np.bool)
-    mask_nuc = mask_nuc.astype(np.bool)
+    mask_cyt, mask_nuc = get_surface_layers(cyt, nuc, cast_float=False)
 
     # compute distances from cytoplasm and nucleus
     distance_cyt = ndi.distance_transform_edt(mask_cyt)
@@ -471,7 +470,7 @@ def get_distance_layers(cyt, nuc):
     return distance_cyt, distance_nuc
 
 
-def get_surface_layers(cyt, nuc):
+def get_surface_layers(cyt, nuc, cast_float=True):
     """Compute plain surface layers as input for the model.
 
     Sometimes the border is too fragmented to compute the surface. In this
@@ -481,17 +480,19 @@ def get_surface_layers(cyt, nuc):
     Parameters
     ----------
     cyt : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
+        A 2-d binary image with shape (y, x).
     nuc : np.ndarray, np.float32
-        A 2-d binary image with shape (x, y).
+        A 2-d binary image with shape (y, x).
+    cast_float : bool
+        Cast output in np.float32.
 
     Returns
     -------
     surface_cyt : np.ndarray, np.float32
-        A 2-d binary tensor with shape (x, y) showing cytoplasm surface.
+        A 2-d binary tensor with shape (y, x) showing cytoplasm surface.
         border.
     surface_nuc : np.ndarray, np.float32
-        A 2-d binary tensor with shape (x, y) showing nucleus surface.
+        A 2-d binary tensor with shape (y, x) showing nucleus surface.
 
         """
     # compute surface from cytoplasm and nucleus
@@ -499,8 +500,9 @@ def get_surface_layers(cyt, nuc):
     surface_nuc = ndi.binary_fill_holes(nuc)
 
     # cast to np.float32
-    surface_cyt = cast_img_float32(surface_cyt)
-    surface_nuc = cast_img_float32(surface_nuc)
+    if cast_float:
+        surface_cyt = cast_img_float32(surface_cyt)
+        surface_nuc = cast_img_float32(surface_nuc)
 
     return surface_cyt, surface_nuc
 
@@ -890,7 +892,7 @@ def _label_experimental_num_to_str_(label_num):
     return label_str
 
 
-def remove_transcription_site(data, threshold):
+def remove_transcription_site_bis(data, threshold):
     # TODO add documentation
     # TODO vectorize it
     data_corrected = data.copy(deep=True)

From d38d0cca117c1423de206003a31ea2eb4ee8a0a4 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:41:08 +0200
Subject: [PATCH 193/264] add postprocess cell extraction

---
 bigfish/stack/postprocess.py | 269 +++++++++++++++++++++++++++++++++++
 1 file changed, 269 insertions(+)

diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index e69de29b..264f0356 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -0,0 +1,269 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions used to format and clean any input loaded in bigfish.
+"""
+
+import numpy as np
+
+from .utils import check_array, check_parameter
+
+from skimage.segmentation import find_boundaries
+from skimage.measure import regionprops
+
+
+# ### Transcription sites ###
+
+def remove_transcription_site(mask_nuc, spots_in_foci, foci):
+    """We define a transcription site as a foci detected in the nucleus.
+
+    Parameters
+    ----------
+    mask_nuc : np.ndarray, bool
+        Binary mask of the nuclei with shape (y, x).
+    spots_in_foci : np.ndarray, np.int64
+        Coordinate of the spots detected inside foci, with shape (nb_spots, 4).
+        One coordinate per dimension (zyx coordinates) plus the index of the
+        foci.
+    foci : np.ndarray, np.int64
+        Array with shape (nb_foci, 5). One coordinate per dimension for the
+        foci centroid (zyx coordinates), the number of RNAs detected in the
+        foci and its index.
+
+    Returns
+    -------
+    spots_in_foci_cleaned : np.ndarray, np.int64
+        Coordinate of the spots detected inside foci, with shape (nb_spots, 4).
+        One coordinate per dimension (zyx coordinates) plus the index of the
+        foci. Transcription sites are removed.
+    foci_cleaned : np.ndarray, np.int64
+        Array with shape (nb_foci, 5). One coordinate per dimension for the
+        foci centroid (zyx coordinates), the number of RNAs detected in the
+        foci and its index. Transcription sites are removed.
+
+    """
+    # check parameters
+    check_array(mask_nuc,
+                ndim=2,
+                dtype=[bool],
+                allow_nan=False)
+    check_array(spots_in_foci,
+                ndim=2,
+                dtype=[np.int64],
+                allow_nan=False)
+    check_array(foci,
+                ndim=2,
+                dtype=[np.int64],
+                allow_nan=False)
+
+    # remove foci inside nuclei
+    foci_cleaned = foci.copy()
+    spots_in_foci_cleaned = spots_in_foci.copy()
+    for (_, y, x, _, i_foci) in foci:
+        if mask_nuc[y, x]:
+            foci_cleaned = foci_cleaned[foci_cleaned[:, 4] != i_foci]
+            spots_in_foci_cleaned = spots_in_foci_cleaned[
+                spots_in_foci_cleaned[:, 3] != i_foci]
+
+    return spots_in_foci_cleaned, foci_cleaned
+
+
+# ### Cell extraction ###
+
+def extract_spots(spots, z_lim=None, y_lim=None, x_lim=None):
+    """Get spots coordinates within a given frame.
+
+    Parameters
+    ----------
+    spots : np.ndarray, np.int64
+        Coordinate of the spots detected inside foci, with shape (nb_spots, 3)
+        or (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus
+        the index of the foci if necessary.
+    z_lim : tuple[int, int]
+        Minimum and maximum coordinate of the frame along the z axis.
+    y_lim : tuple[int, int]
+        Minimum and maximum coordinate of the frame along the y axis.
+    x_lim : tuple[int, int]
+        Minimum and maximum coordinate of the frame along the x axis.
+
+    Returns
+    -------
+    extracted_spots : np.ndarray, np.int64
+        Coordinate of the spots detected inside foci, with shape (nb_spots, 3)
+        or (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus
+        the index of the foci if necessary.
+
+    """
+    # check parameters
+    check_array(spots,
+                ndim=2,
+                dtype=[np.int64],
+                allow_nan=False)
+    check_parameter(z_lim=(tuple, type(None)),
+                    y_lim=(tuple, type(None)),
+                    x_lim=(tuple, type(None)))
+
+    # extract spots
+    extracted_spots = spots.copy()
+    if z_lim is not None:
+        extracted_spots = extracted_spots[extracted_spots[:, 0] < z_lim[1]]
+        extracted_spots = extracted_spots[z_lim[0] < extracted_spots[:, 0]]
+        extracted_spots[:, 0] -= z_lim[0]
+    if y_lim is not None:
+        extracted_spots = extracted_spots[extracted_spots[:, 1] < y_lim[1]]
+        extracted_spots = extracted_spots[y_lim[0] < extracted_spots[:, 1]]
+        extracted_spots[:, 1] -= y_lim[0]
+    if x_lim is not None:
+        extracted_spots = extracted_spots[extracted_spots[:, 2] < x_lim[1]]
+        extracted_spots = extracted_spots[x_lim[0] < extracted_spots[:, 2]]
+        extracted_spots[:, 2] -= x_lim[0]
+
+    return extracted_spots
+
+
+def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
+                              foci):
+    """Extract relevant coordinates from an image, based on segmentation and
+    detection results.
+
+    For each cell in an image we return the coordinates of the cytoplasm, the
+    nucleus, the RNA spots and information about the detected foci. We extract
+    2-d coordinates.
+
+    Parameters
+    ----------
+    cyt_labelled : np.ndarray, np.uint or np.int
+        Labelled cytoplasms image with shape (y, x).
+    nuc_labelled : np.ndarray, np.uint or np.int
+        Labelled nuclei image with shape (y, x).
+    spots_out : np.ndarray, np.int64
+        Coordinate of the spots detected outside foci, with shape (nb_spots, 3).
+        One coordinate per dimension (zyx coordinates).
+    spots_in : np.ndarray, np.int64
+        Coordinate of the spots detected inside foci, with shape (nb_spots, 4).
+        One coordinate per dimension (zyx coordinates) plus the index of the
+        foci.
+    foci : np.ndarray, np.int64
+        Array with shape (nb_foci, 5). One coordinate per dimension for the
+        foci centroid (zyx coordinates), the number of RNAs detected in the
+        foci and its index.
+
+    Returns
+    -------
+    results : List[(cyt_coord, nuc_coord, rna_coord, cell_foci, cell)]
+        - cyt_coord : np.ndarray, np.int64
+            Coordinates of the cytoplasm border with shape (nb_points, 2).
+        - nuc_coord : np.ndarray, np.int64
+            Coordinates of the nuclei border with shape (nb_points, 2).
+        - rna_coord : np.ndarray, np.int64
+            Coordinates of the RNA spots with shape (nb_spots, 3). One
+            coordinate per dimension (yx dimension), plus the index of a
+            potential foci.
+        - cell_foci : np.ndarray, np.int64
+            Array with shape (nb_foci, 5). One coordinate per dimension for the
+            foci centroid (zyx coordinates), the number of RNAs detected in the
+            foci and its index.
+        - cell : skimage.measure._regionprops._RegionProperties
+            Various properties of the cell.
+
+    """
+    # TODO implement several smaller functions
+    # check parameters
+    check_array(cyt_labelled,
+                ndim=2,
+                dtype=[np.uint8, np.uint16, np.int64],
+                allow_nan=True)
+    check_array(nuc_labelled,
+                ndim=2,
+                dtype=[np.uint8, np.uint16, np.int64],
+                allow_nan=True)
+    check_array(spots_out,
+                ndim=2,
+                dtype=[np.int64],
+                allow_nan=False)
+    check_array(spots_in,
+                ndim=2,
+                dtype=[np.int64],
+                allow_nan=False)
+    check_array(foci,
+                ndim=2,
+                dtype=[np.int64],
+                allow_nan=False)
+
+    # initialize results
+    results = []
+    borders = np.zeros(cyt_labelled.shape, dtype=bool)
+    borders[:, 0] = True
+    borders[0, :] = True
+    borders[:, cyt_labelled.shape[1]-1] = True
+    borders[cyt_labelled.shape[0]-1, :] = True
+    cells = regionprops(cyt_labelled)
+    for cell in cells:
+
+        # get information about the cell
+        label = cell.label
+        (min_y, min_x, max_y, max_x) = cell.bbox
+
+        # get masks of the cell
+        cyt = cyt_labelled.copy()
+        cyt = (cyt == label)
+        nuc = nuc_labelled.copy()
+        nuc = (nuc == label)
+
+        # check cell is not cropped by the borders
+        crop = cyt & borders
+        if np.any(crop):
+            continue
+
+        # check nucleus is in the cytoplasm
+        diff = cyt | nuc
+        if np.any(diff != cyt):
+            continue
+
+        # get boundaries coordinates
+        cyt_coord = find_boundaries(cyt, mode='inner')
+        cyt_coord = np.nonzero(cyt_coord)
+        cyt_coord = np.column_stack(cyt_coord)
+        nuc_coord = find_boundaries(nuc, mode='inner')
+        nuc_coord = np.nonzero(nuc_coord)
+        nuc_coord = np.column_stack(nuc_coord)
+
+        # filter foci
+        cell_foci = foci.copy()
+        cell_spots_in = spots_in.copy()
+        for (_, y, x, _, i_foci) in foci:
+            if cyt_labelled[y, x] != label:
+                cell_foci = cell_foci[cell_foci[:, 4] != i_foci]
+                cell_spots_in = cell_spots_in[cell_spots_in[:, 3] != i_foci]
+
+        # get rna coordinates
+        image_shape = cyt_labelled.shape
+        rna_out = np.zeros(image_shape, dtype=bool)
+        rna_out[spots_out[:, 1], spots_out[:, 2]] = True
+        rna_out = (rna_out & cyt)
+        rna_out = np.nonzero(rna_out)
+        rna_out = np.column_stack(rna_out)
+        rna_in = np.zeros(image_shape, dtype=bool)
+        rna_in[cell_spots_in[:, 1], cell_spots_in[:, 2]] = True
+        rna_in = (rna_in & cyt)
+        rna_in = np.nonzero(rna_in)
+        rna_in = np.column_stack(rna_in)
+        rna_coord = np.concatenate([rna_out, rna_in], axis=0)
+
+        # filter cell without enough spots
+        if len(rna_coord) < 30:
+            continue
+
+        # initialize cell coordinates
+        cyt_coord[:, 0] -= min_y
+        cyt_coord[:, 1] -= min_x
+        nuc_coord[:, 0] -= min_y
+        nuc_coord[:, 1] -= min_x
+        rna_coord[:, 0] -= min_y
+        rna_coord[:, 1] -= min_x
+        cell_foci[:, 1] -= min_y
+        cell_foci[:, 2] -= min_x
+
+        results.append((cyt_coord, nuc_coord, rna_coord, cell_foci, cell))
+
+    return results

From a4f7e1f2ac76e3f87b2ad9dd21eb2560024f1ef9 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:43:04 +0200
Subject: [PATCH 194/264] improve plot foci decomposition

---
 bigfish/plot/plot_images.py | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 6d29f3ed..474b818d 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -622,8 +622,9 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
         A 2-d tensor with shape (y, x).
     spots : np.ndarray, np.int64
         Coordinate of the spots with shape (nb_spots, 3).
-    foci : List[tuple]
-        Coordinate of the foci with shape (nb_spots, 3).
+    foci : np.ndarray, np.int64
+        Array with shape (nb_foci, 5). One coordinate per dimension (zyx
+        coordinates), number of RNAs in the foci and index of the foci.
     radius_spots_yx : float or int
         Radius yx of the detected spots.
     rescale : bool
@@ -645,6 +646,7 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
 
     """
     # TODO check coordinates shape
+    # TODO allow a plot for a specific z-slice
     # check parameters
     stack.check_array(tensor,
                       ndim=2,
@@ -655,8 +657,11 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
                       ndim=2,
                       dtype=[np.int64],
                       allow_nan=False)
-    stack.check_parameter(foci=list,
-                          radius_spots_yx=(float, int),
+    stack.check_array(foci,
+                      ndim=2,
+                      dtype=[np.int64],
+                      allow_nan=False)
+    stack.check_parameter(radius_spots_yx=(float, int),
                           rescale=bool,
                           title=(str, type(None)),
                           framesize=tuple,
@@ -687,16 +692,14 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
         ax[1].imshow(tensor, vmin=vmin, vmax=vmax)
     else:
         ax[1].imshow(tensor)
-    for spot_coordinate in spots:
-        _, y, x = spot_coordinate
+    for (_, y, x) in spots:
         c = plt.Circle((x, y), radius_spots_yx,
                        color="red",
                        linewidth=1,
                        fill=False)
         ax[1].add_patch(c)
-    for (foci_coordinates, nb_rna, radius_foci) in foci:
-        _, y, x = foci_coordinates
-        c = plt.Circle((x, y), radius_foci,
+    for (_, y, x, _, _) in foci:
+        c = plt.Circle((x, y), radius_spots_yx * 2,
                        color="blue",
                        linewidth=2,
                        fill=False)

From b23cd4be5ee79f9d045477626870f1453eadd445 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:43:27 +0200
Subject: [PATCH 195/264] add plot cell extraction

---
 bigfish/plot/plot_coordinates.py | 335 ++++++++++++++++++++++++++++++-
 1 file changed, 334 insertions(+), 1 deletion(-)

diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
index 39ee9e02..dad93aad 100644
--- a/bigfish/plot/plot_coordinates.py
+++ b/bigfish/plot/plot_coordinates.py
@@ -8,7 +8,10 @@
 import matplotlib.pyplot as plt
 import numpy as np
 
-from .utils import save_plot
+from .utils import save_plot, get_minmax_values
+
+from skimage.segmentation import find_boundaries
+from matplotlib.colors import ListedColormap
 
 
 def plot_volume(data_cell, id_cell, framesize=(7, 7), path_output=None,
@@ -235,3 +238,333 @@ def plot_layers_coordinates(layers, titles=None, framesize=(5, 10),
     plt.show()
 
     return
+
+
+def plot_extraction_image(results, remove_frame=False, title=None,
+                          framesize=None, path_output=None, ext="png"):
+    """Plot or subplot of 2-d coordinates extracted from an image.
+
+    Parameters
+    ----------
+    results : List[(cyt_coord, nuc_coord, rna_coord, cell_foci, cell)]
+        - cyt_coord : np.ndarray, np.int64
+            Coordinates of the cytoplasm border with shape (nb_points, 2).
+        - nuc_coord : np.ndarray, np.int64
+            Coordinates of the nuclei border with shape (nb_points, 2).
+        - rna_coord : np.ndarray, np.int64
+            Coordinates of the RNA spots with shape (nb_spots, 3). One
+            coordinate per dimension (yx dimension), plus the index of a
+            potential foci.
+        - cell_foci : np.ndarray, np.int64
+            Array with shape (nb_foci, 5). One coordinate per dimension for the
+            foci centroid (zyx coordinates), the number of RNAs detected in the
+            foci and its index.
+        - cell : skimage.measure._regionprops._RegionProperties
+            Various properties of the cell.
+    remove_frame : bool
+        Remove axes and frame.
+    title : str
+        Title of the image.
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # check parameters
+    stack.check_parameter(results=list,
+                          remove_frame=bool,
+                          title=(str, type(None)),
+                          framesize=(tuple, type(None)),
+                          path_output=(str, type(None)),
+                          ext=(str, list))
+
+    # we plot 3 images by row maximum
+    nrow = int(np.ceil(len(results)/3))
+    ncol = min(len(results), 3)
+    if framesize is None:
+        framesize = (5 * ncol, 5 * nrow)
+
+    # plot one image
+    marge = stack.get_offset_value()
+    if len(results) == 1:
+        cyt, nuc, rna, foci, cell = results[0]
+        if remove_frame:
+            fig = plt.figure(figsize=(8, 8), frameon=False)
+            ax = fig.add_axes([0, 0, 1, 1])
+            ax.axis('off')
+        else:
+            plt.figure(figsize=(8, 8))
+        plt.xlim(-marge, max(cyt[:, 1]) + marge)
+        plt.ylim(max(cyt[:, 0]) + marge, -marge)
+        plt.scatter(cyt[:, 1], cyt[:, 0], c="black", s=5, marker=".")
+        plt.scatter(nuc[:, 1], nuc[:, 0], c="steelblue", s=5, marker=".")
+        plt.scatter(rna[:, 1], rna[:, 0], c="firebrick", s=50, marker="x")
+        if len(foci) > 0:
+            plt.scatter(foci[:, 2], foci[:, 1], c="chartreuse", s=60,
+                        marker="D")
+        if title is not None and not remove_frame:
+            title_plot = title + "_cell_0"
+            plt.title(title_plot, fontweight="bold", fontsize=25)
+        if not remove_frame:
+            plt.tight_layout()
+        if path_output is not None:
+            save_plot(path_output, ext)
+        plt.show()
+
+        return
+
+    # plot multiple images
+    fig, ax = plt.subplots(nrow, ncol, figsize=framesize)
+
+    # one row
+    if len(results) in [2, 3]:
+        for i, (cyt, nuc, rna, foci, cell) in enumerate(results):
+            if remove_frame:
+                ax[i].axis("off")
+            ax[i].set_xlim(-marge, max(cyt[:, 1]) + marge)
+            ax[i].set_ylim(max(cyt[:, 0]) + marge, -marge)
+            ax[i].scatter(cyt[:, 1], cyt[:, 0], c="black", s=5, marker=".")
+            ax[i].scatter(nuc[:, 1], nuc[:, 0], c="steelblue", s=5, marker=".")
+            ax[i].scatter(rna[:, 1], rna[:, 0], c="firebrick", s=50,
+                          marker="x")
+            if len(foci) > 0:
+                ax[i].scatter(foci[:, 2], foci[:, 1], c="chartreuse", s=60,
+                              marker="D")
+            if title is not None:
+                title_plot = title + "_cell_{0}".format(i)
+                ax[i].set_title(title_plot, fontweight="bold", fontsize=10)
+
+    # several rows
+    else:
+        # we complete the row with empty frames
+        r = nrow * 3 - len(results)
+        results_completed = [(cyt, nuc, rna, foci, cell)
+                             for (cyt, nuc, rna, foci, cell) in results]
+        results_completed += [None] * r
+        for i, result in enumerate(results_completed):
+            row = i // 3
+            col = i % 3
+            if result is None:
+                ax[row, col].set_visible(False)
+                continue
+            else:
+                cyt, nuc, rna, foci, cell = result
+            if remove_frame:
+                ax[row, col].axis("off")
+            ax[row, col].set_xlim(-marge, max(cyt[:, 1]) + marge)
+            ax[row, col].set_ylim(max(cyt[:, 0]) + marge, -marge)
+            ax[row, col].scatter(cyt[:, 1], cyt[:, 0], c="black", s=5,
+                                 marker=".")
+            ax[row, col].scatter(nuc[:, 1], nuc[:, 0], c="steelblue", s=5,
+                                 marker=".")
+            ax[row, col].scatter(rna[:, 1], rna[:, 0], c="firebrick", s=50,
+                                 marker="x")
+            if len(foci) > 0:
+                ax[row, col].scatter(foci[:, 2], foci[:, 1], c="chartreuse",
+                                     s=60, marker="D")
+            if title is not None:
+                title_plot = title + "_cell_{0}".format(i)
+                ax[row, col].set_title(title_plot,
+                                       fontweight="bold", fontsize=10)
+
+    plt.tight_layout()
+    if path_output is not None:
+        save_plot(path_output, ext)
+    plt.show()
+
+    return
+
+
+def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
+              image_cyt=None, mask_cyt=None, mask_nuc=None, count_rna=False,
+              title=None, remove_frame=False, rescale=False,
+              framesize=(15, 10), path_output=None, ext="png"):
+    """
+
+    Parameters
+    ----------
+    cyt_coord : np.ndarray, np.int64
+        Coordinates of the cytoplasm border with shape (nb_points, 2).
+    nuc_coord : np.ndarray, np.int64
+        Coordinates of the nuclei border with shape (nb_points, 2).
+    rna_coord : np.ndarray, np.int64
+        Coordinates of the RNA spots with shape (nb_spots, 3). One
+        coordinate per dimension (yx dimension), plus the index of a
+        potential foci.
+    foci_coord : np.ndarray, np.int64
+        Array with shape (nb_foci, 5). One coordinate per dimension for the
+        foci centroid (zyx coordinates), the number of RNAs detected in the
+        foci and its index.
+    image_cyt : np.ndarray, np.uint
+        Original image of the cytoplasm.
+    mask_cyt : np.ndarray, np.uint
+        Mask of the cytoplasm.
+    mask_nuc : np.ndarray, np.uint
+        Mask of the nucleus.
+    count_rna : bool
+        Display the number of RNAs in a foci.
+    title : str
+        Title of the image.
+    remove_frame : bool
+        Remove axes and frame.
+    rescale : bool
+        Rescale pixel values of the image (made by default in matplotlib).
+    framesize : tuple
+        Size of the frame used to plot with 'plt.figure(figsize=framesize)'.
+    path_output : str
+        Path to save the image (without extension).
+    ext : str or List[str]
+        Extension used to save the plot. If it is a list of strings, the plot
+        will be saved several times.
+
+    Returns
+    -------
+
+    """
+    # check parameters
+    stack.check_array(cyt_coord,
+                      ndim=2,
+                      dtype=[np.int64],
+                      allow_nan=False)
+    if nuc_coord is not None:
+        stack.check_array(nuc_coord,
+                          ndim=2,
+                          dtype=[np.int64],
+                          allow_nan=False)
+    if rna_coord is not None:
+        stack.check_array(rna_coord,
+                          ndim=2,
+                          dtype=[np.int64],
+                          allow_nan=False)
+    if foci_coord is not None:
+        stack.check_array(foci_coord,
+                          ndim=2,
+                          dtype=[np.int64],
+                          allow_nan=False)
+    if image_cyt is not None:
+        stack.check_array(image_cyt,
+                          ndim=2,
+                          dtype=[np.uint8, np.uint16, np.int64],
+                          allow_nan=True)
+    if mask_cyt is not None:
+        stack.check_array(mask_cyt,
+                          ndim=2,
+                          dtype=[np.uint8, np.uint16, np.int64, bool],
+                          allow_nan=True)
+    if mask_nuc is not None:
+        stack.check_array(mask_nuc,
+                          ndim=2,
+                          dtype=[np.uint8, np.uint16, np.int64, bool],
+                          allow_nan=True)
+    stack.check_parameter(count_rna=bool,
+                          title=(str, type(None)),
+                          remove_frame=bool,
+                          rescale=bool,
+                          framesize=tuple,
+                          path_output=(str, type(None)),
+                          ext=(str, list))
+    if title is None:
+        title = ""
+    else:
+        title = " ({0})".format(title)
+
+    # get shape of image built from coordinates
+    max_y = cyt_coord[:, 0].max() + 1
+    max_x = cyt_coord[:, 1].max() + 1
+    image_shape = (max_y, max_x)
+
+    # get cytoplasm layer
+    cyt = np.zeros(image_shape, dtype=bool)
+    cyt[cyt_coord[:, 0], cyt_coord[:, 1]] = True
+
+    # get nucleus layer
+    nuc = np.zeros(image_shape, dtype=bool)
+    if nuc_coord is not None:
+        nuc[nuc_coord[:, 0], nuc_coord[:, 1]] = True
+
+    # get rna layer
+    rna = np.zeros(image_shape, dtype=bool)
+    if rna_coord is not None:
+        rna[rna_coord[:, 0], rna_coord[:, 1]] = True
+        rna = stack.dilation(rna, kernel_shape="square", kernel_size=3)
+
+    # get foci layer
+    foci = np.zeros(image_shape, dtype=bool)
+    if foci_coord is not None:
+        foci[foci_coord[:, 1], foci_coord[:, 2]] = True
+        foci = stack.dilation(foci, kernel_shape="square", kernel_size=6)
+
+    # build image coordinate
+    image_coord = np.ones((max_y, max_x, 3), dtype=np.float32)
+    image_coord[cyt, :] = [0, 0, 0]  # black
+    image_coord[nuc, :] = [0, 102 / 255, 204 / 255]  # blue
+    image_coord[rna, :] = [204 / 255, 0, 0]  # red
+    image_coord[foci, :] = [102 / 255, 204 / 255, 0]  # green
+
+    # plot original and coordinate image
+    if image_cyt is not None:
+        fig, ax = plt.subplots(1, 2, sharex='col', figsize=framesize)
+
+        # original image
+        if remove_frame:
+            ax[0].axis("off")
+        if not rescale:
+            vmin, vmax = get_minmax_values(image_cyt)
+            ax[0].imshow(image_cyt, vmin=vmin, vmax=vmax)
+        else:
+            ax[0].imshow(image_cyt)
+        if mask_cyt is not None:
+            boundaries_cyt = find_boundaries(mask_cyt, mode='inner')
+            boundaries_cyt = np.ma.masked_where(boundaries_cyt == 0,
+                                                boundaries_cyt)
+            ax[0].imshow(boundaries_cyt, cmap=ListedColormap(['red']))
+        if mask_nuc is not None:
+            boundaries_nuc = find_boundaries(mask_nuc, mode='inner')
+            boundaries_nuc = np.ma.masked_where(boundaries_nuc == 0,
+                                                boundaries_nuc)
+            ax[0].imshow(boundaries_nuc, cmap=ListedColormap(['blue']))
+        ax[0].set_title("Original image" + title,
+                        fontweight="bold", fontsize=10)
+
+        # coordinate image
+        if remove_frame:
+            ax[1].axis("off")
+        ax[1].imshow(image_coord)
+        if count_rna:
+            for (_, y, x, nb_rna, _) in foci_coord:
+                ax[1].text(x+5, y-5, str(nb_rna), color="#66CC00", size=20)
+        ax[1].set_title("Coordinate image" + title,
+                        fontweight="bold", fontsize=10)
+
+        plt.tight_layout()
+
+    # plot coordinate image only
+    else:
+        if remove_frame:
+            fig = plt.figure(figsize=framesize, frameon=False)
+            ax = fig.add_axes([0, 0, 1, 1])
+            ax.axis('off')
+        else:
+            plt.figure(figsize=framesize)
+            plt.title("Coordinate image" + title,
+                      fontweight="bold", fontsize=25)
+        plt.imshow(image_coord)
+        if count_rna:
+            for (_, y, x, nb_rna, _) in foci_coord:
+                plt.text(x+5, y-5, str(nb_rna), color="#66CC00", size=20)
+
+        if not remove_frame:
+            plt.tight_layout()
+
+    if path_output is not None:
+        save_plot(path_output, ext)
+    plt.show()
+
+    return

From 958a52ea03c9c368f506df0af8c49bccc07b9a16 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:43:47 +0200
Subject: [PATCH 196/264] add plot cell extraction #2

---
 bigfish/plot/__init__.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index a9e639ec..87c8e9a9 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -9,7 +9,8 @@
                           plot_illumination_surface,
                           plot_segmentation_boundary, plot_foci_decomposition)
 from .plot_coordinates import (plot_volume, plot_rna, plot_distribution_rna,
-                               plot_cell_coordinates, plot_layers_coordinates)
+                               plot_cell_coordinates, plot_layers_coordinates,
+                               plot_extraction_image, plot_cell)
 from .plot_classification import plot_confusion_matrix, plot_2d_projection
 
 
@@ -19,7 +20,8 @@
            "plot_foci_decomposition"]
 
 _coordinates = ["plot_volume", "plot_rna", "plot_distribution_rna",
-                "plot_cell_coordinates", "plot_layers_coordinates"]
+                "plot_cell_coordinates", "plot_layers_coordinates",
+                "plot_extraction_image", "plot_cell"]
 
 _classification = ["plot_confusion_matrix", "plot_2d_projection"]
 

From 13c3f477fd5cfc05f39624c4bdb3fe517934792e Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:44:29 +0200
Subject: [PATCH 197/264] allow new input dtype

---
 bigfish/stack/io.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/bigfish/stack/io.py b/bigfish/stack/io.py
index 0da925f3..e9ba924b 100644
--- a/bigfish/stack/io.py
+++ b/bigfish/stack/io.py
@@ -21,7 +21,7 @@ def read_image(path):
     """Read an image with the .png, .tif or .tiff extension.
 
     The input image should be in 2-d or 3-d, with unsigned integer 8 or 16
-    bits.
+    bits, integer
 
     Parameters
     ----------
@@ -30,15 +30,18 @@ def read_image(path):
 
     Returns
     -------
-    tensor : ndarray, np.uint
+    tensor : ndarray, np.uint or np.int
         A 2-d or 3-d tensor with spatial dimensions.
 
     """
+    # TODO allow more input dtype
     # read image
     tensor = io.imread(path)
 
     # check the image is in unsigned integer 16 bits with 2 or 3 dimensions
-    check_array(tensor, dtype=[np.uint8, np.uint16], ndim=[2, 3])
+    check_array(tensor,
+                dtype=[np.uint8, np.uint16, np.int64],
+                ndim=[2, 3])
 
     return tensor
 

From 071e55e620d3642ee55165ad42779a99042edc31 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:45:10 +0200
Subject: [PATCH 198/264] misc

---
 bigfish/stack/utils.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 30b25e07..2f474348 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -539,6 +539,8 @@ def complete_coordinates_2d(list_coord):
 
     Returns
     -------
+    list_coord_completed : List[np.array]
+        List of the completed coordinates arrays, with shape (nb_points, 2).
 
     """
     # TODO improve documentation
@@ -576,6 +578,7 @@ def from_coord_to_image(coord, image_shape=None):
         Binary matrix plotting the coordinates values.
 
     """
+    # TODO improve integration with the segmentation/detection part
     # build matrices
     if image_shape is None:
         max_x = coord[:, 0].max() + 5

From 5ad2cbea1ed78771ffa68368f2998341d6e6a637 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 5 Jul 2019 18:45:55 +0200
Subject: [PATCH 199/264] misc

---
 bigfish/segmentation/cyt_segmentation.py |  5 +++--
 bigfish/segmentation/nuc_segmentation.py | 11 ++++++-----
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/bigfish/segmentation/cyt_segmentation.py b/bigfish/segmentation/cyt_segmentation.py
index 8c2de62e..f9761489 100644
--- a/bigfish/segmentation/cyt_segmentation.py
+++ b/bigfish/segmentation/cyt_segmentation.py
@@ -153,7 +153,7 @@ def cyt_watershed(relief, nuc_labelled, mask):
     ----------
     relief : np.ndarray, np.uint
         Relief image of the cytoplasm with shape (y, x).
-    nuc_labelled : np.ndarray
+    nuc_labelled : np.ndarray, np.int64
         Result of the nuclei segmentation with shape (y, x).
     mask : np.ndarray, bool
         Binary mask of the cytoplasm with shape (y, x).
@@ -165,6 +165,7 @@ def cyt_watershed(relief, nuc_labelled, mask):
         (y, x).
 
     """
+    # TODO how to be sure nucleus label corresponds to cell label?
     # check parameters
     stack.check_array(relief,
                       ndim=2,
@@ -172,7 +173,7 @@ def cyt_watershed(relief, nuc_labelled, mask):
                       allow_nan=False)
     stack.check_array(nuc_labelled,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool],
+                      dtype=[np.uint8, np.uint16, np.int64],
                       allow_nan=False)
     stack.check_array(mask,
                       ndim=2,
diff --git a/bigfish/segmentation/nuc_segmentation.py b/bigfish/segmentation/nuc_segmentation.py
index 60a300a7..8bfffb1d 100644
--- a/bigfish/segmentation/nuc_segmentation.py
+++ b/bigfish/segmentation/nuc_segmentation.py
@@ -51,9 +51,9 @@ def filtered_threshold(image, kernel_shape="disk", kernel_size=200,
 
     """
     # remove background noise from image
-    image = stack.remove_background(image,
-                                    kernel_shape=kernel_shape,
-                                    kernel_size=kernel_size)
+    image = stack.remove_background_mean(image,
+                                         kernel_shape=kernel_shape,
+                                         kernel_size=kernel_size)
 
     # discriminate nuclei from background, applying a threshold.
     image_segmented = image >= threshold
@@ -77,7 +77,7 @@ def remove_segmented_nuc(image, mask, nuclei_size=2000):
     background pixels remain unchanged. However, pixels from the missing
     nuclei are partially reconstructed by the dilatation. This reconstructed
     image only differs from the original one where the nuclei have been missed.
-    3) We substract the reconstructed image from the original one.
+    3) We subtract the reconstructed image from the original one.
     4) From the few pixels kept and restored from the missing nuclei, we build
     a binary mask (dilatation, small object removal).
     5) We apply this mask to the original image to get the original pixel
@@ -103,6 +103,7 @@ def remove_segmented_nuc(image, mask, nuclei_size=2000):
     # TODO fix the dtype of the mask
     # TODO start from the original image to manage the potential rescaling
     # TODO improve the threshold
+    # TODO correct the word dilatation -> dilation
     # check parameters
     stack.check_array(image,
                       ndim=2,
@@ -128,7 +129,7 @@ def remove_segmented_nuc(image, mask, nuclei_size=2000):
     diff = image.copy()
     diff[dilated_mask == 0] = 0
 
-    # reconstruct the missing nuclei by dilatation
+    # reconstruct the missing nuclei by dilation
     s = disk(1)
     image_reconstructed = reconstruction(diff, image, selem=s)
     image_reconstructed = image_reconstructed.astype(original_dtype)

From 14976ab8d8bbc730c16f04ae618648332cefdc73 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 10 Jul 2019 11:46:26 +0200
Subject: [PATCH 200/264] misc

---
 bigfish/classification/features.py  | 1 +
 bigfish/detection/spot_detection.py | 4 ++++
 bigfish/stack/postprocess.py        | 2 ++
 requirements.txt                    | 1 +
 requirements_stable.txt             | 3 ++-
 setup.py                            | 1 +
 6 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 172b0d4e..ede86b8f 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -355,6 +355,7 @@ def feature_dispersion(cyt_coord, rna_coord, centroid_rna):
     """
     # TODO add sanity check functions
     # TODO add documentation
+    # TODO correct the formula
     # compute dispersion index
     sigma_rna = np.sum((rna_coord - centroid_rna) ** 2, axis=0)
     sigma_rna = np.sum(sigma_rna / len(rna_coord))
diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index a5ee0b7b..10a2b3c5 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -300,6 +300,7 @@ def filter_cc(image, cc, spots, min_area, min_nb_spots, min_intensity_factor):
     bbox = np.array(bbox)
 
     # keep regions with a minimum size
+    # TODO convert '>' in '>='
     big_area = area > min_area
     regions = regions[big_area]
     intensity = intensity[big_area]
@@ -315,6 +316,7 @@ def filter_cc(image, cc, spots, min_area, min_nb_spots, min_intensity_factor):
     # count spots in the regions
     nb_spots_in = []
     for box in bbox:
+        # TODO convert '<=' in '<'
         (min_z, min_y, min_x, max_z, max_y, max_x) = box
         mask_spots_in = spots[:, 0] <= max_z
         mask_spots_in = (mask_spots_in & (spots[:, 1] <= max_y))
@@ -327,10 +329,12 @@ def filter_cc(image, cc, spots, min_area, min_nb_spots, min_intensity_factor):
         nb_spots_in.append(spots_in.shape[0])
 
     # keep regions with a minimum number of spots
+    # TODO convert '>' in '>='
     nb_spots_in = np.array(nb_spots_in)
     multiple_spots = nb_spots_in > min_nb_spots
 
     # keep regions which reach a minimum intensity value
+    # TODO convert '>' in '>='
     high_intensity = intensity > np.median(intensity) * min_intensity_factor
 
     # filter regions and labels
diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index 264f0356..8d81e884 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -12,6 +12,8 @@
 from skimage.measure import regionprops
 
 
+# TODO use skimage.measure.find_contours
+
 # ### Transcription sites ###
 
 def remove_transcription_site(mask_nuc, spots_in_foci, foci):
diff --git a/requirements.txt b/requirements.txt
index e6533271..f27a3fbe 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,6 +7,7 @@ pip >= 18.1
 scikit-learn >= 0.20.2
 scikit-image >= 0.14.2
 scipy >= 1.2.0
+# tensorflow-gpu == 1.12.0, < 2.0
 tensorflow >= 1.12.0, < 2.0
 matplotlib >= 3.0.2
 pandas >= 0.24.0
diff --git a/requirements_stable.txt b/requirements_stable.txt
index 319656cf..5b9e2262 100644
--- a/requirements_stable.txt
+++ b/requirements_stable.txt
@@ -7,7 +7,8 @@ pip == 18.1
 scikit-learn == 0.20.2
 scikit-image == 0.14.2
 scipy == 1.2.0
-# tensorflow-gpu == 1.12.0
+# tensorflow-gpu == 1.12.0, < 2.0
+tensorflow >= 1.12.0, < 2.0
 matplotlib == 3.0.2
 pandas == 0.24.0
 joblib == 0.13.2
diff --git a/setup.py b/setup.py
index d99c1bfd..673f6775 100644
--- a/setup.py
+++ b/setup.py
@@ -16,6 +16,7 @@
       'scikit-learn',
       'scikit-image',
       'scipy',
+      'pandas',
       'tensorflow',
       'matplotlib',
       'joblib'

From 9803e59b5892e574e981daaa0a84efc77aef30d7 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 15 Jul 2019 16:34:33 +0200
Subject: [PATCH 201/264] update requirements

---
 requirements.txt        |  3 ++-
 requirements_stable.txt |  7 ++++---
 setup.py                | 18 ++++++++++--------
 3 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index f27a3fbe..c61c48da 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -11,4 +11,5 @@ scipy >= 1.2.0
 tensorflow >= 1.12.0, < 2.0
 matplotlib >= 3.0.2
 pandas >= 0.24.0
-joblib >= 0.13.2
+numba >= 0.37.0
+umap >= 0.1.1
diff --git a/requirements_stable.txt b/requirements_stable.txt
index 5b9e2262..37d2d0cc 100644
--- a/requirements_stable.txt
+++ b/requirements_stable.txt
@@ -7,8 +7,9 @@ pip == 18.1
 scikit-learn == 0.20.2
 scikit-image == 0.14.2
 scipy == 1.2.0
-# tensorflow-gpu == 1.12.0, < 2.0
-tensorflow >= 1.12.0, < 2.0
+# tensorflow-gpu == 1.12.0
+tensorflow == 1.12.0
 matplotlib == 3.0.2
 pandas == 0.24.0
-joblib == 0.13.2
+numba == 0.37.0
+umap == 0.1.1
diff --git a/setup.py b/setup.py
index 673f6775..b5a6e4b2 100644
--- a/setup.py
+++ b/setup.py
@@ -12,14 +12,16 @@
 
 # Package abstract dependencies
 REQUIRES = [
-      'numpy',
-      'scikit-learn',
-      'scikit-image',
-      'scipy',
-      'pandas',
-      'tensorflow',
-      'matplotlib',
-      'joblib'
+      'numpy >= 1.16.0',
+      'pip >= 18.1',
+      'scikit-learn >= 0.20.2',
+      'scikit-image >= 0.14.2',
+      'scipy >= 1.2.0',
+      'tensorflow >= 1.12.0, < 2.0',
+      'matplotlib >= 3.0.2',
+      'pandas >= 0.24.0',
+      'numba >= 0.37.0',
+      'umap >= 0.1.1'
 ]
 
 # Long description of the package

From d882e367bfc9e6a9aaacb0c2f2c16d71f51ac07c Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 15 Jul 2019 16:50:30 +0200
Subject: [PATCH 202/264] update requirements #2

---
 requirements.txt        | 2 +-
 requirements_stable.txt | 2 +-
 setup.py                | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index c61c48da..b087f8e5 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -12,4 +12,4 @@ tensorflow >= 1.12.0, < 2.0
 matplotlib >= 3.0.2
 pandas >= 0.24.0
 numba >= 0.37.0
-umap >= 0.1.1
+umap-learn >= 0.3.9
diff --git a/requirements_stable.txt b/requirements_stable.txt
index 37d2d0cc..09f556dd 100644
--- a/requirements_stable.txt
+++ b/requirements_stable.txt
@@ -12,4 +12,4 @@ tensorflow == 1.12.0
 matplotlib == 3.0.2
 pandas == 0.24.0
 numba == 0.37.0
-umap == 0.1.1
+umap-learn == 0.3.9
diff --git a/setup.py b/setup.py
index b5a6e4b2..d1bfb606 100644
--- a/setup.py
+++ b/setup.py
@@ -21,7 +21,7 @@
       'matplotlib >= 3.0.2',
       'pandas >= 0.24.0',
       'numba >= 0.37.0',
-      'umap >= 0.1.1'
+      'umap-learn >= 0.3.9'
 ]
 
 # Long description of the package

From 56bd00b547f775da1ee9fd4d677711362edf7316 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Jul 2019 16:45:18 +0200
Subject: [PATCH 203/264] misc

---
 ...ussian_fit.py => cluster_decomposition.py} | 334 ++++++++++++------
 bigfish/detection/foci_detection.py           |   0
 bigfish/stack/postprocess.py                  |  12 +-
 3 files changed, 242 insertions(+), 104 deletions(-)
 rename bigfish/detection/{gaussian_fit.py => cluster_decomposition.py} (80%)
 create mode 100644 bigfish/detection/foci_detection.py

diff --git a/bigfish/detection/gaussian_fit.py b/bigfish/detection/cluster_decomposition.py
similarity index 80%
rename from bigfish/detection/gaussian_fit.py
rename to bigfish/detection/cluster_decomposition.py
index f960e37f..3accce04 100644
--- a/bigfish/detection/gaussian_fit.py
+++ b/bigfish/detection/cluster_decomposition.py
@@ -1,16 +1,18 @@
 # -*- coding: utf-8 -*-
 
 """
-Functions to fit gaussian functions to the detected RNA spots.
+Functions to fit gaussian functions to the detected RNA spots, especially in
+clustered regions.
 """
 
 import bigfish.stack as stack
-from .spot_detection import get_sigma, get_cc, filter_cc
+from .spot_detection import get_sigma, get_cc
 
 import numpy as np
 
 from scipy.special import erf
 from scipy.optimize import curve_fit
+from skimage.measure import regionprops
 
 
 # TODO complete documentation methods
@@ -234,7 +236,7 @@ def precompute_erf(resolution_z, resolution_yx, sigma_z, sigma_yx,
     return table_erf_z, table_erf_y, table_erf_x
 
 
-# ### Spot parameter ###
+# ### Spot parameters ###
 
 def build_reference_spot_3d(image, spots, radius, method="median"):
     """Build a median or mean spot volume/surface as reference.
@@ -307,6 +309,7 @@ def build_reference_spot_3d(image, spots, radius, method="median"):
         return None
 
     # project the different spot images
+    # TODO np.stack or np.concatenate?
     l_reference_spot = np.stack(l_reference_spot, axis=0)
     if method == "mean":
         reference_spot = np.mean(l_reference_spot, axis=0)
@@ -803,14 +806,14 @@ def simulate_fitted_gaussian_3d(f, grid, popt, original_shape=None):
 def fit_gaussian_mixture(image, region, resolution_z, resolution_yx, sigma_z,
                          sigma_yx, amplitude, background,
                          precomputed_gaussian):
-    """Fit a mixture of gaussian to a potential foci region.
+    """Fit a mixture of gaussian to a potential clustered region.
 
     Parameters
     ----------
     image : np.ndarray, np.uint
         A 3-d image with detected spot and shape (z, y, x).
     region : skimage.measure._regionprops._RegionProperties
-        Properties of a foci region.
+        Properties of a clustered region.
     resolution_z : int or float
         Height of a voxel, along the z axis, in nanometer.
     resolution_yx : int or float
@@ -903,36 +906,199 @@ def fit_gaussian_mixture(image, region, resolution_z, resolution_yx, sigma_z,
     return image_region, best_simulation, positions_gaussian
 
 
-# ### Foci decomposition ###
+# ### Cluster decomposition ###
 
+def filter_clusters(image, cc, spots, min_area=2):
+    """Filter clustered regions (defined as connected component regions).
 
-def foci_decomposition(image_filtered_log, image_filtered_background,
-                       threshold_spot, spots, radius, min_area, min_nb_spots,
-                       min_intensity_factor, resolution_z=300,
-                       resolution_yx=103, psf_z=400, psf_yx=200):
-    """Detect regions with clustered spots (foci) and fit a mixture of
-    gaussian to them.
+    Parameters
+    ----------
+    image : np.ndarray
+        Image with shape (z, y, x) or (y, x).
+    cc : np.ndarray, np.int64
+        Image labelled with shape (z, y, x) or (y, x).
+    spots : np.ndarray, np.int64
+        Coordinate of the spots with shape (nb_spots, 3).
+    min_area : int
+        Minimum number of pixels in the connected region.
+
+    Returns
+    -------
+    regions_filtered : np.ndarray
+        Array with filtered skimage.measure._regionprops._RegionProperties.
+    spots_out_region : np.ndarray, np.int64
+        Coordinate of the spots outside the regions with shape (nb_spots, 3).
+    max_region_size : int
+        Maximum size of the regions.
+
+    """
+    # TODO manage the difference between 2-d and 3-d data
+    # get properties of the different connected regions
+    regions = regionprops(cc, intensity_image=image)
+
+    # get different features of the regions
+    area = []
+    intensity = []
+    bbox = []
+    for i, region in enumerate(regions):
+        area.append(region.area)
+        intensity.append(region.mean_intensity)
+        bbox.append(region.bbox)
+    regions = np.array(regions)
+    area = np.array(area)
+    intensity = np.array(intensity)
+    bbox = np.array(bbox)
+
+    # keep regions with a minimum size
+    big_area = area >= min_area
+    regions = regions[big_area]
+    intensity = intensity[big_area]
+    bbox = bbox[big_area]
+
+    # case where no region big enough were detected
+    if regions.size == 0:
+        regions_filtered = np.array([])
+        spots_out_region = np.array([], dtype=np.int64).reshape((0, 3))
+        return regions_filtered, spots_out_region
+
+    # TODO keep this step?
+    # keep the brightest regions
+    high_intensity = intensity >= np.median(intensity)
+    regions_filtered = regions[high_intensity]
+    bbox = bbox[high_intensity]
+
+    # case where no connected region were detected
+    if regions.size == 0:
+        spots_out_region = np.array([], dtype=np.int64).reshape((0, 2))
+        return regions_filtered, spots_out_region
+
+    # get information about regions
+    mask_spots_out = np.ones(spots[:, 0].shape, dtype=bool)
+    max_region_size = 0
+    for box in bbox:
+        (min_z, min_y, min_x, max_z, max_y, max_x) = box
+
+        # get the size of the biggest region
+        size_z = max_z - min_z
+        size_y = max_y - min_y
+        size_x = max_x - min_x
+        max_region_size = max(max_region_size, size_z, size_y, size_x)
+
+        # get coordinates of spots inside the region
+        mask_spots_in = spots[:, 0] < max_z
+        mask_spots_in = (mask_spots_in & (spots[:, 1] < max_y))
+        mask_spots_in = (mask_spots_in & (spots[:, 2] < max_x))
+        mask_spots_in = (mask_spots_in & (min_z <= spots[:, 0]))
+        mask_spots_in = (mask_spots_in & (min_y <= spots[:, 1]))
+        mask_spots_in = (mask_spots_in & (min_x <= spots[:, 2]))
+        mask_spots_out = mask_spots_out & (~mask_spots_in)
+
+    # keep apart spots inside a region
+    spots_out_region = spots.copy()
+    spots_out_region = spots_out_region[mask_spots_out]
+
+    return regions_filtered, spots_out_region, max_region_size
+
+
+def decompose_clusters(image, cluster_regions, resolution_z, resolution_yx,
+                       sigma_z, sigma_yx, amplitude, background,
+                       precomputed_gaussian):
+    """
+    Decompose clustered regions by fitting mixture of gaussians.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image with shape (z, y, x).
+    cluster_regions : np.ndarray
+        Array with filtered skimage.measure._regionprops._RegionProperties.
+    resolution_z : int or float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : int or float
+        Size of a voxel on the yx plan, in nanometer.
+    sigma_z : int or float
+        Theoretical height of the spot PSF along the z axis, in nanometer.
+    sigma_yx : int or float
+        Theoretical diameter of the spot PSF on the yx plan, in nanometer.
+    amplitude : int or float
+        Amplitude of the spot.
+    background : int of float
+        Background intensity level of the spot.
+    precomputed_gaussian : List[np.ndarray] or Tuple[np.ndarray]
+        Precomputed tables values of erf for the different axis.
+
+    Returns
+    -------
+    spots_in_cluster : np.ndarray, np.int64
+        Coordinate of the spots detected inside cluster, with shape
+        (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus the
+        index of the cluster.
+    clusters : np.ndarray, np.int64
+        Array with shape (nb_cluster, 7). One coordinate per dimension for the
+        cluster centroid (zyx coordinates), the number of RNAs detected in the
+        cluster, the area of the cluster region, its average intensity value
+        and its index.
+
+    """
+    # fit gaussian mixtures in the cluster regions
+    spots_in_cluster = []
+    clusters = []
+    for i_cluster, region in enumerate(cluster_regions):
+        (image_region,
+         best_simulation,
+         pos_gaussian) = fit_gaussian_mixture(
+            image,
+            region,
+            resolution_z,
+            resolution_yx,
+            sigma_z,
+            sigma_yx,
+            amplitude,
+            background,
+            precomputed_gaussian)
+
+        # get coordinates of spots and clusters in the original image
+        box = region.bbox
+        (min_z, min_y, min_x, _, _, _) = box
+        pos_gaussian = np.array(pos_gaussian, dtype=np.float64)
+        pos_gaussian[:, 0] = (pos_gaussian[:, 0] / resolution_z) + min_z
+        pos_gaussian[:, 1] = (pos_gaussian[:, 1] / resolution_yx) + min_y
+        pos_gaussian[:, 2] = (pos_gaussian[:, 2] / resolution_yx) + min_x
+        spots_in_cluster_ = np.zeros((pos_gaussian.shape[0], 4),
+                                     dtype=np.int64)
+        spots_in_cluster_[:, :3] = pos_gaussian
+        spots_in_cluster_[:, 3] = i_cluster
+        spots_in_cluster.append(spots_in_cluster_)
+        cluster_z, cluster_y, cluster_x = tuple(pos_gaussian[0])
+        nb_rna_cluster = pos_gaussian.shape[0]
+        cluster_area = region.area
+        cluster_intensity = region.mean_intensity
+        clusters.append([cluster_z, cluster_y, cluster_x, nb_rna_cluster,
+                         cluster_area, cluster_intensity, i_cluster])
+
+    spots_in_cluster = np.concatenate(spots_in_cluster, axis=0)
+    clusters = np.array(clusters, dtype=np.int64)
+
+    return spots_in_cluster, clusters
+
+
+def cluster_decomposition(image, spots, radius, min_area=2,
+                          resolution_z=300, resolution_yx=103, psf_z=400,
+                          psf_yx=200):
+    """Detect regions with clustered spots and fit a mixture of gaussians to
+    decompose them.
 
     Parameters
     ----------
-    image_filtered_log : np.ndarray
-        Image with shape (z, y, x) and filter with LoG operator.
-    image_filtered_background : np.ndarray
+    image : np.ndarray
         Image with shape (z, y, x) and filter with gaussian operator to
         estimate then remove background.
-    threshold_spot : float or int
-        A threshold to detect spots.
     spots : np.ndarray, np.int64
         Coordinate of the spots with shape (nb_spots, 3).
     radius : Tuple[float]
         Radius of the detected peaks, one for each dimension.
     min_area : int
         Minimum number of pixels in the connected region.
-    min_nb_spots : int
-        Minimum number of spot detected in this region.
-    min_intensity_factor : int or float
-        Minimum pixel intensity in the connected region is equal to
-        median(intensity) * min_intensity_factor.
     resolution_z : int or float
         Height of a voxel, along the z axis, in nanometer.
     resolution_yx : int or float
@@ -944,27 +1110,24 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
 
     Returns
     -------
-    spots_out_foci : np.ndarray, np.int64
-        Coordinate of the spots detected out of foci, with shape (nb_spots, 3).
-        One coordinate per dimension (zyx coordinates).
-    spots_in_foci : np.ndarray, np.int64
-        Coordinate of the spots detected inside foci, with shape (nb_spots, 4).
-        One coordinate per dimension (zyx coordinates) plus the index of the
-        foci.
-    foci : np.ndarray, np.int64
-        Array with shape (nb_foci, 5). One coordinate per dimension for the
-        foci centroid (zyx coordinates), the number of RNAs detected in the
-        foci and its index.
+    spots_out_cluster : np.ndarray, np.int64
+        Coordinate of the spots detected out of cluster, with shape
+        (nb_spots, 3). One coordinate per dimension (zyx coordinates).
+    spots_in_cluster : np.ndarray, np.int64
+        Coordinate of the spots detected inside cluster, with shape
+        (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus the
+        index of the cluster.
+    clusters : np.ndarray, np.int64
+        Array with shape (nb_cluster, 7). One coordinate per dimension for the
+        cluster centroid (zyx coordinates), the number of RNAs detected in the
+        cluster, the area of the cluster region, its average intensity value
+        and its index.
     reference_spot : np.ndarray
         Reference spot with shape (2*radius_z+1, 2*radius_y+1, 2*radius_x+1).
 
     """
     # check parameters
-    stack.check_array(image_filtered_log,
-                      ndim=3,
-                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
-    stack.check_array(image_filtered_background,
+    stack.check_array(image,
                       ndim=3,
                       dtype=[np.uint8, np.uint16, np.float32, np.float64],
                       allow_nan=False)
@@ -972,11 +1135,7 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
                       ndim=2,
                       dtype=[np.int64],
                       allow_nan=False)
-    stack.check_parameter(threshold_spot=(float, int),
-                          radius=(tuple, list),
-                          min_area=(float, int),
-                          min_nb_spots=(float, int),
-                          min_intensity_factor=(float, int),
+    stack.check_parameter(radius=(tuple, list),
                           resolution_z=(float, int),
                           resolution_yx=(float, int),
                           psf_z=(float, int),
@@ -984,24 +1143,25 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
 
     # case where no spot were detected
     if spots.size == 0:
-        spots_out_foci = np.array([], dtype=np.int64).reshape((0, 3))
-        spots_in_foci = np.array([], dtype=np.int64).reshape((0, 4))
-        foci = np.array([], dtype=np.float32).reshape((0, 5))
+        spots_out_cluster = np.array([], dtype=np.int64).reshape((0, 3))
+        spots_in_cluster = np.array([], dtype=np.int64).reshape((0, 4))
+        cluster = np.array([], dtype=np.int64).reshape((0, 5))
         radius_z = int(radius[0]) + 1
         radius_yx = int(radius[1]) + 1
         z_shape = radius_z * 2 + 1
         yx_shape = radius_yx * 2 + 1
         reference_spot = np.zeros((z_shape, yx_shape, yx_shape),
-                                  dtype=image_filtered_background.dtype)
+                                  dtype=image.dtype)
 
-        return spots_out_foci, spots_in_foci, foci, reference_spot
+        return spots_out_cluster, spots_in_cluster, cluster, reference_spot
 
     # build a reference median spot
     reference_spot = build_reference_spot_3d(
-        image_filtered_background,
+        image,
         spots,
         radius,
         method="median")
+    threshold_cluster = int(reference_spot.max())
 
     # initialize a grid representing the reference spot
     grid, centroid_z, centroid_y, centroid_x = initialize_grid_3d(
@@ -1013,7 +1173,7 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
     # compute amplitude and background of the reference spot
     amplitude, background = compute_background_amplitude(reference_spot)
 
-    # TODO initialize the function multiple times
+    # TODO initialize the function multiple times ?
     # fit a 3-d gaussian function on this reference spot
     f = objective_function(
         resolution_z=resolution_z,
@@ -1031,64 +1191,40 @@ def foci_decomposition(image_filtered_log, image_filtered_background,
     amplitude = popt[5]
     background = popt[6]
 
-    # use connected components to detect potential foci
-    cc = get_cc(image_filtered_log, threshold_spot)
-    regions_filtered, spots_out_foci = filter_cc(
-        image_filtered_background,
-        cc,
-        spots,
-        min_area=min_area,
-        min_nb_spots=min_nb_spots,
-        min_intensity_factor=min_intensity_factor)
+    # use connected components to detect potential clusters
+    cc = get_cc(image, threshold_cluster)
+    regions_filtered, spots_out_cluster, max_region_size = filter_clusters(
+        image=image,
+        cc=cc,
+        spots=spots,
+        min_area=min_area)
 
-    # case where no foci where detected
+    # case where no cluster where detected
     if regions_filtered.size == 0:
-        spots_in_foci = np.array([], dtype=np.int64).reshape((0, 4))
-        foci = np.array([], dtype=np.float32).reshape((0, 5))
-        return spots, spots_in_foci, foci, reference_spot
+        spots_in_cluster = np.array([], dtype=np.int64).reshape((0, 4))
+        cluster = np.array([], dtype=np.int64).reshape((0, 5))
+        return spots, spots_in_cluster, cluster, reference_spot
 
     # precompute gaussian function values
+    max_grid = max(200, max_region_size + 1)
     table_erf_z, table_erf_y, table_erf_x = precompute_erf(
         resolution_z,
         resolution_yx,
         sigma_z,
         sigma_yx,
-        max_grid=200)
+        max_grid=max_grid)
     precomputed_gaussian = (table_erf_z, table_erf_y, table_erf_x)
 
-    # fit gaussian mixtures in the foci regions
-    spots_in_foci = []
-    foci = []
-    for i_foci, region in enumerate(regions_filtered):
-        (image_region,
-         best_simulation,
-         pos_gaussian) = fit_gaussian_mixture(
-            image_filtered_background,
-            region,
-            resolution_z,
-            resolution_yx,
-            sigma_z,
-            sigma_yx,
-            amplitude,
-            background,
-            precomputed_gaussian)
+    # fit gaussian mixtures in the cluster regions
+    spots_in_cluster, clusters = decompose_clusters(
+        image=image,
+        cluster_regions=regions_filtered,
+        resolution_z=resolution_z,
+        resolution_yx=resolution_yx,
+        sigma_z=sigma_z,
+        sigma_yx=sigma_yx,
+        amplitude=amplitude,
+        background=background,
+        precomputed_gaussian=precomputed_gaussian)
 
-        # get coordinates of spots and foci in the original image
-        box = region.bbox
-        (min_z, min_y, min_x, _, _, _) = box
-        pos_gaussian = np.array(pos_gaussian, dtype=np.float64)
-        pos_gaussian[:, 0] = (pos_gaussian[:, 0] / resolution_z) + min_z
-        pos_gaussian[:, 1] = (pos_gaussian[:, 1] / resolution_yx) + min_y
-        pos_gaussian[:, 2] = (pos_gaussian[:, 2] / resolution_yx) + min_x
-        spots_in_foci_ = np.zeros((pos_gaussian.shape[0], 4), dtype=np.int64)
-        spots_in_foci_[:, :3] = pos_gaussian
-        spots_in_foci_[:, 3] = i_foci
-        spots_in_foci.append(spots_in_foci_)
-        foci_z, foci_y, foci_x = tuple(pos_gaussian[0])
-        nb_rna_foci = pos_gaussian.shape[0]
-        foci.append([foci_z, foci_y, foci_x, nb_rna_foci, i_foci])
-
-    spots_in_foci = np.concatenate(spots_in_foci, axis=0)
-    foci = np.array(foci, dtype=np.int64)
-
-    return spots_out_foci, spots_in_foci, foci, reference_spot
+    return spots_out_cluster, spots_in_cluster, clusters, reference_spot
diff --git a/bigfish/detection/foci_detection.py b/bigfish/detection/foci_detection.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index 8d81e884..7e3ef9e2 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -139,8 +139,8 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
     nuc_labelled : np.ndarray, np.uint or np.int
         Labelled nuclei image with shape (y, x).
     spots_out : np.ndarray, np.int64
-        Coordinate of the spots detected outside foci, with shape (nb_spots, 3).
-        One coordinate per dimension (zyx coordinates).
+        Coordinate of the spots detected outside foci, with shape
+        (nb_spots, 3). One coordinate per dimension (zyx coordinates).
     spots_in : np.ndarray, np.int64
         Coordinate of the spots detected inside foci, with shape (nb_spots, 4).
         One coordinate per dimension (zyx coordinates) plus the index of the
@@ -165,8 +165,9 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
             Array with shape (nb_foci, 5). One coordinate per dimension for the
             foci centroid (zyx coordinates), the number of RNAs detected in the
             foci and its index.
-        - cell : skimage.measure._regionprops._RegionProperties
-            Various properties of the cell.
+        - cell : Tuple[int]
+            Box coordinate of the cell in the original image (min_y, min_x,
+            max_y and max_x).
 
     """
     # TODO implement several smaller functions
@@ -223,6 +224,7 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
             continue
 
         # get boundaries coordinates
+        # TODO replace by find_contour
         cyt_coord = find_boundaries(cyt, mode='inner')
         cyt_coord = np.nonzero(cyt_coord)
         cyt_coord = np.column_stack(cyt_coord)
@@ -266,6 +268,6 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
         cell_foci[:, 1] -= min_y
         cell_foci[:, 2] -= min_x
 
-        results.append((cyt_coord, nuc_coord, rna_coord, cell_foci, cell))
+        results.append((cyt_coord, nuc_coord, rna_coord, cell_foci, cell.bbox))
 
     return results

From cf347811bdd380205a7093aec9ffe1717920d735 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Jul 2019 16:47:48 +0200
Subject: [PATCH 204/264] misc

---
 bigfish/stack/io.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/bigfish/stack/io.py b/bigfish/stack/io.py
index e9ba924b..74ac8a80 100644
--- a/bigfish/stack/io.py
+++ b/bigfish/stack/io.py
@@ -41,7 +41,8 @@ def read_image(path):
     # check the image is in unsigned integer 16 bits with 2 or 3 dimensions
     check_array(tensor,
                 dtype=[np.uint8, np.uint16, np.int64],
-                ndim=[2, 3])
+                ndim=[2, 3],
+                allow_nan=False)
 
     return tensor
 
@@ -158,4 +159,8 @@ def save_image(image, path):
         warnings.simplefilter("ignore")
         io.imsave(path, image)
 
+    # import warnings
+    # warnings.filterwarnings("ignore", message="numpy.dtype size changed")
+    # warnings.filterwarnings("ignore", message="numpy.ufunc size changed")
+
     return

From 6b46cd8a08c0df736e10a4341aa1d55d00e6e97a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Jul 2019 16:48:17 +0200
Subject: [PATCH 205/264] misc

---
 bigfish/plot/plot_coordinates.py | 67 ++++++++++++++++++--------------
 bigfish/plot/plot_images.py      | 44 ++++++++-------------
 bigfish/stack/filter.py          | 35 ++++++++++-------
 3 files changed, 76 insertions(+), 70 deletions(-)

diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
index dad93aad..6ba97d29 100644
--- a/bigfish/plot/plot_coordinates.py
+++ b/bigfish/plot/plot_coordinates.py
@@ -241,7 +241,8 @@ def plot_layers_coordinates(layers, titles=None, framesize=(5, 10),
 
 
 def plot_extraction_image(results, remove_frame=False, title=None,
-                          framesize=None, path_output=None, ext="png"):
+                          framesize=None, path_output=None, ext="png",
+                          show=True):
     """Plot or subplot of 2-d coordinates extracted from an image.
 
     Parameters
@@ -256,11 +257,13 @@ def plot_extraction_image(results, remove_frame=False, title=None,
             coordinate per dimension (yx dimension), plus the index of a
             potential foci.
         - cell_foci : np.ndarray, np.int64
-            Array with shape (nb_foci, 5). One coordinate per dimension for the
+            Array with shape (nb_foci, 7). One coordinate per dimension for the
             foci centroid (zyx coordinates), the number of RNAs detected in the
-            foci and its index.
-        - cell : skimage.measure._regionprops._RegionProperties
-            Various properties of the cell.
+            foci, its index, the area of the foci region and its maximum
+            intensity value.
+        - cell : Tuple[int]
+            Box coordinate of the cell in the original image (min_y, min_x,
+            max_y and max_x).
     remove_frame : bool
         Remove axes and frame.
     title : str
@@ -272,6 +275,8 @@ def plot_extraction_image(results, remove_frame=False, title=None,
     ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
+    show : bool
+        Show the figure or not.
 
     Returns
     -------
@@ -294,7 +299,7 @@ def plot_extraction_image(results, remove_frame=False, title=None,
     # plot one image
     marge = stack.get_offset_value()
     if len(results) == 1:
-        cyt, nuc, rna, foci, cell = results[0]
+        cyt, nuc, rna, foci, _ = results[0]
         if remove_frame:
             fig = plt.figure(figsize=(8, 8), frameon=False)
             ax = fig.add_axes([0, 0, 1, 1])
@@ -316,7 +321,10 @@ def plot_extraction_image(results, remove_frame=False, title=None,
             plt.tight_layout()
         if path_output is not None:
             save_plot(path_output, ext)
-        plt.show()
+        if show:
+            plt.show()
+        else:
+            plt.close()
 
         return
 
@@ -325,7 +333,7 @@ def plot_extraction_image(results, remove_frame=False, title=None,
 
     # one row
     if len(results) in [2, 3]:
-        for i, (cyt, nuc, rna, foci, cell) in enumerate(results):
+        for i, (cyt, nuc, rna, foci, _) in enumerate(results):
             if remove_frame:
                 ax[i].axis("off")
             ax[i].set_xlim(-marge, max(cyt[:, 1]) + marge)
@@ -345,8 +353,8 @@ def plot_extraction_image(results, remove_frame=False, title=None,
     else:
         # we complete the row with empty frames
         r = nrow * 3 - len(results)
-        results_completed = [(cyt, nuc, rna, foci, cell)
-                             for (cyt, nuc, rna, foci, cell) in results]
+        results_completed = [(cyt, nuc, rna, foci, _)
+                             for (cyt, nuc, rna, foci, _) in results]
         results_completed += [None] * r
         for i, result in enumerate(results_completed):
             row = i // 3
@@ -377,7 +385,10 @@ def plot_extraction_image(results, remove_frame=False, title=None,
     plt.tight_layout()
     if path_output is not None:
         save_plot(path_output, ext)
-    plt.show()
+    if show:
+        plt.show()
+    else:
+        plt.close()
 
     return
 
@@ -385,7 +396,7 @@ def plot_extraction_image(results, remove_frame=False, title=None,
 def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
               image_cyt=None, mask_cyt=None, mask_nuc=None, count_rna=False,
               title=None, remove_frame=False, rescale=False,
-              framesize=(15, 10), path_output=None, ext="png"):
+              framesize=(15, 10), path_output=None, ext="png", show=True):
     """
 
     Parameters
@@ -423,6 +434,8 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
     ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
+    show : bool
+        Show the figure or not.
 
     Returns
     -------
@@ -431,38 +444,31 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
     # check parameters
     stack.check_array(cyt_coord,
                       ndim=2,
-                      dtype=[np.int64],
-                      allow_nan=False)
+                      dtype=[np.int64])
     if nuc_coord is not None:
         stack.check_array(nuc_coord,
                           ndim=2,
-                          dtype=[np.int64],
-                          allow_nan=False)
+                          dtype=[np.int64])
     if rna_coord is not None:
         stack.check_array(rna_coord,
                           ndim=2,
-                          dtype=[np.int64],
-                          allow_nan=False)
+                          dtype=[np.int64])
     if foci_coord is not None:
         stack.check_array(foci_coord,
                           ndim=2,
-                          dtype=[np.int64],
-                          allow_nan=False)
+                          dtype=[np.int64])
     if image_cyt is not None:
         stack.check_array(image_cyt,
                           ndim=2,
-                          dtype=[np.uint8, np.uint16, np.int64],
-                          allow_nan=True)
+                          dtype=[np.uint8, np.uint16, np.int64])
     if mask_cyt is not None:
         stack.check_array(mask_cyt,
                           ndim=2,
-                          dtype=[np.uint8, np.uint16, np.int64, bool],
-                          allow_nan=True)
+                          dtype=[np.uint8, np.uint16, np.int64, bool])
     if mask_nuc is not None:
         stack.check_array(mask_nuc,
                           ndim=2,
-                          dtype=[np.uint8, np.uint16, np.int64, bool],
-                          allow_nan=True)
+                          dtype=[np.uint8, np.uint16, np.int64, bool])
     stack.check_parameter(count_rna=bool,
                           title=(str, type(None)),
                           remove_frame=bool,
@@ -493,13 +499,13 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
     rna = np.zeros(image_shape, dtype=bool)
     if rna_coord is not None:
         rna[rna_coord[:, 0], rna_coord[:, 1]] = True
-        rna = stack.dilation(rna, kernel_shape="square", kernel_size=3)
+        rna = stack.dilation_filter(rna, kernel_shape="square", kernel_size=3)
 
     # get foci layer
     foci = np.zeros(image_shape, dtype=bool)
     if foci_coord is not None:
         foci[foci_coord[:, 1], foci_coord[:, 2]] = True
-        foci = stack.dilation(foci, kernel_shape="square", kernel_size=6)
+        foci = stack.dilation_filter(foci, kernel_shape="square", kernel_size=6)
 
     # build image coordinate
     image_coord = np.ones((max_y, max_x, 3), dtype=np.float32)
@@ -565,6 +571,9 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
 
     if path_output is not None:
         save_plot(path_output, ext)
-    plt.show()
+    if show:
+        plt.show()
+    else:
+        plt.close()
 
     return
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 474b818d..b8488fc7 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -15,6 +15,8 @@
 from matplotlib.colors import ListedColormap
 
 
+# TODO add parameter to show the figure
+
 def plot_yx(tensor, r=0, c=0, z=0, rescale=False, title=None,
             framesize=(8, 8), remove_frame=False, path_output=None,
             ext="png"):
@@ -54,8 +56,7 @@ def plot_yx(tensor, r=0, c=0, z=0, rescale=False, title=None,
                       ndim=[2, 3, 5],
                       dtype=[np.uint8, np.uint16,
                              np.float32, np.float64,
-                             bool],
-                      allow_nan=False)
+                             bool])
     stack.check_parameter(r=int, c=int, z=int,
                           rescale=bool,
                           title=(str, type(None)),
@@ -143,8 +144,7 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
                           ndim=2,
                           dtype=[np.uint8, np.uint16, np.int64,
                                  np.float32, np.float64,
-                                 bool],
-                          allow_nan=False)
+                                 bool])
 
     # we plot 3 images by row maximum
     nrow = int(np.ceil(len(tensors)/3))
@@ -248,8 +248,7 @@ def plot_channels_2d(tensor, r=0, z=0, rescale=False, titles=None,
     # check parameters
     stack.check_array(tensor,
                       ndim=5,
-                      dtype=[np.uint8, np.uint16],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16])
     stack.check_parameter(r=int,
                           z=int,
                           rescale=bool,
@@ -317,7 +316,8 @@ def plot_illumination_surface(illumination_surface, r=0, framesize=(15, 15),
     # TODO add title in the plot and remove axes
     # TODO add parameter for vmin and vmax
     # check tensor
-    stack.check_array(illumination_surface, ndim=4,
+    stack.check_array(illumination_surface,
+                      ndim=4,
                       dtype=[np.float32, np.float64])
 
     # get the number of channels
@@ -370,12 +370,10 @@ def plot_segmentation(tensor, mask, rescale=False, title=None,
                       ndim=2,
                       dtype=[np.uint8, np.uint16,
                              np.float32, np.float64,
-                             bool],
-                      allow_nan=False)
+                             bool])
     stack.check_array(mask,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64, bool])
     stack.check_parameter(rescale=bool,
                           title=(str, type(None)),
                           framesize=tuple,
@@ -465,16 +463,13 @@ def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
                       ndim=2,
                       dtype=[np.uint8, np.uint16,
                              np.float32, np.float64,
-                             bool],
-                      allow_nan=False)
+                             bool])
     stack.check_array(mask_nuc,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64, bool])
     stack.check_array(mask_cyt,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64, bool])
     stack.check_parameter(rescale=bool,
                           title=(str, type(None)),
                           framesize=tuple,
@@ -554,12 +549,10 @@ def plot_spot_detection(tensor, spots, radius_yx, rescale=False,
     stack.check_array(tensor,
                       ndim=2,
                       dtype=[np.uint8, np.uint16,
-                             np.float32, np.float64],
-                      allow_nan=False)
+                             np.float32, np.float64])
     stack.check_array(spots,
                       ndim=2,
-                      dtype=[np.int64],
-                      allow_nan=False)
+                      dtype=[np.int64])
     stack.check_parameter(radius_yx=(float, int),
                           rescale=bool,
                           title=(str, type(None)),
@@ -651,16 +644,13 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
     stack.check_array(tensor,
                       ndim=2,
                       dtype=[np.uint8, np.uint16,
-                             np.float32, np.float64],
-                      allow_nan=False)
+                             np.float32, np.float64])
     stack.check_array(spots,
                       ndim=2,
-                      dtype=[np.int64],
-                      allow_nan=False)
+                      dtype=[np.int64])
     stack.check_array(foci,
                       ndim=2,
-                      dtype=[np.int64],
-                      allow_nan=False)
+                      dtype=[np.int64])
     stack.check_parameter(radius_spots_yx=(float, int),
                           rescale=bool,
                           title=(str, type(None)),
diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
index be82c4a4..7b7787fb 100644
--- a/bigfish/stack/filter.py
+++ b/bigfish/stack/filter.py
@@ -75,7 +75,9 @@ def mean_filter(image, kernel_shape, kernel_size):
 
     """
     # check parameters
-    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_array(image,
+                ndim=2,
+                dtype=[np.uint8, np.uint16])
     check_parameter(kernel_shape=str,
                     kernel_size=(int, tuple, list))
 
@@ -111,7 +113,9 @@ def median_filter(image, kernel_shape, kernel_size):
 
     """
     # check parameters
-    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_array(image,
+                ndim=2,
+                dtype=[np.uint8, np.uint16])
     check_parameter(kernel_shape=str,
                     kernel_size=(int, tuple, list))
 
@@ -147,7 +151,9 @@ def maximum_filter(image, kernel_shape, kernel_size):
 
     """
     # check parameters
-    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_array(image,
+                ndim=2,
+                dtype=[np.uint8, np.uint16])
     check_parameter(kernel_shape=str,
                     kernel_size=(int, tuple, list))
 
@@ -183,7 +189,9 @@ def minimum_filter(image, kernel_shape, kernel_size):
 
     """
     # check parameters
-    check_array(image, ndim=2, dtype=[np.uint8, np.uint16], allow_nan=False)
+    check_array(image,
+                ndim=2,
+                dtype=[np.uint8, np.uint16])
     check_parameter(kernel_shape=str,
                     kernel_size=(int, tuple, list))
 
@@ -225,8 +233,7 @@ def log_filter(image, sigma, keep_dtype=False):
     # check parameters
     check_array(image,
                 ndim=[2, 3],
-                dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                allow_nan=False)
+                dtype=[np.uint8, np.uint16, np.float32, np.float64])
     check_parameter(sigma=(float, int, tuple, list))
 
     # we cast the data in np.float to allow negative values
@@ -287,8 +294,7 @@ def gaussian_filter(image, sigma, allow_negative=False, keep_dtype=False):
     # check parameters
     check_array(image,
                 ndim=[2, 3],
-                dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                allow_nan=False)
+                dtype=[np.uint8, np.uint16, np.float32, np.float64])
     check_parameter(sigma=(float, int, tuple, list),
                     allow_negative=bool)
 
@@ -340,7 +346,10 @@ def remove_background_mean(image, kernel_shape="disk", kernel_size=200):
 
     """
     # check parameters
-    check_array(image, ndim=2, dtype=[np.uint8], allow_nan=False)
+    check_array(image,
+                ndim=2,
+                dtype=[np.uint8])
+    # TODO allow np.uint16 ?
     check_parameter(kernel_shape=str,
                     kernel_size=(int, tuple, list))
 
@@ -380,8 +389,7 @@ def remove_background_gaussian(image, sigma):
     # check parameters
     check_array(image,
                 ndim=[2, 3],
-                dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                allow_nan=False)
+                dtype=[np.uint8, np.uint16, np.float32, np.float64])
     check_parameter(sigma=(float, int, tuple, list))
 
     # apply a gaussian filter
@@ -399,7 +407,7 @@ def remove_background_gaussian(image, sigma):
     return image_no_background
 
 
-def dilation(image, kernel_shape=None, kernel_size=None):
+def dilation_filter(image, kernel_shape=None, kernel_size=None):
     """Apply a dilation to a 2-d image.
 
     Parameters
@@ -423,8 +431,7 @@ def dilation(image, kernel_shape=None, kernel_size=None):
     # check parameters
     check_array(image,
                 ndim=2,
-                dtype=[np.uint8, np.uint16, bool],
-                allow_nan=False)
+                dtype=[np.uint8, np.uint16, bool])
     check_parameter(kernel_shape=(str, type(None)),
                     kernel_size=(int, tuple, list, type(None)))
 

From efa08ce42bb51703bbb4cc8056d988a4a381ee93 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Jul 2019 16:48:43 +0200
Subject: [PATCH 206/264] misc

---
 bigfish/stack/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index d2b10e69..2c769b0c 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,7 +17,7 @@
                          deconstruct_image, reconstruct_image)
 from .filter import (log_filter, mean_filter, median_filter, maximum_filter,
                      minimum_filter, gaussian_filter, remove_background_mean,
-                     remove_background_gaussian, dilation)
+                     remove_background_gaussian, dilation_filter)
 from .projection import (maximum_projection, mean_projection,
                          median_projection, in_focus_selection,
                          focus_measurement, get_in_focus_indices,
@@ -50,7 +50,7 @@
 
 _filter = ["log_filter", "mean_filter", "median_filter", "maximum_filter",
            "minimum_filter", "gaussian_filter", "remove_background_mean",
-           "remove_background_gaussian", "dilation"]
+           "remove_background_gaussian", "dilation_filter"]
 
 _projection = ["maximum_projection", "mean_projection", "median_projection",
                "in_focus_selection", "focus_measurement",

From 23b16c8f857c7e0592e5d5288ecdf86a85bddba8 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Jul 2019 16:49:27 +0200
Subject: [PATCH 207/264] misc

---
 bigfish/segmentation/nuc_segmentation.py |  6 ++----
 bigfish/segmentation/utils.py            | 19 +++++++++----------
 2 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/bigfish/segmentation/nuc_segmentation.py b/bigfish/segmentation/nuc_segmentation.py
index 8bfffb1d..1e90416f 100644
--- a/bigfish/segmentation/nuc_segmentation.py
+++ b/bigfish/segmentation/nuc_segmentation.py
@@ -107,12 +107,10 @@ def remove_segmented_nuc(image, mask, nuclei_size=2000):
     # check parameters
     stack.check_array(image,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16])
     stack.check_array(mask,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64, bool])
 
     # cast mask in np.int64 if it is binary
     if mask.dtype == bool or mask.dtype == np.uint16:
diff --git a/bigfish/segmentation/utils.py b/bigfish/segmentation/utils.py
index 8f5a9701..539b81a0 100644
--- a/bigfish/segmentation/utils.py
+++ b/bigfish/segmentation/utils.py
@@ -34,7 +34,9 @@ def label_instances(mask):
 
     """
     # check parameters
-    stack.check_array(mask, ndim=2, dtype=bool, allow_nan=False)
+    stack.check_array(mask,
+                      ndim=2,
+                      dtype=bool)
 
     # get labels
     image_label, nb_labels = label(mask, return_num=True)
@@ -61,8 +63,7 @@ def compute_mean_size_object(image_labelled):
     # check parameters
     stack.check_array(image_labelled,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64])
 
     # compute properties of the segmented object
     props = regionprops(image_labelled)
@@ -97,12 +98,10 @@ def merge_labels(label_1, label_2):
     # check parameters
     stack.check_array(label_1,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64])
     stack.check_array(label_2,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64])
 
     # count number of label
     nb_label_1 = label_1.max()
@@ -130,7 +129,7 @@ def merge_labels(label_1, label_2):
 
 
 def get_boundaries(mask):
-    """Get the boundaries coordinates of a mask
+    """Get the boundaries coordinates of a mask (not sorted).
 
     Parameters
     ----------
@@ -143,11 +142,11 @@ def get_boundaries(mask):
         Coordinate of the boundaries with shape (nb_points, 2).
 
     """
+    # TODO sort boundaries coordinates with find_contours
     # check parameters
     stack.check_array(mask,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64, bool])
 
     # get boundaries mask
     boundary_mask = find_boundaries(mask, mode='inner')

From 61019f07e10d035c2698be4b61d11775c9ff34d4 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Jul 2019 16:49:48 +0200
Subject: [PATCH 208/264] smooth mask

---
 bigfish/segmentation/cyt_segmentation.py | 37 ++++++++++++++----------
 1 file changed, 21 insertions(+), 16 deletions(-)

diff --git a/bigfish/segmentation/cyt_segmentation.py b/bigfish/segmentation/cyt_segmentation.py
index f9761489..d954cc22 100644
--- a/bigfish/segmentation/cyt_segmentation.py
+++ b/bigfish/segmentation/cyt_segmentation.py
@@ -35,8 +35,7 @@ def build_cyt_binary_mask(image_projected, threshold=None):
     # check parameters
     stack.check_array(image_projected,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16])
     stack.check_parameter(threshold=(int, type(None)))
 
     # get a threshold
@@ -85,16 +84,13 @@ def build_cyt_relief(image_projected, nuc_labelled, mask_cyt, alpha=0.8):
     # check parameters
     stack.check_array(image_projected,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16])
     stack.check_array(nuc_labelled,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64, bool])
     stack.check_array(mask_cyt,
                       ndim=2,
-                      dtype=[bool],
-                      allow_nan=False)
+                      dtype=[bool])
     stack.check_parameter(alpha=(float, int))
 
     # use pixel intensity of the cytoplasm channel to compute the seed.
@@ -146,7 +142,7 @@ def build_cyt_relief(image_projected, nuc_labelled, mask_cyt, alpha=0.8):
     return relief
 
 
-def cyt_watershed(relief, nuc_labelled, mask):
+def cyt_watershed(relief, nuc_labelled, mask, smooth=None):
     """Apply watershed algorithm on the cytoplasm to segment cell instances.
 
     Parameters
@@ -157,6 +153,9 @@ def cyt_watershed(relief, nuc_labelled, mask):
         Result of the nuclei segmentation with shape (y, x).
     mask : np.ndarray, bool
         Binary mask of the cytoplasm with shape (y, x).
+    smooth : int
+        Smooth the final boundaries applying a median filter on the mask
+        (kernel_size=smooth).
 
     Returns
     -------
@@ -169,24 +168,30 @@ def cyt_watershed(relief, nuc_labelled, mask):
     # check parameters
     stack.check_array(relief,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16])
     stack.check_array(nuc_labelled,
                       ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.int64])
     stack.check_array(mask,
                       ndim=2,
-                      dtype=[bool],
-                      allow_nan=False)
+                      dtype=[bool])
+    stack.check_parameter(smooth=(int, type(None)))
 
     # get markers
     markers = np.zeros_like(relief)
     for r in regionprops(nuc_labelled):
         markers[tuple(map(int, r.centroid))] = r.label
+    markers = markers.astype(np.int64)
 
     # segment cytoplasm
     cyt_segmented = watershed(relief, markers, mask=mask)
-    cyt_segmented = cyt_segmented.astype(np.int64)
+
+    # smooth boundaries
+    if smooth is not None:
+        cyt_segmented = stack.median_filter(cyt_segmented.astype(np.uint16),
+                                            kernel_shape="disk",
+                                            kernel_size=smooth)
+        cyt_segmented = remove_small_objects(cyt_segmented, 3000)
+        cyt_segmented = cyt_segmented.astype(np.int64)
 
     return cyt_segmented

From d54511406c1447728664bb95e94f7c5080c435d5 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Jul 2019 16:50:24 +0200
Subject: [PATCH 209/264] refactor spot and foci detection

---
 bigfish/detection/__init__.py              |  41 ++++---
 bigfish/detection/cluster_decomposition.py |  37 +++---
 bigfish/detection/foci_detection.py        | 122 +++++++++++++++++++
 bigfish/detection/spot_detection.py        | 132 +--------------------
 4 files changed, 164 insertions(+), 168 deletions(-)

diff --git a/bigfish/detection/__init__.py b/bigfish/detection/__init__.py
index 93fea9bd..d567ddec 100644
--- a/bigfish/detection/__init__.py
+++ b/bigfish/detection/__init__.py
@@ -5,25 +5,28 @@
 3-d.
 """
 
-from .spot_detection import (log_lm, local_maximum_detection,
-                             spots_thresholding, compute_snr,
-                             from_threshold_to_snr, get_sigma, log_cc, get_cc,
-                             filter_cc)
-from .gaussian_fit import (gaussian_3d, build_reference_spot_3d,
-                           get_spot_volume, get_spot_surface, precompute_erf,
-                           initialize_spot_parameter_3d, objective_function,
-                           fit_gaussian_3d, simulate_fitted_gaussian_3d,
-                           initialize_grid_3d, compute_background_amplitude,
-                           fit_gaussian_mixture, foci_decomposition)
+from .spot_detection import (
+    log_lm, local_maximum_detection, spots_thresholding, compute_snr,
+    from_threshold_to_snr, get_sigma, log_cc, get_cc)
+from .cluster_decomposition import (
+    gaussian_3d, precompute_erf, build_reference_spot_3d,
+    initialize_spot_parameter_3d, objective_function, fit_gaussian_3d,
+    simulate_fitted_gaussian_3d, fit_gaussian_mixture, filter_clusters,
+    decompose_clusters, run_decomposition)
+from .foci_detection import (
+    convert_spot_coordinates, cluster_spots, extract_foci)
 
-_detection = ["log_lm", "local_maximum_detection", "spots_thresholding",
-              "compute_snr", "from_threshold_to_snr", "get_sigma", "log_cc",
-              "get_cc", "filter_cc"]
 
-_fit = ["gaussian_3d", "precompute_erf", "build_reference_spot_3d",
-        "get_spot_volume", "get_spot_surface", "initialize_spot_parameter_3d",
-        "objective_function", "fit_gaussian_3d", "simulate_fitted_gaussian_3d",
-        "initialize_grid_3d", "compute_background_amplitude",
-        "fit_gaussian_mixture", "foci_decomposition"]
+_spots = ["log_lm", "local_maximum_detection", "spots_thresholding",
+          "compute_snr", "from_threshold_to_snr", "get_sigma", "log_cc",
+          "get_cc", "filter_cc"]
 
-__all__ = _detection + _fit
+_clusters = ["gaussian_3d", "precompute_erf", "build_reference_spot_3d",
+             "initialize_spot_parameter_3d", "objective_function",
+             "fit_gaussian_3d", "simulate_fitted_gaussian_3d",
+             "fit_gaussian_mixture", "filter_clusters", "decompose_clusters",
+             "run_decomposition"]
+
+_foci = ["convert_spot_coordinates", "cluster_spots", "extract_foci"]
+
+__all__ = _spots + _clusters + _foci
diff --git a/bigfish/detection/cluster_decomposition.py b/bigfish/detection/cluster_decomposition.py
index 3accce04..9894195a 100644
--- a/bigfish/detection/cluster_decomposition.py
+++ b/bigfish/detection/cluster_decomposition.py
@@ -294,8 +294,8 @@ def build_reference_spot_3d(image, spots, radius, method="median"):
         spot_z, spot_y, spot_x = candidate_spots[i_spot, :]
 
         # get the volume of the spot
-        image_spot = get_spot_volume(image, spot_z, spot_y, spot_x,
-                                     radius_z, radius_yx)
+        image_spot = _get_spot_volume(image, spot_z, spot_y, spot_x,
+                                      radius_z, radius_yx)
 
         # remove the cropped images
         if image_spot.shape != (z_shape, yx_shape, yx_shape):
@@ -320,7 +320,7 @@ def build_reference_spot_3d(image, spots, radius, method="median"):
     return reference_spot
 
 
-def get_spot_volume(image, spot_z, spot_y, spot_x, radius_z, radius_yx):
+def _get_spot_volume(image, spot_z, spot_y, spot_x, radius_z, radius_yx):
     """Get a subimage of a detected spot in 3-d.
 
     Parameters
@@ -371,7 +371,7 @@ def get_spot_volume(image, spot_z, spot_y, spot_x, radius_z, radius_yx):
     return image_spot
 
 
-def get_spot_surface(image, spot_y, spot_x, radius_yx):
+def _get_spot_surface(image, spot_y, spot_x, radius_yx):
     """Get a subimage of a detected spot from its supposed yx plan.
 
     Parameters
@@ -477,7 +477,7 @@ def initialize_spot_parameter_3d(image, spot_z, spot_y, spot_x, psf_z=400,
     radius_yx = np.sqrt(3) * sigma_yx
 
     # get subimage of the spot
-    image_spot = get_spot_volume(
+    image_spot = _get_spot_volume(
         image=image,
         spot_z=spot_z,
         spot_y=spot_y,
@@ -486,21 +486,21 @@ def initialize_spot_parameter_3d(image, spot_z, spot_y, spot_x, psf_z=400,
         radius_yx=radius_yx)
 
     # build a grid to fit the gaussian values
-    grid, center_z, center_y, center_x = initialize_grid_3d(
+    grid, center_z, center_y, center_x = _initialize_grid_3d(
         image_spot=image_spot,
         resolution_z=resolution_z,
         resolution_yx=resolution_yx,
         return_centroid=True)
 
     # compute amplitude and background values
-    psf_amplitude, psf_background = compute_background_amplitude(image_spot)
+    psf_amplitude, psf_background = _compute_background_amplitude(image_spot)
 
     return (image_spot, grid, center_z, center_y, center_x, psf_amplitude,
             psf_background)
 
 
-def initialize_grid_3d(image_spot, resolution_z, resolution_yx,
-                       return_centroid=False):
+def _initialize_grid_3d(image_spot, resolution_z, resolution_yx,
+                        return_centroid=False):
     """Build a grid in nanometer to compute gaussian function over a full
     volume.
 
@@ -567,7 +567,7 @@ def initialize_grid_3d(image_spot, resolution_z, resolution_yx,
         return grid
 
 
-def compute_background_amplitude(image_spot):
+def _compute_background_amplitude(image_spot):
     """Compute amplitude of a spot and background minimum value.
 
     Parameters
@@ -861,7 +861,7 @@ def fit_gaussian_mixture(image, region, resolution_z, resolution_yx, sigma_z,
     image_region_raw = np.reshape(image_region, image_region.size)
 
     # build a grid to represent this image
-    grid = initialize_grid_3d(image_region, resolution_z, resolution_yx)
+    grid = _initialize_grid_3d(image_region, resolution_z, resolution_yx)
 
     # add a gaussian for each local maximum while the RSS decreases
     simulation = np.zeros(image_region_raw.shape, dtype=np.float64)
@@ -1082,9 +1082,8 @@ def decompose_clusters(image, cluster_regions, resolution_z, resolution_yx,
     return spots_in_cluster, clusters
 
 
-def cluster_decomposition(image, spots, radius, min_area=2,
-                          resolution_z=300, resolution_yx=103, psf_z=400,
-                          psf_yx=200):
+def run_decomposition(image, spots, radius, min_area=2, resolution_z=300,
+                      resolution_yx=103, psf_z=400, psf_yx=200):
     """Detect regions with clustered spots and fit a mixture of gaussians to
     decompose them.
 
@@ -1094,11 +1093,11 @@ def cluster_decomposition(image, spots, radius, min_area=2,
         Image with shape (z, y, x) and filter with gaussian operator to
         estimate then remove background.
     spots : np.ndarray, np.int64
-        Coordinate of the spots with shape (nb_spots, 3).
+        Coordinates of the detected spots with shape (nb_spots, 3).
     radius : Tuple[float]
-        Radius of the detected peaks, one for each dimension.
+        Radius of the detected spots, one for each dimension.
     min_area : int
-        Minimum number of pixels in the connected region.
+        Minimum number of pixels in a clustered region.
     resolution_z : int or float
         Height of a voxel, along the z axis, in nanometer.
     resolution_yx : int or float
@@ -1164,14 +1163,14 @@ def cluster_decomposition(image, spots, radius, min_area=2,
     threshold_cluster = int(reference_spot.max())
 
     # initialize a grid representing the reference spot
-    grid, centroid_z, centroid_y, centroid_x = initialize_grid_3d(
+    grid, centroid_z, centroid_y, centroid_x = _initialize_grid_3d(
         image_spot=reference_spot,
         resolution_z=resolution_z,
         resolution_yx=resolution_yx,
         return_centroid=True)
 
     # compute amplitude and background of the reference spot
-    amplitude, background = compute_background_amplitude(reference_spot)
+    amplitude, background = _compute_background_amplitude(reference_spot)
 
     # TODO initialize the function multiple times ?
     # fit a 3-d gaussian function on this reference spot
diff --git a/bigfish/detection/foci_detection.py b/bigfish/detection/foci_detection.py
index e69de29b..ee6ac6da 100644
--- a/bigfish/detection/foci_detection.py
+++ b/bigfish/detection/foci_detection.py
@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions to fit gaussian functions to the detected RNA spots, especially in
+clustered regions.
+"""
+
+import numpy as np
+
+from sklearn.cluster import DBSCAN
+
+
+# ### Spots clustering ###
+
+def convert_spot_coordinates(spots, resolution_z, resolution_yx):
+    """
+    Convert spots coordinates in nanometer.
+
+    Parameters
+    ----------
+    spots : np.ndarray, np.int64
+        Coordinates of the detected spots with shape (nb_spots, 3).
+    resolution_z : int or float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : int or float
+        Size of a voxel on the yx plan, in nanometer.
+
+    Returns
+    -------
+    spots_nanometer : np.ndarray, np.int64
+        Coordinates of the detected spots with shape (nb_spots, 3), in
+        nanometer.
+
+    """
+    # convert spots coordinates in nanometer, for each dimension, according to
+    # the pixel size of the image
+    spots_nanometer = spots.copy()
+    spots_nanometer[:, 0] *= resolution_z
+    spots_nanometer[:, 1:] *= resolution_yx
+
+    return spots_nanometer
+
+
+def cluster_spots(spots, resolution_z, resolution_yx, radius, nb_min_spots):
+    """
+
+    Parameters
+    ----------
+    spots : np.ndarray, np.int64
+        Coordinates of the detected spots with shape (nb_spots, 3).
+    resolution_z : int or float
+        Height of a voxel, along the z axis, in nanometer.
+    resolution_yx : int or float
+        Size of a voxel on the yx plan, in nanometer.
+    radius : int
+        The maximum distance between two samples for one to be considered as
+        in the neighborhood of the other. Radius in nanometer.
+    nb_min_spots : int
+        The number of spots in a neighborhood for a point to be considered as
+        a core point (from which a cluster is expanded). This includes the
+        point itself.
+
+    Returns
+    -------
+    clustered_spots : np.ndarray, np.int64
+        Coordinates of the detected spots with shape (nb_spots, 4). The last
+        column is the cluster assigned to the spot. If no cluster was assigned,
+        value is -1.
+
+    """
+    # convert spots coordinates in nanometer
+    spots_nanometer = convert_spot_coordinates(spots=spots,
+                                               resolution_z=resolution_z,
+                                               resolution_yx=resolution_yx)
+
+    # fit a DBSCAN clustering algorithm with a specific radius
+    dbscan = DBSCAN(eps=radius, min_samples=nb_min_spots)
+    dbscan.fit(spots_nanometer)
+    labels = dbscan.labels_
+    labels = labels[:, np.newaxis]
+
+    # assign a cluster to each spot if possible
+    clustered_spots = spots.copy()
+    clustered_spots = np.concatenate((clustered_spots, labels), axis=1)
+
+    return clustered_spots
+
+
+# ### Detect foci ###
+
+def extract_foci(clustered_spots):
+    """
+    Extract foci information from clustered spots.
+
+    Parameters
+    ----------
+    clustered_spots : np.ndarray, np.int64
+        Coordinates of the detected spots with shape (nb_spots, 4). The last
+        column is the cluster assigned to the spot. If no cluster was assigned,
+        value is -1.
+
+    Returns
+    -------
+    foci : np.ndarray, np.int64
+        Array with shape (nb_foci, 5). One coordinate per dimension for the
+        foci centroid (zyx coordinates), the number of spots detected in the
+        foci and its index.
+
+    """
+    # get foci labels
+    labels_foci = np.unique(clustered_spots[clustered_spots[:, 3] != -1, 3])
+
+    # get foci's information
+    foci = []
+    for label in labels_foci:
+        spots_in_foci = clustered_spots[clustered_spots[:, 3] == label, :3]
+        z_foci, y_foci, x_foci = spots_in_foci.mean(axis=0)
+        nb_spots_foci = len(spots_in_foci)
+        foci.append([z_foci, y_foci, x_foci, nb_spots_foci, label])
+    foci = np.array(foci, dtype=np.int64)
+
+    return foci
diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index 10a2b3c5..9cf4aa79 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -9,7 +9,7 @@
 import scipy.ndimage as ndi
 import numpy as np
 
-from skimage.measure import label, regionprops
+from skimage.measure import label
 
 
 # TODO complete documentation methods
@@ -237,134 +237,6 @@ def get_cc(image, threshold):
     return cc
 
 
-def filter_cc(image, cc, spots, min_area, min_nb_spots, min_intensity_factor):
-    """Filter connected regions.
-
-    Parameters
-    ----------
-    image : np.ndarray
-        Image with shape (z, y, x) or (y, x).
-    cc : np.ndarray, np.int64
-        Image labelled with shape (z, y, x) or (y, x).
-    spots : np.ndarray, np.int64
-        Coordinate of the spots with shape (nb_spots, 3).
-    min_area : int
-        Minimum number of pixels in the connected region.
-    min_nb_spots : int
-        Minimum number of spot detected in this region.
-    min_intensity_factor : int or float
-        Minimum pixel intensity in the connected region is equal to
-        median(intensity) * min_intensity_factor.
-
-    Returns
-    -------
-    regions_filtered : np.ndarray
-        Array with filtered skimage.measure._regionprops._RegionProperties.
-    spots_out_region : np.ndarray, np.int64
-        Coordinate of the spots outside the regions with shape (nb_spots, 3).
-
-    """
-    # TODO manage the difference between 2-d and 3-d data
-
-    # check parameters
-    stack.check_array(image,
-                      ndim=[2, 3],
-                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=True)
-    stack.check_array(cc,
-                      ndim=[2, 3],
-                      dtype=[np.int64],
-                      allow_nan=True)
-    stack.check_array(spots,
-                      ndim=2,
-                      dtype=[np.int64],
-                      allow_nan=True)
-    stack.check_parameter(min_area=int,
-                          min_nb_spots=int,
-                          min_intensity_factor=(float, int))
-
-    # get properties of the different connected regions
-    regions = regionprops(cc, intensity_image=image, cache=True)
-
-    # get different features of the regions
-    area = []
-    intensity = []
-    bbox = []
-    for i, region in enumerate(regions):
-        area.append(region.area)
-        intensity.append(region.max_intensity)
-        bbox.append(region.bbox)
-    regions = np.array(regions)
-    area = np.array(area)
-    intensity = np.array(intensity)
-    bbox = np.array(bbox)
-
-    # keep regions with a minimum size
-    # TODO convert '>' in '>='
-    big_area = area > min_area
-    regions = regions[big_area]
-    intensity = intensity[big_area]
-    bbox = bbox[big_area]
-
-    # case where no region big enough were detected
-    if regions.size == 0:
-        regions_filtered = np.array([])
-        spots_out_region = np.array([], dtype=np.int64).reshape((0, 2))
-        return regions_filtered, spots_out_region
-
-    # TODO remove copy()?
-    # count spots in the regions
-    nb_spots_in = []
-    for box in bbox:
-        # TODO convert '<=' in '<'
-        (min_z, min_y, min_x, max_z, max_y, max_x) = box
-        mask_spots_in = spots[:, 0] <= max_z
-        mask_spots_in = (mask_spots_in & (spots[:, 1] <= max_y))
-        mask_spots_in = (mask_spots_in & (spots[:, 2] <= max_x))
-        mask_spots_in = (mask_spots_in & (min_z <= spots[:, 0]))
-        mask_spots_in = (mask_spots_in & (min_y <= spots[:, 1]))
-        mask_spots_in = (mask_spots_in & (min_x <= spots[:, 2]))
-        spots_in = spots.copy()
-        spots_in = spots_in[mask_spots_in]
-        nb_spots_in.append(spots_in.shape[0])
-
-    # keep regions with a minimum number of spots
-    # TODO convert '>' in '>='
-    nb_spots_in = np.array(nb_spots_in)
-    multiple_spots = nb_spots_in > min_nb_spots
-
-    # keep regions which reach a minimum intensity value
-    # TODO convert '>' in '>='
-    high_intensity = intensity > np.median(intensity) * min_intensity_factor
-
-    # filter regions and labels
-    mask = multiple_spots | high_intensity
-    regions_filtered = regions[mask]
-    bbox = bbox[mask]
-
-    # case where no foci were detected
-    if regions.size == 0:
-        spots_out_region = np.array([], dtype=np.int64).reshape((0, 2))
-        return regions_filtered, spots_out_region
-
-    # TODO make it in a separate function
-    # count spots outside the regions
-    mask_spots_out = np.ones(spots[:, 0].shape, dtype=bool)
-    for box in bbox:
-        (min_z, min_y, min_x, max_z, max_y, max_x) = box
-        mask_spots_in = spots[:, 0] <= max_z
-        mask_spots_in = (mask_spots_in & (spots[:, 1] <= max_y))
-        mask_spots_in = (mask_spots_in & (spots[:, 2] <= max_x))
-        mask_spots_in = (mask_spots_in & (min_z <= spots[:, 0]))
-        mask_spots_in = (mask_spots_in & (min_y <= spots[:, 1]))
-        mask_spots_in = (mask_spots_in & (min_x <= spots[:, 2]))
-        mask_spots_out = mask_spots_out & (~mask_spots_in)
-    spots_out_region = spots.copy()
-    spots_out_region = spots_out_region[mask_spots_out]
-
-    return regions_filtered, spots_out_region
-
-
 # ### Signal-to-Noise ratio ###
 
 def compute_snr(image, sigma, minimum_distance=1,
@@ -494,7 +366,7 @@ def from_threshold_to_snr(image, sigma, mask, threshold=2000,
 
 # ### Utils ###
 
-def get_sigma(resolution_z=300, resolution_yx=103, psf_z=400, psf_yx=200):
+def get_sigma(resolution_z=300, resolution_yx=103, psf_z=350, psf_yx=150):
     """Compute the standard deviation of the PSF of the spots.
 
     Parameters

From 34dbe8fae0849283d9f16577131fd62731edcbdd Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 30 Jul 2019 16:51:14 +0200
Subject: [PATCH 210/264] fix feature dispersion

---
 bigfish/classification/features.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index ede86b8f..55f1406c 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -340,12 +340,12 @@ def feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna):
     return feature
 
 
-def feature_dispersion(cyt_coord, rna_coord, centroid_rna):
+def feature_dispersion(mask_cyt, rna_coord, centroid_rna):
     """
 
     Parameters
     ----------
-    cyt_coord
+    mask_cyt
     rna_coord
     centroid_rna
 
@@ -356,11 +356,15 @@ def feature_dispersion(cyt_coord, rna_coord, centroid_rna):
     # TODO add sanity check functions
     # TODO add documentation
     # TODO correct the formula
+    # get coordinates of each pixel of the cell
+    mask_cyt_coord = np.nonzero(mask_cyt)
+    mask_cyt_coord = np.column_stack(mask_cyt_coord)
+
     # compute dispersion index
     sigma_rna = np.sum((rna_coord - centroid_rna) ** 2, axis=0)
     sigma_rna = np.sum(sigma_rna / len(rna_coord))
-    sigma_cell = np.sum((cyt_coord - centroid_rna) ** 2, axis=0)
-    sigma_cell = np.sum(sigma_cell / len(cyt_coord))
+    sigma_cell = np.sum((mask_cyt_coord - centroid_rna) ** 2, axis=0)
+    sigma_cell = np.sum(sigma_cell / len(mask_cyt_coord))
     feature = sigma_rna / sigma_cell
 
     return feature
@@ -414,7 +418,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord):
     radii = [r for r in range(40)]
     d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
     e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
-    f = feature_dispersion(cyt_coord, rna_coord, centroid_rna)
+    f = feature_dispersion(mask_cyt, rna_coord, centroid_rna)
     features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
 
     return features

From 1d13be9e050faa714211411390fa611e35095044 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 31 Jul 2019 11:40:49 +0200
Subject: [PATCH 211/264] add 'show' parameter in plots

---
 bigfish/plot/__init__.py    |  4 +--
 bigfish/plot/plot_images.py | 69 +++++++++++++++++++++++++------------
 2 files changed, 49 insertions(+), 24 deletions(-)

diff --git a/bigfish/plot/__init__.py b/bigfish/plot/__init__.py
index 87c8e9a9..f36b1287 100644
--- a/bigfish/plot/__init__.py
+++ b/bigfish/plot/__init__.py
@@ -7,7 +7,7 @@
 from .plot_images import (plot_yx, plot_channels_2d, plot_segmentation,
                           plot_images, plot_spot_detection,
                           plot_illumination_surface,
-                          plot_segmentation_boundary, plot_foci_decomposition)
+                          plot_segmentation_boundary, plot_foci_detection)
 from .plot_coordinates import (plot_volume, plot_rna, plot_distribution_rna,
                                plot_cell_coordinates, plot_layers_coordinates,
                                plot_extraction_image, plot_cell)
@@ -17,7 +17,7 @@
 _images = ["plot_yx", "plot_images", "plot_channels_2d",
            "plot_illumination_surface", "plot_segmentation",
            "plot_spot_detection", "plot_segmentation_boundary",
-           "plot_foci_decomposition"]
+           "plot_foci_detection"]
 
 _coordinates = ["plot_volume", "plot_rna", "plot_distribution_rna",
                 "plot_cell_coordinates", "plot_layers_coordinates",
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index b8488fc7..04e247a1 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -429,7 +429,7 @@ def plot_segmentation(tensor, mask, rescale=False, title=None,
 def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
                                title=None, framesize=(10, 10),
                                remove_frame=False, path_output=None,
-                               ext="png"):
+                               ext="png", show=True):
     """Plot the boundary of the segmented objects.
 
     Parameters
@@ -453,6 +453,8 @@ def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
     ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
+    show : bool
+        Show the figure or not.
 
     Returns
     -------
@@ -475,7 +477,8 @@ def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
                           framesize=tuple,
                           remove_frame=bool,
                           path_output=(str, type(None)),
-                          ext=(str, list))
+                          ext=(str, list),
+                          show=bool)
 
     # get minimum and maximum value of the image
     vmin, vmax = None, None
@@ -507,14 +510,17 @@ def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
         plt.tight_layout()
     if path_output is not None:
         save_plot(path_output, ext)
-    plt.show()
+    if show:
+        plt.show()
+    else:
+        plt.close()
 
     return
 
 
 def plot_spot_detection(tensor, spots, radius_yx, rescale=False,
                         title=None, framesize=(15, 5), remove_frame=False,
-                        path_output=None, ext="png"):
+                        path_output=None, ext="png", show=True):
     """Plot detected spot on a 2-d image.
 
     Parameters
@@ -539,6 +545,8 @@ def plot_spot_detection(tensor, spots, radius_yx, rescale=False,
     ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
+    show : bool
+        Show the figure or not.
 
     Returns
     -------
@@ -559,7 +567,8 @@ def plot_spot_detection(tensor, spots, radius_yx, rescale=False,
                           framesize=tuple,
                           remove_frame=bool,
                           path_output=(str, type(None)),
-                          ext=(str, list))
+                          ext=(str, list),
+                          show=bool)
 
     # get minimum and maximum value of the image
     vmin, vmax = None, None
@@ -599,14 +608,18 @@ def plot_spot_detection(tensor, spots, radius_yx, rescale=False,
     plt.tight_layout()
     if path_output is not None:
         save_plot(path_output, ext)
-    plt.show()
+    if show:
+        plt.show()
+    else:
+        plt.close()
 
     return
 
 
-def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
-                            rescale=False, title=None, framesize=(15, 10),
-                            remove_frame=False, path_output=None, ext="png"):
+def plot_foci_detection(tensor, spots, foci, radius_spots_yx,
+                        rescale=False, title=None, framesize=(15, 10),
+                        remove_frame=False, path_output=None, ext="png",
+                        show=True):
     """Plot detected spots and foci on a 2-d image.
 
     Parameters
@@ -633,6 +646,8 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
     ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
+    show : bool
+        Show the figure or not.
 
     Returns
     -------
@@ -645,19 +660,22 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
                       ndim=2,
                       dtype=[np.uint8, np.uint16,
                              np.float32, np.float64])
-    stack.check_array(spots,
-                      ndim=2,
-                      dtype=[np.int64])
     stack.check_array(foci,
                       ndim=2,
                       dtype=[np.int64])
-    stack.check_parameter(radius_spots_yx=(float, int),
+    stack.check_parameter(spots=(np.ndarray, type(None)),
+                          radius_spots_yx=(float, int),
                           rescale=bool,
                           title=(str, type(None)),
                           framesize=tuple,
                           remove_frame=bool,
                           path_output=(str, type(None)),
-                          ext=(str, list))
+                          ext=(str, list),
+                          show=bool)
+    if spots is not None:
+        stack.check_array(spots,
+                          ndim=2,
+                          dtype=[np.int64])
 
     # get minimum and maximum value of the image
     vmin, vmax = None, None
@@ -682,12 +700,16 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
         ax[1].imshow(tensor, vmin=vmin, vmax=vmax)
     else:
         ax[1].imshow(tensor)
-    for (_, y, x) in spots:
-        c = plt.Circle((x, y), radius_spots_yx,
-                       color="red",
-                       linewidth=1,
-                       fill=False)
-        ax[1].add_patch(c)
+    if spots is not None:
+        for (_, y, x) in spots:
+            c = plt.Circle((x, y), radius_spots_yx,
+                           color="red",
+                           linewidth=1,
+                           fill=False)
+            ax[1].add_patch(c)
+            title_ = "Detected spots and foci"
+    else:
+        title_ = "Detected foci"
     for (_, y, x, _, _) in foci:
         c = plt.Circle((x, y), radius_spots_yx * 2,
                        color="blue",
@@ -695,7 +717,7 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
                        fill=False)
         ax[1].add_patch(c)
     if title is not None:
-        ax[1].set_title("Detected spots and foci",
+        ax[1].set_title(title_,
                         fontweight="bold",
                         fontsize=10)
     if remove_frame:
@@ -704,6 +726,9 @@ def plot_foci_decomposition(tensor, spots, foci, radius_spots_yx,
     plt.tight_layout()
     if path_output is not None:
         save_plot(path_output, ext)
-    plt.show()
+    if show:
+        plt.show()
+    else:
+        plt.close()
 
     return

From 029fa270746f9d3699f52aed9bddeda0129f31c1 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 31 Jul 2019 11:41:06 +0200
Subject: [PATCH 212/264] misc

---
 bigfish/detection/spot_detection.py | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/bigfish/detection/spot_detection.py b/bigfish/detection/spot_detection.py
index 9cf4aa79..6b13a516 100644
--- a/bigfish/detection/spot_detection.py
+++ b/bigfish/detection/spot_detection.py
@@ -52,8 +52,7 @@ def log_lm(image, sigma, threshold, minimum_distance=1):
     # check parameters
     stack.check_array(image,
                       ndim=[2, 3],
-                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64])
     stack.check_parameter(sigma=(float, int, tuple),
                           minimum_distance=(float, int),
                           threshold=(float, int))
@@ -93,8 +92,7 @@ def local_maximum_detection(image, minimum_distance):
     # check parameters
     stack.check_array(image,
                       ndim=[2, 3],
-                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64])
     stack.check_parameter(minimum_distance=(float, int))
 
     # compute the kernel size (centered around our pixel because it is uneven)
@@ -140,12 +138,10 @@ def spots_thresholding(image, sigma, mask_lm, threshold):
     # check parameters
     stack.check_array(image,
                       ndim=[2, 3],
-                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64])
     stack.check_array(mask_lm,
                       ndim=[2, 3],
-                      dtype=[bool],
-                      allow_nan=False)
+                      dtype=[bool])
     stack.check_parameter(sigma=(float, int, tuple),
                           threshold=(float, int))
 
@@ -189,8 +185,7 @@ def log_cc(image, sigma, threshold):
     # check parameters
     stack.check_array(image,
                       ndim=[2, 3],
-                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=False)
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64])
     stack.check_parameter(sigma=(float, int, tuple),
                           threshold=(float, int))
 
@@ -224,8 +219,7 @@ def get_cc(image, threshold):
     # check parameters
     stack.check_array(image,
                       ndim=[2, 3],
-                      dtype=[np.uint8, np.uint16, np.float32, np.float64],
-                      allow_nan=True)
+                      dtype=[np.uint8, np.uint16, np.float32, np.float64])
     stack.check_parameter(threshold=(float, int))
 
     # Compute binary mask of the filtered image

From 47e1ae128ac673fc213529ddf5eb219a08e5704b Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 31 Jul 2019 11:53:54 +0200
Subject: [PATCH 213/264] misc

---
 bigfish/plot/plot_images.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 04e247a1..0f9739d7 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -707,7 +707,7 @@ def plot_foci_detection(tensor, spots, foci, radius_spots_yx,
                            linewidth=1,
                            fill=False)
             ax[1].add_patch(c)
-            title_ = "Detected spots and foci"
+        title_ = "Detected spots and foci"
     else:
         title_ = "Detected foci"
     for (_, y, x, _, _) in foci:

From 910a2626470b6a49a36e24fa0c72914f0edd9e71 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 31 Jul 2019 16:20:50 +0200
Subject: [PATCH 214/264] remove tensoforflow (temporary)

---
 bigfish/classification/__init__.py | 7 +++++--
 bigfish/segmentation/__init__.py   | 4 ++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/bigfish/classification/__init__.py b/bigfish/classification/__init__.py
index 2855eb38..31da148e 100644
--- a/bigfish/classification/__init__.py
+++ b/bigfish/classification/__init__.py
@@ -5,10 +5,13 @@
 patterns of the RNA.
 """
 
-from .squeezenet import SqueezeNet0
+# from .squeezenet import SqueezeNet0
 from .features import get_features, get_features_name
 
 # ### Load models ###
 
+_features = ["get_features", "get_features_name"]
 
-__all__ = ["SqueezeNet0", "get_features", "get_features_name"]
+# _squeezenet = ["SqueezeNet0"]
+
+__all__ = _features
diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index 443b8f14..84e04051 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -10,13 +10,13 @@
 from .nuc_segmentation import (filtered_threshold, remove_segmented_nuc)
 from .cyt_segmentation import (build_cyt_relief, build_cyt_binary_mask,
                                cyt_watershed)
-from .unet import get_input_size_unet
+# from .unet import get_input_size_unet
 
 _nuc = ["filtered_threshold", "remove_segmented_nuc"]
 
 _cyt = ["build_cyt_relief", "build_cyt_binary_mask", cyt_watershed]
 
-_unet = ["get_input_size_unet"]
+# _unet = ["get_input_size_unet"]
 
 _utils = ["label_instances", "compute_mean_size_object", "merge_labels",
           "get_boundaries"]

From 622dbef5d847eee1caf946a35af85e8ae1151483 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 1 Aug 2019 14:02:31 +0200
Subject: [PATCH 215/264] misc

---
 bigfish/plot/plot_images.py | 25 +++++++++++++++++++------
 bigfish/stack/projection.py |  1 +
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 0f9739d7..6ccd6b89 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -15,11 +15,12 @@
 from matplotlib.colors import ListedColormap
 
 
+# TODO clean this script (remove useless functions)
 # TODO add parameter to show the figure
 
 def plot_yx(tensor, r=0, c=0, z=0, rescale=False, title=None,
             framesize=(8, 8), remove_frame=False, path_output=None,
-            ext="png"):
+            ext="png", show=True):
     """Plot the selected yx plan of the selected dimensions of an image.
 
     Parameters
@@ -46,6 +47,8 @@ def plot_yx(tensor, r=0, c=0, z=0, rescale=False, title=None,
     ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
+    show : bool
+        Show the figure or not.
 
     Returns
     -------
@@ -96,13 +99,16 @@ def plot_yx(tensor, r=0, c=0, z=0, rescale=False, title=None,
         plt.tight_layout()
     if path_output is not None:
         save_plot(path_output, ext)
-    plt.show()
+    if show:
+        plt.show()
+    else:
+        plt.close()
 
     return
 
 
 def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
-                remove_frame=False, path_output=None, ext="png"):
+                remove_frame=False, path_output=None, ext="png", show=True):
     """Plot or subplot of 2-d images.
 
     Parameters
@@ -122,6 +128,8 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
     ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
+    show : bool
+        Show the figure or not.
 
     Returns
     -------
@@ -138,7 +146,8 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
                           framesize=tuple,
                           remove_frame=bool,
                           path_output=(str, type(None)),
-                          ext=(str, list))
+                          ext=(str, list),
+                          show=bool)
     for tensor in tensors:
         stack.check_array(tensor,
                           ndim=2,
@@ -162,7 +171,8 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
                 framesize=framesize,
                 remove_frame=remove_frame,
                 path_output=path_output,
-                ext=ext)
+                ext=ext,
+                show=show)
 
         return
 
@@ -208,7 +218,10 @@ def plot_images(tensors, rescale=False, titles=None, framesize=(15, 5),
     plt.tight_layout()
     if path_output is not None:
         save_plot(path_output, ext)
-    plt.show()
+    if show:
+        plt.show()
+    else:
+        plt.close()
 
     return
 
diff --git a/bigfish/stack/projection.py b/bigfish/stack/projection.py
index ae481691..d77edc11 100644
--- a/bigfish/stack/projection.py
+++ b/bigfish/stack/projection.py
@@ -168,6 +168,7 @@ def focus_projection_fast(tensor, proportion=0.75, neighborhood_size=7,
         A 2-d tensor with shape (y, x).
 
     """
+    # TODO case where proportion = {0, 1}
     # check parameters
     check_array(tensor, ndim=3, dtype=[np.uint8, np.uint16], allow_nan=False)
     check_parameter(proportion=(float, int),

From 97ff5d9169fbc98bd533fa687e612980ec7ab1b2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 1 Aug 2019 14:41:08 +0200
Subject: [PATCH 216/264] minor fix cluster decomposition

---
 bigfish/detection/cluster_decomposition.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/detection/cluster_decomposition.py b/bigfish/detection/cluster_decomposition.py
index 9894195a..b8247b4a 100644
--- a/bigfish/detection/cluster_decomposition.py
+++ b/bigfish/detection/cluster_decomposition.py
@@ -959,7 +959,7 @@ def filter_clusters(image, cc, spots, min_area=2):
     if regions.size == 0:
         regions_filtered = np.array([])
         spots_out_region = np.array([], dtype=np.int64).reshape((0, 3))
-        return regions_filtered, spots_out_region
+        return regions_filtered, spots_out_region, 0
 
     # TODO keep this step?
     # keep the brightest regions
@@ -970,7 +970,7 @@ def filter_clusters(image, cc, spots, min_area=2):
     # case where no connected region were detected
     if regions.size == 0:
         spots_out_region = np.array([], dtype=np.int64).reshape((0, 2))
-        return regions_filtered, spots_out_region
+        return regions_filtered, spots_out_region, 0
 
     # get information about regions
     mask_spots_out = np.ones(spots[:, 0].shape, dtype=bool)

From ca4f14a103f19a23313441b60c014a4645baca57 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 1 Aug 2019 15:17:52 +0200
Subject: [PATCH 217/264] fix cluster filtering

---
 bigfish/detection/cluster_decomposition.py | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/bigfish/detection/cluster_decomposition.py b/bigfish/detection/cluster_decomposition.py
index b8247b4a..40e3b893 100644
--- a/bigfish/detection/cluster_decomposition.py
+++ b/bigfish/detection/cluster_decomposition.py
@@ -958,8 +958,7 @@ def filter_clusters(image, cc, spots, min_area=2):
     # case where no region big enough were detected
     if regions.size == 0:
         regions_filtered = np.array([])
-        spots_out_region = np.array([], dtype=np.int64).reshape((0, 3))
-        return regions_filtered, spots_out_region, 0
+        return regions_filtered, spots, 0
 
     # TODO keep this step?
     # keep the brightest regions
@@ -967,10 +966,9 @@ def filter_clusters(image, cc, spots, min_area=2):
     regions_filtered = regions[high_intensity]
     bbox = bbox[high_intensity]
 
-    # case where no connected region were detected
-    if regions.size == 0:
-        spots_out_region = np.array([], dtype=np.int64).reshape((0, 2))
-        return regions_filtered, spots_out_region, 0
+    # case where no region bright enough were detected
+    if regions_filtered.size == 0:
+        return regions_filtered, spots, 0
 
     # get information about regions
     mask_spots_out = np.ones(spots[:, 0].shape, dtype=bool)
@@ -997,7 +995,7 @@ def filter_clusters(image, cc, spots, min_area=2):
     spots_out_region = spots.copy()
     spots_out_region = spots_out_region[mask_spots_out]
 
-    return regions_filtered, spots_out_region, max_region_size
+    return regions_filtered, spots_out_region, int(max_region_size)
 
 
 def decompose_clusters(image, cluster_regions, resolution_z, resolution_yx,

From e4cce99ee27f6650ea1640c122219a4cbe4381d2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 1 Aug 2019 17:25:43 +0200
Subject: [PATCH 218/264] fix foci detection when no foci is detected

---
 bigfish/detection/foci_detection.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bigfish/detection/foci_detection.py b/bigfish/detection/foci_detection.py
index ee6ac6da..6d2e2b36 100644
--- a/bigfish/detection/foci_detection.py
+++ b/bigfish/detection/foci_detection.py
@@ -109,6 +109,9 @@ def extract_foci(clustered_spots):
     """
     # get foci labels
     labels_foci = np.unique(clustered_spots[clustered_spots[:, 3] != -1, 3])
+    if labels_foci.size == 0:
+        foci = np.array([], dtype=np.int64).reshape((0, 5))
+        return foci
 
     # get foci's information
     foci = []

From 761c6331ef89c67683561533cebdcf72c06c57a3 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 2 Aug 2019 13:03:57 +0200
Subject: [PATCH 219/264] add area features and normalize ratio_in_nuc feature

---
 bigfish/classification/features.py | 43 +++++++++++++++++++++++++-----
 1 file changed, 36 insertions(+), 7 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 55f1406c..6522f0c5 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -149,7 +149,7 @@ def features_distance(mask_rna, distance_cyt, distance_nuc,
     return features
 
 
-def feature_in_out_nucleus(mask_nuc, distance_nuc, mask_rna):
+def feature_in_out_nucleus(mask_nuc, mask_rna):
     """
 
     Parameters
@@ -166,8 +166,8 @@ def feature_in_out_nucleus(mask_nuc, distance_nuc, mask_rna):
     # TODO add documentation
     # compute the ratio between rna in and out nucleus
     rna_in = mask_rna[mask_nuc].sum()
-    rna_out = mask_rna[distance_nuc > 0].sum()
-    feature = rna_in / rna_out
+    nb_rna = mask_rna.sum()
+    feature = rna_in / nb_rna
 
     return feature
 
@@ -370,6 +370,33 @@ def feature_dispersion(mask_cyt, rna_coord, centroid_rna):
     return feature
 
 
+def feature_area(mask_cyt, mask_nuc):
+    """
+
+    Parameters
+    ----------
+    mask_cyt
+    mask_nuc
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get area of the cytoplasm and the nucleus
+    area_cyt = mask_cyt.sum()
+    area_nuc = mask_nuc.sum()
+
+    # compute relative area of the nucleus
+    relative_area_nuc = area_nuc / area_cyt
+
+    # return features
+    features = [relative_area_nuc, area_cyt, area_nuc]
+
+    return features
+
+
 def get_features(cyt_coord, nuc_coord, rna_coord):
     """Compute cell features.
 
@@ -412,14 +439,15 @@ def get_features(cyt_coord, nuc_coord, rna_coord):
     # compute features
     a = features_distance(mask_rna, distance_cyt, distance_nuc,
                           distance_cyt_centroid, distance_nuc_centroid)
-    b = feature_in_out_nucleus(mask_nuc, distance_nuc, mask_rna)
+    b = feature_in_out_nucleus(mask_nuc, mask_rna)
     opening_sizes = [15, 30, 45, 60]
     c = features_opening(opening_sizes, mask_cyt, mask_rna)
     radii = [r for r in range(40)]
     d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
     e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
     f = feature_dispersion(mask_cyt, rna_coord, centroid_rna)
-    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
+    g = feature_area(mask_cyt, mask_nuc)
+    features = np.array(a + [b] + c + d + [e] + [f] + g, dtype=np.float32)
 
     return features
 
@@ -440,10 +468,11 @@ def get_features_name():
                      "quantile_10_dist_cyt", "quantile_20_dist_cyt",
                      "quantile_50_dist_cyt", "average_dist_cyt_centroid",
                      "average_dist_nuc", "average_dist_nuc_centroid",
-                     "ratio_in_out_nuc", "diff_opening_15", "diff_opening_30",
+                     "ratio_in_nuc", "diff_opening_15", "diff_opening_30",
                      "diff_opening_45", "diff_opening_60", "ripley_max",
                      "ripley_max_gradient", "ripley_min_gradient",
                      "ripley_monotony", "ripley_large", "polarization_index",
-                     "dispersion_index"]
+                     "dispersion_index", "ratio_area_nuc", "area_cyt",
+                     "area_nuc"]
 
     return features_name

From 29becc1636a47ec7b3b476daaf81b0b6e688c98d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 19 Aug 2019 01:19:14 +0200
Subject: [PATCH 220/264] add features Aubin

---
 bigfish/classification/__init__.py |   2 +-
 bigfish/classification/features.py | 153 +++++++++++++++++++++++++++--
 2 files changed, 146 insertions(+), 9 deletions(-)

diff --git a/bigfish/classification/__init__.py b/bigfish/classification/__init__.py
index 31da148e..9fe795e4 100644
--- a/bigfish/classification/__init__.py
+++ b/bigfish/classification/__init__.py
@@ -10,7 +10,7 @@
 
 # ### Load models ###
 
-_features = ["get_features", "get_features_name"]
+_features = ["get_features", "get_features_name", "get_features_aubin"]
 
 # _squeezenet = ["SqueezeNet0"]
 
diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 6522f0c5..d0eeb5e5 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -115,6 +115,63 @@ def features_distance(mask_rna, distance_cyt, distance_nuc,
     """
     # TODO add sanity check functions
     # TODO add documentation
+    # get rna outside nucleus
+    mask_rna_out = mask_rna.copy()
+    mask_rna_out[distance_nuc == 0] = 0
+
+    # compute average distances to cytoplasm and quantiles
+    factor = distance_cyt[distance_nuc > 0].mean()
+    mean_distance_cyt = distance_cyt[mask_rna_out].mean() / factor
+    quantile_5_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 5)
+    quantile_5_distance_cyt /= factor
+    quantile_10_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 10)
+    quantile_10_distance_cyt /= factor
+    quantile_20_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 20)
+    quantile_20_distance_cyt /= factor
+    quantile_50_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 50)
+    quantile_50_distance_cyt /= factor
+
+    # compute average distances to cytoplasm centroid
+    factor = distance_cyt_centroid[distance_nuc > 0].mean()
+    mean_distance_cyt_centroid = distance_cyt_centroid[mask_rna_out].mean()
+    mean_distance_cyt_centroid /= factor
+
+    # compute average distances to nucleus
+    factor = distance_nuc[distance_nuc > 0].mean()
+    mean_distance_nuc = distance_nuc[mask_rna_out].mean() / factor
+
+    # compute average distances to nucleus centroid
+    factor = distance_nuc_centroid[distance_nuc > 0].mean()
+    mean_distance_nuc_centroid = distance_nuc_centroid[mask_rna_out].mean()
+    mean_distance_nuc_centroid /= factor
+
+    features = [mean_distance_cyt, quantile_5_distance_cyt,
+                quantile_10_distance_cyt, quantile_20_distance_cyt,
+                quantile_50_distance_cyt, mean_distance_cyt_centroid,
+                mean_distance_nuc, mean_distance_nuc_centroid]
+
+    return features
+
+
+def features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
+                            distance_cyt_centroid, distance_nuc_centroid):
+    """
+
+    Parameters
+    ----------
+    mask_rna
+    distance_cyt
+    distance_nuc
+    distance_cyt_centroid
+    distance_nuc_centroid
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+
     # compute average distances to cytoplasm and quantiles
     factor = distance_cyt[distance_cyt > 0].mean()
     mean_distance_cyt = distance_cyt[mask_rna].mean() / factor
@@ -155,7 +212,6 @@ def feature_in_out_nucleus(mask_nuc, mask_rna):
     Parameters
     ----------
     mask_nuc
-    distance_nuc
     mask_rna
 
     Returns
@@ -164,7 +220,7 @@ def feature_in_out_nucleus(mask_nuc, mask_rna):
     """
     # TODO add sanity check functions
     # TODO add documentation
-    # compute the ratio between rna in and out nucleus
+    # compute the proportion of rna in the nucleus
     rna_in = mask_rna[mask_nuc].sum()
     nb_rna = mask_rna.sum()
     feature = rna_in / nb_rna
@@ -172,6 +228,29 @@ def feature_in_out_nucleus(mask_nuc, mask_rna):
     return feature
 
 
+def feature_in_out_nucleus_aubin(mask_nuc, mask_rna, distance_nuc):
+    """
+
+    Parameters
+    ----------
+    mask_nuc
+    distance_nuc
+    mask_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute the ratio between rna in and out nucleus
+    rna_in = mask_rna[mask_nuc].sum()
+    rna_out = mask_rna[distance_nuc > 0].sum()
+    feature = rna_in / rna_out
+
+    return feature
+
+
 def features_opening(opening_sizes, mask_cyt, mask_rna):
     """
 
@@ -297,6 +376,7 @@ def features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
 
     # compute features
     index_max = np.argmax(smoothed_values)
+    max_radius = radii[index_max]
     max_value = smoothed_values[index_max]
     if index_max == 0:
         max_gradient = gradients[0]
@@ -311,7 +391,8 @@ def features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
     max_size_cell = np.max(distances_cell)
     big_radius = int(max_size_cell / 4)
     big_value = ripley_values([big_radius], mask_cyt, rna_coord, mask_rna)[0]
-    features = [max_value, max_gradient, min_gradient, monotony, big_value]
+    features = [max_value, max_gradient, min_gradient, monotony, big_value,
+                max_radius]
 
     return features
 
@@ -397,6 +478,10 @@ def feature_area(mask_cyt, mask_nuc):
     return features
 
 
+def feature_height():
+    return
+
+
 def get_features(cyt_coord, nuc_coord, rna_coord):
     """Compute cell features.
 
@@ -446,8 +531,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord):
     d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
     e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
     f = feature_dispersion(mask_cyt, rna_coord, centroid_rna)
-    g = feature_area(mask_cyt, mask_nuc)
-    features = np.array(a + [b] + c + d + [e] + [f] + g, dtype=np.float32)
+    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
 
     return features
 
@@ -471,8 +555,61 @@ def get_features_name():
                      "ratio_in_nuc", "diff_opening_15", "diff_opening_30",
                      "diff_opening_45", "diff_opening_60", "ripley_max",
                      "ripley_max_gradient", "ripley_min_gradient",
-                     "ripley_monotony", "ripley_large", "polarization_index",
-                     "dispersion_index", "ratio_area_nuc", "area_cyt",
-                     "area_nuc"]
+                     "ripley_monotony", "ripley_large", "ripley_radius_max",
+                     "polarization_index", "dispersion_index"]
 
     return features_name
+
+
+def get_features_aubin(cyt_coord, nuc_coord, rna_coord):
+    """Compute cell features.
+
+    Parameters
+    ----------
+    cyt_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    nuc_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    rna_coord : np.ndarray, np.int64
+        Coordinate yx of the detected rna with shape (nb_rna, 2).
+
+    Returns
+    -------
+    features : List[float]
+        List of features (cf. features.get_features_name()).
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # TODO filter features
+    # get a binary representation of the coordinates
+    cyt, nuc, mask_rna = from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord)
+
+    # fill in masks
+    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
+
+    # compute distance maps for the cytoplasm and the nucleus
+    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
+
+    # get centroids
+    centroid_cyt = get_centroid(mask_cyt)
+    centroid_nuc = get_centroid(mask_nuc)
+    centroid_rna = np.mean(rna_coord, axis=0, dtype=np.int64)
+
+    # get centroid distance maps
+    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
+    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+
+    # compute features
+    a = features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
+                                distance_cyt_centroid, distance_nuc_centroid)
+    b = feature_in_out_nucleus_aubin(mask_nuc, mask_rna, distance_nuc)
+    opening_sizes = [15, 30, 45, 60]
+    c = features_opening(opening_sizes, mask_cyt, mask_rna)
+    radii = [r for r in range(40)]
+    d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
+    e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
+    f = feature_dispersion(mask_cyt, rna_coord, centroid_rna)
+    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
+
+    return features

From 720b3c12372bb53a36be6e4b065c0f96705fdf0a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 19 Aug 2019 11:22:46 +0200
Subject: [PATCH 221/264] add Aubin's features

---
 bigfish/classification/__init__.py |   2 +-
 bigfish/classification/features.py | 150 +++++++++++++++++++++++++----
 2 files changed, 130 insertions(+), 22 deletions(-)

diff --git a/bigfish/classification/__init__.py b/bigfish/classification/__init__.py
index 9fe795e4..5fe6fd0c 100644
--- a/bigfish/classification/__init__.py
+++ b/bigfish/classification/__init__.py
@@ -6,7 +6,7 @@
 """
 
 # from .squeezenet import SqueezeNet0
-from .features import get_features, get_features_name
+from .features import get_features, get_features_name, get_features_aubin
 
 # ### Load models ###
 
diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index d0eeb5e5..2f059d38 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -97,13 +97,13 @@ def get_centroid_distance_map(centroid_coordinate, mask_cyt):
     return distance_map
 
 
-def features_distance(mask_rna, distance_cyt, distance_nuc,
+def features_distance(mask_rna_out, distance_cyt, distance_nuc,
                       distance_cyt_centroid, distance_nuc_centroid):
     """
 
     Parameters
     ----------
-    mask_rna
+    mask_rna_out
     distance_cyt
     distance_nuc
     distance_cyt_centroid
@@ -115,9 +115,9 @@ def features_distance(mask_rna, distance_cyt, distance_nuc,
     """
     # TODO add sanity check functions
     # TODO add documentation
-    # get rna outside nucleus
-    mask_rna_out = mask_rna.copy()
-    mask_rna_out[distance_nuc == 0] = 0
+    if mask_rna_out.sum() == 0:
+        features = [1., 1., 1., 1., 1., 1., 1., 1.]
+        return features
 
     # compute average distances to cytoplasm and quantiles
     factor = distance_cyt[distance_nuc > 0].mean()
@@ -228,14 +228,14 @@ def feature_in_out_nucleus(mask_nuc, mask_rna):
     return feature
 
 
-def feature_in_out_nucleus_aubin(mask_nuc, mask_rna, distance_nuc):
+def feature_in_out_nucleus_aubin(mask_nuc, mask_rna, mask_rna_out):
     """
 
     Parameters
     ----------
     mask_nuc
-    distance_nuc
     mask_rna
+    mask_rna_out
 
     Returns
     -------
@@ -245,13 +245,48 @@ def feature_in_out_nucleus_aubin(mask_nuc, mask_rna, distance_nuc):
     # TODO add documentation
     # compute the ratio between rna in and out nucleus
     rna_in = mask_rna[mask_nuc].sum()
-    rna_out = mask_rna[distance_nuc > 0].sum()
+    rna_out = max(mask_rna_out.sum(), 1)
     feature = rna_in / rna_out
 
     return feature
 
 
-def features_opening(opening_sizes, mask_cyt, mask_rna):
+def features_opening(opening_sizes, mask_cyt, mask_rna_out):
+    """
+
+    Parameters
+    ----------
+    opening_sizes
+    mask_cyt
+    mask_rna_out
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get number of rna outside nucleus
+    nb_rna_out = mask_rna_out.sum()
+
+    # case where we do not detect any rna outside the nucleus
+    if nb_rna_out == 0:
+        features = [0. for _ in opening_sizes]
+        return features
+
+    # apply opening operator and count the loss of rna outside the nucleus
+    features = []
+    for size in opening_sizes:
+        s = disk(size, dtype=bool)
+        mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
+        nb_rna_out_after_opening = mask_rna_out[mask_cyt_transformed > 0].sum()
+        diff_opening = (nb_rna_out - nb_rna_out_after_opening) / nb_rna_out
+        features.append(diff_opening)
+
+    return features
+
+
+def features_opening_aubin(opening_sizes, mask_cyt, mask_rna):
     """
 
     Parameters
@@ -348,7 +383,62 @@ def moving_average(a, n=4):
     return averaged_array
 
 
-def features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
+def features_ripley(radii, cyt_coord, mask_cyt, rna_coord_out, mask_rna_out):
+    """
+
+    Parameters
+    ----------
+    radii
+    cyt_coord
+    mask_cyt
+    rna_coord_out
+    mask_rna_out
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # case where we do not detect any rna outside the nucleus
+    if len(rna_coord_out) == 0:
+        features = [0., 0., 0., 0., 0., 0.]
+        return features
+
+    # compute corrected Ripley values for different radii
+    values = ripley_values(radii, mask_cyt, rna_coord_out, mask_rna_out)
+
+    # smooth them using moving average
+    smoothed_values = moving_average(values, n=4)
+
+    # compute the gradients of these values
+    gradients = np.gradient(smoothed_values)
+
+    # compute features
+    index_max = np.argmax(smoothed_values)
+    max_radius = radii[index_max]
+    max_value = smoothed_values[index_max]
+    if index_max == 0:
+        max_gradient = gradients[0]
+    else:
+        max_gradient = max(gradients[:index_max])
+    if index_max == len(gradients) - 1:
+        min_gradient = gradients[-1]
+    else:
+        min_gradient = min(gradients[index_max:])
+    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
+    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
+    max_size_cell = np.max(distances_cell)
+    big_radius = int(max_size_cell / 4)
+    big_value = ripley_values([big_radius], mask_cyt, rna_coord_out,
+                              mask_rna_out)[0]
+    features = [max_value, max_gradient, min_gradient, monotony, big_value,
+                max_radius]
+
+    return features
+
+
+def features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
     """
 
     Parameters
@@ -404,7 +494,6 @@ def feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna):
     ----------
     distance_cyt
     distance_cyt_centroid
-    rna_coord
     centroid_rna
 
     Returns
@@ -437,6 +526,10 @@ def feature_dispersion(mask_cyt, rna_coord, centroid_rna):
     # TODO add sanity check functions
     # TODO add documentation
     # TODO correct the formula
+    # case where we do not detect rna outside nucleus
+    if len(rna_coord) == 0:
+        return 1.
+
     # get coordinates of each pixel of the cell
     mask_cyt_coord = np.nonzero(mask_cyt)
     mask_cyt_coord = np.column_stack(mask_cyt_coord)
@@ -512,25 +605,36 @@ def get_features(cyt_coord, nuc_coord, rna_coord):
     # compute distance maps for the cytoplasm and the nucleus
     distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
 
+    # get rna outside nucleus
+    mask_rna_out = mask_rna.copy()
+    mask_rna_out[distance_nuc == 0] = 0
+    rna_coord_out = np.nonzero(mask_rna_out)
+    rna_coord_out = np.column_stack(rna_coord_out)
+
     # get centroids
     centroid_cyt = get_centroid(mask_cyt)
     centroid_nuc = get_centroid(mask_nuc)
-    centroid_rna = np.mean(rna_coord, axis=0, dtype=np.int64)
+    if len(rna_coord_out) == 0:
+        centroid_rna_out = centroid_cyt
+    else:
+        centroid_rna_out = np.mean(rna_coord_out, axis=0, dtype=np.int64)
 
     # get centroid distance maps
     distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
     distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
 
     # compute features
-    a = features_distance(mask_rna, distance_cyt, distance_nuc,
+    a = features_distance(mask_rna_out, distance_cyt, distance_nuc,
                           distance_cyt_centroid, distance_nuc_centroid)
     b = feature_in_out_nucleus(mask_nuc, mask_rna)
     opening_sizes = [15, 30, 45, 60]
-    c = features_opening(opening_sizes, mask_cyt, mask_rna)
+    c = features_opening(opening_sizes, mask_cyt, mask_rna_out)
     radii = [r for r in range(40)]
-    d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
-    e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
-    f = feature_dispersion(mask_cyt, rna_coord, centroid_rna)
+    d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord_out,
+                        mask_rna_out)
+    e = feature_polarization(distance_cyt, distance_cyt_centroid,
+                             centroid_rna_out)
+    f = feature_dispersion(mask_cyt, rna_coord_out, centroid_rna_out)
     features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
 
     return features
@@ -562,7 +666,7 @@ def get_features_name():
 
 
 def get_features_aubin(cyt_coord, nuc_coord, rna_coord):
-    """Compute cell features.
+    """Compute cell features, according to Aubin's paper.
 
     Parameters
     ----------
@@ -600,14 +704,18 @@ def get_features_aubin(cyt_coord, nuc_coord, rna_coord):
     distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
     distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
 
+    # get rna outside nucleus
+    mask_rna_out = mask_rna.copy()
+    mask_rna_out[distance_nuc == 0] = 0
+
     # compute features
     a = features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
                                 distance_cyt_centroid, distance_nuc_centroid)
-    b = feature_in_out_nucleus_aubin(mask_nuc, mask_rna, distance_nuc)
+    b = feature_in_out_nucleus_aubin(mask_nuc, mask_rna, mask_rna_out)
     opening_sizes = [15, 30, 45, 60]
-    c = features_opening(opening_sizes, mask_cyt, mask_rna)
+    c = features_opening_aubin(opening_sizes, mask_cyt, mask_rna)
     radii = [r for r in range(40)]
-    d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
+    d = features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
     e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
     f = feature_dispersion(mask_cyt, rna_coord, centroid_rna)
     features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)

From 75b16708f88c96edbe0085c891fd5606da5335c4 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 21 Aug 2019 12:14:08 +0200
Subject: [PATCH 222/264] misc

---
 bigfish/stack/preprocess.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index f5712fe3..f5807ebe 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -323,8 +323,7 @@ def build_stack(recipe, input_folder, input_dimension=None, i_fov=0,
     if check:
         check_array(tensor,
                     ndim=5,
-                    dtype=[np.uint8, np.uint16],
-                    allow_nan=False)
+                    dtype=[np.uint8, np.uint16])
 
     # rescale data and improve contrast
     if normalize:

From 0a0aaef36f4416fdd9161ebf317fbfef00122d2a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 21 Aug 2019 14:10:30 +0200
Subject: [PATCH 223/264] misc

---
 bigfish/plot/plot_images.py      | 47 ++++++++++++++++++++-----------
 bigfish/segmentation/__init__.py |  4 +--
 bigfish/segmentation/utils.py    | 44 +++++++++++++++++++++++++++--
 bigfish/stack/__init__.py        |  5 ++--
 bigfish/stack/filter.py          | 48 +++++++++++++++++++++++++++++++-
 5 files changed, 125 insertions(+), 23 deletions(-)

diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index 6ccd6b89..d1302636 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -351,7 +351,7 @@ def plot_illumination_surface(illumination_surface, r=0, framesize=(15, 15),
 
 def plot_segmentation(tensor, mask, rescale=False, title=None,
                       framesize=(15, 5), remove_frame=False,
-                      path_output=None, ext="png"):
+                      path_output=None, ext="png", show=True):
     """Plot result of a 2-d segmentation, with labelled instances if available.
 
     Parameters
@@ -373,6 +373,8 @@ def plot_segmentation(tensor, mask, rescale=False, title=None,
     ext : str or List[str]
         Extension used to save the plot. If it is a list of strings, the plot
         will be saved several times.
+    show : bool
+        Show the figure or not.
 
     Returns
     -------
@@ -434,13 +436,16 @@ def plot_segmentation(tensor, mask, rescale=False, title=None,
     plt.tight_layout()
     if path_output is not None:
         save_plot(path_output, ext)
-    plt.show()
+    if show:
+        plt.show()
+    else:
+        plt.close()
 
     return
 
 
-def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
-                               title=None, framesize=(10, 10),
+def plot_segmentation_boundary(tensor, mask_nuc=None, mask_cyt=None,
+                               rescale=False, title=None, framesize=(10, 10),
                                remove_frame=False, path_output=None,
                                ext="png", show=True):
     """Plot the boundary of the segmented objects.
@@ -479,12 +484,14 @@ def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
                       dtype=[np.uint8, np.uint16,
                              np.float32, np.float64,
                              bool])
-    stack.check_array(mask_nuc,
-                      ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool])
-    stack.check_array(mask_cyt,
-                      ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool])
+    if mask_nuc is not None:
+        stack.check_array(mask_nuc,
+                          ndim=2,
+                          dtype=[np.uint8, np.uint16, np.int64, bool])
+    if mask_cyt is not None:
+        stack.check_array(mask_cyt,
+                          ndim=2,
+                          dtype=[np.uint8, np.uint16, np.int64, bool])
     stack.check_parameter(rescale=bool,
                           title=(str, type(None)),
                           framesize=tuple,
@@ -499,10 +506,16 @@ def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
         vmin, vmax = get_minmax_values(tensor)
 
     # get boundaries
-    boundaries_nuc = find_boundaries(mask_nuc, mode='inner')
-    boundaries_nuc = np.ma.masked_where(boundaries_nuc == 0, boundaries_nuc)
-    boundaries_cyt = find_boundaries(mask_cyt, mode='inner')
-    boundaries_cyt = np.ma.masked_where(boundaries_cyt == 0, boundaries_cyt)
+    boundaries_nuc = None
+    boundaries_cyt = None
+    if mask_nuc is not None:
+        boundaries_nuc = find_boundaries(mask_nuc, mode='inner')
+        boundaries_nuc = np.ma.masked_where(boundaries_nuc == 0,
+                                            boundaries_nuc)
+    if mask_cyt is not None:
+        boundaries_cyt = find_boundaries(mask_cyt, mode='inner')
+        boundaries_cyt = np.ma.masked_where(boundaries_cyt == 0,
+                                            boundaries_cyt)
 
     # plot
     if remove_frame:
@@ -515,8 +528,10 @@ def plot_segmentation_boundary(tensor, mask_nuc, mask_cyt, rescale=False,
         plt.imshow(tensor, vmin=vmin, vmax=vmax)
     else:
         plt.imshow(tensor)
-    plt.imshow(boundaries_nuc, cmap=ListedColormap(['blue']))
-    plt.imshow(boundaries_cyt, cmap=ListedColormap(['red']))
+    if mask_nuc is not None:
+        plt.imshow(boundaries_nuc, cmap=ListedColormap(['blue']))
+    if mask_cyt is not None:
+        plt.imshow(boundaries_cyt, cmap=ListedColormap(['red']))
     if title is not None and not remove_frame:
         plt.title(title, fontweight="bold", fontsize=25)
     if not remove_frame:
diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index 84e04051..1c27c526 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -6,7 +6,7 @@
 """
 
 from .utils import (label_instances, compute_mean_size_object, merge_labels,
-                    get_boundaries)
+                    get_boundaries, dilate_erode_labels)
 from .nuc_segmentation import (filtered_threshold, remove_segmented_nuc)
 from .cyt_segmentation import (build_cyt_relief, build_cyt_binary_mask,
                                cyt_watershed)
@@ -19,6 +19,6 @@
 # _unet = ["get_input_size_unet"]
 
 _utils = ["label_instances", "compute_mean_size_object", "merge_labels",
-          "get_boundaries"]
+          "get_boundaries", "dilate_erode_labels"]
 
 __all__ = _utils + _nuc + _cyt
diff --git a/bigfish/segmentation/utils.py b/bigfish/segmentation/utils.py
index 539b81a0..e9c0c7e5 100644
--- a/bigfish/segmentation/utils.py
+++ b/bigfish/segmentation/utils.py
@@ -91,7 +91,7 @@ def merge_labels(label_1, label_2):
 
     Returns
     -------
-    label : np.ndarray, np.int64
+    final_label : np.ndarray, np.int64
         Labelled image with shape (y, x).
 
     """
@@ -125,7 +125,47 @@ def merge_labels(label_1, label_2):
     label_2[label_2 > 0] += nb_label_1
     label = np.maximum(label_1, label_2)
 
-    return label
+    # postprocess label
+    label_dilated = stack.dilation_filter(label,
+                                          kernel_shape="disk",
+                                          kernel_size=1)
+    label_eroded = stack.erosion_filter(label,
+                                        kernel_shape="disk",
+                                        kernel_size=1)
+    final_label = label_dilated - label_eroded
+
+    return final_label
+
+
+def dilate_erode_labels(label):
+    """Substract an eroded label to a dilated one in order to prevent
+    boundaries contact.
+
+    Parameters
+    ----------
+    label : np.ndarray, np.uint or np.int
+        Labelled image with shape (y, x).
+
+    Returns
+    -------
+    label_final : np.ndarray, np.int64
+        Labelled image with shape (y, x).
+
+    """
+    # check parameters
+    stack.check_array(label,
+                      ndim=2,
+                      dtype=[np.uint8, np.uint16, np.int64])
+
+    # erode-dilate mask
+    label_dilated = stack.dilation_filter(label, "disk", 2)
+    label_eroded = stack.erosion_filter(label, "disk", 2)
+    borders = label_dilated - label_eroded
+    label_final = label.copy()
+    label_final[borders > 0] = 0
+    label_final = label_final.astype(np.int64)
+
+    return label_final
 
 
 def get_boundaries(mask):
diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 2c769b0c..429cb51e 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -17,7 +17,8 @@
                          deconstruct_image, reconstruct_image)
 from .filter import (log_filter, mean_filter, median_filter, maximum_filter,
                      minimum_filter, gaussian_filter, remove_background_mean,
-                     remove_background_gaussian, dilation_filter)
+                     remove_background_gaussian, dilation_filter,
+                     erosion_filter)
 from .projection import (maximum_projection, mean_projection,
                          median_projection, in_focus_selection,
                          focus_measurement, get_in_focus_indices,
@@ -50,7 +51,7 @@
 
 _filter = ["log_filter", "mean_filter", "median_filter", "maximum_filter",
            "minimum_filter", "gaussian_filter", "remove_background_mean",
-           "remove_background_gaussian", "dilation_filter"]
+           "remove_background_gaussian", "dilation_filter", "erosion_filter"]
 
 _projection = ["maximum_projection", "mean_projection", "median_projection",
                "in_focus_selection", "focus_measurement",
diff --git a/bigfish/stack/filter.py b/bigfish/stack/filter.py
index 7b7787fb..3e95550f 100644
--- a/bigfish/stack/filter.py
+++ b/bigfish/stack/filter.py
@@ -9,7 +9,8 @@
                          cast_img_uint16)
 
 from skimage.morphology.selem import square, diamond, rectangle, disk
-from skimage.morphology import binary_dilation, dilation
+from skimage.morphology import (binary_dilation, dilation, binary_erosion,
+                                erosion)
 from skimage.filters import rank, gaussian
 
 from scipy.ndimage import gaussian_laplace
@@ -450,3 +451,48 @@ def dilation_filter(image, kernel_shape=None, kernel_size=None):
         image_filtered = dilation(image, kernel)
 
     return image_filtered
+
+
+def erosion_filter(image, kernel_shape=None, kernel_size=None):
+    """Apply an erosion to a 2-d image.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image with shape (y, x).
+    kernel_shape : str
+        Shape of the kernel used to compute the filter ('diamond', 'disk',
+        'rectangle' or 'square').
+    kernel_size : int or Tuple(int)
+        The size of the kernel. For the rectangle we expect two integers
+        (width, height).
+
+    Returns
+    -------
+    image_filtered : np.ndarray, np.uint
+        Filtered 2-d image with shape (y, x).
+
+    """
+    # TODO check dtype
+    # check parameters
+    check_array(image,
+                ndim=2,
+                dtype=[np.uint8, np.uint16, bool])
+    check_parameter(kernel_shape=(str, type(None)),
+                    kernel_size=(int, tuple, list, type(None)))
+
+    # get kernel
+    if kernel_shape is None or kernel_size is None:
+        kernel = None
+    else:
+        kernel = _define_kernel(shape=kernel_shape,
+                                size=kernel_size,
+                                dtype=image.dtype)
+
+    # apply filter
+    if image.dtype == bool:
+        image_filtered = binary_erosion(image, kernel)
+    else:
+        image_filtered = erosion(image, kernel)
+
+    return image_filtered

From 43310cd82b3ec51fe0bbcee349d3baf72f6a790a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 22 Aug 2019 17:07:35 +0200
Subject: [PATCH 224/264] clean mask postprocessing

---
 bigfish/segmentation/utils.py | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/bigfish/segmentation/utils.py b/bigfish/segmentation/utils.py
index e9c0c7e5..4c48711c 100644
--- a/bigfish/segmentation/utils.py
+++ b/bigfish/segmentation/utils.py
@@ -91,7 +91,7 @@ def merge_labels(label_1, label_2):
 
     Returns
     -------
-    final_label : np.ndarray, np.int64
+    label : np.ndarray, np.int64
         Labelled image with shape (y, x).
 
     """
@@ -125,16 +125,7 @@ def merge_labels(label_1, label_2):
     label_2[label_2 > 0] += nb_label_1
     label = np.maximum(label_1, label_2)
 
-    # postprocess label
-    label_dilated = stack.dilation_filter(label,
-                                          kernel_shape="disk",
-                                          kernel_size=1)
-    label_eroded = stack.erosion_filter(label,
-                                        kernel_shape="disk",
-                                        kernel_size=1)
-    final_label = label_dilated - label_eroded
-
-    return final_label
+    return label
 
 
 def dilate_erode_labels(label):
@@ -157,6 +148,10 @@ def dilate_erode_labels(label):
                       ndim=2,
                       dtype=[np.uint8, np.uint16, np.int64])
 
+    # handle 64 bit integer
+    if label.dtype == np.int64:
+        label = label.astype(np.uint16)
+
     # erode-dilate mask
     label_dilated = stack.dilation_filter(label, "disk", 2)
     label_eroded = stack.erosion_filter(label, "disk", 2)

From 0f70ff8820ef05a1f0e50bcf39e3c597e490e2c9 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 12 Sep 2019 14:55:04 +0200
Subject: [PATCH 225/264] misc

---
 bigfish/detection/foci_detection.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bigfish/detection/foci_detection.py b/bigfish/detection/foci_detection.py
index 6d2e2b36..b0cd9874 100644
--- a/bigfish/detection/foci_detection.py
+++ b/bigfish/detection/foci_detection.py
@@ -43,6 +43,7 @@ def convert_spot_coordinates(spots, resolution_z, resolution_yx):
 
 def cluster_spots(spots, resolution_z, resolution_yx, radius, nb_min_spots):
     """
+    Assign a cluster to each spot.
 
     Parameters
     ----------

From 1370068453848c453c741fb3f473f4b843db6215 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 12 Sep 2019 14:55:24 +0200
Subject: [PATCH 226/264] update plot_cell

---
 bigfish/plot/plot_coordinates.py | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
index 6ba97d29..079b10b5 100644
--- a/bigfish/plot/plot_coordinates.py
+++ b/bigfish/plot/plot_coordinates.py
@@ -398,6 +398,7 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
               title=None, remove_frame=False, rescale=False,
               framesize=(15, 10), path_output=None, ext="png", show=True):
     """
+    Plot image and coordinates extracted for a specific cell.
 
     Parameters
     ----------
@@ -406,8 +407,8 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
     nuc_coord : np.ndarray, np.int64
         Coordinates of the nuclei border with shape (nb_points, 2).
     rna_coord : np.ndarray, np.int64
-        Coordinates of the RNA spots with shape (nb_spots, 3). One
-        coordinate per dimension (yx dimension), plus the index of a
+        Coordinates of the RNA spots with shape (nb_spots, 4). One
+        coordinate per dimension (zyx dimension), plus the index of a
         potential foci.
     foci_coord : np.ndarray, np.int64
         Array with shape (nb_foci, 5). One coordinate per dimension for the
@@ -498,14 +499,19 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
     # get rna layer
     rna = np.zeros(image_shape, dtype=bool)
     if rna_coord is not None:
-        rna[rna_coord[:, 0], rna_coord[:, 1]] = True
-        rna = stack.dilation_filter(rna, kernel_shape="square", kernel_size=3)
+        rna[rna_coord[:, 1], rna_coord[:, 2]] = True
+        rna = stack.dilation_filter(rna,
+                                    kernel_shape="square",
+                                    kernel_size=3)
 
     # get foci layer
     foci = np.zeros(image_shape, dtype=bool)
     if foci_coord is not None:
-        foci[foci_coord[:, 1], foci_coord[:, 2]] = True
-        foci = stack.dilation_filter(foci, kernel_shape="square", kernel_size=6)
+        rna_in_foci_coord = rna_coord[rna_coord[:, 3] != -1, :].copy()
+        foci[rna_in_foci_coord[:, 1], rna_in_foci_coord[:, 2]] = True
+        foci = stack.dilation_filter(foci,
+                                     kernel_shape="square",
+                                     kernel_size=3)
 
     # build image coordinate
     image_coord = np.ones((max_y, max_x, 3), dtype=np.float32)

From 4be1897140f1425067bda13bad871e64fee8f60d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 12 Sep 2019 14:56:47 +0200
Subject: [PATCH 227/264] update spots and foci extraction

---
 bigfish/stack/__init__.py    |   4 +-
 bigfish/stack/postprocess.py | 254 +++++++++++++++++++++++++++--------
 2 files changed, 203 insertions(+), 55 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 429cb51e..ab3dc00f 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -25,7 +25,7 @@
                          focus_projection, focus_projection_fast)
 from .illumination import (compute_illumination_surface,
                            correct_illumination_surface)
-from .postprocess import (remove_transcription_site, extract_spots,
+from .postprocess import (remove_transcription_site, extract_spots_from_frame,
                           extract_coordinates_image)
 from .preparation import (split_from_background, build_image, get_coordinates,
                           get_distance_layers, get_surface_layers, build_batch,
@@ -61,7 +61,7 @@
 _illumination = ["compute_illumination_surface",
                  "correct_illumination_surface"]
 
-_postprocess = ["remove_transcription_site", "extract_spots",
+_postprocess = ["remove_transcription_site", "extract_spots_from_frame",
                 "extract_coordinates_image"]
 
 _augmentation = ["augment"]
diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index 7e3ef9e2..bef3d279 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -8,12 +8,9 @@
 
 from .utils import check_array, check_parameter
 
-from skimage.segmentation import find_boundaries
-from skimage.measure import regionprops
+from skimage.measure import regionprops, find_contours
 
 
-# TODO use skimage.measure.find_contours
-
 # ### Transcription sites ###
 
 def remove_transcription_site(mask_nuc, spots_in_foci, foci):
@@ -59,20 +56,20 @@ def remove_transcription_site(mask_nuc, spots_in_foci, foci):
                 allow_nan=False)
 
     # remove foci inside nuclei
-    foci_cleaned = foci.copy()
-    spots_in_foci_cleaned = spots_in_foci.copy()
-    for (_, y, x, _, i_foci) in foci:
-        if mask_nuc[y, x]:
-            foci_cleaned = foci_cleaned[foci_cleaned[:, 4] != i_foci]
-            spots_in_foci_cleaned = spots_in_foci_cleaned[
-                spots_in_foci_cleaned[:, 3] != i_foci]
+    mask_transcription_site = mask_nuc[foci[:, 1], foci[:, 2]]
+    foci_cleaned = foci[~mask_transcription_site]
+
+    # filter spots in transcription sites
+    spots_to_keep = foci_cleaned[:, 4]
+    mask_spots_to_keep = np.isin(spots_in_foci[:, 3], spots_to_keep)
+    spots_in_foci_cleaned = spots_in_foci[mask_spots_to_keep]
 
     return spots_in_foci_cleaned, foci_cleaned
 
 
 # ### Cell extraction ###
 
-def extract_spots(spots, z_lim=None, y_lim=None, x_lim=None):
+def extract_spots_from_frame(spots, z_lim=None, y_lim=None, x_lim=None):
     """Get spots coordinates within a given frame.
 
     Parameters
@@ -130,7 +127,7 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
 
     For each cell in an image we return the coordinates of the cytoplasm, the
     nucleus, the RNA spots and information about the detected foci. We extract
-    2-d coordinates.
+    2-d coordinates for the cell and 3-d coordinates for the spots and foci.
 
     Parameters
     ----------
@@ -140,7 +137,8 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
         Labelled nuclei image with shape (y, x).
     spots_out : np.ndarray, np.int64
         Coordinate of the spots detected outside foci, with shape
-        (nb_spots, 3). One coordinate per dimension (zyx coordinates).
+        (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus a
+        default index (-1 for mRNAs spotted outside a foci).
     spots_in : np.ndarray, np.int64
         Coordinate of the spots detected inside foci, with shape (nb_spots, 4).
         One coordinate per dimension (zyx coordinates) plus the index of the
@@ -158,8 +156,8 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
         - nuc_coord : np.ndarray, np.int64
             Coordinates of the nuclei border with shape (nb_points, 2).
         - rna_coord : np.ndarray, np.int64
-            Coordinates of the RNA spots with shape (nb_spots, 3). One
-            coordinate per dimension (yx dimension), plus the index of a
+            Coordinates of the RNA spots with shape (nb_spots, 4). One
+            coordinate per dimension (zyx dimension), plus the index of a
             potential foci.
         - cell_foci : np.ndarray, np.int64
             Array with shape (nb_foci, 5). One coordinate per dimension for the
@@ -170,7 +168,6 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
             max_y and max_x).
 
     """
-    # TODO implement several smaller functions
     # check parameters
     check_array(cyt_labelled,
                 ndim=2,
@@ -213,46 +210,24 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
         nuc = nuc_labelled.copy()
         nuc = (nuc == label)
 
-        # check cell is not cropped by the borders
-        crop = cyt & borders
-        if np.any(crop):
+        # check if cell is not cropped by the borders
+        if _check_cropped_cell(cyt, borders):
             continue
 
-        # check nucleus is in the cytoplasm
-        diff = cyt | nuc
-        if np.any(diff != cyt):
+        # check if nucleus is in the cytoplasm
+        if not _check_nucleus_in_cell(cyt, nuc):
             continue
 
         # get boundaries coordinates
-        # TODO replace by find_contour
-        cyt_coord = find_boundaries(cyt, mode='inner')
-        cyt_coord = np.nonzero(cyt_coord)
-        cyt_coord = np.column_stack(cyt_coord)
-        nuc_coord = find_boundaries(nuc, mode='inner')
-        nuc_coord = np.nonzero(nuc_coord)
-        nuc_coord = np.column_stack(nuc_coord)
+        cyt_coord, nuc_coord = _get_boundaries_coordinates(cyt, nuc)
 
         # filter foci
-        cell_foci = foci.copy()
-        cell_spots_in = spots_in.copy()
-        for (_, y, x, _, i_foci) in foci:
-            if cyt_labelled[y, x] != label:
-                cell_foci = cell_foci[cell_foci[:, 4] != i_foci]
-                cell_spots_in = cell_spots_in[cell_spots_in[:, 3] != i_foci]
+        foci_cell, spots_in_foci_cell = _extract_foci(foci, spots_in, cyt)
 
         # get rna coordinates
-        image_shape = cyt_labelled.shape
-        rna_out = np.zeros(image_shape, dtype=bool)
-        rna_out[spots_out[:, 1], spots_out[:, 2]] = True
-        rna_out = (rna_out & cyt)
-        rna_out = np.nonzero(rna_out)
-        rna_out = np.column_stack(rna_out)
-        rna_in = np.zeros(image_shape, dtype=bool)
-        rna_in[cell_spots_in[:, 1], cell_spots_in[:, 2]] = True
-        rna_in = (rna_in & cyt)
-        rna_in = np.nonzero(rna_in)
-        rna_in = np.column_stack(rna_in)
-        rna_coord = np.concatenate([rna_out, rna_in], axis=0)
+        spots_out_foci_cell = _extract_spots_outside_foci(cyt, spots_out)
+        rna_coord = np.concatenate([spots_out_foci_cell, spots_in_foci_cell],
+                                   axis=0)
 
         # filter cell without enough spots
         if len(rna_coord) < 30:
@@ -263,11 +238,184 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
         cyt_coord[:, 1] -= min_x
         nuc_coord[:, 0] -= min_y
         nuc_coord[:, 1] -= min_x
-        rna_coord[:, 0] -= min_y
-        rna_coord[:, 1] -= min_x
-        cell_foci[:, 1] -= min_y
-        cell_foci[:, 2] -= min_x
+        rna_coord[:, 1] -= min_y
+        rna_coord[:, 2] -= min_x
+        foci_cell[:, 1] -= min_y
+        foci_cell[:, 2] -= min_x
 
-        results.append((cyt_coord, nuc_coord, rna_coord, cell_foci, cell.bbox))
+        results.append((cyt_coord, nuc_coord, rna_coord, foci_cell, cell.bbox))
 
     return results
+
+
+def _check_cropped_cell(cell_cyt_mask, border_frame):
+    """
+    Check if a cell is cropped by the border frame.
+
+    Parameters
+    ----------
+    cell_cyt_mask : np.ndarray, bool
+        Binary mask of the cell cytoplasm.
+
+    border_frame : np.ndarray, bool
+        Binary mask of the border frame.
+
+    Returns
+    -------
+    _ : bool
+        True if cell is cropped.
+
+    """
+    # check cell is not cropped by the borders
+    crop = cell_cyt_mask & border_frame
+    if np.any(crop):
+        return True
+    else:
+        return False
+
+
+def _check_nucleus_in_cell(cell_cyt_mask, cell_nuc_mask):
+    """
+    Check if the nucleus is properly contained in the cell cytoplasm.
+
+    Parameters
+    ----------
+    cell_cyt_mask : np.ndarray, bool
+        Binary mask of the cell cytoplasm.
+
+    cell_nuc_mask : np.ndarray, bool
+        Binary mask of the nucleus cytoplasm.
+
+    Returns
+    -------
+    _ : bool
+        True if the nucleus is in the cell.
+
+    """
+    diff = cell_cyt_mask | cell_nuc_mask
+    if np.any(diff != cell_cyt_mask):
+        return False
+    else:
+        return True
+
+
+def _get_boundaries_coordinates(cell_cyt_mask, cell_nuc_mask):
+    """
+    Find boundaries coordinates for cytoplasm and nucleus.
+
+    Parameters
+    ----------
+    cell_cyt_mask : np.ndarray, bool
+        Mask of the cell cytoplasm.
+    cell_nuc_mask : np.ndarray, bool
+        Mask of the cell nucleus.
+
+    Returns
+    -------
+    cyt_coord : np.ndarray, np.int64
+        Coordinates of the cytoplasm in 2-d (yx dimension).
+    nuc_coord : np.ndarray, np.int64
+        Coordinates of the nucleus in 2-d (yx dimension).
+
+    """
+    cyt_coord = np.array([], dtype=np.int64).reshape((0, 2))
+    nuc_coord = np.array([], dtype=np.int64).reshape((0, 2))
+
+    # cyt coordinates
+    cell_cyt_coord = find_contours(cell_cyt_mask, level=0)
+    if len(cell_cyt_coord) == 0:
+        pass
+    elif len(cell_cyt_coord) == 1:
+        cyt_coord = cell_cyt_coord[0].astype(np.int64)
+    else:
+        m = 0
+        for coord in cell_cyt_coord:
+            if len(coord) > m:
+                m = len(coord)
+                cyt_coord = coord.astype(np.int64)
+
+    # nuc coordinates
+    cell_nuc_coord = find_contours(cell_nuc_mask, level=0)
+    if len(cell_nuc_coord) == 0:
+        pass
+    elif len(cell_nuc_coord) == 1:
+        nuc_coord = cell_nuc_coord[0].astype(np.int64)
+    else:
+        m = 0
+        for coord in cell_nuc_coord:
+            if len(coord) > m:
+                m = len(coord)
+                nuc_coord = coord.astype(np.int64)
+
+    return cyt_coord, nuc_coord
+
+
+def _extract_foci(foci, spots_in_foci, cell_cyt_mask):
+    """
+    Extract foci and related spots detected in a specific cell.
+
+    Parameters
+    ----------
+    foci : np.ndarray, np.int64
+        Array with shape (nb_foci, 5). One coordinate per dimension for the
+        foci centroid (zyx coordinates), the number of RNAs detected in the
+        foci and its index.
+
+    spots_in_foci : : np.ndarray, np.int64
+        Coordinate of the spots detected inside foci, with shape (nb_spots, 4).
+        One coordinate per dimension (zyx coordinates) plus the index of the
+        foci.
+    cell_cyt_mask : np.ndarray, bool
+        Binary mask of the cell with shape (y, x).
+
+    Returns
+    -------
+    spots_in_foci_cell : np.ndarray, np.int64
+        Coordinate of the spots detected inside foci in the cell, with shape
+        (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus the
+        index of the foci.
+    foci_cell : np.ndarray, np.int64
+        Array with shape (nb_foci, 5). One coordinate per dimension for the
+        foci centroid (zyx coordinates), the number of RNAs detected in the
+        foci and its index.
+
+    """
+    # filter foci
+    mask_foci_cell = cell_cyt_mask[foci[:, 1], foci[:, 2]]
+    foci_cell = foci[mask_foci_cell]
+
+    # filter spots in foci
+    spots_to_keep = foci_cell[:, 4]
+    mask_spots_to_keep = np.isin(spots_in_foci[:, 3], spots_to_keep)
+    spots_in_foci_cell = spots_in_foci[mask_spots_to_keep]
+
+    return foci_cell, spots_in_foci_cell
+
+
+def _extract_spots_outside_foci(cell_cyt_mask, spots_out_foci):
+    """
+    Extract spots detected outside foci, in a specific cell.
+
+    Parameters
+    ----------
+    cell_cyt_mask : np.ndarray, bool
+        Binary mask of the cell with shape (y, x).
+    spots_out_foci : np.ndarray, np.int64
+        Coordinate of the spots detected outside foci, with shape
+        (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus a
+        default index (-1 for mRNAs spotted outside a foci).
+
+    Returns
+    -------
+    spots_out_foci_cell : np.ndarray, np.int64
+        Coordinate of the spots detected outside foci in the cell, with shape
+        (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus the
+        index of the foci.
+
+    """
+    # get coordinates of rna outside foci
+    mask_spots_to_keep = cell_cyt_mask[spots_out_foci[:, 1],
+                                       spots_out_foci[:, 2]]
+    spots_out_foci_cell = spots_out_foci[mask_spots_to_keep]
+
+    return spots_out_foci_cell

From c4a1a5b2ffb23ffa6ae0d200b3a0dfe1ae539f20 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 12 Sep 2019 15:08:30 +0200
Subject: [PATCH 228/264] fix cell extraction when no foci in the cell

---
 bigfish/stack/postprocess.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index bef3d279..ffd257a8 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -382,6 +382,11 @@ def _extract_foci(foci, spots_in_foci, cell_cyt_mask):
     """
     # filter foci
     mask_foci_cell = cell_cyt_mask[foci[:, 1], foci[:, 2]]
+    if mask_foci_cell.sum() == 0:
+        foci_cell = np.array([], dtype=np.int64).reshape((0, 5))
+        spots_in_foci_cell = np.array([], dtype=np.int64).reshape((0, 4))
+        return foci_cell, spots_in_foci_cell
+
     foci_cell = foci[mask_foci_cell]
 
     # filter spots in foci

From 6866c4a31a089ce89317f45e60d636170839022a Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 12 Sep 2019 15:11:26 +0200
Subject: [PATCH 229/264] fix cell extraction when no foci in the cell #2

---
 bigfish/stack/postprocess.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index ffd257a8..c72b3ba9 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -226,6 +226,7 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
 
         # get rna coordinates
         spots_out_foci_cell = _extract_spots_outside_foci(cyt, spots_out)
+        print(spots_out_foci_cell.shape, spots_in_foci_cell.shape, foci_cell.shape)
         rna_coord = np.concatenate([spots_out_foci_cell, spots_in_foci_cell],
                                    axis=0)
 

From 04389ab573873385622921cca52f88a4d1fd8d3d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 12 Sep 2019 15:17:38 +0200
Subject: [PATCH 230/264] misc

---
 bigfish/stack/postprocess.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index c72b3ba9..ffd257a8 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -226,7 +226,6 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
 
         # get rna coordinates
         spots_out_foci_cell = _extract_spots_outside_foci(cyt, spots_out)
-        print(spots_out_foci_cell.shape, spots_in_foci_cell.shape, foci_cell.shape)
         rna_coord = np.concatenate([spots_out_foci_cell, spots_in_foci_cell],
                                    axis=0)
 

From 54c2d91599dfe8724b482fc3b881c69743a955a6 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 12 Sep 2019 16:11:41 +0200
Subject: [PATCH 231/264] fix plot_cell

---
 bigfish/plot/plot_coordinates.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
index 079b10b5..3194e2d7 100644
--- a/bigfish/plot/plot_coordinates.py
+++ b/bigfish/plot/plot_coordinates.py
@@ -483,23 +483,24 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
         title = " ({0})".format(title)
 
     # get shape of image built from coordinates
-    max_y = cyt_coord[:, 0].max() + 1
-    max_x = cyt_coord[:, 1].max() + 1
+    marge = stack.get_offset_value()
+    max_y = cyt_coord[:, 0].max() + 2 * marge + 1
+    max_x = cyt_coord[:, 1].max() + 2 * marge + 1
     image_shape = (max_y, max_x)
 
     # get cytoplasm layer
     cyt = np.zeros(image_shape, dtype=bool)
-    cyt[cyt_coord[:, 0], cyt_coord[:, 1]] = True
+    cyt[cyt_coord[:, 0] + marge, cyt_coord[:, 1] + marge] = True
 
     # get nucleus layer
     nuc = np.zeros(image_shape, dtype=bool)
     if nuc_coord is not None:
-        nuc[nuc_coord[:, 0], nuc_coord[:, 1]] = True
+        nuc[nuc_coord[:, 0] + marge, nuc_coord[:, 1] + marge] = True
 
     # get rna layer
     rna = np.zeros(image_shape, dtype=bool)
     if rna_coord is not None:
-        rna[rna_coord[:, 1], rna_coord[:, 2]] = True
+        rna[rna_coord[:, 1] + marge, rna_coord[:, 2] + marge] = True
         rna = stack.dilation_filter(rna,
                                     kernel_shape="square",
                                     kernel_size=3)
@@ -508,7 +509,7 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
     foci = np.zeros(image_shape, dtype=bool)
     if foci_coord is not None:
         rna_in_foci_coord = rna_coord[rna_coord[:, 3] != -1, :].copy()
-        foci[rna_in_foci_coord[:, 1], rna_in_foci_coord[:, 2]] = True
+        foci[rna_in_foci_coord[:, 1] + marge, rna_in_foci_coord[:, 2] + marge] = True
         foci = stack.dilation_filter(foci,
                                      kernel_shape="square",
                                      kernel_size=3)

From 2b2e52dd50626df62474c755c7a711ecf1a65c62 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 12 Sep 2019 17:36:40 +0200
Subject: [PATCH 232/264] improve cyt segmentation with watershed

---
 bigfish/segmentation/cyt_segmentation.py | 29 +++++++++++++++++++++---
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/bigfish/segmentation/cyt_segmentation.py b/bigfish/segmentation/cyt_segmentation.py
index d954cc22..3e2ceac2 100644
--- a/bigfish/segmentation/cyt_segmentation.py
+++ b/bigfish/segmentation/cyt_segmentation.py
@@ -8,7 +8,7 @@
 
 import bigfish.stack as stack
 
-from skimage.morphology import remove_small_objects, remove_small_holes
+from skimage.morphology import remove_small_objects, remove_small_holes, label
 from skimage.morphology import watershed
 from skimage.filters import threshold_otsu
 from skimage.measure import regionprops
@@ -159,7 +159,7 @@ def cyt_watershed(relief, nuc_labelled, mask, smooth=None):
 
     Returns
     -------
-    cyt_segmented : np.ndarray, np.int64
+    cyt_segmented_final : np.ndarray, np.int64
         Segmentation of the cytoplasm with instance differentiation and shape
         (y, x).
 
@@ -194,4 +194,27 @@ def cyt_watershed(relief, nuc_labelled, mask, smooth=None):
         cyt_segmented = remove_small_objects(cyt_segmented, 3000)
         cyt_segmented = cyt_segmented.astype(np.int64)
 
-    return cyt_segmented
+    # be sure to remove potential small disjoint part of the mask
+    cyt_segmented_final = np.zeros_like(cyt_segmented)
+    for id_cell in range(1, cyt_segmented.max() + 1):
+        cell = cyt_segmented == id_cell
+        cell_cc = label(cell)
+
+        # one mask for the cell
+        if cell_cc.max() == 1:
+            mask = cell
+
+        # multiple masks for the cell - we keep the larger one
+        else:
+            cell_properties = regionprops(cell_cc)
+            m = 0
+            mask = np.zeros_like(cyt_segmented).astype(bool)
+            for cell_properties_ in cell_properties:
+                area = cell_properties_.area
+                if area > m:
+                    m = area
+                    mask = cell_cc == cell_properties_.label
+
+        cyt_segmented_final[mask] = id_cell
+
+    return cyt_segmented_final

From 0fb38a5a99b8fd933ed00b84137dd3ee69cd65cb Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 13 Sep 2019 03:24:10 +0200
Subject: [PATCH 233/264] misc

---
 bigfish/classification/features_old.py | 723 +++++++++++++++++++++++++
 bigfish/stack/preparation.py           |   3 +-
 2 files changed, 725 insertions(+), 1 deletion(-)
 create mode 100644 bigfish/classification/features_old.py

diff --git a/bigfish/classification/features_old.py b/bigfish/classification/features_old.py
new file mode 100644
index 00000000..2f059d38
--- /dev/null
+++ b/bigfish/classification/features_old.py
@@ -0,0 +1,723 @@
+# -*- coding: utf-8 -*-
+
+"""
+Functions to craft features.
+"""
+
+from bigfish import stack
+
+import numpy as np
+from scipy import ndimage as ndi
+
+from skimage.measure import regionprops
+from skimage.morphology import binary_opening
+from skimage.morphology.selem import disk
+
+from scipy.spatial import distance_matrix
+from scipy.stats import spearmanr
+
+
+def from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord):
+    """
+
+    Parameters
+    ----------
+    cyt_coord
+    nuc_coord
+    rna_coord
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get size of the frame
+    max_y = cyt_coord[:, 0].max() + 1
+    max_x = cyt_coord[:, 1].max() + 1
+    image_shape = (max_y, max_x)
+
+    # cytoplasm
+    cyt = np.zeros(image_shape, dtype=bool)
+    cyt[cyt_coord[:, 0], cyt_coord[:, 1]] = True
+
+    # nucleus
+    nuc = np.zeros(image_shape, dtype=bool)
+    nuc[nuc_coord[:, 0], nuc_coord[:, 1]] = True
+
+    # rna
+    rna = np.zeros(image_shape, dtype=bool)
+    rna[rna_coord[:, 0], rna_coord[:, 1]] = True
+
+    return cyt, nuc, rna
+
+
+def get_centroid(mask):
+    """
+
+    Parameters
+    ----------
+    mask
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get centroid
+    region = regionprops(mask.astype(np.uint8))[0]
+    centroid = np.array(region.centroid, dtype=np.int64)
+
+    return centroid
+
+
+def get_centroid_distance_map(centroid_coordinate, mask_cyt):
+    """
+
+    Parameters
+    ----------
+    centroid_coordinate
+    mask_cyt
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get mask centroid
+    mask_centroid = np.zeros_like(mask_cyt)
+    mask_centroid[centroid_coordinate[0], centroid_coordinate[1]] = True
+
+    # compute distance map
+    distance_map = ndi.distance_transform_edt(~mask_centroid)
+    distance_map = distance_map.astype(np.float32)
+
+    return distance_map
+
+
+def features_distance(mask_rna_out, distance_cyt, distance_nuc,
+                      distance_cyt_centroid, distance_nuc_centroid):
+    """
+
+    Parameters
+    ----------
+    mask_rna_out
+    distance_cyt
+    distance_nuc
+    distance_cyt_centroid
+    distance_nuc_centroid
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    if mask_rna_out.sum() == 0:
+        features = [1., 1., 1., 1., 1., 1., 1., 1.]
+        return features
+
+    # compute average distances to cytoplasm and quantiles
+    factor = distance_cyt[distance_nuc > 0].mean()
+    mean_distance_cyt = distance_cyt[mask_rna_out].mean() / factor
+    quantile_5_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 5)
+    quantile_5_distance_cyt /= factor
+    quantile_10_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 10)
+    quantile_10_distance_cyt /= factor
+    quantile_20_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 20)
+    quantile_20_distance_cyt /= factor
+    quantile_50_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 50)
+    quantile_50_distance_cyt /= factor
+
+    # compute average distances to cytoplasm centroid
+    factor = distance_cyt_centroid[distance_nuc > 0].mean()
+    mean_distance_cyt_centroid = distance_cyt_centroid[mask_rna_out].mean()
+    mean_distance_cyt_centroid /= factor
+
+    # compute average distances to nucleus
+    factor = distance_nuc[distance_nuc > 0].mean()
+    mean_distance_nuc = distance_nuc[mask_rna_out].mean() / factor
+
+    # compute average distances to nucleus centroid
+    factor = distance_nuc_centroid[distance_nuc > 0].mean()
+    mean_distance_nuc_centroid = distance_nuc_centroid[mask_rna_out].mean()
+    mean_distance_nuc_centroid /= factor
+
+    features = [mean_distance_cyt, quantile_5_distance_cyt,
+                quantile_10_distance_cyt, quantile_20_distance_cyt,
+                quantile_50_distance_cyt, mean_distance_cyt_centroid,
+                mean_distance_nuc, mean_distance_nuc_centroid]
+
+    return features
+
+
+def features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
+                            distance_cyt_centroid, distance_nuc_centroid):
+    """
+
+    Parameters
+    ----------
+    mask_rna
+    distance_cyt
+    distance_nuc
+    distance_cyt_centroid
+    distance_nuc_centroid
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+
+    # compute average distances to cytoplasm and quantiles
+    factor = distance_cyt[distance_cyt > 0].mean()
+    mean_distance_cyt = distance_cyt[mask_rna].mean() / factor
+    quantile_5_distance_cyt = np.percentile(distance_cyt[mask_rna], 5)
+    quantile_5_distance_cyt /= factor
+    quantile_10_distance_cyt = np.percentile(distance_cyt[mask_rna], 10)
+    quantile_10_distance_cyt /= factor
+    quantile_20_distance_cyt = np.percentile(distance_cyt[mask_rna], 20)
+    quantile_20_distance_cyt /= factor
+    quantile_50_distance_cyt = np.percentile(distance_cyt[mask_rna], 50)
+    quantile_50_distance_cyt /= factor
+
+    # compute average distances to cytoplasm centroid
+    factor = distance_cyt_centroid[distance_cyt > 0].mean()
+    mean_distance_cyt_centroid = distance_cyt_centroid[mask_rna].mean()
+    mean_distance_cyt_centroid /= factor
+
+    # compute average distances to nucleus
+    factor = distance_nuc[distance_cyt > 0].mean()
+    mean_distance_nuc = distance_nuc[mask_rna].mean() / factor
+
+    # compute average distances to nucleus centroid
+    factor = distance_nuc_centroid[distance_cyt > 0].mean()
+    mean_distance_nuc_centroid = distance_nuc_centroid[mask_rna].mean()
+    mean_distance_nuc_centroid /= factor
+
+    features = [mean_distance_cyt, quantile_5_distance_cyt,
+                quantile_10_distance_cyt, quantile_20_distance_cyt,
+                quantile_50_distance_cyt, mean_distance_cyt_centroid,
+                mean_distance_nuc, mean_distance_nuc_centroid]
+
+    return features
+
+
+def feature_in_out_nucleus(mask_nuc, mask_rna):
+    """
+
+    Parameters
+    ----------
+    mask_nuc
+    mask_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute the proportion of rna in the nucleus
+    rna_in = mask_rna[mask_nuc].sum()
+    nb_rna = mask_rna.sum()
+    feature = rna_in / nb_rna
+
+    return feature
+
+
+def feature_in_out_nucleus_aubin(mask_nuc, mask_rna, mask_rna_out):
+    """
+
+    Parameters
+    ----------
+    mask_nuc
+    mask_rna
+    mask_rna_out
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute the ratio between rna in and out nucleus
+    rna_in = mask_rna[mask_nuc].sum()
+    rna_out = max(mask_rna_out.sum(), 1)
+    feature = rna_in / rna_out
+
+    return feature
+
+
+def features_opening(opening_sizes, mask_cyt, mask_rna_out):
+    """
+
+    Parameters
+    ----------
+    opening_sizes
+    mask_cyt
+    mask_rna_out
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get number of rna outside nucleus
+    nb_rna_out = mask_rna_out.sum()
+
+    # case where we do not detect any rna outside the nucleus
+    if nb_rna_out == 0:
+        features = [0. for _ in opening_sizes]
+        return features
+
+    # apply opening operator and count the loss of rna outside the nucleus
+    features = []
+    for size in opening_sizes:
+        s = disk(size, dtype=bool)
+        mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
+        nb_rna_out_after_opening = mask_rna_out[mask_cyt_transformed > 0].sum()
+        diff_opening = (nb_rna_out - nb_rna_out_after_opening) / nb_rna_out
+        features.append(diff_opening)
+
+    return features
+
+
+def features_opening_aubin(opening_sizes, mask_cyt, mask_rna):
+    """
+
+    Parameters
+    ----------
+    opening_sizes
+    mask_cyt
+    mask_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get number of rna
+    nb_rna = mask_rna.sum()
+
+    # apply opening operator and count the loss of rna
+    features = []
+    for size in opening_sizes:
+        s = disk(size, dtype=bool)
+        mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
+        nb_rna__after_opening = mask_rna[mask_cyt_transformed > 0].sum()
+        diff_opening = (nb_rna - nb_rna__after_opening) / nb_rna
+        features.append(diff_opening)
+
+    return features
+
+
+def ripley_values(radii, mask_cyt, rna_coord, mask_rna):
+    """
+
+    Parameters
+    ----------
+    radii
+    mask_cyt
+    rna_coord
+    mask_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # sort rna coordinates
+    sorted_indices = np.lexsort((rna_coord[:, 1], rna_coord[:, 0]))
+    rna_coord = rna_coord[sorted_indices]
+
+    # compute distance matrix between rna and rna density
+    distances = distance_matrix(rna_coord, rna_coord, p=2)
+    factor = len(rna_coord) ** 2 / mask_cyt.sum()
+
+    # cast cytoplasm mask in np.uint8
+    mask_cyt_8bit = stack.cast_img_uint8(mask_cyt)
+
+    # for each radius, get neighbors and weight
+    values = []
+    for r in radii:
+        mask_distance = distances.copy()
+        mask_distance = mask_distance <= r
+        nb_neighbors = np.sum(mask_distance, axis=0) - 1
+        weights = stack.mean_filter(mask_cyt_8bit, kernel_shape="disk",
+                                    kernel_size=r)
+        weights = weights.astype(np.float32) / 255.
+        rna_weights = weights[mask_rna]
+        nb_neighbors_weighted = np.multiply(nb_neighbors, rna_weights)
+        value = nb_neighbors_weighted.sum() / factor
+        values.append(value)
+    values = np.array(values, dtype=np.float32)
+    values_corrected = np.sqrt(values / np.pi) - np.array(radii)
+
+    return values_corrected
+
+
+def moving_average(a, n=4):
+    """
+
+    Parameters
+    ----------
+    a
+    n
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    res = np.cumsum(a, dtype=np.float32)
+    res[n:] = res[n:] - res[:-n]
+    averaged_array = res[n - 1:] / n
+
+    return averaged_array
+
+
+def features_ripley(radii, cyt_coord, mask_cyt, rna_coord_out, mask_rna_out):
+    """
+
+    Parameters
+    ----------
+    radii
+    cyt_coord
+    mask_cyt
+    rna_coord_out
+    mask_rna_out
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # case where we do not detect any rna outside the nucleus
+    if len(rna_coord_out) == 0:
+        features = [0., 0., 0., 0., 0., 0.]
+        return features
+
+    # compute corrected Ripley values for different radii
+    values = ripley_values(radii, mask_cyt, rna_coord_out, mask_rna_out)
+
+    # smooth them using moving average
+    smoothed_values = moving_average(values, n=4)
+
+    # compute the gradients of these values
+    gradients = np.gradient(smoothed_values)
+
+    # compute features
+    index_max = np.argmax(smoothed_values)
+    max_radius = radii[index_max]
+    max_value = smoothed_values[index_max]
+    if index_max == 0:
+        max_gradient = gradients[0]
+    else:
+        max_gradient = max(gradients[:index_max])
+    if index_max == len(gradients) - 1:
+        min_gradient = gradients[-1]
+    else:
+        min_gradient = min(gradients[index_max:])
+    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
+    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
+    max_size_cell = np.max(distances_cell)
+    big_radius = int(max_size_cell / 4)
+    big_value = ripley_values([big_radius], mask_cyt, rna_coord_out,
+                              mask_rna_out)[0]
+    features = [max_value, max_gradient, min_gradient, monotony, big_value,
+                max_radius]
+
+    return features
+
+
+def features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
+    """
+
+    Parameters
+    ----------
+    radii
+    cyt_coord
+    mask_cyt
+    rna_coord
+    mask_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute corrected Ripley values for different radii
+    values = ripley_values(radii, mask_cyt, rna_coord, mask_rna)
+
+    # smooth them using moving average
+    smoothed_values = moving_average(values, n=4)
+
+    # compute the gradients of these values
+    gradients = np.gradient(smoothed_values)
+
+    # compute features
+    index_max = np.argmax(smoothed_values)
+    max_radius = radii[index_max]
+    max_value = smoothed_values[index_max]
+    if index_max == 0:
+        max_gradient = gradients[0]
+    else:
+        max_gradient = max(gradients[:index_max])
+    if index_max == len(gradients) - 1:
+        min_gradient = gradients[-1]
+    else:
+        min_gradient = min(gradients[index_max:])
+    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
+    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
+    max_size_cell = np.max(distances_cell)
+    big_radius = int(max_size_cell / 4)
+    big_value = ripley_values([big_radius], mask_cyt, rna_coord, mask_rna)[0]
+    features = [max_value, max_gradient, min_gradient, monotony, big_value,
+                max_radius]
+
+    return features
+
+
+def feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna):
+    """
+
+    Parameters
+    ----------
+    distance_cyt
+    distance_cyt_centroid
+    centroid_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # compute polarization index
+    factor = np.mean(distance_cyt_centroid[distance_cyt > 0])
+    distance_rna_cell = distance_cyt_centroid[centroid_rna[0], centroid_rna[1]]
+    feature = distance_rna_cell / factor
+
+    return feature
+
+
+def feature_dispersion(mask_cyt, rna_coord, centroid_rna):
+    """
+
+    Parameters
+    ----------
+    mask_cyt
+    rna_coord
+    centroid_rna
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # TODO correct the formula
+    # case where we do not detect rna outside nucleus
+    if len(rna_coord) == 0:
+        return 1.
+
+    # get coordinates of each pixel of the cell
+    mask_cyt_coord = np.nonzero(mask_cyt)
+    mask_cyt_coord = np.column_stack(mask_cyt_coord)
+
+    # compute dispersion index
+    sigma_rna = np.sum((rna_coord - centroid_rna) ** 2, axis=0)
+    sigma_rna = np.sum(sigma_rna / len(rna_coord))
+    sigma_cell = np.sum((mask_cyt_coord - centroid_rna) ** 2, axis=0)
+    sigma_cell = np.sum(sigma_cell / len(mask_cyt_coord))
+    feature = sigma_rna / sigma_cell
+
+    return feature
+
+
+def feature_area(mask_cyt, mask_nuc):
+    """
+
+    Parameters
+    ----------
+    mask_cyt
+    mask_nuc
+
+    Returns
+    -------
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # get area of the cytoplasm and the nucleus
+    area_cyt = mask_cyt.sum()
+    area_nuc = mask_nuc.sum()
+
+    # compute relative area of the nucleus
+    relative_area_nuc = area_nuc / area_cyt
+
+    # return features
+    features = [relative_area_nuc, area_cyt, area_nuc]
+
+    return features
+
+
+def feature_height():
+    return
+
+
+def get_features(cyt_coord, nuc_coord, rna_coord):
+    """Compute cell features.
+
+    Parameters
+    ----------
+    cyt_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    nuc_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    rna_coord : np.ndarray, np.int64
+        Coordinate yx of the detected rna with shape (nb_rna, 2).
+
+    Returns
+    -------
+    features : List[float]
+        List of features (cf. features.get_features_name()).
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # TODO filter features
+    # get a binary representation of the coordinates
+    cyt, nuc, mask_rna = from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord)
+
+    # fill in masks
+    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
+
+    # compute distance maps for the cytoplasm and the nucleus
+    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
+
+    # get rna outside nucleus
+    mask_rna_out = mask_rna.copy()
+    mask_rna_out[distance_nuc == 0] = 0
+    rna_coord_out = np.nonzero(mask_rna_out)
+    rna_coord_out = np.column_stack(rna_coord_out)
+
+    # get centroids
+    centroid_cyt = get_centroid(mask_cyt)
+    centroid_nuc = get_centroid(mask_nuc)
+    if len(rna_coord_out) == 0:
+        centroid_rna_out = centroid_cyt
+    else:
+        centroid_rna_out = np.mean(rna_coord_out, axis=0, dtype=np.int64)
+
+    # get centroid distance maps
+    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
+    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+
+    # compute features
+    a = features_distance(mask_rna_out, distance_cyt, distance_nuc,
+                          distance_cyt_centroid, distance_nuc_centroid)
+    b = feature_in_out_nucleus(mask_nuc, mask_rna)
+    opening_sizes = [15, 30, 45, 60]
+    c = features_opening(opening_sizes, mask_cyt, mask_rna_out)
+    radii = [r for r in range(40)]
+    d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord_out,
+                        mask_rna_out)
+    e = feature_polarization(distance_cyt, distance_cyt_centroid,
+                             centroid_rna_out)
+    f = feature_dispersion(mask_cyt, rna_coord_out, centroid_rna_out)
+    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
+
+    return features
+
+
+def get_features_name():
+    """Return the current list of features names.
+
+    Returns
+    -------
+    features_name : List[str]
+        List of features name returned by features.get_features().
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # TODO filter features
+    features_name = ["average_dist_cyt", "quantile_5_dist_cyt",
+                     "quantile_10_dist_cyt", "quantile_20_dist_cyt",
+                     "quantile_50_dist_cyt", "average_dist_cyt_centroid",
+                     "average_dist_nuc", "average_dist_nuc_centroid",
+                     "ratio_in_nuc", "diff_opening_15", "diff_opening_30",
+                     "diff_opening_45", "diff_opening_60", "ripley_max",
+                     "ripley_max_gradient", "ripley_min_gradient",
+                     "ripley_monotony", "ripley_large", "ripley_radius_max",
+                     "polarization_index", "dispersion_index"]
+
+    return features_name
+
+
+def get_features_aubin(cyt_coord, nuc_coord, rna_coord):
+    """Compute cell features, according to Aubin's paper.
+
+    Parameters
+    ----------
+    cyt_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    nuc_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    rna_coord : np.ndarray, np.int64
+        Coordinate yx of the detected rna with shape (nb_rna, 2).
+
+    Returns
+    -------
+    features : List[float]
+        List of features (cf. features.get_features_name()).
+
+    """
+    # TODO add sanity check functions
+    # TODO add documentation
+    # TODO filter features
+    # get a binary representation of the coordinates
+    cyt, nuc, mask_rna = from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord)
+
+    # fill in masks
+    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
+
+    # compute distance maps for the cytoplasm and the nucleus
+    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
+
+    # get centroids
+    centroid_cyt = get_centroid(mask_cyt)
+    centroid_nuc = get_centroid(mask_nuc)
+    centroid_rna = np.mean(rna_coord, axis=0, dtype=np.int64)
+
+    # get centroid distance maps
+    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
+    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+
+    # get rna outside nucleus
+    mask_rna_out = mask_rna.copy()
+    mask_rna_out[distance_nuc == 0] = 0
+
+    # compute features
+    a = features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
+                                distance_cyt_centroid, distance_nuc_centroid)
+    b = feature_in_out_nucleus_aubin(mask_nuc, mask_rna, mask_rna_out)
+    opening_sizes = [15, 30, 45, 60]
+    c = features_opening_aubin(opening_sizes, mask_cyt, mask_rna)
+    radii = [r for r in range(40)]
+    d = features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
+    e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
+    f = feature_dispersion(mask_cyt, rna_coord, centroid_rna)
+    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
+
+    return features
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 28301072..40b040dd 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -449,9 +449,10 @@ def get_distance_layers(cyt, nuc):
     -------
     distance_cyt : np.ndarray, np.float32
         A 2-d tensor with shape (y, x) showing distance to the cytoplasm
-        border.
+        border. Normalize between 0 and 1.
     distance_nuc : np.ndarray, np.float32
         A 2-d tensor with shape (y, x) showing distance to the nucleus border.
+        Normalize between 0 and 1.
 
     """
     # TODO can return NaN

From f701a52a1b7393ff6e74eac047c346ce0505d0bc Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 13 Sep 2019 03:24:43 +0200
Subject: [PATCH 234/264] add new features

---
 bigfish/classification/__init__.py |    4 +-
 bigfish/classification/features.py | 1094 +++++++++++++++-------------
 2 files changed, 585 insertions(+), 513 deletions(-)

diff --git a/bigfish/classification/__init__.py b/bigfish/classification/__init__.py
index 5fe6fd0c..31da148e 100644
--- a/bigfish/classification/__init__.py
+++ b/bigfish/classification/__init__.py
@@ -6,11 +6,11 @@
 """
 
 # from .squeezenet import SqueezeNet0
-from .features import get_features, get_features_name, get_features_aubin
+from .features import get_features, get_features_name
 
 # ### Load models ###
 
-_features = ["get_features", "get_features_name", "get_features_aubin"]
+_features = ["get_features", "get_features_name"]
 
 # _squeezenet = ["SqueezeNet0"]
 
diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 2f059d38..6f5b2411 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -4,7 +4,8 @@
 Functions to craft features.
 """
 
-from bigfish import stack
+import bigfish.stack as stack
+import bigfish.detection as detection
 
 import numpy as np
 from scipy import ndimage as ndi
@@ -16,55 +17,224 @@
 from scipy.spatial import distance_matrix
 from scipy.stats import spearmanr
 
+# TODO add sanity check functions
+# TODO add documentation
+# TODO check centroid cyt has a yx format
 
-def from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord):
-    """
+
+def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
+                 features_no_aubin=False):
+    """Compute cell features.
 
     Parameters
     ----------
-    cyt_coord
-    nuc_coord
-    rna_coord
+    cyt_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    nuc_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    rna_coord : np.ndarray, np.int64
+        Coordinate yx of the detected rna with shape (nb_rna, 2).
+    features_aubin : bool
+        Compute features from Aubin paper.
+    features_no_aubin : bool
+        Compute features that are not present in Aubin paper.
 
     Returns
     -------
+    features : List[float]
+        List of features (cf. features.get_features_name()).
 
     """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # get size of the frame
-    max_y = cyt_coord[:, 0].max() + 1
-    max_x = cyt_coord[:, 1].max() + 1
-    image_shape = (max_y, max_x)
+    features = []
 
-    # cytoplasm
-    cyt = np.zeros(image_shape, dtype=bool)
-    cyt[cyt_coord[:, 0], cyt_coord[:, 1]] = True
+    # get a binary representation of the coordinates
+    cyt, nuc = from_coord_to_matrix(cyt_coord, nuc_coord)
+    rna_coord = rna_coord + 1
 
-    # nucleus
-    nuc = np.zeros(image_shape, dtype=bool)
-    nuc[nuc_coord[:, 0], nuc_coord[:, 1]] = True
+    # fill in masks
+    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
+
+    # compute distance maps for the cytoplasm and the nucleus
+    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
+
+    # get rna outside nucleus
+    mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_coord_out = rna_coord[~mask_rna_in]
+
+    # get centroids
+    centroid_cyt = get_centroid_surface(mask_cyt)
+    centroid_nuc = get_centroid_surface(mask_nuc)
+    centroid_rna = get_centroid_rna(rna_coord)
+    if len(rna_coord_out) == 0:
+        centroid_rna_out = centroid_cyt.copy()
+    else:
+        centroid_rna_out = get_centroid_rna(rna_coord_out)
 
-    # rna
-    rna = np.zeros(image_shape, dtype=bool)
-    rna[rna_coord[:, 0], rna_coord[:, 1]] = True
+    # get centroid distance maps
+    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
+    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+    distance_rna_out_centroid = get_centroid_distance_map(centroid_rna_out,
+                                                          mask_cyt)
+    # Aubin's features
+    if features_aubin:
+
+        # compute features
+        a = features_distance_aubin(rna_coord, distance_cyt, distance_nuc,
+                                    distance_cyt_centroid,
+                                    distance_nuc_centroid)
+        b = feature_in_out_nucleus_aubin(rna_coord, mask_nuc)
+        opening_sizes = [15, 30, 45, 60]
+        c = features_opening_aubin(opening_sizes, rna_coord, mask_cyt)
+        radii = [r for r in range(40)]
+        d = features_ripley_aubin(radii, rna_coord, cyt_coord, mask_cyt)
+        e = feature_polarization_aubin(distance_cyt, distance_cyt_centroid,
+                                       centroid_rna)
+        f = feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna)
+
+        # gather features
+        features_to_add = a + [b] + c + d + [e] + [f]
+        features += features_to_add
+
+    # other features
+    if features_no_aubin:
+
+        # compute features
+        aa = features_distance(rna_coord_out, distance_cyt, distance_nuc)
+        bb = feature_in_out_nucleus(rna_coord, mask_nuc)
+        opening_sizes = [15, 30, 45, 60]
+        cc = features_protrusion(opening_sizes, rna_coord_out, mask_cyt)
+        radii = [r for r in range(40)]
+        dd = features_ripley(radii, rna_coord_out, mask_cyt)
+        ee = feature_polarization(centroid_rna_out, centroid_cyt,
+                                  distance_cyt_centroid, mask_cyt)
+        ff = feature_dispersion(rna_coord_out, distance_rna_out_centroid,
+                                mask_cyt)
+        gg = feature_peripheral_dispersion(rna_coord_out,
+                                           distance_cyt_centroid,
+                                           mask_cyt)
+        hh = features_topography(rna_coord, mask_cyt, mask_nuc)
+        ii = features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
+                           mask_nuc)
+        jj = feature_area(mask_cyt, mask_nuc)
+
+        # gather features
+        features_to_add = aa + [bb] + cc + dd + [ee] + [ff] + [gg] + hh + ii + jj
+        features += features_to_add
+
+    features = np.array(features, dtype=np.float32)
 
-    return cyt, nuc, rna
+    return features
 
 
-def get_centroid(mask):
-    """
+def get_features_name(features_aubin=True, features_no_aubin=False):
+    """Return the current list of features names.
 
     Parameters
     ----------
-    mask
+    features_aubin : bool
+        Compute features from Aubin paper.
+    features_no_aubin : bool
+        Compute features that are not present in Aubin paper.
 
     Returns
     -------
+    features_name : List[str]
+        A list of features name.
+
+    """
+    features_name = []
+    if features_aubin:
+        features_to_add = ["aubin_average_dist_cyt",
+                           "aubin_quantile_5_dist_cyt",
+                           "aubin_quantile_10_dist_cyt",
+                           "aubin_quantile_20_dist_cyt",
+                           "aubin_quantile_50_dist_cyt",
+                           "aubin_average_dist_cyt_centroid",
+                           "aubin_average_dist_nuc",
+                           "aubin_average_dist_nuc_centroid",
+                           "aubin_ratio_in_nuc",
+                           "aubin_diff_opening_15",
+                           "aubin_diff_opening_30",
+                           "aubin_diff_opening_45",
+                           "aubin_diff_opening_60",
+                           "aubin_ripley_max",
+                           "aubin_ripley_max_gradient",
+                           "aubin_ripley_min_gradient",
+                           "aubin_ripley_monotony",
+                           "aubin_ripley_mid_cell",
+                           "aubin_ripley_max_radius",
+                           "aubin_polarization_index",
+                           "aubin_dispersion_index"]
+        features_name += features_to_add
+
+    if features_no_aubin:
+        features_to_add = ["mean_distance_cyt",
+                           "median_distance_cyt",
+                           "std_distance_cyt",
+                           "mean_distance_nuc",
+                           "median_distance_nuc",
+                           "std_distance_nuc",
+                           "proportion_in_nuc",
+                           "diff_opening_15",
+                           "diff_opening_30",
+                           "diff_opening_45",
+                           "diff_opening_60",
+                           "nb_rna_opening_15",
+                           "nb_rna_opening_30",
+                           "nb_rna_opening_45",
+                           "nb_rna_opening_60",
+                           "ripley_max",
+                           "ripley_min",
+                           "ripley_max_gradient",
+                           "ripley_min_gradient",
+                           "ripley_monotony",
+                           "aubin_ripley_max_radius",
+                           "polarization_index",
+                           "dispersion_index",
+                           "peripheral_dispersion_index",
+                           "rna_nuc_edge",
+                           "rna_nuc_10_20",
+                           "rna_nuc_20_30",
+                           "rna_cyt_0_10",
+                           "rna_cyt_10_20",
+                           "rna_cyt_20_30",
+                           "nb_low_density_foci",
+                           "ratio_rna_foci_0_10",
+                           "ratio_rna_foci_10_20",
+                           "foci_mean_distance_cyt",
+                           "foci_median_distance_cyt",
+                           "foci_std_distance_cyt",
+                           "foci_mean_distance_nuc",
+                           "foci_median_distance_nuc",
+                           "foci_std_distance_nuc",
+                           "relative_area_nuc",
+                           "area_cyt",
+                           "area_nuc"]
+        features_name += features_to_add
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
+    return features_name
+
+
+# ### Prepare the data ###
+
+def from_coord_to_matrix(cyt_coord, nuc_coord):
+    # get size of the frame
+    max_y = cyt_coord[:, 0].max() + 3
+    max_x = cyt_coord[:, 1].max() + 3
+    image_shape = (max_y, max_x)
+
+    # cytoplasm
+    cyt = np.zeros(image_shape, dtype=bool)
+    cyt[cyt_coord[:, 0] + 1, cyt_coord[:, 1] + 1] = True
+
+    # nucleus
+    nuc = np.zeros(image_shape, dtype=bool)
+    nuc[nuc_coord[:, 0] + 1, nuc_coord[:, 1] + 1] = True
+
+    return cyt, nuc
+
+
+def get_centroid_surface(mask):
     # get centroid
     region = regionprops(mask.astype(np.uint8))[0]
     centroid = np.array(region.centroid, dtype=np.int64)
@@ -72,130 +242,67 @@ def get_centroid(mask):
     return centroid
 
 
-def get_centroid_distance_map(centroid_coordinate, mask_cyt):
-    """
+def get_centroid_rna(rna_coord):
+    # get rna centroids
+    centroid_rna = np.mean(rna_coord[:, :3], axis=0, dtype=np.int64)
+    return centroid_rna
 
-    Parameters
-    ----------
-    centroid_coordinate
-    mask_cyt
 
-    Returns
-    -------
+def get_centroid_distance_map(centroid_coordinate, mask_cyt):
+    if centroid_coordinate.size == 3:
+        centroid_coordinate_2d = centroid_coordinate[1:]
+    else:
+        centroid_coordinate_2d = centroid_coordinate.copy()
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
     # get mask centroid
     mask_centroid = np.zeros_like(mask_cyt)
-    mask_centroid[centroid_coordinate[0], centroid_coordinate[1]] = True
+    mask_centroid[centroid_coordinate_2d[0], centroid_coordinate_2d[1]] = True
 
     # compute distance map
     distance_map = ndi.distance_transform_edt(~mask_centroid)
+    distance_map[mask_cyt == 0] = 0
+    distance_map /= distance_map.max()
     distance_map = distance_map.astype(np.float32)
 
     return distance_map
 
 
-def features_distance(mask_rna_out, distance_cyt, distance_nuc,
-                      distance_cyt_centroid, distance_nuc_centroid):
-    """
-
-    Parameters
-    ----------
-    mask_rna_out
-    distance_cyt
-    distance_nuc
-    distance_cyt_centroid
-    distance_nuc_centroid
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    if mask_rna_out.sum() == 0:
-        features = [1., 1., 1., 1., 1., 1., 1., 1.]
-        return features
-
-    # compute average distances to cytoplasm and quantiles
-    factor = distance_cyt[distance_nuc > 0].mean()
-    mean_distance_cyt = distance_cyt[mask_rna_out].mean() / factor
-    quantile_5_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 5)
-    quantile_5_distance_cyt /= factor
-    quantile_10_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 10)
-    quantile_10_distance_cyt /= factor
-    quantile_20_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 20)
-    quantile_20_distance_cyt /= factor
-    quantile_50_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 50)
-    quantile_50_distance_cyt /= factor
-
-    # compute average distances to cytoplasm centroid
-    factor = distance_cyt_centroid[distance_nuc > 0].mean()
-    mean_distance_cyt_centroid = distance_cyt_centroid[mask_rna_out].mean()
-    mean_distance_cyt_centroid /= factor
+# ### Aubin's features ###
 
-    # compute average distances to nucleus
-    factor = distance_nuc[distance_nuc > 0].mean()
-    mean_distance_nuc = distance_nuc[mask_rna_out].mean() / factor
-
-    # compute average distances to nucleus centroid
-    factor = distance_nuc_centroid[distance_nuc > 0].mean()
-    mean_distance_nuc_centroid = distance_nuc_centroid[mask_rna_out].mean()
-    mean_distance_nuc_centroid /= factor
-
-    features = [mean_distance_cyt, quantile_5_distance_cyt,
-                quantile_10_distance_cyt, quantile_20_distance_cyt,
-                quantile_50_distance_cyt, mean_distance_cyt_centroid,
-                mean_distance_nuc, mean_distance_nuc_centroid]
-
-    return features
-
-
-def features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
+def features_distance_aubin(rna_coord, distance_cyt, distance_nuc,
                             distance_cyt_centroid, distance_nuc_centroid):
-    """
-
-    Parameters
-    ----------
-    mask_rna
-    distance_cyt
-    distance_nuc
-    distance_cyt_centroid
-    distance_nuc_centroid
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
+    rna_coord_2d = rna_coord[:, 1:3]
 
     # compute average distances to cytoplasm and quantiles
     factor = distance_cyt[distance_cyt > 0].mean()
-    mean_distance_cyt = distance_cyt[mask_rna].mean() / factor
-    quantile_5_distance_cyt = np.percentile(distance_cyt[mask_rna], 5)
+    distance_rna_cyt = distance_cyt[rna_coord_2d[:, 0], rna_coord_2d[:, 1]]
+    mean_distance_cyt = distance_rna_cyt.mean() / factor
+    quantile_5_distance_cyt = np.percentile(distance_rna_cyt, 5)
     quantile_5_distance_cyt /= factor
-    quantile_10_distance_cyt = np.percentile(distance_cyt[mask_rna], 10)
+    quantile_10_distance_cyt = np.percentile(distance_rna_cyt, 10)
     quantile_10_distance_cyt /= factor
-    quantile_20_distance_cyt = np.percentile(distance_cyt[mask_rna], 20)
+    quantile_20_distance_cyt = np.percentile(distance_rna_cyt, 20)
     quantile_20_distance_cyt /= factor
-    quantile_50_distance_cyt = np.percentile(distance_cyt[mask_rna], 50)
+    quantile_50_distance_cyt = np.percentile(distance_rna_cyt, 50)
     quantile_50_distance_cyt /= factor
 
     # compute average distances to cytoplasm centroid
     factor = distance_cyt_centroid[distance_cyt > 0].mean()
-    mean_distance_cyt_centroid = distance_cyt_centroid[mask_rna].mean()
+    distance_rna_cyt_centroid = distance_cyt_centroid[rna_coord_2d[:, 0],
+                                                      rna_coord_2d[:, 1]]
+    mean_distance_cyt_centroid = distance_rna_cyt_centroid.mean()
     mean_distance_cyt_centroid /= factor
 
     # compute average distances to nucleus
     factor = distance_nuc[distance_cyt > 0].mean()
-    mean_distance_nuc = distance_nuc[mask_rna].mean() / factor
+    distance_rna_nuc = distance_nuc[rna_coord_2d[:, 0], rna_coord_2d[:, 1]]
+    mean_distance_nuc = distance_rna_nuc.mean() / factor
 
     # compute average distances to nucleus centroid
     factor = distance_nuc_centroid[distance_cyt > 0].mean()
-    mean_distance_nuc_centroid = distance_nuc_centroid[mask_rna].mean()
+    distance_rna_nuc_centroid = distance_nuc_centroid[rna_coord_2d[:, 0],
+                                                      rna_coord_2d[:, 1]]
+    mean_distance_nuc_centroid = distance_rna_nuc_centroid.mean()
     mean_distance_nuc_centroid /= factor
 
     features = [mean_distance_cyt, quantile_5_distance_cyt,
@@ -206,139 +313,78 @@ def features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
     return features
 
 
-def feature_in_out_nucleus(mask_nuc, mask_rna):
-    """
-
-    Parameters
-    ----------
-    mask_nuc
-    mask_rna
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # compute the proportion of rna in the nucleus
-    rna_in = mask_rna[mask_nuc].sum()
-    nb_rna = mask_rna.sum()
-    feature = rna_in / nb_rna
-
-    return feature
-
-
-def feature_in_out_nucleus_aubin(mask_nuc, mask_rna, mask_rna_out):
-    """
-
-    Parameters
-    ----------
-    mask_nuc
-    mask_rna
-    mask_rna_out
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
+def feature_in_out_nucleus_aubin(rna_coord, mask_nuc):
     # compute the ratio between rna in and out nucleus
-    rna_in = mask_rna[mask_nuc].sum()
-    rna_out = max(mask_rna_out.sum(), 1)
-    feature = rna_in / rna_out
+    mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_in = rna_coord[mask_rna_in]
+    rna_out = rna_coord[~mask_rna_in]
+    feature = len(rna_in) / max(len(rna_out), 1)
 
     return feature
 
 
-def features_opening(opening_sizes, mask_cyt, mask_rna_out):
-    """
-
-    Parameters
-    ----------
-    opening_sizes
-    mask_cyt
-    mask_rna_out
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # get number of rna outside nucleus
-    nb_rna_out = mask_rna_out.sum()
-
-    # case where we do not detect any rna outside the nucleus
-    if nb_rna_out == 0:
-        features = [0. for _ in opening_sizes]
-        return features
+def features_opening_aubin(opening_sizes, rna_coord, mask_cyt):
+    # get number of rna
+    nb_rna = len(rna_coord)
 
-    # apply opening operator and count the loss of rna outside the nucleus
+    # apply opening operator and count the loss of rna
     features = []
     for size in opening_sizes:
         s = disk(size, dtype=bool)
         mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
-        nb_rna_out_after_opening = mask_rna_out[mask_cyt_transformed > 0].sum()
-        diff_opening = (nb_rna_out - nb_rna_out_after_opening) / nb_rna_out
+        mask_rna = mask_cyt_transformed[rna_coord[:, 1], rna_coord[:, 2]]
+        rna_after_opening = rna_coord[mask_rna]
+
+        nb_rna_after_opening = len(rna_after_opening)
+        diff_opening = (nb_rna - nb_rna_after_opening) / nb_rna
         features.append(diff_opening)
 
     return features
 
 
-def features_opening_aubin(opening_sizes, mask_cyt, mask_rna):
-    """
-
-    Parameters
-    ----------
-    opening_sizes
-    mask_cyt
-    mask_rna
+def features_ripley_aubin(radii, rna_coord, cyt_coord, mask_cyt):
+    # compute corrected Ripley values for different radii
+    values = _ripley_values_2d(radii, rna_coord, mask_cyt)
 
-    Returns
-    -------
+    # smooth them using moving average
+    smoothed_values = _moving_average(values, n=4)
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # get number of rna
-    nb_rna = mask_rna.sum()
+    # compute the gradients of these values
+    gradients = np.gradient(smoothed_values)
 
-    # apply opening operator and count the loss of rna
-    features = []
-    for size in opening_sizes:
-        s = disk(size, dtype=bool)
-        mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
-        nb_rna__after_opening = mask_rna[mask_cyt_transformed > 0].sum()
-        diff_opening = (nb_rna - nb_rna__after_opening) / nb_rna
-        features.append(diff_opening)
+    # compute features
+    index_max = np.argmax(smoothed_values)
+    max_radius = radii[index_max]
+    max_value = smoothed_values[index_max]
+    if index_max == 0:
+        max_gradient = gradients[0]
+    else:
+        max_gradient = max(gradients[:index_max])
+    if index_max == len(gradients) - 1:
+        min_gradient = gradients[-1]
+    else:
+        min_gradient = min(gradients[index_max:])
+    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
+    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
+    max_size_cell = np.max(distances_cell)
+    big_radius = int(max_size_cell / 4)
+    big_value = _ripley_values_2d([big_radius],rna_coord, mask_cyt)[0]
+    features = [max_value, max_gradient, min_gradient, monotony, big_value,
+                max_radius]
 
     return features
 
 
-def ripley_values(radii, mask_cyt, rna_coord, mask_rna):
-    """
-
-    Parameters
-    ----------
-    radii
-    mask_cyt
-    rna_coord
-    mask_rna
-
-    Returns
-    -------
+def _ripley_values_2d(radii, rna_coord, mask_cyt):
+    rna_coord_2d = rna_coord[:, 1:3]
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
     # sort rna coordinates
-    sorted_indices = np.lexsort((rna_coord[:, 1], rna_coord[:, 0]))
-    rna_coord = rna_coord[sorted_indices]
+    sorted_indices = np.lexsort((rna_coord_2d[:, 1], rna_coord_2d[:, 0]))
+    rna_coord_2d_sorted = rna_coord_2d[sorted_indices]
 
     # compute distance matrix between rna and rna density
-    distances = distance_matrix(rna_coord, rna_coord, p=2)
-    factor = len(rna_coord) ** 2 / mask_cyt.sum()
+    distances = distance_matrix(rna_coord_2d_sorted, rna_coord_2d_sorted, p=2)
+    factor = len(rna_coord_2d_sorted) ** 2 / mask_cyt.sum()
 
     # cast cytoplasm mask in np.uint8
     mask_cyt_8bit = stack.cast_img_uint8(mask_cyt)
@@ -349,10 +395,12 @@ def ripley_values(radii, mask_cyt, rna_coord, mask_rna):
         mask_distance = distances.copy()
         mask_distance = mask_distance <= r
         nb_neighbors = np.sum(mask_distance, axis=0) - 1
-        weights = stack.mean_filter(mask_cyt_8bit, kernel_shape="disk",
+        weights = stack.mean_filter(mask_cyt_8bit,
+                                    kernel_shape="disk",
                                     kernel_size=r)
         weights = weights.astype(np.float32) / 255.
-        rna_weights = weights[mask_rna]
+        rna_weights = weights[rna_coord_2d_sorted[:, 0],
+                              rna_coord_2d_sorted[:, 1]]
         nb_neighbors_weighted = np.multiply(nb_neighbors, rna_weights)
         value = nb_neighbors_weighted.sum() / factor
         values.append(value)
@@ -362,20 +410,7 @@ def ripley_values(radii, mask_cyt, rna_coord, mask_rna):
     return values_corrected
 
 
-def moving_average(a, n=4):
-    """
-
-    Parameters
-    ----------
-    a
-    n
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
+def _moving_average(a, n=4):
     res = np.cumsum(a, dtype=np.float32)
     res[n:] = res[n:] - res[:-n]
     averaged_array = res[n - 1:] / n
@@ -383,83 +418,118 @@ def moving_average(a, n=4):
     return averaged_array
 
 
-def features_ripley(radii, cyt_coord, mask_cyt, rna_coord_out, mask_rna_out):
-    """
+def feature_polarization_aubin(distance_cyt, distance_cyt_centroid,
+                               centroid_rna):
+    # compute polarization index
+    factor = np.mean(distance_cyt_centroid[distance_cyt > 0])
+    distance_rna_cell = distance_cyt_centroid[centroid_rna[1], centroid_rna[2]]
+    feature = distance_rna_cell / factor
 
-    Parameters
-    ----------
-    radii
-    cyt_coord
-    mask_cyt
-    rna_coord_out
-    mask_rna_out
+    return feature
 
-    Returns
-    -------
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # case where we do not detect any rna outside the nucleus
-    if len(rna_coord_out) == 0:
-        features = [0., 0., 0., 0., 0., 0.]
-        return features
+def feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna):
+    rna_coord_2d = rna_coord[:, 1:3]
+    centroid_rna_2d = centroid_rna[1:]
 
-    # compute corrected Ripley values for different radii
-    values = ripley_values(radii, mask_cyt, rna_coord_out, mask_rna_out)
+    # get coordinates of each pixel of the cell
+    mask_cyt_coord = np.nonzero(mask_cyt)
+    mask_cyt_coord = np.column_stack(mask_cyt_coord)
 
-    # smooth them using moving average
-    smoothed_values = moving_average(values, n=4)
+    # compute dispersion index
+    sigma_rna = np.sum((rna_coord_2d - centroid_rna_2d) ** 2, axis=0)
+    sigma_rna = np.sum(sigma_rna / len(rna_coord_2d))
+    sigma_cell = np.sum((mask_cyt_coord - centroid_rna_2d) ** 2, axis=0)
+    sigma_cell = np.sum(sigma_cell / len(mask_cyt_coord))
+    feature = sigma_rna / sigma_cell
 
-    # compute the gradients of these values
-    gradients = np.gradient(smoothed_values)
+    return feature
 
-    # compute features
-    index_max = np.argmax(smoothed_values)
-    max_radius = radii[index_max]
-    max_value = smoothed_values[index_max]
-    if index_max == 0:
-        max_gradient = gradients[0]
-    else:
-        max_gradient = max(gradients[:index_max])
-    if index_max == len(gradients) - 1:
-        min_gradient = gradients[-1]
-    else:
-        min_gradient = min(gradients[index_max:])
-    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
-    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
-    max_size_cell = np.max(distances_cell)
-    big_radius = int(max_size_cell / 4)
-    big_value = ripley_values([big_radius], mask_cyt, rna_coord_out,
-                              mask_rna_out)[0]
-    features = [max_value, max_gradient, min_gradient, monotony, big_value,
-                max_radius]
+
+# ### Other features ###
+
+def features_distance(rna_coord_out, distance_cyt, distance_nuc):
+    rna_coord_out_2d = rna_coord_out[:, 1:3]
+    if len(rna_coord_out_2d) == 0:
+        features = [1., 1., 1., 1., 1., 1.]
+        return features
+
+    # compute statistics from distance to cytoplasm
+    distance_rna_cyt = distance_cyt[rna_coord_out_2d[:, 0],
+                                    rna_coord_out_2d[:, 1]]
+    factor = np.mean(distance_cyt[distance_nuc > 0])
+    mean_distance_cyt = np.mean(distance_rna_cyt) / factor
+    factor = np.median(distance_cyt[distance_nuc > 0])
+    median_distance_cyt = np.median(distance_rna_cyt) / factor
+    factor = np.std(distance_cyt[distance_nuc > 0])
+    std_distance_cyt = np.std(distance_rna_cyt) / factor
+
+    # compute statistics from distance to nucleus
+    distance_rna_nuc = distance_nuc[rna_coord_out_2d[:, 0],
+                                    rna_coord_out_2d[:, 1]]
+    factor = np.mean(distance_nuc[distance_nuc > 0])
+    mean_distance_nuc = np.mean(distance_rna_nuc) / factor
+    factor = np.median(distance_nuc[distance_nuc > 0])
+    median_distance_nuc = np.median(distance_rna_nuc) / factor
+    factor = np.std(distance_nuc[distance_nuc > 0])
+    std_distance_nuc = np.std(distance_rna_nuc) / factor
+
+    features = [mean_distance_cyt, median_distance_cyt, std_distance_cyt,
+                mean_distance_nuc, median_distance_nuc, std_distance_nuc]
 
     return features
 
 
-def features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
-    """
+def feature_in_out_nucleus(rna_coord, mask_nuc):
+    # compute the proportion of rna in the nucleus
+    mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_in = rna_coord[mask_rna_in]
+    feature = len(rna_in) / len(rna_coord)
 
-    Parameters
-    ----------
-    radii
-    cyt_coord
-    mask_cyt
-    rna_coord
-    mask_rna
+    return feature
 
-    Returns
-    -------
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
+def features_protrusion(opening_sizes, rna_coord_out, mask_cyt):
+    # get number of rna outside nucleus
+    nb_rna_out = len(rna_coord_out)
+
+    # case where we do not detect any rna outside the nucleus
+    if nb_rna_out == 0:
+        features = [0. for _ in opening_sizes] * 2
+        return features
+
+    # apply opening operator and count the loss of rna outside the nucleus
+    features_opening = []
+    features_count = []
+    for size in opening_sizes:
+        s = disk(size, dtype=bool)
+        mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
+        mask_rna = mask_cyt_transformed[rna_coord_out[:, 1],
+                                        rna_coord_out[:, 2]]
+        rna_after_opening = rna_coord_out[mask_rna]
+        nb_rna_out_after_opening = len(rna_after_opening)
+        diff_opening = (nb_rna_out - nb_rna_out_after_opening) / nb_rna_out
+        features_opening.append(diff_opening)
+        nb_rna_protrusion = nb_rna_out - nb_rna_out_after_opening
+        features_count.append(nb_rna_protrusion)
+
+    # gather features
+    features = features_opening + features_count
+
+    return features
+
+
+def features_ripley(radii, rna_coord_out, mask_cyt):
+    # case where we do not detect any rna outside the nucleus
+    if len(rna_coord_out) == 0:
+        features = [0., 0., 0., 0., 0., 0.]
+        return features
+
     # compute corrected Ripley values for different radii
-    values = ripley_values(radii, mask_cyt, rna_coord, mask_rna)
+    values = _ripley_values_3d(radii, rna_coord_out, mask_cyt)
 
     # smooth them using moving average
-    smoothed_values = moving_average(values, n=4)
+    smoothed_values = _moving_average(values, n=4)
 
     # compute the gradients of these values
     gradients = np.gradient(smoothed_values)
@@ -467,7 +537,8 @@ def features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
     # compute features
     index_max = np.argmax(smoothed_values)
     max_radius = radii[index_max]
-    max_value = smoothed_values[index_max]
+    max_value = smoothed_values.max()
+    min_value = smoothed_values.min()
     if index_max == 0:
         max_gradient = gradients[0]
     else:
@@ -477,247 +548,248 @@ def features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
     else:
         min_gradient = min(gradients[index_max:])
     monotony, _ = spearmanr(smoothed_values, radii[2:-1])
-    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
-    max_size_cell = np.max(distances_cell)
-    big_radius = int(max_size_cell / 4)
-    big_value = ripley_values([big_radius], mask_cyt, rna_coord, mask_rna)[0]
-    features = [max_value, max_gradient, min_gradient, monotony, big_value,
-                max_radius]
+
+    features = [max_value, min_value, max_gradient, min_gradient,
+                monotony, max_radius]
 
     return features
 
 
-def feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna):
-    """
+def _ripley_values_3d(radii, rna_coord_out, mask_cyt):
+    rna_coord_out_3d = rna_coord_out[:, :3]
 
-    Parameters
-    ----------
-    distance_cyt
-    distance_cyt_centroid
-    centroid_rna
+    # sort rna coordinates
+    sorted_indices = np.lexsort((rna_coord_out_3d[:, 0],
+                                 rna_coord_out_3d[:, 2],
+                                 rna_coord_out_3d[:, 1]))
+    rna_coord_out_3d = rna_coord_out_3d[sorted_indices]
 
-    Returns
-    -------
+    # compute distance matrix between rna and rna density
+    distances = distance_matrix(rna_coord_out_3d, rna_coord_out_3d, p=2)
+    factor = len(rna_coord_out_3d) ** 2 / mask_cyt.sum()
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # compute polarization index
-    factor = np.mean(distance_cyt_centroid[distance_cyt > 0])
-    distance_rna_cell = distance_cyt_centroid[centroid_rna[0], centroid_rna[1]]
-    feature = distance_rna_cell / factor
+    # cast cytoplasm mask in np.uint8
+    mask_cyt_8bit = stack.cast_img_uint8(mask_cyt)
 
-    return feature
+    # for each radius, get neighbors and weight
+    values = []
+    for r in radii:
+        mask_distance = distances.copy()
+        mask_distance = mask_distance <= r
+        nb_neighbors = np.sum(mask_distance, axis=0) - 1
+        weights = stack.mean_filter(mask_cyt_8bit,
+                                    kernel_shape="disk",
+                                    kernel_size=r)
+        weights = weights.astype(np.float32) / 255.
+        rna_weights = weights[rna_coord_out_3d[:, 1], rna_coord_out_3d[:, 2]]
+        nb_neighbors_weighted = np.multiply(nb_neighbors, rna_weights)
+        value = nb_neighbors_weighted.sum() / factor
+        values.append(value)
+    values = np.array(values, dtype=np.float32)
+    values_corrected = np.sqrt(values / np.pi) - np.array(radii)
 
+    return values_corrected
 
-def feature_dispersion(mask_cyt, rna_coord, centroid_rna):
-    """
 
-    Parameters
-    ----------
-    mask_cyt
-    rna_coord
-    centroid_rna
+def feature_polarization(centroid_rna_out, centroid_cyt, distance_cyt_centroid,
+                         mask_cyt):
+    centroid_rna_out_2d = centroid_rna_out[1:]
 
-    Returns
-    -------
+    # compute polarization index
+    a = np.linalg.norm(centroid_rna_out_2d - centroid_cyt)
+    b = np.sqrt(np.mean(np.square(distance_cyt_centroid[mask_cyt > 0])))
+    feature = a / b
+
+    return feature
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # TODO correct the formula
-    # case where we do not detect rna outside nucleus
-    if len(rna_coord) == 0:
-        return 1.
 
+def feature_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt):
     # get coordinates of each pixel of the cell
-    mask_cyt_coord = np.nonzero(mask_cyt)
-    mask_cyt_coord = np.column_stack(mask_cyt_coord)
+    all_cell_coord = np.nonzero(mask_cyt)
+    all_cell_coord = np.column_stack(all_cell_coord)
 
     # compute dispersion index
-    sigma_rna = np.sum((rna_coord - centroid_rna) ** 2, axis=0)
-    sigma_rna = np.sum(sigma_rna / len(rna_coord))
-    sigma_cell = np.sum((mask_cyt_coord - centroid_rna) ** 2, axis=0)
-    sigma_cell = np.sum(sigma_cell / len(mask_cyt_coord))
-    feature = sigma_rna / sigma_cell
+    a = distance_rna_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
+    b = distance_rna_centroid[all_cell_coord[:, 0], all_cell_coord[:, 1]]
+    feature = a.mean() / b.mean()
 
     return feature
 
 
-def feature_area(mask_cyt, mask_nuc):
-    """
-
-    Parameters
-    ----------
-    mask_cyt
-    mask_nuc
+def feature_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
+                                  mask_cyt):
+    # get coordinates of each pixel of the cell
+    all_cell_coord = np.nonzero(mask_cyt)
+    all_cell_coord = np.column_stack(all_cell_coord)
 
-    Returns
-    -------
+    # compute dispersion index
+    a = distance_cyt_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
+    b = distance_cyt_centroid[all_cell_coord[:, 0], all_cell_coord[:, 1]]
+    feature = a.mean() / b.mean()
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # get area of the cytoplasm and the nucleus
-    area_cyt = mask_cyt.sum()
-    area_nuc = mask_nuc.sum()
+    return feature
 
-    # compute relative area of the nucleus
-    relative_area_nuc = area_nuc / area_cyt
 
-    # return features
-    features = [relative_area_nuc, area_cyt, area_nuc]
+def features_topography(rna_coord, mask_cyt, mask_nuc):
+    mask_cyt_bool = mask_cyt > 0
+    mask_cyt_bool[:, 0] = False
+    mask_cyt_bool[0, :] = False
+    mask_nuc_bool = mask_nuc > 0
+    mask_nuc_bool[:, 0] = False
+    mask_nuc_bool[0, :] = False
+
+    # build nucleus topography
+    distance_map_nuc_out = ndi.distance_transform_edt(~mask_nuc_bool)
+    mask_cyt_without_nuc = mask_cyt_bool.copy()
+    mask_cyt_without_nuc[mask_nuc_bool] = 0
+    distance_map_nuc_in = ndi.distance_transform_edt(~mask_cyt_without_nuc)
+    distance_map_nuc = distance_map_nuc_out + distance_map_nuc_in
+    distance_map_nuc[~mask_cyt_bool] = 0
+    distance_map_nuc_edge = distance_map_nuc < 10
+    distance_map_nuc_edge[~mask_cyt_bool] = False
+    distance_map_nuc_10_20 = distance_map_nuc < 20
+    distance_map_nuc_10_20[mask_nuc_bool] = False
+    distance_map_nuc_10_20[distance_map_nuc_edge] = False
+    distance_map_nuc_10_20[~mask_cyt_bool] = False
+    distance_map_nuc_20_30 = distance_map_nuc < 30
+    distance_map_nuc_20_30[mask_nuc_bool] = False
+    distance_map_nuc_20_30[distance_map_nuc_edge] = False
+    distance_map_nuc_20_30[distance_map_nuc_10_20] = False
+    distance_map_nuc_20_30[~mask_cyt_bool] = False
+
+    # build cytoplasm topography
+    distance_map_cyt = ndi.distance_transform_edt(mask_cyt_bool)
+    distance_map_cyt_0_10 = distance_map_cyt < 10
+    distance_map_cyt_0_10[~mask_cyt_bool] = False
+    distance_map_cyt_10_20 = distance_map_cyt < 20
+    distance_map_cyt_10_20[~mask_cyt_bool] = False
+    distance_map_cyt_10_20[distance_map_cyt_0_10] = False
+    distance_map_cyt_20_30 = distance_map_cyt < 30
+    distance_map_cyt_20_30[~mask_cyt_bool] = False
+    distance_map_cyt_20_30[distance_map_cyt_0_10] = False
+    distance_map_cyt_20_30[distance_map_cyt_10_20] = False
+
+    # count rna for each topographic level
+    cell_area = mask_cyt_bool.sum()
+    nb_rna = len(rna_coord)
+
+    factor = nb_rna * distance_map_nuc_edge.sum() / cell_area
+    mask_rna = distance_map_nuc_edge[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_nuc_edge = len(rna_coord[mask_rna]) / factor
+
+    factor = nb_rna * distance_map_nuc_10_20.sum() / cell_area
+    mask_rna = distance_map_nuc_10_20[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_nuc_10_20 = len(rna_coord[mask_rna]) / factor
+
+    factor = nb_rna * distance_map_nuc_20_30.sum() / cell_area
+    mask_rna = distance_map_nuc_20_30[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_nuc_20_30 = len(rna_coord[mask_rna]) / factor
+
+    factor = nb_rna * distance_map_cyt_0_10.sum() / cell_area
+    mask_rna = distance_map_cyt_0_10[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_cyt_0_10 = len(rna_coord[mask_rna]) / factor
+
+    factor = nb_rna * distance_map_cyt_10_20.sum() / cell_area
+    mask_rna = distance_map_cyt_10_20[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_cyt_10_20 = len(rna_coord[mask_rna]) / factor
+
+    factor = nb_rna * distance_map_cyt_20_30.sum() / cell_area
+    mask_rna = distance_map_cyt_20_30[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_cyt_20_30 = len(rna_coord[mask_rna]) / factor
+
+    features = [rna_nuc_edge, rna_nuc_10_20, rna_nuc_20_30,
+                rna_cyt_0_10, rna_cyt_10_20, rna_cyt_20_30]
 
     return features
 
 
-def feature_height():
-    return
-
-
-def get_features(cyt_coord, nuc_coord, rna_coord):
-    """Compute cell features.
-
-    Parameters
-    ----------
-    cyt_coord : np.ndarray, np.int64
-        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
-    nuc_coord : np.ndarray, np.int64
-        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
-    rna_coord : np.ndarray, np.int64
-        Coordinate yx of the detected rna with shape (nb_rna, 2).
-
-    Returns
-    -------
-    features : List[float]
-        List of features (cf. features.get_features_name()).
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # TODO filter features
-    # get a binary representation of the coordinates
-    cyt, nuc, mask_rna = from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord)
-
-    # fill in masks
-    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
-
-    # compute distance maps for the cytoplasm and the nucleus
-    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
-
-    # get rna outside nucleus
-    mask_rna_out = mask_rna.copy()
-    mask_rna_out[distance_nuc == 0] = 0
-    rna_coord_out = np.nonzero(mask_rna_out)
-    rna_coord_out = np.column_stack(rna_coord_out)
-
-    # get centroids
-    centroid_cyt = get_centroid(mask_cyt)
-    centroid_nuc = get_centroid(mask_nuc)
-    if len(rna_coord_out) == 0:
-        centroid_rna_out = centroid_cyt
-    else:
-        centroid_rna_out = np.mean(rna_coord_out, axis=0, dtype=np.int64)
-
-    # get centroid distance maps
-    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
-    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
-
-    # compute features
-    a = features_distance(mask_rna_out, distance_cyt, distance_nuc,
-                          distance_cyt_centroid, distance_nuc_centroid)
-    b = feature_in_out_nucleus(mask_nuc, mask_rna)
-    opening_sizes = [15, 30, 45, 60]
-    c = features_opening(opening_sizes, mask_cyt, mask_rna_out)
-    radii = [r for r in range(40)]
-    d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord_out,
-                        mask_rna_out)
-    e = feature_polarization(distance_cyt, distance_cyt_centroid,
-                             centroid_rna_out)
-    f = feature_dispersion(mask_cyt, rna_coord_out, centroid_rna_out)
-    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
+def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
+                  mask_nuc):
+    # detect low density foci
+    clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
+                                              resolution_z=300,
+                                              resolution_yx=103,
+                                              radius=650,
+                                              nb_min_spots=5)
+    foci = detection.extract_foci(clustered_spots=clustered_spots)
+    nb_low_density_foci = len(foci)
+
+    # get regular foci id
+    rna_coord_out_foci = rna_coord_out[rna_coord_out[:, 3] != -1, :]
+    if len(rna_coord_out_foci) == 0:
+        return [nb_low_density_foci, 0., 0., 1., 1., 1., 1., 1., 1.]
+    l_id_foci = list(set(rna_coord_out_foci[:, 3]))
+
+    # count foci neighbors
+    rna_foci_0_10 = []
+    rna_foci_10_20 = []
+    foci_coord = []
+    for id_foci in l_id_foci:
+        rna_foci = rna_coord_out_foci[rna_coord_out_foci[:, 3] == id_foci, :3]
+        foci = np.mean(rna_foci, axis=0).reshape(1, 3)
+        foci_coord.append(foci)
+        distance = distance_matrix(rna_coord_out_foci[:, :3], foci)
+        mask_distance_0_10 = distance < 10
+        mask_distance_10_20 = distance < 20
+        mask_distance_10_20 &= ~mask_distance_0_10
+        nb_rna_foci_0_10 = mask_distance_0_10.sum()
+        nb_rna_foci_10_20 = mask_distance_10_20.sum()
+        rna_foci_0_10.append(nb_rna_foci_0_10)
+        rna_foci_10_20.append(nb_rna_foci_10_20)
+
+    # compute expected ratio
+    area_0_10 = np.pi * 10 ** 2
+    area_0_20 = np.pi * 20 ** 2
+    area_10_20 = area_0_20 - area_0_10
+    area_cyt_no_nuc = mask_cyt.sum() - mask_nuc.sum()
+    factor_0_10 = len(rna_coord_out) * area_0_10 / area_cyt_no_nuc
+    factor_10_20 = len(rna_coord_out) * area_10_20 / area_cyt_no_nuc
+    ratio_rna_foci_0_10 = np.mean(rna_foci_0_10) / factor_0_10
+    ratio_rna_foci_10_20 = np.mean(rna_foci_10_20) / factor_10_20
+
+    # get foci coordinates
+    foci_coord = np.array(foci_coord, dtype=np.int64)
+    foci_coord = np.squeeze(foci_coord, axis=1)
+    foci_coord_2d = foci_coord[:, 1:3]
+
+    # compute statistics from distance to cytoplasm
+    distance_foci_cyt = distance_cyt[foci_coord_2d[:, 0],
+                                     foci_coord_2d[:, 1]]
+    factor = np.mean(distance_cyt[distance_nuc > 0])
+    foci_mean_distance_cyt = np.mean(distance_foci_cyt) / factor
+    factor = np.median(distance_cyt[distance_nuc > 0])
+    foci_median_distance_cyt = np.median(distance_foci_cyt) / factor
+    factor = np.std(distance_cyt[distance_nuc > 0])
+    foci_std_distance_cyt = np.std(distance_foci_cyt) / factor
+
+    # compute statistics from distance to nucleus
+    distance_foci_nuc = distance_nuc[foci_coord_2d[:, 0],
+                                     foci_coord_2d[:, 1]]
+    factor = np.mean(distance_nuc[distance_nuc > 0])
+    foci_mean_distance_nuc = np.mean(distance_foci_nuc) / factor
+    factor = np.median(distance_nuc[distance_nuc > 0])
+    foci_median_distance_nuc = np.median(distance_foci_nuc) / factor
+    factor = np.std(distance_nuc[distance_nuc > 0])
+    foci_std_distance_nuc = np.std(distance_foci_nuc) / factor
+
+    features = [nb_low_density_foci,
+                ratio_rna_foci_0_10, ratio_rna_foci_10_20,
+                foci_mean_distance_cyt, foci_median_distance_cyt,
+                foci_std_distance_cyt, foci_mean_distance_nuc,
+                foci_median_distance_nuc, foci_std_distance_nuc]
 
     return features
 
 
-def get_features_name():
-    """Return the current list of features names.
-
-    Returns
-    -------
-    features_name : List[str]
-        List of features name returned by features.get_features().
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # TODO filter features
-    features_name = ["average_dist_cyt", "quantile_5_dist_cyt",
-                     "quantile_10_dist_cyt", "quantile_20_dist_cyt",
-                     "quantile_50_dist_cyt", "average_dist_cyt_centroid",
-                     "average_dist_nuc", "average_dist_nuc_centroid",
-                     "ratio_in_nuc", "diff_opening_15", "diff_opening_30",
-                     "diff_opening_45", "diff_opening_60", "ripley_max",
-                     "ripley_max_gradient", "ripley_min_gradient",
-                     "ripley_monotony", "ripley_large", "ripley_radius_max",
-                     "polarization_index", "dispersion_index"]
-
-    return features_name
-
-
-def get_features_aubin(cyt_coord, nuc_coord, rna_coord):
-    """Compute cell features, according to Aubin's paper.
-
-    Parameters
-    ----------
-    cyt_coord : np.ndarray, np.int64
-        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
-    nuc_coord : np.ndarray, np.int64
-        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
-    rna_coord : np.ndarray, np.int64
-        Coordinate yx of the detected rna with shape (nb_rna, 2).
-
-    Returns
-    -------
-    features : List[float]
-        List of features (cf. features.get_features_name()).
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # TODO filter features
-    # get a binary representation of the coordinates
-    cyt, nuc, mask_rna = from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord)
-
-    # fill in masks
-    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
-
-    # compute distance maps for the cytoplasm and the nucleus
-    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
-
-    # get centroids
-    centroid_cyt = get_centroid(mask_cyt)
-    centroid_nuc = get_centroid(mask_nuc)
-    centroid_rna = np.mean(rna_coord, axis=0, dtype=np.int64)
-
-    # get centroid distance maps
-    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
-    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+def feature_area(mask_cyt, mask_nuc):
+    # get area of the cytoplasm and the nucleus
+    area_cyt = mask_cyt.sum()
+    area_nuc = mask_nuc.sum()
 
-    # get rna outside nucleus
-    mask_rna_out = mask_rna.copy()
-    mask_rna_out[distance_nuc == 0] = 0
+    # compute relative area of the nucleus
+    relative_area_nuc = area_nuc / area_cyt
 
-    # compute features
-    a = features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
-                                distance_cyt_centroid, distance_nuc_centroid)
-    b = feature_in_out_nucleus_aubin(mask_nuc, mask_rna, mask_rna_out)
-    opening_sizes = [15, 30, 45, 60]
-    c = features_opening_aubin(opening_sizes, mask_cyt, mask_rna)
-    radii = [r for r in range(40)]
-    d = features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
-    e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
-    f = feature_dispersion(mask_cyt, rna_coord, centroid_rna)
-    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
+    # return features
+    features = [relative_area_nuc, area_cyt, area_nuc]
 
     return features

From af507b85f35011cde8f154531c4d2bb5f9efc9c5 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 13 Sep 2019 03:53:51 +0200
Subject: [PATCH 235/264] fix case when no spot are detected

---
 bigfish/classification/features.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 6f5b2411..acca1f06 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -604,6 +604,9 @@ def feature_polarization(centroid_rna_out, centroid_cyt, distance_cyt_centroid,
 
 
 def feature_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt):
+    if len(rna_coord_out) == 0:
+        return 1.
+
     # get coordinates of each pixel of the cell
     all_cell_coord = np.nonzero(mask_cyt)
     all_cell_coord = np.column_stack(all_cell_coord)
@@ -618,6 +621,9 @@ def feature_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt):
 
 def feature_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
                                   mask_cyt):
+    if len(rna_coord_out) == 0:
+        return 1.
+
     # get coordinates of each pixel of the cell
     all_cell_coord = np.nonzero(mask_cyt)
     all_cell_coord = np.column_stack(all_cell_coord)
@@ -705,6 +711,9 @@ def features_topography(rna_coord, mask_cyt, mask_nuc):
 
 def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
                   mask_nuc):
+    if len(rna_coord_out) == 0:
+        return [0., 1., 1., 1., 1., 1., 1., 1., 1.]
+
     # detect low density foci
     clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
                                               resolution_z=300,

From 108a5660b9451502d6804efb2b6bbf402dadfca6 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 13 Sep 2019 04:02:40 +0200
Subject: [PATCH 236/264] fix features

---
 bigfish/classification/features.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index acca1f06..0d51b7b1 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -49,7 +49,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
 
     # get a binary representation of the coordinates
     cyt, nuc = from_coord_to_matrix(cyt_coord, nuc_coord)
-    rna_coord = rna_coord + 1
+    rna_coord = rna_coord + stack.get_offset_value()
 
     # fill in masks
     mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
@@ -219,17 +219,19 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
 
 def from_coord_to_matrix(cyt_coord, nuc_coord):
     # get size of the frame
-    max_y = cyt_coord[:, 0].max() + 3
-    max_x = cyt_coord[:, 1].max() + 3
+    max_y = cyt_coord[:, 0].max() + stack.get_offset_value() * 2
+    max_x = cyt_coord[:, 1].max() + stack.get_offset_value() * 2
     image_shape = (max_y, max_x)
 
     # cytoplasm
     cyt = np.zeros(image_shape, dtype=bool)
-    cyt[cyt_coord[:, 0] + 1, cyt_coord[:, 1] + 1] = True
+    cyt[cyt_coord[:, 0] + stack.get_offset_value(),
+        cyt_coord[:, 1] + stack.get_offset_value()] = True
 
     # nucleus
     nuc = np.zeros(image_shape, dtype=bool)
-    nuc[nuc_coord[:, 0] + 1, nuc_coord[:, 1] + 1] = True
+    nuc[nuc_coord[:, 0] + stack.get_offset_value(),
+        nuc_coord[:, 1] + stack.get_offset_value()] = True
 
     return cyt, nuc
 

From edceefc617a1458555eb2af84f1304c0179c61fc Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 13 Sep 2019 13:03:21 +0200
Subject: [PATCH 237/264] change normalization polarization score

---
 bigfish/classification/features.py | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 0d51b7b1..b081a03b 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -106,7 +106,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
         radii = [r for r in range(40)]
         dd = features_ripley(radii, rna_coord_out, mask_cyt)
         ee = feature_polarization(centroid_rna_out, centroid_cyt,
-                                  distance_cyt_centroid, mask_cyt)
+                                  distance_cyt_centroid)
         ff = feature_dispersion(rna_coord_out, distance_rna_out_centroid,
                                 mask_cyt)
         gg = feature_peripheral_dispersion(rna_coord_out,
@@ -118,7 +118,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
         jj = feature_area(mask_cyt, mask_nuc)
 
         # gather features
-        features_to_add = aa + [bb] + cc + dd + [ee] + [ff] + [gg] + hh + ii + jj
+        features_to_add = aa + [bb] + cc + dd + ee + [ff] + [gg] + hh + ii + jj
         features += features_to_add
 
     features = np.array(features, dtype=np.float32)
@@ -189,7 +189,8 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
                            "ripley_min_gradient",
                            "ripley_monotony",
                            "aubin_ripley_max_radius",
-                           "polarization_index",
+                           "polarization_score",
+                           "polarization_score_normalized",
                            "dispersion_index",
                            "peripheral_dispersion_index",
                            "rna_nuc_edge",
@@ -593,14 +594,15 @@ def _ripley_values_3d(radii, rna_coord_out, mask_cyt):
     return values_corrected
 
 
-def feature_polarization(centroid_rna_out, centroid_cyt, distance_cyt_centroid,
-                         mask_cyt):
+def feature_polarization(centroid_rna_out, centroid_cyt,
+                         distance_cyt_centroid):
     centroid_rna_out_2d = centroid_rna_out[1:]
 
     # compute polarization index
-    a = np.linalg.norm(centroid_rna_out_2d - centroid_cyt)
-    b = np.sqrt(np.mean(np.square(distance_cyt_centroid[mask_cyt > 0])))
-    feature = a / b
+    polarization_index = np.linalg.norm(centroid_rna_out_2d - centroid_cyt)
+    factor = distance_cyt_centroid.max()
+    polarization_index_normalized = polarization_index / factor
+    feature = [polarization_index, polarization_index_normalized]
 
     return feature
 

From 2018dfb0b03d293ff46470157dad1b50d327d1b7 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 13 Sep 2019 17:32:12 +0200
Subject: [PATCH 238/264] fix feature name

---
 bigfish/classification/features.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index b081a03b..306726a3 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -188,7 +188,7 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
                            "ripley_max_gradient",
                            "ripley_min_gradient",
                            "ripley_monotony",
-                           "aubin_ripley_max_radius",
+                           "ripley_max_radius",
                            "polarization_score",
                            "polarization_score_normalized",
                            "dispersion_index",

From eef967935f9316dbe61a9282f2025aa32ca89351 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 14 Sep 2019 18:18:19 +0200
Subject: [PATCH 239/264] improve new features

---
 bigfish/classification/features.py | 169 +++++++++++++++++------------
 1 file changed, 100 insertions(+), 69 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 306726a3..a13772d5 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -33,7 +33,8 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
     nuc_coord : np.ndarray, np.int64
         Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
     rna_coord : np.ndarray, np.int64
-        Coordinate yx of the detected rna with shape (nb_rna, 2).
+        Coordinate zyx of the detected rna, plus the index of a potential foci.
+        Shape (nb_rna, 4).
     features_aubin : bool
         Compute features from Aubin paper.
     features_no_aubin : bool
@@ -49,7 +50,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
 
     # get a binary representation of the coordinates
     cyt, nuc = from_coord_to_matrix(cyt_coord, nuc_coord)
-    rna_coord = rna_coord + stack.get_offset_value()
+    rna_coord[:, 1:3] += stack.get_offset_value()
 
     # fill in masks
     mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
@@ -102,7 +103,8 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
         aa = features_distance(rna_coord_out, distance_cyt, distance_nuc)
         bb = feature_in_out_nucleus(rna_coord, mask_nuc)
         opening_sizes = [15, 30, 45, 60]
-        cc = features_protrusion(opening_sizes, rna_coord_out, mask_cyt)
+        cc = features_protrusion(opening_sizes, rna_coord_out, mask_cyt,
+                                 mask_nuc)
         radii = [r for r in range(40)]
         dd = features_ripley(radii, rna_coord_out, mask_cyt)
         ee = feature_polarization(centroid_rna_out, centroid_cyt,
@@ -168,21 +170,21 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
         features_name += features_to_add
 
     if features_no_aubin:
-        features_to_add = ["mean_distance_cyt",
-                           "median_distance_cyt",
-                           "std_distance_cyt",
-                           "mean_distance_nuc",
-                           "median_distance_nuc",
-                           "std_distance_nuc",
+        features_to_add = ["index_mean_distance_cyt",
+                           "index_median_distance_cyt",
+                           "index_std_distance_cyt",
+                           "index_mean_distance_nuc",
+                           "index_median_distance_nuc",
+                           "index_std_distance_nuc",
                            "proportion_in_nuc",
-                           "diff_opening_15",
-                           "diff_opening_30",
-                           "diff_opening_45",
-                           "diff_opening_60",
-                           "nb_rna_opening_15",
-                           "nb_rna_opening_30",
-                           "nb_rna_opening_45",
-                           "nb_rna_opening_60",
+                           "index_rna_opening_15",
+                           "index_rna_opening_30",
+                           "index_rna_opening_45",
+                           "index_rna_opening_60",
+                           "proportion_rna_opening_15",
+                           "proportion_rna_opening_30",
+                           "proportion_rna_opening_45",
+                           "proportion_rna_opening_60",
                            "ripley_max",
                            "ripley_min",
                            "ripley_max_gradient",
@@ -193,15 +195,23 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
                            "polarization_score_normalized",
                            "dispersion_index",
                            "peripheral_dispersion_index",
-                           "rna_nuc_edge",
-                           "rna_nuc_10_20",
-                           "rna_nuc_20_30",
-                           "rna_cyt_0_10",
-                           "rna_cyt_10_20",
-                           "rna_cyt_20_30",
+                           "index_rna_nuc_edge",
+                           "index_rna_nuc_5_15",
+                           "index_rna_nuc_15_25",
+                           "index_rna_cyt_0_10",
+                           "index_rna_cyt_10_20",
+                           "index_rna_cyt_20_30",
+                           "proportion_rna_nuc_edge",
+                           "proportion_rna_nuc_5_15",
+                           "proportion_rna_nuc_15_25",
+                           "proportion_rna_cyt_0_10",
+                           "proportion_rna_cyt_10_20",
+                           "proportion_rna_cyt_20_30",
                            "nb_low_density_foci",
-                           "ratio_rna_foci_0_10",
-                           "ratio_rna_foci_10_20",
+                           "index_rna_foci_0_10",
+                           "index_rna_foci_10_20",
+                           "proportion_rna_foci_0_10",
+                           "proportion_rna_foci_10_20",
                            "foci_mean_distance_cyt",
                            "foci_median_distance_cyt",
                            "foci_std_distance_cyt",
@@ -371,7 +381,7 @@ def features_ripley_aubin(radii, rna_coord, cyt_coord, mask_cyt):
     distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
     max_size_cell = np.max(distances_cell)
     big_radius = int(max_size_cell / 4)
-    big_value = _ripley_values_2d([big_radius],rna_coord, mask_cyt)[0]
+    big_value = _ripley_values_2d([big_radius], rna_coord, mask_cyt)[0]
     features = [max_value, max_gradient, min_gradient, monotony, big_value,
                 max_radius]
 
@@ -492,9 +502,12 @@ def feature_in_out_nucleus(rna_coord, mask_nuc):
     return feature
 
 
-def features_protrusion(opening_sizes, rna_coord_out, mask_cyt):
-    # get number of rna outside nucleus
+def features_protrusion(opening_sizes, rna_coord_out, mask_cyt, mask_nuc):
+    # get number of rna outside nucleus and cell area
     nb_rna_out = len(rna_coord_out)
+    area_cell = mask_cyt.sum()
+    area_nuc = mask_nuc.sum()
+    area_cell_no_nuc = area_cell - area_nuc
 
     # case where we do not detect any rna outside the nucleus
     if nb_rna_out == 0:
@@ -502,22 +515,26 @@ def features_protrusion(opening_sizes, rna_coord_out, mask_cyt):
         return features
 
     # apply opening operator and count the loss of rna outside the nucleus
-    features_opening = []
-    features_count = []
+    features_index = []
+    features_proportion = []
     for size in opening_sizes:
         s = disk(size, dtype=bool)
         mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
+        mask_cyt_transformed[mask_nuc] = True
+        new_area_cell_no_nuc = mask_cyt_transformed.sum() - area_nuc
+        area_diff = area_cell_no_nuc - new_area_cell_no_nuc
+        expected_rna_protrusion = (nb_rna_out * area_diff / area_cell_no_nuc)
         mask_rna = mask_cyt_transformed[rna_coord_out[:, 1],
                                         rna_coord_out[:, 2]]
         rna_after_opening = rna_coord_out[mask_rna]
-        nb_rna_out_after_opening = len(rna_after_opening)
-        diff_opening = (nb_rna_out - nb_rna_out_after_opening) / nb_rna_out
-        features_opening.append(diff_opening)
-        nb_rna_protrusion = nb_rna_out - nb_rna_out_after_opening
-        features_count.append(nb_rna_protrusion)
+        nb_rna_protrusion = nb_rna_out - len(rna_after_opening)
+        index_rna_opening = nb_rna_protrusion / expected_rna_protrusion
+        proportion_rna_opening = nb_rna_protrusion / nb_rna_out
+        features_index.append(index_rna_opening)
+        features_proportion.append(proportion_rna_opening)
 
     # gather features
-    features = features_opening + features_count
+    features = features_index + features_proportion
 
     return features
 
@@ -655,17 +672,17 @@ def features_topography(rna_coord, mask_cyt, mask_nuc):
     distance_map_nuc_in = ndi.distance_transform_edt(~mask_cyt_without_nuc)
     distance_map_nuc = distance_map_nuc_out + distance_map_nuc_in
     distance_map_nuc[~mask_cyt_bool] = 0
-    distance_map_nuc_edge = distance_map_nuc < 10
+    distance_map_nuc_edge = distance_map_nuc < 5
     distance_map_nuc_edge[~mask_cyt_bool] = False
-    distance_map_nuc_10_20 = distance_map_nuc < 20
-    distance_map_nuc_10_20[mask_nuc_bool] = False
-    distance_map_nuc_10_20[distance_map_nuc_edge] = False
-    distance_map_nuc_10_20[~mask_cyt_bool] = False
-    distance_map_nuc_20_30 = distance_map_nuc < 30
-    distance_map_nuc_20_30[mask_nuc_bool] = False
-    distance_map_nuc_20_30[distance_map_nuc_edge] = False
-    distance_map_nuc_20_30[distance_map_nuc_10_20] = False
-    distance_map_nuc_20_30[~mask_cyt_bool] = False
+    distance_map_nuc_5_15 = distance_map_nuc < 15
+    distance_map_nuc_5_15[mask_nuc_bool] = False
+    distance_map_nuc_5_15[distance_map_nuc_edge] = False
+    distance_map_nuc_5_15[~mask_cyt_bool] = False
+    distance_map_nuc_15_25 = distance_map_nuc < 25
+    distance_map_nuc_15_25[mask_nuc_bool] = False
+    distance_map_nuc_15_25[distance_map_nuc_edge] = False
+    distance_map_nuc_15_25[distance_map_nuc_5_15] = False
+    distance_map_nuc_15_25[~mask_cyt_bool] = False
 
     # build cytoplasm topography
     distance_map_cyt = ndi.distance_transform_edt(mask_cyt_bool)
@@ -683,32 +700,42 @@ def features_topography(rna_coord, mask_cyt, mask_nuc):
     cell_area = mask_cyt_bool.sum()
     nb_rna = len(rna_coord)
 
-    factor = nb_rna * distance_map_nuc_edge.sum() / cell_area
+    factor = nb_rna * max(distance_map_nuc_edge.sum(), 1) / cell_area
     mask_rna = distance_map_nuc_edge[rna_coord[:, 1], rna_coord[:, 2]]
-    rna_nuc_edge = len(rna_coord[mask_rna]) / factor
+    index_rna_nuc_edge = len(rna_coord[mask_rna]) / factor
+    proportion_rna_nuc_edge = len(rna_coord[mask_rna]) / nb_rna
 
-    factor = nb_rna * distance_map_nuc_10_20.sum() / cell_area
-    mask_rna = distance_map_nuc_10_20[rna_coord[:, 1], rna_coord[:, 2]]
-    rna_nuc_10_20 = len(rna_coord[mask_rna]) / factor
+    factor = nb_rna * max(distance_map_nuc_5_15.sum(), 1) / cell_area
+    mask_rna = distance_map_nuc_5_15[rna_coord[:, 1], rna_coord[:, 2]]
+    index_rna_nuc_5_15 = len(rna_coord[mask_rna]) / factor
+    proportion_rna_nuc_5_15 = len(rna_coord[mask_rna]) / nb_rna
 
-    factor = nb_rna * distance_map_nuc_20_30.sum() / cell_area
-    mask_rna = distance_map_nuc_20_30[rna_coord[:, 1], rna_coord[:, 2]]
-    rna_nuc_20_30 = len(rna_coord[mask_rna]) / factor
+    factor = nb_rna * max(distance_map_nuc_15_25.sum(), 1) / cell_area
+    mask_rna = distance_map_nuc_15_25[rna_coord[:, 1], rna_coord[:, 2]]
+    index_rna_nuc_15_25 = len(rna_coord[mask_rna]) / factor
+    proportion_rna_nuc_15_25 = len(rna_coord[mask_rna]) / nb_rna
 
-    factor = nb_rna * distance_map_cyt_0_10.sum() / cell_area
+    factor = nb_rna * max(distance_map_cyt_0_10.sum(), 1) / cell_area
     mask_rna = distance_map_cyt_0_10[rna_coord[:, 1], rna_coord[:, 2]]
-    rna_cyt_0_10 = len(rna_coord[mask_rna]) / factor
+    index_rna_cyt_0_10 = len(rna_coord[mask_rna]) / factor
+    proportion_rna_cyt_0_10 = len(rna_coord[mask_rna]) / nb_rna
 
-    factor = nb_rna * distance_map_cyt_10_20.sum() / cell_area
+    factor = nb_rna * max(distance_map_cyt_10_20.sum(), 1) / cell_area
     mask_rna = distance_map_cyt_10_20[rna_coord[:, 1], rna_coord[:, 2]]
-    rna_cyt_10_20 = len(rna_coord[mask_rna]) / factor
+    index_rna_cyt_10_20 = len(rna_coord[mask_rna]) / factor
+    proportion_rna_cyt_10_20 = len(rna_coord[mask_rna]) / nb_rna
 
-    factor = nb_rna * distance_map_cyt_20_30.sum() / cell_area
+    factor = nb_rna * max(distance_map_cyt_20_30.sum(), 1) / cell_area
     mask_rna = distance_map_cyt_20_30[rna_coord[:, 1], rna_coord[:, 2]]
-    rna_cyt_20_30 = len(rna_coord[mask_rna]) / factor
+    index_rna_cyt_20_30 = len(rna_coord[mask_rna]) / factor
+    proportion_rna_cyt_20_30 = len(rna_coord[mask_rna]) / nb_rna
 
-    features = [rna_nuc_edge, rna_nuc_10_20, rna_nuc_20_30,
-                rna_cyt_0_10, rna_cyt_10_20, rna_cyt_20_30]
+    features = [index_rna_nuc_edge, index_rna_nuc_5_15,
+                index_rna_nuc_15_25, index_rna_cyt_0_10,
+                index_rna_cyt_10_20, index_rna_cyt_20_30,
+                proportion_rna_nuc_edge, proportion_rna_nuc_5_15,
+                proportion_rna_nuc_15_25, proportion_rna_cyt_0_10,
+                proportion_rna_cyt_10_20, proportion_rna_cyt_20_30]
 
     return features
 
@@ -716,7 +743,7 @@ def features_topography(rna_coord, mask_cyt, mask_nuc):
 def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
                   mask_nuc):
     if len(rna_coord_out) == 0:
-        return [0., 1., 1., 1., 1., 1., 1., 1., 1.]
+        return [0., 1., 1., 0., 0., 1., 1., 1., 1., 1., 1.]
 
     # detect low density foci
     clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
@@ -730,7 +757,7 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
     # get regular foci id
     rna_coord_out_foci = rna_coord_out[rna_coord_out[:, 3] != -1, :]
     if len(rna_coord_out_foci) == 0:
-        return [nb_low_density_foci, 0., 0., 1., 1., 1., 1., 1., 1.]
+        return [nb_low_density_foci, 0., 0., 0., 0., 1., 1., 1., 1., 1., 1.]
     l_id_foci = list(set(rna_coord_out_foci[:, 3]))
 
     # count foci neighbors
@@ -751,14 +778,17 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
         rna_foci_10_20.append(nb_rna_foci_10_20)
 
     # compute expected ratio
+    # TODO better computation of the area around the foci
     area_0_10 = np.pi * 10 ** 2
     area_0_20 = np.pi * 20 ** 2
     area_10_20 = area_0_20 - area_0_10
     area_cyt_no_nuc = mask_cyt.sum() - mask_nuc.sum()
-    factor_0_10 = len(rna_coord_out) * area_0_10 / area_cyt_no_nuc
-    factor_10_20 = len(rna_coord_out) * area_10_20 / area_cyt_no_nuc
-    ratio_rna_foci_0_10 = np.mean(rna_foci_0_10) / factor_0_10
-    ratio_rna_foci_10_20 = np.mean(rna_foci_10_20) / factor_10_20
+    expected_rna_foci_0_10 = len(rna_coord_out) * area_0_10 / area_cyt_no_nuc
+    expected_rna_foci_10_20 = len(rna_coord_out) * area_10_20 / area_cyt_no_nuc
+    index_rna_foci_0_10 = np.mean(rna_foci_0_10) / expected_rna_foci_0_10
+    index_rna_foci_10_20 = np.mean(rna_foci_10_20) / expected_rna_foci_10_20
+    proportion_rna_foci_0_10 = np.mean(rna_foci_0_10) / len(rna_coord_out)
+    proportion_rna_foci_10_20 = np.mean(rna_foci_10_20) / len(rna_coord_out)
 
     # get foci coordinates
     foci_coord = np.array(foci_coord, dtype=np.int64)
@@ -786,7 +816,8 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
     foci_std_distance_nuc = np.std(distance_foci_nuc) / factor
 
     features = [nb_low_density_foci,
-                ratio_rna_foci_0_10, ratio_rna_foci_10_20,
+                index_rna_foci_0_10, index_rna_foci_10_20,
+                proportion_rna_foci_0_10, proportion_rna_foci_10_20,
                 foci_mean_distance_cyt, foci_median_distance_cyt,
                 foci_std_distance_cyt, foci_mean_distance_nuc,
                 foci_median_distance_nuc, foci_std_distance_nuc]

From 66541f20f5248fd6c8bbbf7672616ad3cf3a0302 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 14 Sep 2019 18:18:31 +0200
Subject: [PATCH 240/264] misc

---
 bigfish/plot/plot_coordinates.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
index 3194e2d7..1bcc8f5c 100644
--- a/bigfish/plot/plot_coordinates.py
+++ b/bigfish/plot/plot_coordinates.py
@@ -550,7 +550,7 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
         if remove_frame:
             ax[1].axis("off")
         ax[1].imshow(image_coord)
-        if count_rna:
+        if count_rna and foci_coord is not None:
             for (_, y, x, nb_rna, _) in foci_coord:
                 ax[1].text(x+5, y-5, str(nb_rna), color="#66CC00", size=20)
         ax[1].set_title("Coordinate image" + title,
@@ -569,7 +569,7 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
             plt.title("Coordinate image" + title,
                       fontweight="bold", fontsize=25)
         plt.imshow(image_coord)
-        if count_rna:
+        if count_rna and foci_coord is not None:
             for (_, y, x, nb_rna, _) in foci_coord:
                 plt.text(x+5, y-5, str(nb_rna), color="#66CC00", size=20)
 

From b44fbba0b560ee8d1cab1a47a4d15af897c799c3 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sat, 14 Sep 2019 23:46:35 +0200
Subject: [PATCH 241/264] improve polarization and dispersion indices

---
 bigfish/classification/features.py | 38 +++++++++++++++++++++---------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index a13772d5..9fee3d7b 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -110,10 +110,10 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
         ee = feature_polarization(centroid_rna_out, centroid_cyt,
                                   distance_cyt_centroid)
         ff = feature_dispersion(rna_coord_out, distance_rna_out_centroid,
-                                mask_cyt)
+                                mask_cyt, mask_nuc)
         gg = feature_peripheral_dispersion(rna_coord_out,
                                            distance_cyt_centroid,
-                                           mask_cyt)
+                                           mask_cyt, mask_nuc)
         hh = features_topography(rna_coord, mask_cyt, mask_nuc)
         ii = features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
                            mask_nuc)
@@ -274,7 +274,6 @@ def get_centroid_distance_map(centroid_coordinate, mask_cyt):
     # compute distance map
     distance_map = ndi.distance_transform_edt(~mask_centroid)
     distance_map[mask_cyt == 0] = 0
-    distance_map /= distance_map.max()
     distance_map = distance_map.astype(np.float32)
 
     return distance_map
@@ -614,6 +613,7 @@ def _ripley_values_3d(radii, rna_coord_out, mask_cyt):
 def feature_polarization(centroid_rna_out, centroid_cyt,
                          distance_cyt_centroid):
     centroid_rna_out_2d = centroid_rna_out[1:]
+    # TODO compute the index with a cytoplasm centroid without the nuc area
 
     # compute polarization index
     polarization_index = np.linalg.norm(centroid_rna_out_2d - centroid_cyt)
@@ -624,34 +624,49 @@ def feature_polarization(centroid_rna_out, centroid_cyt,
     return feature
 
 
-def feature_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt):
+def feature_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt,
+                       mask_nuc):
     if len(rna_coord_out) == 0:
         return 1.
 
+    # get number of rna outside nucleus and cell area
+    mask_cyt_no_nuc = mask_cyt.copy()
+    mask_cyt_no_nuc[mask_nuc > 0] = 0.
+    if mask_cyt_no_nuc.sum() == 0:
+        return 1.
+
     # get coordinates of each pixel of the cell
-    all_cell_coord = np.nonzero(mask_cyt)
-    all_cell_coord = np.column_stack(all_cell_coord)
+    cell_outside_nuc_coord = np.nonzero(mask_cyt_no_nuc)
+    cell_outside_nuc_coord = np.column_stack(cell_outside_nuc_coord)
 
     # compute dispersion index
     a = distance_rna_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
-    b = distance_rna_centroid[all_cell_coord[:, 0], all_cell_coord[:, 1]]
+    b = distance_rna_centroid[cell_outside_nuc_coord[:, 0],
+                              cell_outside_nuc_coord[:, 1]]
     feature = a.mean() / b.mean()
 
     return feature
 
 
 def feature_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
-                                  mask_cyt):
+                                  mask_cyt, mask_nuc):
     if len(rna_coord_out) == 0:
         return 1.
 
+    # get number of rna outside nucleus and cell area
+    mask_cyt_no_nuc = mask_cyt.copy()
+    mask_cyt_no_nuc[mask_nuc > 0] = 0.
+    if mask_cyt_no_nuc.sum() == 0:
+        return 1.
+
     # get coordinates of each pixel of the cell
-    all_cell_coord = np.nonzero(mask_cyt)
-    all_cell_coord = np.column_stack(all_cell_coord)
+    cell_outside_nuc_coord = np.nonzero(mask_cyt_no_nuc)
+    cell_outside_nuc_coord = np.column_stack(cell_outside_nuc_coord)
 
     # compute dispersion index
     a = distance_cyt_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
-    b = distance_cyt_centroid[all_cell_coord[:, 0], all_cell_coord[:, 1]]
+    b = distance_cyt_centroid[cell_outside_nuc_coord[:, 0],
+                              cell_outside_nuc_coord[:, 1]]
     feature = a.mean() / b.mean()
 
     return feature
@@ -744,6 +759,7 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
                   mask_nuc):
     if len(rna_coord_out) == 0:
         return [0., 1., 1., 0., 0., 1., 1., 1., 1., 1., 1.]
+    # TODO use a non normalized distance map
 
     # detect low density foci
     clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],

From 1b5d63c00aca41d86ed0cd644de25f7ade0ee659 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 4 Oct 2019 20:03:43 +0200
Subject: [PATCH 242/264] fix cropped cell extraction

---
 bigfish/stack/postprocess.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index ffd257a8..702263c8 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -191,12 +191,13 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
                 allow_nan=False)
 
     # initialize results
+    # TODO fix mask that do not touch the border
     results = []
     borders = np.zeros(cyt_labelled.shape, dtype=bool)
-    borders[:, 0] = True
-    borders[0, :] = True
-    borders[:, cyt_labelled.shape[1]-1] = True
-    borders[cyt_labelled.shape[0]-1, :] = True
+    borders[:, :3] = True
+    borders[:3, :] = True
+    borders[:, cyt_labelled.shape[1] - 3:] = True
+    borders[cyt_labelled.shape[0] - 3:, :] = True
     cells = regionprops(cyt_labelled)
     for cell in cells:
 

From 58fbbbc15fec7b63491b162cd00715725372eb36 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 7 Oct 2019 12:31:04 +0200
Subject: [PATCH 243/264] misc

---
 bigfish/stack/postprocess.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index 702263c8..699ff9e7 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -191,13 +191,12 @@ def extract_coordinates_image(cyt_labelled, nuc_labelled, spots_out, spots_in,
                 allow_nan=False)
 
     # initialize results
-    # TODO fix mask that do not touch the border
     results = []
     borders = np.zeros(cyt_labelled.shape, dtype=bool)
-    borders[:, :3] = True
-    borders[:3, :] = True
-    borders[:, cyt_labelled.shape[1] - 3:] = True
-    borders[cyt_labelled.shape[0] - 3:, :] = True
+    borders[:, 0] = True
+    borders[0, :] = True
+    borders[:, cyt_labelled.shape[1] - 1] = True
+    borders[cyt_labelled.shape[0] - 1, :] = True
     cells = regionprops(cyt_labelled)
     for cell in cells:
 

From e1e9ff8d3edb6e6cf8806c4c156c3b390c4f0208 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 8 Oct 2019 12:18:32 +0200
Subject: [PATCH 244/264] add new features foci

---
 bigfish/classification/features.py | 110 +++++++++++++++++++++++------
 bigfish/stack/preparation.py       |  17 +++--
 2 files changed, 99 insertions(+), 28 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 9fee3d7b..0e7b91ba 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -56,7 +56,14 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
     mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
 
     # compute distance maps for the cytoplasm and the nucleus
-    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
+    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc,
+                                                           normalized=False)
+
+    # normalize distance maps between 0 and 1
+    distance_cyt_normalized = distance_cyt / distance_cyt.max()
+    distance_cyt_normalized = stack.cast_img_float32(distance_cyt_normalized)
+    distance_nuc_normalized = distance_nuc / distance_nuc.max()
+    distance_nuc_normalized = stack.cast_img_float32(distance_nuc_normalized)
 
     # get rna outside nucleus
     mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
@@ -80,7 +87,9 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
     if features_aubin:
 
         # compute features
-        a = features_distance_aubin(rna_coord, distance_cyt, distance_nuc,
+        a = features_distance_aubin(rna_coord,
+                                    distance_cyt_normalized,
+                                    distance_nuc_normalized,
                                     distance_cyt_centroid,
                                     distance_nuc_centroid)
         b = feature_in_out_nucleus_aubin(rna_coord, mask_nuc)
@@ -88,7 +97,8 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
         c = features_opening_aubin(opening_sizes, rna_coord, mask_cyt)
         radii = [r for r in range(40)]
         d = features_ripley_aubin(radii, rna_coord, cyt_coord, mask_cyt)
-        e = feature_polarization_aubin(distance_cyt, distance_cyt_centroid,
+        e = feature_polarization_aubin(distance_cyt_normalized,
+                                       distance_cyt_centroid,
                                        centroid_rna)
         f = feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna)
 
@@ -103,19 +113,28 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
         aa = features_distance(rna_coord_out, distance_cyt, distance_nuc)
         bb = feature_in_out_nucleus(rna_coord, mask_nuc)
         opening_sizes = [15, 30, 45, 60]
-        cc = features_protrusion(opening_sizes, rna_coord_out, mask_cyt,
+        cc = features_protrusion(opening_sizes,
+                                 rna_coord_out,
+                                 mask_cyt,
                                  mask_nuc)
         radii = [r for r in range(40)]
         dd = features_ripley(radii, rna_coord_out, mask_cyt)
-        ee = feature_polarization(centroid_rna_out, centroid_cyt,
+        ee = feature_polarization(centroid_rna_out,
+                                  centroid_cyt,
                                   distance_cyt_centroid)
-        ff = feature_dispersion(rna_coord_out, distance_rna_out_centroid,
-                                mask_cyt, mask_nuc)
+        ff = feature_dispersion(rna_coord_out,
+                                distance_rna_out_centroid,
+                                mask_cyt,
+                                mask_nuc)
         gg = feature_peripheral_dispersion(rna_coord_out,
                                            distance_cyt_centroid,
-                                           mask_cyt, mask_nuc)
+                                           mask_cyt,
+                                           mask_nuc)
         hh = features_topography(rna_coord, mask_cyt, mask_nuc)
-        ii = features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
+        ii = features_foci(rna_coord_out,
+                           distance_cyt,
+                           distance_nuc,
+                           mask_cyt,
                            mask_nuc)
         jj = feature_area(mask_cyt, mask_nuc)
 
@@ -207,7 +226,14 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
                            "proportion_rna_cyt_0_10",
                            "proportion_rna_cyt_10_20",
                            "proportion_rna_cyt_20_30",
-                           "nb_low_density_foci",
+                           "nb_foci_650nm_5",
+                           "nb_foci_200nm_5",
+                           "nb_foci_350nm_10",
+                           "nb_foci_350nm_3",
+                           "proportion_rna_foci_650nm_5",
+                           "proportion_rna_foci_200nm_5",
+                           "proportion_rna_foci_350nm_10",
+                           "proportion_rna_foci_350nm_3",
                            "index_rna_foci_0_10",
                            "index_rna_foci_10_20",
                            "proportion_rna_foci_0_10",
@@ -759,21 +785,60 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
                   mask_nuc):
     if len(rna_coord_out) == 0:
         return [0., 1., 1., 0., 0., 1., 1., 1., 1., 1., 1.]
-    # TODO use a non normalized distance map
 
-    # detect low density foci
+    # detect foci (radius 650nm, 5 spots minimum)
     clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
                                               resolution_z=300,
                                               resolution_yx=103,
                                               radius=650,
                                               nb_min_spots=5)
     foci = detection.extract_foci(clustered_spots=clustered_spots)
-    nb_low_density_foci = len(foci)
+    nb_foci_650nm_5 = len(foci)
+    nb_spots_in_foci_650nm_5 = np.sum(foci[:, 3])
+    proportion_rna_foci_650nm_5 = nb_spots_in_foci_650nm_5 / len(rna_coord_out)
+
+    # detect foci (radius 200nm, 5 spots minimum)
+    clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
+                                              resolution_z=300,
+                                              resolution_yx=103,
+                                              radius=200,
+                                              nb_min_spots=5)
+    foci = detection.extract_foci(clustered_spots=clustered_spots)
+    nb_foci_200nm_5 = len(foci)
+    nb_spots_in_foci_200nm_5 = np.sum(foci[:, 3])
+    proportion_rna_foci_200nm_5 = nb_spots_in_foci_200nm_5 / len(rna_coord_out)
+
+    # detect foci (radius 350nm, 10 spots minimum)
+    clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
+                                              resolution_z=300,
+                                              resolution_yx=103,
+                                              radius=350,
+                                              nb_min_spots=10)
+    foci = detection.extract_foci(clustered_spots=clustered_spots)
+    nb_foci_350nm_10 = len(foci)
+    nb_spots_in_foci_350nm_10 = np.sum(foci[:, 3])
+    proportion_rna_foci_350nm_10 = (nb_spots_in_foci_350nm_10 /
+                                    len(rna_coord_out))
+
+    # detect foci (radius 350nm, 3 spots minimum)
+    clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
+                                              resolution_z=300,
+                                              resolution_yx=103,
+                                              radius=350,
+                                              nb_min_spots=3)
+    foci = detection.extract_foci(clustered_spots=clustered_spots)
+    nb_foci_350nm_3 = len(foci)
+    nb_spots_in_foci_350nm_3 = np.sum(foci[:, 3])
+    proportion_rna_foci_350nm_3 = nb_spots_in_foci_350nm_3 / len(rna_coord_out)
 
     # get regular foci id
     rna_coord_out_foci = rna_coord_out[rna_coord_out[:, 3] != -1, :]
     if len(rna_coord_out_foci) == 0:
-        return [nb_low_density_foci, 0., 0., 0., 0., 1., 1., 1., 1., 1., 1.]
+        return [nb_foci_650nm_5, nb_foci_200nm_5, nb_foci_350nm_10,
+                nb_foci_350nm_3,
+                proportion_rna_foci_650nm_5, proportion_rna_foci_200nm_5,
+                proportion_rna_foci_350nm_10, proportion_rna_foci_350nm_3,
+                0., 0., 0., 0., 1., 1., 1., 1., 1., 1.]
     l_id_foci = list(set(rna_coord_out_foci[:, 3]))
 
     # count foci neighbors
@@ -795,16 +860,16 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
 
     # compute expected ratio
     # TODO better computation of the area around the foci
-    area_0_10 = np.pi * 10 ** 2
-    area_0_20 = np.pi * 20 ** 2
+    area_0_10 = len(l_id_foci) * np.pi * 10 ** 2
+    area_0_20 = len(l_id_foci) * np.pi * 20 ** 2
     area_10_20 = area_0_20 - area_0_10
     area_cyt_no_nuc = mask_cyt.sum() - mask_nuc.sum()
     expected_rna_foci_0_10 = len(rna_coord_out) * area_0_10 / area_cyt_no_nuc
     expected_rna_foci_10_20 = len(rna_coord_out) * area_10_20 / area_cyt_no_nuc
-    index_rna_foci_0_10 = np.mean(rna_foci_0_10) / expected_rna_foci_0_10
-    index_rna_foci_10_20 = np.mean(rna_foci_10_20) / expected_rna_foci_10_20
-    proportion_rna_foci_0_10 = np.mean(rna_foci_0_10) / len(rna_coord_out)
-    proportion_rna_foci_10_20 = np.mean(rna_foci_10_20) / len(rna_coord_out)
+    index_rna_foci_0_10 = np.sum(rna_foci_0_10) / expected_rna_foci_0_10
+    index_rna_foci_10_20 = np.sum(rna_foci_10_20) / expected_rna_foci_10_20
+    proportion_rna_foci_0_10 = np.sum(rna_foci_0_10) / len(rna_coord_out)
+    proportion_rna_foci_10_20 = np.sum(rna_foci_10_20) / len(rna_coord_out)
 
     # get foci coordinates
     foci_coord = np.array(foci_coord, dtype=np.int64)
@@ -831,7 +896,10 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
     factor = np.std(distance_nuc[distance_nuc > 0])
     foci_std_distance_nuc = np.std(distance_foci_nuc) / factor
 
-    features = [nb_low_density_foci,
+    features = [nb_foci_650nm_5, nb_foci_200nm_5, nb_foci_350nm_10,
+                nb_foci_350nm_3,
+                proportion_rna_foci_650nm_5, proportion_rna_foci_200nm_5,
+                proportion_rna_foci_350nm_10, proportion_rna_foci_350nm_3,
                 index_rna_foci_0_10, index_rna_foci_10_20,
                 proportion_rna_foci_0_10, proportion_rna_foci_10_20,
                 foci_mean_distance_cyt, foci_median_distance_cyt,
diff --git a/bigfish/stack/preparation.py b/bigfish/stack/preparation.py
index 40b040dd..6dd8aa1d 100644
--- a/bigfish/stack/preparation.py
+++ b/bigfish/stack/preparation.py
@@ -435,7 +435,7 @@ def _resize_coord(coord, factor):
     return coord
 
 
-def get_distance_layers(cyt, nuc):
+def get_distance_layers(cyt, nuc, normalized=True):
     """Compute distance layers as input for the model.
 
     Parameters
@@ -444,15 +444,17 @@ def get_distance_layers(cyt, nuc):
         A 2-d binary image with shape (y, x).
     nuc : np.ndarray, np.float32
         A 2-d binary image with shape (y, x).
+    normalized : bool
+        Normalized it between 0 and 1.
 
     Returns
     -------
     distance_cyt : np.ndarray, np.float32
         A 2-d tensor with shape (y, x) showing distance to the cytoplasm
-        border. Normalize between 0 and 1.
+        border. Normalize between 0 and 1 if 'normalized' True.
     distance_nuc : np.ndarray, np.float32
         A 2-d tensor with shape (y, x) showing distance to the nucleus border.
-        Normalize between 0 and 1.
+        Normalize between 0 and 1 if 'normalized' True.
 
     """
     # TODO can return NaN
@@ -464,11 +466,12 @@ def get_distance_layers(cyt, nuc):
     distance_nuc_ = ndi.distance_transform_edt(~mask_nuc)
     distance_nuc = mask_cyt * distance_nuc_
 
-    # cast to np.float32 and normalize it between 0 and 1
-    distance_cyt = cast_img_float32(distance_cyt / distance_cyt.max())
-    distance_nuc = cast_img_float32(distance_nuc / distance_nuc.max())
+    if normalized:
+        # cast to np.float32 and normalize it between 0 and 1
+        distance_cyt = cast_img_float32(distance_cyt / distance_cyt.max())
+        distance_nuc = cast_img_float32(distance_nuc / distance_nuc.max())
 
-    return distance_cyt, distance_nuc
+    return distance_cyt.astype(np.float32), distance_nuc.astype(np.float32)
 
 
 def get_surface_layers(cyt, nuc, cast_float=True):

From e8a936ca0447b1fe36b9de5c3834ab77daeb8691 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 8 Oct 2019 13:41:32 +0200
Subject: [PATCH 245/264] fix bug features

---
 bigfish/classification/features.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 0e7b91ba..309d12aa 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -784,7 +784,8 @@ def features_topography(rna_coord, mask_cyt, mask_nuc):
 def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
                   mask_nuc):
     if len(rna_coord_out) == 0:
-        return [0., 1., 1., 0., 0., 1., 1., 1., 1., 1., 1.]
+        return [0., 0., 0., 0., 0., 0., 0., 0.,
+                0., 0., 0., 0., 1., 1., 1., 1., 1., 1.]
 
     # detect foci (radius 650nm, 5 spots minimum)
     clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],

From 8c0fd10da68ca8534472a694be1ee01d00846e1b Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 16 Oct 2019 16:05:12 +0200
Subject: [PATCH 246/264] major refactoring and improvement of the features

---
 bigfish/classification/features.py | 942 +++++++++++++++--------------
 1 file changed, 481 insertions(+), 461 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 309d12aa..f9dfdc9e 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -48,41 +48,18 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
     """
     features = []
 
-    # get a binary representation of the coordinates
-    cyt, nuc = from_coord_to_matrix(cyt_coord, nuc_coord)
-    rna_coord[:, 1:3] += stack.get_offset_value()
-
-    # fill in masks
-    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
-
-    # compute distance maps for the cytoplasm and the nucleus
-    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc,
-                                                           normalized=False)
-
-    # normalize distance maps between 0 and 1
-    distance_cyt_normalized = distance_cyt / distance_cyt.max()
-    distance_cyt_normalized = stack.cast_img_float32(distance_cyt_normalized)
-    distance_nuc_normalized = distance_nuc / distance_nuc.max()
-    distance_nuc_normalized = stack.cast_img_float32(distance_nuc_normalized)
-
-    # get rna outside nucleus
-    mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
-    rna_coord_out = rna_coord[~mask_rna_in]
-
-    # get centroids
-    centroid_cyt = get_centroid_surface(mask_cyt)
-    centroid_nuc = get_centroid_surface(mask_nuc)
-    centroid_rna = get_centroid_rna(rna_coord)
-    if len(rna_coord_out) == 0:
-        centroid_rna_out = centroid_cyt.copy()
-    else:
-        centroid_rna_out = get_centroid_rna(rna_coord_out)
+    # prepare input data
+    (mask_cyt, mask_nuc, mask_cyt_out,
+     distance_cyt, distance_nuc,
+     distance_cyt_normalized, distance_nuc_normalized,
+     rna_coord_out,
+     centroid_cyt, centroid_nuc,
+     centroid_rna, centroid_rna_out,
+     distance_cyt_centroid, distance_nuc_centroid,
+     distance_rna_out_centroid) = prepare_coordinate_data(cyt_coord,
+                                                          nuc_coord,
+                                                          rna_coord)
 
-    # get centroid distance maps
-    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
-    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
-    distance_rna_out_centroid = get_centroid_distance_map(centroid_rna_out,
-                                                          mask_cyt)
     # Aubin's features
     if features_aubin:
 
@@ -110,36 +87,45 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
     if features_no_aubin:
 
         # compute features
-        aa = features_distance(rna_coord_out, distance_cyt, distance_nuc)
-        bb = feature_in_out_nucleus(rna_coord, mask_nuc)
-        opening_sizes = [15, 30, 45, 60]
-        cc = features_protrusion(opening_sizes,
-                                 rna_coord_out,
+        aa = features_distance(rna_coord_out,
+                               distance_cyt,
+                               distance_nuc,
+                               mask_cyt_out)
+
+        bb = feature_in_out_nucleus(rna_coord,
+                                    mask_nuc)
+
+        cc = features_protrusion(rna_coord_out,
                                  mask_cyt,
-                                 mask_nuc)
-        radii = [r for r in range(40)]
-        dd = features_ripley(radii, rna_coord_out, mask_cyt)
-        ee = feature_polarization(centroid_rna_out,
+                                 mask_nuc,
+                                 mask_cyt_out)
+
+        dd = feature_polarization(centroid_rna_out,
                                   centroid_cyt,
-                                  distance_cyt_centroid)
-        ff = feature_dispersion(rna_coord_out,
+                                  centroid_nuc,
+                                  distance_cyt_centroid,
+                                  distance_nuc_centroid)
+
+        ee = feature_dispersion(rna_coord_out,
                                 distance_rna_out_centroid,
-                                mask_cyt,
-                                mask_nuc)
-        gg = feature_peripheral_dispersion(rna_coord_out,
+                                mask_cyt_out)
+
+        ff = feature_peripheral_dispersion(rna_coord_out,
                                            distance_cyt_centroid,
-                                           mask_cyt,
-                                           mask_nuc)
-        hh = features_topography(rna_coord, mask_cyt, mask_nuc)
-        ii = features_foci(rna_coord_out,
+                                           mask_cyt_out)
+
+        gg = features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
+                                 mask_cyt_out)
+
+        hh = features_foci(rna_coord_out,
                            distance_cyt,
                            distance_nuc,
-                           mask_cyt,
-                           mask_nuc)
-        jj = feature_area(mask_cyt, mask_nuc)
+                           mask_cyt_out)
+
+        ii = feature_area(mask_cyt, mask_nuc, mask_cyt_out)
 
         # gather features
-        features_to_add = aa + [bb] + cc + dd + ee + [ff] + [gg] + hh + ii + jj
+        features_to_add = aa + [bb] + cc + dd + ee + ff + gg + hh + ii
         features += features_to_add
 
     features = np.array(features, dtype=np.float32)
@@ -164,90 +150,112 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
 
     """
     features_name = []
+
     if features_aubin:
-        features_to_add = ["aubin_average_dist_cyt",
-                           "aubin_quantile_5_dist_cyt",
-                           "aubin_quantile_10_dist_cyt",
-                           "aubin_quantile_20_dist_cyt",
-                           "aubin_quantile_50_dist_cyt",
-                           "aubin_average_dist_cyt_centroid",
-                           "aubin_average_dist_nuc",
-                           "aubin_average_dist_nuc_centroid",
-                           "aubin_ratio_in_nuc",
-                           "aubin_diff_opening_15",
-                           "aubin_diff_opening_30",
-                           "aubin_diff_opening_45",
-                           "aubin_diff_opening_60",
-                           "aubin_ripley_max",
-                           "aubin_ripley_max_gradient",
-                           "aubin_ripley_min_gradient",
-                           "aubin_ripley_monotony",
-                           "aubin_ripley_mid_cell",
-                           "aubin_ripley_max_radius",
-                           "aubin_polarization_index",
-                           "aubin_dispersion_index"]
-        features_name += features_to_add
+        # features Aubin
+        features_name += ["aubin_average_dist_cyt",
+                          "aubin_quantile_5_dist_cyt",
+                          "aubin_quantile_10_dist_cyt",
+                          "aubin_quantile_20_dist_cyt",
+                          "aubin_quantile_50_dist_cyt",
+                          "aubin_average_dist_cyt_centroid",
+                          "aubin_average_dist_nuc",
+                          "aubin_average_dist_nuc_centroid",
+                          "aubin_ratio_in_nuc",
+                          "aubin_diff_opening_15",
+                          "aubin_diff_opening_30",
+                          "aubin_diff_opening_45",
+                          "aubin_diff_opening_60",
+                          "aubin_ripley_max",
+                          "aubin_ripley_max_gradient",
+                          "aubin_ripley_min_gradient",
+                          "aubin_ripley_monotony",
+                          "aubin_ripley_mid_cell",
+                          "aubin_ripley_max_radius",
+                          "aubin_polarization_index",
+                          "aubin_dispersion_index"]
 
     if features_no_aubin:
-        features_to_add = ["index_mean_distance_cyt",
-                           "index_median_distance_cyt",
-                           "index_std_distance_cyt",
-                           "index_mean_distance_nuc",
-                           "index_median_distance_nuc",
-                           "index_std_distance_nuc",
-                           "proportion_in_nuc",
-                           "index_rna_opening_15",
-                           "index_rna_opening_30",
-                           "index_rna_opening_45",
-                           "index_rna_opening_60",
-                           "proportion_rna_opening_15",
-                           "proportion_rna_opening_30",
-                           "proportion_rna_opening_45",
-                           "proportion_rna_opening_60",
-                           "ripley_max",
-                           "ripley_min",
-                           "ripley_max_gradient",
-                           "ripley_min_gradient",
-                           "ripley_monotony",
-                           "ripley_max_radius",
-                           "polarization_score",
-                           "polarization_score_normalized",
-                           "dispersion_index",
-                           "peripheral_dispersion_index",
-                           "index_rna_nuc_edge",
-                           "index_rna_nuc_5_15",
-                           "index_rna_nuc_15_25",
-                           "index_rna_cyt_0_10",
-                           "index_rna_cyt_10_20",
-                           "index_rna_cyt_20_30",
-                           "proportion_rna_nuc_edge",
-                           "proportion_rna_nuc_5_15",
-                           "proportion_rna_nuc_15_25",
-                           "proportion_rna_cyt_0_10",
-                           "proportion_rna_cyt_10_20",
-                           "proportion_rna_cyt_20_30",
-                           "nb_foci_650nm_5",
-                           "nb_foci_200nm_5",
-                           "nb_foci_350nm_10",
-                           "nb_foci_350nm_3",
-                           "proportion_rna_foci_650nm_5",
-                           "proportion_rna_foci_200nm_5",
-                           "proportion_rna_foci_350nm_10",
-                           "proportion_rna_foci_350nm_3",
-                           "index_rna_foci_0_10",
-                           "index_rna_foci_10_20",
-                           "proportion_rna_foci_0_10",
-                           "proportion_rna_foci_10_20",
-                           "foci_mean_distance_cyt",
-                           "foci_median_distance_cyt",
-                           "foci_std_distance_cyt",
-                           "foci_mean_distance_nuc",
-                           "foci_median_distance_nuc",
-                           "foci_std_distance_nuc",
-                           "relative_area_nuc",
-                           "area_cyt",
-                           "area_nuc"]
-        features_name += features_to_add
+        # features distance
+        features_name += ["index_mean_distance_cyt",
+                          "log2_index_mean_distance_cyt",
+                          "index_median_distance_cyt",
+                          "log2_index_median_distance_cyt",
+                          "index_std_distance_cyt",
+                          "log2_index_std_distance_cyt",
+                          "index_mean_distance_nuc",
+                          "log2_index_mean_distance_nuc",
+                          "index_median_distance_nuc",
+                          "log2_index_median_distance_nuc",
+                          "index_std_distance_nuc",
+                          "log2_index_std_distance_nuc"]
+
+        # feature intranuclear
+        features_name += ["proportion_in_nuc"]
+
+        # features protrusion
+        features_name += ["index_rna_opening_30",
+                          "log2_index_rna_opening_30",
+                          "proportion_rna_opening_30"]
+
+        # features RDI
+        features_name += ["score_polarization_cyt",
+                          "score_polarization_nuc",
+                          "index_dispersion",
+                          "log2_index_dispersion",
+                          "index_peripheral_dispersion",
+                          "log2_index_peripheral_dispersion"]
+
+        # features topography
+        features_name += ["index_rna_nuc_edge",
+                          "log2_index_rna_nuc_edge",
+                          "proportion_rna_nuc_edge"]
+
+        for a in range(1, 31):
+            features_name += ["nb_rna_nuc_radius_{0}".format(a),
+                              "area_nuc_radius_{0}".format(a),
+                              "index_rna_nuc_radius_{0}".format(a),
+                              "log2_index_rna_nuc_radius_{0}".format(a),
+                              "proportion_rna_nuc_radius_{0}".format(a)]
+
+        for a in range(1, 31):
+            features_name += ["nb_rna_cyt_radius_{0}".format(a),
+                              "area_cyt_radius_{0}".format(a),
+                              "index_rna_cyt_radius_{0}".format(a),
+                              "log2_index_rna_cyt_radius_{0}".format(a),
+                              "proportion_rna_cyt_radius_{0}".format(a)]
+
+        # features foci
+        for a in [50, 150, 250, 350, 450, 550, 650, 750]:
+            for b in [2, 3, 4, 5, 6, 7, 8]:
+                features_name += ["nb_foci_{0}nm_{1}".format(a, b),
+                                  "proportion_rna_foci_{0}nm_{1}".format(a, b)]
+
+        for a in range(1, 21):
+            features_name += ["nb_rna_foci_neighbor_radius_{0}".format(a),
+                              "area_foci_neighbor_radius_{0}".format(a),
+                              "index_rna_foci_radius_{0}".format(a),
+                              "log2_index_rna_foci_radius_{0}".format(a),
+                              "proportion_rna_foci_radius_{0}".format(a)]
+
+        features_name += ["index_foci_mean_distance_cyt",
+                          "log2_index_foci_mean_distance_cyt",
+                          "index_foci_median_distance_cyt",
+                          "log2_index_foci_median_distance_cyt",
+                          "index_foci_std_distance_cyt",
+                          "log2_index_foci_std_distance_cyt",
+                          "index_foci_mean_distance_nuc",
+                          "log2_index_foci_mean_distance_nuc",
+                          "index_foci_median_distance_nuc",
+                          "log2_index_foci_median_distance_nuc",
+                          "index_foci_std_distance_nuc",
+                          "log2_index_foci_std_distance_nuc"]
+
+        # features area
+        features_name += ["proportion_nuc_area",
+                          "area_cyt",
+                          "area_nuc",
+                          "area_cyt_out"]
 
     return features_name
 
@@ -305,6 +313,59 @@ def get_centroid_distance_map(centroid_coordinate, mask_cyt):
     return distance_map
 
 
+def prepare_coordinate_data(cyt_coord, nuc_coord, rna_coord):
+    # get a binary representation of the coordinates
+    cyt, nuc = from_coord_to_matrix(cyt_coord, nuc_coord)
+    rna_coord[:, 1:3] += stack.get_offset_value()
+
+    # fill in masks
+    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
+
+    # get mask cytoplasm outside nucleus
+    mask_cyt_out = mask_cyt.copy()
+    mask_cyt_out[mask_nuc] = False
+
+    # compute distance maps for the cytoplasm and the nucleus
+    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc,
+                                                           normalized=False)
+
+    # normalize distance maps between 0 and 1
+    distance_cyt_normalized = distance_cyt / distance_cyt.max()
+    distance_cyt_normalized = stack.cast_img_float32(distance_cyt_normalized)
+    distance_nuc_normalized = distance_nuc / distance_nuc.max()
+    distance_nuc_normalized = stack.cast_img_float32(distance_nuc_normalized)
+
+    # get rna outside nucleus
+    mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_coord_out = rna_coord[~mask_rna_in]
+
+    # get centroids
+    centroid_cyt = get_centroid_surface(mask_cyt)
+    centroid_nuc = get_centroid_surface(mask_nuc)
+    centroid_rna = get_centroid_rna(rna_coord)
+    if len(rna_coord_out) == 0:
+        centroid_rna_out = centroid_cyt.copy()
+    else:
+        centroid_rna_out = get_centroid_rna(rna_coord_out)
+
+    # get centroid distance maps
+    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
+    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+    distance_rna_out_centroid = get_centroid_distance_map(centroid_rna_out,
+                                                          mask_cyt)
+
+    prepared_inputs = (mask_cyt, mask_nuc, mask_cyt_out,
+                       distance_cyt, distance_nuc,
+                       distance_cyt_normalized, distance_nuc_normalized,
+                       rna_coord_out,
+                       centroid_cyt, centroid_nuc,
+                       centroid_rna, centroid_rna_out,
+                       distance_cyt_centroid, distance_nuc_centroid,
+                       distance_rna_out_centroid)
+
+    return prepared_inputs
+
+
 # ### Aubin's features ###
 
 def features_distance_aubin(rna_coord, distance_cyt, distance_nuc,
@@ -486,34 +547,54 @@ def feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna):
 
 # ### Other features ###
 
-def features_distance(rna_coord_out, distance_cyt, distance_nuc):
+def features_distance(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     rna_coord_out_2d = rna_coord_out[:, 1:3]
-    if len(rna_coord_out_2d) == 0:
-        features = [1., 1., 1., 1., 1., 1.]
+    if len(rna_coord_out_2d) <= 10:
+        features = [1., 0., 1., 0., 1., 0.] * 2
         return features
+    features = []
 
     # compute statistics from distance to cytoplasm
     distance_rna_cyt = distance_cyt[rna_coord_out_2d[:, 0],
                                     rna_coord_out_2d[:, 1]]
-    factor = np.mean(distance_cyt[distance_nuc > 0])
-    mean_distance_cyt = np.mean(distance_rna_cyt) / factor
-    factor = np.median(distance_cyt[distance_nuc > 0])
-    median_distance_cyt = np.median(distance_rna_cyt) / factor
-    factor = np.std(distance_cyt[distance_nuc > 0])
-    std_distance_cyt = np.std(distance_rna_cyt) / factor
+    factor = np.mean(distance_cyt[mask_cyt_out])
+    index_mean_distance_cyt = np.mean(distance_rna_cyt) / factor
+    log2_index_mean_distance_cyt = np.log2(index_mean_distance_cyt + 0.0001)
+    factor = np.median(distance_cyt[mask_cyt_out])
+    index_median_distance_cyt = np.median(distance_rna_cyt) / factor
+    log2_index_median_distance_cyt = np.log2(
+        index_median_distance_cyt + 0.0001)
+    factor = np.std(distance_cyt[mask_cyt_out])
+    index_std_distance_cyt = np.std(distance_rna_cyt) / factor
+    log2_index_std_distance_cyt = np.log2(index_std_distance_cyt + 0.0001)
+
+    features += [np.round(index_mean_distance_cyt, decimals=2),
+                 np.round(log2_index_mean_distance_cyt, decimals=2),
+                 np.round(index_median_distance_cyt, decimals=2),
+                 np.round(log2_index_median_distance_cyt, decimals=2),
+                 np.round(index_std_distance_cyt, decimals=2),
+                 np.round(log2_index_std_distance_cyt, decimals=2)]
 
     # compute statistics from distance to nucleus
     distance_rna_nuc = distance_nuc[rna_coord_out_2d[:, 0],
                                     rna_coord_out_2d[:, 1]]
-    factor = np.mean(distance_nuc[distance_nuc > 0])
-    mean_distance_nuc = np.mean(distance_rna_nuc) / factor
-    factor = np.median(distance_nuc[distance_nuc > 0])
-    median_distance_nuc = np.median(distance_rna_nuc) / factor
-    factor = np.std(distance_nuc[distance_nuc > 0])
-    std_distance_nuc = np.std(distance_rna_nuc) / factor
-
-    features = [mean_distance_cyt, median_distance_cyt, std_distance_cyt,
-                mean_distance_nuc, median_distance_nuc, std_distance_nuc]
+    factor = np.mean(distance_nuc[mask_cyt_out])
+    index_mean_distance_nuc = np.mean(distance_rna_nuc) / factor
+    log2_index_mean_distance_nuc = np.log2(index_mean_distance_nuc + 0.0001)
+    factor = np.median(distance_nuc[mask_cyt_out])
+    index_median_distance_nuc = np.median(distance_rna_nuc) / factor
+    log2_index_median_distance_nuc = np.log2(
+        index_median_distance_nuc + 0.0001)
+    factor = np.std(distance_nuc[mask_cyt_out])
+    index_std_distance_nuc = np.std(distance_rna_nuc) / factor
+    log2_index_std_distance_nuc = np.log2(index_std_distance_nuc + 0.0001)
+
+    features += [np.round(index_mean_distance_nuc, decimals=2),
+                 np.round(log2_index_mean_distance_nuc, decimals=2),
+                 np.round(index_median_distance_nuc, decimals=2),
+                 np.round(log2_index_median_distance_nuc, decimals=2),
+                 np.round(index_std_distance_nuc, decimals=2),
+                 np.round(log2_index_std_distance_nuc, decimals=2)]
 
     return features
 
@@ -523,394 +604,330 @@ def feature_in_out_nucleus(rna_coord, mask_nuc):
     mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
     rna_in = rna_coord[mask_rna_in]
     feature = len(rna_in) / len(rna_coord)
+    feature = np.round(feature, decimals=2)
 
     return feature
 
 
-def features_protrusion(opening_sizes, rna_coord_out, mask_cyt, mask_nuc):
+def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
     # get number of rna outside nucleus and cell area
     nb_rna_out = len(rna_coord_out)
-    area_cell = mask_cyt.sum()
     area_nuc = mask_nuc.sum()
-    area_cell_no_nuc = area_cell - area_nuc
+    area_cyt_out = mask_cyt_out.sum()
 
     # case where we do not detect any rna outside the nucleus
-    if nb_rna_out == 0:
-        features = [0. for _ in opening_sizes] * 2
+    if nb_rna_out <= 10:
+        features = [1., 0., 0.]
         return features
 
     # apply opening operator and count the loss of rna outside the nucleus
-    features_index = []
-    features_proportion = []
-    for size in opening_sizes:
+    features = []
+    for size in [30]:
         s = disk(size, dtype=bool)
         mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
         mask_cyt_transformed[mask_nuc] = True
-        new_area_cell_no_nuc = mask_cyt_transformed.sum() - area_nuc
-        area_diff = area_cell_no_nuc - new_area_cell_no_nuc
-        expected_rna_protrusion = (nb_rna_out * area_diff / area_cell_no_nuc)
-        mask_rna = mask_cyt_transformed[rna_coord_out[:, 1],
-                                        rna_coord_out[:, 2]]
-        rna_after_opening = rna_coord_out[mask_rna]
-        nb_rna_protrusion = nb_rna_out - len(rna_after_opening)
-        index_rna_opening = nb_rna_protrusion / expected_rna_protrusion
-        proportion_rna_opening = nb_rna_protrusion / nb_rna_out
-        features_index.append(index_rna_opening)
-        features_proportion.append(proportion_rna_opening)
-
-    # gather features
-    features = features_index + features_proportion
-
-    return features
-
-
-def features_ripley(radii, rna_coord_out, mask_cyt):
-    # case where we do not detect any rna outside the nucleus
-    if len(rna_coord_out) == 0:
-        features = [0., 0., 0., 0., 0., 0.]
-        return features
-
-    # compute corrected Ripley values for different radii
-    values = _ripley_values_3d(radii, rna_coord_out, mask_cyt)
-
-    # smooth them using moving average
-    smoothed_values = _moving_average(values, n=4)
-
-    # compute the gradients of these values
-    gradients = np.gradient(smoothed_values)
-
-    # compute features
-    index_max = np.argmax(smoothed_values)
-    max_radius = radii[index_max]
-    max_value = smoothed_values.max()
-    min_value = smoothed_values.min()
-    if index_max == 0:
-        max_gradient = gradients[0]
-    else:
-        max_gradient = max(gradients[:index_max])
-    if index_max == len(gradients) - 1:
-        min_gradient = gradients[-1]
-    else:
-        min_gradient = min(gradients[index_max:])
-    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
-
-    features = [max_value, min_value, max_gradient, min_gradient,
-                monotony, max_radius]
+        new_area_cell_out = mask_cyt_transformed.sum() - area_nuc
+        area_protrusion = area_cyt_out - new_area_cell_out
+        if area_protrusion > 0:
+            factor = nb_rna_out * area_protrusion / area_cyt_out
+            mask_rna = mask_cyt_transformed[rna_coord_out[:, 1],
+                                            rna_coord_out[:, 2]]
+            rna_after_opening = rna_coord_out[mask_rna]
+            nb_rna_protrusion = nb_rna_out - len(rna_after_opening)
+            index_rna_opening = nb_rna_protrusion / factor
+            log2_index_rna_opening = np.log2(index_rna_opening + 0.0001)
+            proportion_rna_opening = nb_rna_protrusion / nb_rna_out
+
+            features += [np.round(index_rna_opening, decimals=2),
+                         np.round(log2_index_rna_opening, decimals=2),
+                         np.round(proportion_rna_opening, decimals=2)]
+        else:
+            features += [1., 0., 0.]
 
     return features
 
 
-def _ripley_values_3d(radii, rna_coord_out, mask_cyt):
-    rna_coord_out_3d = rna_coord_out[:, :3]
-
-    # sort rna coordinates
-    sorted_indices = np.lexsort((rna_coord_out_3d[:, 0],
-                                 rna_coord_out_3d[:, 2],
-                                 rna_coord_out_3d[:, 1]))
-    rna_coord_out_3d = rna_coord_out_3d[sorted_indices]
-
-    # compute distance matrix between rna and rna density
-    distances = distance_matrix(rna_coord_out_3d, rna_coord_out_3d, p=2)
-    factor = len(rna_coord_out_3d) ** 2 / mask_cyt.sum()
-
-    # cast cytoplasm mask in np.uint8
-    mask_cyt_8bit = stack.cast_img_uint8(mask_cyt)
-
-    # for each radius, get neighbors and weight
-    values = []
-    for r in radii:
-        mask_distance = distances.copy()
-        mask_distance = mask_distance <= r
-        nb_neighbors = np.sum(mask_distance, axis=0) - 1
-        weights = stack.mean_filter(mask_cyt_8bit,
-                                    kernel_shape="disk",
-                                    kernel_size=r)
-        weights = weights.astype(np.float32) / 255.
-        rna_weights = weights[rna_coord_out_3d[:, 1], rna_coord_out_3d[:, 2]]
-        nb_neighbors_weighted = np.multiply(nb_neighbors, rna_weights)
-        value = nb_neighbors_weighted.sum() / factor
-        values.append(value)
-    values = np.array(values, dtype=np.float32)
-    values_corrected = np.sqrt(values / np.pi) - np.array(radii)
-
-    return values_corrected
-
-
-def feature_polarization(centroid_rna_out, centroid_cyt,
-                         distance_cyt_centroid):
+def feature_polarization(centroid_rna_out, centroid_cyt, centroid_nuc,
+                         distance_cyt_centroid, distance_nuc_centroid):
     centroid_rna_out_2d = centroid_rna_out[1:]
-    # TODO compute the index with a cytoplasm centroid without the nuc area
 
-    # compute polarization index
-    polarization_index = np.linalg.norm(centroid_rna_out_2d - centroid_cyt)
+    # compute polarization index from cytoplasm centroid
+    polarization_distance = np.linalg.norm(centroid_rna_out_2d - centroid_cyt)
     factor = distance_cyt_centroid.max()
-    polarization_index_normalized = polarization_index / factor
-    feature = [polarization_index, polarization_index_normalized]
+    feature_cyt = polarization_distance / factor
+
+    # compute polarization index from nucleus centroid
+    polarization_distance = np.linalg.norm(centroid_rna_out_2d - centroid_nuc)
+    factor = distance_nuc_centroid.max()
+    feature_nuc = polarization_distance / factor
+
+    # gather features
+    feature = [np.round(feature_cyt, decimals=2),
+               np.round(feature_nuc, decimals=2)]
 
     return feature
 
 
-def feature_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt,
-                       mask_nuc):
-    if len(rna_coord_out) == 0:
-        return 1.
+def feature_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
+    if len(rna_coord_out) <= 10:
+        features = [1., 0.]
+        return features
 
     # get number of rna outside nucleus and cell area
-    mask_cyt_no_nuc = mask_cyt.copy()
-    mask_cyt_no_nuc[mask_nuc > 0] = 0.
-    if mask_cyt_no_nuc.sum() == 0:
-        return 1.
+    if mask_cyt_out.sum() == 0:
+        features = [1., 0.]
+        return features
 
     # get coordinates of each pixel of the cell
-    cell_outside_nuc_coord = np.nonzero(mask_cyt_no_nuc)
+    cell_outside_nuc_coord = np.nonzero(mask_cyt_out)
     cell_outside_nuc_coord = np.column_stack(cell_outside_nuc_coord)
 
     # compute dispersion index
     a = distance_rna_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
     b = distance_rna_centroid[cell_outside_nuc_coord[:, 0],
                               cell_outside_nuc_coord[:, 1]]
-    feature = a.mean() / b.mean()
+    index_dispersion = a.mean() / b.mean()
+    log2_index_dispersion = np.log2(index_dispersion + 0.0001)
 
-    return feature
+    features = [np.round(index_dispersion, decimals=2),
+                np.round(log2_index_dispersion, decimals=2)]
+
+    return features
 
 
 def feature_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
-                                  mask_cyt, mask_nuc):
-    if len(rna_coord_out) == 0:
-        return 1.
+                                  mask_cyt_out):
+    if len(rna_coord_out) <= 10:
+        features = [1., 0.]
+        return features
 
     # get number of rna outside nucleus and cell area
-    mask_cyt_no_nuc = mask_cyt.copy()
-    mask_cyt_no_nuc[mask_nuc > 0] = 0.
-    if mask_cyt_no_nuc.sum() == 0:
-        return 1.
+    if mask_cyt_out.sum() == 0:
+        features = [1., 0.]
+        return features
 
     # get coordinates of each pixel of the cell
-    cell_outside_nuc_coord = np.nonzero(mask_cyt_no_nuc)
+    cell_outside_nuc_coord = np.nonzero(mask_cyt_out)
     cell_outside_nuc_coord = np.column_stack(cell_outside_nuc_coord)
 
     # compute dispersion index
     a = distance_cyt_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
     b = distance_cyt_centroid[cell_outside_nuc_coord[:, 0],
                               cell_outside_nuc_coord[:, 1]]
-    feature = a.mean() / b.mean()
+    index_peripheral_dispersion = a.mean() / b.mean()
+    log2_index_peripheral_dispersion = np.log2(
+        index_peripheral_dispersion + 0.0001)
 
-    return feature
+    features = [np.round(index_peripheral_dispersion, decimals=2),
+                np.round(log2_index_peripheral_dispersion, decimals=2)]
 
+    return features
 
-def features_topography(rna_coord, mask_cyt, mask_nuc):
-    mask_cyt_bool = mask_cyt > 0
-    mask_cyt_bool[:, 0] = False
-    mask_cyt_bool[0, :] = False
-    mask_nuc_bool = mask_nuc > 0
-    mask_nuc_bool[:, 0] = False
-    mask_nuc_bool[0, :] = False
 
-    # build nucleus topography
-    distance_map_nuc_out = ndi.distance_transform_edt(~mask_nuc_bool)
-    mask_cyt_without_nuc = mask_cyt_bool.copy()
-    mask_cyt_without_nuc[mask_nuc_bool] = 0
-    distance_map_nuc_in = ndi.distance_transform_edt(~mask_cyt_without_nuc)
+def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
+                        mask_cyt_out):
+    # case where no mRNAs outside the nucleus are detected
+    if len(rna_coord_out) <= 0:
+        features = [1., 0., 0.]
+        features += [0., 0., 1., 0., 0.] * 30
+        features += [0., 0., 1., 0., 0.] * 30
+        return features
+
+    # build a distance map from nucleus border and from cytoplasm membrane
+    distance_map_nuc_out = ndi.distance_transform_edt(~mask_nuc)
+    distance_map_nuc_in = ndi.distance_transform_edt(~mask_cyt_out)
     distance_map_nuc = distance_map_nuc_out + distance_map_nuc_in
-    distance_map_nuc[~mask_cyt_bool] = 0
-    distance_map_nuc_edge = distance_map_nuc < 5
-    distance_map_nuc_edge[~mask_cyt_bool] = False
-    distance_map_nuc_5_15 = distance_map_nuc < 15
-    distance_map_nuc_5_15[mask_nuc_bool] = False
-    distance_map_nuc_5_15[distance_map_nuc_edge] = False
-    distance_map_nuc_5_15[~mask_cyt_bool] = False
-    distance_map_nuc_15_25 = distance_map_nuc < 25
-    distance_map_nuc_15_25[mask_nuc_bool] = False
-    distance_map_nuc_15_25[distance_map_nuc_edge] = False
-    distance_map_nuc_15_25[distance_map_nuc_5_15] = False
-    distance_map_nuc_15_25[~mask_cyt_bool] = False
+    distance_map_nuc[~mask_cyt] = 0
+    distance_map_cyt = ndi.distance_transform_edt(mask_cyt)
 
-    # build cytoplasm topography
-    distance_map_cyt = ndi.distance_transform_edt(mask_cyt_bool)
-    distance_map_cyt_0_10 = distance_map_cyt < 10
-    distance_map_cyt_0_10[~mask_cyt_bool] = False
-    distance_map_cyt_10_20 = distance_map_cyt < 20
-    distance_map_cyt_10_20[~mask_cyt_bool] = False
-    distance_map_cyt_10_20[distance_map_cyt_0_10] = False
-    distance_map_cyt_20_30 = distance_map_cyt < 30
-    distance_map_cyt_20_30[~mask_cyt_bool] = False
-    distance_map_cyt_20_30[distance_map_cyt_0_10] = False
-    distance_map_cyt_20_30[distance_map_cyt_10_20] = False
-
-    # count rna for each topographic level
-    cell_area = mask_cyt_bool.sum()
+    # initialization
+    features = []
+    cell_area = mask_cyt.sum()
+    nb_rna_out = len(rna_coord_out)
     nb_rna = len(rna_coord)
 
-    factor = nb_rna * max(distance_map_nuc_edge.sum(), 1) / cell_area
-    mask_rna = distance_map_nuc_edge[rna_coord[:, 1], rna_coord[:, 2]]
-    index_rna_nuc_edge = len(rna_coord[mask_rna]) / factor
-    proportion_rna_nuc_edge = len(rna_coord[mask_rna]) / nb_rna
-
-    factor = nb_rna * max(distance_map_nuc_5_15.sum(), 1) / cell_area
-    mask_rna = distance_map_nuc_5_15[rna_coord[:, 1], rna_coord[:, 2]]
-    index_rna_nuc_5_15 = len(rna_coord[mask_rna]) / factor
-    proportion_rna_nuc_5_15 = len(rna_coord[mask_rna]) / nb_rna
-
-    factor = nb_rna * max(distance_map_nuc_15_25.sum(), 1) / cell_area
-    mask_rna = distance_map_nuc_15_25[rna_coord[:, 1], rna_coord[:, 2]]
-    index_rna_nuc_15_25 = len(rna_coord[mask_rna]) / factor
-    proportion_rna_nuc_15_25 = len(rna_coord[mask_rna]) / nb_rna
-
-    factor = nb_rna * max(distance_map_cyt_0_10.sum(), 1) / cell_area
-    mask_rna = distance_map_cyt_0_10[rna_coord[:, 1], rna_coord[:, 2]]
-    index_rna_cyt_0_10 = len(rna_coord[mask_rna]) / factor
-    proportion_rna_cyt_0_10 = len(rna_coord[mask_rna]) / nb_rna
-
-    factor = nb_rna * max(distance_map_cyt_10_20.sum(), 1) / cell_area
-    mask_rna = distance_map_cyt_10_20[rna_coord[:, 1], rna_coord[:, 2]]
-    index_rna_cyt_10_20 = len(rna_coord[mask_rna]) / factor
-    proportion_rna_cyt_10_20 = len(rna_coord[mask_rna]) / nb_rna
-
-    factor = nb_rna * max(distance_map_cyt_20_30.sum(), 1) / cell_area
-    mask_rna = distance_map_cyt_20_30[rna_coord[:, 1], rna_coord[:, 2]]
-    index_rna_cyt_20_30 = len(rna_coord[mask_rna]) / factor
-    proportion_rna_cyt_20_30 = len(rna_coord[mask_rna]) / nb_rna
-
-    features = [index_rna_nuc_edge, index_rna_nuc_5_15,
-                index_rna_nuc_15_25, index_rna_cyt_0_10,
-                index_rna_cyt_10_20, index_rna_cyt_20_30,
-                proportion_rna_nuc_edge, proportion_rna_nuc_5_15,
-                proportion_rna_nuc_15_25, proportion_rna_cyt_0_10,
-                proportion_rna_cyt_10_20, proportion_rna_cyt_20_30]
+    # build nucleus edge topography
+    mask_nuc_edge = distance_map_nuc < 5
+    mask_nuc_edge[~mask_cyt] = False
+    factor = nb_rna * max(mask_nuc_edge.sum(), 1) / cell_area
+    mask_rna = mask_nuc_edge[rna_coord[:, 1], rna_coord[:, 2]]
+    nb_rna_nuc_edge = len(rna_coord[mask_rna])
+    index_rna_nuc_edge = nb_rna_nuc_edge / factor
+    log2_index_rna_nuc_edge = np.log2(index_rna_nuc_edge + 0.0001)
+    proportion_rna_nuc_edge = nb_rna_nuc_edge / nb_rna
+
+    features += [np.round(index_rna_nuc_edge, decimals=2),
+                 np.round(log2_index_rna_nuc_edge, decimals=2),
+                 np.round(proportion_rna_nuc_edge, decimals=2)]
+
+    # build nucleus topography
+    for radius in range(1, 31):
+        mask_nuc_radius = distance_map_nuc < radius
+        mask_nuc_radius[~mask_cyt] = False
+        mask_nuc_radius[mask_nuc] = False
+        factor = nb_rna_out * max(mask_nuc_radius.sum(), 1) / cell_area
+        mask_rna = mask_nuc_radius[rna_coord_out[:, 1], rna_coord_out[:, 2]]
+        nb_rna_nuc_radius = len(rna_coord_out[mask_rna])
+        index_rna_nuc = nb_rna_nuc_radius / factor
+        log2_index_rna_nuc = np.log2(index_rna_nuc + 0.0001)
+        proportion_rna_nuc = nb_rna_nuc_radius / nb_rna_out
+
+        features += [np.round(nb_rna_nuc_radius, decimals=2),
+                     np.round(mask_nuc_radius.sum(), decimals=2),
+                     np.round(index_rna_nuc, decimals=2),
+                     np.round(log2_index_rna_nuc, decimals=2),
+                     np.round(proportion_rna_nuc, decimals=2)]
+
+    # build cytoplasm topography
+    for radius in range(1, 31):
+        mask_cyt_radius = distance_map_cyt < radius
+        mask_cyt_radius[~mask_cyt] = False
+        mask_cyt_radius[mask_nuc] = False
+        factor = nb_rna_out * max(mask_cyt_radius.sum(), 1) / cell_area
+        mask_rna = mask_cyt_radius[rna_coord_out[:, 1], rna_coord_out[:, 2]]
+        nb_rna_cyt_radius = len(rna_coord_out[mask_rna])
+        index_rna_cyt = nb_rna_cyt_radius / factor
+        log2_index_rna_cyt = np.log2(index_rna_cyt + 0.0001)
+        proportion_rna_cyt = nb_rna_cyt_radius / nb_rna_out
+
+        features += [np.round(nb_rna_cyt_radius, decimals=2),
+                     np.round(mask_cyt_radius.sum(), decimals=2),
+                     np.round(index_rna_cyt, decimals=2),
+                     np.round(log2_index_rna_cyt, decimals=2),
+                     np.round(proportion_rna_cyt, decimals=2)]
 
     return features
 
 
-def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt,
-                  mask_nuc):
+def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
+    # case where no mRNAs outside the nucleus are detected
     if len(rna_coord_out) == 0:
-        return [0., 0., 0., 0., 0., 0., 0., 0.,
-                0., 0., 0., 0., 1., 1., 1., 1., 1., 1.]
-
-    # detect foci (radius 650nm, 5 spots minimum)
-    clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
-                                              resolution_z=300,
-                                              resolution_yx=103,
-                                              radius=650,
-                                              nb_min_spots=5)
-    foci = detection.extract_foci(clustered_spots=clustered_spots)
-    nb_foci_650nm_5 = len(foci)
-    nb_spots_in_foci_650nm_5 = np.sum(foci[:, 3])
-    proportion_rna_foci_650nm_5 = nb_spots_in_foci_650nm_5 / len(rna_coord_out)
-
-    # detect foci (radius 200nm, 5 spots minimum)
-    clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
-                                              resolution_z=300,
-                                              resolution_yx=103,
-                                              radius=200,
-                                              nb_min_spots=5)
-    foci = detection.extract_foci(clustered_spots=clustered_spots)
-    nb_foci_200nm_5 = len(foci)
-    nb_spots_in_foci_200nm_5 = np.sum(foci[:, 3])
-    proportion_rna_foci_200nm_5 = nb_spots_in_foci_200nm_5 / len(rna_coord_out)
-
-    # detect foci (radius 350nm, 10 spots minimum)
-    clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
-                                              resolution_z=300,
-                                              resolution_yx=103,
-                                              radius=350,
-                                              nb_min_spots=10)
-    foci = detection.extract_foci(clustered_spots=clustered_spots)
-    nb_foci_350nm_10 = len(foci)
-    nb_spots_in_foci_350nm_10 = np.sum(foci[:, 3])
-    proportion_rna_foci_350nm_10 = (nb_spots_in_foci_350nm_10 /
-                                    len(rna_coord_out))
-
-    # detect foci (radius 350nm, 3 spots minimum)
-    clustered_spots = detection.cluster_spots(spots=rna_coord_out[:, :3],
-                                              resolution_z=300,
-                                              resolution_yx=103,
-                                              radius=350,
-                                              nb_min_spots=3)
-    foci = detection.extract_foci(clustered_spots=clustered_spots)
-    nb_foci_350nm_3 = len(foci)
-    nb_spots_in_foci_350nm_3 = np.sum(foci[:, 3])
-    proportion_rna_foci_350nm_3 = nb_spots_in_foci_350nm_3 / len(rna_coord_out)
+        features = [0.] * 56 * 2
+        features += [0., 0., 1., 0., 0.] * 20
+        features += [1., 0., 1., 0., 1., 0.]
+        features += [1., 0., 1., 0., 1., 0.]
+        return features
 
-    # get regular foci id
+    features = []
+    for foci_radius in [50, 150, 250, 350, 450, 550, 650, 750]:
+        for min_foci_rna in [2, 3, 4, 5, 6, 7, 8]:
+            clustered_spots = detection.cluster_spots(
+                spots=rna_coord_out[:, :3],
+                resolution_z=300,
+                resolution_yx=103,
+                radius=foci_radius,
+                nb_min_spots=min_foci_rna)
+            foci = detection.extract_foci(clustered_spots=clustered_spots)
+            nb_foci = len(foci)
+            nb_spots_in_foci = np.sum(foci[:, 3])
+            proportion_rna_foci = nb_spots_in_foci / len(rna_coord_out)
+
+            features += [np.round(nb_foci, decimals=2),
+                         np.round(proportion_rna_foci, decimals=2)]
+
+    # case where no default foci are detected
     rna_coord_out_foci = rna_coord_out[rna_coord_out[:, 3] != -1, :]
     if len(rna_coord_out_foci) == 0:
-        return [nb_foci_650nm_5, nb_foci_200nm_5, nb_foci_350nm_10,
-                nb_foci_350nm_3,
-                proportion_rna_foci_650nm_5, proportion_rna_foci_200nm_5,
-                proportion_rna_foci_350nm_10, proportion_rna_foci_350nm_3,
-                0., 0., 0., 0., 1., 1., 1., 1., 1., 1.]
+        features += [0., 0., 1., 0., 0.] * 20
+        features += [1., 0., 1., 0., 1., 0.]
+        features += [1., 0., 1., 0., 1., 0.]
+        return features
+
+    # get regular foci id
     l_id_foci = list(set(rna_coord_out_foci[:, 3]))
 
-    # count foci neighbors
-    rna_foci_0_10 = []
-    rna_foci_10_20 = []
-    foci_coord = []
-    for id_foci in l_id_foci:
-        rna_foci = rna_coord_out_foci[rna_coord_out_foci[:, 3] == id_foci, :3]
-        foci = np.mean(rna_foci, axis=0).reshape(1, 3)
-        foci_coord.append(foci)
-        distance = distance_matrix(rna_coord_out_foci[:, :3], foci)
-        mask_distance_0_10 = distance < 10
-        mask_distance_10_20 = distance < 20
-        mask_distance_10_20 &= ~mask_distance_0_10
-        nb_rna_foci_0_10 = mask_distance_0_10.sum()
-        nb_rna_foci_10_20 = mask_distance_10_20.sum()
-        rna_foci_0_10.append(nb_rna_foci_0_10)
-        rna_foci_10_20.append(nb_rna_foci_10_20)
-
-    # compute expected ratio
-    # TODO better computation of the area around the foci
-    area_0_10 = len(l_id_foci) * np.pi * 10 ** 2
-    area_0_20 = len(l_id_foci) * np.pi * 20 ** 2
-    area_10_20 = area_0_20 - area_0_10
-    area_cyt_no_nuc = mask_cyt.sum() - mask_nuc.sum()
-    expected_rna_foci_0_10 = len(rna_coord_out) * area_0_10 / area_cyt_no_nuc
-    expected_rna_foci_10_20 = len(rna_coord_out) * area_10_20 / area_cyt_no_nuc
-    index_rna_foci_0_10 = np.sum(rna_foci_0_10) / expected_rna_foci_0_10
-    index_rna_foci_10_20 = np.sum(rna_foci_10_20) / expected_rna_foci_10_20
-    proportion_rna_foci_0_10 = np.sum(rna_foci_0_10) / len(rna_coord_out)
-    proportion_rna_foci_10_20 = np.sum(rna_foci_10_20) / len(rna_coord_out)
+    # count foci neighbors for different radius
+    nb_rna_out = len(rna_coord_out)
+    cell_out_area = mask_cyt_out.sum()
+    for radius in range(1, 21):
+        s = disk(radius).astype(bool)
+        mask_foci_neighbor = np.zeros_like(mask_cyt_out)
+        for i in l_id_foci:
+            rna_foci_i = rna_coord_out_foci[rna_coord_out_foci[:, 3] == i, :3]
+            foci = np.mean(rna_foci_i, axis=0)
+            foci = np.round(foci).astype(np.int64)
+            row, col = foci[1], foci[2]
+            mask_neighbor = np.zeros_like(mask_cyt_out)
+            min_row = max(row-radius, 0)
+            max_row = min(row+radius+1, mask_neighbor.shape[0])
+            min_col = max(col-radius, 0)
+            max_col = min(col+radius+1, mask_neighbor.shape[1])
+            mask_neighbor[min_row:max_row, min_col:max_col] = s
+            mask_foci_neighbor |= mask_cyt_out & mask_neighbor
+        mask_rna = mask_foci_neighbor[rna_coord_out[:, 1], rna_coord_out[:, 2]]
+        nb_rna_neighbor = len(rna_coord_out[mask_rna])
+        foci_neighbor_area = mask_foci_neighbor.sum()
+        factor = nb_rna_out * max(foci_neighbor_area, 1) / cell_out_area
+        index_rna_foci = nb_rna_neighbor / factor
+        log2_index_rna_foci = np.log2(index_rna_foci + 0.0001)
+        proportion_rna_foci = nb_rna_neighbor / nb_rna_out
+
+        features += [np.round(nb_rna_neighbor, decimals=2),
+                     np.round(foci_neighbor_area, decimals=2),
+                     np.round(index_rna_foci, decimals=2),
+                     np.round(log2_index_rna_foci, decimals=2),
+                     np.round(proportion_rna_foci, decimals=2)]
 
     # get foci coordinates
+    foci_coord = []
+    for i in l_id_foci:
+        rna_foci_i = rna_coord_out_foci[rna_coord_out_foci[:, 3] == i, :3]
+        foci = np.mean(rna_foci_i, axis=0)
+        foci = np.round(foci).astype(np.int64)
+        foci_coord.append(foci.reshape(1, 3))
     foci_coord = np.array(foci_coord, dtype=np.int64)
     foci_coord = np.squeeze(foci_coord, axis=1)
     foci_coord_2d = foci_coord[:, 1:3]
 
     # compute statistics from distance to cytoplasm
-    distance_foci_cyt = distance_cyt[foci_coord_2d[:, 0],
-                                     foci_coord_2d[:, 1]]
-    factor = np.mean(distance_cyt[distance_nuc > 0])
-    foci_mean_distance_cyt = np.mean(distance_foci_cyt) / factor
-    factor = np.median(distance_cyt[distance_nuc > 0])
-    foci_median_distance_cyt = np.median(distance_foci_cyt) / factor
-    factor = np.std(distance_cyt[distance_nuc > 0])
-    foci_std_distance_cyt = np.std(distance_foci_cyt) / factor
+    distance_foci_cyt = distance_cyt[foci_coord_2d[:, 0], foci_coord_2d[:, 1]]
+    factor = np.mean(distance_cyt[mask_cyt_out])
+    index_foci_mean_distance_cyt = np.mean(distance_foci_cyt) / factor
+    log2_index_foci_mean_distance_cyt = np.log2(
+        index_foci_mean_distance_cyt + 0.0001)
+    factor = np.median(distance_cyt[mask_cyt_out])
+    index_foci_median_distance_cyt = np.median(distance_foci_cyt) / factor
+    log2_index_foci_median_distance_cyt = np.log2(
+        index_foci_median_distance_cyt + 0.0001)
+    factor = np.std(distance_cyt[mask_cyt_out])
+    index_foci_std_distance_cyt = np.std(distance_foci_cyt) / factor
+    log2_index_foci_std_distance_cyt = np.log2(
+        index_foci_std_distance_cyt + 0.0001)
+
+    features += [np.round(index_foci_mean_distance_cyt, decimals=2),
+                 np.round(log2_index_foci_mean_distance_cyt, decimals=2),
+                 np.round(index_foci_median_distance_cyt, decimals=2),
+                 np.round(log2_index_foci_median_distance_cyt, decimals=2),
+                 np.round(index_foci_std_distance_cyt, decimals=2),
+                 np.round(log2_index_foci_std_distance_cyt, decimals=2)]
 
     # compute statistics from distance to nucleus
     distance_foci_nuc = distance_nuc[foci_coord_2d[:, 0],
                                      foci_coord_2d[:, 1]]
-    factor = np.mean(distance_nuc[distance_nuc > 0])
-    foci_mean_distance_nuc = np.mean(distance_foci_nuc) / factor
-    factor = np.median(distance_nuc[distance_nuc > 0])
-    foci_median_distance_nuc = np.median(distance_foci_nuc) / factor
-    factor = np.std(distance_nuc[distance_nuc > 0])
-    foci_std_distance_nuc = np.std(distance_foci_nuc) / factor
-
-    features = [nb_foci_650nm_5, nb_foci_200nm_5, nb_foci_350nm_10,
-                nb_foci_350nm_3,
-                proportion_rna_foci_650nm_5, proportion_rna_foci_200nm_5,
-                proportion_rna_foci_350nm_10, proportion_rna_foci_350nm_3,
-                index_rna_foci_0_10, index_rna_foci_10_20,
-                proportion_rna_foci_0_10, proportion_rna_foci_10_20,
-                foci_mean_distance_cyt, foci_median_distance_cyt,
-                foci_std_distance_cyt, foci_mean_distance_nuc,
-                foci_median_distance_nuc, foci_std_distance_nuc]
+    factor = np.mean(distance_nuc[mask_cyt_out])
+    index_foci_mean_distance_nuc = np.mean(distance_foci_nuc) / factor
+    log2_index_foci_mean_distance_nuc = np.log2(
+        index_foci_mean_distance_nuc + 0.0001)
+    factor = np.median(distance_nuc[mask_cyt_out])
+    index_foci_median_distance_nuc = np.median(distance_foci_nuc) / factor
+    log2_index_foci_median_distance_nuc = np.log2(
+        index_foci_median_distance_nuc + 0.0001)
+    factor = np.std(distance_nuc[mask_cyt_out])
+    index_foci_std_distance_nuc = np.std(distance_foci_nuc) / factor
+    log2_index_foci_std_distance_nuc = np.log2(
+        index_foci_std_distance_nuc + 0.0001)
+
+    features += [np.round(index_foci_mean_distance_nuc, decimals=2),
+                 np.round(log2_index_foci_mean_distance_nuc, decimals=2),
+                 np.round(index_foci_median_distance_nuc, decimals=2),
+                 np.round(log2_index_foci_median_distance_nuc, decimals=2),
+                 np.round(index_foci_std_distance_nuc, decimals=2),
+                 np.round(log2_index_foci_std_distance_nuc, decimals=2)]
 
     return features
 
 
-def feature_area(mask_cyt, mask_nuc):
+def feature_area(mask_cyt, mask_nuc, mask_cyt_out):
     # get area of the cytoplasm and the nucleus
     area_cyt = mask_cyt.sum()
     area_nuc = mask_nuc.sum()
@@ -918,7 +935,10 @@ def feature_area(mask_cyt, mask_nuc):
     # compute relative area of the nucleus
     relative_area_nuc = area_nuc / area_cyt
 
+    # compute area of the cytoplasm outside nucleus
+    area_cyt_out = mask_cyt_out.sum()
+
     # return features
-    features = [relative_area_nuc, area_cyt, area_nuc]
+    features = [relative_area_nuc, area_cyt, area_nuc, area_cyt_out]
 
     return features

From a113037d59b54e09f0c71c97a11cb31e07c3eac8 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 16 Oct 2019 20:11:27 +0200
Subject: [PATCH 247/264] major refactoring and improvement of the features #2

---
 bigfish/classification/features.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index f9dfdc9e..16f4cd86 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -848,11 +848,16 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
             foci = np.round(foci).astype(np.int64)
             row, col = foci[1], foci[2]
             mask_neighbor = np.zeros_like(mask_cyt_out)
-            min_row = max(row-radius, 0)
-            max_row = min(row+radius+1, mask_neighbor.shape[0])
-            min_col = max(col-radius, 0)
-            max_col = min(col+radius+1, mask_neighbor.shape[1])
-            mask_neighbor[min_row:max_row, min_col:max_col] = s
+            min_row = max(row - radius, 0)
+            min_row_s = min_row - (row - radius)
+            max_row = min(row + radius + 1, mask_neighbor.shape[0])
+            max_row_s = s.shape[0] - ((row + radius + 1) - max_row)
+            min_col = max(col - radius, 0)
+            min_col_s = min_col - (col - radius)
+            max_col = min(col + radius + 1, mask_neighbor.shape[1])
+            max_col_s = s.shape[1] - ((col + radius + 1) - max_col)
+            new_s = s[min_row_s:max_row_s, min_col_s:max_col_s]
+            mask_neighbor[min_row:max_row, min_col:max_col] = new_s
             mask_foci_neighbor |= mask_cyt_out & mask_neighbor
         mask_rna = mask_foci_neighbor[rna_coord_out[:, 1], rna_coord_out[:, 2]]
         nb_rna_neighbor = len(rna_coord_out[mask_rna])

From 618d0799c13700c66409d88aae913f04b85a9187 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Wed, 16 Oct 2019 20:42:31 +0200
Subject: [PATCH 248/264] major refactoring and improvement of the features #3

---
 bigfish/classification/features.py | 125 ++++++++++++++++++++---------
 1 file changed, 89 insertions(+), 36 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 16f4cd86..e58322ba 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -22,8 +22,15 @@
 # TODO check centroid cyt has a yx format
 
 
-def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
-                 features_no_aubin=False):
+def get_features(cyt_coord, nuc_coord, rna_coord,
+                 compute_aubin=False,
+                 compute_distance=True,
+                 compute_intranuclear=True,
+                 compute_protrusion=True,
+                 compute_dispersion=True,
+                 compute_topography=True,
+                 compute_foci=True,
+                 compute_area=True):
     """Compute cell features.
 
     Parameters
@@ -35,10 +42,23 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
     rna_coord : np.ndarray, np.int64
         Coordinate zyx of the detected rna, plus the index of a potential foci.
         Shape (nb_rna, 4).
-    features_aubin : bool
+    compute_aubin : bool
         Compute features from Aubin paper.
-    features_no_aubin : bool
-        Compute features that are not present in Aubin paper.
+    compute_distance : bool
+        Compute features related to distances from nucleus or cytoplasmic
+        membrane.
+    compute_intranuclear : bool
+        Compute features related to intranuclear pattern.
+    compute_protrusion : bool
+        Compute features related to protrusion pattern.
+    compute_dispersion : bool
+        Compute features to quantify mRNAs dispersion within the cell.
+    compute_topography : bool
+        Compute topographic features of the cell.
+    compute_foci : bool
+        Compute features related to foci pattern.
+    compute_area : bool
+        Compute features related to area of the cell.
 
     Returns
     -------
@@ -60,10 +80,8 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
                                                           nuc_coord,
                                                           rna_coord)
 
-    # Aubin's features
-    if features_aubin:
-
-        # compute features
+    # features from Aubin's paper
+    if compute_aubin:
         a = features_distance_aubin(rna_coord,
                                     distance_cyt_normalized,
                                     distance_nuc_normalized,
@@ -79,69 +97,106 @@ def get_features(cyt_coord, nuc_coord, rna_coord, features_aubin=True,
                                        centroid_rna)
         f = feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna)
 
-        # gather features
-        features_to_add = a + [b] + c + d + [e] + [f]
-        features += features_to_add
-
-    # other features
-    if features_no_aubin:
+        features += a + [b] + c + d + [e] + [f]
 
-        # compute features
+    # distances related features
+    if compute_distance:
         aa = features_distance(rna_coord_out,
                                distance_cyt,
                                distance_nuc,
                                mask_cyt_out)
 
+        features += aa
+
+    # intranuclear related features
+    if compute_intranuclear:
         bb = feature_in_out_nucleus(rna_coord,
                                     mask_nuc)
 
+        features += [bb]
+
+    # intranuclear related features
+    if compute_protrusion:
         cc = features_protrusion(rna_coord_out,
                                  mask_cyt,
                                  mask_nuc,
                                  mask_cyt_out)
 
+        features += cc
+
+    # dispersion measures
+    if compute_dispersion:
         dd = feature_polarization(centroid_rna_out,
                                   centroid_cyt,
                                   centroid_nuc,
                                   distance_cyt_centroid,
                                   distance_nuc_centroid)
-
         ee = feature_dispersion(rna_coord_out,
                                 distance_rna_out_centroid,
                                 mask_cyt_out)
-
         ff = feature_peripheral_dispersion(rna_coord_out,
                                            distance_cyt_centroid,
                                            mask_cyt_out)
 
+        features += dd + ee + ff
+
+    # topographic features
+    if compute_topography:
         gg = features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
                                  mask_cyt_out)
 
+        features += gg
+
+    # foci related features
+    if compute_foci:
         hh = features_foci(rna_coord_out,
                            distance_cyt,
                            distance_nuc,
                            mask_cyt_out)
 
+        features += hh
+
+    # area related features
+    if compute_area:
         ii = feature_area(mask_cyt, mask_nuc, mask_cyt_out)
 
-        # gather features
-        features_to_add = aa + [bb] + cc + dd + ee + ff + gg + hh + ii
-        features += features_to_add
+        features += ii
 
     features = np.array(features, dtype=np.float32)
 
     return features
 
 
-def get_features_name(features_aubin=True, features_no_aubin=False):
+def get_features_name(names_features_aubin=False,
+                      names_features_distance=True,
+                      names_features_intranuclear=True,
+                      names_features_protrusion=True,
+                      names_features_dispersion=True,
+                      names_features_topography=True,
+                      names_features_foci=True,
+                      names_features_area=True):
     """Return the current list of features names.
 
     Parameters
     ----------
-    features_aubin : bool
-        Compute features from Aubin paper.
-    features_no_aubin : bool
-        Compute features that are not present in Aubin paper.
+    names_features_aubin : bool
+        Return names of features from Aubin paper.
+    names_features_distance : bool
+        Return names of features related to distances from nucleus or
+        cytoplasmic membrane.
+    names_features_intranuclear : bool
+        Return names of features related to intranuclear pattern.
+    names_features_protrusion : bool
+        Return names of features related to protrusion pattern.
+    names_features_dispersion : bool
+        Return names of features used to quantify mRNAs dispersion within the
+        cell.
+    names_features_topography : bool
+        Return names of topographic features of the cell.
+    names_features_foci : bool
+        Return names of features related to foci pattern.
+    names_features_area : bool
+        Return names of features related to area of the cell.
 
     Returns
     -------
@@ -151,8 +206,7 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
     """
     features_name = []
 
-    if features_aubin:
-        # features Aubin
+    if names_features_aubin:
         features_name += ["aubin_average_dist_cyt",
                           "aubin_quantile_5_dist_cyt",
                           "aubin_quantile_10_dist_cyt",
@@ -175,8 +229,7 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
                           "aubin_polarization_index",
                           "aubin_dispersion_index"]
 
-    if features_no_aubin:
-        # features distance
+    if names_features_distance:
         features_name += ["index_mean_distance_cyt",
                           "log2_index_mean_distance_cyt",
                           "index_median_distance_cyt",
@@ -190,15 +243,15 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
                           "index_std_distance_nuc",
                           "log2_index_std_distance_nuc"]
 
-        # feature intranuclear
+    if names_features_intranuclear:
         features_name += ["proportion_in_nuc"]
 
-        # features protrusion
+    if names_features_protrusion:
         features_name += ["index_rna_opening_30",
                           "log2_index_rna_opening_30",
                           "proportion_rna_opening_30"]
 
-        # features RDI
+    if names_features_dispersion:
         features_name += ["score_polarization_cyt",
                           "score_polarization_nuc",
                           "index_dispersion",
@@ -206,7 +259,7 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
                           "index_peripheral_dispersion",
                           "log2_index_peripheral_dispersion"]
 
-        # features topography
+    if names_features_topography:
         features_name += ["index_rna_nuc_edge",
                           "log2_index_rna_nuc_edge",
                           "proportion_rna_nuc_edge"]
@@ -225,7 +278,7 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
                               "log2_index_rna_cyt_radius_{0}".format(a),
                               "proportion_rna_cyt_radius_{0}".format(a)]
 
-        # features foci
+    if names_features_foci:
         for a in [50, 150, 250, 350, 450, 550, 650, 750]:
             for b in [2, 3, 4, 5, 6, 7, 8]:
                 features_name += ["nb_foci_{0}nm_{1}".format(a, b),
@@ -251,7 +304,7 @@ def get_features_name(features_aubin=True, features_no_aubin=False):
                           "index_foci_std_distance_nuc",
                           "log2_index_foci_std_distance_nuc"]
 
-        # features area
+    if names_features_area:
         features_name += ["proportion_nuc_area",
                           "area_cyt",
                           "area_nuc",

From 06b5d2ea5200f8938c8225ba91e5c06296203708 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 18 Oct 2019 10:14:52 +0200
Subject: [PATCH 249/264] major refactoring and improvement of the features #4

---
 bigfish/classification/features.py | 75 ++++++++++++++++--------------
 1 file changed, 41 insertions(+), 34 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index e58322ba..3d94a891 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -19,7 +19,8 @@
 
 # TODO add sanity check functions
 # TODO add documentation
-# TODO check centroid cyt has a yx format
+# TODO allow to return intermediate results (distance map, etc.)
+# TODO round float results
 
 
 def get_features(cyt_coord, nuc_coord, rna_coord,
@@ -110,10 +111,10 @@ def get_features(cyt_coord, nuc_coord, rna_coord,
 
     # intranuclear related features
     if compute_intranuclear:
-        bb = feature_in_out_nucleus(rna_coord,
-                                    mask_nuc)
+        bb = features_in_out_nucleus(rna_coord,
+                                     mask_nuc)
 
-        features += [bb]
+        features += bb
 
     # intranuclear related features
     if compute_protrusion:
@@ -126,17 +127,17 @@ def get_features(cyt_coord, nuc_coord, rna_coord,
 
     # dispersion measures
     if compute_dispersion:
-        dd = feature_polarization(centroid_rna_out,
-                                  centroid_cyt,
-                                  centroid_nuc,
-                                  distance_cyt_centroid,
-                                  distance_nuc_centroid)
-        ee = feature_dispersion(rna_coord_out,
-                                distance_rna_out_centroid,
-                                mask_cyt_out)
-        ff = feature_peripheral_dispersion(rna_coord_out,
-                                           distance_cyt_centroid,
-                                           mask_cyt_out)
+        dd = features_polarization(centroid_rna_out,
+                                   centroid_cyt,
+                                   centroid_nuc,
+                                   distance_cyt_centroid,
+                                   distance_nuc_centroid)
+        ee = features_dispersion(rna_coord_out,
+                                 distance_rna_out_centroid,
+                                 mask_cyt_out)
+        ff = features_peripheral_dispersion(rna_coord_out,
+                                            distance_cyt_centroid,
+                                            mask_cyt_out)
 
         features += dd + ee + ff
 
@@ -158,7 +159,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord,
 
     # area related features
     if compute_area:
-        ii = feature_area(mask_cyt, mask_nuc, mask_cyt_out)
+        ii = features_area(mask_cyt, mask_nuc, mask_cyt_out)
 
         features += ii
 
@@ -244,7 +245,9 @@ def get_features_name(names_features_aubin=False,
                           "log2_index_std_distance_nuc"]
 
     if names_features_intranuclear:
-        features_name += ["proportion_in_nuc"]
+        features_name += ["proportion_in_nuc",
+                          "nb_rna_out",
+                          "nb_rna_in"]
 
     if names_features_protrusion:
         features_name += ["index_rna_opening_30",
@@ -602,7 +605,7 @@ def feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna):
 
 def features_distance(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     rna_coord_out_2d = rna_coord_out[:, 1:3]
-    if len(rna_coord_out_2d) <= 10:
+    if len(rna_coord_out_2d) == 0:
         features = [1., 0., 1., 0., 1., 0.] * 2
         return features
     features = []
@@ -652,14 +655,18 @@ def features_distance(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     return features
 
 
-def feature_in_out_nucleus(rna_coord, mask_nuc):
+def features_in_out_nucleus(rna_coord, rna_coord_out):
+    # number of mRNAs outside and inside nucleus
+    nb_rna_out = len(rna_coord_out)
+    nb_rna_in = len(rna_coord) - nb_rna_out
+
     # compute the proportion of rna in the nucleus
-    mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
-    rna_in = rna_coord[mask_rna_in]
-    feature = len(rna_in) / len(rna_coord)
-    feature = np.round(feature, decimals=2)
+    proportion_rna_in = nb_rna_in / len(rna_coord)
+    proportion_rna_in = np.round(proportion_rna_in, decimals=2)
 
-    return feature
+    features = [proportion_rna_in, nb_rna_out, nb_rna_in]
+
+    return features
 
 
 def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
@@ -669,7 +676,7 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
     area_cyt_out = mask_cyt_out.sum()
 
     # case where we do not detect any rna outside the nucleus
-    if nb_rna_out <= 10:
+    if nb_rna_out == 0:
         features = [1., 0., 0.]
         return features
 
@@ -700,8 +707,8 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
     return features
 
 
-def feature_polarization(centroid_rna_out, centroid_cyt, centroid_nuc,
-                         distance_cyt_centroid, distance_nuc_centroid):
+def features_polarization(centroid_rna_out, centroid_cyt, centroid_nuc,
+                          distance_cyt_centroid, distance_nuc_centroid):
     centroid_rna_out_2d = centroid_rna_out[1:]
 
     # compute polarization index from cytoplasm centroid
@@ -721,8 +728,8 @@ def feature_polarization(centroid_rna_out, centroid_cyt, centroid_nuc,
     return feature
 
 
-def feature_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
-    if len(rna_coord_out) <= 10:
+def features_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
+    if len(rna_coord_out) == 0:
         features = [1., 0.]
         return features
 
@@ -748,9 +755,9 @@ def feature_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
     return features
 
 
-def feature_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
-                                  mask_cyt_out):
-    if len(rna_coord_out) <= 10:
+def features_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
+                                   mask_cyt_out):
+    if len(rna_coord_out) == 0:
         features = [1., 0.]
         return features
 
@@ -780,7 +787,7 @@ def feature_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
 def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
                         mask_cyt_out):
     # case where no mRNAs outside the nucleus are detected
-    if len(rna_coord_out) <= 0:
+    if len(rna_coord_out) == 0:
         features = [1., 0., 0.]
         features += [0., 0., 1., 0., 0.] * 30
         features += [0., 0., 1., 0., 0.] * 30
@@ -985,7 +992,7 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     return features
 
 
-def feature_area(mask_cyt, mask_nuc, mask_cyt_out):
+def features_area(mask_cyt, mask_nuc, mask_cyt_out):
     # get area of the cytoplasm and the nucleus
     area_cyt = mask_cyt.sum()
     area_nuc = mask_nuc.sum()

From b2a1c4bc721890947425fc4bf75cfac36cf14a0e Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 18 Oct 2019 10:53:27 +0200
Subject: [PATCH 250/264] major refactoring and improvement of the features #5

---
 bigfish/classification/features.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 3d94a891..1140a5ce 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -112,7 +112,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord,
     # intranuclear related features
     if compute_intranuclear:
         bb = features_in_out_nucleus(rna_coord,
-                                     mask_nuc)
+                                     rna_coord_out)
 
         features += bb
 
@@ -245,7 +245,7 @@ def get_features_name(names_features_aubin=False,
                           "log2_index_std_distance_nuc"]
 
     if names_features_intranuclear:
-        features_name += ["proportion_in_nuc",
+        features_name += ["proportion_rna_in_nuc",
                           "nb_rna_out",
                           "nb_rna_in"]
 
@@ -807,7 +807,7 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     nb_rna = len(rna_coord)
 
     # build nucleus edge topography
-    mask_nuc_edge = distance_map_nuc < 5
+    mask_nuc_edge = distance_map_nuc <= 5
     mask_nuc_edge[~mask_cyt] = False
     factor = nb_rna * max(mask_nuc_edge.sum(), 1) / cell_area
     mask_rna = mask_nuc_edge[rna_coord[:, 1], rna_coord[:, 2]]
@@ -822,7 +822,7 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
 
     # build nucleus topography
     for radius in range(1, 31):
-        mask_nuc_radius = distance_map_nuc < radius
+        mask_nuc_radius = distance_map_nuc <= radius
         mask_nuc_radius[~mask_cyt] = False
         mask_nuc_radius[mask_nuc] = False
         factor = nb_rna_out * max(mask_nuc_radius.sum(), 1) / cell_area
@@ -840,7 +840,7 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
 
     # build cytoplasm topography
     for radius in range(1, 31):
-        mask_cyt_radius = distance_map_cyt < radius
+        mask_cyt_radius = distance_map_cyt <= radius
         mask_cyt_radius[~mask_cyt] = False
         mask_cyt_radius[mask_nuc] = False
         factor = nb_rna_out * max(mask_cyt_radius.sum(), 1) / cell_area

From 3fc7ddbcf8105f730f901ed832156d53d50f822d Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 18 Oct 2019 18:30:10 +0200
Subject: [PATCH 251/264] major refactoring and improvement of the features #6

---
 bigfish/classification/features.py | 321 +++++++++++++++--------------
 bigfish/stack/utils.py             |  13 ++
 2 files changed, 182 insertions(+), 152 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 1140a5ce..7e80c7ec 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -164,6 +164,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord,
         features += ii
 
     features = np.array(features, dtype=np.float32)
+    features = np.round(features, decimals=2)
 
     return features
 
@@ -267,32 +268,34 @@ def get_features_name(names_features_aubin=False,
                           "log2_index_rna_nuc_edge",
                           "proportion_rna_nuc_edge"]
 
-        for a in range(1, 31):
-            features_name += ["nb_rna_nuc_radius_{0}".format(a),
-                              "area_nuc_radius_{0}".format(a),
-                              "index_rna_nuc_radius_{0}".format(a),
-                              "log2_index_rna_nuc_radius_{0}".format(a),
-                              "proportion_rna_nuc_radius_{0}".format(a)]
+        a = 5
+        for b in range(10, 31, 5):
+            features_name += ["index_rna_nuc_radius_{}_{}".format(a, b),
+                              "log2_index_rna_nuc_radius_{}_{}".format(a, b),
+                              "proportion_rna_nuc_radius_{}_{}".format(a, b)]
+            a = b
 
-        for a in range(1, 31):
-            features_name += ["nb_rna_cyt_radius_{0}".format(a),
-                              "area_cyt_radius_{0}".format(a),
-                              "index_rna_cyt_radius_{0}".format(a),
-                              "log2_index_rna_cyt_radius_{0}".format(a),
-                              "proportion_rna_cyt_radius_{0}".format(a)]
+        a = 0
+        for b in range(5, 31, 5):
+            features_name += ["index_rna_cyt_radius_{}_{}".format(a, b),
+                              "log2_index_rna_cyt_radius_{}_{}".format(a, b),
+                              "proportion_rna_cyt_radius_{}_{}".format(a, b)]
+            a = b
 
     if names_features_foci:
-        for a in [50, 150, 250, 350, 450, 550, 650, 750]:
-            for b in [2, 3, 4, 5, 6, 7, 8]:
+        for a in [50, 150, 250, 350, 450, 550, 650]:
+            for b in [3, 4, 5, 6, 7]:
                 features_name += ["nb_foci_{0}nm_{1}".format(a, b),
                                   "proportion_rna_foci_{0}nm_{1}".format(a, b)]
 
-        for a in range(1, 21):
-            features_name += ["nb_rna_foci_neighbor_radius_{0}".format(a),
-                              "area_foci_neighbor_radius_{0}".format(a),
-                              "index_rna_foci_radius_{0}".format(a),
-                              "log2_index_rna_foci_radius_{0}".format(a),
-                              "proportion_rna_foci_radius_{0}".format(a)]
+        a = 0
+        for b in range(5, 21, 5):
+            features_name += ["index_rna_foci_radius_{0}_{1}".format(a, b),
+                              "log2_index_rna_foci_radius_{0}_{1}".format(a,
+                                                                          b),
+                              "proportion_rna_foci_radius_{0}_{1}".format(a,
+                                                                          b)]
+            a = b
 
         features_name += ["index_foci_mean_distance_cyt",
                           "log2_index_foci_mean_distance_cyt",
@@ -604,7 +607,10 @@ def feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna):
 # ### Other features ###
 
 def features_distance(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
+    # initialization
     rna_coord_out_2d = rna_coord_out[:, 1:3]
+    eps = stack.get_eps_float32()
+
     if len(rna_coord_out_2d) == 0:
         features = [1., 0., 1., 0., 1., 0.] * 2
         return features
@@ -614,43 +620,41 @@ def features_distance(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     distance_rna_cyt = distance_cyt[rna_coord_out_2d[:, 0],
                                     rna_coord_out_2d[:, 1]]
     factor = np.mean(distance_cyt[mask_cyt_out])
-    index_mean_distance_cyt = np.mean(distance_rna_cyt) / factor
-    log2_index_mean_distance_cyt = np.log2(index_mean_distance_cyt + 0.0001)
+    index_mean_distance_cyt = (np.mean(distance_rna_cyt) + eps) / factor
+    log2_index_mean_distance_cyt = np.log2(index_mean_distance_cyt)
     factor = np.median(distance_cyt[mask_cyt_out])
-    index_median_distance_cyt = np.median(distance_rna_cyt) / factor
-    log2_index_median_distance_cyt = np.log2(
-        index_median_distance_cyt + 0.0001)
+    index_median_distance_cyt = (np.median(distance_rna_cyt) + eps) / factor
+    log2_index_median_distance_cyt = np.log2(index_median_distance_cyt)
     factor = np.std(distance_cyt[mask_cyt_out])
-    index_std_distance_cyt = np.std(distance_rna_cyt) / factor
-    log2_index_std_distance_cyt = np.log2(index_std_distance_cyt + 0.0001)
+    index_std_distance_cyt = (np.std(distance_rna_cyt) + eps) / factor
+    log2_index_std_distance_cyt = np.log2(index_std_distance_cyt)
 
-    features += [np.round(index_mean_distance_cyt, decimals=2),
-                 np.round(log2_index_mean_distance_cyt, decimals=2),
-                 np.round(index_median_distance_cyt, decimals=2),
-                 np.round(log2_index_median_distance_cyt, decimals=2),
-                 np.round(index_std_distance_cyt, decimals=2),
-                 np.round(log2_index_std_distance_cyt, decimals=2)]
+    features += [index_mean_distance_cyt,
+                 log2_index_mean_distance_cyt,
+                 index_median_distance_cyt,
+                 log2_index_median_distance_cyt,
+                 index_std_distance_cyt,
+                 log2_index_std_distance_cyt]
 
     # compute statistics from distance to nucleus
     distance_rna_nuc = distance_nuc[rna_coord_out_2d[:, 0],
                                     rna_coord_out_2d[:, 1]]
     factor = np.mean(distance_nuc[mask_cyt_out])
-    index_mean_distance_nuc = np.mean(distance_rna_nuc) / factor
-    log2_index_mean_distance_nuc = np.log2(index_mean_distance_nuc + 0.0001)
+    index_mean_distance_nuc = (np.mean(distance_rna_nuc) + eps) / factor
+    log2_index_mean_distance_nuc = np.log2(index_mean_distance_nuc)
     factor = np.median(distance_nuc[mask_cyt_out])
-    index_median_distance_nuc = np.median(distance_rna_nuc) / factor
-    log2_index_median_distance_nuc = np.log2(
-        index_median_distance_nuc + 0.0001)
+    index_median_distance_nuc = (np.median(distance_rna_nuc) + eps) / factor
+    log2_index_median_distance_nuc = np.log2(index_median_distance_nuc)
     factor = np.std(distance_nuc[mask_cyt_out])
-    index_std_distance_nuc = np.std(distance_rna_nuc) / factor
-    log2_index_std_distance_nuc = np.log2(index_std_distance_nuc + 0.0001)
+    index_std_distance_nuc = (np.std(distance_rna_nuc) + eps) / factor
+    log2_index_std_distance_nuc = np.log2(index_std_distance_nuc)
 
-    features += [np.round(index_mean_distance_nuc, decimals=2),
-                 np.round(log2_index_mean_distance_nuc, decimals=2),
-                 np.round(index_median_distance_nuc, decimals=2),
-                 np.round(log2_index_median_distance_nuc, decimals=2),
-                 np.round(index_std_distance_nuc, decimals=2),
-                 np.round(log2_index_std_distance_nuc, decimals=2)]
+    features += [index_mean_distance_nuc,
+                 log2_index_mean_distance_nuc,
+                 index_median_distance_nuc,
+                 log2_index_median_distance_nuc,
+                 index_std_distance_nuc,
+                 log2_index_std_distance_nuc]
 
     return features
 
@@ -662,7 +666,6 @@ def features_in_out_nucleus(rna_coord, rna_coord_out):
 
     # compute the proportion of rna in the nucleus
     proportion_rna_in = nb_rna_in / len(rna_coord)
-    proportion_rna_in = np.round(proportion_rna_in, decimals=2)
 
     features = [proportion_rna_in, nb_rna_out, nb_rna_in]
 
@@ -674,6 +677,7 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
     nb_rna_out = len(rna_coord_out)
     area_nuc = mask_nuc.sum()
     area_cyt_out = mask_cyt_out.sum()
+    eps = stack.get_eps_float32()
 
     # case where we do not detect any rna outside the nucleus
     if nb_rna_out == 0:
@@ -694,13 +698,13 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
                                             rna_coord_out[:, 2]]
             rna_after_opening = rna_coord_out[mask_rna]
             nb_rna_protrusion = nb_rna_out - len(rna_after_opening)
-            index_rna_opening = nb_rna_protrusion / factor
-            log2_index_rna_opening = np.log2(index_rna_opening + 0.0001)
+            index_rna_opening = (nb_rna_protrusion + eps) / factor
+            log2_index_rna_opening = np.log2(index_rna_opening)
             proportion_rna_opening = nb_rna_protrusion / nb_rna_out
 
-            features += [np.round(index_rna_opening, decimals=2),
-                         np.round(log2_index_rna_opening, decimals=2),
-                         np.round(proportion_rna_opening, decimals=2)]
+            features += [index_rna_opening,
+                         log2_index_rna_opening,
+                         proportion_rna_opening]
         else:
             features += [1., 0., 0.]
 
@@ -722,13 +726,16 @@ def features_polarization(centroid_rna_out, centroid_cyt, centroid_nuc,
     feature_nuc = polarization_distance / factor
 
     # gather features
-    feature = [np.round(feature_cyt, decimals=2),
-               np.round(feature_nuc, decimals=2)]
+    feature = [feature_cyt,
+               feature_nuc]
 
     return feature
 
 
 def features_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
+    # initialization
+    eps = stack.get_eps_float32()
+
     if len(rna_coord_out) == 0:
         features = [1., 0.]
         return features
@@ -746,17 +753,20 @@ def features_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
     a = distance_rna_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
     b = distance_rna_centroid[cell_outside_nuc_coord[:, 0],
                               cell_outside_nuc_coord[:, 1]]
-    index_dispersion = a.mean() / b.mean()
-    log2_index_dispersion = np.log2(index_dispersion + 0.0001)
+    index_dispersion = (a.mean() + eps) / b.mean()
+    log2_index_dispersion = np.log2(index_dispersion)
 
-    features = [np.round(index_dispersion, decimals=2),
-                np.round(log2_index_dispersion, decimals=2)]
+    features = [index_dispersion,
+                log2_index_dispersion]
 
     return features
 
 
 def features_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
                                    mask_cyt_out):
+    # initialization
+    eps = stack.get_eps_float32()
+
     if len(rna_coord_out) == 0:
         features = [1., 0.]
         return features
@@ -774,12 +784,11 @@ def features_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
     a = distance_cyt_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
     b = distance_cyt_centroid[cell_outside_nuc_coord[:, 0],
                               cell_outside_nuc_coord[:, 1]]
-    index_peripheral_dispersion = a.mean() / b.mean()
-    log2_index_peripheral_dispersion = np.log2(
-        index_peripheral_dispersion + 0.0001)
+    index_peripheral_dispersion = (a.mean() + eps) / b.mean()
+    log2_index_peripheral_dispersion = np.log2(index_peripheral_dispersion)
 
-    features = [np.round(index_peripheral_dispersion, decimals=2),
-                np.round(log2_index_peripheral_dispersion, decimals=2)]
+    features = [index_peripheral_dispersion,
+                log2_index_peripheral_dispersion]
 
     return features
 
@@ -789,8 +798,8 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     # case where no mRNAs outside the nucleus are detected
     if len(rna_coord_out) == 0:
         features = [1., 0., 0.]
-        features += [0., 0., 1., 0., 0.] * 30
-        features += [0., 0., 1., 0., 0.] * 30
+        features += [1., 0., 0.] * 6
+        features += [1., 0., 0.] * 6
         return features
 
     # build a distance map from nucleus border and from cytoplasm membrane
@@ -805,56 +814,59 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     cell_area = mask_cyt.sum()
     nb_rna_out = len(rna_coord_out)
     nb_rna = len(rna_coord)
+    eps = stack.get_eps_float32()
 
-    # build nucleus edge topography
+    # count mRNAs along nucleus edge (-5 to 5 pixels)
     mask_nuc_edge = distance_map_nuc <= 5
     mask_nuc_edge[~mask_cyt] = False
     factor = nb_rna * max(mask_nuc_edge.sum(), 1) / cell_area
     mask_rna = mask_nuc_edge[rna_coord[:, 1], rna_coord[:, 2]]
     nb_rna_nuc_edge = len(rna_coord[mask_rna])
-    index_rna_nuc_edge = nb_rna_nuc_edge / factor
-    log2_index_rna_nuc_edge = np.log2(index_rna_nuc_edge + 0.0001)
+    index_rna_nuc_edge = (nb_rna_nuc_edge + eps) / factor
+    log2_index_rna_nuc_edge = np.log2(index_rna_nuc_edge)
     proportion_rna_nuc_edge = nb_rna_nuc_edge / nb_rna
 
-    features += [np.round(index_rna_nuc_edge, decimals=2),
-                 np.round(log2_index_rna_nuc_edge, decimals=2),
-                 np.round(proportion_rna_nuc_edge, decimals=2)]
+    features += [index_rna_nuc_edge,
+                 log2_index_rna_nuc_edge,
+                 proportion_rna_nuc_edge]
 
-    # build nucleus topography
-    for radius in range(1, 31):
+    # count mRNAs in specific regions around nucleus
+    mask_cumulated_radius = mask_nuc_edge.copy()
+    for radius in range(10, 31, 5):
         mask_nuc_radius = distance_map_nuc <= radius
         mask_nuc_radius[~mask_cyt] = False
         mask_nuc_radius[mask_nuc] = False
-        factor = nb_rna_out * max(mask_nuc_radius.sum(), 1) / cell_area
-        mask_rna = mask_nuc_radius[rna_coord_out[:, 1], rna_coord_out[:, 2]]
-        nb_rna_nuc_radius = len(rna_coord_out[mask_rna])
-        index_rna_nuc = nb_rna_nuc_radius / factor
-        log2_index_rna_nuc = np.log2(index_rna_nuc + 0.0001)
-        proportion_rna_nuc = nb_rna_nuc_radius / nb_rna_out
-
-        features += [np.round(nb_rna_nuc_radius, decimals=2),
-                     np.round(mask_nuc_radius.sum(), decimals=2),
-                     np.round(index_rna_nuc, decimals=2),
-                     np.round(log2_index_rna_nuc, decimals=2),
-                     np.round(proportion_rna_nuc, decimals=2)]
-
-    # build cytoplasm topography
-    for radius in range(1, 31):
+        mask_nuc_radius[mask_cumulated_radius] = False
+        mask_cumulated_radius |= mask_nuc_radius
+        factor = nb_rna * max(mask_nuc_radius.sum(), 1) / cell_area
+        mask_rna = mask_nuc_radius[rna_coord[:, 1], rna_coord[:, 2]]
+        nb_rna_nuc_radius = len(rna_coord[mask_rna])
+        index_rna_nuc_radius = (nb_rna_nuc_radius + eps) / factor
+        log2_index_rna_nuc_radius = np.log2(index_rna_nuc_radius)
+        proportion_rna_nuc_radius = nb_rna_nuc_radius / nb_rna_out
+
+        features += [index_rna_nuc_radius,
+                     log2_index_rna_nuc_radius,
+                     proportion_rna_nuc_radius]
+
+    # count mRNAs in specific regions around cytoplasmic membrane
+    mask_cumulated_radius = np.zeros_like(mask_nuc_edge)
+    for radius in range(5, 31, 5):
         mask_cyt_radius = distance_map_cyt <= radius
         mask_cyt_radius[~mask_cyt] = False
         mask_cyt_radius[mask_nuc] = False
-        factor = nb_rna_out * max(mask_cyt_radius.sum(), 1) / cell_area
-        mask_rna = mask_cyt_radius[rna_coord_out[:, 1], rna_coord_out[:, 2]]
-        nb_rna_cyt_radius = len(rna_coord_out[mask_rna])
-        index_rna_cyt = nb_rna_cyt_radius / factor
-        log2_index_rna_cyt = np.log2(index_rna_cyt + 0.0001)
-        proportion_rna_cyt = nb_rna_cyt_radius / nb_rna_out
-
-        features += [np.round(nb_rna_cyt_radius, decimals=2),
-                     np.round(mask_cyt_radius.sum(), decimals=2),
-                     np.round(index_rna_cyt, decimals=2),
-                     np.round(log2_index_rna_cyt, decimals=2),
-                     np.round(proportion_rna_cyt, decimals=2)]
+        mask_cyt_radius[mask_cumulated_radius] = False
+        mask_cumulated_radius |= mask_cyt_radius
+        factor = nb_rna * max(mask_cyt_radius.sum(), 1) / cell_area
+        mask_rna = mask_cyt_radius[rna_coord[:, 1], rna_coord[:, 2]]
+        nb_rna_cyt_radius = len(rna_coord[mask_rna])
+        index_rna_cyt_radius = (nb_rna_cyt_radius + eps) / factor
+        log2_index_rna_cyt_radius = np.log2(index_rna_cyt_radius)
+        proportion_rna_cyt_radius = nb_rna_cyt_radius / nb_rna_out
+
+        features += [index_rna_cyt_radius,
+                     log2_index_rna_cyt_radius,
+                     proportion_rna_cyt_radius]
 
     return features
 
@@ -862,15 +874,15 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
 def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     # case where no mRNAs outside the nucleus are detected
     if len(rna_coord_out) == 0:
-        features = [0.] * 56 * 2
-        features += [0., 0., 1., 0., 0.] * 20
+        features = [0.] * 35 * 2
+        features += [1., 0., 0.] * 4
         features += [1., 0., 1., 0., 1., 0.]
         features += [1., 0., 1., 0., 1., 0.]
         return features
 
     features = []
-    for foci_radius in [50, 150, 250, 350, 450, 550, 650, 750]:
-        for min_foci_rna in [2, 3, 4, 5, 6, 7, 8]:
+    for foci_radius in [50, 150, 250, 350, 450, 550, 650]:
+        for min_foci_rna in [3, 4, 5, 6, 7]:
             clustered_spots = detection.cluster_spots(
                 spots=rna_coord_out[:, :3],
                 resolution_z=300,
@@ -882,13 +894,13 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
             nb_spots_in_foci = np.sum(foci[:, 3])
             proportion_rna_foci = nb_spots_in_foci / len(rna_coord_out)
 
-            features += [np.round(nb_foci, decimals=2),
-                         np.round(proportion_rna_foci, decimals=2)]
+            features += [nb_foci,
+                         proportion_rna_foci]
 
     # case where no default foci are detected
     rna_coord_out_foci = rna_coord_out[rna_coord_out[:, 3] != -1, :]
     if len(rna_coord_out_foci) == 0:
-        features += [0., 0., 1., 0., 0.] * 20
+        features += [1., 0., 0.] * 4
         features += [1., 0., 1., 0., 1., 0.]
         features += [1., 0., 1., 0., 1., 0.]
         return features
@@ -896,12 +908,19 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     # get regular foci id
     l_id_foci = list(set(rna_coord_out_foci[:, 3]))
 
-    # count foci neighbors for different radius
+    # count mRNAs in successive 5 pixels foci neighbors
     nb_rna_out = len(rna_coord_out)
     cell_out_area = mask_cyt_out.sum()
-    for radius in range(1, 21):
+    mask_foci_neighbor_cumulated = np.zeros_like(mask_cyt_out)
+    eps = stack.get_eps_float32()
+
+    # we count mRNAs in the neighbors 0-5 pixels around the foci, 5-10 pixels,
+    # 10-15 pixels, and 15-20 pixels
+    for radius in range(5, 21, 5):
         s = disk(radius).astype(bool)
         mask_foci_neighbor = np.zeros_like(mask_cyt_out)
+
+        # for each foci, get a mask of its neighbor and merge them
         for i in l_id_foci:
             rna_foci_i = rna_coord_out_foci[rna_coord_out_foci[:, 3] == i, :3]
             foci = np.mean(rna_foci_i, axis=0)
@@ -919,19 +938,23 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
             new_s = s[min_row_s:max_row_s, min_col_s:max_col_s]
             mask_neighbor[min_row:max_row, min_col:max_col] = new_s
             mask_foci_neighbor |= mask_cyt_out & mask_neighbor
+
+        # remove neighbor mask from previous radius
+        mask_foci_neighbor[mask_foci_neighbor_cumulated] = False
+        mask_foci_neighbor_cumulated |= mask_foci_neighbor
+
+        # count mRNAs in such a region
         mask_rna = mask_foci_neighbor[rna_coord_out[:, 1], rna_coord_out[:, 2]]
-        nb_rna_neighbor = len(rna_coord_out[mask_rna])
-        foci_neighbor_area = mask_foci_neighbor.sum()
-        factor = nb_rna_out * max(foci_neighbor_area, 1) / cell_out_area
-        index_rna_foci = nb_rna_neighbor / factor
-        log2_index_rna_foci = np.log2(index_rna_foci + 0.0001)
-        proportion_rna_foci = nb_rna_neighbor / nb_rna_out
-
-        features += [np.round(nb_rna_neighbor, decimals=2),
-                     np.round(foci_neighbor_area, decimals=2),
-                     np.round(index_rna_foci, decimals=2),
-                     np.round(log2_index_rna_foci, decimals=2),
-                     np.round(proportion_rna_foci, decimals=2)]
+        nb_rna_foci_neighbor = len(rna_coord_out[mask_rna])
+        area_foci_neighbor = mask_foci_neighbor.sum()
+        factor = nb_rna_out * max(area_foci_neighbor, 1) / cell_out_area
+        index_rna_foci_neighbor = (nb_rna_foci_neighbor + eps) / factor
+        log2_index_rna_foci_neighbor = np.log2(index_rna_foci_neighbor)
+        proportion_rna_foci_neighbor = nb_rna_foci_neighbor / nb_rna_out
+
+        features += [index_rna_foci_neighbor,
+                     log2_index_rna_foci_neighbor,
+                     proportion_rna_foci_neighbor]
 
     # get foci coordinates
     foci_coord = []
@@ -947,47 +970,41 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     # compute statistics from distance to cytoplasm
     distance_foci_cyt = distance_cyt[foci_coord_2d[:, 0], foci_coord_2d[:, 1]]
     factor = np.mean(distance_cyt[mask_cyt_out])
-    index_foci_mean_distance_cyt = np.mean(distance_foci_cyt) / factor
-    log2_index_foci_mean_distance_cyt = np.log2(
-        index_foci_mean_distance_cyt + 0.0001)
+    index_foci_mean_distance_cyt = (np.mean(distance_foci_cyt) + eps) / factor
+    log2_index_foci_mean_distance_cyt = np.log2(index_foci_mean_distance_cyt)
     factor = np.median(distance_cyt[mask_cyt_out])
-    index_foci_median_distance_cyt = np.median(distance_foci_cyt) / factor
-    log2_index_foci_median_distance_cyt = np.log2(
-        index_foci_median_distance_cyt + 0.0001)
+    index_foci_med_distance_cyt = (np.median(distance_foci_cyt) + eps) / factor
+    log2_index_foci_med_distance_cyt = np.log2(index_foci_med_distance_cyt)
     factor = np.std(distance_cyt[mask_cyt_out])
-    index_foci_std_distance_cyt = np.std(distance_foci_cyt) / factor
-    log2_index_foci_std_distance_cyt = np.log2(
-        index_foci_std_distance_cyt + 0.0001)
+    index_foci_std_distance_cyt = (np.std(distance_foci_cyt) + eps) / factor
+    log2_index_foci_std_distance_cyt = np.log2(index_foci_std_distance_cyt)
 
-    features += [np.round(index_foci_mean_distance_cyt, decimals=2),
-                 np.round(log2_index_foci_mean_distance_cyt, decimals=2),
-                 np.round(index_foci_median_distance_cyt, decimals=2),
-                 np.round(log2_index_foci_median_distance_cyt, decimals=2),
-                 np.round(index_foci_std_distance_cyt, decimals=2),
-                 np.round(log2_index_foci_std_distance_cyt, decimals=2)]
+    features += [index_foci_mean_distance_cyt,
+                 log2_index_foci_mean_distance_cyt,
+                 index_foci_med_distance_cyt,
+                 log2_index_foci_med_distance_cyt,
+                 index_foci_std_distance_cyt,
+                 log2_index_foci_std_distance_cyt]
 
     # compute statistics from distance to nucleus
     distance_foci_nuc = distance_nuc[foci_coord_2d[:, 0],
                                      foci_coord_2d[:, 1]]
     factor = np.mean(distance_nuc[mask_cyt_out])
-    index_foci_mean_distance_nuc = np.mean(distance_foci_nuc) / factor
-    log2_index_foci_mean_distance_nuc = np.log2(
-        index_foci_mean_distance_nuc + 0.0001)
+    index_foci_mean_distance_nuc = (np.mean(distance_foci_nuc) + eps) / factor
+    log2_index_foci_mean_distance_nuc = np.log2(index_foci_mean_distance_nuc)
     factor = np.median(distance_nuc[mask_cyt_out])
-    index_foci_median_distance_nuc = np.median(distance_foci_nuc) / factor
-    log2_index_foci_median_distance_nuc = np.log2(
-        index_foci_median_distance_nuc + 0.0001)
+    index_foci_med_distance_nuc = (np.median(distance_foci_nuc) + eps) / factor
+    log2_index_foci_med_distance_nuc = np.log2(index_foci_med_distance_nuc)
     factor = np.std(distance_nuc[mask_cyt_out])
-    index_foci_std_distance_nuc = np.std(distance_foci_nuc) / factor
-    log2_index_foci_std_distance_nuc = np.log2(
-        index_foci_std_distance_nuc + 0.0001)
-
-    features += [np.round(index_foci_mean_distance_nuc, decimals=2),
-                 np.round(log2_index_foci_mean_distance_nuc, decimals=2),
-                 np.round(index_foci_median_distance_nuc, decimals=2),
-                 np.round(log2_index_foci_median_distance_nuc, decimals=2),
-                 np.round(index_foci_std_distance_nuc, decimals=2),
-                 np.round(log2_index_foci_std_distance_nuc, decimals=2)]
+    index_foci_std_distance_nuc = (np.std(distance_foci_nuc) + eps) / factor
+    log2_index_foci_std_distance_nuc = np.log2(index_foci_std_distance_nuc)
+
+    features += [index_foci_mean_distance_nuc,
+                 log2_index_foci_mean_distance_nuc,
+                 index_foci_med_distance_nuc,
+                 log2_index_foci_med_distance_nuc,
+                 index_foci_std_distance_nuc,
+                 log2_index_foci_std_distance_nuc]
 
     return features
 
diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 2f474348..ba7e4b77 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -601,3 +601,16 @@ def get_offset_value():
 
     """
     return 5
+
+
+def get_eps_float32():
+    """Return the epsilon value for a 32 bit float.
+
+    Returns
+    -------
+    _ : np.float32
+        Epsilon value.
+
+    """
+
+    return np.finfo(np.float32).eps

From 8208f7691ad40b69765e7075217fcd40c5f4e009 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 18 Oct 2019 18:32:28 +0200
Subject: [PATCH 252/264] major refactoring and improvement of the features #7

---
 bigfish/stack/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index ab3dc00f..01a833cc 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -7,7 +7,7 @@
 
 from .utils import (check_array, check_df, check_recipe, check_parameter,
                     check_range_value, complete_coordinates_2d,
-                    from_coord_to_image, get_offset_value)
+                    from_coord_to_image, get_offset_value, get_eps_float32)
 from .io import (read_image, read_pickle, read_cell_json, read_rna_json,
                  save_image)
 from .preprocess import (build_simulated_dataset, build_stacks, build_stack,
@@ -38,7 +38,7 @@
 
 _utils = ["check_array", "check_df", "check_recipe", "check_parameter",
           "check_range_value", "complete_coordinates_2d",
-          "from_coord_to_image", "get_offset_value"]
+          "from_coord_to_image", "get_offset_value", "get_eps_float32"]
 
 _io = ["read_image", "read_pickle", "read_cell_json", "read_rna_json",
        "save_image"]

From 56dc1a61a71136eb05a9cbd364ce27f389869d58 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Fri, 18 Oct 2019 18:44:56 +0200
Subject: [PATCH 253/264] major refactoring and improvement of the features #8

---
 bigfish/classification/features.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 7e80c7ec..d2bf49d6 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -726,10 +726,10 @@ def features_polarization(centroid_rna_out, centroid_cyt, centroid_nuc,
     feature_nuc = polarization_distance / factor
 
     # gather features
-    feature = [feature_cyt,
-               feature_nuc]
+    features = [feature_cyt,
+                feature_nuc]
 
-    return feature
+    return features
 
 
 def features_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
@@ -798,7 +798,7 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     # case where no mRNAs outside the nucleus are detected
     if len(rna_coord_out) == 0:
         features = [1., 0., 0.]
-        features += [1., 0., 0.] * 6
+        features += [1., 0., 0.] * 5
         features += [1., 0., 0.] * 6
         return features
 

From 60db0242114c56c83a7ca36cb912d40bff428450 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sun, 20 Oct 2019 15:06:09 +0200
Subject: [PATCH 254/264] major refactoring and improvement of the features #9

---
 bigfish/classification/features.py | 67 +++++++++++++++++++++++++++---
 1 file changed, 62 insertions(+), 5 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index d2bf49d6..89304d01 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -275,6 +275,13 @@ def get_features_name(names_features_aubin=False,
                               "proportion_rna_nuc_radius_{}_{}".format(a, b)]
             a = b
 
+        a = 5
+        for b in range(15, 26, 10):
+            features_name += ["index_rna_nuc_radius_{}_{}".format(a, b),
+                              "log2_index_rna_nuc_radius_{}_{}".format(a, b),
+                              "proportion_rna_nuc_radius_{}_{}".format(a, b)]
+            a = b
+
         a = 0
         for b in range(5, 31, 5):
             features_name += ["index_rna_cyt_radius_{}_{}".format(a, b),
@@ -282,6 +289,13 @@ def get_features_name(names_features_aubin=False,
                               "proportion_rna_cyt_radius_{}_{}".format(a, b)]
             a = b
 
+        a = 0
+        for b in range(10, 31, 10):
+            features_name += ["index_rna_cyt_radius_{}_{}".format(a, b),
+                              "log2_index_rna_cyt_radius_{}_{}".format(a, b),
+                              "proportion_rna_cyt_radius_{}_{}".format(a, b)]
+            a = b
+
     if names_features_foci:
         for a in [50, 150, 250, 350, 450, 550, 650]:
             for b in [3, 4, 5, 6, 7]:
@@ -799,7 +813,9 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     if len(rna_coord_out) == 0:
         features = [1., 0., 0.]
         features += [1., 0., 0.] * 5
+        features += [1., 0., 0.] * 2
         features += [1., 0., 0.] * 6
+        features += [1., 0., 0.] * 3
         return features
 
     # build a distance map from nucleus border and from cytoplasm membrane
@@ -812,8 +828,8 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     # initialization
     features = []
     cell_area = mask_cyt.sum()
-    nb_rna_out = len(rna_coord_out)
     nb_rna = len(rna_coord)
+    nb_rna_out = len(rna_coord_out)
     eps = stack.get_eps_float32()
 
     # count mRNAs along nucleus edge (-5 to 5 pixels)
@@ -830,7 +846,8 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
                  log2_index_rna_nuc_edge,
                  proportion_rna_nuc_edge]
 
-    # count mRNAs in specific regions around nucleus
+    # count mRNAs in specific regions around nucleus (5-10, 10-15, 15-20,
+    # 20-25, 25-30)
     mask_cumulated_radius = mask_nuc_edge.copy()
     for radius in range(10, 31, 5):
         mask_nuc_radius = distance_map_nuc <= radius
@@ -843,13 +860,33 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
         nb_rna_nuc_radius = len(rna_coord[mask_rna])
         index_rna_nuc_radius = (nb_rna_nuc_radius + eps) / factor
         log2_index_rna_nuc_radius = np.log2(index_rna_nuc_radius)
-        proportion_rna_nuc_radius = nb_rna_nuc_radius / nb_rna_out
+        proportion_rna_nuc_radius = nb_rna_nuc_radius / nb_rna
+
+        features += [index_rna_nuc_radius,
+                     log2_index_rna_nuc_radius,
+                     proportion_rna_nuc_radius]
+
+    # count mRNAs in specific regions around nucleus (5-15, 15-25)
+    mask_cumulated_radius = mask_nuc_edge.copy()
+    for radius in range(15, 26, 10):
+        mask_nuc_radius = distance_map_nuc <= radius
+        mask_nuc_radius[~mask_cyt] = False
+        mask_nuc_radius[mask_nuc] = False
+        mask_nuc_radius[mask_cumulated_radius] = False
+        mask_cumulated_radius |= mask_nuc_radius
+        factor = nb_rna * max(mask_nuc_radius.sum(), 1) / cell_area
+        mask_rna = mask_nuc_radius[rna_coord[:, 1], rna_coord[:, 2]]
+        nb_rna_nuc_radius = len(rna_coord[mask_rna])
+        index_rna_nuc_radius = (nb_rna_nuc_radius + eps) / factor
+        log2_index_rna_nuc_radius = np.log2(index_rna_nuc_radius)
+        proportion_rna_nuc_radius = nb_rna_nuc_radius / nb_rna
 
         features += [index_rna_nuc_radius,
                      log2_index_rna_nuc_radius,
                      proportion_rna_nuc_radius]
 
-    # count mRNAs in specific regions around cytoplasmic membrane
+    # count mRNAs in specific regions around cytoplasmic membrane (0-5, 5-10,
+    # 10-15, 15-20, 20-25, 25-30)
     mask_cumulated_radius = np.zeros_like(mask_nuc_edge)
     for radius in range(5, 31, 5):
         mask_cyt_radius = distance_map_cyt <= radius
@@ -862,7 +899,27 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
         nb_rna_cyt_radius = len(rna_coord[mask_rna])
         index_rna_cyt_radius = (nb_rna_cyt_radius + eps) / factor
         log2_index_rna_cyt_radius = np.log2(index_rna_cyt_radius)
-        proportion_rna_cyt_radius = nb_rna_cyt_radius / nb_rna_out
+        proportion_rna_cyt_radius = nb_rna_cyt_radius / nb_rna
+
+        features += [index_rna_cyt_radius,
+                     log2_index_rna_cyt_radius,
+                     proportion_rna_cyt_radius]
+
+    # count mRNAs in specific regions around cytoplasmic membrane (0-10, 10-20,
+    # 20-30)
+    mask_cumulated_radius = np.zeros_like(mask_nuc_edge)
+    for radius in range(10, 31, 10):
+        mask_cyt_radius = distance_map_cyt <= radius
+        mask_cyt_radius[~mask_cyt] = False
+        mask_cyt_radius[mask_nuc] = False
+        mask_cyt_radius[mask_cumulated_radius] = False
+        mask_cumulated_radius |= mask_cyt_radius
+        factor = nb_rna * max(mask_cyt_radius.sum(), 1) / cell_area
+        mask_rna = mask_cyt_radius[rna_coord[:, 1], rna_coord[:, 2]]
+        nb_rna_cyt_radius = len(rna_coord[mask_rna])
+        index_rna_cyt_radius = (nb_rna_cyt_radius + eps) / factor
+        log2_index_rna_cyt_radius = np.log2(index_rna_cyt_radius)
+        proportion_rna_cyt_radius = nb_rna_cyt_radius / nb_rna
 
         features += [index_rna_cyt_radius,
                      log2_index_rna_cyt_radius,

From 69cba7626dab767b295a7f0cb7b06e3aa3319bf9 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Sun, 20 Oct 2019 18:46:25 +0200
Subject: [PATCH 255/264] major refactoring and improvement of the features #10

---
 bigfish/classification/features.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 89304d01..e720a717 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -833,7 +833,7 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     eps = stack.get_eps_float32()
 
     # count mRNAs along nucleus edge (-5 to 5 pixels)
-    mask_nuc_edge = distance_map_nuc <= 5
+    mask_nuc_edge = distance_map_nuc < 5
     mask_nuc_edge[~mask_cyt] = False
     factor = nb_rna * max(mask_nuc_edge.sum(), 1) / cell_area
     mask_rna = mask_nuc_edge[rna_coord[:, 1], rna_coord[:, 2]]
@@ -850,7 +850,7 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     # 20-25, 25-30)
     mask_cumulated_radius = mask_nuc_edge.copy()
     for radius in range(10, 31, 5):
-        mask_nuc_radius = distance_map_nuc <= radius
+        mask_nuc_radius = distance_map_nuc < radius
         mask_nuc_radius[~mask_cyt] = False
         mask_nuc_radius[mask_nuc] = False
         mask_nuc_radius[mask_cumulated_radius] = False
@@ -869,7 +869,7 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     # count mRNAs in specific regions around nucleus (5-15, 15-25)
     mask_cumulated_radius = mask_nuc_edge.copy()
     for radius in range(15, 26, 10):
-        mask_nuc_radius = distance_map_nuc <= radius
+        mask_nuc_radius = distance_map_nuc < radius
         mask_nuc_radius[~mask_cyt] = False
         mask_nuc_radius[mask_nuc] = False
         mask_nuc_radius[mask_cumulated_radius] = False
@@ -889,7 +889,7 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     # 10-15, 15-20, 20-25, 25-30)
     mask_cumulated_radius = np.zeros_like(mask_nuc_edge)
     for radius in range(5, 31, 5):
-        mask_cyt_radius = distance_map_cyt <= radius
+        mask_cyt_radius = distance_map_cyt < radius
         mask_cyt_radius[~mask_cyt] = False
         mask_cyt_radius[mask_nuc] = False
         mask_cyt_radius[mask_cumulated_radius] = False
@@ -909,7 +909,7 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     # 20-30)
     mask_cumulated_radius = np.zeros_like(mask_nuc_edge)
     for radius in range(10, 31, 10):
-        mask_cyt_radius = distance_map_cyt <= radius
+        mask_cyt_radius = distance_map_cyt < radius
         mask_cyt_radius[~mask_cyt] = False
         mask_cyt_radius[mask_nuc] = False
         mask_cyt_radius[mask_cumulated_radius] = False

From d702bbdf0c9b1976d14adda2208ec099197d3c44 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 21 Oct 2019 16:53:46 +0200
Subject: [PATCH 256/264] major refactoring and improvement of the features #11

---
 bigfish/classification/features.py | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index e720a717..c40a6f94 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -695,7 +695,7 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
 
     # case where we do not detect any rna outside the nucleus
     if nb_rna_out == 0:
-        features = [1., 0., 0.]
+        features = [0., np.log2(eps), 0.]
         return features
 
     # apply opening operator and count the loss of rna outside the nucleus
@@ -720,7 +720,7 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
                          log2_index_rna_opening,
                          proportion_rna_opening]
         else:
-            features += [1., 0., 0.]
+            features += [0., np.log2(eps), 0.]
 
     return features
 
@@ -809,13 +809,20 @@ def features_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
 
 def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
                         mask_cyt_out):
+    # initialization
+    features = []
+    cell_area = mask_cyt.sum()
+    nb_rna = len(rna_coord)
+    nb_rna_out = len(rna_coord_out)
+    eps = stack.get_eps_float32()
+
     # case where no mRNAs outside the nucleus are detected
-    if len(rna_coord_out) == 0:
-        features = [1., 0., 0.]
-        features += [1., 0., 0.] * 5
-        features += [1., 0., 0.] * 2
-        features += [1., 0., 0.] * 6
-        features += [1., 0., 0.] * 3
+    if nb_rna_out == 0:
+        features = [0., np.log2(eps), 0.]
+        features += [0., np.log2(eps), 0.] * 5
+        features += [0., np.log2(eps), 0.] * 2
+        features += [0., np.log2(eps), 0.] * 6
+        features += [0., np.log2(eps), 0.] * 3
         return features
 
     # build a distance map from nucleus border and from cytoplasm membrane
@@ -825,13 +832,6 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     distance_map_nuc[~mask_cyt] = 0
     distance_map_cyt = ndi.distance_transform_edt(mask_cyt)
 
-    # initialization
-    features = []
-    cell_area = mask_cyt.sum()
-    nb_rna = len(rna_coord)
-    nb_rna_out = len(rna_coord_out)
-    eps = stack.get_eps_float32()
-
     # count mRNAs along nucleus edge (-5 to 5 pixels)
     mask_nuc_edge = distance_map_nuc < 5
     mask_nuc_edge[~mask_cyt] = False

From 420a6ea7a95cc6c4961a2457d789517d16fb7d23 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 5 Nov 2019 19:58:41 +0100
Subject: [PATCH 257/264] remove useless features

---
 bigfish/classification/features.py     |  525 +--------
 bigfish/classification/features_old.py | 1376 +++++++++++++++---------
 2 files changed, 911 insertions(+), 990 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index c40a6f94..87045b51 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -5,7 +5,6 @@
 """
 
 import bigfish.stack as stack
-import bigfish.detection as detection
 
 import numpy as np
 from scipy import ndimage as ndi
@@ -14,9 +13,6 @@
 from skimage.morphology import binary_opening
 from skimage.morphology.selem import disk
 
-from scipy.spatial import distance_matrix
-from scipy.stats import spearmanr
-
 # TODO add sanity check functions
 # TODO add documentation
 # TODO allow to return intermediate results (distance map, etc.)
@@ -24,7 +20,6 @@
 
 
 def get_features(cyt_coord, nuc_coord, rna_coord,
-                 compute_aubin=False,
                  compute_distance=True,
                  compute_intranuclear=True,
                  compute_protrusion=True,
@@ -43,8 +38,6 @@ def get_features(cyt_coord, nuc_coord, rna_coord,
     rna_coord : np.ndarray, np.int64
         Coordinate zyx of the detected rna, plus the index of a potential foci.
         Shape (nb_rna, 4).
-    compute_aubin : bool
-        Compute features from Aubin paper.
     compute_distance : bool
         Compute features related to distances from nucleus or cytoplasmic
         membrane.
@@ -81,25 +74,6 @@ def get_features(cyt_coord, nuc_coord, rna_coord,
                                                           nuc_coord,
                                                           rna_coord)
 
-    # features from Aubin's paper
-    if compute_aubin:
-        a = features_distance_aubin(rna_coord,
-                                    distance_cyt_normalized,
-                                    distance_nuc_normalized,
-                                    distance_cyt_centroid,
-                                    distance_nuc_centroid)
-        b = feature_in_out_nucleus_aubin(rna_coord, mask_nuc)
-        opening_sizes = [15, 30, 45, 60]
-        c = features_opening_aubin(opening_sizes, rna_coord, mask_cyt)
-        radii = [r for r in range(40)]
-        d = features_ripley_aubin(radii, rna_coord, cyt_coord, mask_cyt)
-        e = feature_polarization_aubin(distance_cyt_normalized,
-                                       distance_cyt_centroid,
-                                       centroid_rna)
-        f = feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna)
-
-        features += a + [b] + c + d + [e] + [f]
-
     # distances related features
     if compute_distance:
         aa = features_distance(rna_coord_out,
@@ -169,8 +143,7 @@ def get_features(cyt_coord, nuc_coord, rna_coord,
     return features
 
 
-def get_features_name(names_features_aubin=False,
-                      names_features_distance=True,
+def get_features_name(names_features_distance=True,
                       names_features_intranuclear=True,
                       names_features_protrusion=True,
                       names_features_dispersion=True,
@@ -181,8 +154,6 @@ def get_features_name(names_features_aubin=False,
 
     Parameters
     ----------
-    names_features_aubin : bool
-        Return names of features from Aubin paper.
     names_features_distance : bool
         Return names of features related to distances from nucleus or
         cytoplasmic membrane.
@@ -208,42 +179,11 @@ def get_features_name(names_features_aubin=False,
     """
     features_name = []
 
-    if names_features_aubin:
-        features_name += ["aubin_average_dist_cyt",
-                          "aubin_quantile_5_dist_cyt",
-                          "aubin_quantile_10_dist_cyt",
-                          "aubin_quantile_20_dist_cyt",
-                          "aubin_quantile_50_dist_cyt",
-                          "aubin_average_dist_cyt_centroid",
-                          "aubin_average_dist_nuc",
-                          "aubin_average_dist_nuc_centroid",
-                          "aubin_ratio_in_nuc",
-                          "aubin_diff_opening_15",
-                          "aubin_diff_opening_30",
-                          "aubin_diff_opening_45",
-                          "aubin_diff_opening_60",
-                          "aubin_ripley_max",
-                          "aubin_ripley_max_gradient",
-                          "aubin_ripley_min_gradient",
-                          "aubin_ripley_monotony",
-                          "aubin_ripley_mid_cell",
-                          "aubin_ripley_max_radius",
-                          "aubin_polarization_index",
-                          "aubin_dispersion_index"]
-
     if names_features_distance:
         features_name += ["index_mean_distance_cyt",
-                          "log2_index_mean_distance_cyt",
                           "index_median_distance_cyt",
-                          "log2_index_median_distance_cyt",
-                          "index_std_distance_cyt",
-                          "log2_index_std_distance_cyt",
                           "index_mean_distance_nuc",
-                          "log2_index_mean_distance_nuc",
-                          "index_median_distance_nuc",
-                          "log2_index_median_distance_nuc",
-                          "index_std_distance_nuc",
-                          "log2_index_std_distance_nuc"]
+                          "index_median_distance_nuc"]
 
     if names_features_intranuclear:
         features_name += ["proportion_rna_in_nuc",
@@ -252,77 +192,36 @@ def get_features_name(names_features_aubin=False,
 
     if names_features_protrusion:
         features_name += ["index_rna_opening_30",
-                          "log2_index_rna_opening_30",
                           "proportion_rna_opening_30"]
 
     if names_features_dispersion:
         features_name += ["score_polarization_cyt",
                           "score_polarization_nuc",
                           "index_dispersion",
-                          "log2_index_dispersion",
-                          "index_peripheral_dispersion",
-                          "log2_index_peripheral_dispersion"]
+                          "index_peripheral_dispersion"]
 
     if names_features_topography:
         features_name += ["index_rna_nuc_edge",
-                          "log2_index_rna_nuc_edge",
                           "proportion_rna_nuc_edge"]
 
         a = 5
         for b in range(10, 31, 5):
             features_name += ["index_rna_nuc_radius_{}_{}".format(a, b),
-                              "log2_index_rna_nuc_radius_{}_{}".format(a, b),
-                              "proportion_rna_nuc_radius_{}_{}".format(a, b)]
-            a = b
-
-        a = 5
-        for b in range(15, 26, 10):
-            features_name += ["index_rna_nuc_radius_{}_{}".format(a, b),
-                              "log2_index_rna_nuc_radius_{}_{}".format(a, b),
                               "proportion_rna_nuc_radius_{}_{}".format(a, b)]
             a = b
 
         a = 0
         for b in range(5, 31, 5):
             features_name += ["index_rna_cyt_radius_{}_{}".format(a, b),
-                              "log2_index_rna_cyt_radius_{}_{}".format(a, b),
-                              "proportion_rna_cyt_radius_{}_{}".format(a, b)]
-            a = b
-
-        a = 0
-        for b in range(10, 31, 10):
-            features_name += ["index_rna_cyt_radius_{}_{}".format(a, b),
-                              "log2_index_rna_cyt_radius_{}_{}".format(a, b),
                               "proportion_rna_cyt_radius_{}_{}".format(a, b)]
             a = b
 
     if names_features_foci:
-        for a in [50, 150, 250, 350, 450, 550, 650]:
-            for b in [3, 4, 5, 6, 7]:
-                features_name += ["nb_foci_{0}nm_{1}".format(a, b),
-                                  "proportion_rna_foci_{0}nm_{1}".format(a, b)]
-
-        a = 0
-        for b in range(5, 21, 5):
-            features_name += ["index_rna_foci_radius_{0}_{1}".format(a, b),
-                              "log2_index_rna_foci_radius_{0}_{1}".format(a,
-                                                                          b),
-                              "proportion_rna_foci_radius_{0}_{1}".format(a,
-                                                                          b)]
-            a = b
-
-        features_name += ["index_foci_mean_distance_cyt",
-                          "log2_index_foci_mean_distance_cyt",
+        features_name += ["proportion_rna_in_foci",
+                          "index_foci_mean_distance_cyt",
                           "index_foci_median_distance_cyt",
-                          "log2_index_foci_median_distance_cyt",
-                          "index_foci_std_distance_cyt",
-                          "log2_index_foci_std_distance_cyt",
                           "index_foci_mean_distance_nuc",
-                          "log2_index_foci_mean_distance_nuc",
-                          "index_foci_median_distance_nuc",
-                          "log2_index_foci_median_distance_nuc",
-                          "index_foci_std_distance_nuc",
-                          "log2_index_foci_std_distance_nuc"]
+                          "index_foci_median_distance_nuc"]
 
     if names_features_area:
         features_name += ["proportion_nuc_area",
@@ -439,194 +338,14 @@ def prepare_coordinate_data(cyt_coord, nuc_coord, rna_coord):
     return prepared_inputs
 
 
-# ### Aubin's features ###
-
-def features_distance_aubin(rna_coord, distance_cyt, distance_nuc,
-                            distance_cyt_centroid, distance_nuc_centroid):
-    rna_coord_2d = rna_coord[:, 1:3]
-
-    # compute average distances to cytoplasm and quantiles
-    factor = distance_cyt[distance_cyt > 0].mean()
-    distance_rna_cyt = distance_cyt[rna_coord_2d[:, 0], rna_coord_2d[:, 1]]
-    mean_distance_cyt = distance_rna_cyt.mean() / factor
-    quantile_5_distance_cyt = np.percentile(distance_rna_cyt, 5)
-    quantile_5_distance_cyt /= factor
-    quantile_10_distance_cyt = np.percentile(distance_rna_cyt, 10)
-    quantile_10_distance_cyt /= factor
-    quantile_20_distance_cyt = np.percentile(distance_rna_cyt, 20)
-    quantile_20_distance_cyt /= factor
-    quantile_50_distance_cyt = np.percentile(distance_rna_cyt, 50)
-    quantile_50_distance_cyt /= factor
-
-    # compute average distances to cytoplasm centroid
-    factor = distance_cyt_centroid[distance_cyt > 0].mean()
-    distance_rna_cyt_centroid = distance_cyt_centroid[rna_coord_2d[:, 0],
-                                                      rna_coord_2d[:, 1]]
-    mean_distance_cyt_centroid = distance_rna_cyt_centroid.mean()
-    mean_distance_cyt_centroid /= factor
-
-    # compute average distances to nucleus
-    factor = distance_nuc[distance_cyt > 0].mean()
-    distance_rna_nuc = distance_nuc[rna_coord_2d[:, 0], rna_coord_2d[:, 1]]
-    mean_distance_nuc = distance_rna_nuc.mean() / factor
-
-    # compute average distances to nucleus centroid
-    factor = distance_nuc_centroid[distance_cyt > 0].mean()
-    distance_rna_nuc_centroid = distance_nuc_centroid[rna_coord_2d[:, 0],
-                                                      rna_coord_2d[:, 1]]
-    mean_distance_nuc_centroid = distance_rna_nuc_centroid.mean()
-    mean_distance_nuc_centroid /= factor
-
-    features = [mean_distance_cyt, quantile_5_distance_cyt,
-                quantile_10_distance_cyt, quantile_20_distance_cyt,
-                quantile_50_distance_cyt, mean_distance_cyt_centroid,
-                mean_distance_nuc, mean_distance_nuc_centroid]
-
-    return features
-
-
-def feature_in_out_nucleus_aubin(rna_coord, mask_nuc):
-    # compute the ratio between rna in and out nucleus
-    mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
-    rna_in = rna_coord[mask_rna_in]
-    rna_out = rna_coord[~mask_rna_in]
-    feature = len(rna_in) / max(len(rna_out), 1)
-
-    return feature
-
-
-def features_opening_aubin(opening_sizes, rna_coord, mask_cyt):
-    # get number of rna
-    nb_rna = len(rna_coord)
-
-    # apply opening operator and count the loss of rna
-    features = []
-    for size in opening_sizes:
-        s = disk(size, dtype=bool)
-        mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
-        mask_rna = mask_cyt_transformed[rna_coord[:, 1], rna_coord[:, 2]]
-        rna_after_opening = rna_coord[mask_rna]
-
-        nb_rna_after_opening = len(rna_after_opening)
-        diff_opening = (nb_rna - nb_rna_after_opening) / nb_rna
-        features.append(diff_opening)
-
-    return features
-
-
-def features_ripley_aubin(radii, rna_coord, cyt_coord, mask_cyt):
-    # compute corrected Ripley values for different radii
-    values = _ripley_values_2d(radii, rna_coord, mask_cyt)
-
-    # smooth them using moving average
-    smoothed_values = _moving_average(values, n=4)
-
-    # compute the gradients of these values
-    gradients = np.gradient(smoothed_values)
-
-    # compute features
-    index_max = np.argmax(smoothed_values)
-    max_radius = radii[index_max]
-    max_value = smoothed_values[index_max]
-    if index_max == 0:
-        max_gradient = gradients[0]
-    else:
-        max_gradient = max(gradients[:index_max])
-    if index_max == len(gradients) - 1:
-        min_gradient = gradients[-1]
-    else:
-        min_gradient = min(gradients[index_max:])
-    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
-    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
-    max_size_cell = np.max(distances_cell)
-    big_radius = int(max_size_cell / 4)
-    big_value = _ripley_values_2d([big_radius], rna_coord, mask_cyt)[0]
-    features = [max_value, max_gradient, min_gradient, monotony, big_value,
-                max_radius]
-
-    return features
-
-
-def _ripley_values_2d(radii, rna_coord, mask_cyt):
-    rna_coord_2d = rna_coord[:, 1:3]
-
-    # sort rna coordinates
-    sorted_indices = np.lexsort((rna_coord_2d[:, 1], rna_coord_2d[:, 0]))
-    rna_coord_2d_sorted = rna_coord_2d[sorted_indices]
-
-    # compute distance matrix between rna and rna density
-    distances = distance_matrix(rna_coord_2d_sorted, rna_coord_2d_sorted, p=2)
-    factor = len(rna_coord_2d_sorted) ** 2 / mask_cyt.sum()
-
-    # cast cytoplasm mask in np.uint8
-    mask_cyt_8bit = stack.cast_img_uint8(mask_cyt)
-
-    # for each radius, get neighbors and weight
-    values = []
-    for r in radii:
-        mask_distance = distances.copy()
-        mask_distance = mask_distance <= r
-        nb_neighbors = np.sum(mask_distance, axis=0) - 1
-        weights = stack.mean_filter(mask_cyt_8bit,
-                                    kernel_shape="disk",
-                                    kernel_size=r)
-        weights = weights.astype(np.float32) / 255.
-        rna_weights = weights[rna_coord_2d_sorted[:, 0],
-                              rna_coord_2d_sorted[:, 1]]
-        nb_neighbors_weighted = np.multiply(nb_neighbors, rna_weights)
-        value = nb_neighbors_weighted.sum() / factor
-        values.append(value)
-    values = np.array(values, dtype=np.float32)
-    values_corrected = np.sqrt(values / np.pi) - np.array(radii)
-
-    return values_corrected
-
-
-def _moving_average(a, n=4):
-    res = np.cumsum(a, dtype=np.float32)
-    res[n:] = res[n:] - res[:-n]
-    averaged_array = res[n - 1:] / n
-
-    return averaged_array
-
-
-def feature_polarization_aubin(distance_cyt, distance_cyt_centroid,
-                               centroid_rna):
-    # compute polarization index
-    factor = np.mean(distance_cyt_centroid[distance_cyt > 0])
-    distance_rna_cell = distance_cyt_centroid[centroid_rna[1], centroid_rna[2]]
-    feature = distance_rna_cell / factor
-
-    return feature
-
-
-def feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna):
-    rna_coord_2d = rna_coord[:, 1:3]
-    centroid_rna_2d = centroid_rna[1:]
-
-    # get coordinates of each pixel of the cell
-    mask_cyt_coord = np.nonzero(mask_cyt)
-    mask_cyt_coord = np.column_stack(mask_cyt_coord)
-
-    # compute dispersion index
-    sigma_rna = np.sum((rna_coord_2d - centroid_rna_2d) ** 2, axis=0)
-    sigma_rna = np.sum(sigma_rna / len(rna_coord_2d))
-    sigma_cell = np.sum((mask_cyt_coord - centroid_rna_2d) ** 2, axis=0)
-    sigma_cell = np.sum(sigma_cell / len(mask_cyt_coord))
-    feature = sigma_rna / sigma_cell
-
-    return feature
-
-
 # ### Other features ###
 
 def features_distance(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     # initialization
     rna_coord_out_2d = rna_coord_out[:, 1:3]
-    eps = stack.get_eps_float32()
 
     if len(rna_coord_out_2d) == 0:
-        features = [1., 0., 1., 0., 1., 0.] * 2
+        features = [1., 1., 1., 1.]
         return features
     features = []
 
@@ -634,41 +353,23 @@ def features_distance(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     distance_rna_cyt = distance_cyt[rna_coord_out_2d[:, 0],
                                     rna_coord_out_2d[:, 1]]
     factor = np.mean(distance_cyt[mask_cyt_out])
-    index_mean_distance_cyt = (np.mean(distance_rna_cyt) + eps) / factor
-    log2_index_mean_distance_cyt = np.log2(index_mean_distance_cyt)
+    index_mean_distance_cyt = np.mean(distance_rna_cyt) / factor
     factor = np.median(distance_cyt[mask_cyt_out])
-    index_median_distance_cyt = (np.median(distance_rna_cyt) + eps) / factor
-    log2_index_median_distance_cyt = np.log2(index_median_distance_cyt)
-    factor = np.std(distance_cyt[mask_cyt_out])
-    index_std_distance_cyt = (np.std(distance_rna_cyt) + eps) / factor
-    log2_index_std_distance_cyt = np.log2(index_std_distance_cyt)
+    index_median_distance_cyt = np.median(distance_rna_cyt) / factor
 
     features += [index_mean_distance_cyt,
-                 log2_index_mean_distance_cyt,
-                 index_median_distance_cyt,
-                 log2_index_median_distance_cyt,
-                 index_std_distance_cyt,
-                 log2_index_std_distance_cyt]
+                 index_median_distance_cyt]
 
     # compute statistics from distance to nucleus
     distance_rna_nuc = distance_nuc[rna_coord_out_2d[:, 0],
                                     rna_coord_out_2d[:, 1]]
     factor = np.mean(distance_nuc[mask_cyt_out])
-    index_mean_distance_nuc = (np.mean(distance_rna_nuc) + eps) / factor
-    log2_index_mean_distance_nuc = np.log2(index_mean_distance_nuc)
+    index_mean_distance_nuc = np.mean(distance_rna_nuc) / factor
     factor = np.median(distance_nuc[mask_cyt_out])
-    index_median_distance_nuc = (np.median(distance_rna_nuc) + eps) / factor
-    log2_index_median_distance_nuc = np.log2(index_median_distance_nuc)
-    factor = np.std(distance_nuc[mask_cyt_out])
-    index_std_distance_nuc = (np.std(distance_rna_nuc) + eps) / factor
-    log2_index_std_distance_nuc = np.log2(index_std_distance_nuc)
+    index_median_distance_nuc = np.median(distance_rna_nuc) / factor
 
     features += [index_mean_distance_nuc,
-                 log2_index_mean_distance_nuc,
-                 index_median_distance_nuc,
-                 log2_index_median_distance_nuc,
-                 index_std_distance_nuc,
-                 log2_index_std_distance_nuc]
+                 index_median_distance_nuc]
 
     return features
 
@@ -691,11 +392,10 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
     nb_rna_out = len(rna_coord_out)
     area_nuc = mask_nuc.sum()
     area_cyt_out = mask_cyt_out.sum()
-    eps = stack.get_eps_float32()
 
     # case where we do not detect any rna outside the nucleus
     if nb_rna_out == 0:
-        features = [0., np.log2(eps), 0.]
+        features = [0., 0.]
         return features
 
     # apply opening operator and count the loss of rna outside the nucleus
@@ -712,15 +412,13 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
                                             rna_coord_out[:, 2]]
             rna_after_opening = rna_coord_out[mask_rna]
             nb_rna_protrusion = nb_rna_out - len(rna_after_opening)
-            index_rna_opening = (nb_rna_protrusion + eps) / factor
-            log2_index_rna_opening = np.log2(index_rna_opening)
+            index_rna_opening = nb_rna_protrusion / factor
             proportion_rna_opening = nb_rna_protrusion / nb_rna_out
 
             features += [index_rna_opening,
-                         log2_index_rna_opening,
                          proportion_rna_opening]
         else:
-            features += [0., np.log2(eps), 0.]
+            features += [0., 0.]
 
     return features
 
@@ -748,15 +446,13 @@ def features_polarization(centroid_rna_out, centroid_cyt, centroid_nuc,
 
 def features_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
     # initialization
-    eps = stack.get_eps_float32()
-
     if len(rna_coord_out) == 0:
         features = [1., 0.]
         return features
 
     # get number of rna outside nucleus and cell area
     if mask_cyt_out.sum() == 0:
-        features = [1., 0.]
+        features = [1.]
         return features
 
     # get coordinates of each pixel of the cell
@@ -767,11 +463,9 @@ def features_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
     a = distance_rna_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
     b = distance_rna_centroid[cell_outside_nuc_coord[:, 0],
                               cell_outside_nuc_coord[:, 1]]
-    index_dispersion = (a.mean() + eps) / b.mean()
-    log2_index_dispersion = np.log2(index_dispersion)
+    index_dispersion = a.mean() / b.mean()
 
-    features = [index_dispersion,
-                log2_index_dispersion]
+    features = [index_dispersion]
 
     return features
 
@@ -779,10 +473,8 @@ def features_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
 def features_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
                                    mask_cyt_out):
     # initialization
-    eps = stack.get_eps_float32()
-
     if len(rna_coord_out) == 0:
-        features = [1., 0.]
+        features = [1.]
         return features
 
     # get number of rna outside nucleus and cell area
@@ -798,11 +490,9 @@ def features_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
     a = distance_cyt_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
     b = distance_cyt_centroid[cell_outside_nuc_coord[:, 0],
                               cell_outside_nuc_coord[:, 1]]
-    index_peripheral_dispersion = (a.mean() + eps) / b.mean()
-    log2_index_peripheral_dispersion = np.log2(index_peripheral_dispersion)
+    index_peripheral_dispersion = a.mean() / b.mean()
 
-    features = [index_peripheral_dispersion,
-                log2_index_peripheral_dispersion]
+    features = [index_peripheral_dispersion]
 
     return features
 
@@ -814,15 +504,12 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     cell_area = mask_cyt.sum()
     nb_rna = len(rna_coord)
     nb_rna_out = len(rna_coord_out)
-    eps = stack.get_eps_float32()
 
     # case where no mRNAs outside the nucleus are detected
     if nb_rna_out == 0:
-        features = [0., np.log2(eps), 0.]
-        features += [0., np.log2(eps), 0.] * 5
-        features += [0., np.log2(eps), 0.] * 2
-        features += [0., np.log2(eps), 0.] * 6
-        features += [0., np.log2(eps), 0.] * 3
+        features = [0., 0.]
+        features += [0., 0.] * 5
+        features += [0., 0.] * 6
         return features
 
     # build a distance map from nucleus border and from cytoplasm membrane
@@ -838,12 +525,10 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
     factor = nb_rna * max(mask_nuc_edge.sum(), 1) / cell_area
     mask_rna = mask_nuc_edge[rna_coord[:, 1], rna_coord[:, 2]]
     nb_rna_nuc_edge = len(rna_coord[mask_rna])
-    index_rna_nuc_edge = (nb_rna_nuc_edge + eps) / factor
-    log2_index_rna_nuc_edge = np.log2(index_rna_nuc_edge)
+    index_rna_nuc_edge = nb_rna_nuc_edge / factor
     proportion_rna_nuc_edge = nb_rna_nuc_edge / nb_rna
 
     features += [index_rna_nuc_edge,
-                 log2_index_rna_nuc_edge,
                  proportion_rna_nuc_edge]
 
     # count mRNAs in specific regions around nucleus (5-10, 10-15, 15-20,
@@ -858,31 +543,10 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
         factor = nb_rna * max(mask_nuc_radius.sum(), 1) / cell_area
         mask_rna = mask_nuc_radius[rna_coord[:, 1], rna_coord[:, 2]]
         nb_rna_nuc_radius = len(rna_coord[mask_rna])
-        index_rna_nuc_radius = (nb_rna_nuc_radius + eps) / factor
-        log2_index_rna_nuc_radius = np.log2(index_rna_nuc_radius)
+        index_rna_nuc_radius = nb_rna_nuc_radius / factor
         proportion_rna_nuc_radius = nb_rna_nuc_radius / nb_rna
 
         features += [index_rna_nuc_radius,
-                     log2_index_rna_nuc_radius,
-                     proportion_rna_nuc_radius]
-
-    # count mRNAs in specific regions around nucleus (5-15, 15-25)
-    mask_cumulated_radius = mask_nuc_edge.copy()
-    for radius in range(15, 26, 10):
-        mask_nuc_radius = distance_map_nuc < radius
-        mask_nuc_radius[~mask_cyt] = False
-        mask_nuc_radius[mask_nuc] = False
-        mask_nuc_radius[mask_cumulated_radius] = False
-        mask_cumulated_radius |= mask_nuc_radius
-        factor = nb_rna * max(mask_nuc_radius.sum(), 1) / cell_area
-        mask_rna = mask_nuc_radius[rna_coord[:, 1], rna_coord[:, 2]]
-        nb_rna_nuc_radius = len(rna_coord[mask_rna])
-        index_rna_nuc_radius = (nb_rna_nuc_radius + eps) / factor
-        log2_index_rna_nuc_radius = np.log2(index_rna_nuc_radius)
-        proportion_rna_nuc_radius = nb_rna_nuc_radius / nb_rna
-
-        features += [index_rna_nuc_radius,
-                     log2_index_rna_nuc_radius,
                      proportion_rna_nuc_radius]
 
     # count mRNAs in specific regions around cytoplasmic membrane (0-5, 5-10,
@@ -897,32 +561,10 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
         factor = nb_rna * max(mask_cyt_radius.sum(), 1) / cell_area
         mask_rna = mask_cyt_radius[rna_coord[:, 1], rna_coord[:, 2]]
         nb_rna_cyt_radius = len(rna_coord[mask_rna])
-        index_rna_cyt_radius = (nb_rna_cyt_radius + eps) / factor
-        log2_index_rna_cyt_radius = np.log2(index_rna_cyt_radius)
+        index_rna_cyt_radius = nb_rna_cyt_radius / factor
         proportion_rna_cyt_radius = nb_rna_cyt_radius / nb_rna
 
         features += [index_rna_cyt_radius,
-                     log2_index_rna_cyt_radius,
-                     proportion_rna_cyt_radius]
-
-    # count mRNAs in specific regions around cytoplasmic membrane (0-10, 10-20,
-    # 20-30)
-    mask_cumulated_radius = np.zeros_like(mask_nuc_edge)
-    for radius in range(10, 31, 10):
-        mask_cyt_radius = distance_map_cyt < radius
-        mask_cyt_radius[~mask_cyt] = False
-        mask_cyt_radius[mask_nuc] = False
-        mask_cyt_radius[mask_cumulated_radius] = False
-        mask_cumulated_radius |= mask_cyt_radius
-        factor = nb_rna * max(mask_cyt_radius.sum(), 1) / cell_area
-        mask_rna = mask_cyt_radius[rna_coord[:, 1], rna_coord[:, 2]]
-        nb_rna_cyt_radius = len(rna_coord[mask_rna])
-        index_rna_cyt_radius = (nb_rna_cyt_radius + eps) / factor
-        log2_index_rna_cyt_radius = np.log2(index_rna_cyt_radius)
-        proportion_rna_cyt_radius = nb_rna_cyt_radius / nb_rna
-
-        features += [index_rna_cyt_radius,
-                     log2_index_rna_cyt_radius,
                      proportion_rna_cyt_radius]
 
     return features
@@ -931,88 +573,25 @@ def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
 def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     # case where no mRNAs outside the nucleus are detected
     if len(rna_coord_out) == 0:
-        features = [0.] * 35 * 2
-        features += [1., 0., 0.] * 4
-        features += [1., 0., 1., 0., 1., 0.]
-        features += [1., 0., 1., 0., 1., 0.]
+        features = [0., 1., 1., 1., 1]
         return features
 
-    features = []
-    for foci_radius in [50, 150, 250, 350, 450, 550, 650]:
-        for min_foci_rna in [3, 4, 5, 6, 7]:
-            clustered_spots = detection.cluster_spots(
-                spots=rna_coord_out[:, :3],
-                resolution_z=300,
-                resolution_yx=103,
-                radius=foci_radius,
-                nb_min_spots=min_foci_rna)
-            foci = detection.extract_foci(clustered_spots=clustered_spots)
-            nb_foci = len(foci)
-            nb_spots_in_foci = np.sum(foci[:, 3])
-            proportion_rna_foci = nb_spots_in_foci / len(rna_coord_out)
-
-            features += [nb_foci,
-                         proportion_rna_foci]
-
     # case where no default foci are detected
     rna_coord_out_foci = rna_coord_out[rna_coord_out[:, 3] != -1, :]
     if len(rna_coord_out_foci) == 0:
-        features += [1., 0., 0.] * 4
-        features += [1., 0., 1., 0., 1., 0.]
-        features += [1., 0., 1., 0., 1., 0.]
+        features = [0., 1., 1., 1., 1]
         return features
 
+    # compute proportion of mRNAs in foci
+    nb_rna_in_foci = len(rna_coord_out_foci)
+    nb_rna = len(rna_coord_out)
+    proportion_rna_in_foci = nb_rna_in_foci / nb_rna
+
+    features = [proportion_rna_in_foci]
+
     # get regular foci id
     l_id_foci = list(set(rna_coord_out_foci[:, 3]))
 
-    # count mRNAs in successive 5 pixels foci neighbors
-    nb_rna_out = len(rna_coord_out)
-    cell_out_area = mask_cyt_out.sum()
-    mask_foci_neighbor_cumulated = np.zeros_like(mask_cyt_out)
-    eps = stack.get_eps_float32()
-
-    # we count mRNAs in the neighbors 0-5 pixels around the foci, 5-10 pixels,
-    # 10-15 pixels, and 15-20 pixels
-    for radius in range(5, 21, 5):
-        s = disk(radius).astype(bool)
-        mask_foci_neighbor = np.zeros_like(mask_cyt_out)
-
-        # for each foci, get a mask of its neighbor and merge them
-        for i in l_id_foci:
-            rna_foci_i = rna_coord_out_foci[rna_coord_out_foci[:, 3] == i, :3]
-            foci = np.mean(rna_foci_i, axis=0)
-            foci = np.round(foci).astype(np.int64)
-            row, col = foci[1], foci[2]
-            mask_neighbor = np.zeros_like(mask_cyt_out)
-            min_row = max(row - radius, 0)
-            min_row_s = min_row - (row - radius)
-            max_row = min(row + radius + 1, mask_neighbor.shape[0])
-            max_row_s = s.shape[0] - ((row + radius + 1) - max_row)
-            min_col = max(col - radius, 0)
-            min_col_s = min_col - (col - radius)
-            max_col = min(col + radius + 1, mask_neighbor.shape[1])
-            max_col_s = s.shape[1] - ((col + radius + 1) - max_col)
-            new_s = s[min_row_s:max_row_s, min_col_s:max_col_s]
-            mask_neighbor[min_row:max_row, min_col:max_col] = new_s
-            mask_foci_neighbor |= mask_cyt_out & mask_neighbor
-
-        # remove neighbor mask from previous radius
-        mask_foci_neighbor[mask_foci_neighbor_cumulated] = False
-        mask_foci_neighbor_cumulated |= mask_foci_neighbor
-
-        # count mRNAs in such a region
-        mask_rna = mask_foci_neighbor[rna_coord_out[:, 1], rna_coord_out[:, 2]]
-        nb_rna_foci_neighbor = len(rna_coord_out[mask_rna])
-        area_foci_neighbor = mask_foci_neighbor.sum()
-        factor = nb_rna_out * max(area_foci_neighbor, 1) / cell_out_area
-        index_rna_foci_neighbor = (nb_rna_foci_neighbor + eps) / factor
-        log2_index_rna_foci_neighbor = np.log2(index_rna_foci_neighbor)
-        proportion_rna_foci_neighbor = nb_rna_foci_neighbor / nb_rna_out
-
-        features += [index_rna_foci_neighbor,
-                     log2_index_rna_foci_neighbor,
-                     proportion_rna_foci_neighbor]
-
     # get foci coordinates
     foci_coord = []
     for i in l_id_foci:
@@ -1027,41 +606,23 @@ def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
     # compute statistics from distance to cytoplasm
     distance_foci_cyt = distance_cyt[foci_coord_2d[:, 0], foci_coord_2d[:, 1]]
     factor = np.mean(distance_cyt[mask_cyt_out])
-    index_foci_mean_distance_cyt = (np.mean(distance_foci_cyt) + eps) / factor
-    log2_index_foci_mean_distance_cyt = np.log2(index_foci_mean_distance_cyt)
+    index_foci_mean_distance_cyt = np.mean(distance_foci_cyt) / factor
     factor = np.median(distance_cyt[mask_cyt_out])
-    index_foci_med_distance_cyt = (np.median(distance_foci_cyt) + eps) / factor
-    log2_index_foci_med_distance_cyt = np.log2(index_foci_med_distance_cyt)
-    factor = np.std(distance_cyt[mask_cyt_out])
-    index_foci_std_distance_cyt = (np.std(distance_foci_cyt) + eps) / factor
-    log2_index_foci_std_distance_cyt = np.log2(index_foci_std_distance_cyt)
+    index_foci_med_distance_cyt = np.median(distance_foci_cyt) / factor
 
     features += [index_foci_mean_distance_cyt,
-                 log2_index_foci_mean_distance_cyt,
-                 index_foci_med_distance_cyt,
-                 log2_index_foci_med_distance_cyt,
-                 index_foci_std_distance_cyt,
-                 log2_index_foci_std_distance_cyt]
+                 index_foci_med_distance_cyt]
 
     # compute statistics from distance to nucleus
     distance_foci_nuc = distance_nuc[foci_coord_2d[:, 0],
                                      foci_coord_2d[:, 1]]
     factor = np.mean(distance_nuc[mask_cyt_out])
-    index_foci_mean_distance_nuc = (np.mean(distance_foci_nuc) + eps) / factor
-    log2_index_foci_mean_distance_nuc = np.log2(index_foci_mean_distance_nuc)
+    index_foci_mean_distance_nuc = np.mean(distance_foci_nuc) / factor
     factor = np.median(distance_nuc[mask_cyt_out])
-    index_foci_med_distance_nuc = (np.median(distance_foci_nuc) + eps) / factor
-    log2_index_foci_med_distance_nuc = np.log2(index_foci_med_distance_nuc)
-    factor = np.std(distance_nuc[mask_cyt_out])
-    index_foci_std_distance_nuc = (np.std(distance_foci_nuc) + eps) / factor
-    log2_index_foci_std_distance_nuc = np.log2(index_foci_std_distance_nuc)
+    index_foci_med_distance_nuc = np.median(distance_foci_nuc) / factor
 
     features += [index_foci_mean_distance_nuc,
-                 log2_index_foci_mean_distance_nuc,
-                 index_foci_med_distance_nuc,
-                 log2_index_foci_med_distance_nuc,
-                 index_foci_std_distance_nuc,
-                 log2_index_foci_std_distance_nuc]
+                 index_foci_med_distance_nuc]
 
     return features
 
diff --git a/bigfish/classification/features_old.py b/bigfish/classification/features_old.py
index 2f059d38..c40a6f94 100644
--- a/bigfish/classification/features_old.py
+++ b/bigfish/classification/features_old.py
@@ -4,7 +4,8 @@
 Functions to craft features.
 """
 
-from bigfish import stack
+import bigfish.stack as stack
+import bigfish.detection as detection
 
 import numpy as np
 from scipy import ndimage as ndi
@@ -16,55 +17,344 @@
 from scipy.spatial import distance_matrix
 from scipy.stats import spearmanr
 
+# TODO add sanity check functions
+# TODO add documentation
+# TODO allow to return intermediate results (distance map, etc.)
+# TODO round float results
+
+
+def get_features(cyt_coord, nuc_coord, rna_coord,
+                 compute_aubin=False,
+                 compute_distance=True,
+                 compute_intranuclear=True,
+                 compute_protrusion=True,
+                 compute_dispersion=True,
+                 compute_topography=True,
+                 compute_foci=True,
+                 compute_area=True):
+    """Compute cell features.
+
+    Parameters
+    ----------
+    cyt_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    nuc_coord : np.ndarray, np.int64
+        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
+    rna_coord : np.ndarray, np.int64
+        Coordinate zyx of the detected rna, plus the index of a potential foci.
+        Shape (nb_rna, 4).
+    compute_aubin : bool
+        Compute features from Aubin paper.
+    compute_distance : bool
+        Compute features related to distances from nucleus or cytoplasmic
+        membrane.
+    compute_intranuclear : bool
+        Compute features related to intranuclear pattern.
+    compute_protrusion : bool
+        Compute features related to protrusion pattern.
+    compute_dispersion : bool
+        Compute features to quantify mRNAs dispersion within the cell.
+    compute_topography : bool
+        Compute topographic features of the cell.
+    compute_foci : bool
+        Compute features related to foci pattern.
+    compute_area : bool
+        Compute features related to area of the cell.
+
+    Returns
+    -------
+    features : List[float]
+        List of features (cf. features.get_features_name()).
 
-def from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord):
     """
+    features = []
+
+    # prepare input data
+    (mask_cyt, mask_nuc, mask_cyt_out,
+     distance_cyt, distance_nuc,
+     distance_cyt_normalized, distance_nuc_normalized,
+     rna_coord_out,
+     centroid_cyt, centroid_nuc,
+     centroid_rna, centroid_rna_out,
+     distance_cyt_centroid, distance_nuc_centroid,
+     distance_rna_out_centroid) = prepare_coordinate_data(cyt_coord,
+                                                          nuc_coord,
+                                                          rna_coord)
+
+    # features from Aubin's paper
+    if compute_aubin:
+        a = features_distance_aubin(rna_coord,
+                                    distance_cyt_normalized,
+                                    distance_nuc_normalized,
+                                    distance_cyt_centroid,
+                                    distance_nuc_centroid)
+        b = feature_in_out_nucleus_aubin(rna_coord, mask_nuc)
+        opening_sizes = [15, 30, 45, 60]
+        c = features_opening_aubin(opening_sizes, rna_coord, mask_cyt)
+        radii = [r for r in range(40)]
+        d = features_ripley_aubin(radii, rna_coord, cyt_coord, mask_cyt)
+        e = feature_polarization_aubin(distance_cyt_normalized,
+                                       distance_cyt_centroid,
+                                       centroid_rna)
+        f = feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna)
+
+        features += a + [b] + c + d + [e] + [f]
+
+    # distances related features
+    if compute_distance:
+        aa = features_distance(rna_coord_out,
+                               distance_cyt,
+                               distance_nuc,
+                               mask_cyt_out)
+
+        features += aa
+
+    # intranuclear related features
+    if compute_intranuclear:
+        bb = features_in_out_nucleus(rna_coord,
+                                     rna_coord_out)
+
+        features += bb
+
+    # intranuclear related features
+    if compute_protrusion:
+        cc = features_protrusion(rna_coord_out,
+                                 mask_cyt,
+                                 mask_nuc,
+                                 mask_cyt_out)
+
+        features += cc
+
+    # dispersion measures
+    if compute_dispersion:
+        dd = features_polarization(centroid_rna_out,
+                                   centroid_cyt,
+                                   centroid_nuc,
+                                   distance_cyt_centroid,
+                                   distance_nuc_centroid)
+        ee = features_dispersion(rna_coord_out,
+                                 distance_rna_out_centroid,
+                                 mask_cyt_out)
+        ff = features_peripheral_dispersion(rna_coord_out,
+                                            distance_cyt_centroid,
+                                            mask_cyt_out)
+
+        features += dd + ee + ff
+
+    # topographic features
+    if compute_topography:
+        gg = features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
+                                 mask_cyt_out)
+
+        features += gg
+
+    # foci related features
+    if compute_foci:
+        hh = features_foci(rna_coord_out,
+                           distance_cyt,
+                           distance_nuc,
+                           mask_cyt_out)
+
+        features += hh
+
+    # area related features
+    if compute_area:
+        ii = features_area(mask_cyt, mask_nuc, mask_cyt_out)
+
+        features += ii
+
+    features = np.array(features, dtype=np.float32)
+    features = np.round(features, decimals=2)
+
+    return features
+
+
+def get_features_name(names_features_aubin=False,
+                      names_features_distance=True,
+                      names_features_intranuclear=True,
+                      names_features_protrusion=True,
+                      names_features_dispersion=True,
+                      names_features_topography=True,
+                      names_features_foci=True,
+                      names_features_area=True):
+    """Return the current list of features names.
 
     Parameters
     ----------
-    cyt_coord
-    nuc_coord
-    rna_coord
+    names_features_aubin : bool
+        Return names of features from Aubin paper.
+    names_features_distance : bool
+        Return names of features related to distances from nucleus or
+        cytoplasmic membrane.
+    names_features_intranuclear : bool
+        Return names of features related to intranuclear pattern.
+    names_features_protrusion : bool
+        Return names of features related to protrusion pattern.
+    names_features_dispersion : bool
+        Return names of features used to quantify mRNAs dispersion within the
+        cell.
+    names_features_topography : bool
+        Return names of topographic features of the cell.
+    names_features_foci : bool
+        Return names of features related to foci pattern.
+    names_features_area : bool
+        Return names of features related to area of the cell.
 
     Returns
     -------
+    features_name : List[str]
+        A list of features name.
 
     """
-    # TODO add sanity check functions
-    # TODO add documentation
+    features_name = []
+
+    if names_features_aubin:
+        features_name += ["aubin_average_dist_cyt",
+                          "aubin_quantile_5_dist_cyt",
+                          "aubin_quantile_10_dist_cyt",
+                          "aubin_quantile_20_dist_cyt",
+                          "aubin_quantile_50_dist_cyt",
+                          "aubin_average_dist_cyt_centroid",
+                          "aubin_average_dist_nuc",
+                          "aubin_average_dist_nuc_centroid",
+                          "aubin_ratio_in_nuc",
+                          "aubin_diff_opening_15",
+                          "aubin_diff_opening_30",
+                          "aubin_diff_opening_45",
+                          "aubin_diff_opening_60",
+                          "aubin_ripley_max",
+                          "aubin_ripley_max_gradient",
+                          "aubin_ripley_min_gradient",
+                          "aubin_ripley_monotony",
+                          "aubin_ripley_mid_cell",
+                          "aubin_ripley_max_radius",
+                          "aubin_polarization_index",
+                          "aubin_dispersion_index"]
+
+    if names_features_distance:
+        features_name += ["index_mean_distance_cyt",
+                          "log2_index_mean_distance_cyt",
+                          "index_median_distance_cyt",
+                          "log2_index_median_distance_cyt",
+                          "index_std_distance_cyt",
+                          "log2_index_std_distance_cyt",
+                          "index_mean_distance_nuc",
+                          "log2_index_mean_distance_nuc",
+                          "index_median_distance_nuc",
+                          "log2_index_median_distance_nuc",
+                          "index_std_distance_nuc",
+                          "log2_index_std_distance_nuc"]
+
+    if names_features_intranuclear:
+        features_name += ["proportion_rna_in_nuc",
+                          "nb_rna_out",
+                          "nb_rna_in"]
+
+    if names_features_protrusion:
+        features_name += ["index_rna_opening_30",
+                          "log2_index_rna_opening_30",
+                          "proportion_rna_opening_30"]
+
+    if names_features_dispersion:
+        features_name += ["score_polarization_cyt",
+                          "score_polarization_nuc",
+                          "index_dispersion",
+                          "log2_index_dispersion",
+                          "index_peripheral_dispersion",
+                          "log2_index_peripheral_dispersion"]
+
+    if names_features_topography:
+        features_name += ["index_rna_nuc_edge",
+                          "log2_index_rna_nuc_edge",
+                          "proportion_rna_nuc_edge"]
+
+        a = 5
+        for b in range(10, 31, 5):
+            features_name += ["index_rna_nuc_radius_{}_{}".format(a, b),
+                              "log2_index_rna_nuc_radius_{}_{}".format(a, b),
+                              "proportion_rna_nuc_radius_{}_{}".format(a, b)]
+            a = b
+
+        a = 5
+        for b in range(15, 26, 10):
+            features_name += ["index_rna_nuc_radius_{}_{}".format(a, b),
+                              "log2_index_rna_nuc_radius_{}_{}".format(a, b),
+                              "proportion_rna_nuc_radius_{}_{}".format(a, b)]
+            a = b
+
+        a = 0
+        for b in range(5, 31, 5):
+            features_name += ["index_rna_cyt_radius_{}_{}".format(a, b),
+                              "log2_index_rna_cyt_radius_{}_{}".format(a, b),
+                              "proportion_rna_cyt_radius_{}_{}".format(a, b)]
+            a = b
+
+        a = 0
+        for b in range(10, 31, 10):
+            features_name += ["index_rna_cyt_radius_{}_{}".format(a, b),
+                              "log2_index_rna_cyt_radius_{}_{}".format(a, b),
+                              "proportion_rna_cyt_radius_{}_{}".format(a, b)]
+            a = b
+
+    if names_features_foci:
+        for a in [50, 150, 250, 350, 450, 550, 650]:
+            for b in [3, 4, 5, 6, 7]:
+                features_name += ["nb_foci_{0}nm_{1}".format(a, b),
+                                  "proportion_rna_foci_{0}nm_{1}".format(a, b)]
+
+        a = 0
+        for b in range(5, 21, 5):
+            features_name += ["index_rna_foci_radius_{0}_{1}".format(a, b),
+                              "log2_index_rna_foci_radius_{0}_{1}".format(a,
+                                                                          b),
+                              "proportion_rna_foci_radius_{0}_{1}".format(a,
+                                                                          b)]
+            a = b
+
+        features_name += ["index_foci_mean_distance_cyt",
+                          "log2_index_foci_mean_distance_cyt",
+                          "index_foci_median_distance_cyt",
+                          "log2_index_foci_median_distance_cyt",
+                          "index_foci_std_distance_cyt",
+                          "log2_index_foci_std_distance_cyt",
+                          "index_foci_mean_distance_nuc",
+                          "log2_index_foci_mean_distance_nuc",
+                          "index_foci_median_distance_nuc",
+                          "log2_index_foci_median_distance_nuc",
+                          "index_foci_std_distance_nuc",
+                          "log2_index_foci_std_distance_nuc"]
+
+    if names_features_area:
+        features_name += ["proportion_nuc_area",
+                          "area_cyt",
+                          "area_nuc",
+                          "area_cyt_out"]
+
+    return features_name
+
+
+# ### Prepare the data ###
+
+def from_coord_to_matrix(cyt_coord, nuc_coord):
     # get size of the frame
-    max_y = cyt_coord[:, 0].max() + 1
-    max_x = cyt_coord[:, 1].max() + 1
+    max_y = cyt_coord[:, 0].max() + stack.get_offset_value() * 2
+    max_x = cyt_coord[:, 1].max() + stack.get_offset_value() * 2
     image_shape = (max_y, max_x)
 
     # cytoplasm
     cyt = np.zeros(image_shape, dtype=bool)
-    cyt[cyt_coord[:, 0], cyt_coord[:, 1]] = True
+    cyt[cyt_coord[:, 0] + stack.get_offset_value(),
+        cyt_coord[:, 1] + stack.get_offset_value()] = True
 
     # nucleus
     nuc = np.zeros(image_shape, dtype=bool)
-    nuc[nuc_coord[:, 0], nuc_coord[:, 1]] = True
-
-    # rna
-    rna = np.zeros(image_shape, dtype=bool)
-    rna[rna_coord[:, 0], rna_coord[:, 1]] = True
-
-    return cyt, nuc, rna
-
-
-def get_centroid(mask):
-    """
+    nuc[nuc_coord[:, 0] + stack.get_offset_value(),
+        nuc_coord[:, 1] + stack.get_offset_value()] = True
 
-    Parameters
-    ----------
-    mask
+    return cyt, nuc
 
-    Returns
-    -------
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
+def get_centroid_surface(mask):
     # get centroid
     region = regionprops(mask.astype(np.uint8))[0]
     centroid = np.array(region.centroid, dtype=np.int64)
@@ -72,130 +362,119 @@ def get_centroid(mask):
     return centroid
 
 
-def get_centroid_distance_map(centroid_coordinate, mask_cyt):
-    """
+def get_centroid_rna(rna_coord):
+    # get rna centroids
+    centroid_rna = np.mean(rna_coord[:, :3], axis=0, dtype=np.int64)
+    return centroid_rna
 
-    Parameters
-    ----------
-    centroid_coordinate
-    mask_cyt
 
-    Returns
-    -------
+def get_centroid_distance_map(centroid_coordinate, mask_cyt):
+    if centroid_coordinate.size == 3:
+        centroid_coordinate_2d = centroid_coordinate[1:]
+    else:
+        centroid_coordinate_2d = centroid_coordinate.copy()
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
     # get mask centroid
     mask_centroid = np.zeros_like(mask_cyt)
-    mask_centroid[centroid_coordinate[0], centroid_coordinate[1]] = True
+    mask_centroid[centroid_coordinate_2d[0], centroid_coordinate_2d[1]] = True
 
     # compute distance map
     distance_map = ndi.distance_transform_edt(~mask_centroid)
+    distance_map[mask_cyt == 0] = 0
     distance_map = distance_map.astype(np.float32)
 
     return distance_map
 
 
-def features_distance(mask_rna_out, distance_cyt, distance_nuc,
-                      distance_cyt_centroid, distance_nuc_centroid):
-    """
-
-    Parameters
-    ----------
-    mask_rna_out
-    distance_cyt
-    distance_nuc
-    distance_cyt_centroid
-    distance_nuc_centroid
-
-    Returns
-    -------
+def prepare_coordinate_data(cyt_coord, nuc_coord, rna_coord):
+    # get a binary representation of the coordinates
+    cyt, nuc = from_coord_to_matrix(cyt_coord, nuc_coord)
+    rna_coord[:, 1:3] += stack.get_offset_value()
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    if mask_rna_out.sum() == 0:
-        features = [1., 1., 1., 1., 1., 1., 1., 1.]
-        return features
+    # fill in masks
+    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
 
-    # compute average distances to cytoplasm and quantiles
-    factor = distance_cyt[distance_nuc > 0].mean()
-    mean_distance_cyt = distance_cyt[mask_rna_out].mean() / factor
-    quantile_5_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 5)
-    quantile_5_distance_cyt /= factor
-    quantile_10_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 10)
-    quantile_10_distance_cyt /= factor
-    quantile_20_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 20)
-    quantile_20_distance_cyt /= factor
-    quantile_50_distance_cyt = np.percentile(distance_cyt[mask_rna_out], 50)
-    quantile_50_distance_cyt /= factor
+    # get mask cytoplasm outside nucleus
+    mask_cyt_out = mask_cyt.copy()
+    mask_cyt_out[mask_nuc] = False
 
-    # compute average distances to cytoplasm centroid
-    factor = distance_cyt_centroid[distance_nuc > 0].mean()
-    mean_distance_cyt_centroid = distance_cyt_centroid[mask_rna_out].mean()
-    mean_distance_cyt_centroid /= factor
+    # compute distance maps for the cytoplasm and the nucleus
+    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc,
+                                                           normalized=False)
 
-    # compute average distances to nucleus
-    factor = distance_nuc[distance_nuc > 0].mean()
-    mean_distance_nuc = distance_nuc[mask_rna_out].mean() / factor
+    # normalize distance maps between 0 and 1
+    distance_cyt_normalized = distance_cyt / distance_cyt.max()
+    distance_cyt_normalized = stack.cast_img_float32(distance_cyt_normalized)
+    distance_nuc_normalized = distance_nuc / distance_nuc.max()
+    distance_nuc_normalized = stack.cast_img_float32(distance_nuc_normalized)
 
-    # compute average distances to nucleus centroid
-    factor = distance_nuc_centroid[distance_nuc > 0].mean()
-    mean_distance_nuc_centroid = distance_nuc_centroid[mask_rna_out].mean()
-    mean_distance_nuc_centroid /= factor
+    # get rna outside nucleus
+    mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_coord_out = rna_coord[~mask_rna_in]
 
-    features = [mean_distance_cyt, quantile_5_distance_cyt,
-                quantile_10_distance_cyt, quantile_20_distance_cyt,
-                quantile_50_distance_cyt, mean_distance_cyt_centroid,
-                mean_distance_nuc, mean_distance_nuc_centroid]
+    # get centroids
+    centroid_cyt = get_centroid_surface(mask_cyt)
+    centroid_nuc = get_centroid_surface(mask_nuc)
+    centroid_rna = get_centroid_rna(rna_coord)
+    if len(rna_coord_out) == 0:
+        centroid_rna_out = centroid_cyt.copy()
+    else:
+        centroid_rna_out = get_centroid_rna(rna_coord_out)
 
-    return features
+    # get centroid distance maps
+    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
+    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+    distance_rna_out_centroid = get_centroid_distance_map(centroid_rna_out,
+                                                          mask_cyt)
 
+    prepared_inputs = (mask_cyt, mask_nuc, mask_cyt_out,
+                       distance_cyt, distance_nuc,
+                       distance_cyt_normalized, distance_nuc_normalized,
+                       rna_coord_out,
+                       centroid_cyt, centroid_nuc,
+                       centroid_rna, centroid_rna_out,
+                       distance_cyt_centroid, distance_nuc_centroid,
+                       distance_rna_out_centroid)
 
-def features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
-                            distance_cyt_centroid, distance_nuc_centroid):
-    """
+    return prepared_inputs
 
-    Parameters
-    ----------
-    mask_rna
-    distance_cyt
-    distance_nuc
-    distance_cyt_centroid
-    distance_nuc_centroid
 
-    Returns
-    -------
+# ### Aubin's features ###
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
+def features_distance_aubin(rna_coord, distance_cyt, distance_nuc,
+                            distance_cyt_centroid, distance_nuc_centroid):
+    rna_coord_2d = rna_coord[:, 1:3]
 
     # compute average distances to cytoplasm and quantiles
     factor = distance_cyt[distance_cyt > 0].mean()
-    mean_distance_cyt = distance_cyt[mask_rna].mean() / factor
-    quantile_5_distance_cyt = np.percentile(distance_cyt[mask_rna], 5)
+    distance_rna_cyt = distance_cyt[rna_coord_2d[:, 0], rna_coord_2d[:, 1]]
+    mean_distance_cyt = distance_rna_cyt.mean() / factor
+    quantile_5_distance_cyt = np.percentile(distance_rna_cyt, 5)
     quantile_5_distance_cyt /= factor
-    quantile_10_distance_cyt = np.percentile(distance_cyt[mask_rna], 10)
+    quantile_10_distance_cyt = np.percentile(distance_rna_cyt, 10)
     quantile_10_distance_cyt /= factor
-    quantile_20_distance_cyt = np.percentile(distance_cyt[mask_rna], 20)
+    quantile_20_distance_cyt = np.percentile(distance_rna_cyt, 20)
     quantile_20_distance_cyt /= factor
-    quantile_50_distance_cyt = np.percentile(distance_cyt[mask_rna], 50)
+    quantile_50_distance_cyt = np.percentile(distance_rna_cyt, 50)
     quantile_50_distance_cyt /= factor
 
     # compute average distances to cytoplasm centroid
     factor = distance_cyt_centroid[distance_cyt > 0].mean()
-    mean_distance_cyt_centroid = distance_cyt_centroid[mask_rna].mean()
+    distance_rna_cyt_centroid = distance_cyt_centroid[rna_coord_2d[:, 0],
+                                                      rna_coord_2d[:, 1]]
+    mean_distance_cyt_centroid = distance_rna_cyt_centroid.mean()
     mean_distance_cyt_centroid /= factor
 
     # compute average distances to nucleus
     factor = distance_nuc[distance_cyt > 0].mean()
-    mean_distance_nuc = distance_nuc[mask_rna].mean() / factor
+    distance_rna_nuc = distance_nuc[rna_coord_2d[:, 0], rna_coord_2d[:, 1]]
+    mean_distance_nuc = distance_rna_nuc.mean() / factor
 
     # compute average distances to nucleus centroid
     factor = distance_nuc_centroid[distance_cyt > 0].mean()
-    mean_distance_nuc_centroid = distance_nuc_centroid[mask_rna].mean()
+    distance_rna_nuc_centroid = distance_nuc_centroid[rna_coord_2d[:, 0],
+                                                      rna_coord_2d[:, 1]]
+    mean_distance_nuc_centroid = distance_rna_nuc_centroid.mean()
     mean_distance_nuc_centroid /= factor
 
     features = [mean_distance_cyt, quantile_5_distance_cyt,
@@ -206,139 +485,78 @@ def features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
     return features
 
 
-def feature_in_out_nucleus(mask_nuc, mask_rna):
-    """
-
-    Parameters
-    ----------
-    mask_nuc
-    mask_rna
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # compute the proportion of rna in the nucleus
-    rna_in = mask_rna[mask_nuc].sum()
-    nb_rna = mask_rna.sum()
-    feature = rna_in / nb_rna
-
-    return feature
-
-
-def feature_in_out_nucleus_aubin(mask_nuc, mask_rna, mask_rna_out):
-    """
-
-    Parameters
-    ----------
-    mask_nuc
-    mask_rna
-    mask_rna_out
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
+def feature_in_out_nucleus_aubin(rna_coord, mask_nuc):
     # compute the ratio between rna in and out nucleus
-    rna_in = mask_rna[mask_nuc].sum()
-    rna_out = max(mask_rna_out.sum(), 1)
-    feature = rna_in / rna_out
+    mask_rna_in = mask_nuc[rna_coord[:, 1], rna_coord[:, 2]]
+    rna_in = rna_coord[mask_rna_in]
+    rna_out = rna_coord[~mask_rna_in]
+    feature = len(rna_in) / max(len(rna_out), 1)
 
     return feature
 
 
-def features_opening(opening_sizes, mask_cyt, mask_rna_out):
-    """
-
-    Parameters
-    ----------
-    opening_sizes
-    mask_cyt
-    mask_rna_out
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # get number of rna outside nucleus
-    nb_rna_out = mask_rna_out.sum()
-
-    # case where we do not detect any rna outside the nucleus
-    if nb_rna_out == 0:
-        features = [0. for _ in opening_sizes]
-        return features
+def features_opening_aubin(opening_sizes, rna_coord, mask_cyt):
+    # get number of rna
+    nb_rna = len(rna_coord)
 
-    # apply opening operator and count the loss of rna outside the nucleus
+    # apply opening operator and count the loss of rna
     features = []
     for size in opening_sizes:
         s = disk(size, dtype=bool)
         mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
-        nb_rna_out_after_opening = mask_rna_out[mask_cyt_transformed > 0].sum()
-        diff_opening = (nb_rna_out - nb_rna_out_after_opening) / nb_rna_out
+        mask_rna = mask_cyt_transformed[rna_coord[:, 1], rna_coord[:, 2]]
+        rna_after_opening = rna_coord[mask_rna]
+
+        nb_rna_after_opening = len(rna_after_opening)
+        diff_opening = (nb_rna - nb_rna_after_opening) / nb_rna
         features.append(diff_opening)
 
     return features
 
 
-def features_opening_aubin(opening_sizes, mask_cyt, mask_rna):
-    """
-
-    Parameters
-    ----------
-    opening_sizes
-    mask_cyt
-    mask_rna
+def features_ripley_aubin(radii, rna_coord, cyt_coord, mask_cyt):
+    # compute corrected Ripley values for different radii
+    values = _ripley_values_2d(radii, rna_coord, mask_cyt)
 
-    Returns
-    -------
+    # smooth them using moving average
+    smoothed_values = _moving_average(values, n=4)
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # get number of rna
-    nb_rna = mask_rna.sum()
+    # compute the gradients of these values
+    gradients = np.gradient(smoothed_values)
 
-    # apply opening operator and count the loss of rna
-    features = []
-    for size in opening_sizes:
-        s = disk(size, dtype=bool)
-        mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
-        nb_rna__after_opening = mask_rna[mask_cyt_transformed > 0].sum()
-        diff_opening = (nb_rna - nb_rna__after_opening) / nb_rna
-        features.append(diff_opening)
+    # compute features
+    index_max = np.argmax(smoothed_values)
+    max_radius = radii[index_max]
+    max_value = smoothed_values[index_max]
+    if index_max == 0:
+        max_gradient = gradients[0]
+    else:
+        max_gradient = max(gradients[:index_max])
+    if index_max == len(gradients) - 1:
+        min_gradient = gradients[-1]
+    else:
+        min_gradient = min(gradients[index_max:])
+    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
+    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
+    max_size_cell = np.max(distances_cell)
+    big_radius = int(max_size_cell / 4)
+    big_value = _ripley_values_2d([big_radius], rna_coord, mask_cyt)[0]
+    features = [max_value, max_gradient, min_gradient, monotony, big_value,
+                max_radius]
 
     return features
 
 
-def ripley_values(radii, mask_cyt, rna_coord, mask_rna):
-    """
-
-    Parameters
-    ----------
-    radii
-    mask_cyt
-    rna_coord
-    mask_rna
-
-    Returns
-    -------
+def _ripley_values_2d(radii, rna_coord, mask_cyt):
+    rna_coord_2d = rna_coord[:, 1:3]
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
     # sort rna coordinates
-    sorted_indices = np.lexsort((rna_coord[:, 1], rna_coord[:, 0]))
-    rna_coord = rna_coord[sorted_indices]
+    sorted_indices = np.lexsort((rna_coord_2d[:, 1], rna_coord_2d[:, 0]))
+    rna_coord_2d_sorted = rna_coord_2d[sorted_indices]
 
     # compute distance matrix between rna and rna density
-    distances = distance_matrix(rna_coord, rna_coord, p=2)
-    factor = len(rna_coord) ** 2 / mask_cyt.sum()
+    distances = distance_matrix(rna_coord_2d_sorted, rna_coord_2d_sorted, p=2)
+    factor = len(rna_coord_2d_sorted) ** 2 / mask_cyt.sum()
 
     # cast cytoplasm mask in np.uint8
     mask_cyt_8bit = stack.cast_img_uint8(mask_cyt)
@@ -349,10 +567,12 @@ def ripley_values(radii, mask_cyt, rna_coord, mask_rna):
         mask_distance = distances.copy()
         mask_distance = mask_distance <= r
         nb_neighbors = np.sum(mask_distance, axis=0) - 1
-        weights = stack.mean_filter(mask_cyt_8bit, kernel_shape="disk",
+        weights = stack.mean_filter(mask_cyt_8bit,
+                                    kernel_shape="disk",
                                     kernel_size=r)
         weights = weights.astype(np.float32) / 255.
-        rna_weights = weights[mask_rna]
+        rna_weights = weights[rna_coord_2d_sorted[:, 0],
+                              rna_coord_2d_sorted[:, 1]]
         nb_neighbors_weighted = np.multiply(nb_neighbors, rna_weights)
         value = nb_neighbors_weighted.sum() / factor
         values.append(value)
@@ -362,20 +582,7 @@ def ripley_values(radii, mask_cyt, rna_coord, mask_rna):
     return values_corrected
 
 
-def moving_average(a, n=4):
-    """
-
-    Parameters
-    ----------
-    a
-    n
-
-    Returns
-    -------
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
+def _moving_average(a, n=4):
     res = np.cumsum(a, dtype=np.float32)
     res[n:] = res[n:] - res[:-n]
     averaged_array = res[n - 1:] / n
@@ -383,341 +590,494 @@ def moving_average(a, n=4):
     return averaged_array
 
 
-def features_ripley(radii, cyt_coord, mask_cyt, rna_coord_out, mask_rna_out):
-    """
+def feature_polarization_aubin(distance_cyt, distance_cyt_centroid,
+                               centroid_rna):
+    # compute polarization index
+    factor = np.mean(distance_cyt_centroid[distance_cyt > 0])
+    distance_rna_cell = distance_cyt_centroid[centroid_rna[1], centroid_rna[2]]
+    feature = distance_rna_cell / factor
 
-    Parameters
-    ----------
-    radii
-    cyt_coord
-    mask_cyt
-    rna_coord_out
-    mask_rna_out
+    return feature
 
-    Returns
-    -------
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # case where we do not detect any rna outside the nucleus
-    if len(rna_coord_out) == 0:
-        features = [0., 0., 0., 0., 0., 0.]
-        return features
+def feature_dispersion_aubin(rna_coord, mask_cyt, centroid_rna):
+    rna_coord_2d = rna_coord[:, 1:3]
+    centroid_rna_2d = centroid_rna[1:]
 
-    # compute corrected Ripley values for different radii
-    values = ripley_values(radii, mask_cyt, rna_coord_out, mask_rna_out)
+    # get coordinates of each pixel of the cell
+    mask_cyt_coord = np.nonzero(mask_cyt)
+    mask_cyt_coord = np.column_stack(mask_cyt_coord)
 
-    # smooth them using moving average
-    smoothed_values = moving_average(values, n=4)
+    # compute dispersion index
+    sigma_rna = np.sum((rna_coord_2d - centroid_rna_2d) ** 2, axis=0)
+    sigma_rna = np.sum(sigma_rna / len(rna_coord_2d))
+    sigma_cell = np.sum((mask_cyt_coord - centroid_rna_2d) ** 2, axis=0)
+    sigma_cell = np.sum(sigma_cell / len(mask_cyt_coord))
+    feature = sigma_rna / sigma_cell
 
-    # compute the gradients of these values
-    gradients = np.gradient(smoothed_values)
+    return feature
 
-    # compute features
-    index_max = np.argmax(smoothed_values)
-    max_radius = radii[index_max]
-    max_value = smoothed_values[index_max]
-    if index_max == 0:
-        max_gradient = gradients[0]
-    else:
-        max_gradient = max(gradients[:index_max])
-    if index_max == len(gradients) - 1:
-        min_gradient = gradients[-1]
-    else:
-        min_gradient = min(gradients[index_max:])
-    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
-    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
-    max_size_cell = np.max(distances_cell)
-    big_radius = int(max_size_cell / 4)
-    big_value = ripley_values([big_radius], mask_cyt, rna_coord_out,
-                              mask_rna_out)[0]
-    features = [max_value, max_gradient, min_gradient, monotony, big_value,
-                max_radius]
 
-    return features
+# ### Other features ###
 
+def features_distance(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
+    # initialization
+    rna_coord_out_2d = rna_coord_out[:, 1:3]
+    eps = stack.get_eps_float32()
 
-def features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna):
-    """
+    if len(rna_coord_out_2d) == 0:
+        features = [1., 0., 1., 0., 1., 0.] * 2
+        return features
+    features = []
 
-    Parameters
-    ----------
-    radii
-    cyt_coord
-    mask_cyt
-    rna_coord
-    mask_rna
+    # compute statistics from distance to cytoplasm
+    distance_rna_cyt = distance_cyt[rna_coord_out_2d[:, 0],
+                                    rna_coord_out_2d[:, 1]]
+    factor = np.mean(distance_cyt[mask_cyt_out])
+    index_mean_distance_cyt = (np.mean(distance_rna_cyt) + eps) / factor
+    log2_index_mean_distance_cyt = np.log2(index_mean_distance_cyt)
+    factor = np.median(distance_cyt[mask_cyt_out])
+    index_median_distance_cyt = (np.median(distance_rna_cyt) + eps) / factor
+    log2_index_median_distance_cyt = np.log2(index_median_distance_cyt)
+    factor = np.std(distance_cyt[mask_cyt_out])
+    index_std_distance_cyt = (np.std(distance_rna_cyt) + eps) / factor
+    log2_index_std_distance_cyt = np.log2(index_std_distance_cyt)
+
+    features += [index_mean_distance_cyt,
+                 log2_index_mean_distance_cyt,
+                 index_median_distance_cyt,
+                 log2_index_median_distance_cyt,
+                 index_std_distance_cyt,
+                 log2_index_std_distance_cyt]
+
+    # compute statistics from distance to nucleus
+    distance_rna_nuc = distance_nuc[rna_coord_out_2d[:, 0],
+                                    rna_coord_out_2d[:, 1]]
+    factor = np.mean(distance_nuc[mask_cyt_out])
+    index_mean_distance_nuc = (np.mean(distance_rna_nuc) + eps) / factor
+    log2_index_mean_distance_nuc = np.log2(index_mean_distance_nuc)
+    factor = np.median(distance_nuc[mask_cyt_out])
+    index_median_distance_nuc = (np.median(distance_rna_nuc) + eps) / factor
+    log2_index_median_distance_nuc = np.log2(index_median_distance_nuc)
+    factor = np.std(distance_nuc[mask_cyt_out])
+    index_std_distance_nuc = (np.std(distance_rna_nuc) + eps) / factor
+    log2_index_std_distance_nuc = np.log2(index_std_distance_nuc)
+
+    features += [index_mean_distance_nuc,
+                 log2_index_mean_distance_nuc,
+                 index_median_distance_nuc,
+                 log2_index_median_distance_nuc,
+                 index_std_distance_nuc,
+                 log2_index_std_distance_nuc]
 
-    Returns
-    -------
+    return features
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # compute corrected Ripley values for different radii
-    values = ripley_values(radii, mask_cyt, rna_coord, mask_rna)
 
-    # smooth them using moving average
-    smoothed_values = moving_average(values, n=4)
+def features_in_out_nucleus(rna_coord, rna_coord_out):
+    # number of mRNAs outside and inside nucleus
+    nb_rna_out = len(rna_coord_out)
+    nb_rna_in = len(rna_coord) - nb_rna_out
 
-    # compute the gradients of these values
-    gradients = np.gradient(smoothed_values)
+    # compute the proportion of rna in the nucleus
+    proportion_rna_in = nb_rna_in / len(rna_coord)
 
-    # compute features
-    index_max = np.argmax(smoothed_values)
-    max_radius = radii[index_max]
-    max_value = smoothed_values[index_max]
-    if index_max == 0:
-        max_gradient = gradients[0]
-    else:
-        max_gradient = max(gradients[:index_max])
-    if index_max == len(gradients) - 1:
-        min_gradient = gradients[-1]
-    else:
-        min_gradient = min(gradients[index_max:])
-    monotony, _ = spearmanr(smoothed_values, radii[2:-1])
-    distances_cell = distance_matrix(cyt_coord, cyt_coord, p=2)
-    max_size_cell = np.max(distances_cell)
-    big_radius = int(max_size_cell / 4)
-    big_value = ripley_values([big_radius], mask_cyt, rna_coord, mask_rna)[0]
-    features = [max_value, max_gradient, min_gradient, monotony, big_value,
-                max_radius]
+    features = [proportion_rna_in, nb_rna_out, nb_rna_in]
 
     return features
 
 
-def feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna):
-    """
-
-    Parameters
-    ----------
-    distance_cyt
-    distance_cyt_centroid
-    centroid_rna
-
-    Returns
-    -------
+def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
+    # get number of rna outside nucleus and cell area
+    nb_rna_out = len(rna_coord_out)
+    area_nuc = mask_nuc.sum()
+    area_cyt_out = mask_cyt_out.sum()
+    eps = stack.get_eps_float32()
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # compute polarization index
-    factor = np.mean(distance_cyt_centroid[distance_cyt > 0])
-    distance_rna_cell = distance_cyt_centroid[centroid_rna[0], centroid_rna[1]]
-    feature = distance_rna_cell / factor
+    # case where we do not detect any rna outside the nucleus
+    if nb_rna_out == 0:
+        features = [0., np.log2(eps), 0.]
+        return features
 
-    return feature
+    # apply opening operator and count the loss of rna outside the nucleus
+    features = []
+    for size in [30]:
+        s = disk(size, dtype=bool)
+        mask_cyt_transformed = binary_opening(mask_cyt, selem=s)
+        mask_cyt_transformed[mask_nuc] = True
+        new_area_cell_out = mask_cyt_transformed.sum() - area_nuc
+        area_protrusion = area_cyt_out - new_area_cell_out
+        if area_protrusion > 0:
+            factor = nb_rna_out * area_protrusion / area_cyt_out
+            mask_rna = mask_cyt_transformed[rna_coord_out[:, 1],
+                                            rna_coord_out[:, 2]]
+            rna_after_opening = rna_coord_out[mask_rna]
+            nb_rna_protrusion = nb_rna_out - len(rna_after_opening)
+            index_rna_opening = (nb_rna_protrusion + eps) / factor
+            log2_index_rna_opening = np.log2(index_rna_opening)
+            proportion_rna_opening = nb_rna_protrusion / nb_rna_out
+
+            features += [index_rna_opening,
+                         log2_index_rna_opening,
+                         proportion_rna_opening]
+        else:
+            features += [0., np.log2(eps), 0.]
 
+    return features
 
-def feature_dispersion(mask_cyt, rna_coord, centroid_rna):
-    """
 
-    Parameters
-    ----------
-    mask_cyt
-    rna_coord
-    centroid_rna
+def features_polarization(centroid_rna_out, centroid_cyt, centroid_nuc,
+                          distance_cyt_centroid, distance_nuc_centroid):
+    centroid_rna_out_2d = centroid_rna_out[1:]
 
-    Returns
-    -------
+    # compute polarization index from cytoplasm centroid
+    polarization_distance = np.linalg.norm(centroid_rna_out_2d - centroid_cyt)
+    factor = distance_cyt_centroid.max()
+    feature_cyt = polarization_distance / factor
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # TODO correct the formula
-    # case where we do not detect rna outside nucleus
-    if len(rna_coord) == 0:
-        return 1.
+    # compute polarization index from nucleus centroid
+    polarization_distance = np.linalg.norm(centroid_rna_out_2d - centroid_nuc)
+    factor = distance_nuc_centroid.max()
+    feature_nuc = polarization_distance / factor
 
-    # get coordinates of each pixel of the cell
-    mask_cyt_coord = np.nonzero(mask_cyt)
-    mask_cyt_coord = np.column_stack(mask_cyt_coord)
+    # gather features
+    features = [feature_cyt,
+                feature_nuc]
 
-    # compute dispersion index
-    sigma_rna = np.sum((rna_coord - centroid_rna) ** 2, axis=0)
-    sigma_rna = np.sum(sigma_rna / len(rna_coord))
-    sigma_cell = np.sum((mask_cyt_coord - centroid_rna) ** 2, axis=0)
-    sigma_cell = np.sum(sigma_cell / len(mask_cyt_coord))
-    feature = sigma_rna / sigma_cell
+    return features
 
-    return feature
 
+def features_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
+    # initialization
+    eps = stack.get_eps_float32()
 
-def feature_area(mask_cyt, mask_nuc):
-    """
-
-    Parameters
-    ----------
-    mask_cyt
-    mask_nuc
+    if len(rna_coord_out) == 0:
+        features = [1., 0.]
+        return features
 
-    Returns
-    -------
+    # get number of rna outside nucleus and cell area
+    if mask_cyt_out.sum() == 0:
+        features = [1., 0.]
+        return features
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # get area of the cytoplasm and the nucleus
-    area_cyt = mask_cyt.sum()
-    area_nuc = mask_nuc.sum()
+    # get coordinates of each pixel of the cell
+    cell_outside_nuc_coord = np.nonzero(mask_cyt_out)
+    cell_outside_nuc_coord = np.column_stack(cell_outside_nuc_coord)
 
-    # compute relative area of the nucleus
-    relative_area_nuc = area_nuc / area_cyt
+    # compute dispersion index
+    a = distance_rna_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
+    b = distance_rna_centroid[cell_outside_nuc_coord[:, 0],
+                              cell_outside_nuc_coord[:, 1]]
+    index_dispersion = (a.mean() + eps) / b.mean()
+    log2_index_dispersion = np.log2(index_dispersion)
 
-    # return features
-    features = [relative_area_nuc, area_cyt, area_nuc]
+    features = [index_dispersion,
+                log2_index_dispersion]
 
     return features
 
 
-def feature_height():
-    return
-
-
-def get_features(cyt_coord, nuc_coord, rna_coord):
-    """Compute cell features.
+def features_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
+                                   mask_cyt_out):
+    # initialization
+    eps = stack.get_eps_float32()
 
-    Parameters
-    ----------
-    cyt_coord : np.ndarray, np.int64
-        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
-    nuc_coord : np.ndarray, np.int64
-        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
-    rna_coord : np.ndarray, np.int64
-        Coordinate yx of the detected rna with shape (nb_rna, 2).
-
-    Returns
-    -------
-    features : List[float]
-        List of features (cf. features.get_features_name()).
-
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # TODO filter features
-    # get a binary representation of the coordinates
-    cyt, nuc, mask_rna = from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord)
-
-    # fill in masks
-    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
-
-    # compute distance maps for the cytoplasm and the nucleus
-    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
+    if len(rna_coord_out) == 0:
+        features = [1., 0.]
+        return features
 
-    # get rna outside nucleus
-    mask_rna_out = mask_rna.copy()
-    mask_rna_out[distance_nuc == 0] = 0
-    rna_coord_out = np.nonzero(mask_rna_out)
-    rna_coord_out = np.column_stack(rna_coord_out)
+    # get number of rna outside nucleus and cell area
+    if mask_cyt_out.sum() == 0:
+        features = [1., 0.]
+        return features
 
-    # get centroids
-    centroid_cyt = get_centroid(mask_cyt)
-    centroid_nuc = get_centroid(mask_nuc)
-    if len(rna_coord_out) == 0:
-        centroid_rna_out = centroid_cyt
-    else:
-        centroid_rna_out = np.mean(rna_coord_out, axis=0, dtype=np.int64)
+    # get coordinates of each pixel of the cell
+    cell_outside_nuc_coord = np.nonzero(mask_cyt_out)
+    cell_outside_nuc_coord = np.column_stack(cell_outside_nuc_coord)
 
-    # get centroid distance maps
-    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
-    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+    # compute dispersion index
+    a = distance_cyt_centroid[rna_coord_out[:, 1], rna_coord_out[:, 2]]
+    b = distance_cyt_centroid[cell_outside_nuc_coord[:, 0],
+                              cell_outside_nuc_coord[:, 1]]
+    index_peripheral_dispersion = (a.mean() + eps) / b.mean()
+    log2_index_peripheral_dispersion = np.log2(index_peripheral_dispersion)
 
-    # compute features
-    a = features_distance(mask_rna_out, distance_cyt, distance_nuc,
-                          distance_cyt_centroid, distance_nuc_centroid)
-    b = feature_in_out_nucleus(mask_nuc, mask_rna)
-    opening_sizes = [15, 30, 45, 60]
-    c = features_opening(opening_sizes, mask_cyt, mask_rna_out)
-    radii = [r for r in range(40)]
-    d = features_ripley(radii, cyt_coord, mask_cyt, rna_coord_out,
-                        mask_rna_out)
-    e = feature_polarization(distance_cyt, distance_cyt_centroid,
-                             centroid_rna_out)
-    f = feature_dispersion(mask_cyt, rna_coord_out, centroid_rna_out)
-    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
+    features = [index_peripheral_dispersion,
+                log2_index_peripheral_dispersion]
 
     return features
 
 
-def get_features_name():
-    """Return the current list of features names.
-
-    Returns
-    -------
-    features_name : List[str]
-        List of features name returned by features.get_features().
+def features_topography(rna_coord, rna_coord_out, mask_cyt, mask_nuc,
+                        mask_cyt_out):
+    # initialization
+    features = []
+    cell_area = mask_cyt.sum()
+    nb_rna = len(rna_coord)
+    nb_rna_out = len(rna_coord_out)
+    eps = stack.get_eps_float32()
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # TODO filter features
-    features_name = ["average_dist_cyt", "quantile_5_dist_cyt",
-                     "quantile_10_dist_cyt", "quantile_20_dist_cyt",
-                     "quantile_50_dist_cyt", "average_dist_cyt_centroid",
-                     "average_dist_nuc", "average_dist_nuc_centroid",
-                     "ratio_in_nuc", "diff_opening_15", "diff_opening_30",
-                     "diff_opening_45", "diff_opening_60", "ripley_max",
-                     "ripley_max_gradient", "ripley_min_gradient",
-                     "ripley_monotony", "ripley_large", "ripley_radius_max",
-                     "polarization_index", "dispersion_index"]
+    # case where no mRNAs outside the nucleus are detected
+    if nb_rna_out == 0:
+        features = [0., np.log2(eps), 0.]
+        features += [0., np.log2(eps), 0.] * 5
+        features += [0., np.log2(eps), 0.] * 2
+        features += [0., np.log2(eps), 0.] * 6
+        features += [0., np.log2(eps), 0.] * 3
+        return features
 
-    return features_name
+    # build a distance map from nucleus border and from cytoplasm membrane
+    distance_map_nuc_out = ndi.distance_transform_edt(~mask_nuc)
+    distance_map_nuc_in = ndi.distance_transform_edt(~mask_cyt_out)
+    distance_map_nuc = distance_map_nuc_out + distance_map_nuc_in
+    distance_map_nuc[~mask_cyt] = 0
+    distance_map_cyt = ndi.distance_transform_edt(mask_cyt)
+
+    # count mRNAs along nucleus edge (-5 to 5 pixels)
+    mask_nuc_edge = distance_map_nuc < 5
+    mask_nuc_edge[~mask_cyt] = False
+    factor = nb_rna * max(mask_nuc_edge.sum(), 1) / cell_area
+    mask_rna = mask_nuc_edge[rna_coord[:, 1], rna_coord[:, 2]]
+    nb_rna_nuc_edge = len(rna_coord[mask_rna])
+    index_rna_nuc_edge = (nb_rna_nuc_edge + eps) / factor
+    log2_index_rna_nuc_edge = np.log2(index_rna_nuc_edge)
+    proportion_rna_nuc_edge = nb_rna_nuc_edge / nb_rna
+
+    features += [index_rna_nuc_edge,
+                 log2_index_rna_nuc_edge,
+                 proportion_rna_nuc_edge]
+
+    # count mRNAs in specific regions around nucleus (5-10, 10-15, 15-20,
+    # 20-25, 25-30)
+    mask_cumulated_radius = mask_nuc_edge.copy()
+    for radius in range(10, 31, 5):
+        mask_nuc_radius = distance_map_nuc < radius
+        mask_nuc_radius[~mask_cyt] = False
+        mask_nuc_radius[mask_nuc] = False
+        mask_nuc_radius[mask_cumulated_radius] = False
+        mask_cumulated_radius |= mask_nuc_radius
+        factor = nb_rna * max(mask_nuc_radius.sum(), 1) / cell_area
+        mask_rna = mask_nuc_radius[rna_coord[:, 1], rna_coord[:, 2]]
+        nb_rna_nuc_radius = len(rna_coord[mask_rna])
+        index_rna_nuc_radius = (nb_rna_nuc_radius + eps) / factor
+        log2_index_rna_nuc_radius = np.log2(index_rna_nuc_radius)
+        proportion_rna_nuc_radius = nb_rna_nuc_radius / nb_rna
+
+        features += [index_rna_nuc_radius,
+                     log2_index_rna_nuc_radius,
+                     proportion_rna_nuc_radius]
+
+    # count mRNAs in specific regions around nucleus (5-15, 15-25)
+    mask_cumulated_radius = mask_nuc_edge.copy()
+    for radius in range(15, 26, 10):
+        mask_nuc_radius = distance_map_nuc < radius
+        mask_nuc_radius[~mask_cyt] = False
+        mask_nuc_radius[mask_nuc] = False
+        mask_nuc_radius[mask_cumulated_radius] = False
+        mask_cumulated_radius |= mask_nuc_radius
+        factor = nb_rna * max(mask_nuc_radius.sum(), 1) / cell_area
+        mask_rna = mask_nuc_radius[rna_coord[:, 1], rna_coord[:, 2]]
+        nb_rna_nuc_radius = len(rna_coord[mask_rna])
+        index_rna_nuc_radius = (nb_rna_nuc_radius + eps) / factor
+        log2_index_rna_nuc_radius = np.log2(index_rna_nuc_radius)
+        proportion_rna_nuc_radius = nb_rna_nuc_radius / nb_rna
+
+        features += [index_rna_nuc_radius,
+                     log2_index_rna_nuc_radius,
+                     proportion_rna_nuc_radius]
+
+    # count mRNAs in specific regions around cytoplasmic membrane (0-5, 5-10,
+    # 10-15, 15-20, 20-25, 25-30)
+    mask_cumulated_radius = np.zeros_like(mask_nuc_edge)
+    for radius in range(5, 31, 5):
+        mask_cyt_radius = distance_map_cyt < radius
+        mask_cyt_radius[~mask_cyt] = False
+        mask_cyt_radius[mask_nuc] = False
+        mask_cyt_radius[mask_cumulated_radius] = False
+        mask_cumulated_radius |= mask_cyt_radius
+        factor = nb_rna * max(mask_cyt_radius.sum(), 1) / cell_area
+        mask_rna = mask_cyt_radius[rna_coord[:, 1], rna_coord[:, 2]]
+        nb_rna_cyt_radius = len(rna_coord[mask_rna])
+        index_rna_cyt_radius = (nb_rna_cyt_radius + eps) / factor
+        log2_index_rna_cyt_radius = np.log2(index_rna_cyt_radius)
+        proportion_rna_cyt_radius = nb_rna_cyt_radius / nb_rna
+
+        features += [index_rna_cyt_radius,
+                     log2_index_rna_cyt_radius,
+                     proportion_rna_cyt_radius]
+
+    # count mRNAs in specific regions around cytoplasmic membrane (0-10, 10-20,
+    # 20-30)
+    mask_cumulated_radius = np.zeros_like(mask_nuc_edge)
+    for radius in range(10, 31, 10):
+        mask_cyt_radius = distance_map_cyt < radius
+        mask_cyt_radius[~mask_cyt] = False
+        mask_cyt_radius[mask_nuc] = False
+        mask_cyt_radius[mask_cumulated_radius] = False
+        mask_cumulated_radius |= mask_cyt_radius
+        factor = nb_rna * max(mask_cyt_radius.sum(), 1) / cell_area
+        mask_rna = mask_cyt_radius[rna_coord[:, 1], rna_coord[:, 2]]
+        nb_rna_cyt_radius = len(rna_coord[mask_rna])
+        index_rna_cyt_radius = (nb_rna_cyt_radius + eps) / factor
+        log2_index_rna_cyt_radius = np.log2(index_rna_cyt_radius)
+        proportion_rna_cyt_radius = nb_rna_cyt_radius / nb_rna
+
+        features += [index_rna_cyt_radius,
+                     log2_index_rna_cyt_radius,
+                     proportion_rna_cyt_radius]
 
+    return features
 
-def get_features_aubin(cyt_coord, nuc_coord, rna_coord):
-    """Compute cell features, according to Aubin's paper.
 
-    Parameters
-    ----------
-    cyt_coord : np.ndarray, np.int64
-        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
-    nuc_coord : np.ndarray, np.int64
-        Coordinate yx of the cytoplasm boundary with shape (nb_points, 2).
-    rna_coord : np.ndarray, np.int64
-        Coordinate yx of the detected rna with shape (nb_rna, 2).
+def features_foci(rna_coord_out, distance_cyt, distance_nuc, mask_cyt_out):
+    # case where no mRNAs outside the nucleus are detected
+    if len(rna_coord_out) == 0:
+        features = [0.] * 35 * 2
+        features += [1., 0., 0.] * 4
+        features += [1., 0., 1., 0., 1., 0.]
+        features += [1., 0., 1., 0., 1., 0.]
+        return features
 
-    Returns
-    -------
-    features : List[float]
-        List of features (cf. features.get_features_name()).
+    features = []
+    for foci_radius in [50, 150, 250, 350, 450, 550, 650]:
+        for min_foci_rna in [3, 4, 5, 6, 7]:
+            clustered_spots = detection.cluster_spots(
+                spots=rna_coord_out[:, :3],
+                resolution_z=300,
+                resolution_yx=103,
+                radius=foci_radius,
+                nb_min_spots=min_foci_rna)
+            foci = detection.extract_foci(clustered_spots=clustered_spots)
+            nb_foci = len(foci)
+            nb_spots_in_foci = np.sum(foci[:, 3])
+            proportion_rna_foci = nb_spots_in_foci / len(rna_coord_out)
+
+            features += [nb_foci,
+                         proportion_rna_foci]
+
+    # case where no default foci are detected
+    rna_coord_out_foci = rna_coord_out[rna_coord_out[:, 3] != -1, :]
+    if len(rna_coord_out_foci) == 0:
+        features += [1., 0., 0.] * 4
+        features += [1., 0., 1., 0., 1., 0.]
+        features += [1., 0., 1., 0., 1., 0.]
+        return features
 
-    """
-    # TODO add sanity check functions
-    # TODO add documentation
-    # TODO filter features
-    # get a binary representation of the coordinates
-    cyt, nuc, mask_rna = from_coord_to_matrix(cyt_coord, nuc_coord, rna_coord)
+    # get regular foci id
+    l_id_foci = list(set(rna_coord_out_foci[:, 3]))
+
+    # count mRNAs in successive 5 pixels foci neighbors
+    nb_rna_out = len(rna_coord_out)
+    cell_out_area = mask_cyt_out.sum()
+    mask_foci_neighbor_cumulated = np.zeros_like(mask_cyt_out)
+    eps = stack.get_eps_float32()
+
+    # we count mRNAs in the neighbors 0-5 pixels around the foci, 5-10 pixels,
+    # 10-15 pixels, and 15-20 pixels
+    for radius in range(5, 21, 5):
+        s = disk(radius).astype(bool)
+        mask_foci_neighbor = np.zeros_like(mask_cyt_out)
+
+        # for each foci, get a mask of its neighbor and merge them
+        for i in l_id_foci:
+            rna_foci_i = rna_coord_out_foci[rna_coord_out_foci[:, 3] == i, :3]
+            foci = np.mean(rna_foci_i, axis=0)
+            foci = np.round(foci).astype(np.int64)
+            row, col = foci[1], foci[2]
+            mask_neighbor = np.zeros_like(mask_cyt_out)
+            min_row = max(row - radius, 0)
+            min_row_s = min_row - (row - radius)
+            max_row = min(row + radius + 1, mask_neighbor.shape[0])
+            max_row_s = s.shape[0] - ((row + radius + 1) - max_row)
+            min_col = max(col - radius, 0)
+            min_col_s = min_col - (col - radius)
+            max_col = min(col + radius + 1, mask_neighbor.shape[1])
+            max_col_s = s.shape[1] - ((col + radius + 1) - max_col)
+            new_s = s[min_row_s:max_row_s, min_col_s:max_col_s]
+            mask_neighbor[min_row:max_row, min_col:max_col] = new_s
+            mask_foci_neighbor |= mask_cyt_out & mask_neighbor
+
+        # remove neighbor mask from previous radius
+        mask_foci_neighbor[mask_foci_neighbor_cumulated] = False
+        mask_foci_neighbor_cumulated |= mask_foci_neighbor
+
+        # count mRNAs in such a region
+        mask_rna = mask_foci_neighbor[rna_coord_out[:, 1], rna_coord_out[:, 2]]
+        nb_rna_foci_neighbor = len(rna_coord_out[mask_rna])
+        area_foci_neighbor = mask_foci_neighbor.sum()
+        factor = nb_rna_out * max(area_foci_neighbor, 1) / cell_out_area
+        index_rna_foci_neighbor = (nb_rna_foci_neighbor + eps) / factor
+        log2_index_rna_foci_neighbor = np.log2(index_rna_foci_neighbor)
+        proportion_rna_foci_neighbor = nb_rna_foci_neighbor / nb_rna_out
+
+        features += [index_rna_foci_neighbor,
+                     log2_index_rna_foci_neighbor,
+                     proportion_rna_foci_neighbor]
+
+    # get foci coordinates
+    foci_coord = []
+    for i in l_id_foci:
+        rna_foci_i = rna_coord_out_foci[rna_coord_out_foci[:, 3] == i, :3]
+        foci = np.mean(rna_foci_i, axis=0)
+        foci = np.round(foci).astype(np.int64)
+        foci_coord.append(foci.reshape(1, 3))
+    foci_coord = np.array(foci_coord, dtype=np.int64)
+    foci_coord = np.squeeze(foci_coord, axis=1)
+    foci_coord_2d = foci_coord[:, 1:3]
+
+    # compute statistics from distance to cytoplasm
+    distance_foci_cyt = distance_cyt[foci_coord_2d[:, 0], foci_coord_2d[:, 1]]
+    factor = np.mean(distance_cyt[mask_cyt_out])
+    index_foci_mean_distance_cyt = (np.mean(distance_foci_cyt) + eps) / factor
+    log2_index_foci_mean_distance_cyt = np.log2(index_foci_mean_distance_cyt)
+    factor = np.median(distance_cyt[mask_cyt_out])
+    index_foci_med_distance_cyt = (np.median(distance_foci_cyt) + eps) / factor
+    log2_index_foci_med_distance_cyt = np.log2(index_foci_med_distance_cyt)
+    factor = np.std(distance_cyt[mask_cyt_out])
+    index_foci_std_distance_cyt = (np.std(distance_foci_cyt) + eps) / factor
+    log2_index_foci_std_distance_cyt = np.log2(index_foci_std_distance_cyt)
+
+    features += [index_foci_mean_distance_cyt,
+                 log2_index_foci_mean_distance_cyt,
+                 index_foci_med_distance_cyt,
+                 log2_index_foci_med_distance_cyt,
+                 index_foci_std_distance_cyt,
+                 log2_index_foci_std_distance_cyt]
+
+    # compute statistics from distance to nucleus
+    distance_foci_nuc = distance_nuc[foci_coord_2d[:, 0],
+                                     foci_coord_2d[:, 1]]
+    factor = np.mean(distance_nuc[mask_cyt_out])
+    index_foci_mean_distance_nuc = (np.mean(distance_foci_nuc) + eps) / factor
+    log2_index_foci_mean_distance_nuc = np.log2(index_foci_mean_distance_nuc)
+    factor = np.median(distance_nuc[mask_cyt_out])
+    index_foci_med_distance_nuc = (np.median(distance_foci_nuc) + eps) / factor
+    log2_index_foci_med_distance_nuc = np.log2(index_foci_med_distance_nuc)
+    factor = np.std(distance_nuc[mask_cyt_out])
+    index_foci_std_distance_nuc = (np.std(distance_foci_nuc) + eps) / factor
+    log2_index_foci_std_distance_nuc = np.log2(index_foci_std_distance_nuc)
+
+    features += [index_foci_mean_distance_nuc,
+                 log2_index_foci_mean_distance_nuc,
+                 index_foci_med_distance_nuc,
+                 log2_index_foci_med_distance_nuc,
+                 index_foci_std_distance_nuc,
+                 log2_index_foci_std_distance_nuc]
 
-    # fill in masks
-    mask_cyt, mask_nuc = stack.get_surface_layers(cyt, nuc, cast_float=False)
+    return features
 
-    # compute distance maps for the cytoplasm and the nucleus
-    distance_cyt, distance_nuc = stack.get_distance_layers(cyt, nuc)
 
-    # get centroids
-    centroid_cyt = get_centroid(mask_cyt)
-    centroid_nuc = get_centroid(mask_nuc)
-    centroid_rna = np.mean(rna_coord, axis=0, dtype=np.int64)
+def features_area(mask_cyt, mask_nuc, mask_cyt_out):
+    # get area of the cytoplasm and the nucleus
+    area_cyt = mask_cyt.sum()
+    area_nuc = mask_nuc.sum()
 
-    # get centroid distance maps
-    distance_cyt_centroid = get_centroid_distance_map(centroid_cyt, mask_cyt)
-    distance_nuc_centroid = get_centroid_distance_map(centroid_nuc, mask_cyt)
+    # compute relative area of the nucleus
+    relative_area_nuc = area_nuc / area_cyt
 
-    # get rna outside nucleus
-    mask_rna_out = mask_rna.copy()
-    mask_rna_out[distance_nuc == 0] = 0
+    # compute area of the cytoplasm outside nucleus
+    area_cyt_out = mask_cyt_out.sum()
 
-    # compute features
-    a = features_distance_aubin(mask_rna, distance_cyt, distance_nuc,
-                                distance_cyt_centroid, distance_nuc_centroid)
-    b = feature_in_out_nucleus_aubin(mask_nuc, mask_rna, mask_rna_out)
-    opening_sizes = [15, 30, 45, 60]
-    c = features_opening_aubin(opening_sizes, mask_cyt, mask_rna)
-    radii = [r for r in range(40)]
-    d = features_ripley_aubin(radii, cyt_coord, mask_cyt, rna_coord, mask_rna)
-    e = feature_polarization(distance_cyt, distance_cyt_centroid, centroid_rna)
-    f = feature_dispersion(mask_cyt, rna_coord, centroid_rna)
-    features = np.array(a + [b] + c + d + [e] + [f], dtype=np.float32)
+    # return features
+    features = [relative_area_nuc, area_cyt, area_nuc, area_cyt_out]
 
     return features

From 05369e6bf0b3c8867c42e469eea533a2004015d2 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 11 Nov 2019 21:51:29 +0100
Subject: [PATCH 258/264] fix features (again)

---
 bigfish/classification/features.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 87045b51..1957e8d8 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -447,7 +447,7 @@ def features_polarization(centroid_rna_out, centroid_cyt, centroid_nuc,
 def features_dispersion(rna_coord_out, distance_rna_centroid, mask_cyt_out):
     # initialization
     if len(rna_coord_out) == 0:
-        features = [1., 0.]
+        features = [1.]
         return features
 
     # get number of rna outside nucleus and cell area
@@ -479,7 +479,7 @@ def features_peripheral_dispersion(rna_coord_out, distance_cyt_centroid,
 
     # get number of rna outside nucleus and cell area
     if mask_cyt_out.sum() == 0:
-        features = [1., 0.]
+        features = [1.]
         return features
 
     # get coordinates of each pixel of the cell

From 63f198ed264f54e6e25e41160997033225b11e07 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Nov 2019 13:50:20 +0100
Subject: [PATCH 259/264] add protrusion area features

---
 bigfish/classification/features.py | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index 1957e8d8..ad8511b3 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -192,7 +192,8 @@ def get_features_name(names_features_distance=True,
 
     if names_features_protrusion:
         features_name += ["index_rna_opening_30",
-                          "proportion_rna_opening_30"]
+                          "proportion_rna_opening_30",
+                          "area_opening_30"]
 
     if names_features_dispersion:
         features_name += ["score_polarization_cyt",
@@ -393,11 +394,6 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
     area_nuc = mask_nuc.sum()
     area_cyt_out = mask_cyt_out.sum()
 
-    # case where we do not detect any rna outside the nucleus
-    if nb_rna_out == 0:
-        features = [0., 0.]
-        return features
-
     # apply opening operator and count the loss of rna outside the nucleus
     features = []
     for size in [30]:
@@ -406,6 +402,11 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
         mask_cyt_transformed[mask_nuc] = True
         new_area_cell_out = mask_cyt_transformed.sum() - area_nuc
         area_protrusion = area_cyt_out - new_area_cell_out
+
+        # case where we do not detect any rna outside the nucleus
+        if nb_rna_out == 0:
+            features += [0., 0., area_protrusion]
+
         if area_protrusion > 0:
             factor = nb_rna_out * area_protrusion / area_cyt_out
             mask_rna = mask_cyt_transformed[rna_coord_out[:, 1],
@@ -416,9 +417,10 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
             proportion_rna_opening = nb_rna_protrusion / nb_rna_out
 
             features += [index_rna_opening,
-                         proportion_rna_opening]
+                         proportion_rna_opening,
+                         area_protrusion]
         else:
-            features += [0., 0.]
+            features += [0., 0., 0.]
 
     return features
 

From 56cc4d79f31f9b88fa27d156bc09b96287a9a244 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 14 Nov 2019 14:17:02 +0100
Subject: [PATCH 260/264] add protrusion area features #2

---
 bigfish/classification/features.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bigfish/classification/features.py b/bigfish/classification/features.py
index ad8511b3..8d153d76 100644
--- a/bigfish/classification/features.py
+++ b/bigfish/classification/features.py
@@ -406,6 +406,7 @@ def features_protrusion(rna_coord_out, mask_cyt, mask_nuc, mask_cyt_out):
         # case where we do not detect any rna outside the nucleus
         if nb_rna_out == 0:
             features += [0., 0., area_protrusion]
+            continue
 
         if area_protrusion > 0:
             factor = nb_rna_out * area_protrusion / area_cyt_out

From 48947de79bd8ba5dc3d1e5fff0211be9f7b6f740 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Tue, 3 Dec 2019 16:58:28 +0100
Subject: [PATCH 261/264] improve functions to manipulates masks of
 segmentation

---
 bigfish/segmentation/__init__.py |   9 +-
 bigfish/segmentation/utils.py    |  37 +-----
 bigfish/stack/__init__.py        |  16 ++-
 bigfish/stack/postprocess.py     | 210 ++++++++++++++++++++++++++++++-
 bigfish/stack/preprocess.py      |   6 +-
 bigfish/stack/utils.py           |  66 +---------
 6 files changed, 231 insertions(+), 113 deletions(-)

diff --git a/bigfish/segmentation/__init__.py b/bigfish/segmentation/__init__.py
index 1c27c526..075e6d6c 100644
--- a/bigfish/segmentation/__init__.py
+++ b/bigfish/segmentation/__init__.py
@@ -6,7 +6,7 @@
 """
 
 from .utils import (label_instances, compute_mean_size_object, merge_labels,
-                    get_boundaries, dilate_erode_labels)
+                    dilate_erode_labels)
 from .nuc_segmentation import (filtered_threshold, remove_segmented_nuc)
 from .cyt_segmentation import (build_cyt_relief, build_cyt_binary_mask,
                                cyt_watershed)
@@ -14,11 +14,14 @@
 
 _nuc = ["filtered_threshold", "remove_segmented_nuc"]
 
-_cyt = ["build_cyt_relief", "build_cyt_binary_mask", cyt_watershed]
+_cyt = ["build_cyt_relief", "build_cyt_binary_mask", "cyt_watershed"]
 
 # _unet = ["get_input_size_unet"]
 
 _utils = ["label_instances", "compute_mean_size_object", "merge_labels",
-          "get_boundaries", "dilate_erode_labels"]
+          "dilate_erode_labels", "center_binary_mask",
+          "from_binary_surface_to_coord_2d", "complete_coord_2d",
+          "from_coord_2d_to_binary_surface",
+          "from_binary_boundaries_to_binary_surface"]
 
 __all__ = _utils + _nuc + _cyt
diff --git a/bigfish/segmentation/utils.py b/bigfish/segmentation/utils.py
index 4c48711c..9e1af2e4 100644
--- a/bigfish/segmentation/utils.py
+++ b/bigfish/segmentation/utils.py
@@ -9,13 +9,15 @@
 import bigfish.stack as stack
 
 import numpy as np
+
 from skimage.measure import label, regionprops
 from skimage.morphology import remove_small_objects
-from skimage.segmentation import find_boundaries
 
 
 # TODO homogenize the dtype of masks
 
+# ### Manipulate labels ###
+
 def label_instances(mask):
     """Count and label the different instances previously segmented in an
     image.
@@ -161,36 +163,3 @@ def dilate_erode_labels(label):
     label_final = label_final.astype(np.int64)
 
     return label_final
-
-
-def get_boundaries(mask):
-    """Get the boundaries coordinates of a mask (not sorted).
-
-    Parameters
-    ----------
-    mask : np.ndarray, np.uint or np.int or bool
-        Labelled image with shape (y, x).
-
-    Returns
-    -------
-    boundaries : np.ndarray, np.int64
-        Coordinate of the boundaries with shape (nb_points, 2).
-
-    """
-    # TODO sort boundaries coordinates with find_contours
-    # check parameters
-    stack.check_array(mask,
-                      ndim=2,
-                      dtype=[np.uint8, np.uint16, np.int64, bool])
-
-    # get boundaries mask
-    boundary_mask = find_boundaries(mask, mode='inner')
-
-    # get peak coordinates and radius
-    boundary_coordinates = np.nonzero(boundary_mask)
-    boundary_coordinates = np.column_stack(boundary_coordinates)
-
-    # complete coordinates if necessary
-    boundary_coordinates = stack.complete_coordinates_2d(boundary_coordinates)
-
-    return boundary_coordinates
diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index 01a833cc..d6e1a815 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -6,8 +6,7 @@
 """
 
 from .utils import (check_array, check_df, check_recipe, check_parameter,
-                    check_range_value, complete_coordinates_2d,
-                    from_coord_to_image, get_offset_value, get_eps_float32)
+                    check_range_value, get_offset_value, get_eps_float32)
 from .io import (read_image, read_pickle, read_cell_json, read_rna_json,
                  save_image)
 from .preprocess import (build_simulated_dataset, build_stacks, build_stack,
@@ -26,7 +25,10 @@
 from .illumination import (compute_illumination_surface,
                            correct_illumination_surface)
 from .postprocess import (remove_transcription_site, extract_spots_from_frame,
-                          extract_coordinates_image)
+                          extract_coordinates_image, center_binary_mask,
+                          from_binary_surface_to_coord_2d, complete_coord_2d,
+                          from_coord_2d_to_binary_surface,
+                          from_binary_boundaries_to_binary_surface)
 from .preparation import (split_from_background, build_image, get_coordinates,
                           get_distance_layers, get_surface_layers, build_batch,
                           get_label, Generator, encode_labels, get_map_label,
@@ -37,8 +39,7 @@
 
 
 _utils = ["check_array", "check_df", "check_recipe", "check_parameter",
-          "check_range_value", "complete_coordinates_2d",
-          "from_coord_to_image", "get_offset_value", "get_eps_float32"]
+          "check_range_value", "get_offset_value", "get_eps_float32"]
 
 _io = ["read_image", "read_pickle", "read_cell_json", "read_rna_json",
        "save_image"]
@@ -62,7 +63,10 @@
                  "correct_illumination_surface"]
 
 _postprocess = ["remove_transcription_site", "extract_spots_from_frame",
-                "extract_coordinates_image"]
+                "extract_coordinates_image", "center_binary_mask",
+                "from_binary_surface_to_coord_2d", "complete_coord_2d",
+                "from_coord_2d_to_binary_surface",
+                "from_binary_boundaries_to_binary_surface"]
 
 _augmentation = ["augment"]
 
diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index 699ff9e7..738a8b3e 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -1,14 +1,17 @@
 # -*- coding: utf-8 -*-
 
 """
-Functions used to format and clean any input loaded in bigfish.
+Functions used to format and clean any intermediate results loaded in or
+returned by a bigfish method.
 """
 
 import numpy as np
+from scipy import ndimage as ndi
 
-from .utils import check_array, check_parameter
+from .utils import check_array, check_parameter, get_offset_value
 
 from skimage.measure import regionprops, find_contours
+from skimage.draw import polygon_perimeter
 
 
 # ### Transcription sites ###
@@ -424,3 +427,206 @@ def _extract_spots_outside_foci(cell_cyt_mask, spots_out_foci):
     spots_out_foci_cell = spots_out_foci[mask_spots_to_keep]
 
     return spots_out_foci_cell
+
+
+# ### Segmentation postprocessing ###
+
+# TODO from_binary_surface_to_binary_boundaries
+
+def center_binary_mask(binary_mask):
+    """Center a 2-d binary mask (surface or boundaries) and pad with one pixel.
+
+    Parameters
+    ----------
+    binary_mask : np.ndarray, np.uint or np.int or bool
+        Binary image with shape (y, x).
+
+    Returns
+    -------
+    binary_mask_centered : np.ndarray, np.uint or np.int or bool
+        Binary image with shape (y, x).
+
+    """
+    # check parameters
+    check_array(binary_mask,
+                ndim=2,
+                dtype=[np.uint8, np.uint16, np.int64, bool])
+
+    # initialize parameter
+    marge = get_offset_value()
+
+    # center binary mask
+    coord = np.nonzero(binary_mask)
+    coord = np.column_stack(coord)
+    min_y, max_y = coord[:, 0].min(), coord[:, 0].max()
+    min_x, max_x = coord[:, 1].min(), coord[:, 1].max()
+    shape_y = max_y - min_y + 1
+    shape_x = max_x - min_x + 1
+    binary_mask_centered_shape = (shape_y + 2 * marge, shape_x + 2 * marge)
+    binary_mask_centered = np.zeros(binary_mask_centered_shape, dtype=bool)
+    crop = binary_mask[min_y:max_y + 1, min_x:max_x + 1]
+    binary_mask_centered[marge:shape_y + marge, marge:shape_x + marge] = crop
+
+    return binary_mask_centered
+
+
+def from_binary_surface_to_coord_2d(binary_surface):
+    """Extract coordinates from a 2-d binary matrix.
+
+    The resulting coordinates represent the external boundaries of the object.
+
+    Parameters
+    ----------
+    binary_surface : np.ndarray, np.uint or np.int or bool
+        Binary image with shape (y, x).
+
+    Returns
+    -------
+    coord : np.ndarray, np.uint64
+        Array of coordinates with shape (nb_points, 2).
+
+    """
+    # check parameters
+    check_array(binary_surface,
+                ndim=2,
+                dtype=[np.uint8, np.uint16, np.int64, bool])
+
+    # from binary surface to 2D coordinates boundaries
+    coord = find_contours(binary_surface, level=0)[0].astype(np.int64)
+
+    return coord
+
+
+def complete_coord_2d(coord):
+    """Complete a 2-d coordinates array, by generating/interpolating missing
+    points.
+
+    Parameters
+    ----------
+    coord : np.ndarray, np.uint64
+        Array of coordinates to complete, with shape (nb_points, 2).
+
+    Returns
+    -------
+    coord_completed : np.ndarray, np.uint64
+        Completed coordinates arrays, with shape (nb_points, 2).
+
+    """
+    # check parameters
+    check_array(coord,
+                ndim=2,
+                dtype=[np.int64])
+
+    # for each array in the list, complete its coordinates using the scikit
+    # image method 'polygon_perimeter'
+    coord_y, coord_x = polygon_perimeter(coord[:, 0], coord[:, 1])
+    coord_y = coord_y[:, np.newaxis]
+    coord_x = coord_x[:, np.newaxis]
+    coord_completed = np.concatenate((coord_y, coord_x), axis=-1)
+
+    return coord_completed
+
+
+def from_coord_2d_to_binary_surface(coord):
+    """Convert 2-d coordinates to a binary matrix with the surface of the
+    object.
+
+    As we manipulate the coordinates of the external boundaries, the relative
+    binary matrix has two extra pixels in each dimension. We compensate by
+    keeping only the inside pixels of the object surface.
+
+    Parameters
+    ----------
+    coord : np.ndarray, np.uint64
+        Array of coordinates with shape (nb_points, 2).
+
+    Returns
+    -------
+    binary_surface : np.ndarray, np.uint or np.int or bool
+        Binary image with shape (y, x).
+
+    """
+    # check parameters
+    check_array(coord,
+                ndim=2,
+                dtype=[np.int64])
+
+    # from coordinates to binary boundaries
+    boundaries = _from_coord_2d_to_binary_boundaries(coord)
+
+    # from binary boundaries to binary surface
+    binary_surface = from_binary_boundaries_to_binary_surface(boundaries)
+
+    # remove the pixels from the external boundaries
+    binary_surface[boundaries] = False
+
+    return binary_surface
+
+
+def from_binary_boundaries_to_binary_surface(binary_boundaries):
+    """Fill in the binary matrix representing the boundaries of an object.
+
+    Parameters
+    ----------
+    binary_boundaries : np.ndarray, np.uint or np.int or bool
+        Binary image with shape (y, x).
+
+    Returns
+    -------
+    binary_surface : np.ndarray, np.uint or np.int or bool
+        Binary image with shape (y, x).
+
+    """
+    # check parameters
+    check_array(binary_boundaries,
+                ndim=2,
+                dtype=[np.uint8, np.uint16, np.int64, bool])
+
+    # from binary boundaries to binary surface
+    binary_surface = ndi.binary_fill_holes(binary_boundaries)
+
+    return binary_surface
+
+
+def _from_coord_2d_to_binary_boundaries(coord):
+    """Convert 2-d coordinates to a binary matrix with the boundaries of the
+    object.
+
+    As we manipulate the coordinates of the external boundaries, the relative
+    binary matrix has two extra pixels in each dimension. We compensate by
+    reducing the marge by one in order to keep the same shape for the frame.
+
+    Parameters
+    ----------
+    coord : np.ndarray, np.uint64
+        Array of coordinates with shape (nb_points, 2).
+
+    Returns
+    -------
+    binary_boundaries : np.ndarray, np.uint or np.int or bool
+        Binary image with shape (y, x).
+
+    """
+    # check parameters
+    check_array(coord,
+                ndim=2,
+                dtype=[np.int64])
+
+    # initialize parameter
+    marge = get_offset_value()
+    marge -= 1
+
+    # from 2D coordinates boundaries to binary boundaries
+    max_y = coord[:, 0].max()
+    max_x = coord[:, 1].max()
+    min_y = coord[:, 0].min()
+    min_x = coord[:, 1].min()
+    shape_y = max_y - min_y + 1
+    shape_x = max_x - min_x + 1
+    image_shape = (shape_y + 2 * marge, shape_x + 2 * marge)
+    coord[:, 0] = coord[:, 0] - min_y + marge
+    coord[:, 1] = coord[:, 1] - min_x + marge
+    binary_boundaries = np.zeros(image_shape, dtype=bool)
+    binary_boundaries[coord[:, 0], coord[:, 1]] = True
+
+    return binary_boundaries
diff --git a/bigfish/stack/preprocess.py b/bigfish/stack/preprocess.py
index f5807ebe..a5fc5a56 100644
--- a/bigfish/stack/preprocess.py
+++ b/bigfish/stack/preprocess.py
@@ -12,9 +12,9 @@
 
 from .io import read_image, read_cell_json, read_rna_json
 from .utils import (check_array, check_parameter, check_recipe,
-                    check_range_value, check_df, complete_coordinates_2d,
-                    from_coord_to_image, fit_recipe, get_path_from_recipe,
-                    get_nb_element_per_dimension, count_nb_fov)
+                    check_range_value, check_df, fit_recipe,
+                    get_path_from_recipe, get_nb_element_per_dimension,
+                    count_nb_fov)
 
 from sklearn.preprocessing import LabelEncoder
 
diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index ba7e4b77..348b1e89 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -12,8 +12,6 @@
 import numpy as np
 import pandas as pd
 
-from skimage.draw import polygon_perimeter
-
 
 # ### Sanity checks dataframe ###
 
@@ -526,69 +524,7 @@ def check_parameter(**kwargs):
     return
 
 
-# ### Coordinate utilities ###
-
-def complete_coordinates_2d(list_coord):
-    """Complete a 2-d coordinates array, by generating/interpolating missing
-    points.
-
-    Parameters
-    ----------
-    list_coord : List[np.array]
-        List of the coordinates arrays to complete, with shape (nb_points, 2).
-
-    Returns
-    -------
-    list_coord_completed : List[np.array]
-        List of the completed coordinates arrays, with shape (nb_points, 2).
-
-    """
-    # TODO improve documentation
-    # TODO remove the list
-    # check parameter
-    check_parameter(list_coord=(list, np.ndarray))
-    if isinstance(list_coord, np.ndarray):
-        list_coord = [list_coord]
-
-    # for each array in the list, complete its coordinates using the scikit
-    # image method 'polygon_perimeter'
-    list_coord_completed = []
-    for coord in list_coord:
-        coord_x, coord_y = polygon_perimeter(coord[:, 0], coord[:, 1])
-        coord_x = coord_x[:, np.newaxis]
-        coord_y = coord_y[:, np.newaxis]
-        new_coord = np.concatenate((coord_x, coord_y), axis=-1)
-        list_coord_completed.append(new_coord)
-
-    return list_coord_completed
-
-
-def from_coord_to_image(coord, image_shape=None):
-    """Convert an array of coordinates into a binary matrix.
-
-    Parameters
-    ----------
-    coord : np.ndarray, np.uint64
-        Array of coordinate with shape (nb_points, 2) or (nb_points, 3).
-    image_shape:
-
-    Returns
-    -------
-    image : np.ndarray, np.float32
-        Binary matrix plotting the coordinates values.
-
-    """
-    # TODO improve integration with the segmentation/detection part
-    # build matrices
-    if image_shape is None:
-        max_x = coord[:, 0].max() + 5
-        max_y = coord[:, 1].max() + 5
-        image_shape = (max_x, max_y)
-    image = np.zeros(image_shape, dtype=np.float32)
-    image[coord[:, 0], coord[:, 1]] = 1.0
-
-    return image
-
+# ### Others ###
 
 def get_offset_value():
     """Return the margin pixel around a cell coordinate used to define its

From 6a67a61a1945425df3f56c4cd6e32e78665e3cf8 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Thu, 5 Dec 2019 00:00:37 +0100
Subject: [PATCH 262/264] fix segmented masks postprocessing

---
 bigfish/stack/__init__.py    |  11 +-
 bigfish/stack/postprocess.py | 248 +++++++++++++++++++++++++----------
 bigfish/stack/utils.py       |   2 +
 3 files changed, 184 insertions(+), 77 deletions(-)

diff --git a/bigfish/stack/__init__.py b/bigfish/stack/__init__.py
index d6e1a815..a340803c 100644
--- a/bigfish/stack/__init__.py
+++ b/bigfish/stack/__init__.py
@@ -26,9 +26,9 @@
                            correct_illumination_surface)
 from .postprocess import (remove_transcription_site, extract_spots_from_frame,
                           extract_coordinates_image, center_binary_mask,
-                          from_binary_surface_to_coord_2d, complete_coord_2d,
-                          from_coord_2d_to_binary_surface,
-                          from_binary_boundaries_to_binary_surface)
+                          from_surface_to_coord, complete_coord_boundaries,
+                          from_coord_to_surface,
+                          from_boundaries_to_surface)
 from .preparation import (split_from_background, build_image, get_coordinates,
                           get_distance_layers, get_surface_layers, build_batch,
                           get_label, Generator, encode_labels, get_map_label,
@@ -64,9 +64,8 @@
 
 _postprocess = ["remove_transcription_site", "extract_spots_from_frame",
                 "extract_coordinates_image", "center_binary_mask",
-                "from_binary_surface_to_coord_2d", "complete_coord_2d",
-                "from_coord_2d_to_binary_surface",
-                "from_binary_boundaries_to_binary_surface"]
+                "from_surface_to_coord", "complete_coord_boundaries",
+                "from_coord_to_surface", "from_boundaries_to_surface"]
 
 _augmentation = ["augment"]
 
diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index 738a8b3e..823444a8 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -433,44 +433,107 @@ def _extract_spots_outside_foci(cell_cyt_mask, spots_out_foci):
 
 # TODO from_binary_surface_to_binary_boundaries
 
-def center_binary_mask(binary_mask):
-    """Center a 2-d binary mask (surface or boundaries) and pad with one pixel.
+def center_binary_mask(cyt, nuc=None, rna=None):
+    """Center a 2-d binary mask (surface or boundaries) and pad it.
+
+    One mask should be at least provided ('cyt'). If others masks are provided
+    ('nuc' and 'rna'), they will be transformed like the main mask. All the
+    provided masks should have the same shape. If others coordinates are
+    provided, the values will be transformed, but an array of coordinates with
+    the same format is returned
 
     Parameters
     ----------
-    binary_mask : np.ndarray, np.uint or np.int or bool
-        Binary image with shape (y, x).
+    cyt : np.ndarray, np.uint or np.int or bool
+        Binary image of cytoplasm with shape (y, x).
+    nuc : np.ndarray, np.uint or np.int or bool
+        Binary image of nucleus with shape (y, x) or array of nucleus
+        coordinates with shape (nb_points, 2).
+    rna : np.ndarray, np.uint or np.int or bool
+        Binary image of mRNAs localization with shape (y, x) or array of mRNAs
+        coordinates with shape (nb_points, 2) or (nb_points, 3).
 
     Returns
     -------
-    binary_mask_centered : np.ndarray, np.uint or np.int or bool
-        Binary image with shape (y, x).
+    cyt_centered : np.ndarray, np.uint or np.int or bool
+        Centered binary image of cytoplasm with shape (y, x).
+    nuc_centered : np.ndarray, np.uint or np.int or bool
+        Centered binary image of nucleus with shape (y, x).
+    rna_centered : np.ndarray, np.uint or np.int or bool
+        Centered binary image of mRNAs localizations with shape (y, x).
 
     """
     # check parameters
-    check_array(binary_mask,
+    check_array(cyt,
                 ndim=2,
                 dtype=[np.uint8, np.uint16, np.int64, bool])
+    if nuc is not None:
+        check_array(nuc,
+                    ndim=2,
+                    dtype=[np.uint8, np.uint16, np.int64, bool])
+    if rna is not None:
+        check_array(rna,
+                    ndim=2,
+                    dtype=[np.uint8, np.uint16, np.int64, bool])
 
     # initialize parameter
+    nuc_centered, rna_centered = None, None
     marge = get_offset_value()
 
-    # center binary mask
-    coord = np.nonzero(binary_mask)
+    # center the binary mask of the cell
+    coord = np.nonzero(cyt)
     coord = np.column_stack(coord)
     min_y, max_y = coord[:, 0].min(), coord[:, 0].max()
     min_x, max_x = coord[:, 1].min(), coord[:, 1].max()
     shape_y = max_y - min_y + 1
     shape_x = max_x - min_x + 1
-    binary_mask_centered_shape = (shape_y + 2 * marge, shape_x + 2 * marge)
-    binary_mask_centered = np.zeros(binary_mask_centered_shape, dtype=bool)
-    crop = binary_mask[min_y:max_y + 1, min_x:max_x + 1]
-    binary_mask_centered[marge:shape_y + marge, marge:shape_x + marge] = crop
-
-    return binary_mask_centered
-
-
-def from_binary_surface_to_coord_2d(binary_surface):
+    cyt_centered_shape = (shape_y + 2 * marge, shape_x + 2 * marge)
+    cyt_centered = np.zeros(cyt_centered_shape, dtype=bool)
+    crop = cyt[min_y:max_y + 1, min_x:max_x + 1]
+    cyt_centered[marge:shape_y + marge, marge:shape_x + marge] = crop
+
+    # center the binary mask of the nucleus with the same transformation
+    if nuc is not None:
+        if nuc.shape == 2:
+            nuc_centered = nuc.copy()
+            nuc_centered[:, 0] = nuc_centered[:, 0] - min_y + marge
+            nuc_centered[:, 1] = nuc_centered[:, 1] - min_x + marge
+
+        elif nuc.shape == cyt.shape:
+            nuc_centered = np.zeros(cyt_centered_shape, dtype=bool)
+            crop = nuc[min_y:max_y + 1, min_x:max_x + 1]
+            nuc_centered[marge:shape_y + marge, marge:shape_x + marge] = crop
+
+        else:
+            raise ValueError("mRNAs mask should have the same shape than "
+                             "cytoplasm mask and coordinates should be in 2-d")
+
+    # center the binary mask of the mRNAs with the same transformation
+    if rna is not None:
+        if rna.shape[1] == 3:
+            rna_centered = rna.copy()
+            rna_centered[:, 1] = rna_centered[:, 1] - min_y + marge
+            rna_centered[:, 2] = rna_centered[:, 2] - min_x + marge
+
+        elif rna.shape[1] == 2:
+            rna_centered = rna.copy()
+            rna_centered[:, 0] = rna_centered[:, 0] - min_y + marge
+            rna_centered[:, 1] = rna_centered[:, 1] - min_x + marge
+
+        elif rna.shape == cyt.shape:
+            rna_centered = np.zeros(cyt_centered_shape, dtype=bool)
+            crop = rna[min_y:max_y + 1, min_x:max_x + 1]
+            rna_centered[marge:shape_y + marge, marge:shape_x + marge] = crop
+
+        else:
+            raise ValueError("mRNAs mask should have the same shape than "
+                             "cytoplasm mask and coordinates should be in 2-d "
+                             "or 3-d")
+
+    return cyt_centered, nuc_centered, rna_centered
+
+
+def from_surface_to_coord(binary_surface):
     """Extract coordinates from a 2-d binary matrix.
 
     The resulting coordinates represent the external boundaries of the object.
@@ -482,8 +545,8 @@ def from_binary_surface_to_coord_2d(binary_surface):
 
     Returns
     -------
-    coord : np.ndarray, np.uint64
-        Array of coordinates with shape (nb_points, 2).
+    coord : np.ndarray, np.int64
+        Array of boundaries coordinates with shape (nb_points, 2).
 
     """
     # check parameters
@@ -497,18 +560,18 @@ def from_binary_surface_to_coord_2d(binary_surface):
     return coord
 
 
-def complete_coord_2d(coord):
+def complete_coord_boundaries(coord):
     """Complete a 2-d coordinates array, by generating/interpolating missing
     points.
 
     Parameters
     ----------
-    coord : np.ndarray, np.uint64
+    coord : np.ndarray, np.int64
         Array of coordinates to complete, with shape (nb_points, 2).
 
     Returns
     -------
-    coord_completed : np.ndarray, np.uint64
+    coord_completed : np.ndarray, np.int64
         Completed coordinates arrays, with shape (nb_points, 2).
 
     """
@@ -527,43 +590,77 @@ def complete_coord_2d(coord):
     return coord_completed
 
 
-def from_coord_2d_to_binary_surface(coord):
-    """Convert 2-d coordinates to a binary matrix with the surface of the
+def _from_coord_to_boundaries(coord_cyt, coord_nuc=None, coord_rna=None):
+    """Convert 2-d coordinates to a binary matrix with the boundaries of the
     object.
 
     As we manipulate the coordinates of the external boundaries, the relative
     binary matrix has two extra pixels in each dimension. We compensate by
-    keeping only the inside pixels of the object surface.
+    reducing the marge by one in order to keep the same shape for the frame.
+    If others coordinates are provided, the relative binary matrix is build
+    with the same shape as the main coordinates.
 
     Parameters
     ----------
-    coord : np.ndarray, np.uint64
-        Array of coordinates with shape (nb_points, 2).
+    coord_cyt : np.ndarray, np.int64
+        Array of cytoplasm boundaries coordinates with shape (nb_points, 2).
+    coord_nuc : np.ndarray, np.int64
+        Array of nucleus boundaries coordinates with shape (nb_points, 2).
+    coord_rna : np.ndarray, np.int64
+        Array of mRNAs coordinates with shape (nb_points, 2) or
+        (nb_points, 3).
 
     Returns
     -------
-    binary_surface : np.ndarray, np.uint or np.int or bool
-        Binary image with shape (y, x).
+    cyt : np.ndarray, np.uint or np.int or bool
+        Binary image of cytoplasm boundaries with shape (y, x).
+    nuc : np.ndarray, np.uint or np.int or bool
+        Binary image of nucleus boundaries with shape (y, x).
+    rna : np.ndarray, np.uint or np.int or bool
+        Binary image of mRNAs localizations with shape (y, x).
 
     """
-    # check parameters
-    check_array(coord,
-                ndim=2,
-                dtype=[np.int64])
-
-    # from coordinates to binary boundaries
-    boundaries = _from_coord_2d_to_binary_boundaries(coord)
-
-    # from binary boundaries to binary surface
-    binary_surface = from_binary_boundaries_to_binary_surface(boundaries)
-
-    # remove the pixels from the external boundaries
-    binary_surface[boundaries] = False
-
-    return binary_surface
-
+    # initialize parameter
+    nuc, rna = None, None
+    marge = get_offset_value()
+    marge -= 1
 
-def from_binary_boundaries_to_binary_surface(binary_boundaries):
+    # from 2D coordinates boundaries to binary boundaries
+    max_y = coord_cyt[:, 0].max()
+    max_x = coord_cyt[:, 1].max()
+    min_y = coord_cyt[:, 0].min()
+    min_x = coord_cyt[:, 1].min()
+    shape_y = max_y - min_y + 1
+    shape_x = max_x - min_x + 1
+    image_shape = (shape_y + 2 * marge, shape_x + 2 * marge)
+    coord_cyt[:, 0] = coord_cyt[:, 0] - min_y + marge
+    coord_cyt[:, 1] = coord_cyt[:, 1] - min_x + marge
+    cyt = np.zeros(image_shape, dtype=bool)
+    cyt[coord_cyt[:, 0], coord_cyt[:, 1]] = True
+
+    # transform nucleus coordinates with the same parameters
+    if coord_nuc is not None:
+        nuc = np.zeros(image_shape, dtype=bool)
+        coord_nuc[:, 0] = coord_nuc[:, 0] - min_y + marge
+        coord_nuc[:, 1] = coord_nuc[:, 1] - min_x + marge
+        nuc[coord_nuc[:, 0], coord_nuc[:, 1]] = True
+
+    # transform mRNAs coordinates with the same parameters
+    if coord_rna is not None:
+        rna = np.zeros(image_shape, dtype=bool)
+        if coord_rna.shape[1] == 3:
+            coord_rna[:, 1] = coord_rna[:, 1] - min_y + marge
+            coord_rna[:, 2] = coord_rna[:, 2] - min_x + marge
+            rna[coord_rna[:, 1], coord_rna[:, 2]] = True
+        else:
+            coord_rna[:, 0] = coord_rna[:, 0] - min_y + marge
+            coord_rna[:, 1] = coord_rna[:, 1] - min_x + marge
+            rna[coord_rna[:, 0], coord_rna[:, 1]] = True
+
+    return cyt, nuc, rna
+
+
+def from_boundaries_to_surface(binary_boundaries):
     """Fill in the binary matrix representing the boundaries of an object.
 
     Parameters
@@ -588,45 +685,54 @@ def from_binary_boundaries_to_binary_surface(binary_boundaries):
     return binary_surface
 
 
-def _from_coord_2d_to_binary_boundaries(coord):
-    """Convert 2-d coordinates to a binary matrix with the boundaries of the
+def from_coord_to_surface(coord_cyt, coord_nuc=None, coord_rna=None):
+    """Convert 2-d coordinates to a binary matrix with the surface of the
     object.
 
     As we manipulate the coordinates of the external boundaries, the relative
     binary matrix has two extra pixels in each dimension. We compensate by
-    reducing the marge by one in order to keep the same shape for the frame.
+    keeping only the inside pixels of the object surface.
+    If others coordinates are provided, the relative binary matrix is build
+    with the same shape as the main coordinates.
 
     Parameters
     ----------
-    coord : np.ndarray, np.uint64
-        Array of coordinates with shape (nb_points, 2).
+    coord_cyt : np.ndarray, np.int64
+        Array of cytoplasm boundaries coordinates with shape (nb_points, 2).
+    coord_nuc : np.ndarray, np.int64
+        Array of nucleus boundaries coordinates with shape (nb_points, 2).
+    coord_rna : np.ndarray, np.int64
+        Array of mRNAs coordinates with shape (nb_points, 2) or
+        (nb_points, 3).
 
     Returns
     -------
-    binary_boundaries : np.ndarray, np.uint or np.int or bool
-        Binary image with shape (y, x).
+    cyt_surface : np.ndarray, np.uint or np.int or bool
+        Binary image of cytoplasm surface with shape (y, x).
+    nuc_surface : np.ndarray, np.uint or np.int or bool
+        Binary image of nucleus surface with shape (y, x).
+    rna : np.ndarray, np.uint or np.int or bool
+        Binary image of mRNAs localizations with shape (y, x).
 
     """
     # check parameters
-    check_array(coord,
+    check_array(coord_cyt,
                 ndim=2,
                 dtype=[np.int64])
+    if coord_nuc is not None:
+        check_array(coord_nuc,
+                    ndim=2,
+                    dtype=[np.int64])
+    if coord_rna is not None:
+        check_array(coord_rna,
+                    ndim=2,
+                    dtype=[np.int64])
 
-    # initialize parameter
-    marge = get_offset_value()
-    marge -= 1
+    # from coordinates to binary boundaries
+    cyt, nuc, rna = _from_coord_to_boundaries(coord_cyt, coord_nuc, coord_rna)
 
-    # from 2D coordinates boundaries to binary boundaries
-    max_y = coord[:, 0].max()
-    max_x = coord[:, 1].max()
-    min_y = coord[:, 0].min()
-    min_x = coord[:, 1].min()
-    shape_y = max_y - min_y + 1
-    shape_x = max_x - min_x + 1
-    image_shape = (shape_y + 2 * marge, shape_x + 2 * marge)
-    coord[:, 0] = coord[:, 0] - min_y + marge
-    coord[:, 1] = coord[:, 1] - min_x + marge
-    binary_boundaries = np.zeros(image_shape, dtype=bool)
-    binary_boundaries[coord[:, 0], coord[:, 1]] = True
+    # from binary boundaries to binary surface
+    cyt_surface = from_boundaries_to_surface(cyt)
+    nuc_surface = from_boundaries_to_surface(nuc)
 
-    return binary_boundaries
+    return cyt_surface, nuc_surface, rna
diff --git a/bigfish/stack/utils.py b/bigfish/stack/utils.py
index 348b1e89..a1f7c738 100644
--- a/bigfish/stack/utils.py
+++ b/bigfish/stack/utils.py
@@ -536,6 +536,8 @@ def get_offset_value():
         Margin value (in pixels).
 
     """
+    # TODO rename it 'get_margin_value'
+    # should be greater than 2 (maybe 1 is enough)
     return 5
 
 

From 89c3ca461ee6a79eb43dbf54144ff1bf975ed7c4 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 9 Dec 2019 22:45:48 +0100
Subject: [PATCH 263/264] misc and TODO

---
 bigfish/plot/plot_coordinates.py | 1 +
 bigfish/plot/plot_images.py      | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/bigfish/plot/plot_coordinates.py b/bigfish/plot/plot_coordinates.py
index 1bcc8f5c..bcbe2c6b 100644
--- a/bigfish/plot/plot_coordinates.py
+++ b/bigfish/plot/plot_coordinates.py
@@ -442,6 +442,7 @@ def plot_cell(cyt_coord, nuc_coord=None, rna_coord=None, foci_coord=None,
     -------
 
     """
+    # TODO recode it
     # check parameters
     stack.check_array(cyt_coord,
                       ndim=2,
diff --git a/bigfish/plot/plot_images.py b/bigfish/plot/plot_images.py
index d1302636..820a4dda 100644
--- a/bigfish/plot/plot_images.py
+++ b/bigfish/plot/plot_images.py
@@ -509,11 +509,11 @@ def plot_segmentation_boundary(tensor, mask_nuc=None, mask_cyt=None,
     boundaries_nuc = None
     boundaries_cyt = None
     if mask_nuc is not None:
-        boundaries_nuc = find_boundaries(mask_nuc, mode='inner')
+        boundaries_nuc = find_boundaries(mask_nuc, mode='thick')
         boundaries_nuc = np.ma.masked_where(boundaries_nuc == 0,
                                             boundaries_nuc)
     if mask_cyt is not None:
-        boundaries_cyt = find_boundaries(mask_cyt, mode='inner')
+        boundaries_cyt = find_boundaries(mask_cyt, mode='thick')
         boundaries_cyt = np.ma.masked_where(boundaries_cyt == 0,
                                             boundaries_cyt)
 

From 47342cfb6820cef878d5a1804321a86aa0613ca3 Mon Sep 17 00:00:00 2001
From: Arthur Imbert <arthur.imbert.pro@gmail.com>
Date: Mon, 9 Dec 2019 22:46:13 +0100
Subject: [PATCH 264/264] add TODO

---
 bigfish/stack/postprocess.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bigfish/stack/postprocess.py b/bigfish/stack/postprocess.py
index 823444a8..f71077e6 100644
--- a/bigfish/stack/postprocess.py
+++ b/bigfish/stack/postprocess.py
@@ -431,7 +431,7 @@ def _extract_spots_outside_foci(cell_cyt_mask, spots_out_foci):
 
 # ### Segmentation postprocessing ###
 
-# TODO from_binary_surface_to_binary_boundaries
+# TODO add from_binary_surface_to_binary_boundaries
 
 def center_binary_mask(cyt, nuc=None, rna=None):
     """Center a 2-d binary mask (surface or boundaries) and pad it.
@@ -674,6 +674,7 @@ def from_boundaries_to_surface(binary_boundaries):
         Binary image with shape (y, x).
 
     """
+    # TODO check dtype input & output
     # check parameters
     check_array(binary_boundaries,
                 ndim=2,