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).  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