fixed file close CTRLHA-109

# By ebner
# Via ebner
* commit 'e5331e0c2d5d33dffee6906b5db5bda33f144e5a':
  Updated version CTRLHA-109
  Fixed memory leak that was introduced with the VirtualStack workaround - its still a workaround so CTRLHA-109
  tried to implement close of file CTRLHA-109
  implemented a HDF5 Virtual Stack CTRLHA-109

.gitignore

@@ -1 +1,3 @@
 /target
+.gradle
+build

Readme.md

@@ -2,7 +2,9 @@
 
 ImageJ plugin for reading and writing HDF5 files.
 
-
+For 3D datasets an individual slice can be selected for visualization.
+Also, especially for very big datasets only every x-th slice can be selected
+for visualization. This can be done by either specifying a number, e.g. `10` (for the slice 10) or a number with a preceding %, e.g. `%10` (for every 10th image). Indexing starts at 0.
 
 # Usage
 

build.gradle

@@ -0,0 +1,30 @@
+apply plugin: 'java'
+apply plugin: 'maven'
+
+group = 'ch.psi'
+version = '0.8.0'
+
+description = """"""
+
+sourceCompatibility = 1.7
+targetCompatibility = 1.7
+
+
+
+repositories {
+     mavenCentral()
+     maven { url "http://slsyoke4.psi.ch:8081/artifactory/libs-releases" }
+}
+dependencies {
+    compile group: 'hdf5', name: 'hdf', version:'2.10.0'
+    compile group: 'hdf5', name: 'hdfobj', version:'2.10.0'
+    compile group: 'hdf5', name: 'hdf5', version:'2.10.0'
+    compile group: 'hdf5', name: 'hdf5obj', version:'2.10.0'
+    compile group: 'org.slf4j', name: 'slf4j-api', version:'1.7.6'
+    testCompile group: 'junit', name: 'junit', version:'4.11'
+    compile(group: 'gov.nih.imagej', name: 'imagej', version:'1.46') {
+       /* This dependency was originally in the Maven provided scope, but the project was not of type war.
+       This behavior is not yet supported by Gradle, so this dependency has been converted to a compile dependency.
+       Please review and delete this closure when resolved. */
+    }
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Tue Apr 14 08:25:23 CEST 2015
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-bin.zip

gradlew

@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

pom.xml

@@ -3,7 +3,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>ch.psi</groupId>
 	<artifactId>imagej.hdf5</artifactId>
-	<version>0.8.0</version>
+	<version>0.9.0</version>
 
 	<dependencies>
 		<dependency>

src/main/java/ch/psi/imagej/hdf5/DatasetSelection.java

@@ -0,0 +1,47 @@
+package ch.psi.imagej.hdf5;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import ncsa.hdf.object.Dataset;
+
+public class DatasetSelection {
+
+	private List<Dataset> datasets = new ArrayList<Dataset>();
+	private boolean group = false;
+	private Integer slice;
+	// Intervall to read images
+	private Integer modulo;
+	private boolean virtualStack;
+	
+	public List<Dataset> getDatasets() {
+		return datasets;
+	}
+	public void setDatasets(List<Dataset> datasets) {
+		this.datasets = datasets;
+	}
+	public boolean isGroup() {
+		return group;
+	}
+	public void setGroup(boolean group) {
+		this.group = group;
+	}
+	public void setSlice(Integer slice) {
+		this.slice = slice;
+	}
+	public Integer getSlice() {
+		return slice;
+	}
+	public void setModulo(Integer modulo) {
+		this.modulo = modulo;
+	}
+	public Integer getModulo() {
+		return modulo;
+	}
+	public void setVirtualStack(boolean virtualStack) {
+		this.virtualStack = virtualStack;
+	}
+	public boolean isVirtualStack(){
+		return this.virtualStack;
+	}
+}

src/main/java/ch/psi/imagej/hdf5/HDF5Reader.java

@@ -10,20 +10,9 @@ import ij.plugin.PlugIn;
 
 import java.io.File;
 import java.lang.reflect.Array;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import java.awt.*;
-
-import javax.swing.BoxLayout;
-import javax.swing.DefaultListCellRenderer;
-import javax.swing.JCheckBox;
-import javax.swing.JLabel;
-import javax.swing.JList;
-import javax.swing.JPanel;
-import javax.swing.JScrollPane;
-import javax.swing.ScrollPaneConstants;
 
 import ncsa.hdf.object.*;
 import ncsa.hdf.object.h5.*;
@@ -62,13 +51,16 @@ public class HDF5Reader implements PlugIn {
 		
 		// Read HDF5 file
 		H5File file = null;
+		boolean close = true;
 		try {
 			file = new H5File(filename, H5File.READ);
 			file.setMaxMembers(Integer.MAX_VALUE);
 			file.open();
 
 			List<Dataset> datasets = HDF5Utilities.getDatasets(file);
-			SelectedDatasets selectedDatasets = selectDatasets(datasets);
+			DatasetSelection selectedDatasets = selectDatasets(datasets);
+			// TODO to be removed - Workaround virtual stack - keep HDF5 file open at the end 
+			close=!selectedDatasets.isVirtualStack();
 
 			
 			// TODO Remove
@@ -217,22 +209,76 @@ public class HDF5Reader implements PlugIn {
 				} else if (numberOfDimensions == 3) {
 					logger.info("3D Image");
 
-					// Select what to readout
+					ImageStack stack;
-					long[] selected = var.getSelectedDims();
+					
-					selected[0] = dimensions[0];
+					if(selectedDatasets.isVirtualStack()){
-					selected[1] = dimensions[1];
+						logger.info("Use virtual stack");
-					selected[2] = dimensions[2];
+						stack = new VirtualStackHDF5(file, var);
-
+					}
-					Object wholeDataset = var.read();
+					else{
-
+						if(selectedDatasets.getSlice()!=null){
-					ImageStack stack = new ImageStack((int) dimensions[2], (int) dimensions[1]);
+							
-					int size = (int) (dimensions[1] * dimensions[2]);
+							// Select what to readout
-					for (int lev = 0; lev < dimensions[0]; ++lev) {
+							long[] selected = var.getSelectedDims();
-						int startIdx = lev * size;
+							selected[0] = 1;
-						addSlice(stack, wholeDataset, startIdx, size);
+							selected[1] = dimensions[1];
+							selected[2] = dimensions[2];
+							
+							long[] start = var.getStartDims();
+							start[0] = selectedDatasets.getSlice();
+	
+							Object wholeDataset = var.read();
+							
+							stack = new ImageStack((int) dimensions[2], (int) dimensions[1]);
+							int size = (int) (dimensions[1] * dimensions[2]);
+							
+	//						int startIdx = selectedDatasets.getSlice() * size;
+							addSlice(stack, wholeDataset, 0, size);
+						}
+						else if(selectedDatasets.getModulo()!=null){
+							logger.info("Read every "+selectedDatasets.getModulo()+" image");
+							// Select what to readout
+							
+							stack = new ImageStack((int) dimensions[2], (int) dimensions[1]);
+							
+							for(int indexToRead=0;indexToRead<dimensions[0]; indexToRead=indexToRead+selectedDatasets.getModulo()){
+								
+								long[] selected = var.getSelectedDims();
+								selected[0] = 1;
+								selected[1] = dimensions[1];
+								selected[2] = dimensions[2];
+		
+								long[] start = var.getStartDims();
+								start[0] = indexToRead;
+								
+								Object wholeDataset = var.read();
+		
+								int size = (int) (dimensions[1] * dimensions[2]);
+	//							int startIdx = selectedDatasets.getSlice() * size;
+								addSlice(stack, wholeDataset, 0, size);
+							}
+						}
+						else{
+							// Select what to readout
+							long[] selected = var.getSelectedDims();
+							selected[0] = dimensions[0];
+							selected[1] = dimensions[1];
+							selected[2] = dimensions[2];
+	
+							
+							Object wholeDataset = var.read();
+	
+							stack = new ImageStack((int) dimensions[2], (int) dimensions[1]);
+							int size = (int) (dimensions[1] * dimensions[2]);
+							
+							for (int lev = 0; lev < dimensions[0]; ++lev) {
+								int startIdx = lev * size;
+								addSlice(stack, wholeDataset, startIdx, size);
+							}
+						}
 					}
 
-					ImagePlus imp = new ImagePlus(filename + " " + datasetName, stack);
+					ImagePlus imp = new ImagePlusHDF5(filename + " " + datasetName, stack);
 					imp.resetDisplayRange();
 					imp.show();
 					
@@ -260,8 +306,11 @@ public class HDF5Reader implements PlugIn {
 			IJ.outOfMemory("Out of memory while loading file: " + filename);
 		} finally {
 			try {
-				if (file != null) {
+				// TODO workaround - to be removed
-					file.close();
+				if(close){
+					if (file != null) {
+						file.close();
+					}
 				}
 			} catch (HDF5Exception e) {
 				logger.log(Level.WARNING, "Error while closing: " + filename, e);
@@ -279,39 +328,12 @@ public class HDF5Reader implements PlugIn {
 	 * @return	List of datasets to visualize. If nothing selected the list will be empty
 	 * @throws HDF5Exception
 	 */
-	private SelectedDatasets selectDatasets(List<Dataset> datasets) throws HDF5Exception {
+	private DatasetSelection selectDatasets(List<Dataset> datasets) throws HDF5Exception {
 		
 		GenericDialog gd = new GenericDialog("Variable Name Selection");
 		gd.addMessage("Please select variables to be loaded.\n");
 		
-			// Filter datasets that are not potential images / that cannot be displayed
+		SelectionPanel panel = new SelectionPanel(datasets);
-			List<Dataset> fdatasets = new ArrayList<Dataset>();
-			for(Dataset d: datasets){
-				if(d.getRank()>=2 && d.getRank()<=5){
-					fdatasets.add(d);
-				}
-			}
-			
-			JList<Dataset> list = new JList<>(fdatasets.toArray(new Dataset[fdatasets.size()]));
-			list.setCellRenderer(new DefaultListCellRenderer() {
-				private static final long serialVersionUID = 1L;
-				public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected, boolean cellHasFocus)	{
-					JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
-					final Dataset d = ((Dataset) value);
-					label.setText(d.getFullName()+" ("+d.getRank()+"D)");
-					return label;
-
-				}
-			});
-		    
-		    JScrollPane scroll = new JScrollPane(list);
-		    scroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
-		    
-			JPanel panel = new JPanel();
-			panel.setLayout(new BoxLayout(panel,BoxLayout.Y_AXIS));
-			panel.add(scroll);
-			JCheckBox checkbox = new JCheckBox("Group Datasets (2D datasets only)");
-			panel.add(checkbox);
 			
 			gd = new GenericDialog("Variable Name Selection");
 			gd.add(panel);
@@ -319,10 +341,13 @@ public class HDF5Reader implements PlugIn {
 			gd.pack();
 			gd.showDialog();
 
-			SelectedDatasets selectedDatasets = new SelectedDatasets();
+			DatasetSelection selectedDatasets = new DatasetSelection();
 			if (!gd.wasCanceled()) {
-				selectedDatasets.setDatasets(list.getSelectedValuesList());
+				selectedDatasets.setDatasets(panel.getSelectedValues());
-				selectedDatasets.setGroup(checkbox.isSelected());
+				selectedDatasets.setGroup(panel.groupValues());
+				selectedDatasets.setSlice(panel.getSlice());
+				selectedDatasets.setModulo(panel.getModulo());
+				selectedDatasets.setVirtualStack(panel.useVirtualStack());
 			}
 		
 		return selectedDatasets;

src/main/java/ch/psi/imagej/hdf5/ImagePlusHDF5.java

@@ -0,0 +1,70 @@
+package ch.psi.imagej.hdf5;
+
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+import java.util.logging.Logger;
+
+import ij.ImagePlus;
+import ij.ImageStack;
+
+public class ImagePlusHDF5 extends ImagePlus {
+	
+	
+	private static final Logger logger = Logger.getLogger(ImagePlusHDF5.class.getName());
+	private VirtualStackHDF5 stack;
+	
+	public ImagePlusHDF5(String title, ImageStack stack) {
+		super(title, stack);
+		if(stack instanceof VirtualStackHDF5){
+			logger.info("VirtualStackHDF5");
+			this.stack = (VirtualStackHDF5) stack;
+		}
+		
+	}
+	
+	@Override
+	public void show() {
+		super.show();
+		getWindow().addWindowListener(new WindowListener() {
+			
+			@Override
+			public void windowOpened(WindowEvent e) {
+				logger.info("");
+			}
+			
+			@Override
+			public void windowIconified(WindowEvent e) {
+				logger.info("");
+			}
+			
+			@Override
+			public void windowDeiconified(WindowEvent e) {
+				logger.info("");
+			}
+			
+			@Override
+			public void windowDeactivated(WindowEvent e) {
+				logger.info("");
+			}
+			
+			@Override
+			public void windowClosing(WindowEvent e) {
+				logger.info("Closing");
+			}
+			
+			@Override
+			public void windowClosed(WindowEvent e) {
+				logger.info("Closed");
+				
+				if(stack!=null){
+					stack.close();
+				}
+			}
+			
+			@Override
+			public void windowActivated(WindowEvent e) {
+				logger.info("");
+			}
+		});
+	}
+}

src/main/java/ch/psi/imagej/hdf5/SelectedDatasets.java

@@ -1,26 +0,0 @@
-package ch.psi.imagej.hdf5;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import ncsa.hdf.object.Dataset;
-
-public class SelectedDatasets {
-
-	private List<Dataset> datasets = new ArrayList<Dataset>();
-	private boolean group = false;
-	
-	public List<Dataset> getDatasets() {
-		return datasets;
-	}
-	public void setDatasets(List<Dataset> datasets) {
-		this.datasets = datasets;
-	}
-	public boolean isGroup() {
-		return group;
-	}
-	public void setGroup(boolean group) {
-		this.group = group;
-	}
-	
-}

src/main/java/ch/psi/imagej/hdf5/SelectionPanel.java

@@ -0,0 +1,111 @@
+package ch.psi.imagej.hdf5;
+
+import java.awt.Component;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.BoxLayout;
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.DefaultListModel;
+import javax.swing.JCheckBox;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.ScrollPaneConstants;
+
+import ncsa.hdf.object.Dataset;
+import javax.swing.JTextField;
+import java.awt.FlowLayout;
+
+public class SelectionPanel extends JPanel {
+
+	private static final long serialVersionUID = 1L;
+
+	private final JList<Dataset> list;
+	private JCheckBox checkbox;
+	private JCheckBox checkBoxVirtualStack;
+	private JLabel lblSlice;
+	private JPanel panel;
+	private JTextField textField;
+	
+	public SelectionPanel(){
+		this(new ArrayList<Dataset>());
+	}
+	
+	public SelectionPanel(List<Dataset> datasets){
+		// Filter datasets that are not potential images / that cannot be displayed
+		List<Dataset> fdatasets = new ArrayList<Dataset>();
+		for(Dataset d: datasets){
+			if(d.getRank()>=2 && d.getRank()<=5){
+				fdatasets.add(d);
+			}
+		}
+		
+		list = new JList<>(new DefaultListModel<Dataset>());
+		list.setListData(fdatasets.toArray(new Dataset[fdatasets.size()]));
+		list.setCellRenderer(new DefaultListCellRenderer() {
+			private static final long serialVersionUID = 1L;
+			public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected, boolean cellHasFocus)	{
+				JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+				final Dataset d = ((Dataset) value);
+				label.setText(d.getFullName()+" ("+d.getRank()+"D)");
+				return label;
+
+			}
+		});
+		list.setSelectedIndex(0);
+	    
+	    JScrollPane scroll = new JScrollPane(list);
+	    scroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
+	    
+		setLayout(new BoxLayout(this,BoxLayout.Y_AXIS));
+		add(scroll);
+		checkbox = new JCheckBox("Group Datasets (2D datasets only)");
+		add(checkbox);
+		
+		checkBoxVirtualStack = new JCheckBox("Virtual Stack");
+		checkBoxVirtualStack.setSelected(true);
+		add(checkBoxVirtualStack);
+		
+		panel = new JPanel();
+		FlowLayout flowLayout = (FlowLayout) panel.getLayout();
+		flowLayout.setAlignment(FlowLayout.LEFT);
+		add(panel);
+		
+		lblSlice = new JLabel("Slice (3D only):");
+		panel.add(lblSlice);
+		
+		textField = new JTextField();
+		panel.add(textField);
+		textField.setColumns(10);
+	}
+	
+	public List<Dataset> getSelectedValues(){
+		return list.getSelectedValuesList();
+	}
+	
+	public boolean groupValues(){
+		return checkbox.isSelected();
+	}
+	
+	public Integer getSlice(){
+		String text = textField.getText();
+		if(text.matches("^[0-9]+$")){
+			return new Integer(text);
+		}
+		return null;
+	}
+	
+	public Integer getModulo(){
+		String text = textField.getText();
+		if(text.matches("^%[0-9]+$")){
+			return new Integer(text.replace("%", ""));
+		}
+		return null;
+	}
+	
+	public boolean useVirtualStack(){
+		return checkBoxVirtualStack.isSelected();
+	}
+}

src/main/java/ch/psi/imagej/hdf5/VirtualStackHDF5.java

@@ -0,0 +1,174 @@
+package ch.psi.imagej.hdf5;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import ncsa.hdf.object.Dataset;
+import ncsa.hdf.object.h5.H5File;
+import ij.ImageStack;
+import ij.process.ByteProcessor;
+import ij.process.ColorProcessor;
+import ij.process.FloatProcessor;
+import ij.process.ImageProcessor;
+import ij.process.ShortProcessor;
+
+public class VirtualStackHDF5 extends ImageStack {
+	
+	
+	private static final Logger logger = Logger.getLogger(VirtualStackHDF5.class.getName());
+	
+	private int bitDepth = 0;
+	private Dataset dataset;
+	private H5File file;
+	
+	public VirtualStackHDF5(H5File file, Dataset dataset){
+		super((int) dataset.getDims()[2], (int) dataset.getDims()[1]);
+		this.dataset = dataset;
+		this.file = file;
+	}
+	
+	/** Does noting. */
+	public void addSlice(String sliceLabel, Object pixels) {
+	}
+
+	/** Does nothing.. */
+	public void addSlice(String sliceLabel, ImageProcessor ip) {
+	}
+
+	/** Does noting. */
+	public void addSlice(String sliceLabel, ImageProcessor ip, int n) {
+	}
+
+	/** Does noting. */
+	public void deleteSlice(int n) {
+	}
+
+	/** Does noting. */
+	public void deleteLastSlice() {
+	}
+
+	public Object getPixels(int slice) {
+		try {
+			long[] dimensions = dataset.getDims();
+
+			// Select what to readout
+			long[] selected = dataset.getSelectedDims();
+			selected[0] = 1;
+			selected[1] = dimensions[1];
+			selected[2] = dimensions[2];
+
+			long[] start = dataset.getStartDims();
+			start[0] = slice-1; // Indexing at image J starts at 1
+
+			Object wholeDataset = dataset.read();
+
+			if (wholeDataset instanceof byte[]) {
+				return (byte[]) wholeDataset;
+			} else if (wholeDataset instanceof short[]) {
+				return (short[]) wholeDataset;
+			} else if (wholeDataset instanceof int[]) {
+				return HDF5Utilities.convertToFloat((int[]) wholeDataset);
+			} else if (wholeDataset instanceof long[]) {
+				return HDF5Utilities.convertToFloat((long[]) wholeDataset);
+			} else if (wholeDataset instanceof float[]) {
+				return (float[]) wholeDataset;
+			} else if (wholeDataset instanceof double[]) {
+				return HDF5Utilities.convertToFloat((double[]) wholeDataset);
+			} else {
+				logger.warning("Datatype not supported");
+			}
+		} catch (OutOfMemoryError | Exception e) {
+			logger.log(Level.WARNING, "Unable to open slice", e);
+		}
+		
+		return null;
+	}
+
+	/**
+	 * Assigns a pixel array to the specified slice, were 1<=n<=nslices.
+	 */
+	public void setPixels(Object pixels, int n) {
+	}
+
+	/**
+	 * Returns an ImageProcessor for the specified slice, were 1<=n<=nslices.
+	 * Returns null if the stack is empty.
+	 */
+	public ImageProcessor getProcessor(int slice) {
+		
+		long[] dimensions = dataset.getDims();
+		final Object pixels = getPixels(slice);
+		
+		// Todo support more ImageProcessor types
+		ImageProcessor ip;		
+		
+		if (pixels instanceof byte[]){
+			ip = new ByteProcessor((int) dimensions[2], (int) dimensions[1]);
+		}
+		else if (pixels instanceof short[]){
+			ip = new ShortProcessor((int) dimensions[2], (int) dimensions[1]);
+		}
+		else if (pixels instanceof int[]){
+			ip = new ColorProcessor((int) dimensions[2], (int) dimensions[1]);
+		}
+		else if (pixels instanceof float[]){
+			ip = new FloatProcessor((int) dimensions[2], (int) dimensions[1]);
+		}
+		else {
+			throw new IllegalArgumentException("Unknown stack type");
+		}
+		
+		ip.setPixels(pixels);
+		return ip;
+	}
+
+	/** Returns the number of slices in this stack. */
+	public int getSize() {
+		return (int) this.dataset.getDims()[0];
+	}
+
+	/** Returns the label of the Nth image. */
+	public String getSliceLabel(int slice) {
+		return "Slice: "+slice;
+	}
+
+	/** Returns null. */
+	public Object[] getImageArray() {
+		return null;
+	}
+
+	/** Does nothing. */
+	public void setSliceLabel(String label, int n) {
+	}
+
+	/** Always return true. */
+	public boolean isVirtual() {
+		return true;
+	}
+
+	/** Does nothing. */
+	public void trim() {
+	}
+
+	/**
+	 * Returns the bit depth (8, 16, 24 or 32), or 0 if the bit depth is not
+	 * known.
+	 */
+	public int getBitDepth() {
+		return bitDepth;
+	}
+	
+	/**
+	 * Close HDF5 file
+	 */
+	public void close() {		
+		logger.info("Closing HDF5 file");
+		try{
+			file.close();
+		}
+		catch(Exception e){
+			logger.log(Level.WARNING, "Unable to close HDF5 file", e);
+		}
+		
+	}
+}