diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 109b3db2a12014d3f01146592dd98a94f0991899..fccfa6a6aedbf02467344129fa2435fbd8ed4daa 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -2,6 +2,7 @@ stages:
   - build
   - test
   - deploy
+  - versioning
 
 variables:
   MAVEN_OPTS: "-Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository"
@@ -21,10 +22,21 @@ maven:
     paths:
       - target/*.jar
 
+release:
+  image: maven:3.6.3-jdk-11
+  stage: versioning
+  when: manual
+  script:
+    - curl --fail https://raw.githubusercontent.com/scijava/scijava-scripts/main/release-version.sh | bash -s -- --dry-run
+#    script with dry-run option
+#    - curl --fail https://raw.githubusercontent.com/scijava/scijava-scripts/main/release-version.sh | bash -s -- --dry-run
+
+
 
 pages:
   image: maven:3.6.3-jdk-11
   stage: deploy
+  when: manual
   script:
     - mvn javadoc:javadoc
     - mkdir .public
@@ -35,16 +47,59 @@ pages:
       - public
 
 
-selectionParamaterSweep:
+ParamaterSweep_mouche:
   image: maven:3.6.3-jdk-11
   stage: test
   when: manual
   script:
-    - mvn -Dtest=ParameterSweep test
+    - mvn -Dtest=ParameterSweepMouche test
   artifacts:
     paths:
       - target/*.csv
 
+
+ParamaterSweep_cochlée:
+  image: maven:3.6.3-jdk-11
+  stage: test
+  when: manual
+  script:
+    - mvn -Dtest=ParameterSweepCochlee2 test
+  artifacts:
+    paths:
+      - target/*.csv
+
+ParamaterSweep_culture:
+  image: maven:3.6.3-jdk-11
+  stage: test
+  when: manual
+  script:
+    - mvn -Dtest=ParameterSweepCulture test
+  artifacts:
+    paths:
+      - target/*.csv
+
+ParamaterSweep_organoid:
+  image: maven:3.6.3-jdk-11
+  stage: test
+  when: manual
+  script:
+    - mvn -Dtest=ParameterSweepOrganoid test
+  artifacts:
+    paths:
+      - target/*.csv
+
+
+ParamaterSweep_phantom:
+  image: maven:3.6.3-jdk-11
+  stage: test
+  when: manual
+  script:
+    - mvn -Dtest=ParameterSweepPhantom test
+  artifacts:
+    paths:
+      - target/*.csv
+
+
 doubleParamaterSweep:
   image: maven:3.6.3-jdk-11
   stage: test
diff --git a/README.md b/README.md
index c178a77e220d80b11eef9d6e369121becde0d68d..9cad74eb1c504f4773fdf9ac309698097f2b229b 100644
--- a/README.md
+++ b/README.md
@@ -5,8 +5,8 @@
 The program takes a 3D stack as input and generates the projection of all surfaces contained in the 3D stack as 2D
 images. That process can be divided into 3 stages :
 
-- first the selection of all the pixels belonging to any surface
-- second the regrouping of those selected pixels to produce a height map for each surface
+- first the selection of all the pixels belonging to any selectedPixels
+- second the regrouping of those selected pixels to produce a height map for each selectedPixels
 - third the use of each height map to extract a projection according to a given projection's method (only MIP for now).
 
 ![ZelligePipeline](doc/zellige_pipeline.jpg)
diff --git a/doc/Organoid.tif b/doc/Organoid.tif
new file mode 100644
index 0000000000000000000000000000000000000000..7835f2ddfd6e66c44469d387eb0dad922f1ef946
Binary files /dev/null and b/doc/Organoid.tif differ
diff --git a/pom.xml b/pom.xml
index 6fa0e3145087d1f7e6b8a82e83b6f9cb8fca57c7..b2933c0db3268856f3112662bce8738b16e8ca35 100644
--- a/pom.xml
+++ b/pom.xml
@@ -13,7 +13,7 @@
 
     <groupId>org.example</groupId>
     <artifactId>zellige-core</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>1.0.0-SNAPSHOT</version>
 
 
     <name>Zellige-core</name>
@@ -77,6 +77,14 @@
                     </excludes>
                 </configuration>
             </plugin>
+            <!--            <plugin>-->
+            <!--                <groupId>org.apache.maven.plugins</groupId>-->
+            <!--                <artifactId>maven-compiler-plugin</artifactId>-->
+            <!--                <configuration>-->
+            <!--                    <source>8</source>-->
+            <!--                    <target>8</target>-->
+            <!--                </configuration>-->
+            <!--            </plugin>-->
 
         </plugins>
     </build>
@@ -102,6 +110,12 @@
                 </exclusion>
             </exclusions>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/org.jzy3d/jzy3d-svm-mapper -->
+        <dependency>
+            <groupId>org.jzy3d</groupId>
+            <artifactId>jzy3d-svm-mapper</artifactId>
+            <version>2.0.0</version>
+        </dependency>
 
         <dependency>
             <groupId>org.smurn</groupId>
@@ -211,6 +225,21 @@
             <artifactId>powermock-module-junit4</artifactId>
             <version>2.0.9</version>
         </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-controls</artifactId>
+            <version>17.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-fxml</artifactId>
+            <version>17.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-swing</artifactId>
+            <version>18-ea+4</version>
+        </dependency>
 
         <!--        <dependency>-->
         <!--            <groupId>org.jacoco</groupId>-->
@@ -250,6 +279,8 @@
         <license.organizationName>Institut Pasteur</license.organizationName>
         <license.copyrightOwners>Institut Pasteur</license.copyrightOwners>
         <enforcer.skip>true</enforcer.skip>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
     </properties>
 
     <developers>
diff --git a/src/main/java/fr/pasteur/ida/zellige/Main.java b/src/main/java/fr/pasteur/ida/zellige/Main.java
index 0e66c540b8a975da2532fb0e190b58edb4aabd3a..b48a91a5b49c870bad44928a102d5029d2d828cb 100644
--- a/src/main/java/fr/pasteur/ida/zellige/Main.java
+++ b/src/main/java/fr/pasteur/ida/zellige/Main.java
@@ -25,15 +25,16 @@ public class Main
 {
 
 
-    public static < T extends RealType < T > & NativeType < T > > void main( String[] args ) throws Exception
+    public static < T extends RealType< T > & NativeType< T > > void main( String[] args ) throws Exception
     {
         // Launch ImageJ.
         ImageJ ij = new ImageJ();
 
 
         // Input of the image.
-        final String imagePath = args[ 0 ]; /* The image path goes here !!!! */
-
+        final String imagePath =// "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\files\\SNR\\snr_000\\multiSurfaces\\phantoms_snr0.mat.tif";
+                args[ 0 ]; /* The image path goes here !!!! */
+        System.out.println( imagePath );
         /* JY version for opening files. */
         final SCIFIOImgPlus< ? > imgPlus = IO.openImgs( imagePath ).get( 0 );
 
@@ -41,8 +42,8 @@ public class Main
 
 
         /* User Parameters AKA arguments to run the program*/
-        double amplitude = Double.parseDouble( args[ 1 ] );
-        double otsu = Double.parseDouble( args[ 2 ] );
+        int amplitude = Integer.parseInt( args[ 1 ] );
+        int otsu = Integer.parseInt( args[ 2 ] );
         int islandSize = Integer.parseInt( args[ 3 ] );
         int connexity = Integer.parseInt( args[ 4 ] );
         double sigmaXY = Double.parseDouble( args[ 5 ] );
@@ -95,10 +96,10 @@ public class Main
 
         DisplayParameters displayParameters = new DisplayParameters(
                 true,
-                false,
-                false,
                 true,
-                false );
+                true,
+                true,
+                true, true );
         IJ.log( "Type: " + imgPlus.firstElement().getClass().toGenericString() );
 
         if ( stackImage.numDimensions() == 3 )// Is it a stack ?
@@ -107,10 +108,21 @@ public class Main
                     ( stackImage, stackImage.factory() );
             rse.select( pretreatmentParameters, classificationParameters, postTreatmentParameters );
             rse.construct( constructionParameters );
+//            for ( ReferenceSurface< T > referenceSurface : rse.getReferenceSurfaces() )
+//            {
+//                writeHeightMap( referenceSurface.getzMap(), imgPlus.getName(), referenceSurface.getIndex() );
+//            }
 
             if ( ! GraphicsEnvironment.isHeadless() )
             {
-                rse.project( projectionParameters, displayParameters );
+                try
+                {
+                    rse.project( projectionParameters, displayParameters );
+                }
+                catch ( Exception e )
+                {
+                    System.out.println( e.getMessage() );
+                }
             }
         }
         else
diff --git a/src/main/java/fr/pasteur/ida/zellige/ReferenceSurfaceExtraction.java b/src/main/java/fr/pasteur/ida/zellige/ReferenceSurfaceExtraction.java
index f02dcbfde5ce8d4240161a86223dd9ae6aa3287c..e094ffe92641945fb23c0e9c170ba689dcc783a0 100644
--- a/src/main/java/fr/pasteur/ida/zellige/ReferenceSurfaceExtraction.java
+++ b/src/main/java/fr/pasteur/ida/zellige/ReferenceSurfaceExtraction.java
@@ -13,16 +13,25 @@ import fr.pasteur.ida.zellige.steps.projection.NoPossibleDisplayException;
 import fr.pasteur.ida.zellige.steps.projection.ProjectionParameters;
 import fr.pasteur.ida.zellige.steps.projection.ReferenceSurfaceProjection;
 import fr.pasteur.ida.zellige.steps.selection.Selection;
+import fr.pasteur.ida.zellige.steps.selection.classification.AmplitudeClassification;
+import fr.pasteur.ida.zellige.steps.selection.classification.Classification;
 import fr.pasteur.ida.zellige.steps.selection.classification.ClassificationParameters;
+import fr.pasteur.ida.zellige.steps.selection.classification.OtsuClassification;
 import fr.pasteur.ida.zellige.steps.selection.exception.DataValidationException;
 import fr.pasteur.ida.zellige.steps.selection.exception.EmptyOutputException;
 import fr.pasteur.ida.zellige.steps.selection.exception.NoClassificationException;
+import fr.pasteur.ida.zellige.steps.selection.postTreatment.PostTreatment;
 import fr.pasteur.ida.zellige.steps.selection.postTreatment.PostTreatmentParameters;
+import fr.pasteur.ida.zellige.steps.selection.pretreatment.Pretreatment;
 import fr.pasteur.ida.zellige.steps.selection.pretreatment.PretreatmentParameters;
 import net.imglib2.RandomAccessibleInterval;
+import net.imglib2.img.Img;
 import net.imglib2.img.ImgFactory;
+import net.imglib2.img.array.ArrayImgFactory;
 import net.imglib2.type.NativeType;
+import net.imglib2.type.logic.BitType;
 import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.real.FloatType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -40,7 +49,13 @@ public class ReferenceSurfaceExtraction< T extends RealType< T > & NativeType< T
     private final RandomAccessibleInterval< T > input;
     private final ImgFactory< T > factory;
 
+    private final String filter = "GaussianBlur";
+    private final double filterParameter = 2;
+    private Img< FloatType > pretreatedImg;
+    private Img< FloatType > amplitudeImg;
 
+    private Img< FloatType > otsuImg;
+    //    private FloatType otsuValue;
     private Pixels[][] maximums;
     private final static double adequacy = 1;
 
@@ -58,6 +73,9 @@ public class ReferenceSurfaceExtraction< T extends RealType< T > & NativeType< T
     private int SS_smallSurfaces;
     private int SS_goodSurfaces;
     private static final String derivativeMethod = FORWARD;
+    private Img< BitType > selectedAmplitude;
+    private Img< BitType > selectedOtsu;
+    private Img< BitType > selectionOutput;
 
 
     public ReferenceSurfaceExtraction( RandomAccessibleInterval< T > input, ImgFactory< T > factory )
@@ -71,14 +89,52 @@ public class ReferenceSurfaceExtraction< T extends RealType< T > & NativeType< T
         return adequacy;
     }
 
+    public void computeClassificationImages() throws DataValidationException
+    {
+        pretreatedImg = Pretreatment.run( input, filterParameter );
+        computeImages( pretreatedImg );
+    }
+
+    private void computeImages( RandomAccessibleInterval< FloatType > input ) throws DataValidationException
+    {
+        ImgFactory< FloatType > factory = new ArrayImgFactory<>( new FloatType() );
+        amplitudeImg = AmplitudeClassification.computeAmplitudeImage( input, factory );
+        otsuImg = OtsuClassification.computeOtsuImage( input, factory );
+    }
+
+    public void runAmplitudeClassification( int userThreshold )
+    {
+        LOGGER.info( "Amplitude threshold value after user ={}", userThreshold );
+        selectedAmplitude = AmplitudeClassification.applyThreshold( amplitudeImg, userThreshold );
+    }
+
+    public void runOtsuClassification( int userThreshold )
+    {
+        selectedOtsu = OtsuClassification.applyLocalThreshold( pretreatedImg, otsuImg, userThreshold );
+    }
+
+    public void runInterClassification()
+    {
+        selectionOutput = Classification.interClassification( selectedAmplitude, selectedAmplitude.factory(), selectedOtsu );
+        System.out.println( "The selected output has been changed" );
+    }
+
+    public void runPostTreatment( PostTreatmentParameters postTreatmentParameters ) throws DataValidationException
+    {
+        maximums = PostTreatment.run( selectionOutput, postTreatmentParameters );
+    }
+
+
     public void select( PretreatmentParameters pretreatmentParameters, ClassificationParameters classificationParameters, PostTreatmentParameters postTreatmentParameters ) throws NoClassificationException, EmptyOutputException, DataValidationException
     {
         /* First step : Pixel selection */
         LOGGER.info( "Running selection..." );
         maximums = Selection.run( input, pretreatmentParameters, classificationParameters, postTreatmentParameters );
 //        displayMaximums( maximums );
+//        writeSelectedPixels( maximums, "Phantom" );
     }
 
+
     public void construct( ConstructionParameters[] constructionParameters ) throws NoSurfaceFoundException
     {
         LOGGER.info( "Running construction..." );
@@ -109,6 +165,7 @@ public class ReferenceSurfaceExtraction< T extends RealType< T > & NativeType< T
         referenceSurfaces.addAll( ConstructionCompletion.run( input, factory, finalSurfaces ) );
 //        referenceSurfaceInstantiation( finalSurfaces );
         LOGGER.debug( " Constructions of {} surfaces.", referenceSurfaces.size() );
+
     }
 
 
@@ -122,6 +179,17 @@ public class ReferenceSurfaceExtraction< T extends RealType< T > & NativeType< T
         }
     }
 
+
+    public void setMaximums( Pixels[][] maximums )
+    {
+        this.maximums = maximums;
+    }
+
+    public Img< BitType > getSelectionOutput()
+    {
+        return selectionOutput;
+    }
+
     public ArrayList< ReferenceSurface< T > > getReferenceSurfaces()
     {
         return referenceSurfaces;
@@ -203,6 +271,16 @@ public class ReferenceSurfaceExtraction< T extends RealType< T > & NativeType< T
         return SS_startingOS_count;
     }
 
+    public String getFilter()
+    {
+        return filter;
+    }
+
+    public double getFilterParameter()
+    {
+        return filterParameter;
+    }
+
 
 }
 
diff --git a/src/main/java/fr/pasteur/ida/zellige/command/Zellige.java b/src/main/java/fr/pasteur/ida/zellige/command/Zellige.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d26a67db57ad126ab29996dd79ccc98a11a772c
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/command/Zellige.java
@@ -0,0 +1,77 @@
+package fr.pasteur.ida.zellige.command;
+
+
+import fr.pasteur.ida.zellige.gui.MainAppFrame;
+import net.imagej.DatasetService;
+import net.imagej.ImageJ;
+import net.imagej.display.ImageDisplayService;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.scijava.command.Command;
+import org.scijava.log.LogService;
+import org.scijava.plugin.Parameter;
+import org.scijava.plugin.Plugin;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileSystems;
+
+@Plugin( type = Command.class, menuPath = "Plugins>Zellige>" )
+public class Zellige< T extends RealType< T > & NativeType< T > > implements Command
+{
+
+    @Parameter
+    private ImageJ ij;
+
+    @Parameter
+    private LogService logService;
+
+    @Parameter
+    private ImageDisplayService imageDisplayService;
+
+    @Parameter
+    private ImageDisplayService image;
+
+    @Parameter
+    DatasetService datasetService;
+
+
+    public static void main( String[] args ) throws IOException
+    {
+        String currentFolder = FileSystems.getDefault()
+                .getPath( "" )
+                .toAbsolutePath()
+                .toString();
+        String imageFilePath = "doc/Organoid.tif";
+
+        // Launch ImageJ.
+        ImageJ ij = new ImageJ();
+        ij.launch( args );
+
+        // Load the image.
+        Object obj = ij.io().open( new File( currentFolder, imageFilePath ).getAbsolutePath() );
+
+        // for large images
+//        final SCIFIOConfig config = new SCIFIOConfig();
+//        config.imgOpenerSetImgModes( SCIFIOConfig.ImgMode.PLANAR );
+//
+//        final Dataset obj = ij.scifio().datasetIO().open( imageFilePath, config );
+        // Display it.
+        ij.ui().show( obj );
+
+        ij.command().run( Zellige.class, true );
+    }
+
+    @Override
+    public void run()
+    {
+
+        // Launch JavaFX interface
+        MainAppFrame app = new MainAppFrame( ij, image, logService );
+        app.setTitle( "Zellige" );
+        app.init();
+
+    }
+}
+
+
diff --git a/src/main/java/fr/pasteur/ida/zellige/command/ZelligeCommand.java b/src/main/java/fr/pasteur/ida/zellige/command/ZelligeCommand.java
index 39f4992982316f6de6cb85892cde5ab3b005e884..ac863a1a4a9269b4f5a4ed5da7bc24e8274e2408 100644
--- a/src/main/java/fr/pasteur/ida/zellige/command/ZelligeCommand.java
+++ b/src/main/java/fr/pasteur/ida/zellige/command/ZelligeCommand.java
@@ -41,11 +41,11 @@ public class ZelligeCommand< T extends RealType< T > & NativeType< T > > extends
     @Parameter
     private LogService logService;
 
-    @Parameter( label = "Amplitude threshold", min = "0", max = "2", stepSize = "0.1" )
-    private double amplitude = 1;
+    @Parameter( label = "Amplitude threshold", min = "0", max = "255", stepSize = "1" )
+    private int amplitude = 5;
 
-    @Parameter( label = "Otsu threshold", min = "0", max = "2", stepSize = "0.1" )
-    private double otsu = 0.1;
+    @Parameter( label = "Otsu threshold", min = "0", max = "255", stepSize = "1" )
+    private int otsu = 5;
 
     @Parameter( label = "XY blur radius", min = "0", max = "10" )
     private int sigmaXY = 1;
@@ -141,6 +141,23 @@ public class ZelligeCommand< T extends RealType< T > & NativeType< T > > extends
         // Fixed parameters for now...
         String filter = "GaussianBlur";
         double filterParameter = 2;
+        IJ.log( "Input image : " + dataset.getName() );
+        IJ.log( "filter : " + filter );
+        IJ.log( "filter parameter : " + filterParameter );
+        IJ.log( "amplitude  : " + amplitude );
+        IJ.log( "threshold  : " + otsu );
+        IJ.log( "connexity : " + connexity );
+        IJ.log( "island size : " + islandSize );
+        IJ.log( "sigmaXY : " + sigmaXY );
+        IJ.log( "sigmaZ : " + sigmaZ );
+        IJ.log( "starting os size1 : " + startingOsSize1 );
+        IJ.log( "overlap1 :" + overlap1 );
+        IJ.log( "connexityRate1  :" + connexityRate1 );
+        IJ.log( "starting os size2 : " + startingOsSize2 );
+        IJ.log( "overlap2 :" + overlap2 );
+        IJ.log( "connexityRate2  :" + connexityRate2 );
+        IJ.log( "surface Minimum size factor : " + surfaceMinSizeFactor );
+        IJ.log( "delta : " + delta );
         PretreatmentParameters pretreatmentParameters = null;
         try
         {
@@ -187,7 +204,7 @@ public class ZelligeCommand< T extends RealType< T > & NativeType< T > > extends
                 false,
                 false,
                 true,
-                false );
+                false, true );
 
 
         if ( img.numDimensions() == 3 )// Is it a stack ?
diff --git a/src/main/java/fr/pasteur/ida/zellige/command/ZelligeCommandGui.java b/src/main/java/fr/pasteur/ida/zellige/command/ZelligeCommandGui.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c1cc1dee9ff3e4dc5d263fcc40d6a74902825de
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/command/ZelligeCommandGui.java
@@ -0,0 +1,54 @@
+package fr.pasteur.ida.zellige.command;
+
+import net.imagej.ImageJ;
+import net.imagej.display.ImageDisplayService;
+import net.imagej.ops.OpService;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.scijava.command.ContextCommand;
+import org.scijava.log.LogService;
+import org.scijava.plugin.Parameter;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileSystems;
+
+//@Plugin( type = ZelligeCommandGui.class, name = "Zellige", menuPath = "Plugins > Process > Zellige" )
+public class ZelligeCommandGui< T extends RealType< T > & NativeType< T > > extends ContextCommand
+{
+
+    @Parameter
+    protected OpService ops;
+    @Parameter
+    private ImageDisplayService imageDisplayService;
+    @Parameter
+    private LogService logService;
+
+    public static void main( String[] args ) throws IOException
+    {
+        String currentFolder = FileSystems.getDefault()
+                .getPath( "" )
+                .toAbsolutePath()
+                .toString();
+        String imageFilePath = "doc/Cochlée1.tif";
+
+        // Launch ImageJ.
+        ImageJ ij = new ImageJ();
+        ij.launch( args );
+
+        // Load the image.
+        Object obj = ij.io().open( new File( currentFolder, imageFilePath ).getAbsolutePath() );
+
+        // Display it.
+        ij.ui().show( obj );
+
+
+        ij.command().run( ZelligeCommandGui.class, true );
+    }
+
+    @Override
+    public void run()
+    {
+
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/element/Projection.java b/src/main/java/fr/pasteur/ida/zellige/element/Projection.java
index 888d2cb0ebcb42963224b8bbe9caaa2b88c43caa..1a7b9ce4ab1aecf0ba3cfed5f95c1cd06eba7f3f 100644
--- a/src/main/java/fr/pasteur/ida/zellige/element/Projection.java
+++ b/src/main/java/fr/pasteur/ida/zellige/element/Projection.java
@@ -2,38 +2,37 @@ package fr.pasteur.ida.zellige.element;
 
 import net.imglib2.img.Img;
 import net.imglib2.type.NativeType;
+import net.imglib2.type.logic.BitType;
 import net.imglib2.type.numeric.RealType;
 import net.imglib2.type.numeric.integer.UnsignedShortType;
 
 public class Projection< T extends RealType< T > & NativeType< T > >
 {
     private Img< T > projection;
-    private Img< UnsignedShortType > projectionHeightMap;
-    private Img< T > HeightMapSubVolumeMask;
-    private Img< T > extractedHeightMapSubStack;
-//    private int index;
-//    private int delta;
-//    private String projectionType;
+    private Img< UnsignedShortType > extractedHeightMap;
+    private Img< T > segmentedSurface;
+    private Img< T > reduced3DSpace;
+    private Img< BitType > segmentedSurfaceMask;
 
 
-    public Img< T > getHeightMapSubVolumeMask()
+    public Img< T > getSegmentedSurface()
     {
-        return HeightMapSubVolumeMask;
+        return segmentedSurface;
     }
 
-    public void setHeightMapSubVolumeMask( Img< T > heightMapSubVolumeMask )
+    public void setSegmentedSurface( Img< T > segmentedSurface )
     {
-        this.HeightMapSubVolumeMask = heightMapSubVolumeMask;
+        this.segmentedSurface = segmentedSurface;
     }
 
-    public Img< UnsignedShortType > getProjectionHeightMap()
+    public Img< UnsignedShortType > getExtractedHeightMap()
     {
-        return projectionHeightMap;
+        return extractedHeightMap;
     }
 
-    public void setProjectionHeightMap( Img< UnsignedShortType > projectionHeightMap )
+    public void setExtractedHeightMap( Img< UnsignedShortType > extractedHeightMap )
     {
-        this.projectionHeightMap = projectionHeightMap;
+        this.extractedHeightMap = extractedHeightMap;
     }
 
     public Img< T > get()
@@ -46,15 +45,23 @@ public class Projection< T extends RealType< T > & NativeType< T > >
         this.projection = projection;
     }
 
-    public Img< T > getExtractedHeightMapSubStack()
+    public Img< T > getReduced3DSpace()
     {
-        return extractedHeightMapSubStack;
+        return reduced3DSpace;
     }
 
-    public void setExtractedHeightMapSubStack( Img< T > extractedHeightMapSubStack )
+    public void setReduced3DSpace( Img< T > reduced3DSpace )
     {
-        this.extractedHeightMapSubStack = extractedHeightMapSubStack;
+        this.reduced3DSpace = reduced3DSpace;
     }
 
+    public Img< BitType > getSegmentedSurfaceMask()
+    {
+        return segmentedSurfaceMask;
+    }
 
+    public void setSegmentedSurfaceMask( Img< BitType > segmentedSurfaceMask )
+    {
+        this.segmentedSurfaceMask = segmentedSurfaceMask;
+    }
 }
diff --git a/src/main/java/fr/pasteur/ida/zellige/element/Surface.java b/src/main/java/fr/pasteur/ida/zellige/element/Surface.java
index f8e44e2d7097227b222b6bf5970f3545f11b8059..b99ebd67b26690b1abbfc037b43a9d2981bf0b2c 100644
--- a/src/main/java/fr/pasteur/ida/zellige/element/Surface.java
+++ b/src/main/java/fr/pasteur/ida/zellige/element/Surface.java
@@ -118,10 +118,45 @@ public class Surface
             }
 
         }
-        return  inCommon / (double) count;
+        return inCommon / ( double ) count;
     }
-    
-    
+
+    public boolean isTheSameSurfaceAs( Surface other )
+    {
+        for ( int i = 0; i <= this.getHeight() - 1; i++ )
+        {
+            SurfaceLine refLine = this.get( i );
+            if ( refLine != null )
+            {
+                SurfaceLine toTest = other.get( i );
+                if ( toTest != null )
+                {
+
+                    for ( int j = 0; j < refLine.getLength(); j++ )
+                    {
+                        Pixels refPixels = refLine.get( j );
+                        if ( refPixels != null )
+                        {
+                            Pixels pixelsToTest = toTest.get( j );
+                            if ( pixelsToTest != null )
+                            {
+//                            return false;
+//                        }
+                                if ( ! refPixels.equals( pixelsToTest ) )
+                                {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                }
+
+            }
+
+        }
+        return true;
+    }
+
 
     /**
      * Checks if this object shares a majority of {@link Pixels} with an other {@link Surface} object.
@@ -305,8 +340,8 @@ public class Surface
         }
         Surface other = (Surface ) obj;
         {
-            System.out.println(overlappingRate( other ));
             return overlappingRate( other ) == 1;
+//            return isTheSameSurfaceAs( other );
         }
     }
 }
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/ConstructionController.java b/src/main/java/fr/pasteur/ida/zellige/gui/ConstructionController.java
new file mode 100644
index 0000000000000000000000000000000000000000..a12299d0b10c9f3ec3294cf68bbb51db3eb8feef
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/ConstructionController.java
@@ -0,0 +1,76 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+
+import java.net.URL;
+import java.util.ResourceBundle;
+
+public class ConstructionController implements Initializable
+{
+    @FXML
+    private ParameterSliderDouble c1;
+
+    @FXML
+    private ParameterSliderDouble c2;
+
+    @FXML
+    private ParameterSliderInteger r1;
+
+    @FXML
+    private ParameterSliderInteger r2;
+
+    @FXML
+    private ParameterSliderDouble st1;
+
+    @FXML
+    private ParameterSliderDouble st2;
+
+    @FXML
+    private ParameterSliderDouble surfaceSize;
+    public ConstructionController()
+    {
+
+    }
+
+    @Override
+    public void initialize( URL url, ResourceBundle resourceBundle )
+    {
+
+    }
+
+    public double getC1()
+    {
+        return c1.getSlider().getValue();
+    }
+
+    public double getC2()
+    {
+        return c2.getSlider().getValue();
+    }
+
+    public int getR1()
+    {
+        return ( int ) r1.getSlider().getValue();
+    }
+
+    public int getR2()
+    {
+        return ( int ) r2.getSlider().getValue();
+    }
+
+    public double getSt1()
+    {
+        return st1.getSlider().getValue();
+    }
+
+    public double getSt2()
+    {
+        return st2.getSlider().getValue();
+    }
+
+    public double getSurfaceSize()
+    {
+        return surfaceSize.getSlider().getValue();
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/DisplayController.java b/src/main/java/fr/pasteur/ida/zellige/gui/DisplayController.java
new file mode 100644
index 0000000000000000000000000000000000000000..782c99c42d0fb8756e896d5ad0c91d43313966f8
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/DisplayController.java
@@ -0,0 +1,33 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+import javafx.scene.control.CheckBox;
+
+import java.net.URL;
+import java.util.ResourceBundle;
+
+public class DisplayController implements Initializable
+{
+
+    @FXML
+    private CheckBox extractedSurface;
+
+    @FXML
+    private CheckBox heightMapStack;
+
+    @FXML
+    private CheckBox heightMapStackMask;
+
+    @FXML
+    private CheckBox heightmap;
+
+    @FXML
+    private CheckBox projection;
+
+    @Override
+    public void initialize( URL url, ResourceBundle resourceBundle )
+    {
+
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/FileCombobox.java b/src/main/java/fr/pasteur/ida/zellige/gui/FileCombobox.java
new file mode 100644
index 0000000000000000000000000000000000000000..f427c2b53468d3e80097df5f4b34df4dd95db89d
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/FileCombobox.java
@@ -0,0 +1,38 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.scene.control.ComboBox;
+import net.imagej.Dataset;
+
+public class FileCombobox extends ComboBox< Dataset >
+{
+
+    public void setBehavior()
+    {
+        /* Control of the file comboBox*/
+//      setOnMousePressed( event ->
+//    setAndDisplayDatasetChoices() );
+//
+//        activeDataset.getSelectionModel().selectedItemProperty().addListener( ( observableValue, oldValue, newValue ) ->
+//    {
+//        LOGGER.debug( "selectedItemProperty : old value = {}, new value = {} " , oldValue, newValue);
+//        int index = activeDataset.getSelectionModel().getSelectedIndex();
+//        if ( oldValue == null && newValue != null )
+//        {
+//            LOGGER.debug( "case 1" );
+//            Dataset dataset = datasets.get(index);
+//            selectAndLoadNewImage( dataset );
+//        }
+//        else if ( oldValue != null && newValue != null && !oldValue.equals( newValue ))
+//        {
+//            LOGGER.debug( "case 2" );
+//            Dataset dataset = datasets.get(index);
+//            selectAndLoadNewImage( dataset );
+//        }
+//        else if (oldValue == null )
+//        {
+//            LOGGER.debug("case 3");
+//            showError( new NoInputException() );
+//        }
+//    } );
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/ImageFXDisplay.java b/src/main/java/fr/pasteur/ida/zellige/gui/ImageFXDisplay.java
new file mode 100644
index 0000000000000000000000000000000000000000..fabbfa8e81fc68ba308afd6e9324071eeb49962d
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/ImageFXDisplay.java
@@ -0,0 +1,97 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.scene.image.ImageView;
+import javafx.scene.image.PixelFormat;
+import javafx.scene.image.PixelWriter;
+import javafx.scene.image.WritableImage;
+import net.imglib2.Cursor;
+import net.imglib2.IterableInterval;
+import net.imglib2.type.logic.BitType;
+
+public class ImageFXDisplay
+{
+
+
+    private final IterableInterval< BitType > input;
+    private final ImageView[] imageViews;
+    private final int width;
+    private final int height;
+    private final int depth;
+
+
+    public ImageFXDisplay( IterableInterval< BitType > input )
+    {
+        this.input = input;
+
+        width = ( int ) input.dimension( 0 );
+        height = ( int ) input.dimension( 1 );
+        depth = ( int ) input.dimension( 2 );
+        this.imageViews = new ImageView[ depth ];
+
+    }
+
+    public void set()
+    {
+        int[] data2 = convert2( input );
+        for ( int z = 0; z < depth; z++ )
+        {
+            WritableImage writableImage = new WritableImage( width, height );
+            PixelWriter pixelWriter = writableImage.getPixelWriter();
+            pixelWriter.setPixels( 0, 0, width, height, PixelFormat.getIntArgbInstance(), data2, height * width * z, width );
+            this.imageViews[ z ] = new ImageView( writableImage );
+            setImageViews( this.imageViews[ z ] );
+        }
+
+    }
+
+
+    public int[] convert2( IterableInterval< BitType > input )
+    {
+        int[] data = new int[ height * width * depth ];
+        Cursor< BitType > cursor = input.cursor();
+        int index = 0;
+        while ( cursor.hasNext() )
+        {
+            cursor.fwd();
+            if ( cursor.get().get() )
+            {
+                data[ index++ ] = ( 0xFFFFFFFF );
+            }
+            else
+            {
+                data[ index++ ] = 0xFF000000;
+            }
+
+
+        }
+        return data;
+    }
+
+    public ImageView[] getImageViews()
+    {
+        return this.imageViews;
+    }
+
+    public void setImageViews( ImageView imageView )
+    {
+        imageView.setPreserveRatio( true );
+        setFit( imageView );
+
+        imageView.setSmooth( true );
+        imageView.setCache( true );
+    }
+
+    public void setFit( ImageView imageView )
+    {
+        if ( width >= height )
+        {
+            imageView.setFitWidth( 280 );
+        }
+        else
+        {
+            imageView.setFitHeight( 280 );
+        }
+    }
+
+
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/MainAppFrame.java b/src/main/java/fr/pasteur/ida/zellige/gui/MainAppFrame.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1fb9fcf3f68fada41ec4c51fad46b3232b384c8
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/MainAppFrame.java
@@ -0,0 +1,105 @@
+package fr.pasteur.ida.zellige.gui;
+
+import fr.pasteur.ida.zellige.steps.selection.exception.DataValidationException;
+import javafx.application.Platform;
+import javafx.embed.swing.JFXPanel;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Scene;
+import javafx.scene.layout.AnchorPane;
+import net.imagej.ImageJ;
+import net.imagej.display.ImageDisplayService;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.scijava.log.LogService;
+import org.scijava.plugin.Parameter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.swing.*;
+import java.io.IOException;
+import java.util.ResourceBundle;
+
+public class MainAppFrame extends JFrame
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( MainAppFrame.class );
+    private final ImageJ ij;
+    private final ImageDisplayService image;
+    @Parameter
+    private final LogService logService;
+    private JFXPanel fxPanel;
+    private Scene scene;
+
+    public MainAppFrame( ImageJ ij, ImageDisplayService image, LogService logService )
+    {
+        this.ij = ij;
+        this.image = image;
+        this.logService = logService;
+    }
+
+    /**
+     * Create the JFXPanel that make the link between Swing (IJ) and JavaFX
+     * plugin.
+     */
+    public void init()
+    {
+        this.fxPanel = new JFXPanel();
+        this.add( this.fxPanel );
+        this.setVisible( true );
+        LOGGER.info( "JFRAME" );
+
+        // The call to runLater() avoid a mix between JavaFX thread and Swing
+        // thread.
+        Platform.runLater( this::initFX );
+    }
+
+    public < T extends RealType< T > & NativeType< T > > void initFX()
+    {
+        // Init the root layout
+        try
+        {
+            ResourceBundle bundle = ResourceBundle.getBundle( "gui" );// access to properties f
+            FXMLLoader loader = new FXMLLoader( MainAppFrame.class.getClassLoader().getResource( "fr.pasteur.ida.zellige.gui.view/Main.fxml" ), bundle );
+
+            AnchorPane rootLayout = loader.load();
+
+            // Get the controller and add an ImageJ context to it.
+            MainController< T > controller = loader.getController();
+            controller.setMainApp( this );
+
+
+            // Show the scene containing the root layout.
+            scene = new Scene( rootLayout );
+            this.fxPanel.setScene( scene );
+
+            // Resize the JFrame to the JavaFX scene
+            this.setSize( ( int ) scene.getWidth() + 20, ( int ) scene.getHeight() + 30 );
+            controller.initExtraction();
+        }
+        catch ( IOException | DataValidationException e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+
+    public LogService getLogService()
+    {
+        return logService;
+    }
+
+    public ImageJ getIj()
+    {
+        return ij;
+    }
+
+    public ImageDisplayService getImage()
+    {
+        return image;
+    }
+
+    public Scene getScene()
+    {
+        return scene;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/MainController.java b/src/main/java/fr/pasteur/ida/zellige/gui/MainController.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee21be338d3334d4c05f5d8f265b49c758a2e8f7
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/MainController.java
@@ -0,0 +1,305 @@
+package fr.pasteur.ida.zellige.gui;
+
+import fr.pasteur.ida.zellige.ReferenceSurfaceExtraction;
+import fr.pasteur.ida.zellige.element.Pixels;
+import fr.pasteur.ida.zellige.element.ReferenceSurface;
+import fr.pasteur.ida.zellige.element.Surface;
+import fr.pasteur.ida.zellige.gui.exception.NoInputException;
+import fr.pasteur.ida.zellige.gui.task.*;
+import fr.pasteur.ida.zellige.steps.construction.exception.NoSurfaceFoundException;
+import fr.pasteur.ida.zellige.steps.projection.NoPossibleDisplayException;
+import fr.pasteur.ida.zellige.steps.selection.exception.DataValidationException;
+import fr.pasteur.ida.zellige.steps.selection.exception.EmptyOutputException;
+import fr.pasteur.ida.zellige.steps.selection.exception.NoClassificationException;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Button;
+import javafx.scene.control.ComboBox;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontWeight;
+import net.imagej.Dataset;
+import net.imagej.ImgPlus;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import net.imglib2.util.Util;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.ResourceBundle;
+
+public class MainController< T extends RealType< T > & NativeType< T > > implements Initializable
+{
+    private final static Logger LOGGER = LoggerFactory.getLogger( MainController.class );
+
+    @FXML
+    ComboBox< Dataset > activeDataset;
+
+    @FXML
+    private Button runButton;
+
+    @FXML
+    private ConstructionController constructionController;
+
+    @FXML
+    private ProjectionController projectionController;
+
+    @FXML
+    private SelectionController< T > selectionController;
+
+    private ReferenceSurfaceExtraction< T > extraction;
+
+    private Dataset currentDataset;
+
+    private MainAppFrame mainAppFrame;
+
+    private Pixels[][] pixels;
+
+
+    @Override
+    public void initialize( URL url, ResourceBundle resourceBundle )
+    {
+        // run button initialization
+        runButton.setOnAction( actionEvent ->
+        {
+            try
+            {
+                run();
+            }
+            catch ( DataValidationException | EmptyOutputException | NoClassificationException | NoSurfaceFoundException | NoPossibleDisplayException e )
+            {
+                showError( e );
+            }
+        } );
+
+        /* Control of the files comboBox*/
+        activeDataset.setStyle( "-fx-font: 13px \"System\";" );
+        activeDataset.setOnMousePressed( event ->
+                setAndDisplayDatasetChoices() );// the list of open Fiji images is updated
+
+        activeDataset.getSelectionModel().selectedItemProperty().addListener( ( observableValue, oldValue, newValue ) ->
+        {
+            LOGGER.debug( "selectedItemProperty : old value = {}, new value = {} ", oldValue, newValue );
+            if ( oldValue == null && newValue != null )
+            {
+                LOGGER.debug( "case 1" );
+                selectAndLoadNewImage( activeDataset.getSelectionModel().getSelectedItem() );
+            }
+            else if ( oldValue != null && newValue != null && ! oldValue.equals( newValue ) )
+            {
+                LOGGER.debug( "case 2" );
+                selectAndLoadNewImage( newValue );
+            }
+            activeDataset.getEditor().setFont( Font.font( "Symbol", FontWeight.EXTRA_BOLD, 9 ) );
+        } );
+
+
+    }
+
+    public void initExtraction() throws DataValidationException
+    {
+        LOGGER.debug( "Init Extraction" );
+        Dataset dataset = mainAppFrame.getImage().getActiveDataset();
+        if ( dataset == null )
+        {
+            showError( new NoInputException() );
+            return;
+        }
+//        datasets.add( dataset );
+        activeDataset.getItems().add( dataset );
+        LOGGER.debug( "Init Extraction completed" );
+    }
+
+    public void run() throws DataValidationException, EmptyOutputException, NoClassificationException, NoSurfaceFoundException, NoPossibleDisplayException
+    {
+        long[] dims = new long[ currentDataset.numDimensions() ];
+        currentDataset.dimensions( dims );
+        mainAppFrame.getLogService().info( "Zellige received the image: " + currentDataset.getName() );
+        mainAppFrame.getLogService().info( "Size: " + Util.printInterval( currentDataset ) );
+        mainAppFrame.getLogService().info( "Type: " + currentDataset.firstElement().getClass().toGenericString() );
+        mainAppFrame.getLogService().info( "Dimensionality: " + currentDataset.numDimensions() + "D" );
+        for ( int d = 0; d < currentDataset.numDimensions(); d++ )
+        {
+            mainAppFrame.getLogService().info( " - dimension " + d + ": [" + currentDataset.axis( d ).type() + "], 1 unit = " + currentDataset.averageScale( d ) + " " + currentDataset.axis( d ).unit() );
+        }
+        // Fixed parameters
+        String filter = "GaussianBlur";
+        double filterParameter = 2;
+        // End of fixed parameters
+        int connexity = 4;
+
+        double startingOsSize1 = constructionController.getSt1();
+        int overlap1 = constructionController.getR1();
+        double connexityRate1 = constructionController.getC1();
+        double startingOsSize2 = constructionController.getSt2();
+        int overlap2 = constructionController.getR2();
+        double connexityRate2 = constructionController.getC2();
+        double surfaceMinSizeFactor = constructionController.getSurfaceSize();
+        int delta = projectionController.getDelta();
+        String method = projectionController.getMethod();
+        /* Print parameters.*/
+        mainAppFrame.getLogService().info( "Input : " + currentDataset.getName() );
+        mainAppFrame.getLogService().info( "filter : " + filter );
+        mainAppFrame.getLogService().info( "filterParameter : " + filterParameter );
+        mainAppFrame.getLogService().info( "amplitude  : " + getAmplitude() );
+        mainAppFrame.getLogService().info( "threshold  : " + getOtsu() );
+        mainAppFrame.getLogService().info( "connexity : " + connexity );
+        mainAppFrame.getLogService().info( "islandSize : " + getIsland() );
+        mainAppFrame.getLogService().info( "sigmaXY : " + getSigmaXY() );
+        mainAppFrame.getLogService().info( "sigmaZ : " + getSigmaZ() );
+        mainAppFrame.getLogService().info( "startingOsSize1 : " + startingOsSize1 );
+        mainAppFrame.getLogService().info( "overlap1 : " + overlap1 );
+        mainAppFrame.getLogService().info( "connexityRate1  : " + connexityRate1 );
+        mainAppFrame.getLogService().info( "startingOsSize2 : " + startingOsSize2 );
+        mainAppFrame.getLogService().info( "overlap2 : " + overlap2 );
+        mainAppFrame.getLogService().info( "connexityRate2  : " + connexityRate2 );
+        mainAppFrame.getLogService().info( "surfaceMinimumSizeFactor : " + surfaceMinSizeFactor );
+        mainAppFrame.getLogService().info( "delta : " + delta + "\n" );
+        /* End of  Print parameters.*/
+
+
+        AbstractTask< Pixels[][] > runPostTreatmentTask = new RunPostTreatmentTask<>( extraction, getSigmaXY(), getSigmaZ(), getIsland(), connexity );
+        runPostTreatmentTask.setOnSucceeded( workerStateEvent ->
+        {
+            AbstractTask< ArrayList< Surface > > runFirstConstructionTask = new RunFirstConstructionTask(
+                    runPostTreatmentTask.getValue(),
+                    startingOsSize1,
+                    overlap1,
+                    connexityRate1,
+                    surfaceMinSizeFactor );
+            runFirstConstructionTask.setOnSucceeded( workerStateEvent2 ->
+            {
+                AbstractTask< ArrayList< Surface > > runSecondConstructionTask = new RunSecondConstructionTask(
+                        runFirstConstructionTask.getValue(),
+                        startingOsSize2,
+                        overlap2,
+                        connexityRate2,
+                        surfaceMinSizeFactor );
+                runSecondConstructionTask.setOnSucceeded( workerStateEvent3 ->
+                {
+                    ImgPlus< T > input = ( ImgPlus< T > ) currentDataset.getImgPlus();
+                    AbstractTask< ArrayList< ReferenceSurface< T > > > constructionCompletionTask = new ConstructionCompletionTask<>( input, input.factory(), runSecondConstructionTask.getValue() );
+                    constructionCompletionTask.setOnSucceeded( workerStateEvent4 ->
+                    {
+                        extraction.getReferenceSurfaces().addAll( constructionCompletionTask.getValue() );
+                        AbstractTask< Void > projectionTask = new ProjectionTask<>( constructionCompletionTask.getValue(), delta, method,
+                                projectionController.getProjection(),
+                                projectionController.getRawHeightmap(),
+                                projectionController.getExtractedHeightMap(),
+                                projectionController.getReduced3DSpace(),
+                                projectionController.getSegmentedSurface(),
+                                projectionController.getSegmentedSurfaceMask(),
+                                projectionController.getDelta2() );
+                        projectionTask.start();
+                    } );
+                    constructionCompletionTask.start();
+                } );
+                runSecondConstructionTask.start();
+
+            } );
+            runFirstConstructionTask.start();
+        } );
+        runPostTreatmentTask.start();
+
+    }
+
+    private void showError( Exception exception )
+    {
+        Alert alert = new Alert( Alert.AlertType.ERROR );
+        alert.setTitle( "Error alert" );
+        alert.setHeaderText( exception.getMessage() );
+        alert.showAndWait();
+    }
+
+    public void setAndDisplayDatasetChoices()
+    {
+        AbstractTask< ArrayList< Dataset > > displayTask = new DisplayDatasetChoicesTask( mainAppFrame.getImage() );
+        displayTask.setOnSucceeded( workerStateEvent ->
+        {
+            LOGGER.debug( "Datasets displayed successfully" );
+            ObservableList< Dataset > list = FXCollections.observableArrayList( displayTask.getValue() );
+            activeDataset.setItems( list );
+            LOGGER.debug( "item selected : list size = " + list.size() );
+            if ( list.isEmpty() )
+            {
+                showError( new NoInputException() );
+            }
+        } );
+        displayTask.start();
+
+    }
+
+    public void selectAndLoadNewImage( Dataset dataset )
+    {
+        AbstractTask< Dataset > setCurrentDatasetTask = new SetCurrentDatasetTask( dataset );
+        setCurrentDatasetTask.setOnSucceeded( workerStateEvent ->
+        {
+            this.currentDataset = setCurrentDatasetTask.getValue();
+            LOGGER.debug( "Dataset setting successful" );
+            if ( currentDataset != null )
+            {
+                selectionController.disableSliders();
+                AbstractTask< ReferenceSurfaceExtraction< T > > startExtraction = new CreateExtractionTask<>( currentDataset, getAmplitude(), getOtsu() );
+                startExtraction.setOnSucceeded( workerStateEvent2 ->
+                {
+                    this.extraction = startExtraction.getValue();
+                    LOGGER.debug( "Input image loaded" );
+                    activeDataset.getSelectionModel().select( currentDataset );
+                    selectionController.set( this.extraction );
+                    selectionController.displayClassification();
+                    selectionController.enableParameters();
+                    activeDataset.setDisable( false );
+                } );
+                startExtraction.start();
+            }
+            else
+            {
+                LOGGER.debug( "show error!!!" );
+                showError( new NoInputException() );
+            }
+        } );
+        if ( dataset != currentDataset )
+        {
+            selectionController.disableSliders();
+            activeDataset.setDisable( true );
+            setCurrentDatasetTask.start();
+        }
+    }
+
+    public void setMainApp( MainAppFrame mainAppFrame )
+    {
+        this.mainAppFrame = mainAppFrame;
+    }
+
+    public int getAmplitude()
+    {
+        return ( int ) selectionController.getAmplitude().getSlider().getValue();
+    }
+
+    public int getOtsu()
+    {
+        return ( int ) selectionController.getOtsu().getSlider().getValue();
+    }
+
+    public int getIsland()
+    {
+        return ( int ) selectionController.getIsland().getSlider().getValue();
+    }
+
+    public int getSigmaXY()
+    {
+        return ( int ) selectionController.getXyBlur().getSlider().getValue();
+    }
+
+    public int getSigmaZ()
+    {
+        return ( int ) selectionController.getzBlur().getSlider().getValue();
+    }
+
+
+}
+
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/ParameterSlider.java b/src/main/java/fr/pasteur/ida/zellige/gui/ParameterSlider.java
new file mode 100644
index 0000000000000000000000000000000000000000..a561753c562ad92bd439bfbe86f98597adcce954
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/ParameterSlider.java
@@ -0,0 +1,182 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.beans.NamedArg;
+import javafx.beans.property.StringProperty;
+import javafx.css.PseudoClass;
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.control.Label;
+import javafx.scene.control.Slider;
+import javafx.scene.control.TextField;
+import javafx.scene.layout.GridPane;
+
+import java.io.IOException;
+
+public abstract class ParameterSlider extends GridPane
+{
+
+    public static String INTERVAL1 = "[0-9]|[1-4][0-9]|[5][0]";
+    private final String name;
+    private final int minorTickUnit;
+    private final double majorTickUnit, increment, defaultValue, min, max;
+    @FXML
+    private Label label;// Contains the parameter name
+    @FXML
+    private Slider slider;
+    @FXML
+    private TextField textField;
+    private StringProperty userValue;
+    private Number previousValue = 1;
+    private String interval;
+    private PseudoClass errorClass = PseudoClass.getPseudoClass( "error" );
+
+    public ParameterSlider( @NamedArg( "name" ) String name,
+                            @NamedArg( "min" ) double min,
+                            @NamedArg( "max" ) double max,
+                            @NamedArg( "major" ) double majorTickUnit,
+                            @NamedArg( "minor" ) int minorTickUnit,
+                            @NamedArg( "increment" ) double increment,
+                            @NamedArg( "default" ) double defaultValue,
+                            @NamedArg( "interval" ) String interval )
+    {
+        this.name = name;
+        this.majorTickUnit = majorTickUnit;
+        this.minorTickUnit = minorTickUnit;
+        this.min = min;
+        this.max = max;
+        this.increment = increment;
+        this.defaultValue = defaultValue;
+        this.interval = interval;
+        FXMLLoader fxmlLoader = new FXMLLoader( ParameterSlider.class.getClassLoader().getResource( "fr.pasteur.ida.zellige.gui.view/ParameterSlider.fxml" ) );
+        fxmlLoader.setRoot( this );
+        fxmlLoader.setController( this );
+        try
+        {
+            fxmlLoader.load();
+        }
+        catch ( IOException e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+
+    @FXML
+    public void initialize()
+    {
+        this.label.setText( name );
+        slider.setMin( min );
+        slider.setMax( max );
+        slider.setBlockIncrement( increment );
+        slider.setValue( defaultValue );
+        slider.setShowTickMarks( true );
+        slider.setShowTickLabels( true );
+        slider.setMajorTickUnit( majorTickUnit );
+        slider.setMinorTickCount( minorTickUnit );
+        slider.setSnapToTicks( false );
+        userValue = textFieldProperty();
+        textField.getStyleClass().add( "error" );
+        bindProperties();
+        listenerSetting();
+    }
+
+
+    /**
+     * Allows the user to be notified if the input value is not in the slider range
+     */
+    public void listenerSetting()
+    {
+        this.userValueProperty().addListener( event ->
+        {
+            System.out.println( "Changed" );
+            this.getTextField().pseudoClassStateChanged(
+                    this.getErrorClass(), ! this.getTextField().getText().matches( this.getInterval() )
+            );
+        } );
+    }
+
+    public abstract void bindProperties();
+
+
+    public boolean hasChanged( Number newValue )
+    {
+        if ( ! getSlider().isValueChanging() && previousValue != newValue )
+        {
+            previousValue = newValue;
+            return true;
+        }
+        return false;
+    }
+
+
+    public void enable()
+    {
+        this.getSlider().setDisable( false );
+        this.getTextField().setDisable( false );
+    }
+
+    public void disable()
+    {
+        this.getSlider().setDisable( true );
+        this.getTextField().setDisable( true );
+    }
+
+    public StringProperty textFieldProperty()
+    {
+        return textField.textProperty();
+    }
+
+    public String getLabelText()
+    {
+        return labelProperty().get();
+    }
+
+    public StringProperty labelProperty()
+    {
+        return label.textProperty();
+
+    }
+
+    public PseudoClass getErrorClass()
+    {
+        return errorClass;
+    }
+
+    public TextField getTextField()
+    {
+        return textField;
+    }
+
+    public Slider getSlider()
+    {
+        return slider;
+    }
+
+    public void setSlider( Slider slider )
+    {
+        this.slider = slider;
+    }
+
+    public String getUserValue()
+    {
+        return userValue.get();
+    }
+
+    public void setUserValue( String userValue )
+    {
+        this.userValue.set( userValue );
+    }
+
+    public StringProperty userValueProperty()
+    {
+        return userValue;
+    }
+
+    public String getInterval()
+    {
+        return interval;
+    }
+}
+
+
+
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/ParameterSliderDouble.java b/src/main/java/fr/pasteur/ida/zellige/gui/ParameterSliderDouble.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d1f6ac3061d4fb2eca497bfcefdd676ffa473ae
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/ParameterSliderDouble.java
@@ -0,0 +1,51 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.beans.NamedArg;
+import javafx.beans.binding.Bindings;
+import javafx.util.StringConverter;
+import org.apache.commons.math3.util.Precision;
+
+public class ParameterSliderDouble extends ParameterSlider
+{
+
+
+    public ParameterSliderDouble( @NamedArg( "name" ) String name,
+                                  @NamedArg( "min" ) double min,
+                                  @NamedArg( "max" ) double max,
+                                  @NamedArg( "major" ) double majorTickUnit,
+                                  @NamedArg( "minor" ) int minorTickUnit,
+                                  @NamedArg( "increment" ) double increment,
+                                  @NamedArg( "default" ) double defaultValue,
+                                  @NamedArg( "interval" ) String interval )
+    {
+        super( name, min, max, majorTickUnit, minorTickUnit, increment, defaultValue, interval );
+    }
+
+    public void bindProperties()
+    {
+        Bindings.bindBidirectional( this.userValueProperty(), this.getSlider().valueProperty(), new StringConverter< Number >()
+        {
+            final double oldValue = getSlider().valueProperty().doubleValue();
+
+            @Override
+            public String toString( Number number )
+            {
+                System.out.println( Precision.round( number.doubleValue(), 1 ) );
+                return String.valueOf( Precision.round( number.doubleValue(), 1 ) );
+            }
+
+            @Override
+            public Number fromString( String s )
+            {
+                try
+                {
+                    return Double.parseDouble( s );
+                }
+                catch ( NumberFormatException e )
+                {
+                    return oldValue;// set the slider value at the old value
+                }
+            }
+        } );
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/ParameterSliderInteger.java b/src/main/java/fr/pasteur/ida/zellige/gui/ParameterSliderInteger.java
new file mode 100644
index 0000000000000000000000000000000000000000..8674d64ba070898640132767cfb5f2dc0e467035
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/ParameterSliderInteger.java
@@ -0,0 +1,50 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.beans.NamedArg;
+import javafx.beans.binding.Bindings;
+import javafx.util.StringConverter;
+
+public class ParameterSliderInteger extends ParameterSlider
+{
+    public ParameterSliderInteger( @NamedArg( "name" ) String name,
+                                   @NamedArg( "min" ) double min,
+                                   @NamedArg( "max" ) double max,
+                                   @NamedArg( "major" ) double majorTickUnit,
+                                   @NamedArg( "minor" ) int minorTickUnit,
+                                   @NamedArg( "increment" ) double increment,
+                                   @NamedArg( "default" ) double defaultValue,
+                                   @NamedArg( "interval" ) String interval )
+    {
+        super( name, min, max, majorTickUnit, minorTickUnit, increment, defaultValue, interval );
+    }
+
+
+    public void bindProperties()
+    {
+        Bindings.bindBidirectional( this.userValueProperty(), this.getSlider().valueProperty(), new StringConverter< Number >()
+        {
+            final int oldValue = getSlider().valueProperty().intValue();
+
+            @Override
+            public String toString( Number number )
+            {
+                return String.valueOf( number.intValue() );
+            }
+
+            @Override
+            public Number fromString( String s )
+            {
+                try
+                {
+                    return Integer.parseInt( s );
+                }
+                catch ( NumberFormatException e )
+                {
+                    return oldValue;// set the slider value at the old value
+                }
+            }
+        } );
+    }
+
+
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/ProjectionController.java b/src/main/java/fr/pasteur/ida/zellige/gui/ProjectionController.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3dbfcbf9793c2aae224927f3a051624006900b6
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/ProjectionController.java
@@ -0,0 +1,105 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.ComboBox;
+import javafx.scene.control.Spinner;
+import javafx.scene.control.SpinnerValueFactory;
+
+import java.net.URL;
+import java.util.ResourceBundle;
+
+public class ProjectionController implements Initializable
+{
+
+
+    @FXML
+    private Spinner< Integer > deltaSpinner;
+
+    @FXML
+    private ComboBox< String > methodComboBox;
+
+    @FXML
+    private CheckBox extractedHeightMap;
+
+    @FXML
+    private CheckBox segmentedSurface;
+
+    @FXML
+    private CheckBox reduced3DSpace;
+
+    @FXML
+    private CheckBox segmentedSurfaceMask;
+
+    @FXML
+    private CheckBox projection;
+
+    @FXML
+    private CheckBox rawHeightMap;
+
+    @FXML
+    private Spinner< Integer > delta2;
+
+    @Override
+    public void initialize( URL url, ResourceBundle resourceBundle )
+    {
+        SpinnerValueFactory< Integer > valueFactory =//TODO spinner start at 0
+                new SpinnerValueFactory.IntegerSpinnerValueFactory( 1, 30, 0 );
+        deltaSpinner.setValueFactory( valueFactory );
+        ObservableList< String > list = FXCollections.observableArrayList( "MIP", "Mean" );
+        methodComboBox.setItems( list );
+        methodComboBox.getSelectionModel().selectFirst();
+        SpinnerValueFactory< Integer > valueFactory2 =//TODO spinner start at 0
+                new SpinnerValueFactory.IntegerSpinnerValueFactory( 1, 30, 0 );
+        delta2.setValueFactory( valueFactory2 );
+    }
+
+
+    public String getMethod()
+    {
+        return methodComboBox.getValue();
+    }
+
+    public int getDelta()
+    {
+        return deltaSpinner.getValue();
+    }
+
+    public int getDelta2()
+    {
+        return delta2.getValue();
+    }
+
+    public Boolean getSegmentedSurface()
+    {
+        return segmentedSurface.isSelected();
+    }
+
+    public Boolean getReduced3DSpace()
+    {
+        return reduced3DSpace.isSelected();
+    }
+
+    public Boolean getSegmentedSurfaceMask()
+    {
+        return segmentedSurfaceMask.isSelected();
+    }
+
+    public Boolean getRawHeightmap()
+    {
+        return rawHeightMap.isSelected();
+    }
+
+    public Boolean getProjection()
+    {
+        return projection.isSelected();
+    }
+
+    public Boolean getExtractedHeightMap()
+    {
+        return extractedHeightMap.isSelected();
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/SelectionController.java b/src/main/java/fr/pasteur/ida/zellige/gui/SelectionController.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e3e70805e265c01a834792d6cd280c9c3b3d72a
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/SelectionController.java
@@ -0,0 +1,196 @@
+package fr.pasteur.ida.zellige.gui;
+
+import fr.pasteur.ida.zellige.ReferenceSurfaceExtraction;
+import fr.pasteur.ida.zellige.gui.task.AbstractTask;
+import fr.pasteur.ida.zellige.gui.task.ComputeWithNewAmplitudeValueTask;
+import fr.pasteur.ida.zellige.gui.task.ComputeWithNewOtsuValueTask;
+import fr.pasteur.ida.zellige.gui.task.ImageFXDisplayTask;
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+import javafx.geometry.Pos;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.FlowPane;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URL;
+import java.util.ResourceBundle;
+
+public class SelectionController< T extends RealType< T > & NativeType< T > > implements Initializable
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( SelectionController.class );
+    @FXML
+    private ParameterSliderInteger amplitude;
+
+    @FXML
+    private ParameterSliderInteger island;
+
+    @FXML
+    private ParameterSliderInteger otsu;
+
+    @FXML
+    private FlowPane stack;
+
+    @FXML
+    private ParameterSliderInteger xyBlur;
+
+    @FXML
+    private ParameterSliderInteger zBlur;
+
+    @FXML
+    private ZSlicesSlider zSlices;
+
+
+    private ImageView[] imageViews;
+
+    private ReferenceSurfaceExtraction< T > extraction;
+
+
+    private int width;
+
+    @Override
+    public void initialize( URL url, ResourceBundle resourceBundle )
+    {
+        /* Amplitude slider initialization */
+
+        amplitude.getSlider().valueProperty().addListener( ( observableValue, number, newValue ) ->
+        {
+            if ( amplitude.hasChanged( newValue ) )
+            {
+                computeWithNewAmplitudeValue( newValue.intValue() );
+            }
+        } );
+
+        /* Otsu slider initialization */
+        otsu.getSlider().valueProperty().addListener( ( observableValue, number, newValue ) ->
+        {
+            if ( otsu.hasChanged( newValue ) )
+            {
+                computeWithNewOtsuValue( newValue.intValue() );
+            }
+        } );
+
+
+        stack.setAlignment( Pos.CENTER );
+
+        // section Slider initialization
+
+        zSlices.getSlider().valueProperty().addListener( ( observableValue, number, newValue ) ->
+        {
+            int newZValue = newValue.intValue();
+            if ( zSlices.hasChanged( newZValue ) )
+            {
+                System.out.println( "children n° " + newZValue );
+                refreshDisplayOfSelectedPixels();
+            }
+        } );
+    }
+
+    public void computeWithNewAmplitudeValue( int value )
+    {
+        AbstractTask< Void > compute = new ComputeWithNewAmplitudeValueTask<>( extraction, value );
+        compute.setOnSucceeded( workerStateEvent ->
+                refreshDisplayOfSelectedPixels() );
+        compute.start();
+    }
+
+    public void computeWithNewOtsuValue( int value )
+    {
+        AbstractTask< Void > compute = new ComputeWithNewOtsuValueTask<>( extraction, value );
+        compute.setOnSucceeded( workerStateEvent ->
+                refreshDisplayOfSelectedPixels() );
+        compute.start();
+    }
+
+
+    public void displayClassification()
+    {
+        AbstractTask< ImageView[] > task = new ImageFXDisplayTask( extraction.getSelectionOutput() );
+        task.setOnSucceeded( workerStateEvent ->
+        {
+            stack.getChildren().clear();
+            imageViews = task.getValue();
+            if ( ! stack.getChildren().isEmpty() )
+            {
+                System.out.println( "The stack is not empty" );
+                stack.getChildren().remove( 0 );
+            }
+            ImageView i = imageViews[ 0 ];
+            stack.getChildren().add( i );
+            width = ( int ) i.boundsInParentProperty().get().getWidth();
+            this.zSlices.getSlider().setMaxWidth( width );
+            this.zSlices.getSlider().setVisible( true );
+        } );
+        task.start();
+    }
+
+    /**
+     * Displays the slice of the classified stack according to the value of the Z Slider.
+     */
+    public void refreshDisplayOfSelectedPixels()
+    {
+        AbstractTask< ImageView[] > task = new ImageFXDisplayTask( extraction.getSelectionOutput() );
+        task.setOnSucceeded( workerStateEvent ->
+        {
+            imageViews = task.getValue();
+            this.stack.getChildren().clear();// Removal of previous stack
+            ImageView i = imageViews[ zSlices.userValue ];
+//            stack.getChildren().addAll( task.getValue() ); // Addition of new classified stack
+            stack.getChildren().add( i ); // display of selected z slice
+            LOGGER.debug( "Refresh Display successful with " + imageViews.length + " slices" );
+        } );
+        task.start();
+    }
+
+    public void setSliceNumber( int depth )
+    {
+        zSlices.setWidth( depth - 1 );
+    }
+
+    public void set( ReferenceSurfaceExtraction< T > extraction )
+    {
+
+        this.extraction = extraction;
+        this.setSliceNumber( ( int ) extraction.getSelectionOutput().dimension( 2 ) );
+    }
+
+    public void enableParameters()
+    {
+        this.amplitude.enable();
+        this.otsu.enable();
+    }
+
+    public void disableSliders()
+    {
+        this.amplitude.disable();
+        this.otsu.disable();
+    }
+
+    public ParameterSliderInteger getAmplitude()
+    {
+        return amplitude;
+    }
+
+    public ParameterSliderInteger getIsland()
+    {
+        return island;
+    }
+
+    public ParameterSliderInteger getOtsu()
+    {
+        return otsu;
+    }
+
+    public ParameterSliderInteger getXyBlur()
+    {
+        return xyBlur;
+    }
+
+    public ParameterSliderInteger getzBlur()
+    {
+        return zBlur;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/StepPanel.java b/src/main/java/fr/pasteur/ida/zellige/gui/StepPanel.java
new file mode 100644
index 0000000000000000000000000000000000000000..a9d8c8387924085f314994d7ef375ae11b37a225
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/StepPanel.java
@@ -0,0 +1,42 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.beans.NamedArg;
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.control.Label;
+import javafx.scene.layout.VBox;
+
+import java.io.IOException;
+
+public class StepPanel extends VBox
+{
+
+    private final String name;
+    @FXML
+    Label Label2;
+
+
+    public StepPanel( @NamedArg( "name" ) String name )
+    {
+        this.name = name;
+        FXMLLoader fxmlLoader = new FXMLLoader( StepPanel.class.getClassLoader().getResource(
+                "fr.pasteur.ida.zellige.gui.view/StepPanel.fxml" ) );
+        fxmlLoader.setRoot( this );
+        fxmlLoader.setController( this );
+        try
+        {
+            fxmlLoader.load();
+        }
+        catch ( IOException e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+
+    @FXML
+    public void initialize()
+    {
+        this.Label2.setText( name );
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/ZSlicesSlider.java b/src/main/java/fr/pasteur/ida/zellige/gui/ZSlicesSlider.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2b5beb860c71039ab9f9e74407bacc4bad39725
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/ZSlicesSlider.java
@@ -0,0 +1,72 @@
+package fr.pasteur.ida.zellige.gui;
+
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.control.Slider;
+import javafx.scene.layout.FlowPane;
+
+import java.io.IOException;
+
+public class ZSlicesSlider extends FlowPane
+{
+
+    @FXML
+    Slider slider;
+
+    int userValue;
+
+    public ZSlicesSlider()
+    {
+        FXMLLoader fxmlLoader = new FXMLLoader( ParameterSlider.class.getClassLoader().getResource(
+                "fr.pasteur.ida.zellige.gui.view/ZSlicesSlider.fxml" ) );
+        fxmlLoader.setRoot( this );
+        fxmlLoader.setController( this );
+        try
+        {
+            fxmlLoader.load();
+        }
+        catch ( IOException e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    @FXML
+    public void initialize()
+    {
+        slider.setMin( 0 );
+        slider.setMax( 30 );
+        slider.setBlockIncrement( 1 );
+        slider.setValue( 0 );
+        slider.setShowTickMarks( true );
+        slider.setShowTickLabels( true );
+        slider.setMajorTickUnit( 5 );
+        slider.setMinorTickCount( 4 );
+        slider.setSnapToTicks( true );
+    }
+
+    public Slider getSlider()
+    {
+        return slider;
+    }
+
+    public boolean hasChanged( int newValue )
+    {
+        if ( userValue != newValue )
+        {
+            userValue = newValue;
+            return true;
+        }
+        return false;
+    }
+
+    public int getUserValue()
+    {
+        return userValue;
+    }
+
+    public void setWidth( int length )
+    {
+        slider.setMax( length );
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/exception/NoA3DStackException.java b/src/main/java/fr/pasteur/ida/zellige/gui/exception/NoA3DStackException.java
new file mode 100644
index 0000000000000000000000000000000000000000..20711ebd3c8b09e6d6554c04c852ae9ff0159ecc
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/exception/NoA3DStackException.java
@@ -0,0 +1,13 @@
+package fr.pasteur.ida.zellige.gui.exception;
+
+public class NoA3DStackException extends Exception
+{
+
+    final String message = "The input image has to be 3D stack ! ";
+
+    @Override
+    public String getMessage()
+    {
+        return message;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/exception/NoInputException.java b/src/main/java/fr/pasteur/ida/zellige/gui/exception/NoInputException.java
new file mode 100644
index 0000000000000000000000000000000000000000..e491f0135d6df7c99bedfaef759467ebd3bfa5a4
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/exception/NoInputException.java
@@ -0,0 +1,13 @@
+package fr.pasteur.ida.zellige.gui.exception;
+
+public class NoInputException extends Exception
+{
+
+    final String message = "Please load a 3D stack before running Zellige";
+
+    @Override
+    public String getMessage()
+    {
+        return message;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/exception/NotANumberException.java b/src/main/java/fr/pasteur/ida/zellige/gui/exception/NotANumberException.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e871564c10bc3f1dff0b3f620d1662959ef4564
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/exception/NotANumberException.java
@@ -0,0 +1,14 @@
+package fr.pasteur.ida.zellige.gui.exception;
+
+public class NotANumberException extends Exception
+{
+
+    private final String message = "Please enter a number !";
+
+
+    @Override
+    public String getMessage()
+    {
+        return message;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/selection/Container.java b/src/main/java/fr/pasteur/ida/zellige/gui/selection/Container.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc5e4970766af30d55d96181cabb76c262ec49e0
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/selection/Container.java
@@ -0,0 +1,17 @@
+package fr.pasteur.ida.zellige.gui.selection;
+
+import javafx.fxml.Initializable;
+
+import java.net.URL;
+import java.util.ResourceBundle;
+
+public class Container implements Initializable
+{
+
+
+    @Override
+    public void initialize( URL url, ResourceBundle resourceBundle )
+    {
+
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/selection/IslandSearch.fxml b/src/main/java/fr/pasteur/ida/zellige/gui/selection/IslandSearch.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..d39077c4cc052bcd9f6cb205fbebd32c2ca87f49
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/selection/IslandSearch.fxml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+
+<?import javafx.scene.control.CheckBox?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.RadioButton?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.Pane?>
+<AnchorPane xmlns:fx="http://javafx.com/fxml/1" prefHeight="100.0" prefWidth="291.0" xmlns="http://javafx.com/javafx/17"
+            fx:controller="IslandSearchP">
+    <children>
+        <Pane prefHeight="50.0" prefWidth="291.0">
+            <children>
+                <Label layoutX="111.0" layoutY="14.0" text="Island Search"/>
+            </children>
+        </Pane>
+        <HBox alignment="TOP_CENTER" layoutY="56.0" prefHeight="50.0" prefWidth="291.0">
+            <children>
+                <CheckBox mnemonicParsing="false" text="Enable"/>
+                <RadioButton mnemonicParsing="false" text="4-connectivity"/>
+                <RadioButton mnemonicParsing="false" text="8-connectivity"/>
+            </children>
+        </HBox>
+    </children>
+</AnchorPane>
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/selection/IslandSearchP.java b/src/main/java/fr/pasteur/ida/zellige/gui/selection/IslandSearchP.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe2aa273869a9f6fe7dc0642c18040138870eb76
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/selection/IslandSearchP.java
@@ -0,0 +1,18 @@
+package fr.pasteur.ida.zellige.gui.selection;
+
+import javafx.fxml.FXML;
+import javafx.scene.control.CheckBox;
+
+public class IslandSearchP
+{
+    @FXML
+    private CheckBox enableISCheckbox;
+
+
+    private void doSomething()
+    {
+
+    }
+
+
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/AbstractTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/AbstractTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..74b0ee9ee1960d56ad0065bb76a6102b74e9477b
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/AbstractTask.java
@@ -0,0 +1,17 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import javafx.concurrent.Task;
+
+public class AbstractTask< T > extends Task< T >
+{
+    @Override
+    protected T call() throws Exception
+    {
+        return null;
+    }
+
+    public void start()
+    {
+        new Thread( this ).start();
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/CheckParameterValueTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/CheckParameterValueTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c5364f65c98827bc52a667cf7533543e3fb9879
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/CheckParameterValueTask.java
@@ -0,0 +1,62 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.gui.exception.NotANumberException;
+import fr.pasteur.ida.zellige.steps.selection.exception.DataValidationException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CheckParameterValueTask extends AbstractTask< Void >
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( CheckParameterValueTask.class );
+    private final String value;
+    private final String parameter;
+
+    public CheckParameterValueTask( String value, String parameter )
+    {
+        this.value = value;
+        this.parameter = parameter;
+    }
+
+    @Override
+    protected Void call() throws Exception
+    {
+
+        try
+        {
+            double v = Double.parseDouble( value );
+            if ( v < 0 )
+            {
+                LOGGER.debug( "The parameter {} is INVALID.", parameter );
+                throw new DataValidationException( "This parameter value has to be superior to zero !" );
+            }
+
+            if ( ( parameter.equals( "Amplitude" ) || parameter.equals( "Otsu" ) ||
+                    parameter.equals( "Stating threshold" ) || parameter.equals( "Connexity" ) ) && v > 1 )
+            {
+                LOGGER.debug( "The parameter {} is INVALID.", parameter );
+                throw new DataValidationException( "This parameter value has to be inferior or equals to 1!" );
+            }
+            else if ( parameter.equals( "xy Blur" ) || parameter.equals( "z Blur" ) && v > 10 )
+            {
+                LOGGER.debug( "The parameter {} is INVALID.", parameter );
+                throw new DataValidationException( "This parameter value has to be inferior or equals to 10!" );
+            }
+            else
+            {
+                if ( v > 50 )
+                {
+                    LOGGER.debug( "The parameter {} is INVALID.", parameter );
+                    throw new DataValidationException( "This parameter value has to be inferior or equals to 50!" );
+                }
+            }
+        }
+        catch ( NumberFormatException e )
+        {
+            LOGGER.debug( "The parameter {} is INVALID.", parameter );
+            throw new NotANumberException();
+        }
+        LOGGER.debug( "The parameter {} is VALID", parameter );
+        return null;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/ComputeWithNewAmplitudeValueTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/ComputeWithNewAmplitudeValueTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a1596e71310d424edcbf4c5edd98f29ad8dd6a7
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/ComputeWithNewAmplitudeValueTask.java
@@ -0,0 +1,37 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.ReferenceSurfaceExtraction;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ComputeWithNewAmplitudeValueTask< T extends RealType< T > & NativeType< T > > extends AbstractTask< Void >
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( ComputeWithNewAmplitudeValueTask.class );
+    private final ReferenceSurfaceExtraction< T > extraction;
+    private final int newAmplitudeThresholdValue;
+
+    public ComputeWithNewAmplitudeValueTask( ReferenceSurfaceExtraction< T > extraction, int newAmplitudeThresholdValue )
+    {
+        this.extraction = extraction;
+        this.newAmplitudeThresholdValue = newAmplitudeThresholdValue;
+    }
+
+    @Override
+    protected Void call() throws Exception
+    {
+        if ( extraction.getSelectionOutput() == null )
+        {
+            updateMessage( "NoClassificationException" );
+            LOGGER.debug( "No Amplitude classification performed." );
+            this.cancelled();
+
+        }
+        extraction.runAmplitudeClassification( newAmplitudeThresholdValue );
+        extraction.runInterClassification();
+        LOGGER.debug( "Amplitude classification completed." );
+        return null;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/ComputeWithNewOtsuValueTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/ComputeWithNewOtsuValueTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..c6f9ed1a13f72183d099316705ad03040a703a85
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/ComputeWithNewOtsuValueTask.java
@@ -0,0 +1,37 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.ReferenceSurfaceExtraction;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ComputeWithNewOtsuValueTask< T extends RealType< T > & NativeType< T > > extends AbstractTask< Void >
+{
+    private final static Logger LOGGER = LoggerFactory.getLogger( ComputeWithNewOtsuValueTask.class );
+
+    private final ReferenceSurfaceExtraction< T > extraction;
+    private final int newAmplitudeThresholdValue;
+
+    public ComputeWithNewOtsuValueTask( ReferenceSurfaceExtraction< T > extraction, int newOtsuThresholdValue )
+    {
+        this.extraction = extraction;
+        this.newAmplitudeThresholdValue = newOtsuThresholdValue;
+    }
+
+    @Override
+    protected Void call() throws Exception
+    {
+        if ( extraction.getSelectionOutput() == null )
+        {
+            updateMessage( "NoClassificationException" );
+            LOGGER.debug( "No Otsu classification performed." );
+            this.cancelled();
+
+        }
+        extraction.runOtsuClassification( newAmplitudeThresholdValue );
+        extraction.runInterClassification();
+        LOGGER.debug( "Otsu classification completed." );
+        return null;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/ConstructionCompletionTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/ConstructionCompletionTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..ceb55dea8245fb2703d1d5a79637bb15a57a1406
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/ConstructionCompletionTask.java
@@ -0,0 +1,37 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.element.ReferenceSurface;
+import fr.pasteur.ida.zellige.element.Surface;
+import fr.pasteur.ida.zellige.steps.construction.ConstructionCompletion;
+import net.imglib2.RandomAccessibleInterval;
+import net.imglib2.img.ImgFactory;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+
+public class ConstructionCompletionTask< T extends RealType< T > & NativeType< T > > extends AbstractTask< ArrayList< ReferenceSurface< T > > >
+{
+    private final static Logger LOGGER = LoggerFactory.getLogger( ConstructionCompletion.class );
+    private final RandomAccessibleInterval< T > input;
+    private final ImgFactory< T > factory;
+    private final ArrayList< Surface > finalSurfaces;
+
+
+    public ConstructionCompletionTask( RandomAccessibleInterval< T > input, ImgFactory< T > factory, ArrayList< Surface > finalSurfaces )
+    {
+        this.input = input;
+        this.factory = factory;
+        this.finalSurfaces = finalSurfaces;
+    }
+
+    @Override
+    protected ArrayList< ReferenceSurface< T > > call() throws Exception
+    {
+        LOGGER.debug( "Construction completion completed." );
+        return ConstructionCompletion.run( input, factory, finalSurfaces );
+
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/CreateExtractionTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/CreateExtractionTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..7af123d760e9c90af617e9d97774deb50c202755
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/CreateExtractionTask.java
@@ -0,0 +1,47 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.ReferenceSurfaceExtraction;
+import net.imagej.Dataset;
+import net.imagej.ImgPlus;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+/**
+ * This task is performed each time a new input image is selected in the file combobox.
+ *
+ * @param <T> the input image type
+ */
+public class CreateExtractionTask< T extends RealType< T > & NativeType< T > > extends AbstractTask< ReferenceSurfaceExtraction< T > >
+{
+    private final static Logger LOGGER = LoggerFactory.getLogger( CreateExtractionTask.class );
+    private final Dataset dataset;
+    private final int amplitudeThresholdValue;
+    private final int otsuThresholdValue;
+
+    public CreateExtractionTask( Dataset dataset, int amplitudeThresholdValue, int otsuThresholdValue )
+    {
+        this.dataset = dataset;
+
+        this.amplitudeThresholdValue = amplitudeThresholdValue;
+        this.otsuThresholdValue = otsuThresholdValue;
+    }
+
+    @Override
+    protected ReferenceSurfaceExtraction< T > call() throws Exception
+    {
+        ImgPlus< T > input = ( ImgPlus< T > ) dataset.getImgPlus();
+        ReferenceSurfaceExtraction< T > extraction = new ReferenceSurfaceExtraction<>( input, input.factory() );
+        extraction.computeClassificationImages();
+        LOGGER.debug( "Classification images computed" );
+        extraction.runAmplitudeClassification( amplitudeThresholdValue );
+        LOGGER.debug( "Otsu classification completed" );
+        extraction.runOtsuClassification( otsuThresholdValue );
+        LOGGER.debug( "Amplitude classification completed" );
+        extraction.runInterClassification();
+        LOGGER.debug( "Inter classification completed" );
+        return extraction;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/DisplayDatasetChoicesTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/DisplayDatasetChoicesTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..1993dbcbf33918c79d8b171bf5af894420f9a327
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/DisplayDatasetChoicesTask.java
@@ -0,0 +1,33 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import net.imagej.Dataset;
+import net.imagej.display.ImageDisplay;
+import net.imagej.display.ImageDisplayService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+
+public class DisplayDatasetChoicesTask extends AbstractTask< ArrayList< Dataset > >
+{
+    private final static Logger LOGGER = LoggerFactory.getLogger( DisplayDatasetChoicesTask.class );
+    private final ImageDisplayService imageDisplayService;
+
+    public DisplayDatasetChoicesTask( ImageDisplayService imageDisplayService )
+    {
+        this.imageDisplayService = imageDisplayService;
+    }
+
+    @Override
+    protected ArrayList< Dataset > call() throws Exception
+    {
+        ArrayList< ImageDisplay > imageDisplays = ( ArrayList< ImageDisplay > ) imageDisplayService.getImageDisplays();
+        ArrayList< Dataset > tempDatasets = new ArrayList<>( imageDisplays.size() );
+        for ( ImageDisplay imageDisplay : imageDisplays )
+        {
+            tempDatasets.add( imageDisplayService.getActiveDataset( imageDisplay ) );
+        }
+        LOGGER.debug( "Available datasets updated." );
+        return tempDatasets;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/ImageFXDisplayTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/ImageFXDisplayTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3fc2e9d39248763df8418e5c9fd35fbda744c11
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/ImageFXDisplayTask.java
@@ -0,0 +1,29 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.gui.ImageFXDisplay;
+import javafx.scene.image.ImageView;
+import net.imglib2.IterableInterval;
+import net.imglib2.type.logic.BitType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ImageFXDisplayTask extends AbstractTask< ImageView[] >
+{
+    private final static Logger LOGGER = LoggerFactory.getLogger( ImageFXDisplayTask.class );
+    private final IterableInterval< BitType > input;
+
+    public ImageFXDisplayTask( IterableInterval< BitType > input )
+    {
+        this.input = input;
+    }
+
+
+    @Override
+    protected ImageView[] call() throws Exception
+    {
+        ImageFXDisplay display = new ImageFXDisplay( input );
+        display.set();
+        LOGGER.debug( "Classified image updated." );
+        return display.getImageViews();
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/NewClassificationTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/NewClassificationTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..0fcf8f8b306e41a0a3ef2c0bfa6f4fe6c0696d53
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/NewClassificationTask.java
@@ -0,0 +1,48 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.ReferenceSurfaceExtraction;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NewClassificationTask< T extends RealType< T > & NativeType< T > > extends AbstractTask< Void >
+{
+    private final Logger LOGGER = LoggerFactory.getLogger( NewClassificationTask.class );
+    private final ReferenceSurfaceExtraction< T > extraction;
+
+    private final int amplitude;
+    private final int otsu;
+
+    public NewClassificationTask( ReferenceSurfaceExtraction< T > extraction, int amplitude, int otsu )
+    {
+        this.extraction = extraction;
+        this.amplitude = amplitude;
+        this.otsu = otsu;
+    }
+
+    @Override
+    protected Void call() throws Exception
+    {
+        extraction.computeClassificationImages();
+        LOGGER.debug( "Images computed." );
+        extraction.runAmplitudeClassification( amplitude );
+        LOGGER.debug( "Amplitude classification done." );
+        extraction.runOtsuClassification( otsu );
+        LOGGER.debug( "Otsu classification done." );
+        extraction.runInterClassification();
+        LOGGER.debug( "InterClassification done." );
+        return null;
+    }
+
+
+//
+    @Override
+    protected void succeeded()
+    {
+        super.succeeded();
+        LOGGER.debug( "Task successful." );
+    }
+
+
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/ProjectionTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/ProjectionTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d72d43ab73657a66b204c32f76ecd855b0bd882
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/ProjectionTask.java
@@ -0,0 +1,65 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.element.ReferenceSurface;
+import fr.pasteur.ida.zellige.steps.projection.ReferenceSurfaceProjection;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+
+public class ProjectionTask< T extends RealType< T > & NativeType< T > > extends AbstractTask< Void >
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( ProjectionTask.class );
+    private final ArrayList< ReferenceSurface< T > > referenceSurfaces;
+    private final int delta;
+    private final String projectionType;
+    private final boolean projectionDisplay;// the projection
+    private final boolean rawHeightMapDisplay;// the raw height map extracted by Zellige before projection
+    private final boolean extractedHeightMapDisplay;// the height map after projection
+    private final boolean reduced3DSpaceDisplay; // the volume of surface +- delta
+    private final boolean segmentedSurfaceDisplay; // the surface segmented in the 3D original volume
+    private final boolean segmentedSurfaceMaskDisplay; // the mask of the segmented surface +- delta
+    private final int delta2;
+
+    public ProjectionTask( ArrayList< ReferenceSurface< T > > referenceSurfaces, int delta, String projectionType,
+                           boolean projectionDisplay,
+                           boolean rawHeightMapDisplay,
+                           boolean extractedHeightMapDisplay,
+                           boolean reduced3DSpaceDisplay,
+                           boolean segmentedSurfaceDisplay,
+                           boolean segmentedSurfaceMaskDisplay, int delta2 )
+    {
+        this.referenceSurfaces = referenceSurfaces;
+        this.delta = delta;
+        this.projectionType = projectionType;
+        this.projectionDisplay = projectionDisplay;
+        this.rawHeightMapDisplay = rawHeightMapDisplay;
+        this.extractedHeightMapDisplay = extractedHeightMapDisplay;
+        this.reduced3DSpaceDisplay = reduced3DSpaceDisplay;
+        this.segmentedSurfaceDisplay = segmentedSurfaceDisplay;
+        this.segmentedSurfaceMaskDisplay = segmentedSurfaceMaskDisplay;
+        this.delta2 = delta2;
+    }
+
+
+    @Override
+    protected Void call() throws Exception
+    {
+        for ( ReferenceSurface< T > referenceSurface : referenceSurfaces )
+        {
+            referenceSurface.init();
+            ReferenceSurfaceProjection.run( referenceSurface, delta, projectionType,
+                    projectionDisplay,
+                    rawHeightMapDisplay,
+                    extractedHeightMapDisplay,
+                    reduced3DSpaceDisplay,
+                    segmentedSurfaceDisplay,
+                    segmentedSurfaceMaskDisplay, delta2 );
+        }
+        LOGGER.debug( "Projection completed." );
+        return null;
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/RunFirstConstructionTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/RunFirstConstructionTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..dcbc9023f4657b6022b35c2d6485ad046fe52038
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/RunFirstConstructionTask.java
@@ -0,0 +1,40 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.element.Pixels;
+import fr.pasteur.ida.zellige.element.Surface;
+import fr.pasteur.ida.zellige.steps.construction.rounds.FirstRoundConstruction;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+
+public class RunFirstConstructionTask extends AbstractTask< ArrayList< Surface > >
+{
+    private final static Logger LOGGER = LoggerFactory.getLogger( RunFirstConstructionTask.class );
+    private final Pixels[][] selectedPixels;
+    private final double startingOsSize1;
+    private final int overlap1;
+    private final double connexityRate1;
+    private final double surfaceMinSizeFactor;
+
+    public RunFirstConstructionTask( Pixels[][] selectedPixels, double startingOsSize1, int overlap1, double connexityRate1, double surfaceMinSizeFactor )
+    {
+        this.selectedPixels = selectedPixels;
+        this.startingOsSize1 = startingOsSize1;
+        this.overlap1 = overlap1;
+        this.connexityRate1 = connexityRate1;
+        this.surfaceMinSizeFactor = surfaceMinSizeFactor;
+    }
+
+    @Override
+    protected ArrayList< Surface > call() throws Exception
+    {
+        FirstRoundConstruction step1 = new FirstRoundConstruction( selectedPixels, startingOsSize1, overlap1, connexityRate1, surfaceMinSizeFactor );
+        step1.process();
+        LOGGER.debug( "First round task completed." );
+        return step1.getSurfaces();
+
+    }
+
+
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/RunPostTreatmentTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/RunPostTreatmentTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..c36ab37a6e2c0cc3862b8a21b9fa70582db8f128
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/RunPostTreatmentTask.java
@@ -0,0 +1,37 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.ReferenceSurfaceExtraction;
+import fr.pasteur.ida.zellige.element.Pixels;
+import fr.pasteur.ida.zellige.steps.selection.postTreatment.PostTreatment;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class RunPostTreatmentTask< T extends RealType< T > & NativeType< T > > extends AbstractTask< Pixels[][] >
+
+{
+    private final static Logger LOGGER = LoggerFactory.getLogger( RunPostTreatmentTask.class );
+    private final ReferenceSurfaceExtraction< T > extraction;
+    private final double sigmaXY;
+    private final double sigmaZ;
+    private final int islandSize;
+    private final int connexity;
+
+    public RunPostTreatmentTask( ReferenceSurfaceExtraction< T > extraction, double sigmaXY, double sigmaZ, int islandSize, int connexity )
+    {
+        this.extraction = extraction;
+        this.sigmaXY = sigmaXY;
+        this.sigmaZ = sigmaZ;
+        this.islandSize = islandSize;
+
+        this.connexity = connexity;
+    }
+
+    @Override
+    protected Pixels[][] call() throws Exception
+    {
+        LOGGER.debug( "Task's start." );
+        return PostTreatment.run( extraction.getSelectionOutput(), sigmaXY, sigmaZ, islandSize, connexity );
+    }
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/RunSecondConstructionTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/RunSecondConstructionTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..d0062e0c839403304adb008f69794bca5990e389
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/RunSecondConstructionTask.java
@@ -0,0 +1,39 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+import fr.pasteur.ida.zellige.element.Surface;
+import fr.pasteur.ida.zellige.steps.construction.rounds.SecondRoundConstruction;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+
+public class RunSecondConstructionTask extends AbstractTask< ArrayList< Surface > >
+{
+    private final static Logger LOGGER = LoggerFactory.getLogger( RunSecondConstructionTask.class );
+    private final ArrayList< Surface > tempSurfaces;
+
+    private final double startingOsSize2;
+    private final int overlap2;
+    private final double connexityRate2;
+    private final double surfaceMinSizeFactor;
+
+    public RunSecondConstructionTask( ArrayList< Surface > tempSurfaces, double startingOsSize2, int overlap2, double connexityRate2, double surfaceMinSizeFactor )
+    {
+        this.tempSurfaces = tempSurfaces;
+        this.startingOsSize2 = startingOsSize2;
+        this.overlap2 = overlap2;
+        this.connexityRate2 = connexityRate2;
+        this.surfaceMinSizeFactor = surfaceMinSizeFactor;
+    }
+
+    @Override
+    protected ArrayList< Surface > call() throws Exception
+    {
+        SecondRoundConstruction step1 = new SecondRoundConstruction( tempSurfaces, startingOsSize2, overlap2, connexityRate2, surfaceMinSizeFactor );
+        step1.process();
+        LOGGER.debug( "Second round task completed." );
+        return step1.getSurfaces();
+    }
+
+
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/gui/task/SetCurrentDatasetTask.java b/src/main/java/fr/pasteur/ida/zellige/gui/task/SetCurrentDatasetTask.java
new file mode 100644
index 0000000000000000000000000000000000000000..1763e6fe3b1c399e75b1b719aab09dc9b2980e30
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/gui/task/SetCurrentDatasetTask.java
@@ -0,0 +1,43 @@
+package fr.pasteur.ida.zellige.gui.task;
+
+
+import net.imagej.Dataset;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SetCurrentDatasetTask extends AbstractTask< Dataset >
+
+{
+    private final Logger LOGGER = LoggerFactory.getLogger( SetCurrentDatasetTask.class );
+    private final Dataset dataset;
+
+
+    public SetCurrentDatasetTask( Dataset dataset )
+    {
+        this.dataset = dataset;
+        LOGGER.debug( " constructor" );
+    }
+
+    @Override
+    protected Dataset call() throws Exception
+    {
+        LOGGER.debug( "Task's start." );
+        if ( dataset.numDimensions() != 3 )
+        {
+            LOGGER.debug( "This input is not a z-stack" );
+            return null;
+        }
+        return dataset;
+    }
+
+
+    //
+    @Override
+    protected void succeeded()
+    {
+        super.succeeded();
+        LOGGER.debug( "Task successful" );
+    }
+
+
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/construction/ConstructionCompletion.java b/src/main/java/fr/pasteur/ida/zellige/steps/construction/ConstructionCompletion.java
index 259d5ea484444cf0ff6cb6c76bf0c29d23300779..d61951dba538debecdf8b1aaba2652415493c6ef 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/construction/ConstructionCompletion.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/construction/ConstructionCompletion.java
@@ -17,6 +17,7 @@ import net.imglib2.util.Util;
 
 import java.util.ArrayList;
 
+
 /**
  * This class allows to get a height map from a {@link Surface} by averaging the Z values or discarding them if not possible (gteZmap())
  * and by interpolating when possible if there is any missing internal values (processZMap()).
@@ -49,6 +50,7 @@ public class ConstructionCompletion< T extends RealType< T > & NativeType< T > >
         for ( Surface surface : finalSurfaces )
         {
             Img< UnsignedShortType > processedZMap = processedZMap( surface );
+
             ReferenceSurface< T > referenceSurface = new ReferenceSurface<>( input, factory, processedZMap, index++ );
             referenceSurfaces.add( referenceSurface );
         }
@@ -81,6 +83,7 @@ public class ConstructionCompletion< T extends RealType< T > & NativeType< T > >
                             int z = averageIntZ( pixel );
                             if ( z != - 1 )
                             {
+                                System.out.println( "only two : " + pixel );
                                 randomAccess.setPosition( i, 1 );
                                 randomAccess.get().set( new UnsignedShortType( z + 1 ) );
                             }
@@ -92,6 +95,13 @@ public class ConstructionCompletion< T extends RealType< T > & NativeType< T > >
                             randomAccess.get().set( new UnsignedShortType( z + 1 ) );
                         }
                     }
+                    else
+                    {
+                        if ( pixel != null )
+                        {
+                            System.out.println( "more than two : " + pixel );
+                        }
+                    }
                 }
             }
         }
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/construction/Interpolation.java b/src/main/java/fr/pasteur/ida/zellige/steps/construction/Interpolation.java
index b19ba0c5ce18c75f2668c61128ecde7c07ad065f..3faa344b41ab080e69dd1162c7e4ae0dccc3b4f5 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/construction/Interpolation.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/construction/Interpolation.java
@@ -20,7 +20,6 @@ public class Interpolation
     public static Img< UnsignedShortType > run( RandomAccessibleInterval< UnsignedShortType > input )
     {
         InterpolationOperator operator = new InterpolationOperator( input );
-//        ImageJFunctions.show( operator.getOutput() );
         return operator.getOutput();
     }
 
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/ConstructionRound.java b/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/ConstructionRound.java
index 8c0131923f5edda6bd527535d77288aee1a32d82..452cdb03e93595020080075b2db2608136924d36 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/ConstructionRound.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/ConstructionRound.java
@@ -36,6 +36,19 @@ public abstract class ConstructionRound
         this.surfaceMinSizeFactor = constructionParameters.getSurfaceMinSizeFactor();
     }
 
+    protected ConstructionRound( final double startingSizeThreshold,
+                                 final int overlap,
+                                 final double connexityRate,
+                                 final double surfaceMinSizeFactor )
+    {
+        this.startingSizeThreshold = startingSizeThreshold;
+        this.overlap = overlap;
+        this.connexityRate = connexityRate;
+        this.surfaces = new ArrayList<>();
+        this.surfaceMinSizeFactor = surfaceMinSizeFactor;
+    }
+
+
     void finalizeSurface( ArrayList< Surface > surfaces ) throws NoSurfaceFoundException
     {
         goodSurfacesCount = surfaces.size();
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/FirstRoundConstruction.java b/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/FirstRoundConstruction.java
index caea159bf08b70f919cf8ba1a9f72c485ccc65bd..832b87f4c55fd90209b907c9b12b8764de52a927 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/FirstRoundConstruction.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/FirstRoundConstruction.java
@@ -19,6 +19,15 @@ public class FirstRoundConstruction extends ConstructionRound
         this.maximums = maximums;
     }
 
+    public FirstRoundConstruction( Pixels[][] maximums, final double startingSizeThreshold,
+                                   final int overlap,
+                                   final double connexityRate,
+                                   final double surfaceMinSizeFactor )
+    {
+        super( startingSizeThreshold, overlap, connexityRate, surfaceMinSizeFactor );
+        this.maximums = maximums;
+    }
+
     public void process() throws NoSurfaceFoundException
     {
         LOGGER.debug( "Processing..." );
@@ -26,7 +35,7 @@ public class FirstRoundConstruction extends ConstructionRound
         long startOseConstructionTime = System.currentTimeMillis();
         OSEListArray oseLists = constructOSE( maximums );
         long stopOseConstructionTime = System.currentTimeMillis();
-                this.setOSConstructionProcessingTime( stopOseConstructionTime - startOseConstructionTime );
+        this.setOSConstructionProcessingTime( stopOseConstructionTime - startOseConstructionTime );
         /* Construction of surfaces*/
         LOGGER.info( "Starting surface construction..." );
         int lineLength = maximums[ 0 ].length;
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/SecondRoundConstruction.java b/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/SecondRoundConstruction.java
index a70e11ff9fd67fdfcef47133e73ff302a347464b..688f2e50f69e8c57e806bd2de6966150a49779ef 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/SecondRoundConstruction.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/construction/rounds/SecondRoundConstruction.java
@@ -22,6 +22,15 @@ public class SecondRoundConstruction extends ConstructionRound
         this.tempSurfaces = tempSurfaces;
     }
 
+    public SecondRoundConstruction( final ArrayList< Surface > tempSurfaces, final double startingSizeThreshold,
+                                    final int overlap,
+                                    final double connexityRate,
+                                    final double surfaceMinSizeFactor )
+    {
+        super( startingSizeThreshold, overlap, connexityRate, surfaceMinSizeFactor );
+        this.tempSurfaces = tempSurfaces;
+    }
+
 //    public static ArrayList< Surface > run( ArrayList< Surface > tempSurfaces, ConstructionParameters constructionParameters ) throws NoSurfaceFoundException
 //    {
 //        SecondStepConstruction round = new SecondStepConstruction( tempSurfaces, constructionParameters );
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/projection/DisplayParameters.java b/src/main/java/fr/pasteur/ida/zellige/steps/projection/DisplayParameters.java
index 2b1664e15d6060add1b2a2c3978e9181af444d2a..1134e1356037bf2ea6a101dfc7913392cf542958 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/projection/DisplayParameters.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/projection/DisplayParameters.java
@@ -5,19 +5,21 @@ public class DisplayParameters
     private final boolean zMapDisplay;
     private final boolean projectionDisplay;
     private final boolean projectionHeightMapDisplay;
-    private final boolean heightMapSubVolumeMaskDisplay;
+    private final boolean surfaceSubVolumeDisplay;
     private final boolean extractedHeightMapSubStackDisplay;
+    private final boolean heightMapSubVolumeMask;
 
 
     public DisplayParameters( boolean zMapDisplay, boolean extractedHeightMapSubStackDisplay, boolean projectionHeightMapDisplay,
-                              boolean projectionDisplay, boolean heightMapSubVolumeMaskDisplay )
+                              boolean projectionDisplay, boolean surfaceSubVolumeDisplay, boolean heightMapSubVolumeMask )
     {
 
         this.zMapDisplay = zMapDisplay;
         this.extractedHeightMapSubStackDisplay = extractedHeightMapSubStackDisplay;
         this.projectionHeightMapDisplay = projectionHeightMapDisplay;
         this.projectionDisplay = projectionDisplay;
-        this.heightMapSubVolumeMaskDisplay = heightMapSubVolumeMaskDisplay;
+        this.surfaceSubVolumeDisplay = surfaceSubVolumeDisplay;
+        this.heightMapSubVolumeMask = heightMapSubVolumeMask;
     }
 
     public boolean iszMapDisplay()
@@ -40,8 +42,13 @@ public class DisplayParameters
         return projectionDisplay;
     }
 
-    public boolean isHeightMapSubVolumeMaskDisplay()
+    public boolean isSurfaceSubVolumeDisplay()
     {
-        return heightMapSubVolumeMaskDisplay;
+        return surfaceSubVolumeDisplay;
+    }
+
+    public boolean isHeightMapSubVolumeMask()
+    {
+        return heightMapSubVolumeMask;
     }
 }
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/projection/ReferenceSurfaceProjection.java b/src/main/java/fr/pasteur/ida/zellige/steps/projection/ReferenceSurfaceProjection.java
index f8ce6b0dc4412c9662ca2264b642a7a6368898dc..5e5693f37a6555e6f7e3e8401d3aaec5d44eed87 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/projection/ReferenceSurfaceProjection.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/projection/ReferenceSurfaceProjection.java
@@ -1,7 +1,8 @@
 package fr.pasteur.ida.zellige.steps.projection;
 
 import fr.pasteur.ida.zellige.element.ReferenceSurface;
-import fr.pasteur.ida.zellige.steps.Utils;
+import net.imglib2.Cursor;
+import net.imglib2.IterableInterval;
 import net.imglib2.RandomAccess;
 import net.imglib2.RandomAccessibleInterval;
 import net.imglib2.img.Img;
@@ -9,11 +10,14 @@ import net.imglib2.img.ImgFactory;
 import net.imglib2.img.array.ArrayImgFactory;
 import net.imglib2.img.display.imagej.ImageJFunctions;
 import net.imglib2.type.NativeType;
+import net.imglib2.type.logic.BitType;
 import net.imglib2.type.numeric.RealType;
 import net.imglib2.type.numeric.integer.UnsignedShortType;
 
 import java.util.Arrays;
 
+import static fr.pasteur.ida.zellige.steps.Utils.setPosition;
+
 /**
  * @author ctrebeau
  * Methods to extract the reference surface from a stack with the height map obtained with the program.
@@ -35,6 +39,48 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
         referenceSurfaceProjection.display( referenceSurface, projectionParameters, displayParameters );
     }
 
+//    public static < T extends RealType< T > & NativeType< T > > void run( ReferenceSurface< T > referenceSurface,
+//                                                                          int delta, String projectionType,
+//                                                                          boolean projectionDisplay,
+//                                                                          boolean rawHeightMapDisplay,
+//                                                                          boolean extractedHeightMapDisplay,
+//                                                                          boolean reduced3DSpaceDisplay,
+//                                                                          boolean segmentedSurfaceDisplay,
+//                                                                          boolean segmentedSurfaceMaskDisplay ) throws NoPossibleDisplayException
+//    {
+//        ReferenceSurfaceProjection< T > referenceSurfaceProjection = new ReferenceSurfaceProjection<>();
+//        referenceSurfaceProjection.set( referenceSurface, delta, projectionType );
+//        referenceSurfaceProjection.display( referenceSurface, delta, projectionType,
+//                projectionDisplay,
+//                rawHeightMapDisplay,
+//                extractedHeightMapDisplay,
+//                reduced3DSpaceDisplay,
+//                segmentedSurfaceDisplay,
+//                segmentedSurfaceMaskDisplay );
+//    }
+
+    public static < T extends RealType< T > & NativeType< T > > void run( ReferenceSurface< T > referenceSurface,
+                                                                          int delta, String projectionType,
+                                                                          boolean projectionDisplay,
+                                                                          boolean rawHeightMapDisplay,
+                                                                          boolean extractedHeightMapDisplay,
+                                                                          boolean reduced3DSpaceDisplay,
+                                                                          boolean segmentedSurfaceDisplay,
+                                                                          boolean segmentedSurfaceMaskDisplay,
+                                                                          int delta2 ) throws NoPossibleDisplayException
+    {
+        ReferenceSurfaceProjection< T > referenceSurfaceProjection = new ReferenceSurfaceProjection<>();
+        referenceSurfaceProjection.set( referenceSurface, delta, projectionType, delta2 );
+        referenceSurfaceProjection.display( referenceSurface, delta, projectionType,
+                projectionDisplay,
+                rawHeightMapDisplay,
+                extractedHeightMapDisplay,
+                reduced3DSpaceDisplay,
+                segmentedSurfaceDisplay,
+                segmentedSurfaceMaskDisplay, delta2 );
+    }
+
+
     /**
      * @param referenceSurface the considered referenceSurface
      * @param method           the desired user projection method
@@ -61,13 +107,13 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
                 for ( int y = 0; y <= input.dimension( 1 ) - 1; y++ )
                 {
 
-                    Utils.setPosition( zMapAccess, x, y );
+                    setPosition( zMapAccess, x, y );
                     int z = zMapAccess.get().getInteger() - 1;
                     if ( z != - 1 )
                     {
-                        Utils.setPosition( stackAccess, x, y, z );
+                        setPosition( stackAccess, x, y, z );
                         int finalZ = findZ( stackAccess, ( int ) input.dimension( 2 ) - 1, delta );
-                        Utils.setPosition( heightmapAccess, x, y );
+                        setPosition( heightmapAccess, x, y );
                         heightmapAccess.get().set( finalZ + 1 );
                     }
                 }
@@ -91,7 +137,7 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
         RandomAccessibleInterval< T > input = referenceSurface.getInput();
         ImgFactory< T > factory = referenceSurface.getFactory();
         RandomAccessibleInterval< UnsignedShortType > zMap = referenceSurface.getzMap();
-        //the stack slice number depends of the user "delta" parameter.
+        //the stack slice number depends on the user "delta" parameter.
         Img< T > heightMapStack = factory.create( input.dimension( 0 ), input.dimension( 1 ), ( delta * 2L ) + 1 );
         RandomAccess< T > stackAccess = input.randomAccess();
         RandomAccess< T > heightMapAccess = heightMapStack.randomAccess();
@@ -112,8 +158,8 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
                     int zHeight = delta;
                     for ( int z = zMapValue; z >= startIndex; z-- )
                     {
-                        Utils.setPosition( heightMapAccess, x, y, zHeight );
-                        Utils.setPosition( stackAccess, x, y, z );
+                        setPosition( heightMapAccess, x, y, zHeight );
+                        setPosition( stackAccess, x, y, z );
                         heightMapAccess.get().set( stackAccess.get() );
                         zHeight--;
                     }
@@ -121,8 +167,8 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
                     zHeight = delta + 1;
                     for ( int z = zMapValue + 1; z <= stopIndex; z++ )
                     {
-                        Utils.setPosition( heightMapAccess, x, y, zHeight );
-                        Utils.setPosition( stackAccess, x, y, z );
+                        setPosition( heightMapAccess, x, y, zHeight );
+                        setPosition( stackAccess, x, y, z );
                         heightMapAccess.get().set( stackAccess.get() );
                         zHeight++;
                     }
@@ -131,53 +177,102 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
                 {
                     for ( int z = 0; z <= heightMapStack.dimension( 2 ) - 1; z++ )
                     {
-                        Utils.setPosition( heightMapAccess, x, y, z );
+                        setPosition( heightMapAccess, x, y, z );
                         heightMapAccess.get().setReal( 0 );
                     }
                 }
             }
         }
-//        Utils.saveImage( heightMapStack, "surface n°" + surfaceNumber, "C:\\Users\\Barbier-Trebeau\\Desktop\\ ");
         return heightMapStack;
     }
 
-    public static < T extends RealType< T > & NativeType< T > > Img< T > getHeightMapSubVolumeStack
-            ( ReferenceSurface< T > referenceSurface, int delta )
-    {
-        RandomAccessibleInterval< T > input = referenceSurface.getInput();
-        ImgFactory< T > factory = referenceSurface.getFactory();
-        RandomAccessibleInterval< UnsignedShortType > zMap = referenceSurface.getzMap();
-        Img< T > heightMapStack = factory.create( input.dimension( 0 ), input.dimension( 1 ), input.dimension( 2 ) );
-        RandomAccess< T > stackAccess = input.randomAccess();
-        RandomAccess< T > heightmapAccess = heightMapStack.randomAccess();
-        RandomAccess< UnsignedShortType > zMapAccess = zMap.randomAccess();
 
-        for ( int x = 0; x <= input.dimension( 0 ) - 1; x++ )
+    public static < T extends RealType< T > & NativeType< T > > Img< BitType > getSegmentedSurfaceMask
+            ( IterableInterval< T > segmentedSurface, int delta )
+    {
+        Img< BitType > segmentedSurfaceMask = new ArrayImgFactory<>( new BitType() ).create( segmentedSurface );
+        Cursor< T > surfaceAccess = segmentedSurface.cursor();
+        RandomAccess< BitType > mapAccess = segmentedSurfaceMask.randomAccess();
+        while ( surfaceAccess.hasNext() )
         {
-            for ( int y = 0; y <= input.dimension( 1 ) - 1; y++ )
+            surfaceAccess.fwd();
+            if ( surfaceAccess.get().getRealFloat() > 0 )// there is a surface pixel
             {
-                Utils.setPosition( zMapAccess, x, y );
-                int Z = zMapAccess.get().getInteger();
-                if ( Z > 0 )
+                int x = surfaceAccess.getIntPosition( 0 );
+                int y = surfaceAccess.getIntPosition( 1 );
+                int z = surfaceAccess.getIntPosition( 2 );
+                int startIndex = Math.max( z - delta, 0 );
+                int stopIndex = Math.min( ( int ) segmentedSurface.dimension( 2 ) - 1, ( z + delta ) );
+                for ( int Z = startIndex; Z <= stopIndex; Z++ )
                 {
-//                    Utils.setPosition( stackAccess, x, y, Z - 1 );
-                    // " - 1" because by convention the z values start at 1, 0 is for unassigned values.
-//                    heightmapAccess.get().set( stackAccess.get() );
-                    int startIndex = Math.max( Z - delta, 0 );
-                    int stopIndex = Math.min( ( int ) input.dimension( 2 ) - 1, ( Z + delta ) );
+                    mapAccess.setPosition( surfaceAccess );
+                    setPosition( mapAccess, x, y, Z );
+                    mapAccess.get().set( true );
+                }
+            }
+        }
+//        ImageJFunctions.show( segmentedSurfaceMask, "Mask with " + delta );
+        return segmentedSurfaceMask;
+    }
 
 
-                    for ( int z = startIndex; z <= stopIndex; z++ )
-                    {
-                        Utils.setPosition( heightmapAccess, x, y, z );
-                        Utils.setPosition( stackAccess, x, y, z );
-                        heightmapAccess.get().set( stackAccess.get() );
-                    }
-                }
+    //    public static < T extends RealType< T > & NativeType< T > > Img< T > getSegmentedSurface
+//            ( ReferenceSurface< T > referenceSurface, int delta )
+//    {
+//        RandomAccessibleInterval< T > input = referenceSurface.getInput();
+//        ImgFactory< T > factory = referenceSurface.getFactory();
+//        RandomAccessibleInterval< UnsignedShortType > zMap = referenceSurface.getzMap();
+//        Img< T > heightMapStack = factory.create( input.dimension( 0 ), input.dimension( 1 ), input.dimension( 2 ) );
+//        RandomAccess< T > stackAccess = input.randomAccess();
+//        RandomAccess< T > heightmapAccess = heightMapStack.randomAccess();
+//        RandomAccess< UnsignedShortType > zMapAccess = zMap.randomAccess();
+//
+//        for ( int x = 0; x <= input.dimension( 0 ) - 1; x++ )
+//        {
+//            for ( int y = 0; y <= input.dimension( 1 ) - 1; y++ )
+//            {
+//                setPosition( zMapAccess, x, y );
+//                int Z = zMapAccess.get().getInteger();
+//                if ( Z > 0 )
+//                {
+//                    // " - 1" because by convention the z values start at 1, 0 is for unassigned values.
+////                    heightmapAccess.get().set( stackAccess.get() );
+//                    int startIndex = Math.max( Z - delta, 0 );
+//                    int stopIndex = Math.min( ( int ) input.dimension( 2 ) - 1, ( Z + delta ) );
+//
+//
+//                    for ( int z = startIndex; z <= stopIndex; z++ )
+//                    {
+//                        setPosition( heightmapAccess, x, y, z );
+//                        setPosition( stackAccess, x, y, z );
+//                        heightmapAccess.get().set( stackAccess.get() );
+//                    }
+//                }
+//            }
+//        }
+//        return heightMapStack;
+//    }
+    public static < T extends RealType< T > & NativeType< T > > Img< T > getSegmentedSurface
+    ( Img< UnsignedShortType > extractedHeightMap, RandomAccessibleInterval< T > originalInput, ImgFactory< T > factory )
+    {
+        Img< T > segmentedSurface = factory.create( originalInput );
+        RandomAccess< T > surfaceAccess = segmentedSurface.randomAccess();
+        RandomAccess< T > inputAccess = originalInput.randomAccess();
+        Cursor< UnsignedShortType > heightMapCursor = extractedHeightMap.cursor();
+        while ( heightMapCursor.hasNext() )
+        {
+            heightMapCursor.fwd();
+            if ( heightMapCursor.get().getInteger() > 0 )
+            {
+                int x = heightMapCursor.getIntPosition( 0 );
+                int y = heightMapCursor.getIntPosition( 1 );
+                setPosition( surfaceAccess, x, y, heightMapCursor.get().getInteger() - 1 );
+                setPosition( inputAccess, x, y, heightMapCursor.get().getInteger() - 1 );
+                surfaceAccess.get().set( inputAccess.get() );
             }
         }
-//        Utils.saveImage( heightMapStack, "surface n°" + surfaceNumber, "C:\\Users\\Barbier-Trebeau\\Desktop\\ ");
-        return heightMapStack;
+
+        return segmentedSurface;
     }
 
 
@@ -194,7 +289,7 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
     {
         RandomAccessibleInterval< T > input = referenceSurface.getInput();
         ImgFactory< T > factory = referenceSurface.getFactory();
-        RandomAccessibleInterval< UnsignedShortType > projectionHeightMap = referenceSurface.getProjection().getProjectionHeightMap();
+        RandomAccessibleInterval< UnsignedShortType > projectionHeightMap = referenceSurface.getProjection().getExtractedHeightMap();
         if ( projectionType.equals( "MIP" ) )
         {
             Img< T > projection = factory.create( input.dimension( 0 ), input.dimension( 1 ) );
@@ -207,18 +302,17 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
             {
                 for ( int y = 0; y <= input.dimension( 1 ) - 1; y++ )
                 {
-                    Utils.setPosition( heightmapAccess, x, y );
+                    setPosition( heightmapAccess, x, y );
                     final int z = heightmapAccess.get().getInteger();
                     if ( z == 0 )
-//                    if ( heightmapAccess.get().compareTo( minus ) == 0 )
                     {
                         projectionAccess.get().setReal( 0 );
                     }
                     else
                     {
-                        Utils.setPosition( stackAccess, x, y, z - 1 );
+                        setPosition( stackAccess, x, y, z - 1 );
                         // " - 1" because by convention the z values start at 1, 0 is for unassigned values.
-                        Utils.setPosition( projectionAccess, x, y );
+                        setPosition( projectionAccess, x, y );
                         projectionAccess.get().set( stackAccess.get() );
                     }
                 }
@@ -239,12 +333,12 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
     {
 
         ImgFactory< T > factory = referenceSurface.getFactory();
-        RandomAccessibleInterval< T > extractedHeightMapSubStack = referenceSurface.getProjection().getExtractedHeightMapSubStack();
+        RandomAccessibleInterval< T > extractedHeightMapSubStack = referenceSurface.getProjection().getReduced3DSpace();
         Img< T > projection = factory.create( extractedHeightMapSubStack.dimension( 0 ), extractedHeightMapSubStack.dimension( 1 ) );
         if ( projectionType.equals( "median" ) )// sumSlices, median, standardDeviation
         {
             medianProjection( extractedHeightMapSubStack, projection );
-            return projection;   //something something
+            return projection;
         }
         return null;
     }
@@ -274,7 +368,7 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
 
         for ( int z = startIndex; z <= stopIndex; z++ )
         {
-            Utils.setPosition( stackAccess, xValue, yValue, z );
+            setPosition( stackAccess, xValue, yValue, z );
             if ( stackAccess.get().compareTo( max ) >= 0 )
             {
                 max = stackAccess.get().copy();
@@ -301,7 +395,7 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
                     inputAccess.setPosition( z, 2 );
                     column[ z ] = inputAccess.get().getRealFloat();
                 }
-                Utils.setPosition( outputAccess, x, y );
+                setPosition( outputAccess, x, y );
                 outputAccess.get().setReal( median( column ) );
             }
         }
@@ -328,18 +422,45 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
 
         int delta = projectionParameters.getDelta();
         String projectionType = projectionParameters.getProjectionType();
-        referenceSurface.getProjection().setHeightMapSubVolumeMask( getHeightMapSubVolumeStack( referenceSurface, delta ) );
+
+
+        if ( projectionType.equals( "MIP" ) ||
+                projectionType.equals( "Minimum Intensity" ) )
+        {
+            referenceSurface.getProjection().setExtractedHeightMap( getProjectionHeightMap( referenceSurface, projectionType, delta ) );
+            referenceSurface.getProjection().setReduced3DSpace( getExtractedHeightMapSubStack( referenceSurface, delta ) );
+            referenceSurface.getProjection().setProjection( projection1( referenceSurface, projectionType ) );
+//            referenceSurface.getProjection().setSegmentedSurface( getSegmentedSurface( referenceSurface, delta ) );
+            referenceSurface.getProjection().setSegmentedSurface( getSegmentedSurface( referenceSurface.getProjection().getExtractedHeightMap(),
+                    referenceSurface.getInput(),
+                    referenceSurface.getFactory() ) );
+        }
+        else
+        {
+            referenceSurface.getProjection().setReduced3DSpace( getExtractedHeightMapSubStack( referenceSurface, delta ) );
+            referenceSurface.getProjection().setProjection( projection2( referenceSurface, projectionType ) );
+        }
+
+    }
+
+    public void set( ReferenceSurface< T > referenceSurface, int delta, String projectionType, int delta2 )
+    {
+
 
         if ( projectionType.equals( "MIP" ) ||
                 projectionType.equals( "Minimum Intensity" ) )
         {
-            referenceSurface.getProjection().setProjectionHeightMap( getProjectionHeightMap( referenceSurface, projectionType, delta ) );
-            referenceSurface.getProjection().setExtractedHeightMapSubStack( getExtractedHeightMapSubStack( referenceSurface, delta ) );
+            referenceSurface.getProjection().setExtractedHeightMap( getProjectionHeightMap( referenceSurface, projectionType, delta ) );
+            referenceSurface.getProjection().setReduced3DSpace( getExtractedHeightMapSubStack( referenceSurface, delta ) );
             referenceSurface.getProjection().setProjection( projection1( referenceSurface, projectionType ) );
+            referenceSurface.getProjection().setSegmentedSurface( getSegmentedSurface( referenceSurface.getProjection().getExtractedHeightMap(),
+                    referenceSurface.getInput(),
+                    referenceSurface.getFactory() ) );
+            referenceSurface.getProjection().setSegmentedSurfaceMask( getSegmentedSurfaceMask( referenceSurface.getProjection().getSegmentedSurface(), delta2 ) );
         }
         else
         {
-            referenceSurface.getProjection().setExtractedHeightMapSubStack( getExtractedHeightMapSubStack( referenceSurface, delta ) );
+            referenceSurface.getProjection().setReduced3DSpace( getExtractedHeightMapSubStack( referenceSurface, delta ) );
             referenceSurface.getProjection().setProjection( projection2( referenceSurface, projectionType ) );
         }
 
@@ -353,46 +474,49 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
         {
             if ( displayParameters.isProjectionDisplay() )
             {
-
                 ImageJFunctions.show( referenceSurface.getProjection().get(),
                         "Projection with " + projectionType + " RS n°" + referenceSurface.getIndex() );
 
             }
             if ( displayParameters.iszMapDisplay() )
             {
-                ImageJFunctions.show( referenceSurface.getzMap(), "Zellige generated height map" + "RS n°" + referenceSurface.getIndex() );
+                ImageJFunctions.show( referenceSurface.getzMap(), "Raw height map" + "RS n°" + referenceSurface.getIndex() );
             }
-
             if ( displayParameters.isExtractedHeightMapSubStackDisplay() )
 
             {
-                if ( delta != 0 )
+                if ( delta >= 0 )
                 {
-                    ImageJFunctions.show( referenceSurface.getProjection().getExtractedHeightMapSubStack(),
-                            "Extracted height map subStack (delta = " + delta + ")" + "RS n°" + referenceSurface.getIndex() );
+                    ImageJFunctions.show( referenceSurface.getProjection().getReduced3DSpace(),
+                            "Extracted surface subStack (delta = " + delta + ")" + "RS n°" + referenceSurface.getIndex() );
                 }
                 else
                 {
                     throw new NoPossibleDisplayException( "The value of parameter delta equals 0 !" );
                 }
             }
-            if ( displayParameters.isHeightMapSubVolumeMaskDisplay() )
+            if ( displayParameters.isSurfaceSubVolumeDisplay() )
             {
-                if ( delta != 0 )
+                if ( delta > 0 )
                 {
-                    ImageJFunctions.show( referenceSurface.getProjection().getHeightMapSubVolumeMask(),
-                            "Height map subVolume mask (delta = " + delta + ")" + "RS n°" + referenceSurface.getIndex() );
+                    ImageJFunctions.show( referenceSurface.getProjection().getSegmentedSurface(),
+                            "RS n°" + referenceSurface.getIndex() + ": segmented surface (delta = " + delta + ")" + "RS n°" + referenceSurface.getIndex() );
                 }
                 else
                 {
                     throw new NoPossibleDisplayException( "The value of parameter delta equals 0 !" );
                 }
             }
+            if ( displayParameters.isHeightMapSubVolumeMask() )
+            {
+                ImageJFunctions.show( referenceSurface.getProjection().getSegmentedSurfaceMask(),
+                        "RS n° " + referenceSurface.getIndex() + " :  segmented surface mask mask (delta = " + delta );
+            }
             if ( ( projectionType.equals( "MIP" ) || projectionType.equals( "Min" ) ) && displayParameters.isProjectionHeightMapDisplay() )
             {
-                if ( delta != 0 )
+                if ( delta >= 0 )
                 {
-                    ImageJFunctions.show( referenceSurface.getProjection().getProjectionHeightMap(), "Projection height Map with " +
+                    ImageJFunctions.show( referenceSurface.getProjection().getExtractedHeightMap(), "Extracted height Map with " +
                             projectionType + " RS n°" + referenceSurface.getIndex() );
                 }
                 else
@@ -401,7 +525,144 @@ public class ReferenceSurfaceProjection< T extends RealType< T > & NativeType< T
                 }
             }
 
+
+        }
+    }
+
+    public void display( ReferenceSurface< T > referenceSurface, int delta, String projectionType,
+                         boolean projectionDisplay,
+                         boolean rawHeightMapDisplay,
+                         boolean extractedHeightMapDisplay,
+                         boolean reduced3DSpaceDisplay,
+                         boolean segmentedSurfaceDisplay,
+                         boolean segmentedSurfaceMaskDisplay ) throws NoPossibleDisplayException
+    {
+
+        if ( referenceSurface.getProjection() != null )
+        {
+            if ( projectionDisplay )// the projection
+            {
+                ImageJFunctions.show( referenceSurface.getProjection().get(),
+                        "Projection with " + projectionType + " RS n°" + referenceSurface.getIndex() );
+            }
+            if ( rawHeightMapDisplay )// the raw height map
+            {
+                ImageJFunctions.show( referenceSurface.getzMap(), "Zellige generated height map" + "RS n°" + referenceSurface.getIndex() );
+            }
+
+            if ( reduced3DSpaceDisplay )
+            {
+                if ( delta != 0 )
+                {
+                    ImageJFunctions.show( referenceSurface.getProjection().getReduced3DSpace(),
+                            "Reduced 3D space (delta = " + delta + ")" + "RS n°" + referenceSurface.getIndex() );
+                }
+                else
+                {
+                    throw new NoPossibleDisplayException( "The value of parameter delta equals 0 !" );
+                }
+            }
+
+            if ( ( projectionType.equals( "MIP" ) || projectionType.equals( "Min" ) ) && extractedHeightMapDisplay ) // the extracted height map
+            {
+                if ( delta != 0 )
+                {
+                    ImageJFunctions.show( referenceSurface.getProjection().getExtractedHeightMap(), "Extracted height Map with " +
+                            projectionType + " RS n°" + referenceSurface.getIndex() );
+                }
+                else
+                {
+                    throw new NoPossibleDisplayException( "This method does not produce a extracted height map !" );
+                }
+            }
+            if ( segmentedSurfaceDisplay )
+            {
+                if ( delta != 0 )
+                {
+                    ImageJFunctions.show( referenceSurface.getProjection().getSegmentedSurface(),
+                            "Height map subVolume mask (delta = " + delta + ")" + "RS n°" + referenceSurface.getIndex() );
+                }
+                else
+                {
+                    throw new NoPossibleDisplayException( "The value of parameter delta equals 0 !" );
+                }
+            }
+            if ( segmentedSurfaceMaskDisplay ) // the segmented surface mask
+            {
+                ImageJFunctions.show( referenceSurface.getProjection().getSegmentedSurfaceMask(),
+                        "RS n° " + referenceSurface.getIndex() + " :  SubVolume mask (delta = " + delta );
+            }
         }
+
     }
 
+    public void display( ReferenceSurface< T > referenceSurface, int delta, String projectionType,
+                         boolean projectionDisplay,
+                         boolean rawHeightMapDisplay,
+                         boolean extractedHeightMapDisplay,
+                         boolean reduced3DSpaceDisplay,
+                         boolean segmentedSurfaceDisplay,
+                         boolean segmentedSurfaceMaskDisplay,
+                         int delta2 ) throws NoPossibleDisplayException
+    {
+        if ( referenceSurface.getProjection() != null )
+        {
+            if ( projectionDisplay )// the projection
+            {
+                ImageJFunctions.show( referenceSurface.getProjection().get(),
+                        "Projection with " + projectionType + " RS n°" + referenceSurface.getIndex() );
+            }
+            if ( rawHeightMapDisplay )// the raw height map
+            {
+                ImageJFunctions.show( referenceSurface.getzMap(), "Raw Height Map" + "RS n°" + referenceSurface.getIndex() );
+            }
+
+            if ( reduced3DSpaceDisplay )// the reduced 3D stack of size (X, Y, delta*2 +1)
+            {
+                if ( delta != 0 )
+                {
+                    ImageJFunctions.show( referenceSurface.getProjection().getReduced3DSpace(),
+                            "Reduced 3D space (delta = " + delta + ")" + "RS n°" + referenceSurface.getIndex() );
+                }
+                else
+                {
+                    throw new NoPossibleDisplayException( "The value of parameter delta equals 0 !" );
+                }
+            }
+
+            if ( ( projectionType.equals( "MIP" ) || projectionType.equals( "Min" ) ) && extractedHeightMapDisplay ) // the extracted height map
+            {
+                if ( delta != 0 )
+                {
+                    ImageJFunctions.show( referenceSurface.getProjection().getExtractedHeightMap(), "Extracted height Map with " +
+                            projectionType + " RS n°" + referenceSurface.getIndex() );
+                }
+                else
+                {
+                    throw new NoPossibleDisplayException( "This method does not produce a extracted height map !" );
+                }
+            }
+            if ( segmentedSurfaceDisplay )
+            {
+                if ( delta > 0 )
+                {
+                    ImageJFunctions.show( referenceSurface.getProjection().getSegmentedSurface(),
+                            "Segmented surface (delta = " + delta + ")" + "RS n°" + referenceSurface.getIndex() );
+                }
+                else
+                {
+                    throw new NoPossibleDisplayException( "The value of parameter delta equals 0 !" );
+                }
+            }
+            if ( segmentedSurfaceMaskDisplay ) // the segmented surface mask
+            {
+                ImageJFunctions.show( referenceSurface.getProjection().getSegmentedSurfaceMask(),
+                        "RS n° " + referenceSurface.getIndex() + " : Segmented surface mask (delta = " + delta2 );
+            }
+        }
+
+    }
 }
+
+
+
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/Selection.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/Selection.java
index 8c4ab7275bcf8cf6d54afd165f117dc70ee2ccf8..50d92f1d4c8c29be24e35565085e084d7b81cfad 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/Selection.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/Selection.java
@@ -29,7 +29,7 @@ public class Selection< T extends RealType< T > & NativeType< T > >
 {
     private final static Logger LOGGER = LoggerFactory.getLogger( Selection.class );
 
-    private final PretreatmentParameters pretreatmentParameters;
+    private final double radius;
     private final ClassificationParameters classificationParameters;
     private final PostTreatmentParameters postTreatmentParameters;
     private final RandomAccessibleInterval< T > input;
@@ -42,7 +42,7 @@ public class Selection< T extends RealType< T > & NativeType< T > >
     public Selection( PretreatmentParameters pretreatmentParameters, ClassificationParameters classificationParameters, PostTreatmentParameters postTreatmentParameters,
                       RandomAccessibleInterval< T > input )
     {
-        this.pretreatmentParameters = pretreatmentParameters;
+        this.radius = pretreatmentParameters.getParameter();
         this.classificationParameters = classificationParameters;
         this.postTreatmentParameters = postTreatmentParameters;
         this.input = input;
@@ -55,21 +55,15 @@ public class Selection< T extends RealType< T > & NativeType< T > >
         Selection< T > selection = new Selection<>( pretreatmentParameters, classificationParameters, postTreatmentParameters, input );
         selection.run();
         LOGGER.info( "Process complete." );
-
-
         return selection.output;
     }
 
+
     public static Logger getLOGGER()
     {
         return LOGGER;
     }
 
-    public Pixels[][] getOutput()
-    {
-        return output;
-    }
-
     public static long getAmplitudePT()
     {
         return amplitudePT;
@@ -93,16 +87,18 @@ public class Selection< T extends RealType< T > & NativeType< T > >
     public void run() throws EmptyOutputException, NoClassificationException, DataValidationException
     {
         /* Pretreatment of the image.*/
-        Img< FloatType > pretreatedImage = Pretreatment.run( input, pretreatmentParameters );
-//        ImageJFunctions.show( pretreatedImage, " pretreatedImage" );
+        Img< FloatType > pretreatedImage = Pretreatment.run( input, radius );
         /* Classification. */
         Img< BitType > classifiedPixel = Classification.run( pretreatedImage, pretreatedImage.factory(), classificationParameters );
         amplitudePT = AmplitudeClassification.getProcessingTime();
         otsuPT = OtsuClassification.getProcessingTime();
-//        ImageJFunctions.show( classifiedPixel );
         /* PostTreatment and output*/
         output = PostTreatment.run( classifiedPixel, postTreatmentParameters );
         islandSearchPT = IslandSearch.getProcessingTime();
-//        displayMaximums( maximums );
+    }
+
+    public Pixels[][] getOutput()
+    {
+        return output;
     }
 }
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/AmplitudeClassification.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/AmplitudeClassification.java
index 0de333ce17b77cff726e2d3bcd2fa1973568736b..b5d2ca8adcf1ba9bdd14b272c6f53004e37e294c 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/AmplitudeClassification.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/AmplitudeClassification.java
@@ -26,24 +26,23 @@ public class AmplitudeClassification< T extends RealType< T > & NativeType< T >
 
     private final RandomAccessibleInterval< T > input;
     private final ImgFactory< T > factory;
-    private final double userThreshold;
+    private double userThreshold;
     private Img< BitType > output;
     private static long processingTime;
+    private static double firstMaxValue;
 
     private final static Logger LOGGER = LoggerFactory.getLogger( AmplitudeClassification.class );
 
+
     public AmplitudeClassification( RandomAccessibleInterval< T > input,
-                                    ImgFactory< T > factory, Img< BitType > amplitude,
-                                    double userThreshold )
+                                    ImgFactory< T > factory )
     {
         this.input = input;
         this.factory = factory;
-        this.output = amplitude;
-        this.userThreshold = userThreshold;
-        LOGGER.info( "User input = {}", userThreshold );
         LOGGER.info( "Derivative method used : {}", ReferenceSurfaceExtraction.getDerivativeMethod() );
     }
 
+
     /**
      * @param <T>                - the type of the input
      * @param input              - the input image as a {@link RandomAccessibleInterval}
@@ -65,12 +64,52 @@ public class AmplitudeClassification< T extends RealType< T > & NativeType< T >
         return classification.getOutput();
     }
 
+    public static < T extends RealType< T > & NativeType< T > > Img< BitType >
+    applyThreshold( Img< T > input, T value, double userThreshold )
+    {
+        value.mul( userThreshold );
+        return Thresholder.threshold( input, value, true, 5 );
+    }
+
+    public static < T extends RealType< T > & NativeType< T > > Img< BitType >
+    applyThreshold( Img< T > input, int userThreshold )
+    {
+        T value = input.firstElement().createVariable();
+        value.setReal( ( float ) userThreshold );
+        return Thresholder.threshold( input, value, true, 5 );
+    }
+
+    public AmplitudeClassification( RandomAccessibleInterval< T > input,
+                                    ImgFactory< T > factory, Img< BitType > amplitude,
+                                    double userThreshold )
+    {
+        this.input = input;
+        this.factory = factory;
+        this.output = amplitude;
+        this.userThreshold = userThreshold;
+        LOGGER.info( "Derivative method used : {}", ReferenceSurfaceExtraction.getDerivativeMethod() );
+    }
+
+    /**
+     * @param <T>     - the type of the input
+     * @param input   - the input image as a {@link RandomAccessibleInterval}
+     * @param factory the input image {@link ImgFactory}
+     * @return a binary image of background foreground classification based on contrast
+     * @throws DataValidationException if the value of parameter amplitudeThreshold is not valid.
+     */
+    public static < T extends RealType< T > & NativeType< T > > Img< T > computeAmplitudeImage( final RandomAccessibleInterval< T > input,
+                                                                                                final ImgFactory< T > factory ) throws DataValidationException
+    {
+        AmplitudeClassification< T > classification =
+                new AmplitudeClassification<>( input, factory );
+        return classification.getAmplitudeImg();
+    }
     /**
      * @param max the image containing only the values of local maximums
      * @param min the image containing only the values of local minimums
      * @return an image containing the value of the maximums amplitude
      */
-    private  Img< T > getAmplitude(
+    private Img< T > getAmplitude(
             RandomAccessibleInterval< T > max, ImgFactory< T > factory, RandomAccessibleInterval< T > min )
     {
         Img< T > amp = factory.create( max );
@@ -161,17 +200,21 @@ public class AmplitudeClassification< T extends RealType< T > & NativeType< T >
         return maxValue;
     }
 
+    public static double getFirstMaxValue()
+    {
+        return firstMaxValue;
+    }
+
     //
     public void run() throws DataValidationException
     {
         Img< T > maximums = ExtremaDetection.findMaxima( input, factory );
         Img< T > minimums = ExtremaDetection.findMinima( input, factory );
         Img< T > amp = getAmplitude( maximums, factory, minimums );
-        T TMax = Threshold.getFirstMaxValue( maximums, false );
-        LOGGER.debug( "threshold value before user = {} ", TMax );
-        TMax.mul( userThreshold );
-        LOGGER.debug( "Threshold value after user = {}", TMax );
-        output = Thresholder.threshold( amp, TMax, true, 5 );
+        T threshold = maximums.firstElement().createVariable();
+        threshold.setReal( userThreshold );
+        LOGGER.info( "Amplitude Threshold applied  = {}", threshold );
+        output = Thresholder.threshold( amp, threshold, true, 5 );
     }
 
 
@@ -180,6 +223,13 @@ public class AmplitudeClassification< T extends RealType< T > & NativeType< T >
         return output;
     }
 
+    public Img< T > getAmplitudeImg() throws DataValidationException
+    {
+        Img< T > maximums = ExtremaDetection.findMaxima( input, factory );
+        Img< T > minimums = ExtremaDetection.findMinima( input, factory );
+        return getAmplitude( maximums, factory, minimums );
+    }
+
     public static long getProcessingTime()
     {
         return processingTime;
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/Classification.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/Classification.java
index 4e757a786537169f84cde08e007f2ea5b8682eaf..d199728cb4916f6f5f4c53add34baf4b9b4df85c 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/Classification.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/Classification.java
@@ -27,13 +27,18 @@ public class Classification< T extends RealType< T > & NativeType< T > >
     public static final int ZERO = 0;
     private final static Logger LOGGER = LoggerFactory.getLogger( Classification.class );
     private final RandomAccessibleInterval< T > input;
+    private final ImgFactory< T > factory;
     private Img< BitType > output;
 
-    private Classification( RandomAccessibleInterval< T > input )
+
+    private Classification( RandomAccessibleInterval< T > input, ImgFactory< T > factory )
     {
         this.input = input;
+        this.factory = factory;
     }
 
+
+
     /**
      * Static method to provide a 2-part classification on a 3D image
      *
@@ -48,9 +53,8 @@ public class Classification< T extends RealType< T > & NativeType< T > >
     public static < T extends RealType< T > & NativeType< T > > Img< BitType >
     run( RandomAccessibleInterval< T > input, ImgFactory< T > factory, ClassificationParameters parameters ) throws NoClassificationException, DataValidationException
     {
-        Classification< T > classification = new Classification<>( input );
+        Classification< T > classification = new Classification<>( input, factory );
         classification.process( factory, parameters );
-//        ImageJFunctions.show( classification.output, "classification" );
         return classification.output;
     }
 
@@ -63,8 +67,8 @@ public class Classification< T extends RealType< T > & NativeType< T > >
     void process( ImgFactory< T > factory, ClassificationParameters parameters ) throws NoClassificationException, DataValidationException
     {
         LOGGER.info( "Starting classification..." );
-        double amplitudeThreshold = parameters.getAmplitudeThreshold();
-        double otsuThreshold = parameters.getOtsuThreshold();
+        int amplitudeThreshold = parameters.getAmplitudeThreshold();
+        int otsuThreshold = parameters.getOtsuThreshold();
         if ( amplitudeThreshold != ZERO && otsuThreshold != ZERO )
         {
             processBothClassification( factory, amplitudeThreshold, otsuThreshold );
@@ -85,19 +89,19 @@ public class Classification< T extends RealType< T > & NativeType< T > >
     }
 
 
-    void processAmplitudeClassification( ImgFactory< T > factory, double amplitudeThreshold ) throws DataValidationException
+    void processAmplitudeClassification( ImgFactory< T > factory, int amplitudeThreshold ) throws DataValidationException
     {
         /* Classification according to maximum amplitude */
         output = AmplitudeClassification.run( input, factory, amplitudeThreshold );
     }
 
-    void processOtsuClassification( ImgFactory< T > factory, double otsuThreshold )
+    void processOtsuClassification( ImgFactory< T > factory, int otsuThreshold )
     {
         /* Classification according to local intensity*/
         output = OtsuClassification.run( input, factory, otsuThreshold );
     }
 
-    void processBothClassification( ImgFactory< T > factory, double amplitudeThreshold, double otsuThreshold ) throws DataValidationException
+    void processBothClassification( ImgFactory< T > factory, int amplitudeThreshold, int otsuThreshold ) throws DataValidationException
     {
         /* Classification according to maximum amplitude */
         Img< BitType > amplitudeImg = AmplitudeClassification.run( input, factory, amplitudeThreshold );
@@ -114,9 +118,41 @@ public class Classification< T extends RealType< T > & NativeType< T > >
      * @param thresholds another {@link BitType}{@link Img}
      * @return the intersection of both image
      */
-    private Img< BitType > interClassification( IterableInterval< BitType > amplitude,
-                                                ImgFactory< BitType > factory,
-                                                RandomAccessibleInterval< BitType > thresholds )
+    public static Img< BitType > interClassification( IterableInterval< BitType > amplitude,
+                                                      ImgFactory< BitType > factory,
+                                                      RandomAccessibleInterval< BitType > thresholds )
+    {
+        Img< BitType > output = factory.create( thresholds );
+        Cursor< BitType > amplitudeCursor = amplitude.localizingCursor();
+        RandomAccess< BitType > thresholdAccess
+                = thresholds.randomAccess();
+        RandomAccess< BitType > outputAccess = output.randomAccess();
+        while ( amplitudeCursor.hasNext() )
+        {
+            amplitudeCursor.fwd();
+            if ( amplitudeCursor.get().getRealDouble() != 0 )
+            {
+                thresholdAccess.setPosition( amplitudeCursor );
+                if ( thresholdAccess.get().get() )
+                {
+                    outputAccess.setPosition( amplitudeCursor );
+                    outputAccess.get().setOne();
+                }
+            }
+        }
+        return output;
+    }
+
+
+    /**
+     * @param amplitude  an {@link BitType}{@link Img}
+     * @param factory    the same  {@link BitType} {@link ImgFactory} as amplitude
+     * @param thresholds another {@link BitType}{@link Img}
+     * @return the intersection of both image
+     */
+    public static Img< BitType > runInterClassification( IterableInterval< BitType > amplitude,
+                                                         ImgFactory< BitType > factory,
+                                                         RandomAccessibleInterval< BitType > thresholds )
     {
         Img< BitType > output = factory.create( thresholds );
         Cursor< BitType > amplitudeCursor = amplitude.localizingCursor();
@@ -138,4 +174,6 @@ public class Classification< T extends RealType< T > & NativeType< T > >
         }
         return output;
     }
+
+
 }
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/ClassificationParameters.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/ClassificationParameters.java
index c1ac9ed2541a91eb6d1fb45f8372cac231d046c7..1147477ccfe7ed9e7fd824596a516e00c5fc6b35 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/ClassificationParameters.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/ClassificationParameters.java
@@ -8,50 +8,56 @@ public class ClassificationParameters
 {
     private final static Logger LOGGER = LoggerFactory.getLogger( ClassificationParameters.class );
 
-    private final double amplitudeThreshold, otsuThreshold;
+    private final int amplitudeThreshold, otsuThreshold;
 
-    public ClassificationParameters( double amplitudeThreshold, double otsuThreshold ) throws DataValidationException
+    public ClassificationParameters( int amplitudeThreshold, int otsuThreshold ) throws DataValidationException
     {
         classificationParametersValidationCheck( amplitudeThreshold, otsuThreshold );
         this.amplitudeThreshold = amplitudeThreshold;
         this.otsuThreshold = otsuThreshold;
+        LOGGER.info( "Classification parameters are valid" );
     }
 
     /**
-     *
-     * @param name the parameter name to display in the error message.
+     * @param name  the parameter name to display in the error message.
      * @param value the value of the parameter tested.
      * @throws DataValidationException if the value is inferior to zero.
      */
-    private void valueValidationCheck( String name, double value ) throws DataValidationException
+    public static void valueValidationCheck( String name, int value ) throws DataValidationException
     {
         if ( value < 0 )
         {
             throw new DataValidationException( "The value of parameter " + name + " has to be superior to zero !" );
         }
+        if ( value > 255 )
+        {
+            throw new DataValidationException( "The value of parameter " + name + " has to be inferior or equals to 50!" );
+        }
+
 
     }
 
 
     /**
      * Checks the four parameters validity.
+     *
      * @param amplitudeThreshold - the value choose as amplitude threshold.
-     * @param otsuThreshold - the value choose as otsu threshold.
+     * @param otsuThreshold      - the value choose as otsu threshold.
      * @throws DataValidationException if at least one parameter is not valid.
      */
-    public void classificationParametersValidationCheck( double amplitudeThreshold, double otsuThreshold) throws DataValidationException
+    public void classificationParametersValidationCheck( int amplitudeThreshold, int otsuThreshold ) throws DataValidationException
     {
         valueValidationCheck( "Amplitude Threshold", amplitudeThreshold );
         valueValidationCheck( "Otsu Threshold", otsuThreshold );
     }
 
 
-    public double getAmplitudeThreshold()
+    public int getAmplitudeThreshold()
     {
         return amplitudeThreshold;
     }
 
-    public double getOtsuThreshold()
+    public int getOtsuThreshold()
     {
         return otsuThreshold;
     }
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/OtsuClassification.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/OtsuClassification.java
index 970b2c7f86f7017df27b3fcb0becd37c4682db74..a59eab2becd92b67cb804086a75773c85870a42a 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/OtsuClassification.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/OtsuClassification.java
@@ -18,20 +18,20 @@ import java.util.List;
 public class OtsuClassification< T extends RealType< T > & NativeType< T > >
 {
 
-    private final RandomAccessibleInterval< T > input;
-    private final RandomAccessibleInterval< T > grid;
-    private final Img< BitType > output;
-    private final double userThreshold;
-    private static long processingTime;
-
     private final static Logger LOGGER = LoggerFactory.getLogger( OtsuClassification.class );
+    private static long processingTime;
+    private final RandomAccessibleInterval< T > input;
+    private final Img< T > grid;
+    private Img< BitType > output;
+    private int userThreshold;
 
     /**
-     * @param input         the input {@link Img}
+     * @param input         the input image as a {@link RandomAccessibleInterval}
+     * @param factory       the input factory
      * @param output        the resulting binary image as a {@link Img<BitType> }
-     * @param userThreshold the percentage of global otsu value
+     * @param userThreshold the the user's intensity threshold
      */
-    private OtsuClassification( final RandomAccessibleInterval< T > input, final ImgFactory< T > factory, final Img< BitType > output, double userThreshold )
+    private OtsuClassification( final RandomAccessibleInterval< T > input, final ImgFactory< T > factory, final Img< BitType > output, int userThreshold )
     {
         this.input = input;
         this.output = output;
@@ -40,24 +40,35 @@ public class OtsuClassification< T extends RealType< T > & NativeType< T > >
     }
 
     /**
-     * @param input   the input {@link Img}
-     * @param factory the {@link ImgFactory} of the input image
-     * @param percent the percentage of global otsu value
-     * @param <T>     the type on the input
+     * @param input   the input image as a {@link RandomAccessibleInterval}
+     * @param factory the input factory
+     */
+    private OtsuClassification( final RandomAccessibleInterval< T > input, final ImgFactory< T > factory )
+    {
+        this.input = input;
+        this.grid = factory.create( input );
+    }
+
+    /**
+     * @param input         the input image as a {@link RandomAccessibleInterval}
+     * @param factory       the {@link ImgFactory} of the input image
+     * @param userThreshold the percentage of global otsu value
+     * @param <T>           the type on the input
      * @return a 3D binary image
      */
-    public static < T extends RealType< T > & NativeType< T > > Img< BitType > run( final RandomAccessibleInterval< T > input, ImgFactory< T > factory, double percent )
+    public static < T extends RealType< T > & NativeType< T > > Img< BitType > run( final RandomAccessibleInterval< T > input, ImgFactory< T > factory, int userThreshold )
     {
-        if ( percent > 0 )
+        if ( userThreshold > 0 )
         {
-            // Prepare output.
             long start = System.currentTimeMillis();
+            // Prepare output.
             final ImgFactory< BitType > bitTypeImgFactory = net.imglib2.util.Util.getArrayOrCellImgFactory( input, new BitType() );
             Img< BitType > binary = bitTypeImgFactory.create( input );
-            OtsuClassification< T > classification = new OtsuClassification<>( input, factory, binary, percent );
+            OtsuClassification< T > classification = new OtsuClassification<>( input, factory, binary, userThreshold );
             classification.run();
             long stop = System.currentTimeMillis();
-            classification.setProcessingTime( stop - start );
+            LOGGER.debug( "Otsu classification done in {} s", ( ( stop - start ) / 1000.0 ) );
+            classification.setProcessingTime( ( stop - start ) );
             return classification.getOutput();
         }
         else
@@ -67,16 +78,32 @@ public class OtsuClassification< T extends RealType< T > & NativeType< T > >
     }
 
     /**
-     * @param input   the input image as an {@link IterableInterval}
-     * @param grid    the image containing the grid of local thresholds as an {@link IterableInterval}
-     * @param output  the resulting output image as a {@link RandomAccessibleInterval<BitType> }
-     * @param percent the percentage of global otsu value
-     * @param <T>     the input type
+     * @param input
+     * @param factory
+     * @param <T>
+     * @return
+     */
+    public static < T extends RealType< T > & NativeType< T > > Img< T > computeOtsuImage( final RandomAccessibleInterval< T > input, ImgFactory< T > factory )
+    {
+        OtsuClassification< T > classification = new OtsuClassification<>( input, factory );
+        classification.computeLocalThreshold( input, classification.grid );
+        return classification.getGrid();
+    }
+
+
+    /**
+     * @param input
+     * @param grid
+     * @param userThreshold
+     * @param <T>
+     * @return
      */
-    private static < T extends RealType< T > & NativeType< T > > void
-    applyLocalThreshold( IterableInterval< T > input, IterableInterval< T > grid, RandomAccessibleInterval< BitType > output, double percent )
+    public static < T extends RealType< T > & NativeType< T > > Img< BitType >
+    applyLocalThreshold( IterableInterval< T > input, IterableInterval< T > grid, int userThreshold )
     {
-        double threshold = Threshold.getThreshold( input, percent ).getRealDouble();
+        long start = System.currentTimeMillis();
+        final ImgFactory< BitType > bitTypeImgFactory = net.imglib2.util.Util.getArrayOrCellImgFactory( input, new BitType() );
+        Img< BitType > output = bitTypeImgFactory.create( input );
         Cursor< T > sourceCursor = input.localizingCursor();
         Cursor< T > gridCursor = grid.cursor();
         RandomAccess< BitType > randomAccess = output.randomAccess();
@@ -84,19 +111,22 @@ public class OtsuClassification< T extends RealType< T > & NativeType< T > >
         {
             sourceCursor.fwd();
             gridCursor.fwd();
-            final double s = sourceCursor.get().getRealDouble();
-            final double o = gridCursor.get().getRealDouble();
+            final double intensityValue = sourceCursor.get().getRealDouble();
+            final double localThreshold = gridCursor.get().getRealDouble();
             {
-                if ( s >= Math.max( o, threshold ) )// background subtraction
+                if ( intensityValue >= Math.max( localThreshold, userThreshold ) )// background subtraction
                 {
                     randomAccess.setPosition( sourceCursor );
                     randomAccess.get().set( true );
                 }
             }
         }
-        LOGGER.debug( "Local thresholds applied." );
+        long stop = System.currentTimeMillis();
+        LOGGER.debug( "Threshold applied in {} s.", ( ( stop - start ) / 1000.0 ) );
+        return output;
     }
 
+
     /**
      * @param input the input {@link Img}
      * @param grid  the image containing the grid of local thresholds
@@ -104,21 +134,31 @@ public class OtsuClassification< T extends RealType< T > & NativeType< T > >
     private void
     computeLocalThreshold( RandomAccessibleInterval< T > input, RandomAccessibleInterval< T > grid )
     {
+        long start = System.currentTimeMillis();
         long width = input.dimension( 0 );
         long height = input.dimension( 1 );
         long depth = input.dimension( 2 );
         List< Interval > intervals = Grids.collectAllContainedIntervals( new long[]{ width, height, depth },
-                new int[]{ 40, 40, 3 } );//TODO Size of a grid cube ?
+                new int[]{ 40, 40, 3 } );
 
         for ( Interval interval : intervals )
         {
             computeLocalThreshold( input, grid, interval );
         }
         Utils.gaussianConvolution( grid, grid, new double[]{ 5, 5, 1 } );
-//        ImageJFunctions.show(grid, "grid ");
-        LOGGER.info( "Local thresholds computed with user value  = {}.", this.userThreshold );
+        long stop = System.currentTimeMillis();
+        LOGGER.info( "Local thresholds computed in {} s.", ( ( stop - start ) / 1000.0 ) );
+
     }
 
+    /**
+     * This method applies an Otsu threshold on a specified interval on a given image.
+     *
+     * @param input    the input image as a {@link RandomAccessibleInterval}
+     * @param grid     the local thresholds image as a {@link RandomAccessibleInterval}
+     * @param interval the considered interval of the image as a {@link Interval}
+     */
+
     private void
     computeLocalThreshold( RandomAccessibleInterval< T > input, RandomAccessibleInterval< T > grid, Interval interval )
     {
@@ -126,7 +166,6 @@ public class OtsuClassification< T extends RealType< T > & NativeType< T > >
         IntervalView< T > viewGrid = Views.offsetInterval( grid, interval );
         T threshold = Otsu.getThreshold( viewSource );
         viewGrid.forEach( pixel -> pixel.set( threshold ) );
-
     }
 
     /**
@@ -135,7 +174,10 @@ public class OtsuClassification< T extends RealType< T > & NativeType< T > >
     private void run()
     {
         computeLocalThreshold( input, grid );
-        applyLocalThreshold( Views.iterable( input ), Views.iterable( grid ), output, userThreshold );
+
+        output = applyLocalThreshold( Views.iterable( input ), Views.iterable( grid ), userThreshold );
+        LOGGER.info( "Local thresholds computed with user value  = {}.", this.userThreshold );
+
     }
 
     /**
@@ -146,6 +188,12 @@ public class OtsuClassification< T extends RealType< T > & NativeType< T > >
         return output;
     }
 
+    private Img< T > getGrid()
+    {
+        return grid;
+    }
+
+
     public static long getProcessingTime()
     {
         return processingTime;
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/Threshold.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/Threshold.java
index 474d0f2b21e8cd45ccdc18c0b1764d022a26ccd0..10ddd6f7c1e6692f837c72b6c9b403a283e66dcb 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/Threshold.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/classification/Threshold.java
@@ -170,6 +170,15 @@ public class Threshold
     }
 
 
+    public static < T extends RealType< T > & NativeType< T > > T getThreshold( IterableInterval< T > input )
+    {
+        T max = Threshold.findMax( input );
+        T min = Threshold.findMin( input );
+        int[] histogram = getHistogram( input, min, max, 256 );
+        return getThreshold( min, max, histogram );
+    }
+
+
     public static < T extends RealType< T > & NativeType< T > > T getThreshold( IterableInterval< T > input, double percent )
     {
         T max = Threshold.findMax( input );
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/PostTreatment.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/PostTreatment.java
index 665344617e3adae51444123d7c23372ad80b8d15..492b5a19db47984a45a937bc2c222c9913cc4aa9 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/PostTreatment.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/PostTreatment.java
@@ -27,6 +27,7 @@ public class PostTreatment
     private Pixels[][] output;
     private final Img< BitType > input;
 
+
     public PostTreatment( Img< BitType > input )
     {
         this.input = input;
@@ -39,6 +40,13 @@ public class PostTreatment
         return postTreatment.getOutput();
     }
 
+    public static Pixels[][] run( Img< BitType > input, double sigmaXY, double sigmaZ, int islandSize, int connexity ) throws DataValidationException
+    {
+        PostTreatment postTreatment = new PostTreatment( input );
+        postTreatment.process( sigmaXY, sigmaZ, islandSize, connexity );
+        return postTreatment.getOutput();
+    }
+
     /**
      * @param image - the source image as a float type {@link IterableInterval}
      * @return the source image converted into float type Img object
@@ -68,10 +76,10 @@ public class PostTreatment
 
     Img< BitType > runIslandSearch(Img< BitType > input , int islandSize, int connexity)
     {
-            return IslandSearch.run( input, islandSize, connexity );
+        return IslandSearch.run( input, islandSize, connexity );
     }
 
-    void runDilatation( Img<FloatType> input, PostTreatmentParameters parameters )
+    void runDilatation( Img< FloatType > input, PostTreatmentParameters parameters )
     {
         double sigmaXY = parameters.getSigmaXY();
         double sigmaZ = parameters.getSigmaZ();
@@ -79,13 +87,18 @@ public class PostTreatment
         Utils.gaussianConvolution( input.copy(), input, new double[]{ sigmaXY, sigmaXY, sigmaZ } );
     }
 
+    void runDilatation( Img< FloatType > input, double sigmaXY, double sigmaZ )
+    {
+        LOGGER.info( "Running dilatation with sigma XY = {} and sigma Z = {}", sigmaXY, sigmaZ );
+        Utils.gaussianConvolution( input.copy(), input, new double[]{ sigmaXY, sigmaXY, sigmaZ } );
+    }
+
     /**
-     *
      * @param stack an image as a {@link RandomAccessibleInterval}
-     * @param <T> the image type
+     * @param <T>   the image type
      * @return the image as a 2D {@link Pixels} array.
      */
-    public  < T extends RealType< T > & NativeType< T > > Pixels[][] buildPixelArray(
+    public < T extends RealType< T > & NativeType< T > > Pixels[][] buildPixelArray(
             final RandomAccessibleInterval< T > stack )
     {
         RandomAccess< T > access = stack.randomAccess();
@@ -138,6 +151,28 @@ public class PostTreatment
         LOGGER.info( "Post treatment complete" );
     }
 
+    public void process( double sigmaXY, double sigmaZ, int islandSize, int connexity ) throws DataValidationException
+    {
+        LOGGER.info( "Starting post treatment." );
+        /* Isolated Pixel removal */
+        Img< BitType > temp = input;
+        if ( islandSize != 0 )
+        {
+            temp = runIslandSearch( input, islandSize, connexity );
+        }
+        /* Conversion into FloatType before dilatation */
+        Img< FloatType > converted = convertBitTypeIntoFloatType( temp );
+        // Use of Converter.convert() not possible because classifiedPixel type do not extends RealType
+
+        /* Dilatation of the resulting image*/
+        runDilatation( converted, sigmaXY, sigmaZ );
+
+        /* Final local maximum detection */
+        converted = ExtremaDetection.findMaxima( converted.copy(), converted.factory() );
+        output = buildPixelArray( converted );
+        LOGGER.info( "Post treatment complete" );
+    }
+
     public Pixels[][] getOutput()
     {
         return output;
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/PostTreatmentParameters.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/PostTreatmentParameters.java
index aeb4bae45ab507fd2d73eb0f9e3f1567d515b9f5..9ec464eef190b5d34c1261846512e5c4c540bcd3 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/PostTreatmentParameters.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/PostTreatmentParameters.java
@@ -31,24 +31,23 @@ public class PostTreatmentParameters
      * @param islandSize the minimum size of the island search
      * @throws DataValidationException if at least one parameter is not valid.
      */
-    public void postTreatmentParametersValidationCheck( double sigmaXY, double sigmaZ, int islandSize) throws DataValidationException
+    public static void postTreatmentParametersValidationCheck( double sigmaXY, double sigmaZ, int islandSize ) throws DataValidationException
     {
         valueValidationCheck( SIGMA_XY, sigmaXY );
-        valueValidationCheck( SIGMA_Z, sigmaZ);
-        valueValidationCheck( ISLAND_SIZE , islandSize);
+        valueValidationCheck( SIGMA_Z, sigmaZ );
+        valueValidationCheck( ISLAND_SIZE, islandSize );
     }
 
     /**
-     *
-     * @param name the parameter name to display in the error message.
+     * @param name  the parameter name to display in the error message.
      * @param value the value of the parameter tested.
      * @throws DataValidationException if the value is inferior to zero.
      */
-    private void valueValidationCheck( String name, double value ) throws DataValidationException
+    private static void valueValidationCheck( String name, double value ) throws DataValidationException
     {
-        if (name.equals( CONNEXITY ))
+        if ( name.equals( CONNEXITY ) )
         {
-            if (value!= 4 && value!= 8)
+            if ( value != 4 && value != 8 )
             {
                 throw new DataValidationException( "The value of parameter " + name + " has to be 4 or 8 !" );
             }
@@ -59,6 +58,7 @@ public class PostTreatmentParameters
             {
                 throw new DataValidationException( "The value of parameter " + name + " has to be superior to zero !" );
             }
+
         }
     }
 
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/islandSearch/IslandSearch.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/islandSearch/IslandSearch.java
index 9d95e65aa875758df9fc2fcf0ec42770dc912885..203db928678b0f85b97652f30fe7fff88471ac69 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/islandSearch/IslandSearch.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/postTreatment/islandSearch/IslandSearch.java
@@ -84,6 +84,7 @@ public class IslandSearch
      */
     private World convertImgIntoWorld()
     {
+        inputCount = 0;
         int width = ( int ) classifiedImage.dimension( 0 );
         int height = ( int ) classifiedImage.dimension( 1 );
         int depth = ( int ) classifiedImage.dimension( 2 );
@@ -114,6 +115,7 @@ public class IslandSearch
      */
     private void convertWorldIntoImg( World world, Img< BitType > image )
     {
+        pixelRemovedCount = 0;
         RandomAccess< BitType > access = image.randomAccess();
         for ( int z = 0; z < world.getDepth(); z++ )
         {
diff --git a/src/main/java/fr/pasteur/ida/zellige/steps/selection/pretreatment/Pretreatment.java b/src/main/java/fr/pasteur/ida/zellige/steps/selection/pretreatment/Pretreatment.java
index 551eabd26e856b0e70a75c13ffcae4872bd70804..b3873e153572416ea93877df5e92ef0702fbabaf 100644
--- a/src/main/java/fr/pasteur/ida/zellige/steps/selection/pretreatment/Pretreatment.java
+++ b/src/main/java/fr/pasteur/ida/zellige/steps/selection/pretreatment/Pretreatment.java
@@ -22,22 +22,23 @@ public class Pretreatment< T extends RealType< T > & NativeType< T > >
     private final static Logger LOGGER = LoggerFactory.getLogger( Pretreatment.class );
 
     private final RandomAccessibleInterval< T > input;
-    private final PretreatmentParameters pretreatmentParameters;
+    //    private final PretreatmentParameters pretreatmentParameters;
+    private final double radius;
     private Img< FloatType > output;
 
 
-    Pretreatment( RandomAccessibleInterval< T > input, PretreatmentParameters pretreatmentParameters )
+    Pretreatment( RandomAccessibleInterval< T > input, double radius )
     {
         this.input = input;
-        this.pretreatmentParameters = pretreatmentParameters;
+        this.radius = radius;
     }
 
 
     public static < T extends RealType< T > & NativeType< T > > Img< FloatType >
-    run( RandomAccessibleInterval< T > input, PretreatmentParameters pretreatmentParameters )
+    run( RandomAccessibleInterval< T > input, double radius )
     {
         LOGGER.debug( "Starting process..." );
-        Pretreatment< T > pretreatment = new Pretreatment<>( input, pretreatmentParameters );
+        Pretreatment< T > pretreatment = new Pretreatment<>( input, radius );
         pretreatment.run();
         LOGGER.info( "Process complete." );
         return pretreatment.getOutput();
@@ -46,12 +47,13 @@ public class Pretreatment< T extends RealType< T > & NativeType< T > >
     /**
      * Normalizes the pixel values of an Img between 0 and 255.
      *
-     * @param image - the input Img.
-     * @param <T>   - the type of the input Img.
+     * @param <T>     - the type of the input Img.
+     * @param image   - the input Img.
+     * @param factory
      * @return a new Img with normalize pixel intensity values.
      */
     private static < T extends RealType< T > & NativeType< T > > Img< T > normalizeImage(
-            RandomAccessibleInterval< T > image, ImgFactory< T > factory )
+            Img< T > image, ImgFactory< T > factory )
     {
         Img< T > normalizedImage = factory.create( image );
         ImgUtil.copy( image, normalizedImage );
@@ -97,7 +99,6 @@ public class Pretreatment< T extends RealType< T > & NativeType< T > >
 
     void run()
     {
-
         // The input is converted into FloatType
         RandomAccessibleInterval< FloatType > converted = Converters.convert( input, new RealFloatSamplerConverter<>() );
         LOGGER.debug( "Input converted." );
@@ -118,8 +119,7 @@ public class Pretreatment< T extends RealType< T > & NativeType< T > >
     Img< FloatType > gaussianBlurFilterDenoising( RandomAccessibleInterval< FloatType > input )
     {
         ImgFactory< FloatType > factory = new ArrayImgFactory<>( new FloatType() );
-        double parameters = pretreatmentParameters.getParameter();
-        return gaussianConvolution( input, factory, new double[]{ parameters, parameters, 1 } );
+        return gaussianConvolution( input, factory, new double[]{ radius, radius, 1 } );
     }
 
     public RandomAccessibleInterval< T > getInput()
diff --git a/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/HMvsGT_Display.java b/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/HMvsGT_Display.java
index 72b06b6739b2e9ef4f1a0071d95624251bc381de..74ea63d827204c1ee8e6db4bd5ddefe1ab52dbbf 100644
--- a/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/HMvsGT_Display.java
+++ b/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/HMvsGT_Display.java
@@ -61,8 +61,8 @@ public class HMvsGT_Display< T extends RealType< T > & NativeType< T >, R extend
 
     public static void main( String[] args )
     {
-        String pathGT = "C:\\Users\\ctrebeau\\Desktop\\Covid Zellige\\C2-MucilairB spike zo1 J4 Sars-3_Ground truth Height map.tif";
-        String pathHM = "C:\\Users\\ctrebeau\\Desktop\\Covid Zellige\\C2-MucilairB spike zo1 J4 Sars-3_HM.tif";
+        String pathGT = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\files\\Organoid\\Organoid_GT_HM2.tif";
+        String pathHM = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\Paper_012022\\Organoid\\Organoid_HM_0.tif";
         final SCIFIOImgPlus< ? > imgPlusRef = IO.openImgs( pathGT ).get( 0 );
         Img< FloatType > GT = ( Img< FloatType > ) imgPlusRef.getImg();
 
diff --git a/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/HeightMapArrayWriter.java b/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/HeightMapArrayWriter.java
new file mode 100644
index 0000000000000000000000000000000000000000..0808a25536d8fae62e6168eb3af3cd60e63904d8
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/HeightMapArrayWriter.java
@@ -0,0 +1,87 @@
+package fr.pasteur.ida.zellige.utils.jzy3D;
+
+import fr.pasteur.ida.zellige.element.Surface;
+import fr.pasteur.ida.zellige.utils.test.CSVWriter;
+import io.scif.img.IO;
+import io.scif.img.SCIFIOImgPlus;
+import net.imglib2.Cursor;
+import net.imglib2.img.Img;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import org.jzy3d.analysis.AbstractAnalysis;
+
+import java.io.IOException;
+
+public class HeightMapArrayWriter< T extends RealType< T > & NativeType< T > > extends AbstractAnalysis
+{
+
+    private final Img< T > surface;
+    private final String originalInput;
+    private final int surfaceNumber;
+
+    public HeightMapArrayWriter( Img< T > surface, String originalInput, int surfaceNumber ) throws IOException
+    {
+
+        this.surface = surface;
+        this.originalInput = originalInput;
+        this.surfaceNumber = surfaceNumber;
+        init();
+    }
+
+    /**
+     * Displays the local maximums found using jzy3D package.
+     *
+     * @param surface the {@link Surface} to display
+     */
+    public static < T extends RealType< T > & NativeType< T > > void writeHeightMap( Img< T > surface, String originalInput, int surfaceNumber )
+    {
+        try
+        {
+            new HeightMapArrayWriter( surface, originalInput, surfaceNumber );
+        }
+        catch ( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    public static < T extends RealType< T > & NativeType< T > > void main( String[] args )
+    {
+        final String imagePath = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\Paper_012022\\Organoid\\Organoid_GT_HM1.tif"; /* The image path goes here !!!! */
+        System.out.println( imagePath );
+        /* JY version for opening files. */
+        final SCIFIOImgPlus< ? > imgPlus = IO.openImgs( imagePath ).get( 0 );
+        final Img< T > heightMap = ( Img< T > ) imgPlus.getImg();
+        writeHeightMap( heightMap, imgPlus.getName(), 2 );
+        System.out.println( "END" );
+
+    }
+
+    @Override
+    public void init() throws IOException
+    {
+        if ( surface != null )
+        {
+            CSVWriter csvWriter =
+                    new CSVWriter( originalInput + "_" + "surface" );
+            Cursor< T > cursor = surface.cursor();
+            csvWriter.writeToFile( new String[]{ "x", "y", "z" } );
+            while ( cursor.hasNext() )
+            {
+                cursor.fwd();
+                {
+                    if ( cursor.get().getRealFloat() != 0 )
+                    {
+                        csvWriter.writeToFile(
+                                new String[]{ String.valueOf( cursor.getIntPosition( 0 ) ),
+                                        String.valueOf( cursor.getIntPosition( 1 ) ),
+                                        String.valueOf( cursor.get().getRealFloat() ) } );
+                    }
+                }
+            }
+
+        }
+    }
+
+
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/LocalMaximumsDisplay.java b/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/LocalMaximumsDisplay.java
index fbe4482612410fc3f368d1d544e1943eee287f1e..9982250744a686f9fbae5995bb4d6793a1f4360e 100644
--- a/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/LocalMaximumsDisplay.java
+++ b/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/LocalMaximumsDisplay.java
@@ -100,7 +100,7 @@ public class LocalMaximumsDisplay extends AbstractAnalysis
             }
 
             Scatter scatter = new Scatter( points, colors );
-            scatter.setWidth( 1 );
+            scatter.setWidth( 2 );
             chart = AWTChartComponentFactory.chart( Quality.Advanced, "awt" );
             chart.getScene().add( scatter );
         }
diff --git a/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/SelectedPixelsArrayWriter.java b/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/SelectedPixelsArrayWriter.java
new file mode 100644
index 0000000000000000000000000000000000000000..25a4ad900c7688dfdf31f5ffbe1d3213612d87f8
--- /dev/null
+++ b/src/main/java/fr/pasteur/ida/zellige/utils/jzy3D/SelectedPixelsArrayWriter.java
@@ -0,0 +1,68 @@
+package fr.pasteur.ida.zellige.utils.jzy3D;
+
+import fr.pasteur.ida.zellige.element.Pixels;
+import fr.pasteur.ida.zellige.element.Surface;
+import fr.pasteur.ida.zellige.utils.test.CSVWriter;
+import org.jzy3d.analysis.AbstractAnalysis;
+
+import java.io.IOException;
+
+public class SelectedPixelsArrayWriter extends AbstractAnalysis
+{
+
+    private final Pixels[][] selectedPixels;
+    private final String originalInput;
+
+    public SelectedPixelsArrayWriter( Pixels[][] selectedPixels, String originalInput ) throws IOException
+    {
+
+        this.selectedPixels = selectedPixels;
+        this.originalInput = originalInput;
+        init();
+    }
+
+    /**
+     * Displays the local maximums found using jzy3D package.
+     *
+     * @param selectedPixels the {@link Surface} to display
+     */
+    public static void writeSelectedPixels( Pixels[][] selectedPixels, String originalInput )
+    {
+        try
+        {
+            new SelectedPixelsArrayWriter( selectedPixels, originalInput );
+        }
+        catch ( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void init() throws IOException
+    {
+        if ( selectedPixels != null )
+        {
+
+            CSVWriter csvWriter =
+                    new CSVWriter( originalInput + "_selectedPixels" );
+            csvWriter.writeToFile( new String[]{ "x", "y", "z" } );
+            for ( int x = 0; x < selectedPixels.length; x++ )
+            {
+                for ( int y = 0; y < selectedPixels[ 0 ].length; y++ )
+                {
+                    for ( int z = 0; z < selectedPixels[ y ][ x ].size(); z++ )
+                    {
+                        Pixels pixel = selectedPixels[ y ][ x ];
+                        csvWriter.writeToFile(
+                                new String[]{ String.valueOf( x ),
+                                        String.valueOf( y ),
+                                        String.valueOf( pixel.get( z ).getZ() ) } );
+                    }
+                }
+            }
+        }
+    }
+
+
+}
diff --git a/src/main/java/fr/pasteur/ida/zellige/utils/test/DistanceImageWriter.java b/src/main/java/fr/pasteur/ida/zellige/utils/test/DistanceImageWriter.java
index 654aab90c7c57faa896ee30be55ee0326df3306f..d5095dea73cb24daf9a498fc4ed832a8e9c0f3b1 100644
--- a/src/main/java/fr/pasteur/ida/zellige/utils/test/DistanceImageWriter.java
+++ b/src/main/java/fr/pasteur/ida/zellige/utils/test/DistanceImageWriter.java
@@ -45,8 +45,8 @@ public class DistanceImageWriter< T extends RealType< T > & NativeType< T >, R e
 
     public static void main( String[] args ) throws IOException
     {
-        String pathGT = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\files\\SNR\\snr_010\\multiSurface\\phantoms_snrtest_zmap3_gt.tif";
-        String pathHM = "C:\\Users\\ctrebeau\\Downloads\\MinCostZSurface\\CostFunctionVar\\H2_mind6_maxd50_maxdz1.tif";
+        String pathGT = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\files\\Mouche_c01_f0001_p013\\GT\\Ground truth Height map_4_crop.tif";
+        String pathHM = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\Paper_012022\\Mouche\\Mouche_HM_3.tif";
         final SCIFIOImgPlus< ? > imgPlusRef = IO.openImgs( pathGT ).get( 0 );
         Img< FloatType > GT = ( Img< FloatType > ) imgPlusRef.getImg();
         new ImageJ();
@@ -55,8 +55,7 @@ public class DistanceImageWriter< T extends RealType< T > & NativeType< T >, R e
         final SCIFIOImgPlus< ? > imgPlus = IO.openImgs( pathHM ).get( 0 );
         Img< FloatType > HM = ( Img< FloatType > ) imgPlus.getImg();
         ImageJFunctions.show( HM );
-        DistanceImageWriter.create( GT, HM, "Min cost Z_distance_surface 1_H1_mind6_maxd50_maxdz2" );
-
+        DistanceImageWriter.create( GT, HM, "Mouche_distance4_crop" );
     }
 
     public void run() throws IOException
diff --git a/src/main/java/fr/pasteur/ida/zellige/utils/test/RMSEAndCoverageComputation.java b/src/main/java/fr/pasteur/ida/zellige/utils/test/RMSEAndCoverageComputation.java
index 7bfd105b9306699f84ea325a1cdb0fe8e3154782..49a4e267f7b4e2713795e46dcb06acf00f303b79 100644
--- a/src/main/java/fr/pasteur/ida/zellige/utils/test/RMSEAndCoverageComputation.java
+++ b/src/main/java/fr/pasteur/ida/zellige/utils/test/RMSEAndCoverageComputation.java
@@ -176,8 +176,8 @@ public class RMSEAndCoverageComputation< T extends RealType< T > & NativeType< T
 
     public static void main( String[] args ) throws NotAnHeightMapException, DifferentReferenceTestedSizeException
     {
-        String pathGT = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\files\\SNR\\snr_010\\multiSurface\\phantoms_snrtest_zmap1_gt.tif";
-        String pathHM = "C:\\Users\\ctrebeau\\Downloads\\MinCostZSurface\\CostFunctionInt\\H1_mind5_maxd17_maxdz1.tif";
+        String pathGT = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\files\\Covid Zellige\\C2-MucilairB spike zo1 J4 Sars-3_Ground truth Height map.tif";
+        String pathHM = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\files\\Covid Zellige\\Covid_0.5_0.1_5.tif";
         final SCIFIOImgPlus< ? > imgPlusRef = IO.openImgs( pathGT ).get( 0 );
         Img< FloatType > GT = ( Img< FloatType > ) imgPlusRef.getImg();
         new ImageJ();
diff --git a/src/main/java/fr/pasteur/ida/zellige/utils/test/ZParameters.java b/src/main/java/fr/pasteur/ida/zellige/utils/test/ZParameters.java
index 702c1a3d2b5ad959165a2b8f6d2172c7648862a1..ff670809cf94a1952ea19ab298cf2a77c6883563 100644
--- a/src/main/java/fr/pasteur/ida/zellige/utils/test/ZParameters.java
+++ b/src/main/java/fr/pasteur/ida/zellige/utils/test/ZParameters.java
@@ -20,7 +20,7 @@ public class ZParameters
 
 
     public ZParameters( String filter, int filterParameter,
-                        double amplitudeThreshold, double otsuThreshold,
+                        int amplitudeThreshold, int otsuThreshold,
                         int ISConnexity, int ISSize,
                         double XYSmoothing, double ZSmoothing,
                         double startingThreshold1, int overlap1, double connexityRate1,
diff --git a/src/main/java/fr/pasteur/ida/zellige/utils/test/ZelligePipelineAnalyse.java b/src/main/java/fr/pasteur/ida/zellige/utils/test/ZelligePipelineAnalyse.java
index 81f98f3b2e4f8a989afd378c3afb629f58e3b345..3bf7ba8f94042f00a9fb919330540380c15fade1 100644
--- a/src/main/java/fr/pasteur/ida/zellige/utils/test/ZelligePipelineAnalyse.java
+++ b/src/main/java/fr/pasteur/ida/zellige/utils/test/ZelligePipelineAnalyse.java
@@ -192,6 +192,7 @@ public class ZelligePipelineAnalyse< T extends RealType< T > & NativeType< T >,
             }
             else
             {
+
                 return new String[]{
                         String.valueOf( error.getIndex() ),
                         String.valueOf( getSelectedPixelNumber() ),
@@ -217,6 +218,7 @@ public class ZelligePipelineAnalyse< T extends RealType< T > & NativeType< T >,
                         String.valueOf( extraction.getSS_goodSurfaces() ),
                         String.valueOf( extraction.getSS_smallSurfaces() ),
                         String.valueOf( extraction.getReferenceSurfaces().size() ) };
+
             }
         }
         return null;
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/Construction.fxml b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Construction.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..8fbf673e2986726fc4642edcc40b5a66a8479b9a
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Construction.fxml
@@ -0,0 +1,100 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import fr.pasteur.ida.zellige.gui.*?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.*?>
+<StepPanel xmlns:fx="http://javafx.com/fxml/1" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+           minWidth="-Infinity" name="Construction" prefHeight="342.0" prefWidth="390.0"
+           xmlns="http://javafx.com/javafx/17" fx:controller="fr.pasteur.ida.zellige.gui.ConstructionController">
+    <children>
+        <GridPane alignment="CENTER" minWidth="-Infinity" prefHeight="307.0" prefWidth="390.0" vgap="15.0">
+            <columnConstraints>
+                <ColumnConstraints halignment="CENTER" hgrow="SOMETIMES" maxWidth="-Infinity" minWidth="10.0"
+                                   prefWidth="44.0"/>
+                <ColumnConstraints hgrow="SOMETIMES" maxWidth="469.599951171875" minWidth="10.0"
+                                   prefWidth="346.40001220703124"/>
+            </columnConstraints>
+            <rowConstraints>
+                <RowConstraints maxHeight="170.9999984741211" minHeight="10.0" prefHeight="128.0" valignment="CENTER"
+                                vgrow="SOMETIMES"/>
+                <RowConstraints maxHeight="218.9999755859375" minHeight="10.0" prefHeight="128.0" vgrow="SOMETIMES"/>
+                <RowConstraints maxHeight="110.00003662109378" minHeight="10.0" prefHeight="70.39997253417965"
+                                vgrow="SOMETIMES"/>
+            </rowConstraints>
+            <children>
+                <VBox alignment="CENTER" GridPane.columnIndex="1">
+                    <children>
+                        <GridPane alignment="CENTER" prefHeight="147.0" prefWidth="599.0">
+                            <columnConstraints>
+                                <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0"/>
+                            </columnConstraints>
+                            <rowConstraints>
+                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                            </rowConstraints>
+                            <children>
+                                <ParameterSliderDouble fx:id="st1" alignment="CENTER" default="0.7" increment="0.1"
+                                                       interval="%INTERVAL3" major="0.2" max="1" min="0" minor="1"
+                                                       name="Starting threshold"/>
+                                <ParameterSliderDouble fx:id="c1" alignment="CENTER" default="0.8" increment="0.1"
+                                                       interval="%INTERVAL3" major="0.2" max="1" min="0" minor="1"
+                                                       name="Connexity" GridPane.rowIndex="1"/>
+                                <ParameterSliderInteger fx:id="r1" default="5" increment="0.1" interval="%INTERVAL1"
+                                                        major="10" max="50" min="0" minor="4" name="Overlap"
+                                                        GridPane.rowIndex="2"/>
+                            </children>
+                        </GridPane>
+                    </children>
+                </VBox>
+                <VBox alignment="CENTER" prefHeight="200.0" prefWidth="100.0" GridPane.columnIndex="1"
+                      GridPane.rowIndex="1">
+                    <children>
+                        <GridPane prefHeight="147.0" prefWidth="599.0">
+                            <columnConstraints>
+                                <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0"/>
+                            </columnConstraints>
+                            <rowConstraints>
+                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                            </rowConstraints>
+                            <children>
+                                <ParameterSliderDouble fx:id="st2" default="0.7" increment="0.1" interval="%INTERVAL3"
+                                                       major="0.2" max="1" min="0" minor="1" name="Starting threshold"/>
+                                <ParameterSliderDouble fx:id="c2" default="0.8" increment="0.1" interval="%INTERVAL3"
+                                                       major="0.2" max="1" min="0" minor="1" name="Connexity"
+                                                       GridPane.rowIndex="1"/>
+                                <ParameterSliderInteger fx:id="r2" default="5" increment="0.1" interval="%INTERVAL1"
+                                                        major="10" max="50" min="0" minor="1" name="Overlap"
+                                                        GridPane.rowIndex="2"/>
+                            </children>
+                        </GridPane>
+                    </children>
+                </VBox>
+                <VBox alignment="CENTER" prefHeight="36.0" prefWidth="340.0" GridPane.columnIndex="1"
+                      GridPane.rowIndex="2">
+                    <children>
+                        <GridPane>
+                            <columnConstraints>
+                                <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0"/>
+                            </columnConstraints>
+                            <rowConstraints>
+                                <RowConstraints minHeight="10.0" vgrow="SOMETIMES"/>
+                            </rowConstraints>
+                            <children>
+                                <ParameterSliderDouble fx:id="surfaceSize" default="0.7" increment="0.05"
+                                                       interval="%INTERVAL3" major="0.2" max="1" min="0" minor="4"
+                                                       name="Surface min size"/>
+                            </children>
+                        </GridPane>
+                    </children>
+                </VBox>
+                <Label alignment="CENTER" minWidth="-Infinity" prefHeight="14.0" prefWidth="100.0" rotate="-90.0"
+                       text="FIRST ROUND"/>
+                <Label alignment="CENTER" minWidth="-Infinity" prefWidth="100.0" rotate="-90.0" text="SECOND ROUND"
+                       GridPane.rowIndex="1"/>
+            </children>
+        </GridPane>
+    </children>
+</StepPanel>
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/Display.fxml b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Display.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..d0c7e15b204dafe46f41c367ce48460ee62971b4
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Display.fxml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.*?>
+<?import java.lang.String?>
+<BorderPane xmlns:fx="http://javafx.com/fxml/1" xmlns="http://javafx.com/javafx/17">
+    <center>
+        <VBox alignment="CENTER_LEFT" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+              minWidth="-Infinity" prefHeight="186.0" prefWidth="286.0" spacing="10.0"
+              BorderPane.alignment="CENTER_RIGHT">
+            <children>
+                <CheckBox fx:id="projection" mnemonicParsing="false" text="2D selectedPixels projection"/>
+                <CheckBox fx:id="heightmap" mnemonicParsing="false" text="Height map"/>
+                <CheckBox fx:id="extractedSurface" mnemonicParsing="false" text="3D extracted selectedPixels"/>
+                <CheckBox fx:id="heightMapStack" mnemonicParsing="false" text="Height map stack(± delta)"/>
+                <CheckBox fx:id="heightMapStackMask" mnemonicParsing="false"
+                          text="Height map sub-volume mask (± delta)"/>
+            </children>
+            <padding>
+                <Insets left="40.0" top="5.0"/>
+            </padding>
+            <opaqueInsets>
+                <Insets/>
+            </opaqueInsets>
+        </VBox>
+    </center>
+    <top>
+        <Label alignment="TOP_LEFT" styleClass="step-title" text="Output display" BorderPane.alignment="TOP_LEFT">
+            <BorderPane.margin>
+                <Insets/>
+            </BorderPane.margin>
+            <padding>
+                <Insets left="20.0"/>
+            </padding>
+        </Label>
+    </top>
+    <styleClass>
+        <String fx:value="step_border"/>
+        <String fx:value="step-title"/>
+    </styleClass>
+</BorderPane>
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/Main.fxml b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Main.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..d558902c17346586eb3bb6b4db8c9bebf67594b0
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Main.fxml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.ComboBox?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.*?>
+<AnchorPane xmlns:fx="http://javafx.com/fxml/1" prefHeight="764.0" prefWidth="826.0" xmlns="http://javafx.com/javafx/17"
+            fx:controller="fr.pasteur.ida.zellige.gui.MainController">
+    <children>
+        <VBox maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="751.0"
+              prefWidth="816.0" spacing="7.0" AnchorPane.bottomAnchor="3.0" AnchorPane.topAnchor="0.0">
+            <children>
+                <HBox prefHeight="26.0" prefWidth="774.0" spacing="8.0">
+                    <children>
+                        <Label text="File : "/>
+                        <ComboBox fx:id="activeDataset" maxWidth="-Infinity" minWidth="-Infinity" prefHeight="26.0"
+                                  prefWidth="262.0"/>
+                    </children>
+                    <padding>
+                        <Insets left="10.0"/>
+                    </padding>
+                </HBox>
+                <fx:include fx:id="selection" source="Selection.fxml"/>
+                <HBox alignment="CENTER_LEFT" prefHeight="319.0" prefWidth="600.0" spacing="20.0">
+                    <children>
+                        <fx:include fx:id="construction" source="Construction.fxml"/>
+                        <fx:include fx:id="projection" source="Projection.fxml"/>
+                    </children>
+                </HBox>
+                <StackPane prefHeight="51.0" prefWidth="747.0">
+                    <children>
+                        <Button fx:id="runButton" mnemonicParsing="false" text="Run Zellige !"/>
+                    </children>
+                </StackPane>
+            </children>
+            <padding>
+                <Insets left="10.0" top="5.0"/>
+            </padding>
+        </VBox>
+    </children>
+    <padding>
+        <Insets left="10.0"/>
+    </padding>
+</AnchorPane>
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/ParameterSlider.fxml b/src/main/resources/fr.pasteur.ida.zellige.gui.view/ParameterSlider.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..eeda355b0c28bb0f7d4bc59c83bc7a06a12c5b57
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/ParameterSlider.fxml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--No controller specified and need of fx:root-->
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.Slider?>
+<?import javafx.scene.control.TextField?>
+<?import javafx.scene.layout.*?>
+<fx:root xmlns:fx="http://javafx.com/fxml/1" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+         minWidth="-Infinity" prefHeight="41.0" prefWidth="338.0" styleClass="parameter" stylesheets="@theme2.css"
+         type="GridPane" xmlns="http://javafx.com/javafx/17">
+    <columnConstraints>
+        <ColumnConstraints halignment="CENTER" hgrow="ALWAYS" maxWidth="130.1999755859375" minWidth="10.0"
+                           prefWidth="56.79996337890625"/>
+        <ColumnConstraints hgrow="ALWAYS" maxWidth="415.5999755859375" minWidth="10.0" prefWidth="251.20003662109374"/>
+        <ColumnConstraints halignment="CENTER" hgrow="ALWAYS" maxWidth="242.79998779296875" minWidth="10.0"
+                           prefWidth="36.20002441406251"/>
+    </columnConstraints>
+    <rowConstraints>
+        <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+    </rowConstraints>
+
+    <Label fx:id="label" alignment="CENTER_RIGHT" prefHeight="35.0" prefWidth="71.0" text="Parameter Name"
+           textAlignment="RIGHT" wrapText="true" GridPane.halignment="RIGHT" GridPane.valignment="CENTER"/>
+    <Slider fx:id="slider" stylesheets="@theme2.css" GridPane.columnIndex="1" GridPane.valignment="BOTTOM">
+        <padding>
+            <Insets left="5.0" right="5.0"/>
+        </padding>
+    </Slider>
+    <TextField fx:id="textField" alignment="CENTER" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+               minWidth="-Infinity" prefHeight="26.0" prefWidth="30.0" GridPane.columnIndex="2"
+               GridPane.halignment="CENTER" GridPane.valignment="CENTER"/>
+
+</fx:root>
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/Projection.fxml b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Projection.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..2c8d1d4cd257a0d397c315ad805dc46a792bc4b5
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Projection.fxml
@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import fr.pasteur.ida.zellige.gui.StepPanel?>
+<?import javafx.geometry.*?>
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.*?>
+<StepPanel xmlns:fx="http://javafx.com/fxml/1" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+           minWidth="-Infinity" name="Projection" prefHeight="342.0" prefWidth="390.0"
+           xmlns="http://javafx.com/javafx/17" fx:controller="fr.pasteur.ida.zellige.gui.ProjectionController">
+    <children>
+        <VBox alignment="CENTER" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" prefHeight="312.0"
+              prefWidth="389.0">
+            <children>
+                <StackPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" prefHeight="313.0"
+                           prefWidth="362.0">
+                    <children>
+                        <BorderPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+                                    minWidth="-Infinity" prefHeight="316.0" prefWidth="362.0">
+                            <opaqueInsets>
+                                <Insets/>
+                            </opaqueInsets>
+                            <center>
+                                <HBox maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+                                      minWidth="-Infinity" prefHeight="61.0" prefWidth="342.0"
+                                      BorderPane.alignment="CENTER">
+                                    <children>
+                                        <VBox alignment="CENTER" prefHeight="108.0" prefWidth="220.0" spacing="5.0">
+                                            <children>
+                                                <Label contentDisplay="CENTER" text="Method"/>
+                                                <ComboBox fx:id="methodComboBox" prefWidth="150.0"/>
+                                            </children>
+                                        </VBox>
+                                        <VBox alignment="CENTER" prefHeight="108.0" prefWidth="216.0" spacing="5.0">
+                                            <children>
+                                                <Label text="Delta Z"/>
+                                                <Spinner fx:id="deltaSpinner" prefHeight="27.0" prefWidth="119.0"/>
+                                            </children>
+                                        </VBox>
+                                    </children>
+                                </HBox>
+                            </center>
+                            <bottom>
+                                <BorderPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+                                            minWidth="-Infinity" prefHeight="222.0" prefWidth="342.0"
+                                            BorderPane.alignment="CENTER">
+                                    <top>
+                                        <Label alignment="TOP_LEFT" styleClass="step-title" text="Output display"
+                                               BorderPane.alignment="TOP_LEFT">
+                                            <BorderPane.margin>
+                                                <Insets/>
+                                            </BorderPane.margin>
+                                            <padding>
+                                                <Insets left="20.0"/>
+                                            </padding>
+                                        </Label>
+                                    </top>
+                                    <bottom>
+                                        <VBox alignment="CENTER_LEFT" maxHeight="-Infinity" maxWidth="-Infinity"
+                                              minHeight="-Infinity" minWidth="-Infinity" prefHeight="201.0"
+                                              prefWidth="286.0" spacing="10.0" BorderPane.alignment="CENTER">
+                                            <children>
+                                                <CheckBox fx:id="projection" mnemonicParsing="false" selected="true"
+                                                          text="2D selectedPixels projection"/>
+                                                <CheckBox fx:id="rawHeightMap" mnemonicParsing="false" selected="true"
+                                                          text="Raw height map"/>
+                                                <CheckBox fx:id="extractedHeightMap" mnemonicParsing="false"
+                                                          text="Extracted height map"/>
+                                                <CheckBox fx:id="segmentedSurface" mnemonicParsing="false"
+                                                          text="3D extracted selectedPixels"/>
+                                                <CheckBox fx:id="reduced3DSpace" mnemonicParsing="false"
+                                                          text="Height map stack(± delta)"/>
+                                                <HBox prefHeight="26.0" prefWidth="194.0" spacing="30.0">
+                                                    <children>
+                                                        <CheckBox fx:id="segmentedSurfaceMask" mnemonicParsing="false"
+                                                                  text="Surface mask"/>
+                                                        <Spinner fx:id="delta2" prefHeight="26.0" prefWidth="65.0"/>
+                                                    </children>
+                                                </HBox>
+                                            </children>
+                                            <padding>
+                                                <Insets left="40.0"/>
+                                            </padding>
+                                            <opaqueInsets>
+                                                <Insets/>
+                                            </opaqueInsets>
+                                        </VBox>
+                                    </bottom>
+                                </BorderPane>
+                            </bottom>
+                        </BorderPane>
+                    </children>
+                </StackPane>
+            </children>
+        </VBox>
+    </children>
+</StepPanel>
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/Selection.fxml b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Selection.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..efcc3e81cdf443fb61cacc919629175e6405bb30
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/Selection.fxml
@@ -0,0 +1,112 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import fr.pasteur.ida.zellige.gui.*?>
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.*?>
+<StepPanel xmlns:fx="http://javafx.com/fxml/1" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+           minWidth="-Infinity" name="Selection" prefHeight="327.0" prefWidth="800.0"
+           xmlns="http://javafx.com/javafx/17" fx:controller="fr.pasteur.ida.zellige.gui.SelectionController">
+    <children>
+        <GridPane prefHeight="296.0" prefWidth="766.0">
+            <columnConstraints>
+                <ColumnConstraints hgrow="SOMETIMES" maxWidth="-Infinity" minWidth="10.0" prefWidth="390.0"/>
+                <ColumnConstraints hgrow="SOMETIMES" maxWidth="-Infinity" minWidth="10.0" prefWidth="390.0"/>
+            </columnConstraints>
+            <rowConstraints>
+                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+            </rowConstraints>
+            <children>
+                <Pane maxHeight="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="224.0"
+                      prefWidth="390.0" GridPane.halignment="CENTER" GridPane.valignment="CENTER">
+                    <children>
+                        <GridPane alignment="CENTER" layoutX="1.0" prefHeight="223.0" prefWidth="397.0" vgap="15.0">
+                            <columnConstraints>
+                                <ColumnConstraints hgrow="SOMETIMES" maxWidth="-Infinity" minWidth="0.0"
+                                                   prefWidth="44.0"/>
+                                <ColumnConstraints hgrow="SOMETIMES" maxWidth="542.9999614715576" minWidth="10.0"
+                                                   prefWidth="353.5999816894531"/>
+                            </columnConstraints>
+                            <rowConstraints>
+                                <RowConstraints maxHeight="203.59998168945313" minHeight="10.0"
+                                                prefHeight="150.40000610351564" vgrow="SOMETIMES"/>
+                                <RowConstraints maxHeight="187.99998779296874" minHeight="10.0"
+                                                prefHeight="114.39999389648438" vgrow="SOMETIMES"/>
+                            </rowConstraints>
+                            <children>
+                                <VBox alignment="CENTER" prefHeight="148.0" prefWidth="352.0" GridPane.columnIndex="1"
+                                      GridPane.halignment="CENTER" GridPane.valignment="CENTER">
+                                    <children>
+                                        <GridPane prefHeight="165.0" prefWidth="370.0">
+                                            <columnConstraints>
+                                                <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0"/>
+                                            </columnConstraints>
+                                            <rowConstraints>
+                                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                                            </rowConstraints>
+                                            <children>
+                                                <ParameterSliderInteger fx:id="amplitude" default="10" increment="1"
+                                                                        interval="%INTERVAL1" major="10" max="50"
+                                                                        min="0" minor="9" name="Amplitude"/>
+                                                <ParameterSliderInteger fx:id="otsu" default="10" increment="1"
+                                                                        interval="%INTERVAL1" major="10" max="50"
+                                                                        min="0" minor="1" name="Otsu"
+                                                                        GridPane.rowIndex="1"/>
+                                                <ParameterSliderInteger fx:id="island" default="5" increment="1"
+                                                                        interval="%INTERVAL1" major="10" max="50"
+                                                                        min="0" minor="1" name="Island Search"
+                                                                        GridPane.rowIndex="2"/>
+                                            </children>
+                                        </GridPane>
+                                    </children>
+                                </VBox>
+                                <VBox alignment="CENTER" prefHeight="69.0" prefWidth="366.0" spacing="10.0"
+                                      GridPane.columnIndex="1" GridPane.halignment="CENTER" GridPane.rowIndex="1"
+                                      GridPane.valignment="CENTER">
+                                    <children>
+                                        <GridPane alignment="CENTER" prefHeight="66.0" prefWidth="352.0">
+                                            <columnConstraints>
+                                                <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0"/>
+                                            </columnConstraints>
+                                            <rowConstraints>
+                                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                                                <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES"/>
+                                            </rowConstraints>
+                                            <children>
+                                                <ParameterSliderInteger default="1" increment="1" interval="%INTERVAL2"
+                                                                        major="5" max="10" min="0" minor="4"
+                                                                        name="XY Blur" prefHeight="30.0"
+                                                                        fx:id="xyBlur"/>
+                                                <ParameterSliderInteger fx:id="zBlur" default="1" increment="1"
+                                                                        interval="%INTERVAL2" major="5" max="10" min="0"
+                                                                        minor="4" name="Z Blur " GridPane.rowIndex="1"/>
+                                            </children>
+                                        </GridPane>
+                                    </children>
+                                </VBox>
+                                <Label alignment="TOP_CENTER" minWidth="-Infinity" prefHeight="16.0" prefWidth="121.0"
+                                       rotate="-90.0" text="CLASSIFICATION" GridPane.halignment="CENTER"
+                                       GridPane.valignment="CENTER"/>
+                                <Label alignment="TOP_CENTER" minWidth="-Infinity" prefHeight="16.0" prefWidth="121.0"
+                                       rotate="-90.0" text="SMOOTHING" GridPane.halignment="CENTER"
+                                       GridPane.rowIndex="1" GridPane.valignment="CENTER"/>
+                            </children>
+                        </GridPane>
+                    </children>
+                    <GridPane.margin>
+                        <Insets top="10.0"/>
+                    </GridPane.margin>
+                </Pane>
+                <VBox prefHeight="200.0" prefWidth="100.0" GridPane.columnIndex="1">
+                    <children>
+                        <FlowPane fx:id="stack" prefHeight="352.0" prefWidth="346.0"/>
+                        <ZSlicesSlider fx:id="zSlices" alignment="TOP_CENTER" maxHeight="-Infinity" maxWidth="-Infinity"
+                                       minHeight="-Infinity" minWidth="-Infinity" prefHeight="42.0" prefWidth="390.0"/>
+                    </children>
+                </VBox>
+            </children>
+        </GridPane>
+    </children>
+</StepPanel>
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/StepPanel.fxml b/src/main/resources/fr.pasteur.ida.zellige.gui.view/StepPanel.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..a4e1cd37b69d2763d8f38b243a834cb430f9e3f3
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/StepPanel.fxml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.Separator?>
+<?import javafx.scene.layout.VBox?>
+<?import java.lang.String?>
+<fx:root xmlns:fx="http://javafx.com/fxml/1" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity"
+         minWidth="-Infinity" prefHeight="303.0" prefWidth="600.0" stylesheets="@theme2.css" type="VBox"
+         xmlns="http://javafx.com/javafx/17">
+    <children>
+        <Label fx:id="Label2" alignment="CENTER_RIGHT" contentDisplay="RIGHT" prefHeight="7.0" prefWidth="131.0"
+               stylesheets="@theme2.css">
+            <styleClass>
+                <String fx:value="step"/>
+                <String fx:value="label"/>
+            </styleClass>
+        </Label>
+        <Separator prefWidth="200.0">
+            <VBox.margin>
+                <Insets left="5.0" right="10.0"/>
+            </VBox.margin>
+        </Separator>
+    </children>
+    <styleClass>
+        <String fx:value="step"/>
+        <String fx:value="vbox"/>
+    </styleClass>
+</fx:root>
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/ZSlicesSlider.fxml b/src/main/resources/fr.pasteur.ida.zellige.gui.view/ZSlicesSlider.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..bd3b7250821220405a112282eadf0b4318714661
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/ZSlicesSlider.fxml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+
+<?import javafx.scene.control.Slider?>
+<?import javafx.scene.layout.FlowPane?>
+<fx:root xmlns:fx="http://javafx.com/fxml/1" alignment="CENTER" columnHalignment="CENTER" prefHeight="47.0"
+         prefWidth="400.0" stylesheets="@theme2.css" type="FlowPane" xmlns="http://javafx.com/javafx/17">
+    <children>
+        <Slider fx:id="slider" prefHeight="14.0" prefWidth="400.0" visible="false"/>
+    </children>
+</fx:root>
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/theme1.css b/src/main/resources/fr.pasteur.ida.zellige.gui.view/theme1.css
new file mode 100644
index 0000000000000000000000000000000000000000..e84320af31f37de9294286b1fed29cff4305fdd8
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/theme1.css
@@ -0,0 +1,40 @@
+.background {
+    -fx-background-color: #733785;
+}
+
+.step-header {
+    -fx-background-color: #733785;
+}
+
+.step-border {
+    -fx-background-radius: 15 0 0 0;
+    -fx-border-radius: 15 0 0 0;
+    -fx-border-color: #B0B8BA;
+}
+
+.step-title {
+    -fx-font: bold italic 14px System;
+}
+
+
+.parameter.line {
+    /*-fx-background-color: #15BAE7;*/
+    /*blue
+       */
+    -fx-font: 10px Tahoma;
+    /*-fx-vgap : 30px;*/
+    /*-fx-hgap : 30px;*/
+}
+
+.parameter.line.textfield {
+    -fx-alignement: center;
+}
+
+
+.view {
+    -fx-alignement: center;
+}
+
+.spinner {
+    -fx-font: 10px System;
+}
\ No newline at end of file
diff --git a/src/main/resources/fr.pasteur.ida.zellige.gui.view/theme2.css b/src/main/resources/fr.pasteur.ida.zellige.gui.view/theme2.css
new file mode 100644
index 0000000000000000000000000000000000000000..b768c11eddf671d70cc3e708dc910edc73f934d7
--- /dev/null
+++ b/src/main/resources/fr.pasteur.ida.zellige.gui.view/theme2.css
@@ -0,0 +1,152 @@
+
+.root {
+    -fx-base: #ececec;
+    -fx-color: -fx-base;
+    -fx-focus-color: #039E22;
+    -fx-inner-border: linear-gradient(to bottom,
+    ladder(
+            -fx-color,
+            derive(-fx-color, 30%) 0%,
+            derive(-fx-color, 20%) 40%,
+            derive(-fx-color, 25%) 60%,
+            derive(-fx-color, 55%) 80%,
+            derive(-fx-color, 55%) 90%,
+            derive(-fx-color, 75%) 100%
+    ),
+    ladder(
+            -fx-color,
+            derive(-fx-color, 20%) 0%,
+            derive(-fx-color, 10%) 20%,
+            derive(-fx-color, 5%) 40%,
+            derive(-fx-color, -2%) 60%,
+            derive(-fx-color, -5%) 100%
+    ));
+    -fx-body-color: linear-gradient(to bottom,
+    ladder(
+            -fx-color,
+            derive(-fx-color, 8%) 75%,
+            derive(-fx-color, 10%) 80%
+    ),
+    derive(-fx-color, -8%));
+
+}
+
+parameter-slider-integer.label {
+    -fx-text-fill: #252526;
+    -fx-font-size: 0.9em;
+    -fx-font-weight: normal;
+}
+
+/*******************************************************************************
+ *                                                                             *
+ * Label                                                                       *
+ *                                                                             *
+ ******************************************************************************/
+
+.label {
+    -fx-text-fill: #252526;
+    -fx-font-size: 0.9em;
+    -fx-font-weight: normal;
+}
+
+
+/*******************************************************************************
+ *                                                                             *
+ * Slider                                                                      *
+ *                                                                             *
+ ******************************************************************************/
+.slider .thumb:hover {
+    -fx-color: -fx-hover-base;
+}
+
+.slider .thumb:pressed {
+    -fx-color: -fx-pressed-base;
+}
+
+
+.slider .thumb {
+    -fx-background-color: linear-gradient(to bottom, derive(-fx-text-box-border, -20%), derive(-fx-text-box-border, -30%)),
+    -fx-inner-border,
+    -fx-body-color;
+    -fx-background-insets: 0, 1, 2;
+    -fx-background-radius: 1.0em; /* makes sure this remains circular */
+    -fx-padding: 0.583333em; /* 7 */
+    -fx-effect: dropshadow(two-pass-box, rgba(0, 0, 0, 0.1), 5, 0.0, 0, 2);
+}
+
+.slider:focused .thumb {
+    -fx-background-color: #515769, -fx-inner-border, -fx-body-color, #51576936, -fx-body-color;
+    -fx-background-insets: -0.2, 1, 2, -1.4, 2.6;
+    -fx-background-radius: 3, 2, 1, 4, 1;
+}
+
+.slider:focused .thumb {
+    -fx-background-radius: 1.0em; /* makes sure this remains circular */
+}
+
+.slider .track {
+    -fx-background-color: #484c54A3,
+    linear-gradient(to bottom, derive(-fx-text-box-border, -10%), -fx-text-box-border),
+    linear-gradient(to bottom,
+            derive(-fx-control-inner-background, -9%),
+            derive(-fx-control-inner-background, 0%),
+            derive(-fx-control-inner-background, -5%),
+            derive(-fx-control-inner-background, -12%)
+    );
+    -fx-background-insets: 0 0 -1 0, 0, 1;
+    -fx-background-radius: 0.25em, 0.25em, 0.166667em; /* 3 3 2 */
+    -fx-padding: 0.25em; /* 3 */
+}
+
+.axis {
+    AXIS_COLOR: derive(#0f1012, -20%);
+    -fx-tick-label-font-size: 0.7em; /* 10px */
+    -fx-tick-label-fill: #252526;
+}
+
+/*******************************************************************************
+ *                                                                             *
+ * TextField                                                                   *
+ *                                                                             *
+ ******************************************************************************/
+.text-field {
+    -fx-text-fill: #252526;
+    -fx-font-size: 0.8em;
+    -fx-font-weight: normal;
+}
+
+.text-input:error {
+    -fx-text-fill: black;
+    -fx-border-insets: 0;
+    -fx-border-width: 2px;
+    -fx-border-color: red;
+    -fx-border-style: hidden hidden solid hidden;
+    -fx-background-color: derive(red, 99%);
+}
+
+.text-input:focused {
+    -fx-highlight-fill: -fx-accent;
+    -fx-highlight-text-fill: white;
+    -fx-background-color: #515769,
+    -fx-control-inner-background,
+    #51576936,
+    linear-gradient(from 0px 0px to 0px 5px, derive(-fx-control-inner-background, -9%), -fx-control-inner-background);
+    -fx-background-insets: -0.2, 1, -1.4, 3;
+    -fx-background-radius: 3, 2, 4, 0;
+    -fx-prompt-text-fill: transparent;
+}
+
+
+.step.label {
+    -fx-font-family: Garamond;
+    /*-fx-font-style: oblique;*/
+    -fx-text-fill: #515769;
+    -fx-font-size: 1.2em;
+    -fx-font-weight: bold;
+    -fx-font-smoothing-type: lcd;
+}
+
+.step.vbox {
+    -fx-border-radius: 0.5em 2em 0.5em 0.5em;
+    -fx-border-color: lightgrey;
+}
\ No newline at end of file
diff --git a/src/main/resources/gui.properties b/src/main/resources/gui.properties
new file mode 100644
index 0000000000000000000000000000000000000000..d2b3367b8a90a1ae3c10a4c16844a623b5878333
--- /dev/null
+++ b/src/main/resources/gui.properties
@@ -0,0 +1,7 @@
+#[0-50]
+INTERVAL1=[0-9]|[1-4][0-9]|[5][0]
+#[0-10]
+INTERVAL2=[0-9]|[1][0]
+#[0.0 - 1.0]
+INTERVAL3=0?\\.[0-9]|[1]\\.[0]?|[0]|[1]
+#
\ No newline at end of file
diff --git a/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweep.java b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweep.java
index 87c077caf72a65615a059861de3902385350916a..71c61933cf38db75ca049e8ba97bfee8d1ab9b5a 100644
--- a/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweep.java
+++ b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweep.java
@@ -1,23 +1,29 @@
 package fr.pasteur.ida.zellige.behavior;
 
-import fr.pasteur.ida.zellige.utils.jzy3D.HM_GT_DifferenceDisplay;
 import fr.pasteur.ida.zellige.utils.test.*;
-import ij.ImageJ;
-import net.imglib2.RandomAccessibleInterval;
 import net.imglib2.img.Img;
-import net.imglib2.img.display.imagej.ImageJFunctions;
 import net.imglib2.type.NativeType;
 import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.integer.UnsignedShortType;
+import org.junit.Rule;
+import org.junit.internal.runners.statements.FailOnTimeout;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvFileSource;
 import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.rules.Timeout;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.concurrent.TimeoutException;
+
+import static fr.pasteur.ida.zellige.behavior.Utils.buildStringLine;
 
 //@Ignore
 public class ParameterSweep< T extends RealType< T > & NativeType< T >, R extends RealType< R > & NativeType< R > >
@@ -28,17 +34,57 @@ public class ParameterSweep< T extends RealType< T > & NativeType< T >, R extend
     static ArrayList< Img > ref;
     static Img tested;
     private final int delta = 0;
-    private double surfaceMinSizeFactor;
+    private double surfaceMinSizeFactor = 0.05;
+    private static final int MIN_TIMEOUT = 200;
+    public String[] errorLine =
+            new String[]{
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN",
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN" };
+
+    @AfterAll
+    static void closeBw() throws IOException
+    {
+        writer.close();
+    }
+
+    @Rule
+    public Timeout timeout = new Timeout( MIN_TIMEOUT )
+    {
+        public Statement apply( Statement base, Description description )
+        {
+            return new FailOnTimeout( base, MIN_TIMEOUT )
+            {
+                @Override
+                public void evaluate() throws Throwable
+                {
+                    try
+                    {
+                        super.evaluate();
+                        throw new TimeoutException();
+                    }
+                    catch ( Exception e )
+                    {
+                    }
+                }
+            };
+        }
+
+
+    };
 
     //    @Ignore
     @BeforeAll
     static void init() throws IOException
     {
-        String imagePath = "doc/Cochlée2.tif";
+        String imagePath = "doc/Mouche.tif";
         final String[] refImagePath = new String[]{
-                "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\files\\Atlas\\Ground truth Height map.tif",
+                "src/test/resources/Mouche/Ground truth Height map_1.tif",
+                "src/test/resources/Mouche/Ground truth Height map_2.tif",
+                "src/test/resources/Mouche/Ground truth Height map_3.tif",
+                "src/test/resources/Mouche/Ground truth Height map_4.tif"
+
         };
-        ParameterSweepFiles files = new ParameterSweepFiles( refImagePath, imagePath, "Atlas_selectionTime4" );
+        ParameterSweepFiles files = new ParameterSweepFiles( refImagePath, imagePath, "Timeout" );
         ref = files.getRefs();
         tested = files.getTested();
         writer = new CSVWriter( files.getPath() );
@@ -53,98 +99,115 @@ public class ParameterSweep< T extends RealType< T > & NativeType< T >, R extend
         RMSEAndCoverageComputation.setSubtract( - 1 );
     }
 
-    @AfterAll
-    static void closeBw() throws IOException
+    // The test times out and is skipped
+    public void givesTimeout() throws InterruptedException
     {
-        writer.close();
+        Thread.sleep( 1000 );
     }
 
     //    @Ignore
     @ParameterizedTest
-    @CsvFileSource( files = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\files\\Atlas\\Atlas_ParametersSweepSelectionPT.csv", numLinesToSkip = 0, delimiterString = ";" )
+    @CsvFileSource( files = "src/test/resources/Mouche/Mouche_ParameterSweep.csv", numLinesToSkip = 1, delimiterString = ";" )
     void parameterSweep( String testedParameter, String testedParameterValue, String filter, int filterParameter,
-                         double amplitudeThreshold, double otsuThreshold,
+                         int amplitudeThreshold, int otsuThreshold,
                          int ISConnexity, int ISSize,
                          double XYSmoothing, double ZSmoothing,
                          double startingThreshold1, int overlap1, double connexityRate1,
                          double startingThreshold2, int overlap2, double connexityRate2,
                          String optimalSet ) throws Exception
     {
-        LOGGER.info( "Parameter sweep " );
-        LOGGER.debug( " The parameter sweep is done for a total of {} ground truths", ref.size() );
-        ZParameters parameters = new ZParameters( filter, filterParameter,
-                amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
-                startingThreshold1, overlap1, connexityRate1,
-                startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
-
-        parameters.print();
-        ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse();
-        analyse.run( parameters, tested, ref );
-        for ( RMSEAndCoverageComputation r : analyse.getErrorList() )
+        try
         {
-            String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
-            writer.writeToFile( line );
-        }
-    }
+            ZParameters parameters = new ZParameters( filter, filterParameter,
+                    amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
+                    startingThreshold1, overlap1, connexityRate1,
+                    startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
 
-    public String[] buildStringLine( String testedParameter1, String testedParameterValue1,
-                                     String[] error, String optimalSet )
-    {
-        String[] line = new String[ 3 + error.length ];
-        line[ 0 ] = testedParameter1;
-        line[ 1 ] = testedParameterValue1;
-        int index = 2;
-        for ( String s : error )
+            parameters.print();
+            ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse<>();
+            analyse.run( parameters, tested, ref );
+            for ( RMSEAndCoverageComputation< T, UnsignedShortType > r : analyse.getErrorList() )
+            {
+                String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
+                writer.writeToFile( line );
+            }
+        }
+        catch ( Exception exception )
         {
-            line[ index ] = s;
-            index++;
+            for ( int i = 0; i < ref.size(); i++ )
+            {
+                writer.writeToFile( errorLine );
+            }
         }
-        line[ line.length - 1 ] = optimalSet;
-        return line;
     }
 
 
-    //    @Ignore
-    @ParameterizedTest
-    @CsvSource( value = "Amplitude;0.9;GaussianBlur;2;0.9;0.1;4;10;2;3;0.7;10;0.7;0.1;10;0.8;YES",
+    //    @Disabled( "Ignored" )
+    @Test
+    @CsvSource( value = "Amplitude;0;GaussianBlur;2;0;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO",
             delimiterString = ";" )
     void parameterSweepSingle( String testedParameter, String testedParameterValue, String filter, int filterParameter,
-                               double amplitudeThreshold, double otsuThreshold,
+                               int amplitudeThreshold, int otsuThreshold,
                                int ISConnexity, int ISSize,
                                double XYSmoothing, double ZSmoothing,
                                double startingThreshold1, int overlap1, double connexityRate1,
                                double startingThreshold2, int overlap2, double connexityRate2,
                                String optimalSet ) throws Exception
     {
-        ImageJ ij = new ImageJ();
-        LOGGER.info( "Parameter sweep " );
-        LOGGER.debug( " The parameter sweep is done for a total of {} ground truths", ref.size() );
-        ZParameters parameters = new ZParameters( filter, filterParameter,
-                amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
-                startingThreshold1, overlap1, connexityRate1,
-                startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
-
-        parameters.print();
-        ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse();
-        analyse.run( parameters, tested, ref );
-        for ( RMSEAndCoverageComputation r : analyse.getErrorList() )
-        {
-            String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
-            writer.writeToFile( line );
-        }
 
-        int index = 0;
-        for ( RandomAccessibleInterval rai : ref )
+        try
         {
-            HM_GT_DifferenceDisplay.displayDiff( ref.get( index ), analyse.getErrorList().get( index ).getProjection() );
-            ImageJFunctions.show( ref.get( index ), "GT" );
-            ImageJFunctions.show( analyse.getErrorList().get( index ).getProjection(), "HM" );
-            index++;
+            ZParameters parameters = new ZParameters( filter, filterParameter,
+                    amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
+                    startingThreshold1, overlap1, connexityRate1,
+                    startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
+
+            parameters.print();
+            ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse<>();
+            analyse.run( parameters, tested, ref );
+            for ( RMSEAndCoverageComputation< T, UnsignedShortType > r : analyse.getErrorList() )
+            {
+                String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
+                writer.writeToFile( line );
+            }
         }
-        while ( true )
+        catch ( InterruptedException exception )
         {
-
+            for ( int i = 0; i < ref.size(); i++ )
+            {
+                writer.writeToFile( errorLine );
+            }
         }
+
+//        ImageJ ij = new ImageJ();
+//        LOGGER.info( "Parameter sweep " );
+//        LOGGER.debug( " The parameter sweep is done for a total of {} ground truths", ref.size() );
+//        ZParameters parameters = new ZParameters( filter, filterParameter,
+//                amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
+//                startingThreshold1, overlap1, connexityRate1,
+//                startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
+//
+//        parameters.print();
+//        ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse();
+//        analyse.run( parameters, tested, ref );
+//        for ( RMSEAndCoverageComputation r : analyse.getErrorList() )
+//        {
+//            String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
+//            writer.writeToFile( line );
+//        }
+
+        int index = 0;
+//        for ( RandomAccessibleInterval rai : ref )
+//        {
+//            HM_GT_DifferenceDisplay.displayDiff( ref.get( index ), analyse.getErrorList().get( index ).getProjection() );
+//            ImageJFunctions.show( ref.get( index ), "GT" );
+//            ImageJFunctions.show( analyse.getErrorList().get( index ).getProjection(), "HM" );
+//            index++;
+//        }
+//        while ( true )
+//        {
+//
+//        }
     }
 
 }
diff --git a/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepCochlee2.java b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepCochlee2.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8f285c4be28a3a3a49cb1f37d7cc3e798d7ef8a
--- /dev/null
+++ b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepCochlee2.java
@@ -0,0 +1,112 @@
+package fr.pasteur.ida.zellige.behavior;
+
+import fr.pasteur.ida.zellige.utils.test.*;
+import net.imglib2.img.Img;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.integer.UnsignedShortType;
+import org.junit.Rule;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvFileSource;
+import org.junit.rules.Timeout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import static fr.pasteur.ida.zellige.behavior.Utils.buildStringLine;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+
+public class ParameterSweepCochlee2< T extends RealType< T > & NativeType< T >, R extends RealType< R > & NativeType< R > >
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( ParameterSweepCochlee2.class );
+    private static final String[] header = { "Parameter1", "Parameter1Value",
+            "GroundTruthNb", "SelectedPixelNb", "RMSE", "Coverage", "SelectionPT",
+            "AmplitudePT", "OtsuPT", "IslandSearchPT",
+            "ConstructionPT", "FS_OS_PT", "FS_surface_PT", "SS_OS_PT", "SS_surface_PT", "Total_PT",
+            "FS_OS_count", "FS_startingOS_count", "SS_OS_count", "SS_startingOS_count",
+            "FS_good", "FS_small", "FS_finalised",
+            "SS_good", "SS_small", "SS_finalised", "OptimizedSet" };
+    /* Specific Parameters */
+    private static final String sample = "Cochlée2";
+    private static final String imagePath = "doc/Cochlée2.tif";
+    private static final String[] refImagePath = new String[]{
+            "src/test/resources/Cochlée2/Ground truth Height map.tif"
+    };
+    static ArrayList< Img > ref;
+    static Img tested;
+    private static CSVWriter writer;
+    private final int delta = 0;
+    private final String parameterSweepCSVFile = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\Paper_012022\\ProcessingTime\\Cochlée2_PT.csv";
+    private final double surfaceMinSizeFactor = 0.8;
+    public String[] errorLine =
+            new String[]{
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN",
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN" };
+
+
+    @Rule
+    public Timeout globalTimeout = new Timeout( 10000, SECONDS );
+
+    @BeforeAll
+    static void init() throws IOException
+    {
+        ParameterSweepFiles files = new ParameterSweepFiles( refImagePath, imagePath, "PT_" + sample );
+        ref = files.getRefs();
+        tested = files.getTested();
+        writer = new CSVWriter( files.getPath() );
+        writer.writeToFile( header );
+        RMSEAndCoverageComputation.setSubtract( - 1 );
+        LOGGER.info( "Parameter sweep for the {} sample", sample );
+        LOGGER.debug( " The parameter sweep is done for a total of {} ground truths", ref.size() );
+    }
+
+    @AfterAll
+    static void closeBw() throws IOException
+    {
+        writer.close();
+    }
+
+
+    @ParameterizedTest
+    @CsvFileSource( files = parameterSweepCSVFile, numLinesToSkip = 1, delimiterString = ";" )
+    void parameterSweep( String testedParameter, String testedParameterValue, String filter, int filterParameter,
+                         int amplitudeThreshold, int otsuThreshold,
+                         int ISConnexity, int ISSize,
+                         double XYSmoothing, double ZSmoothing,
+                         double startingThreshold1, int overlap1, double connexityRate1,
+                         double startingThreshold2, int overlap2, double connexityRate2,
+                         String optimalSet ) throws Exception
+    {
+        try
+        {
+            ZParameters parameters = new ZParameters( filter, filterParameter,
+                    amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
+                    startingThreshold1, overlap1, connexityRate1,
+                    startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
+
+            parameters.print();
+            ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse<>();
+            analyse.run( parameters, tested, ref );
+            for ( RMSEAndCoverageComputation< T, UnsignedShortType > r : analyse.getErrorList() )
+            {
+                String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
+                writer.writeToFile( line );
+            }
+        }
+        catch ( OutOfMemoryError error )
+        {
+            for ( int i = 0; i < ref.size(); i++ )
+            {
+                writer.writeToFile( errorLine );
+            }
+        }
+    }
+
+
+}
diff --git a/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepCulture.java b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepCulture.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc6c8b1189a3b834e955232da8b02d053bb1e1a9
--- /dev/null
+++ b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepCulture.java
@@ -0,0 +1,105 @@
+package fr.pasteur.ida.zellige.behavior;
+
+import fr.pasteur.ida.zellige.utils.test.*;
+import net.imglib2.img.Img;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.integer.UnsignedShortType;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvFileSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import static fr.pasteur.ida.zellige.behavior.Utils.buildStringLine;
+
+
+public class ParameterSweepCulture< T extends RealType< T > & NativeType< T >, R extends RealType< R > & NativeType< R > >
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( ParameterSweepCulture.class );
+    private static final String[] header = { "Parameter1", "Parameter1Value",
+            "GroundTruthNb", "SelectedPixelNb", "RMSE", "Coverage", "SelectionPT",
+            "AmplitudePT", "OtsuPT", "IslandSearchPT",
+            "ConstructionPT", "FS_OS_PT", "FS_surface_PT", "SS_OS_PT", "SS_surface_PT", "Total_PT",
+            "FS_OS_count", "FS_startingOS_count", "SS_OS_count", "SS_startingOS_count",
+            "FS_good", "FS_small", "FS_finalised",
+            "SS_good", "SS_small", "SS_finalised", "OptimizedSet" };
+    /* Specific Parameters */
+    private static final String sample = "Culture";
+    private static final String imagePath = "doc/Culture.tif";
+    private static final String[] refImagePath = new String[]{
+            "src/test/resources/Culture/C2-MucilairB spike zo1 J4 Sars-3_Ground truth Height map.tif"
+    };
+    static ArrayList< Img > ref;
+    static Img tested;
+    private static CSVWriter writer;
+    private final int delta = 0;
+    private final String parameterSweepCSVFile = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\Paper_012022\\ProcessingTime\\Cuture_PT.csv";
+    private final double surfaceMinSizeFactor = 0.3;
+    public String[] errorLine =
+            new String[]{
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN",
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN" };
+
+    //    @Ignore
+    @BeforeAll
+    static void init() throws IOException
+    {
+        ParameterSweepFiles files = new ParameterSweepFiles( refImagePath, imagePath, "PT_" + sample );
+        ref = files.getRefs();
+        tested = files.getTested();
+        writer = new CSVWriter( files.getPath() );
+        writer.writeToFile( header );
+        RMSEAndCoverageComputation.setSubtract( - 1 );
+        LOGGER.info( "Parameter sweep for the {} sample", sample );
+        LOGGER.debug( " The parameter sweep is done for a total of {} ground truths", ref.size() );
+    }
+
+    @AfterAll
+    static void closeBw() throws IOException
+    {
+        writer.close();
+    }
+
+    @ParameterizedTest
+    @CsvFileSource( files = parameterSweepCSVFile, numLinesToSkip = 1, delimiterString = ";" )
+    void parameterSweep( String testedParameter, String testedParameterValue, String filter, int filterParameter,
+                         int amplitudeThreshold, int otsuThreshold,
+                         int ISConnexity, int ISSize,
+                         double XYSmoothing, double ZSmoothing,
+                         double startingThreshold1, int overlap1, double connexityRate1,
+                         double startingThreshold2, int overlap2, double connexityRate2,
+                         String optimalSet ) throws Exception
+    {
+        try
+        {
+            ZParameters parameters = new ZParameters( filter, filterParameter,
+                    amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
+                    startingThreshold1, overlap1, connexityRate1,
+                    startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
+
+            parameters.print();
+            ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse<>();
+            analyse.run( parameters, tested, ref );
+            for ( RMSEAndCoverageComputation< T, UnsignedShortType > r : analyse.getErrorList() )
+            {
+                String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
+                writer.writeToFile( line );
+            }
+        }
+        catch ( OutOfMemoryError error )
+        {
+            for ( int i = 0; i < ref.size(); i++ )
+            {
+                writer.writeToFile( errorLine );
+            }
+        }
+    }
+
+
+}
diff --git a/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepMouche.java b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepMouche.java
new file mode 100644
index 0000000000000000000000000000000000000000..555e356f8403de4b664fb718790689d83a861931
--- /dev/null
+++ b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepMouche.java
@@ -0,0 +1,110 @@
+package fr.pasteur.ida.zellige.behavior;
+
+import fr.pasteur.ida.zellige.utils.test.*;
+import net.imglib2.img.Img;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.integer.UnsignedShortType;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvFileSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import static fr.pasteur.ida.zellige.behavior.Utils.buildStringLine;
+
+
+public class ParameterSweepMouche< T extends RealType< T > & NativeType< T >, R extends RealType< R > & NativeType< R > >
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( ParameterSweepMouche.class );
+    private static final String[] header = { "Parameter1", "Parameter1Value",
+            "GroundTruthNb", "SelectedPixelNb", "RMSE", "Coverage", "SelectionPT",
+            "AmplitudePT", "OtsuPT", "IslandSearchPT",
+            "ConstructionPT", "FS_OS_PT", "FS_surface_PT", "SS_OS_PT", "SS_surface_PT", "Total_PT",
+            "FS_OS_count", "FS_startingOS_count", "SS_OS_count", "SS_startingOS_count",
+            "FS_good", "FS_small", "FS_finalised",
+            "SS_good", "SS_small", "SS_finalised", "OptimizedSet" };
+    public String[] errorLine =
+            new String[]{
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN",
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN" };
+    /* Specific Parameters */
+    private static final String sample = "Mouche";
+    private static final String imagePath = "doc/Mouche.tif";
+    private static final String[] refImagePath = new String[]{
+            "src/test/resources/Mouche/Ground truth Height map_1.tif",
+            "src/test/resources/Mouche/Ground truth Height map_2.tif",
+            "src/test/resources/Mouche/Ground truth Height map_3_crop.tif",
+            "src/test/resources/Mouche/Ground truth Height map_4_crop.tif"
+
+    };
+    static ArrayList< Img > ref;
+    static Img tested;
+    private static CSVWriter writer;
+    private final int delta = 0;
+    private final String parameterSweepCSVFile = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\Paper_012022\\ProcessingTime\\Mouche_PT.csv";
+    private final double surfaceMinSizeFactor = 0.05;
+
+    //    @Ignore
+    @BeforeAll
+    static void init() throws IOException
+    {
+        ParameterSweepFiles files = new ParameterSweepFiles( refImagePath, imagePath, "PT_" + sample );
+        ref = files.getRefs();
+        tested = files.getTested();
+        writer = new CSVWriter( files.getPath() );
+        writer.writeToFile( header );
+        RMSEAndCoverageComputation.setSubtract( - 1 );
+        LOGGER.info( "Parameter sweep for the {} sample", sample );
+        LOGGER.debug( " The parameter sweep is done for a total of {} ground truths", ref.size() );
+    }
+
+    @AfterAll
+    static void closeBw() throws IOException
+    {
+        writer.close();
+    }
+
+    @ParameterizedTest
+    @CsvFileSource( files = parameterSweepCSVFile, numLinesToSkip = 1, delimiterString = ";" )
+    void parameterSweep( String testedParameter, String testedParameterValue, String filter, int filterParameter,
+                         int amplitudeThreshold, int otsuThreshold,
+                         int ISConnexity, int ISSize,
+                         double XYSmoothing, double ZSmoothing,
+                         double startingThreshold1, int overlap1, double connexityRate1,
+                         double startingThreshold2, int overlap2, double connexityRate2,
+                         String optimalSet ) throws Exception
+    {
+
+        try
+        {
+            ZParameters parameters = new ZParameters( filter, filterParameter,
+                    amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
+                    startingThreshold1, overlap1, connexityRate1,
+                    startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
+
+            parameters.print();
+            ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse<>();
+            analyse.run( parameters, tested, ref );
+            for ( RMSEAndCoverageComputation< T, UnsignedShortType > r : analyse.getErrorList() )
+            {
+                String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
+                writer.writeToFile( line );
+            }
+        }
+        catch ( Exception exception )
+        {
+            for ( int i = 0; i < ref.size(); i++ )
+            {
+                writer.writeToFile( errorLine );
+            }
+        }
+    }
+
+
+}
diff --git a/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepOrganoid.java b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepOrganoid.java
new file mode 100644
index 0000000000000000000000000000000000000000..723c6d144b940b2f32268cd9c037c28edadb23db
--- /dev/null
+++ b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepOrganoid.java
@@ -0,0 +1,107 @@
+package fr.pasteur.ida.zellige.behavior;
+
+import fr.pasteur.ida.zellige.utils.test.*;
+import net.imglib2.img.Img;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.integer.UnsignedShortType;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvFileSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import static fr.pasteur.ida.zellige.behavior.Utils.buildStringLine;
+
+
+public class ParameterSweepOrganoid< T extends RealType< T > & NativeType< T >, R extends RealType< R > & NativeType< R > >
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( ParameterSweepOrganoid.class );
+    private static final String[] header = { "Parameter1", "Parameter1Value",
+            "GroundTruthNb", "SelectedPixelNb", "RMSE", "Coverage", "SelectionPT",
+            "AmplitudePT", "OtsuPT", "IslandSearchPT",
+            "ConstructionPT", "FS_OS_PT", "FS_surface_PT", "SS_OS_PT", "SS_surface_PT", "Total_PT",
+            "FS_OS_count", "FS_startingOS_count", "SS_OS_count", "SS_startingOS_count",
+            "FS_good", "FS_small", "FS_finalised",
+            "SS_good", "SS_small", "SS_finalised", "OptimizedSet" };
+    public String[] errorLine =
+            new String[]{
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN",
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN" };
+    /* Specific Parameters */
+    private static final String sample = "Organoid";
+    private static final String imagePath = "doc/Organoid.tif";
+    private static final String[] refImagePath = new String[]{
+            "src/test/resources/Organoid/HM1.tif",
+            "src/test/resources/Organoid/HM2.tif"
+    };
+    static ArrayList< Img > ref;
+    static Img tested;
+    private static CSVWriter writer;
+    private final int delta = 0;
+    private final String parameterSweepCSVFile = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\Paper_012022\\ProcessingTime\\Organoid_PT.csv";
+    private final double surfaceMinSizeFactor = 0.1;
+
+    //    @Ignore
+    @BeforeAll
+    static void init() throws IOException
+    {
+        ParameterSweepFiles files = new ParameterSweepFiles( refImagePath, imagePath, "PT_" + sample );
+        ref = files.getRefs();
+        tested = files.getTested();
+        writer = new CSVWriter( files.getPath() );
+        writer.writeToFile( header );
+        RMSEAndCoverageComputation.setSubtract( - 1 );
+        LOGGER.info( "Parameter sweep for the {} sample", sample );
+        LOGGER.debug( " The parameter sweep is done for a total of {} ground truths", ref.size() );
+    }
+
+    @AfterAll
+    static void closeBw() throws IOException
+    {
+        writer.close();
+    }
+
+    @ParameterizedTest
+    @CsvFileSource( files = parameterSweepCSVFile, numLinesToSkip = 1, delimiterString = ";" )
+    void parameterSweep( String testedParameter, String testedParameterValue, String filter, int filterParameter,
+                         int amplitudeThreshold, int otsuThreshold,
+                         int ISConnexity, int ISSize,
+                         double XYSmoothing, double ZSmoothing,
+                         double startingThreshold1, int overlap1, double connexityRate1,
+                         double startingThreshold2, int overlap2, double connexityRate2,
+                         String optimalSet ) throws Exception
+    {
+
+        try
+        {
+            ZParameters parameters = new ZParameters( filter, filterParameter,
+                    amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
+                    startingThreshold1, overlap1, connexityRate1,
+                    startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
+
+            parameters.print();
+            ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse<>();
+            analyse.run( parameters, tested, ref );
+            for ( RMSEAndCoverageComputation< T, UnsignedShortType > r : analyse.getErrorList() )
+            {
+                String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
+                writer.writeToFile( line );
+            }
+        }
+        catch ( Exception exception )
+        {
+            for ( int i = 0; i < ref.size(); i++ )
+            {
+                writer.writeToFile( errorLine );
+            }
+        }
+    }
+
+
+}
diff --git a/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepPhantom.java b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepPhantom.java
new file mode 100644
index 0000000000000000000000000000000000000000..019eb98df43d9a8e2141d8bae7ad060652681479
--- /dev/null
+++ b/src/test/java/fr/pasteur/ida/zellige/behavior/ParameterSweepPhantom.java
@@ -0,0 +1,108 @@
+package fr.pasteur.ida.zellige.behavior;
+
+import fr.pasteur.ida.zellige.utils.test.*;
+import net.imglib2.img.Img;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.integer.UnsignedShortType;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvFileSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import static fr.pasteur.ida.zellige.behavior.Utils.buildStringLine;
+
+
+public class ParameterSweepPhantom< T extends RealType< T > & NativeType< T >, R extends RealType< R > & NativeType< R > >
+{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger( ParameterSweepPhantom.class );
+    private static final String[] header = { "Parameter1", "Parameter1Value",
+            "GroundTruthNb", "SelectedPixelNb", "RMSE", "Coverage", "SelectionPT",
+            "AmplitudePT", "OtsuPT", "IslandSearchPT",
+            "ConstructionPT", "FS_OS_PT", "FS_surface_PT", "SS_OS_PT", "SS_surface_PT", "Total_PT",
+            "FS_OS_count", "FS_startingOS_count", "SS_OS_count", "SS_startingOS_count",
+            "FS_good", "FS_small", "FS_finalised",
+            "SS_good", "SS_small", "SS_finalised", "OptimizedSet" };
+    public String[] errorLine =
+            new String[]{
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN",
+                    "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN", "NaN" };
+    /* Specific Parameters */
+    private static final String sample = "Phantom";
+    private static final String imagePath = "doc/Phantom.tif";
+    private static final String[] refImagePath = new String[]{
+            "src/test/resources/Phantom/phantoms_snrtest_zmap1_gt.tif",
+            "src/test/resources/Phantom/phantoms_snrtest_zmap2_gt.tif",
+            "src/test/resources/Phantom/phantoms_snrtest_zmap3_gt.tif"
+    };
+    static ArrayList< Img > ref;
+    static Img tested;
+    private static CSVWriter writer;
+    private final int delta = 0;
+    private final String parameterSweepCSVFile = "C:\\Users\\ctrebeau\\Desktop\\Zellige analysis\\Paper_012022\\ProcessingTime\\Phantom_PT.csv";
+    private final double surfaceMinSizeFactor = 0.8;
+
+    //    @Ignore
+    @BeforeAll
+    static void init() throws IOException
+    {
+        ParameterSweepFiles files = new ParameterSweepFiles( refImagePath, imagePath, "PT_" + sample );
+        ref = files.getRefs();
+        tested = files.getTested();
+        writer = new CSVWriter( files.getPath() );
+        writer.writeToFile( header );
+        RMSEAndCoverageComputation.setSubtract( 0 );
+        LOGGER.info( "Parameter sweep for the {} sample", sample );
+        LOGGER.debug( " The parameter sweep is done for a total of {} ground truths", ref.size() );
+    }
+
+    @AfterAll
+    static void closeBw() throws IOException
+    {
+        writer.close();
+    }
+
+    @ParameterizedTest
+    @CsvFileSource( files = parameterSweepCSVFile, numLinesToSkip = 1, delimiterString = ";" )
+    void parameterSweep( String testedParameter, String testedParameterValue, String filter, int filterParameter,
+                         int amplitudeThreshold, int otsuThreshold,
+                         int ISConnexity, int ISSize,
+                         double XYSmoothing, double ZSmoothing,
+                         double startingThreshold1, int overlap1, double connexityRate1,
+                         double startingThreshold2, int overlap2, double connexityRate2,
+                         String optimalSet ) throws Exception
+    {
+
+        try
+        {
+            ZParameters parameters = new ZParameters( filter, filterParameter,
+                    amplitudeThreshold, otsuThreshold, ISConnexity, ISSize, XYSmoothing, ZSmoothing,
+                    startingThreshold1, overlap1, connexityRate1,
+                    startingThreshold2, overlap2, connexityRate2, surfaceMinSizeFactor, delta );
+
+            parameters.print();
+            ZelligePipelineAnalyse< T, R > analyse = new ZelligePipelineAnalyse<>();
+            analyse.run( parameters, tested, ref );
+            for ( RMSEAndCoverageComputation< T, UnsignedShortType > r : analyse.getErrorList() )
+            {
+                String[] line = buildStringLine( testedParameter, testedParameterValue, analyse.getErrorAnalysis( r ), optimalSet );
+                writer.writeToFile( line );
+            }
+        }
+        catch ( Exception exception )
+        {
+            for ( int i = 0; i < ref.size(); i++ )
+            {
+                writer.writeToFile( errorLine );
+            }
+        }
+    }
+
+
+}
diff --git a/src/test/java/fr/pasteur/ida/zellige/behavior/StartingOSE_SameSurfaceTest.java b/src/test/java/fr/pasteur/ida/zellige/behavior/StartingOSE_SameSurfaceTest.java
index bd17aaa75d598d2cb5c574d1e0790c545d4cb93d..587095c7957aed4ca0582a060cff940d72e2e798 100644
--- a/src/test/java/fr/pasteur/ida/zellige/behavior/StartingOSE_SameSurfaceTest.java
+++ b/src/test/java/fr/pasteur/ida/zellige/behavior/StartingOSE_SameSurfaceTest.java
@@ -37,8 +37,8 @@ public class StartingOSE_SameSurfaceTest
    < T extends RealType< T > & NativeType< T > > void  TwoStartingOSEFromTheSameSurface_whenUseForStartASurface_DonTProduceTheExactSameSurface() throws DataValidationException, EmptyOutputException, NoClassificationException
     {
         /* Parameters*/
-        double amplitude = 0.2;
-        double otsu = 0.2;
+        int amplitude = 5;
+        int otsu = 5;
         double sigmaXY = 2;
         double sigmaZ = 0;
         double startingSizeThreshold = 0.9;
diff --git a/src/test/java/fr/pasteur/ida/zellige/behavior/Utils.java b/src/test/java/fr/pasteur/ida/zellige/behavior/Utils.java
new file mode 100644
index 0000000000000000000000000000000000000000..458ccc8533e9cafed1b4a9be78a004fa951c61d3
--- /dev/null
+++ b/src/test/java/fr/pasteur/ida/zellige/behavior/Utils.java
@@ -0,0 +1,21 @@
+package fr.pasteur.ida.zellige.behavior;
+
+public class Utils
+{
+
+    public static String[] buildStringLine( String testedParameter1, String testedParameterValue1,
+                                            String[] error, String optimalSet )
+    {
+        String[] line = new String[ 3 + error.length ];
+        line[ 0 ] = testedParameter1;
+        line[ 1 ] = testedParameterValue1;
+        int index = 2;
+        for ( String s : error )
+        {
+            line[ index ] = s;
+            index++;
+        }
+        line[ line.length - 1 ] = optimalSet;
+        return line;
+    }
+}
diff --git a/src/test/java/fr/pasteur/ida/zellige/parameters/ClassificationParametersTest.java b/src/test/java/fr/pasteur/ida/zellige/parameters/ClassificationParametersTest.java
index 99db282925d1983a432804d8727cbb3c83355966..0029d1df97a487e3c726c5f07a2d5c44f46045f5 100644
--- a/src/test/java/fr/pasteur/ida/zellige/parameters/ClassificationParametersTest.java
+++ b/src/test/java/fr/pasteur/ida/zellige/parameters/ClassificationParametersTest.java
@@ -15,8 +15,8 @@ public class ClassificationParametersTest
     @Test
     void rightPixelClassificationParameters_whenCreatingANewInstance_DonTRaiseAValidationDataException()
     {
-        double amplitudeThreshold = 1.0;
-        double otsuThreshold = 1.5;
+        int amplitudeThreshold = 5;
+        int otsuThreshold = 5;
         assertDoesNotThrow( () -> new ClassificationParameters( amplitudeThreshold, otsuThreshold ) );
     }
 
@@ -25,22 +25,22 @@ public class ClassificationParametersTest
     @Test
     void amplitudeThresholdUnderZero_WhenCreatingANewInstance_raisesAValidationDataException()
     {
-        double amplitudeThreshold = -1;
-        double otsuThreshold = 1.5;
+        int amplitudeThreshold = - 1;
+        int otsuThreshold = 2;
         DataValidationException exception = assertThrows( DataValidationException.class, () ->
                 new ClassificationParameters( amplitudeThreshold, otsuThreshold ) );
-        assertThat(exception).hasMessageContaining( "Amplitude" );
+        assertThat( exception ).hasMessageContaining( "Amplitude" );
     }
 
     @DisplayName( " An otsu threshold inferior to zero raises a ValidationDataException with a specific message " )
     @Test
     void otsuThresholdUnderZero_WhenCreatingANewInstance_raisesAValidationDataException()
     {
-        double amplitudeThreshold = 1;
-        double otsuThreshold = - 1;
+        int amplitudeThreshold = 1;
+        int otsuThreshold = - 1;
         DataValidationException exception = assertThrows( DataValidationException.class, () ->
                 new ClassificationParameters( amplitudeThreshold, otsuThreshold ) );
-        assertThat(exception).hasMessageContaining( "Otsu" );
+        assertThat( exception ).hasMessageContaining( "Otsu" );
     }
 
 
diff --git "a/src/test/resources/Cochl\303\251e2/Ground truth Height map.tif" "b/src/test/resources/Cochl\303\251e2/Ground truth Height map.tif"
new file mode 100644
index 0000000000000000000000000000000000000000..cbe88c0b0988f206ee3d043036f58e377016066d
Binary files /dev/null and "b/src/test/resources/Cochl\303\251e2/Ground truth Height map.tif" differ
diff --git "a/src/test/resources/Cochl\303\251e2/PS_Cochl\303\251e2.csv" "b/src/test/resources/Cochl\303\251e2/PS_Cochl\303\251e2.csv"
new file mode 100644
index 0000000000000000000000000000000000000000..7a2e083dbf7fdcd3d9b79ae0a26123e9bbab6528
--- /dev/null
+++ "b/src/test/resources/Cochl\303\251e2/PS_Cochl\303\251e2.csv"
@@ -0,0 +1,163 @@
+Cochlee2;;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;
+Amplitude;0;GaussianBlur;2;0;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;1;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+Amplitude;2;GaussianBlur;2;2;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;3;GaussianBlur;2;3;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;4;GaussianBlur;2;4;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;5;GaussianBlur;2;5;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;6;GaussianBlur;2;6;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;7;GaussianBlur;2;7;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;8;GaussianBlur;2;8;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;9;GaussianBlur;2;9;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;10;GaussianBlur;2;10;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;11;GaussianBlur;2;11;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;12;GaussianBlur;2;12;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;13;GaussianBlur;2;13;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;14;GaussianBlur;2;14;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;15;GaussianBlur;2;15;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;16;GaussianBlur;2;16;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;17;GaussianBlur;2;17;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;18;GaussianBlur;2;18;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;19;GaussianBlur;2;19;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;20;GaussianBlur;2;20;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;21;GaussianBlur;2;21;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;22;GaussianBlur;2;22;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;23;GaussianBlur;2;23;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;24;GaussianBlur;2;24;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;25;GaussianBlur;2;25;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;26;GaussianBlur;2;26;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;27;GaussianBlur;2;27;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;28;GaussianBlur;2;28;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;29;GaussianBlur;2;29;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Amplitude;30;GaussianBlur;2;30;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;0;GaussianBlur;2;1;0;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;1;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+Otsu;2;GaussianBlur;2;1;2;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;3;GaussianBlur;2;1;3;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;4;GaussianBlur;2;1;4;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;5;GaussianBlur;2;1;5;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;6;GaussianBlur;2;1;6;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;7;GaussianBlur;2;1;7;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;8;GaussianBlur;2;1;8;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;9;GaussianBlur;2;1;9;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;10;GaussianBlur;2;1;10;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;11;GaussianBlur;2;1;11;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;12;GaussianBlur;2;1;12;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;13;GaussianBlur;2;1;13;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;14;GaussianBlur;2;1;14;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;15;GaussianBlur;2;1;15;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;16;GaussianBlur;2;1;16;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;17;GaussianBlur;2;1;17;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;18;GaussianBlur;2;1;18;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;19;GaussianBlur;2;1;19;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;20;GaussianBlur;2;1;20;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;21;GaussianBlur;2;1;21;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;22;GaussianBlur;2;1;22;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;23;GaussianBlur;2;1;23;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;24;GaussianBlur;2;1;24;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;25;GaussianBlur;2;1;25;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;26;GaussianBlur;2;1;26;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;27;GaussianBlur;2;1;27;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;28;GaussianBlur;2;1;28;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;29;GaussianBlur;2;1;29;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Otsu;30;GaussianBlur;2;1;30;4;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Connexity;4;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+IS Connexity;8;GaussianBlur;2;1;1;8;5;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;0;GaussianBlur;2;1;1;4;0;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;5;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+IS Min Size;10;GaussianBlur;2;1;1;4;10;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;15;GaussianBlur;2;1;1;4;15;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;20;GaussianBlur;2;1;1;4;20;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;25;GaussianBlur;2;1;1;4;25;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;30;GaussianBlur;2;1;1;4;30;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;35;GaussianBlur;2;1;1;4;35;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;40;GaussianBlur;2;1;1;4;40;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;45;GaussianBlur;2;1;1;4;45;4;1;0.1;5;0.7;0.1;10;0.8;NO
+IS Min Size;50;GaussianBlur;2;1;1;4;50;4;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;0;GaussianBlur;2;1;1;4;5;0;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;1;GaussianBlur;2;1;1;4;5;1;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;2;GaussianBlur;2;1;1;4;5;2;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;3;GaussianBlur;2;1;1;4;5;3;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;4;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+Blur XY;5;GaussianBlur;2;1;1;4;5;5;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;6;GaussianBlur;2;1;1;4;5;6;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;7;GaussianBlur;2;1;1;4;5;7;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;8;GaussianBlur;2;1;1;4;5;8;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;9;GaussianBlur;2;1;1;4;5;9;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur XY;10;GaussianBlur;2;1;1;4;5;10;1;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;0;GaussianBlur;2;1;1;4;5;4;0;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;1;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+Blur Z;2;GaussianBlur;2;1;1;4;5;4;2;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;3;GaussianBlur;2;1;1;4;5;4;3;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;4;GaussianBlur;2;1;1;4;5;4;4;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;5;GaussianBlur;2;1;1;4;5;4;5;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;6;GaussianBlur;2;1;1;4;5;4;6;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;7;GaussianBlur;2;1;1;4;5;4;7;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;8;GaussianBlur;2;1;1;4;5;4;8;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;9;GaussianBlur;2;1;1;4;5;4;9;0.1;5;0.7;0.1;10;0.8;NO
+Blur Z;10;GaussianBlur;2;1;1;4;5;4;10;0.1;5;0.7;0.1;10;0.8;NO
+ST_1;0.0;GaussianBlur;2;1;1;4;5;4;1;0.0;5;0.7;0.1;10;0.8;NO
+ST_1;0.1;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+ST_1;0.2;GaussianBlur;2;1;1;4;5;4;1;0.2;5;0.7;0.1;10;0.8;NO
+ST_1;0.3;GaussianBlur;2;1;1;4;5;4;1;0.3;5;0.7;0.1;10;0.8;NO
+ST_1;0.4;GaussianBlur;2;1;1;4;5;4;1;0.4;5;0.7;0.1;10;0.8;NO
+ST_1;0.5;GaussianBlur;2;1;1;4;5;4;1;0.5;5;0.7;0.1;10;0.8;NO
+ST_1;0.6;GaussianBlur;2;1;1;4;5;4;1;0.6;5;0.7;0.1;10;0.8;NO
+ST_1;0.7;GaussianBlur;2;1;1;4;5;4;1;0.7;5;0.7;0.1;10;0.8;NO
+ST_1;0.8;GaussianBlur;2;1;1;4;5;4;1;0.8;5;0.7;0.1;10;0.8;NO
+Overlap_1;0;GaussianBlur;2;1;1;4;5;4;1;0.1;0;0.7;0.1;10;0.8;NO
+Overlap_1;5;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+Overlap_1;10;GaussianBlur;2;1;1;4;5;4;1;0.1;10;0.7;0.1;10;0.8;NO
+Overlap_1;15;GaussianBlur;2;1;1;4;5;4;1;0.1;15;0.7;0.1;10;0.8;NO
+Overlap_1;17;GaussianBlur;2;1;1;4;5;4;1;0.1;17;0.7;0.1;10;0.8;NO
+Overlap_1;20;GaussianBlur;2;1;1;4;5;4;1;0.1;20;0.7;0.1;10;0.8;NO
+Overlap_1;25;GaussianBlur;2;1;1;4;5;4;1;0.1;25;0.7;0.1;10;0.8;NO
+Overlap_1;30;GaussianBlur;2;1;1;4;5;4;1;0.1;30;0.7;0.1;10;0.8;NO
+Overlap_1;35;GaussianBlur;2;1;1;4;5;4;1;0.1;35;0.7;0.1;10;0.8;NO
+Overlap_1;40;GaussianBlur;2;1;1;4;5;4;1;0.1;40;0.7;0.1;10;0.8;NO
+Overlap_1;45;GaussianBlur;2;1;1;4;5;4;1;0.1;45;0.7;0.1;10;0.8;NO
+Overlap_1;50;GaussianBlur;2;1;1;4;5;4;1;0.1;50;0.7;0.1;10;0.8;NO
+CR_1;0.5;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.5;0.1;10;0.8;NO
+CR_1;0.55;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.55;0.1;10;0.8;NO
+CR_1;0.6;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.6;0.1;10;0.8;NO
+CR_1;0.65;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.65;0.1;10;0.8;NO
+CR_1;0.7;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+CR_1;0.75;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.75;0.1;10;0.8;NO
+CR_1;0.8;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.8;0.1;10;0.8;NO
+CR_1;0.85;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.85;0.1;10;0.8;NO
+CR_1;0.9;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.9;0.1;10;0.8;NO
+CR_1;0.95;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.95;0.1;10;0.8;NO
+CR_1;1;GaussianBlur;2;1;1;4;5;4;1;0.1;5;1;0.1;10;0.8;NO
+ST_2;0.0;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.0;10;0.8;NO
+ST_2;0.1;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+ST_2;0.2;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.2;10;0.8;NO
+ST_2;0.3;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.3;10;0.8;NO
+ST_2;0.4;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.4;10;0.8;NO
+ST_2;0.5;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.5;10;0.8;NO
+ST_2;0.6;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.6;10;0.8;NO
+ST_2;0.7;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.7;10;0.8;NO
+ST_2;0.8;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.8;10;0.8;NO
+ST_2;0.9;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.9;10;0.8;NO
+ST_2;1.0;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;1.0;10;0.8;NO
+Overlap_2;0;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;0;0.8;NO
+Overlap_2;5;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;5;0.8;NO
+Overlap_2;10;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+Overlap_2;15;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;15;0.8;NO
+Overlap_2;20;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;20;0.8;NO
+Overlap_2;25;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;25;0.8;NO
+Overlap_2;30;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;30;0.8;NO
+Overlap_2;35;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;35;0.8;NO
+Overlap_2;40;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;40;0.8;NO
+Overlap_2;45;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;45;0.8;NO
+Overlap_2;50;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;50;0.8;NO
+CR_2;0.5;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.5;NO
+CR_2;0.55;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.55;NO
+CR_2;0.6;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.6;NO
+CR_2;0.65;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.65;NO
+CR_2;0.7;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.7;NO
+CR_2;0.75;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.75;NO
+CR_2;0.8;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.8;YES
+CR_2;0.85;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.85;NO
+CR_2;0.9;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.9;NO
+CR_2;0.95;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;0.95;NO
+CR_2;1;GaussianBlur;2;1;1;4;5;4;1;0.1;5;0.7;0.1;10;1;NO
diff --git a/src/test/resources/Culture/C2-MucilairB spike zo1 J4 Sars-3_Ground truth Height map.tif b/src/test/resources/Culture/C2-MucilairB spike zo1 J4 Sars-3_Ground truth Height map.tif
new file mode 100644
index 0000000000000000000000000000000000000000..05ab8be7dc6ed804ebfb35e6992e27888b2afc77
Binary files /dev/null and b/src/test/resources/Culture/C2-MucilairB spike zo1 J4 Sars-3_Ground truth Height map.tif differ
diff --git a/src/test/resources/Culture/PS_Culture.csv b/src/test/resources/Culture/PS_Culture.csv
new file mode 100644
index 0000000000000000000000000000000000000000..5c17726415525c51009dcffab80646a50f7e1344
--- /dev/null
+++ b/src/test/resources/Culture/PS_Culture.csv
@@ -0,0 +1,165 @@
+Culture;;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;
+Amplitude;0;GaussianBlur;2;0;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;1;GaussianBlur;2;1;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;2;GaussianBlur;2;2;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;3;GaussianBlur;2;3;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;4;GaussianBlur;2;4;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;5;GaussianBlur;2;5;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;6;GaussianBlur;2;6;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;7;GaussianBlur;2;7;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;8;GaussianBlur;2;8;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;9;GaussianBlur;2;9;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;10;GaussianBlur;2;10;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;11;GaussianBlur;2;11;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;12;GaussianBlur;2;12;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;13;GaussianBlur;2;13;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;14;GaussianBlur;2;14;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;15;GaussianBlur;2;15;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;16;GaussianBlur;2;16;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;17;GaussianBlur;2;17;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;18;GaussianBlur;2;18;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;19;GaussianBlur;2;19;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;20;GaussianBlur;2;20;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;21;GaussianBlur;2;21;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;22;GaussianBlur;2;22;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;23;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+Amplitude;24;GaussianBlur;2;24;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;25;GaussianBlur;2;25;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;26;GaussianBlur;2;26;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;27;GaussianBlur;2;27;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;28;GaussianBlur;2;28;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;29;GaussianBlur;2;29;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Amplitude;30;GaussianBlur;2;30;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;0;GaussianBlur;2;23;0;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;1;GaussianBlur;2;23;1;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;2;GaussianBlur;2;23;2;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;3;GaussianBlur;2;23;3;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;4;GaussianBlur;2;23;4;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;5;GaussianBlur;2;23;5;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;6;GaussianBlur;2;23;6;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;7;GaussianBlur;2;23;7;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;8;GaussianBlur;2;23;8;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;9;GaussianBlur;2;23;9;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;10;GaussianBlur;2;23;10;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;11;GaussianBlur;2;23;11;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;12;GaussianBlur;2;23;12;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;13;GaussianBlur;2;23;13;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;14;GaussianBlur;2;23;14;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;15;GaussianBlur;2;23;15;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;16;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+Otsu;17;GaussianBlur;2;23;17;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;18;GaussianBlur;2;23;18;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;19;GaussianBlur;2;23;19;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;20;GaussianBlur;2;23;20;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;21;GaussianBlur;2;23;21;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;22;GaussianBlur;2;23;22;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;23;GaussianBlur;2;23;23;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;24;GaussianBlur;2;23;24;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;25;GaussianBlur;2;23;25;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;26;GaussianBlur;2;23;26;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;27;GaussianBlur;2;23;27;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;28;GaussianBlur;2;23;28;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;29;GaussianBlur;2;23;29;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Otsu;30;GaussianBlur;2;23;30;4;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Connexity;4;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+IS Connexity;8;GaussianBlur;2;23;16;8;5;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;0;GaussianBlur;2;23;16;4;0;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;5;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+IS Min Size;10;GaussianBlur;2;23;16;4;10;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;15;GaussianBlur;2;23;16;4;15;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;20;GaussianBlur;2;23;16;4;20;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;25;GaussianBlur;2;23;16;4;25;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;30;GaussianBlur;2;23;16;4;30;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;35;GaussianBlur;2;23;16;4;35;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;40;GaussianBlur;2;23;16;4;40;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;45;GaussianBlur;2;23;16;4;45;4;1;0.9;5;0.9;0.1;5;0.8;NO
+IS Min Size;50;GaussianBlur;2;23;16;4;50;4;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;0;GaussianBlur;2;23;16;4;5;0;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;1;GaussianBlur;2;23;16;4;5;1;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;2;GaussianBlur;2;23;16;4;5;2;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;3;GaussianBlur;2;23;16;4;5;3;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;4;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+Blur XY;5;GaussianBlur;2;23;16;4;5;5;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;6;GaussianBlur;2;23;16;4;5;6;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;7;GaussianBlur;2;23;16;4;5;7;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;8;GaussianBlur;2;23;16;4;5;8;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;9;GaussianBlur;2;23;16;4;5;9;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur XY;10;GaussianBlur;2;23;16;4;5;10;1;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;0;GaussianBlur;2;23;16;4;5;4;0;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;1;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+Blur Z;2;GaussianBlur;2;23;16;4;5;4;2;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;3;GaussianBlur;2;23;16;4;5;4;3;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;4;GaussianBlur;2;23;16;4;5;4;4;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;5;GaussianBlur;2;23;16;4;5;4;5;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;6;GaussianBlur;2;23;16;4;5;4;6;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;7;GaussianBlur;2;23;16;4;5;4;7;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;8;GaussianBlur;2;23;16;4;5;4;8;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;9;GaussianBlur;2;23;16;4;5;4;9;0.9;5;0.9;0.1;5;0.8;NO
+Blur Z;10;GaussianBlur;2;23;16;4;5;4;10;0.9;5;0.9;0.1;5;0.8;NO
+ST_1;0.0;GaussianBlur;2;23;16;4;5;4;1;0.0;5;0.9;0.1;5;0.8;NO
+ST_1;0.1;GaussianBlur;2;23;16;4;5;4;1;0.1;5;0.9;0.1;5;0.8;NO
+ST_1;0.2;GaussianBlur;2;23;16;4;5;4;1;0.2;5;0.9;0.1;5;0.8;NO
+ST_1;0.3;GaussianBlur;2;23;16;4;5;4;1;0.3;5;0.9;0.1;5;0.8;NO
+ST_1;0.4;GaussianBlur;2;23;16;4;5;4;1;0.4;5;0.9;0.1;5;0.8;NO
+ST_1;0.5;GaussianBlur;2;23;16;4;5;4;1;0.5;5;0.9;0.1;5;0.8;NO
+ST_1;0.6;GaussianBlur;2;23;16;4;5;4;1;0.6;5;0.9;0.1;5;0.8;NO
+ST_1;0.7;GaussianBlur;2;23;16;4;5;4;1;0.7;5;0.9;0.1;5;0.8;NO
+ST_1;0.8;GaussianBlur;2;23;16;4;5;4;1;0.8;5;0.9;0.1;5;0.8;NO
+ST_1;0.9;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+ST_1;1.0;GaussianBlur;2;23;16;4;5;4;1;1.0;5;0.9;0.1;5;0.8;NO
+Overlap_1;0;GaussianBlur;2;23;16;4;5;4;1;0.9;0;0.9;0.1;5;0.8;NO
+Overlap_1;5;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+Overlap_1;10;GaussianBlur;2;23;16;4;5;4;1;0.9;10;0.9;0.1;5;0.8;NO
+Overlap_1;15;GaussianBlur;2;23;16;4;5;4;1;0.9;15;0.9;0.1;5;0.8;NO
+Overlap_1;17;GaussianBlur;2;23;16;4;5;4;1;0.9;17;0.9;0.1;5;0.8;NO
+Overlap_1;20;GaussianBlur;2;23;16;4;5;4;1;0.9;20;0.9;0.1;5;0.8;NO
+Overlap_1;25;GaussianBlur;2;23;16;4;5;4;1;0.9;25;0.9;0.1;5;0.8;NO
+Overlap_1;30;GaussianBlur;2;23;16;4;5;4;1;0.9;30;0.9;0.1;5;0.8;NO
+Overlap_1;35;GaussianBlur;2;23;16;4;5;4;1;0.9;35;0.9;0.1;5;0.8;NO
+Overlap_1;40;GaussianBlur;2;23;16;4;5;4;1;0.9;40;0.9;0.1;5;0.8;NO
+Overlap_1;45;GaussianBlur;2;23;16;4;5;4;1;0.9;45;0.9;0.1;5;0.8;NO
+Overlap_1;50;GaussianBlur;2;23;16;4;5;4;1;0.9;50;0.9;0.1;5;0.8;NO
+CR_1;0.5;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.5;0.1;5;0.8;NO
+CR_1;0.55;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.55;0.1;5;0.8;NO
+CR_1;0.6;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.6;0.1;5;0.8;NO
+CR_1;0.65;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.65;0.1;5;0.8;NO
+CR_1;0.7;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.7;0.1;5;0.8;NO
+CR_1;0.75;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.75;0.1;5;0.8;NO
+CR_1;0.8;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.8;0.1;5;0.8;NO
+CR_1;0.85;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.85;0.1;5;0.8;NO
+CR_1;0.9;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+CR_1;0.95;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.95;0.1;5;0.8;NO
+CR_1;1;GaussianBlur;2;23;16;4;5;4;1;0.9;5;1;0.1;5;0.8;NO
+ST_2;0.0;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.0;5;0.8;NO
+ST_2;0.1;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+ST_2;0.2;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.2;5;0.8;NO
+ST_2;0.3;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.3;5;0.8;NO
+ST_2;0.4;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.4;5;0.8;NO
+ST_2;0.5;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.5;5;0.8;NO
+ST_2;0.6;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.6;5;0.8;NO
+ST_2;0.7;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.7;5;0.8;NO
+ST_2;0.8;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.8;5;0.8;NO
+ST_2;0.9;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.9;5;0.8;NO
+ST_2;1.0;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;1.0;5;0.8;NO
+Overlap_2;0;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;0;0.8;NO
+Overlap_2;5;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+Overlap_2;10;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;10;0.8;NO
+Overlap_2;15;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;15;0.8;NO
+Overlap_2;20;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;20;0.8;NO
+Overlap_2;25;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;25;0.8;NO
+Overlap_2;30;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;30;0.8;NO
+Overlap_2;35;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;35;0.8;NO
+Overlap_2;40;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;40;0.8;NO
+Overlap_2;45;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;45;0.8;NO
+Overlap_2;50;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;50;0.8;NO
+CR_2;0.5;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.5;NO
+CR_2;0.55;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.55;NO
+CR_2;0.6;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.6;NO
+CR_2;0.65;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.65;NO
+CR_2;0.7;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.7;NO
+CR_2;0.75;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.75;NO
+CR_2;0.8;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.8;YES
+CR_2;0.85;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.85;NO
+CR_2;0.9;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.9;NO
+CR_2;0.95;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;0.95;NO
+CR_2;1;GaussianBlur;2;23;16;4;5;4;1;0.9;5;0.9;0.1;5;1;NO
diff --git a/src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_1.tif b/src/test/resources/Mouche/Ground truth Height map_1.tif
similarity index 100%
rename from src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_1.tif
rename to src/test/resources/Mouche/Ground truth Height map_1.tif
diff --git a/src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_2.tif b/src/test/resources/Mouche/Ground truth Height map_2.tif
similarity index 100%
rename from src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_2.tif
rename to src/test/resources/Mouche/Ground truth Height map_2.tif
diff --git a/src/test/resources/Mouche/Ground truth Height map_3_crop.tif b/src/test/resources/Mouche/Ground truth Height map_3_crop.tif
new file mode 100644
index 0000000000000000000000000000000000000000..4926f1d9e01c2a03d1f7f5370f572c9d47fa24e0
Binary files /dev/null and b/src/test/resources/Mouche/Ground truth Height map_3_crop.tif differ
diff --git a/src/test/resources/Mouche/Ground truth Height map_4_crop.tif b/src/test/resources/Mouche/Ground truth Height map_4_crop.tif
new file mode 100644
index 0000000000000000000000000000000000000000..97818d6078907014ce2fe0abc2bcbf8c86d6a3d7
Binary files /dev/null and b/src/test/resources/Mouche/Ground truth Height map_4_crop.tif differ
diff --git a/src/test/resources/Mouche/Mouche_PS.csv b/src/test/resources/Mouche/Mouche_PS.csv
new file mode 100644
index 0000000000000000000000000000000000000000..18d0a6f5e303094da2ed3f765c443c9d0083c78c
--- /dev/null
+++ b/src/test/resources/Mouche/Mouche_PS.csv
@@ -0,0 +1,165 @@
+Mouche;;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;
+Amplitude;0;GaussianBlur;2;0;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;1;GaussianBlur;2;1;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;2;GaussianBlur;2;2;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;3;GaussianBlur;2;3;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;4;GaussianBlur;2;4;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;5;GaussianBlur;2;5;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;6;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+Amplitude;7;GaussianBlur;2;7;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;8;GaussianBlur;2;8;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;9;GaussianBlur;2;9;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;10;GaussianBlur;2;10;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;11;GaussianBlur;2;11;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;12;GaussianBlur;2;12;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;13;GaussianBlur;2;13;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;14;GaussianBlur;2;14;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;15;GaussianBlur;2;15;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;16;GaussianBlur;2;16;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;17;GaussianBlur;2;17;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;18;GaussianBlur;2;18;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;19;GaussianBlur;2;19;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;20;GaussianBlur;2;20;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;21;GaussianBlur;2;21;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;22;GaussianBlur;2;22;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;23;GaussianBlur;2;23;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;24;GaussianBlur;2;24;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;25;GaussianBlur;2;25;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;26;GaussianBlur;2;26;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;27;GaussianBlur;2;27;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;28;GaussianBlur;2;28;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;29;GaussianBlur;2;29;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Amplitude;30;GaussianBlur;2;30;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;0;GaussianBlur;2;6;0;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;1;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+Otsu;2;GaussianBlur;2;6;2;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;3;GaussianBlur;2;6;3;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;4;GaussianBlur;2;6;4;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;5;GaussianBlur;2;6;5;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;6;GaussianBlur;2;6;6;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;7;GaussianBlur;2;6;7;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;8;GaussianBlur;2;6;8;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;9;GaussianBlur;2;6;9;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;10;GaussianBlur;2;6;10;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;11;GaussianBlur;2;6;11;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;12;GaussianBlur;2;6;12;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;13;GaussianBlur;2;6;13;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;14;GaussianBlur;2;6;14;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;15;GaussianBlur;2;6;15;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;16;GaussianBlur;2;6;16;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;17;GaussianBlur;2;6;17;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;18;GaussianBlur;2;6;18;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;19;GaussianBlur;2;6;19;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;20;GaussianBlur;2;6;20;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;21;GaussianBlur;2;6;21;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;22;GaussianBlur;2;6;22;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;23;GaussianBlur;2;6;23;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;24;GaussianBlur;2;6;24;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;25;GaussianBlur;2;6;25;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;26;GaussianBlur;2;6;26;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;27;GaussianBlur;2;6;27;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;28;GaussianBlur;2;6;28;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;29;GaussianBlur;2;6;29;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Otsu;30;GaussianBlur;2;6;30;4;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Connexity;4;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+IS Connexity;8;GaussianBlur;2;6;1;8;5;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;0;GaussianBlur;2;6;1;4;0;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;5;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+IS Min Size;10;GaussianBlur;2;6;1;4;10;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;15;GaussianBlur;2;6;1;4;15;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;20;GaussianBlur;2;6;1;4;20;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;25;GaussianBlur;2;6;1;4;25;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;30;GaussianBlur;2;6;1;4;30;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;35;GaussianBlur;2;6;1;4;35;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;40;GaussianBlur;2;6;1;4;40;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;45;GaussianBlur;2;6;1;4;45;5;1;0.7;10;0.8;0.1;5;0.9;NO
+IS Min Size;50;GaussianBlur;2;6;1;4;50;5;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;0;GaussianBlur;2;6;1;4;5;0;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;1;GaussianBlur;2;6;1;4;5;1;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;2;GaussianBlur;2;6;1;4;5;2;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;3;GaussianBlur;2;6;1;4;5;3;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;4;GaussianBlur;2;6;1;4;5;4;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;5;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+Blur XY;6;GaussianBlur;2;6;1;4;5;6;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;7;GaussianBlur;2;6;1;4;5;7;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;8;GaussianBlur;2;6;1;4;5;8;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;9;GaussianBlur;2;6;1;4;5;9;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur XY;10;GaussianBlur;2;6;1;4;5;10;1;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;0;GaussianBlur;2;6;1;4;5;5;0;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;1;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+Blur Z;2;GaussianBlur;2;6;1;4;5;5;2;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;3;GaussianBlur;2;6;1;4;5;5;3;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;4;GaussianBlur;2;6;1;4;5;5;4;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;5;GaussianBlur;2;6;1;4;5;5;5;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;6;GaussianBlur;2;6;1;4;5;5;6;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;7;GaussianBlur;2;6;1;4;5;5;7;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;8;GaussianBlur;2;6;1;4;5;5;8;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;9;GaussianBlur;2;6;1;4;5;5;9;0.7;10;0.8;0.1;5;0.9;NO
+Blur Z;10;GaussianBlur;2;6;1;4;5;5;10;0.7;10;0.8;0.1;5;0.9;NO
+ST_1;0.0;GaussianBlur;2;6;1;4;5;5;1;0.0;10;0.8;0.1;5;0.9;NO
+ST_1;0.1;GaussianBlur;2;6;1;4;5;5;1;0.1;10;0.8;0.1;5;0.9;NO
+ST_1;0.2;GaussianBlur;2;6;1;4;5;5;1;0.2;10;0.8;0.1;5;0.9;NO
+ST_1;0.3;GaussianBlur;2;6;1;4;5;5;1;0.3;10;0.8;0.1;5;0.9;NO
+ST_1;0.4;GaussianBlur;2;6;1;4;5;5;1;0.4;10;0.8;0.1;5;0.9;NO
+ST_1;0.5;GaussianBlur;2;6;1;4;5;5;1;0.5;10;0.8;0.1;5;0.9;NO
+ST_1;0.6;GaussianBlur;2;6;1;4;5;5;1;0.6;10;0.8;0.1;5;0.9;NO
+ST_1;0.7;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+ST_1;0.8;GaussianBlur;2;6;1;4;5;5;1;0.8;10;0.8;0.1;5;0.9;NO
+ST_1;0.9;GaussianBlur;2;6;1;4;5;5;1;0.9;10;0.8;0.1;5;0.9;NO
+ST_1;1.0;GaussianBlur;2;6;1;4;5;5;1;1.0;10;0.8;0.1;5;0.9;NO
+Overlap_1;0;GaussianBlur;2;6;1;4;5;5;1;0.7;0;0.8;0.1;5;0.9;NO
+Overlap_1;5;GaussianBlur;2;6;1;4;5;5;1;0.7;5;0.8;0.1;5;0.9;NO
+Overlap_1;10;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+Overlap_1;15;GaussianBlur;2;6;1;4;5;5;1;0.7;15;0.8;0.1;5;0.9;NO
+Overlap_1;17;GaussianBlur;2;6;1;4;5;5;1;0.7;17;0.8;0.1;5;0.9;NO
+Overlap_1;20;GaussianBlur;2;6;1;4;5;5;1;0.7;20;0.8;0.1;5;0.9;NO
+Overlap_1;25;GaussianBlur;2;6;1;4;5;5;1;0.7;25;0.8;0.1;5;0.9;NO
+Overlap_1;30;GaussianBlur;2;6;1;4;5;5;1;0.7;30;0.8;0.1;5;0.9;NO
+Overlap_1;35;GaussianBlur;2;6;1;4;5;5;1;0.7;35;0.8;0.1;5;0.9;NO
+Overlap_1;40;GaussianBlur;2;6;1;4;5;5;1;0.7;40;0.8;0.1;5;0.9;NO
+Overlap_1;45;GaussianBlur;2;6;1;4;5;5;1;0.7;45;0.8;0.1;5;0.9;NO
+Overlap_1;50;GaussianBlur;2;6;1;4;5;5;1;0.7;50;0.8;0.1;5;0.9;NO
+CR_1;0.5;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.5;0.1;5;0.9;NO
+CR_1;0.55;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.55;0.1;5;0.9;NO
+CR_1;0.6;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.6;0.1;5;0.9;NO
+CR_1;0.65;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.65;0.1;5;0.9;NO
+CR_1;0.7;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.7;0.1;5;0.9;NO
+CR_1;0.75;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.75;0.1;5;0.9;NO
+CR_1;0.8;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+CR_1;0.85;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.85;0.1;5;0.9;NO
+CR_1;0.9;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.9;0.1;5;0.9;NO
+CR_1;0.95;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.95;0.1;5;0.9;NO
+CR_1;1;GaussianBlur;2;6;1;4;5;5;1;0.7;10;1;0.1;5;0.9;NO
+ST_2;0.0;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.0;5;0.9;NO
+ST_2;0.1;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+ST_2;0.2;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.2;5;0.9;NO
+ST_2;0.3;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.3;5;0.9;NO
+ST_2;0.4;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.4;5;0.9;NO
+ST_2;0.5;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.5;5;0.9;NO
+ST_2;0.6;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.6;5;0.9;NO
+ST_2;0.7;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.7;5;0.9;NO
+ST_2;0.8;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.8;5;0.9;NO
+ST_2;0.9;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.9;5;0.9;NO
+ST_2;1.0;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;1.0;5;0.9;NO
+Overlap_2;0;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;0;0.9;NO
+Overlap_2;5;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+Overlap_2;10;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;10;0.9;NO
+Overlap_2;15;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;15;0.9;NO
+Overlap_2;20;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;20;0.9;NO
+Overlap_2;25;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;25;0.9;NO
+Overlap_2;30;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;30;0.9;NO
+Overlap_2;35;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;35;0.9;NO
+Overlap_2;40;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;40;0.9;NO
+Overlap_2;45;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;45;0.9;NO
+Overlap_2;50;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;50;0.9;NO
+CR_2;0.5;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.5;NO
+CR_2;0.55;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.55;NO
+CR_2;0.6;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.6;NO
+CR_2;0.65;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.65;NO
+CR_2;0.7;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.7;NO
+CR_2;0.75;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.75;NO
+CR_2;0.8;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.8;NO
+CR_2;0.85;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.85;NO
+CR_2;0.9;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.9;YES
+CR_2;0.95;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;0.95;NO
+CR_2;1;GaussianBlur;2;6;1;4;5;5;1;0.7;10;0.8;0.1;5;1;NO
diff --git a/src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_3.tif b/src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_3.tif
deleted file mode 100644
index acf79178f75a795c33c5f8d4f2c5822ffdca8048..0000000000000000000000000000000000000000
Binary files a/src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_3.tif and /dev/null differ
diff --git a/src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_4.tif b/src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_4.tif
deleted file mode 100644
index c82952b11d718be33e0fa731173c7599216d08da..0000000000000000000000000000000000000000
Binary files a/src/test/resources/Mouche_c01_f0001_p013/Ground truth Height map_4.tif and /dev/null differ
diff --git a/src/test/resources/Mouche_c01_f0001_p013/Mouche_c01_f0001_p013_SweepSelection.csv b/src/test/resources/Mouche_c01_f0001_p013/Mouche_c01_f0001_p013_SweepSelection.csv
deleted file mode 100644
index d266d749a1cc68976486c5ecd359c6aa78c39b7c..0000000000000000000000000000000000000000
--- a/src/test/resources/Mouche_c01_f0001_p013/Mouche_c01_f0001_p013_SweepSelection.csv
+++ /dev/null
@@ -1,48 +0,0 @@
-;;GaussianBlur;2;0.8;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;
-AmplitudeThreshold;0;GaussianBlur;2;0;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;GaussianBlur;2;0.1;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;GaussianBlur;2;0.2;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;GaussianBlur;2;0.3;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;GaussianBlur;2;0.4;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;GaussianBlur;2;0.5;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;GaussianBlur;2;0.6;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;GaussianBlur;2;0.7;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;GaussianBlur;2;0.8;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;YES
-AmplitudeThreshold;0.9;GaussianBlur;2;0.9;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;GaussianBlur;2;1;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;0;GaussianBlur;2;0.8;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;0.1;GaussianBlur;2;0.8;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;YES
-Otsu Threshold;0.2;GaussianBlur;2;0.8;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;0.3;GaussianBlur;2;0.8;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;0.4;GaussianBlur;2;0.8;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;0.5;GaussianBlur;2;0.8;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;0.6;GaussianBlur;2;0.8;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;0.7;GaussianBlur;2;0.8;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;0.8;GaussianBlur;2;0.8;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;0.9;GaussianBlur;2;0.8;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Otsu Threshold;1;GaussianBlur;2;0.8;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Connexity;4;GaussianBlur;2;0.8;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;YES
-IS Connexity;8;GaussianBlur;2;0.8;0.1;8;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;0;GaussianBlur;2;0.8;0.1;4;0;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;5;GaussianBlur;2;0.8;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;YES
-IS Min Size;10;GaussianBlur;2;0.8;0.1;4;10;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;15;GaussianBlur;2;0.8;0.1;4;15;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;20;GaussianBlur;2;0.8;0.1;4;20;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;25;GaussianBlur;2;0.8;0.1;4;25;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;30;GaussianBlur;2;0.8;0.1;4;30;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;35;GaussianBlur;2;0.8;0.1;4;35;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;40;GaussianBlur;2;0.8;0.1;4;40;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;45;GaussianBlur;2;0.8;0.1;4;45;4;1;0.75;10;0.8;0.1;10;0.9;NO
-IS Min Size;50;GaussianBlur;2;0.8;0.1;4;50;4;1;0.75;10;0.8;0.1;10;0.9;NO
-Blur XY;0;GaussianBlur;2;0.8;0.1;4;5;0;1;0.75;10;0.8;0.1;10;0.9;NO
-Blur XY;1;GaussianBlur;2;0.8;0.1;4;5;1;1;0.75;10;0.8;0.1;10;0.9;NO
-Blur XY;2;GaussianBlur;2;0.8;0.1;4;5;2;1;0.75;10;0.8;0.1;10;0.9;NO
-Blur XY;3;GaussianBlur;2;0.8;0.1;4;5;3;1;0.75;10;0.8;0.1;10;0.9;NO
-Blur XY;4;GaussianBlur;2;0.8;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;YES
-Blur XY;5;GaussianBlur;2;0.8;0.1;4;5;5;1;0.75;10;0.8;0.1;10;0.9;NO
-BlurZ;0;GaussianBlur;2;0.8;0.1;4;5;4;0;0.75;10;0.8;0.1;10;0.9;NO
-BlurZ;1;GaussianBlur;2;0.8;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;YES
-BlurZ;2;GaussianBlur;2;0.8;0.1;4;5;4;2;0.75;10;0.8;0.1;10;0.9;NO
-BlurZ;3;GaussianBlur;2;0.8;0.1;4;5;4;3;0.75;10;0.8;0.1;10;0.9;NO
-BlurZ;4;GaussianBlur;2;0.8;0.1;4;5;4;4;0.75;10;0.8;0.1;10;0.9;NO
-BlurZ;5;GaussianBlur;2;0.8;0.1;4;5;4;5;0.75;10;0.8;0.1;10;0.9;NO
diff --git a/src/test/resources/Mouche_c01_f0001_p013/Mouche_c01_f0001_p013_SweepThreshold.csv b/src/test/resources/Mouche_c01_f0001_p013/Mouche_c01_f0001_p013_SweepThreshold.csv
deleted file mode 100644
index 3752dc8e3287496ef9c9464b87598cec54ff35bb..0000000000000000000000000000000000000000
--- a/src/test/resources/Mouche_c01_f0001_p013/Mouche_c01_f0001_p013_SweepThreshold.csv
+++ /dev/null
@@ -1,120 +0,0 @@
-;;;;GaussianBlur;2;0.8;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;
-AmplitudeThreshold;0;Otsu Threshold;0.1;GaussianBlur;2;0;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0;Otsu Threshold;0.2;GaussianBlur;2;0;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0;Otsu Threshold;0.3;GaussianBlur;2;0;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0;Otsu Threshold;0.4;GaussianBlur;2;0;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0;Otsu Threshold;0.5;GaussianBlur;2;0;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0;Otsu Threshold;0.6;GaussianBlur;2;0;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0;Otsu Threshold;0.7;GaussianBlur;2;0;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0;Otsu Threshold;0.8;GaussianBlur;2;0;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0;Otsu Threshold;0.9;GaussianBlur;2;0;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0;Otsu Threshold;1;GaussianBlur;2;0;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;0.1;GaussianBlur;2;0.1;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;0.2;GaussianBlur;2;0.1;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;0.3;GaussianBlur;2;0.1;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;0.4;GaussianBlur;2;0.1;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;0.5;GaussianBlur;2;0.1;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;0.6;GaussianBlur;2;0.1;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;0.7;GaussianBlur;2;0.1;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;0.8;GaussianBlur;2;0.1;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;0.9;GaussianBlur;2;0.1;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.1;Otsu Threshold;1;GaussianBlur;2;0.1;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0;GaussianBlur;2;0.2;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0.1;GaussianBlur;2;0.2;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0.2;GaussianBlur;2;0.2;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0.3;GaussianBlur;2;0.2;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0.4;GaussianBlur;2;0.2;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0.5;GaussianBlur;2;0.2;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0.6;GaussianBlur;2;0.2;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0.7;GaussianBlur;2;0.2;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0.8;GaussianBlur;2;0.2;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;0.9;GaussianBlur;2;0.2;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.2;Otsu Threshold;1;GaussianBlur;2;0.2;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0;GaussianBlur;2;0.3;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0.1;GaussianBlur;2;0.3;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0.2;GaussianBlur;2;0.3;0.2;4;5;0;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0.3;GaussianBlur;2;0.3;0.3;4;5;1;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0.4;GaussianBlur;2;0.3;0.4;4;5;2;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0.5;GaussianBlur;2;0.3;0.5;4;5;3;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0.6;GaussianBlur;2;0.3;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0.7;GaussianBlur;2;0.3;0.7;4;5;5;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0.8;GaussianBlur;2;0.3;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;0.9;GaussianBlur;2;0.3;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.3;Otsu Threshold;1;GaussianBlur;2;0.3;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0;GaussianBlur;2;0.4;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0.1;GaussianBlur;2;0.4;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0.2;GaussianBlur;2;0.4;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0.3;GaussianBlur;2;0.4;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0.4;GaussianBlur;2;0.4;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0.5;GaussianBlur;2;0.4;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0.6;GaussianBlur;2;0.4;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0.7;GaussianBlur;2;0.4;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0.8;GaussianBlur;2;0.4;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;0.9;GaussianBlur;2;0.4;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.4;Otsu Threshold;1;GaussianBlur;2;0.4;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0;GaussianBlur;2;0.5;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0.1;GaussianBlur;2;0.5;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0.2;GaussianBlur;2;0.5;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0.3;GaussianBlur;2;0.5;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0.4;GaussianBlur;2;0.5;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0.5;GaussianBlur;2;0.5;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0.6;GaussianBlur;2;0.5;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0.7;GaussianBlur;2;0.5;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0.8;GaussianBlur;2;0.5;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;0.9;GaussianBlur;2;0.5;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.5;Otsu Threshold;1;GaussianBlur;2;0.5;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0;GaussianBlur;2;0.6;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0.1;GaussianBlur;2;0.6;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0.2;GaussianBlur;2;0.6;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0.3;GaussianBlur;2;0.6;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0.4;GaussianBlur;2;0.6;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0.5;GaussianBlur;2;0.6;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0.6;GaussianBlur;2;0.6;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0.7;GaussianBlur;2;0.6;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0.8;GaussianBlur;2;0.6;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;0.9;GaussianBlur;2;0.6;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.6;Otsu Threshold;1;GaussianBlur;2;0.6;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0;GaussianBlur;2;0.7;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0.1;GaussianBlur;2;0.7;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0.2;GaussianBlur;2;0.7;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0.3;GaussianBlur;2;0.7;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0.4;GaussianBlur;2;0.7;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0.5;GaussianBlur;2;0.7;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0.6;GaussianBlur;2;0.7;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0.7;GaussianBlur;2;0.7;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0.8;GaussianBlur;2;0.7;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;0.9;GaussianBlur;2;0.7;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.7;Otsu Threshold;1;GaussianBlur;2;0.7;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;0;GaussianBlur;2;0.8;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;0.1;GaussianBlur;2;0.8;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;YES
-AmplitudeThreshold;0.8;Otsu Threshold;0.2;GaussianBlur;2;0.8;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;0.3;GaussianBlur;2;0.8;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;0.4;GaussianBlur;2;0.8;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;0.5;GaussianBlur;2;0.8;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;0.6;GaussianBlur;2;0.8;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;0.7;GaussianBlur;2;0.8;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;0.8;GaussianBlur;2;0.8;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;0.9;GaussianBlur;2;0.8;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.8;Otsu Threshold;1;GaussianBlur;2;0.8;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0;GaussianBlur;2;0.9;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0.1;GaussianBlur;2;0.9;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0.2;GaussianBlur;2;0.9;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0.3;GaussianBlur;2;0.9;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0.4;GaussianBlur;2;0.9;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0.5;GaussianBlur;2;0.9;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0.6;GaussianBlur;2;0.9;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0.7;GaussianBlur;2;0.9;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0.8;GaussianBlur;2;0.9;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;0.9;GaussianBlur;2;0.9;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;0.9;Otsu Threshold;1;GaussianBlur;2;0.9;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0;GaussianBlur;2;1;0;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0.1;GaussianBlur;2;1;0.1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0.2;GaussianBlur;2;1;0.2;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0.3;GaussianBlur;2;1;0.3;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0.4;GaussianBlur;2;1;0.4;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0.5;GaussianBlur;2;1;0.5;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0.6;GaussianBlur;2;1;0.6;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0.7;GaussianBlur;2;1;0.7;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0.8;GaussianBlur;2;1;0.8;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;0.9;GaussianBlur;2;1;0.9;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
-AmplitudeThreshold;1;Otsu Threshold;1;GaussianBlur;2;1;1;4;5;4;1;0.75;10;0.8;0.1;10;0.9;NO
diff --git a/src/test/resources/Mouche_c01_f0001_p013/ParameterSweep_Mouche_13.csv b/src/test/resources/Mouche_c01_f0001_p013/ParameterSweep_Mouche_13.csv
deleted file mode 100644
index 0faeaeb7ea490fef211d49dea28475b1d2caa1f6..0000000000000000000000000000000000000000
--- a/src/test/resources/Mouche_c01_f0001_p013/ParameterSweep_Mouche_13.csv
+++ /dev/null
@@ -1,124 +0,0 @@
-;;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;
-Amplitude;0.0;GaussianBlur;2;0.0;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Amplitude;0.1;GaussianBlur;2;0.1;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Amplitude;0.2;GaussianBlur;2;0.2;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Amplitude;0.3;GaussianBlur;2;0.3;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Amplitude;0.4;GaussianBlur;2;0.4;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Amplitude;0.5;GaussianBlur;2;0.5;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Amplitude;0.6;GaussianBlur;2;0.6;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Amplitude;0.7;GaussianBlur;2;0.7;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Amplitude;0.8;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-Amplitude;0.9;GaussianBlur;2;0.9;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Amplitude;1.0;GaussianBlur;2;1.0;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;0.0;GaussianBlur;2;0.8;0.0;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;0.1;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-Otsu;0.2;GaussianBlur;2;0.8;0.2;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;0.3;GaussianBlur;2;0.8;0.3;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;0.4;GaussianBlur;2;0.8;0.4;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;0.5;GaussianBlur;2;0.8;0.5;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;0.6;GaussianBlur;2;0.8;0.6;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;0.7;GaussianBlur;2;0.8;0.7;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;0.8;GaussianBlur;2;0.8;0.8;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;0.9;GaussianBlur;2;0.8;0.9;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Otsu;1.0;GaussianBlur;2;0.8;1.0;4;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Connexity;4;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-IS Connexity;8;GaussianBlur;2;0.8;0.1;8;10;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;0;GaussianBlur;2;0.8;0.1;4;0;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;5;GaussianBlur;2;0.8;0.1;4;5;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;10;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-IS Min Size;15;GaussianBlur;2;0.8;0.1;4;15;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;20;GaussianBlur;2;0.8;0.1;4;20;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;25;GaussianBlur;2;0.8;0.1;4;25;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;30;GaussianBlur;2;0.8;0.1;4;30;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;35;GaussianBlur;2;0.8;0.1;4;35;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;40;GaussianBlur;2;0.8;0.1;4;40;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;45;GaussianBlur;2;0.8;0.1;4;45;4;1;0.7;10;0.8;0.1;10;0.9;NO
-IS Min Size;50;GaussianBlur;2;0.8;0.1;4;50;4;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;0;GaussianBlur;2;0.8;0.1;4;10;0;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;1;GaussianBlur;2;0.8;0.1;4;10;1;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;2;GaussianBlur;2;0.8;0.1;4;10;2;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;3;GaussianBlur;2;0.8;0.1;4;10;3;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;4;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-Blur XY;5;GaussianBlur;2;0.8;0.1;4;10;5;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;6;GaussianBlur;2;0.8;0.1;4;10;6;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;7;GaussianBlur;2;0.8;0.1;4;10;7;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;8;GaussianBlur;2;0.8;0.1;4;10;8;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;9;GaussianBlur;2;0.8;0.1;4;10;9;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur XY;10;GaussianBlur;2;0.8;0.1;4;10;10;1;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;0;GaussianBlur;2;0.8;0.1;4;10;4;0;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;1;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-Blur Z;2;GaussianBlur;2;0.8;0.1;4;10;4;2;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;3;GaussianBlur;2;0.8;0.1;4;10;4;3;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;4;GaussianBlur;2;0.8;0.1;4;10;4;4;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;5;GaussianBlur;2;0.8;0.1;4;10;4;5;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;6;GaussianBlur;2;0.8;0.1;4;10;4;6;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;7;GaussianBlur;2;0.8;0.1;4;10;4;7;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;8;GaussianBlur;2;0.8;0.1;4;10;4;8;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;9;GaussianBlur;2;0.8;0.1;4;10;4;9;0.7;10;0.8;0.1;10;0.9;NO
-Blur Z;10;GaussianBlur;2;0.8;0.1;4;10;4;10;0.7;10;0.8;0.1;10;0.9;NO
-ST_1;0.0;GaussianBlur;2;0.8;0.1;4;10;4;1;0.0;10;0.8;0.1;10;0.9;NO
-ST_1;0.1;GaussianBlur;2;0.8;0.1;4;10;4;1;0.1;10;0.8;0.1;10;0.9;NO
-ST_1;0.2;GaussianBlur;2;0.8;0.1;4;10;4;1;0.2;10;0.8;0.1;10;0.9;NO
-ST_1;0.3;GaussianBlur;2;0.8;0.1;4;10;4;1;0.3;10;0.8;0.1;10;0.9;NO
-ST_1;0.4;GaussianBlur;2;0.8;0.1;4;10;4;1;0.4;10;0.8;0.1;10;0.9;NO
-ST_1;0.5;GaussianBlur;2;0.8;0.1;4;10;4;1;0.5;10;0.8;0.1;10;0.9;NO
-ST_1;0.6;GaussianBlur;2;0.8;0.1;4;10;4;1;0.6;10;0.8;0.1;10;0.9;NO
-ST_1;0.7;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-ST_1;0.8;GaussianBlur;2;0.8;0.1;4;10;4;1;0.8;10;0.8;0.1;10;0.9;NO
-ST_1;0.9;GaussianBlur;2;0.8;0.1;4;10;4;1;0.9;10;0.8;0.1;10;0.9;NO
-ST_1;1.0;GaussianBlur;2;0.8;0.1;4;10;4;1;1.0;10;0.8;0.1;10;0.9;NO
-Overlap_1;0;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;0;0.8;0.1;10;0.9;NO
-Overlap_1;5;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;5;0.8;0.1;10;0.9;NO
-Overlap_1;10;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-Overlap_1;15;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;15;0.8;0.1;10;0.9;NO
-Overlap_1;20;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;20;0.8;0.1;10;0.9;NO
-Overlap_1;25;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;25;0.8;0.1;10;0.9;NO
-Overlap_1;30;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;30;0.8;0.1;10;0.9;NO
-Overlap_1;35;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;35;0.8;0.1;10;0.9;NO
-Overlap_1;40;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;40;0.8;0.1;10;0.9;NO
-Overlap_1;45;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;45;0.8;0.1;10;0.9;NO
-Overlap_1;50;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;50;0.8;0.1;10;0.9;NO
-CR_1;0.5;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.5;0.1;10;0.9;NO
-CR_1;0.55;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.55;0.1;10;0.9;NO
-CR_1;0.6;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.6;0.1;10;0.9;NO
-CR_1;0.65;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.65;0.1;10;0.9;NO
-CR_1;0.7;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.7;0.1;10;0.9;NO
-CR_1;0.75;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.75;0.1;10;0.9;NO
-CR_1;0.8;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-CR_1;0.85;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.85;0.1;10;0.9;NO
-CR_1;0.9;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.9;0.1;10;0.9;NO
-CR_1;0.95;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.95;0.1;10;0.9;NO
-CR_1;1;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;1;0.1;10;0.9;NO
-ST_2;0.0;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.0;10;0.9;NO
-ST_2;0.1;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-ST_2;0.2;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.2;10;0.9;NO
-ST_2;0.3;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.3;10;0.9;NO
-ST_2;0.4;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.4;10;0.9;NO
-ST_2;0.5;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.5;10;0.9;NO
-ST_2;0.6;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.6;10;0.9;NO
-ST_2;0.7;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.7;10;0.9;NO
-ST_2;0.8;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.8;10;0.9;NO
-ST_2;0.9;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.9;10;0.9;NO
-ST_2;1.0;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;1.0;10;0.9;NO
-Overlap_2;0;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;0;0.9;NO
-Overlap_2;5;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;5;0.9;NO
-Overlap_2;10;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-Overlap_2;15;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;15;0.9;NO
-Overlap_2;20;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;20;0.9;NO
-Overlap_2;25;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;25;0.9;NO
-Overlap_2;30;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;30;0.9;NO
-Overlap_2;35;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;35;0.9;NO
-Overlap_2;40;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;40;0.9;NO
-Overlap_2;45;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;45;0.9;NO
-Overlap_2;50;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;50;0.9;NO
-CR_2;0.5;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.5;NO
-CR_2;0.55;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.55;NO
-CR_2;0.6;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.6;NO
-CR_2;0.65;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.65;NO
-CR_2;0.7;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.7;NO
-CR_2;0.75;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.75;NO
-CR_2;0.8;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.8;NO
-CR_2;0.85;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.85;NO
-CR_2;0.9;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.9;YES
-CR_2;0.95;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;0.95;NO
-CR_2;1;GaussianBlur;2;0.8;0.1;4;10;4;1;0.7;10;0.8;0.1;10;1;NO
diff --git a/src/test/resources/Mouche_c01_f0001_p013/STK_Mouche_c01_f0001_p013.tif b/src/test/resources/Mouche_c01_f0001_p013/STK_Mouche_c01_f0001_p013.tif
deleted file mode 100644
index 32c9cfa57fcdf0da7ffd43d2151a0ece9dc65b2e..0000000000000000000000000000000000000000
Binary files a/src/test/resources/Mouche_c01_f0001_p013/STK_Mouche_c01_f0001_p013.tif and /dev/null differ
diff --git a/src/test/resources/Organoid/HM1.tif b/src/test/resources/Organoid/HM1.tif
new file mode 100644
index 0000000000000000000000000000000000000000..4ce5204c3b5db2dc2ff96d866caaedc4e7042197
Binary files /dev/null and b/src/test/resources/Organoid/HM1.tif differ
diff --git a/src/test/resources/Organoid/HM2.tif b/src/test/resources/Organoid/HM2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..52801e3d4a0299d658edc0e0e852bd0136a9c5a6
Binary files /dev/null and b/src/test/resources/Organoid/HM2.tif differ
diff --git a/src/test/resources/Organoid/Organoid_PS.csv b/src/test/resources/Organoid/Organoid_PS.csv
new file mode 100644
index 0000000000000000000000000000000000000000..f24014c0bb6f1f588b03698c71770e2b490a6486
--- /dev/null
+++ b/src/test/resources/Organoid/Organoid_PS.csv
@@ -0,0 +1,165 @@
+Organoid;;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;
+Amplitude;0;GaussianBlur;2;0;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;1;GaussianBlur;2;1;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;2;GaussianBlur;2;2;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;3;GaussianBlur;2;3;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;4;GaussianBlur;2;4;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;5;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+Amplitude;6;GaussianBlur;2;6;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;7;GaussianBlur;2;7;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;8;GaussianBlur;2;8;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;9;GaussianBlur;2;9;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;10;GaussianBlur;2;10;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;11;GaussianBlur;2;11;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;12;GaussianBlur;2;12;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;13;GaussianBlur;2;13;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;14;GaussianBlur;2;14;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;15;GaussianBlur;2;15;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;16;GaussianBlur;2;16;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;17;GaussianBlur;2;17;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;18;GaussianBlur;2;18;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;19;GaussianBlur;2;19;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;20;GaussianBlur;2;20;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;21;GaussianBlur;2;21;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;22;GaussianBlur;2;22;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;23;GaussianBlur;2;23;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;24;GaussianBlur;2;24;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;25;GaussianBlur;2;25;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;26;GaussianBlur;2;26;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;27;GaussianBlur;2;27;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;28;GaussianBlur;2;28;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;29;GaussianBlur;2;29;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;30;GaussianBlur;2;30;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;0;GaussianBlur;2;5;0;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;1;GaussianBlur;2;5;1;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;2;GaussianBlur;2;5;2;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;3;GaussianBlur;2;5;3;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;4;GaussianBlur;2;5;4;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;5;GaussianBlur;2;5;5;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;6;GaussianBlur;2;5;6;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;7;GaussianBlur;2;5;7;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;8;GaussianBlur;2;5;8;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;9;GaussianBlur;2;5;9;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;10;GaussianBlur;2;5;10;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;11;GaussianBlur;2;5;11;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;12;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+Otsu;13;GaussianBlur;2;5;13;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;14;GaussianBlur;2;5;14;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;15;GaussianBlur;2;5;15;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;16;GaussianBlur;2;5;16;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;17;GaussianBlur;2;5;17;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;18;GaussianBlur;2;5;18;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;19;GaussianBlur;2;5;19;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;20;GaussianBlur;2;5;20;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;21;GaussianBlur;2;5;21;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;22;GaussianBlur;2;5;22;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;23;GaussianBlur;2;5;23;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;24;GaussianBlur;2;5;24;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;25;GaussianBlur;2;5;25;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;26;GaussianBlur;2;5;26;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;27;GaussianBlur;2;5;27;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;28;GaussianBlur;2;5;28;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;29;GaussianBlur;2;5;29;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;30;GaussianBlur;2;5;30;4;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Connexity;4;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+IS Connexity;8;GaussianBlur;2;5;12;8;5;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;0;GaussianBlur;2;5;12;4;0;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;5;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+IS Min Size;10;GaussianBlur;2;5;12;4;10;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;15;GaussianBlur;2;5;12;4;15;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;20;GaussianBlur;2;5;12;4;20;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;25;GaussianBlur;2;5;12;4;25;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;30;GaussianBlur;2;5;12;4;30;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;35;GaussianBlur;2;5;12;4;35;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;40;GaussianBlur;2;5;12;4;40;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;45;GaussianBlur;2;5;12;4;45;2;1;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;50;GaussianBlur;2;5;12;4;50;2;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;0;GaussianBlur;2;5;12;4;5;0;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;1;GaussianBlur;2;5;12;4;5;1;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;2;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+Blur XY;3;GaussianBlur;2;5;12;4;5;3;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;4;GaussianBlur;2;5;12;4;5;4;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;5;GaussianBlur;2;5;12;4;5;5;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;6;GaussianBlur;2;5;12;4;5;6;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;7;GaussianBlur;2;5;12;4;5;7;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;8;GaussianBlur;2;5;12;4;5;8;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;9;GaussianBlur;2;5;12;4;5;9;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;10;GaussianBlur;2;5;12;4;5;10;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;0;GaussianBlur;2;5;12;4;5;2;0;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;1;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+Blur Z;2;GaussianBlur;2;5;12;4;5;2;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;3;GaussianBlur;2;5;12;4;5;2;3;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;4;GaussianBlur;2;5;12;4;5;2;4;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;5;GaussianBlur;2;5;12;4;5;2;5;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;6;GaussianBlur;2;5;12;4;5;2;6;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;7;GaussianBlur;2;5;12;4;5;2;7;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;8;GaussianBlur;2;5;12;4;5;2;8;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;9;GaussianBlur;2;5;12;4;5;2;9;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;10;GaussianBlur;2;5;12;4;5;2;10;0.9;5;0.8;0.1;10;0.8;NO
+ST_1;0.0;GaussianBlur;2;5;12;4;5;2;1;0.0;5;0.8;0.1;10;0.8;NO
+ST_1;0.1;GaussianBlur;2;5;12;4;5;2;1;0.1;5;0.8;0.1;10;0.8;NO
+ST_1;0.2;GaussianBlur;2;5;12;4;5;2;1;0.2;5;0.8;0.1;10;0.8;NO
+ST_1;0.3;GaussianBlur;2;5;12;4;5;2;1;0.3;5;0.8;0.1;10;0.8;NO
+ST_1;0.4;GaussianBlur;2;5;12;4;5;2;1;0.4;5;0.8;0.1;10;0.8;NO
+ST_1;0.5;GaussianBlur;2;5;12;4;5;2;1;0.5;5;0.8;0.1;10;0.8;NO
+ST_1;0.6;GaussianBlur;2;5;12;4;5;2;1;0.6;5;0.8;0.1;10;0.8;NO
+ST_1;0.7;GaussianBlur;2;5;12;4;5;2;1;0.7;5;0.8;0.1;10;0.8;NO
+ST_1;0.8;GaussianBlur;2;5;12;4;5;2;1;0.8;5;0.8;0.1;10;0.8;NO
+ST_1;0.9;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+ST_1;1.0;GaussianBlur;2;5;12;4;5;2;1;1.0;5;0.8;0.1;10;0.8;NO
+Overlap_1;0;GaussianBlur;2;5;12;4;5;2;1;0.9;0;0.8;0.1;10;0.8;NO
+Overlap_1;5;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+Overlap_1;10;GaussianBlur;2;5;12;4;5;2;1;0.9;10;0.8;0.1;10;0.8;NO
+Overlap_1;15;GaussianBlur;2;5;12;4;5;2;1;0.9;15;0.8;0.1;10;0.8;NO
+Overlap_1;17;GaussianBlur;2;5;12;4;5;2;1;0.9;17;0.8;0.1;10;0.8;NO
+Overlap_1;20;GaussianBlur;2;5;12;4;5;2;1;0.9;20;0.8;0.1;10;0.8;NO
+Overlap_1;25;GaussianBlur;2;5;12;4;5;2;1;0.9;25;0.8;0.1;10;0.8;NO
+Overlap_1;30;GaussianBlur;2;5;12;4;5;2;1;0.9;30;0.8;0.1;10;0.8;NO
+Overlap_1;35;GaussianBlur;2;5;12;4;5;2;1;0.9;35;0.8;0.1;10;0.8;NO
+Overlap_1;40;GaussianBlur;2;5;12;4;5;2;1;0.9;40;0.8;0.1;10;0.8;NO
+Overlap_1;45;GaussianBlur;2;5;12;4;5;2;1;0.9;45;0.8;0.1;10;0.8;NO
+Overlap_1;50;GaussianBlur;2;5;12;4;5;2;1;0.9;50;0.8;0.1;10;0.8;NO
+CR_1;0.5;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.5;0.1;10;0.8;NO
+CR_1;0.55;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.55;0.1;10;0.8;NO
+CR_1;0.6;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.6;0.1;10;0.8;NO
+CR_1;0.65;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.65;0.1;10;0.8;NO
+CR_1;0.7;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.7;0.1;10;0.8;NO
+CR_1;0.75;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.75;0.1;10;0.8;NO
+CR_1;0.8;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+CR_1;0.85;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.85;0.1;10;0.8;NO
+CR_1;0.9;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.9;0.1;10;0.8;NO
+CR_1;0.95;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.95;0.1;10;0.8;NO
+CR_1;1;GaussianBlur;2;5;12;4;5;2;1;0.9;5;1;0.1;10;0.8;NO
+ST_2;0.0;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.0;10;0.8;NO
+ST_2;0.1;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+ST_2;0.2;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.2;10;0.8;NO
+ST_2;0.3;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.3;10;0.8;NO
+ST_2;0.4;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.4;10;0.8;NO
+ST_2;0.5;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.5;10;0.8;NO
+ST_2;0.6;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.6;10;0.8;NO
+ST_2;0.7;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.7;10;0.8;NO
+ST_2;0.8;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.8;10;0.8;NO
+ST_2;0.9;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.9;10;0.8;NO
+ST_2;1.0;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;1.0;10;0.8;NO
+Overlap_2;0;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;0;0.8;NO
+Overlap_2;5;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;5;0.8;NO
+Overlap_2;10;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+Overlap_2;15;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;15;0.8;NO
+Overlap_2;20;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;20;0.8;NO
+Overlap_2;25;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;25;0.8;NO
+Overlap_2;30;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;30;0.8;NO
+Overlap_2;35;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;35;0.8;NO
+Overlap_2;40;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;40;0.8;NO
+Overlap_2;45;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;45;0.8;NO
+Overlap_2;50;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;50;0.8;NO
+CR_2;0.5;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.5;NO
+CR_2;0.55;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.55;NO
+CR_2;0.6;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.6;NO
+CR_2;0.65;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.65;NO
+CR_2;0.7;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.7;NO
+CR_2;0.75;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.75;NO
+CR_2;0.8;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.8;YES
+CR_2;0.85;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.85;NO
+CR_2;0.9;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.9;NO
+CR_2;0.95;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;0.95;NO
+CR_2;1;GaussianBlur;2;5;12;4;5;2;1;0.9;5;0.8;0.1;10;1;NO
diff --git a/src/test/resources/Phantom/Phantom_PS.csv b/src/test/resources/Phantom/Phantom_PS.csv
new file mode 100644
index 0000000000000000000000000000000000000000..a26a291b828a76be7b9f36f5ae439a4df5a44cd5
--- /dev/null
+++ b/src/test/resources/Phantom/Phantom_PS.csv
@@ -0,0 +1,165 @@
+Phantom;;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;
+Amplitude;0;GaussianBlur;2;0;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;1;GaussianBlur;2;1;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;2;GaussianBlur;2;2;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;3;GaussianBlur;2;3;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;4;GaussianBlur;2;4;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;5;GaussianBlur;2;5;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;6;GaussianBlur;2;6;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;7;GaussianBlur;2;7;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;8;GaussianBlur;2;8;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;9;GaussianBlur;2;9;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;10;GaussianBlur;2;10;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;11;GaussianBlur;2;11;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;12;GaussianBlur;2;12;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;13;GaussianBlur;2;13;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;14;GaussianBlur;2;14;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;15;GaussianBlur;2;15;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;16;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+Amplitude;17;GaussianBlur;2;17;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;18;GaussianBlur;2;18;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;19;GaussianBlur;2;19;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;20;GaussianBlur;2;20;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;21;GaussianBlur;2;21;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;22;GaussianBlur;2;22;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;23;GaussianBlur;2;23;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;24;GaussianBlur;2;24;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;25;GaussianBlur;2;25;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;26;GaussianBlur;2;26;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;27;GaussianBlur;2;27;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;28;GaussianBlur;2;28;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;29;GaussianBlur;2;29;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Amplitude;30;GaussianBlur;2;30;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;0;GaussianBlur;2;16;0;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;1;GaussianBlur;2;16;1;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;2;GaussianBlur;2;16;2;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;3;GaussianBlur;2;16;3;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;4;GaussianBlur;2;16;4;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;5;GaussianBlur;2;16;5;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;6;GaussianBlur;2;16;6;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;7;GaussianBlur;2;16;7;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;8;GaussianBlur;2;16;8;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;9;GaussianBlur;2;16;9;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;10;GaussianBlur;2;16;10;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;11;GaussianBlur;2;16;11;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;12;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+Otsu;13;GaussianBlur;2;16;13;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;14;GaussianBlur;2;16;14;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;15;GaussianBlur;2;16;15;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;16;GaussianBlur;2;16;16;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;17;GaussianBlur;2;16;17;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;18;GaussianBlur;2;16;18;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;19;GaussianBlur;2;16;19;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;20;GaussianBlur;2;16;20;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;21;GaussianBlur;2;16;21;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;22;GaussianBlur;2;16;22;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;23;GaussianBlur;2;16;23;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;24;GaussianBlur;2;16;24;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;25;GaussianBlur;2;16;25;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;26;GaussianBlur;2;16;26;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;27;GaussianBlur;2;16;27;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;28;GaussianBlur;2;16;28;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;29;GaussianBlur;2;16;29;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Otsu;30;GaussianBlur;2;16;30;4;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Connexity;4;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+IS Connexity;8;GaussianBlur;2;16;12;8;5;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;0;GaussianBlur;2;16;12;4;0;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;5;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+IS Min Size;10;GaussianBlur;2;16;12;4;10;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;15;GaussianBlur;2;16;12;4;15;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;20;GaussianBlur;2;16;12;4;20;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;25;GaussianBlur;2;16;12;4;25;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;30;GaussianBlur;2;16;12;4;30;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;35;GaussianBlur;2;16;12;4;35;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;40;GaussianBlur;2;16;12;4;40;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;45;GaussianBlur;2;16;12;4;45;4;2;0.9;5;0.8;0.1;10;0.8;NO
+IS Min Size;50;GaussianBlur;2;16;12;4;50;4;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;0;GaussianBlur;2;16;12;4;5;0;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;1;GaussianBlur;2;16;12;4;5;1;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;2;GaussianBlur;2;16;12;4;5;2;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;3;GaussianBlur;2;16;12;4;5;3;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;4;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+Blur XY;5;GaussianBlur;2;16;12;4;5;5;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;6;GaussianBlur;2;16;12;4;5;6;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;7;GaussianBlur;2;16;12;4;5;7;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;8;GaussianBlur;2;16;12;4;5;8;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;9;GaussianBlur;2;16;12;4;5;9;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur XY;10;GaussianBlur;2;16;12;4;5;10;2;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;0;GaussianBlur;2;16;12;4;5;4;0;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;1;GaussianBlur;2;16;12;4;5;4;1;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;2;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+Blur Z;3;GaussianBlur;2;16;12;4;5;4;3;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;4;GaussianBlur;2;16;12;4;5;4;4;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;5;GaussianBlur;2;16;12;4;5;4;5;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;6;GaussianBlur;2;16;12;4;5;4;6;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;7;GaussianBlur;2;16;12;4;5;4;7;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;8;GaussianBlur;2;16;12;4;5;4;8;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;9;GaussianBlur;2;16;12;4;5;4;9;0.9;5;0.8;0.1;10;0.8;NO
+Blur Z;10;GaussianBlur;2;16;12;4;5;4;10;0.9;5;0.8;0.1;10;0.8;NO
+ST_1;0.0;GaussianBlur;2;16;12;4;5;4;2;0.0;5;0.8;0.1;10;0.8;NO
+ST_1;0.1;GaussianBlur;2;16;12;4;5;4;2;0.1;5;0.8;0.1;10;0.8;NO
+ST_1;0.2;GaussianBlur;2;16;12;4;5;4;2;0.2;5;0.8;0.1;10;0.8;NO
+ST_1;0.3;GaussianBlur;2;16;12;4;5;4;2;0.3;5;0.8;0.1;10;0.8;NO
+ST_1;0.4;GaussianBlur;2;16;12;4;5;4;2;0.4;5;0.8;0.1;10;0.8;NO
+ST_1;0.5;GaussianBlur;2;16;12;4;5;4;2;0.5;5;0.8;0.1;10;0.8;NO
+ST_1;0.6;GaussianBlur;2;16;12;4;5;4;2;0.6;5;0.8;0.1;10;0.8;NO
+ST_1;0.7;GaussianBlur;2;16;12;4;5;4;2;0.7;5;0.8;0.1;10;0.8;NO
+ST_1;0.8;GaussianBlur;2;16;12;4;5;4;2;0.8;5;0.8;0.1;10;0.8;NO
+ST_1;0.9;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+ST_1;1.0;GaussianBlur;2;16;12;4;5;4;2;1.0;5;0.8;0.1;10;0.8;NO
+Overlap_1;0;GaussianBlur;2;16;12;4;5;4;2;0.9;0;0.8;0.1;10;0.8;NO
+Overlap_1;5;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+Overlap_1;10;GaussianBlur;2;16;12;4;5;4;2;0.9;10;0.8;0.1;10;0.8;NO
+Overlap_1;15;GaussianBlur;2;16;12;4;5;4;2;0.9;15;0.8;0.1;10;0.8;NO
+Overlap_1;17;GaussianBlur;2;16;12;4;5;4;2;0.9;17;0.8;0.1;10;0.8;NO
+Overlap_1;20;GaussianBlur;2;16;12;4;5;4;2;0.9;20;0.8;0.1;10;0.8;NO
+Overlap_1;25;GaussianBlur;2;16;12;4;5;4;2;0.9;25;0.8;0.1;10;0.8;NO
+Overlap_1;30;GaussianBlur;2;16;12;4;5;4;2;0.9;30;0.8;0.1;10;0.8;NO
+Overlap_1;35;GaussianBlur;2;16;12;4;5;4;2;0.9;35;0.8;0.1;10;0.8;NO
+Overlap_1;40;GaussianBlur;2;16;12;4;5;4;2;0.9;40;0.8;0.1;10;0.8;NO
+Overlap_1;45;GaussianBlur;2;16;12;4;5;4;2;0.9;45;0.8;0.1;10;0.8;NO
+Overlap_1;50;GaussianBlur;2;16;12;4;5;4;2;0.9;50;0.8;0.1;10;0.8;NO
+CR_1;0.5;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.5;0.1;10;0.8;NO
+CR_1;0.55;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.55;0.1;10;0.8;NO
+CR_1;0.6;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.6;0.1;10;0.8;NO
+CR_1;0.65;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.65;0.1;10;0.8;NO
+CR_1;0.7;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.7;0.1;10;0.8;NO
+CR_1;0.75;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.75;0.1;10;0.8;NO
+CR_1;0.8;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+CR_1;0.85;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.85;0.1;10;0.8;NO
+CR_1;0.9;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.9;0.1;10;0.8;NO
+CR_1;0.95;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.95;0.1;10;0.8;NO
+CR_1;1;GaussianBlur;2;16;12;4;5;4;2;0.9;5;1;0.1;10;0.8;NO
+ST_2;0.0;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.0;10;0.8;NO
+ST_2;0.1;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+ST_2;0.2;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.2;10;0.8;NO
+ST_2;0.3;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.3;10;0.8;NO
+ST_2;0.4;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.4;10;0.8;NO
+ST_2;0.5;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.5;10;0.8;NO
+ST_2;0.6;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.6;10;0.8;NO
+ST_2;0.7;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.7;10;0.8;NO
+ST_2;0.8;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.8;10;0.8;NO
+ST_2;0.9;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.9;10;0.8;NO
+ST_2;1.0;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;1.0;10;0.8;NO
+Overlap_2;0;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;0;0.8;NO
+Overlap_2;5;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;5;0.8;NO
+Overlap_2;10;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+Overlap_2;15;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;15;0.8;NO
+Overlap_2;20;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;20;0.8;NO
+Overlap_2;25;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;25;0.8;NO
+Overlap_2;30;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;30;0.8;NO
+Overlap_2;35;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;35;0.8;NO
+Overlap_2;40;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;40;0.8;NO
+Overlap_2;45;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;45;0.8;NO
+Overlap_2;50;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;50;0.8;NO
+CR_2;0.5;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.5;NO
+CR_2;0.55;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.55;NO
+CR_2;0.6;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.6;NO
+CR_2;0.65;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.65;NO
+CR_2;0.7;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.7;NO
+CR_2;0.75;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.75;NO
+CR_2;0.8;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.8;YES
+CR_2;0.85;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.85;NO
+CR_2;0.9;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.9;NO
+CR_2;0.95;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;0.95;NO
+CR_2;1;GaussianBlur;2;16;12;4;5;4;2;0.9;5;0.8;0.1;10;1;NO
diff --git a/src/test/resources/Phantom/phantoms_snrtest_zmap1_gt.tif b/src/test/resources/Phantom/phantoms_snrtest_zmap1_gt.tif
new file mode 100644
index 0000000000000000000000000000000000000000..54307b7423ae2fc823633f6cc8b6b7e092ed260e
Binary files /dev/null and b/src/test/resources/Phantom/phantoms_snrtest_zmap1_gt.tif differ
diff --git a/src/test/resources/Phantom/phantoms_snrtest_zmap2_gt.tif b/src/test/resources/Phantom/phantoms_snrtest_zmap2_gt.tif
new file mode 100644
index 0000000000000000000000000000000000000000..ec64c533ec1261c7e8cbf77cc0b533cd46fd3200
Binary files /dev/null and b/src/test/resources/Phantom/phantoms_snrtest_zmap2_gt.tif differ
diff --git a/src/test/resources/Phantom/phantoms_snrtest_zmap3_gt.tif b/src/test/resources/Phantom/phantoms_snrtest_zmap3_gt.tif
new file mode 100644
index 0000000000000000000000000000000000000000..e624076fa8cde24da6b249d333142b997ce78ff1
Binary files /dev/null and b/src/test/resources/Phantom/phantoms_snrtest_zmap3_gt.tif differ