diff --git a/.classpath b/.classpath
index 373b83c7ad36b985d889e4699104d78f14456193..46222352c47d7768e185d55b381831b0734f08cf 100644
--- a/.classpath
+++ b/.classpath
@@ -1,10 +1,48 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="src" path="src"/>
+ <classpathentry kind="src" path="src/main/java"/>
+ <classpathentry kind="src" path="src/main/resources"/>
+ <classpathentry kind="src" path="src/test/java"/>
<classpathentry kind="lib" path="/Icy-App/plugins/adufour/ezplug/EzPlug.jar"/>
<classpathentry kind="lib" path="/Icy-App/plugins/adufour/blocks/Blocks.jar"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="var" path="ICY_JAR"/>
- <classpathentry kind="output" path="bin"/>
- <referencedentry kind="lib" path="D:/Stephane/Documents/dev/GIT/Icy-App/lib/scifio.jar" sourcepath="D:/Stephane/Documents/dev/GIT/bioformats"/>
+ <classpathentry kind="lib" path="F:/SDKs/Java/jdk1.8.0_241/lib/tools.jar"/>
+ <classpathentry kind="var" path="USER_HOME/SDKs/Java/jdk1.8.0_251/lib/tools.jar"/>
+ <classpathentry kind="var" path="USER_HOME/SDKs/Java/jdk1.8.0_251/lib/tools.jar"/>
+ <classpathentry kind="var" path="USER_HOME/SDKs/Java/jdk1.8.0_251/lib/tools.jar"/>
+ <classpathentry kind="var" path="USER_HOME/SDKs/Java/jdk1.8.0_251/lib/tools.jar"/>
+ <classpathentry kind="var" path="USER_HOME/SDKs/Java/jdk1.8.0_251/lib/tools.jar"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.bioimageanalysis.icy:icy-kernel:2.1.0"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: net.sf.ehcache:ehcache:2.10.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.slf4j:slf4j-api:1.7.25"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.bioimageanalysis.icy:icy-bioformats:6.3.1"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.bioimageanalysis.icy:icy-insubstantial:7.3.7"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.bioimageanalysis.icy:icy-vtk:6.3.0.1"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: net.imagej:ij:1.52q"/>
+ <classpathentry kind="var" path="USER_HOME/SDKs/Java/jdk1.8.0_251/lib/tools.jar"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: javax.media:jai-core:1.1.3"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: javax.media:jai-codec:1.1.3"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.jogl:jogl-all:2.1.5-01"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.jogl:jogl-all-natives-linux-amd64:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.jogl:jogl-all-natives-linux-i586:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.jogl:jogl-all-natives-macosx-universal:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.jogl:jogl-all-natives-windows-amd64:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.jogl:jogl-all-natives-windows-i586:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.gluegen:gluegen-rt:2.1.5-01"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.gluegen:gluegen-rt-natives-linux-amd64:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.gluegen:gluegen-rt-natives-linux-i586:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.gluegen:gluegen-rt-natives-macosx-universal:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.gluegen:gluegen-rt-natives-windows-amd64:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.jogamp.gluegen:gluegen-rt-natives-windows-i586:2.1.5"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.javassist:javassist:3.22.0-GA"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: net.sourceforge.jexcelapi:jxl:2.6.12"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: log4j:log4j:1.2.14"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.swinglabs.swingx:swingx-all:1.6.5-1"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.bioimageanalysis.icy:icy-blocks:1.0.1"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.bioimageanalysis.icy:icy-protocols:3.0.9"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.bioimageanalysis.icy:icy-javadocparser:1.0.0"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: com.nativelibs4java:ochafik-util:0.12"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/Maven: org.bioimageanalysis.icy:icy-ezplug:3.15.13"/>
+ <classpathentry kind="output" path="target/classes"/>
</classpath>
diff --git a/.gitignore b/.gitignore
index 88e283fbbe38edf75f524ead36b103a8eeb25e1a..4d6d26eb5c996073a0b63007cf16faee399b26cd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,8 @@
-bin
-*.jar
-
+.idea/
+.settings/
+build/
+target/
+*.iml
+*.eml
+.classpath
+.project
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..ff1742542d6363c006ec70520db33f20b37886d0
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <groupId>org.bioimageanalysis.icy</groupId>
+ <artifactId>icy-sequence-blocks</artifactId>
+ <version>2.0.14</version>
+
+ <packaging>jar</packaging>
+
+ <name>SequenceBlocks</name>
+ <description>
+ This plugin allows one to use various basic sequence operations within Blocks.
+ </description>
+
+ <properties>
+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+ <jdk.version>1.8</jdk.version>
+
+ <maven.compiler.source>1.8</maven.compiler.source>
+ <maven.compiler.target>1.8</maven.compiler.target>
+
+ <outputJar>${project.build.outputDirectory}/../plugin</outputJar>
+ </properties>
+
+ <build>
+ <finalName>${project.artifactId}</finalName>
+
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-jar-plugin</artifactId>
+ <version>3.1.2</version>
+ <configuration>
+ <outputDirectory>${outputJar}</outputDirectory>
+ <archive>
+ <manifest>
+ <addClasspath>true</addClasspath>
+ <mainClass>plugins.tprovoost.sequenceblocks.SequenceBlocks</mainClass>
+ </manifest>
+ </archive>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.bioimageanalysis.icy</groupId>
+ <artifactId>icy-kernel</artifactId>
+ <version>2.1.0</version>
+ </dependency>
+ <dependency>
+ <groupId>org.bioimageanalysis.icy</groupId>
+ <artifactId>icy-blocks</artifactId>
+ <version>1.0.1</version>
+ </dependency>
+ </dependencies>
+
+ <repositories>
+ <repository>
+ <id>icy</id>
+ <url>https://icy-nexus.pasteur.fr/repository/Icy/</url>
+ </repository>
+ </repositories>
+
+ <distributionManagement>
+ <snapshotRepository>
+ <id>icy-dev</id>
+ <name>icy-dev</name>
+ <url>https://icy-nexus-dev.pasteur.cloud/repository/icy-core/</url>
+ </snapshotRepository>
+ <repository>
+ <id>icy-prod</id>
+ <name>icy-prod</name>
+ <url>https://icy-nexus.pasteur.fr/repository/icy-core/</url>
+ </repository>
+ </distributionManagement>
+
+</project>
\ No newline at end of file
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/SequenceBlocks.java b/src/main/java/plugins/tprovoost/sequenceblocks/SequenceBlocks.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a194ff3f2e713996cbec739d8681a9f72cc710c
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/SequenceBlocks.java
@@ -0,0 +1,16 @@
+package plugins.tprovoost.sequenceblocks;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginLibrary;
+
+/**
+ * This class is used as a main class for all the blocks contained in this
+ * package. Each Block has a specified dedicated purpose. More documentation on
+ * the concerned files.
+ *
+ * @author thomasprovoost
+ */
+public class SequenceBlocks extends Plugin implements PluginLibrary
+{
+ //
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/add/AddOverlays.java b/src/main/java/plugins/tprovoost/sequenceblocks/add/AddOverlays.java
new file mode 100644
index 0000000000000000000000000000000000000000..4251b970849bbe310e71ff4160b4fbf00e20e712
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/add/AddOverlays.java
@@ -0,0 +1,79 @@
+package plugins.tprovoost.sequenceblocks.add;
+
+import icy.painter.Overlay;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to add one or several {@link Overlay} to a Sequence
+ *
+ * @author Stephane
+ */
+public class AddOverlays extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarArray<Overlay> overlays = new VarArray<Overlay>("Overlay(s)", Overlay[].class, new Overlay[0])
+ {
+ @Override
+ public String getValueAsString()
+ {
+ final Overlay[] value = getValue();
+
+ if (value == null || value.length == 0)
+ return "No overlay";
+
+ return value.length + " overlay";
+ }
+ };
+
+ @Override
+ public void run()
+ {
+ final Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ final Overlay[] o = overlays.getValue();
+ if (o != null)
+ {
+ s.beginUpdate();
+ try
+ {
+ for (Overlay overlay : o)
+ s.addOverlay(overlay);
+ }
+ finally
+ {
+ s.endUpdate();
+ }
+ }
+
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("overlay(s)", overlays);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/add/AddRois.java b/src/main/java/plugins/tprovoost/sequenceblocks/add/AddRois.java
new file mode 100644
index 0000000000000000000000000000000000000000..cbf26c84a61aa965af654edd9d7f4973873a6d8e
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/add/AddRois.java
@@ -0,0 +1,63 @@
+package plugins.tprovoost.sequenceblocks.add;
+
+import java.util.Arrays;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to add one or several {@link ROI} to a Sequence
+ *
+ * @author Stephane
+ */
+public class AddRois extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarROIArray rois = new VarROIArray("Roi(s)");
+ final protected VarBoolean removePrevious = new VarBoolean("Remove previous", Boolean.FALSE);
+
+ @Override
+ public void run()
+ {
+ final Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ if (removePrevious.getValue().booleanValue())
+ s.removeAllROI();
+
+ final ROI[] r = rois.getValue();
+ if (r != null)
+ s.addROIs(Arrays.asList(r), false);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("rois(s)", rois);
+ inputMap.add("remove", removePrevious);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/convert/ConvertColor.java b/src/main/java/plugins/tprovoost/sequenceblocks/convert/ConvertColor.java
new file mode 100644
index 0000000000000000000000000000000000000000..3347c0383581322dec8dd49b53031d25eea44751
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/convert/ConvertColor.java
@@ -0,0 +1,131 @@
+package plugins.tprovoost.sequenceblocks.convert;
+
+import java.awt.image.BufferedImage;
+
+import icy.image.IcyBufferedImageUtil;
+import icy.image.lut.LUT;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import icy.util.OMEUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarEnum;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to render a given Sequence using a specific LUT.<br>
+ * The result can be provided ARGB, RGB or GRAY sequence.
+ *
+ * @author Stephane
+ */
+public class ConvertColor extends Plugin implements SequenceBlock, PluginBundled
+{
+ public static enum ColorConversion
+ {
+ GRAY, RGB, ARGB;
+ };
+
+ final protected VarSequence EZseq = new VarSequence("Sequence", null);
+ final protected VarEnum<ColorConversion> EZtype = new VarEnum<ColorConversion>("Conversion", ColorConversion.ARGB);
+ final protected Var<LUT> EZlut = new Var<LUT>("Lut", LUT.class);
+ final protected VarSequence varOut = new VarSequence("Out", null);
+
+ @Override
+ public void run()
+ {
+ Sequence s;
+
+ // EZ PLUG
+ s = EZseq.getValue();
+ if (s == null)
+ throw new VarException(EZseq, "Input sequence is null.");
+
+ varOut.setValue(convertColor(s, getImageType(EZtype.getValue()), EZlut.getValue()));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("Sequence", EZseq);
+ inputMap.add("Conversion", EZtype);
+ inputMap.add("Lut", EZlut);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("Out", varOut);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+
+ public static int getImageType(ColorConversion value)
+ {
+ switch (value)
+ {
+ default:
+ case ARGB:
+ return BufferedImage.TYPE_INT_ARGB;
+
+ case RGB:
+ return BufferedImage.TYPE_INT_RGB;
+
+ case GRAY:
+ return BufferedImage.TYPE_BYTE_GRAY;
+ }
+ }
+
+ public static Sequence convertColor(Sequence source, int imageType, LUT lut)
+ {
+ final Sequence result = new Sequence(OMEUtil.createOMEXMLMetadata(source.getOMEXMLMetadata()));
+ // image receiver
+ final BufferedImage imgOut = new BufferedImage(source.getSizeX(), source.getSizeY(), imageType);
+
+ result.beginUpdate();
+ try
+ {
+ for (int t = 0; t < source.getSizeT(); t++)
+ for (int z = 0; z < source.getSizeZ(); z++)
+ result.setImage(t, z, IcyBufferedImageUtil.toBufferedImage(source.getImage(t, z), imgOut, lut));
+
+ // rename channels and set final name
+ switch (imageType)
+ {
+ default:
+ case BufferedImage.TYPE_INT_ARGB:
+ result.setChannelName(0, "red");
+ result.setChannelName(1, "green");
+ result.setChannelName(2, "blue");
+ result.setChannelName(3, "alpha");
+ result.setName(source.getName() + " (ARGB rendering)");
+ break;
+
+ case BufferedImage.TYPE_INT_RGB:
+ result.setChannelName(0, "red");
+ result.setChannelName(1, "green");
+ result.setChannelName(2, "blue");
+ result.setName(source.getName() + " (RGB rendering)");
+ break;
+
+ case BufferedImage.TYPE_BYTE_GRAY:
+ result.setChannelName(0, "gray");
+ result.setName(source.getName() + " (gray rendering)");
+ break;
+ }
+ }
+ finally
+ {
+ result.endUpdate();
+ }
+
+ return result;
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/convert/ConvertStack.java b/src/main/java/plugins/tprovoost/sequenceblocks/convert/ConvertStack.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7dbfdcaff0953815304a16d920bcecffe335b6a
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/convert/ConvertStack.java
@@ -0,0 +1,63 @@
+package plugins.tprovoost.sequenceblocks.convert;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarEnum;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class ConvertStack extends Plugin implements SequenceBlock, PluginBundled
+{
+ public static enum TypeConversion
+ {
+ STACK, TIME
+ };
+
+ final protected VarEnum<TypeConversion> type = new VarEnum<TypeConversion>("Type Wanted", TypeConversion.STACK);
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarSequence outputSequence = new VarSequence("Out", null);
+
+ @Override
+ public void run()
+ {
+ Sequence in = inputSequence.getValue();
+ if (in == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ // create a copy as we don't want to modify input
+ Sequence out = SequenceUtil.getCopy(in);
+ if (type.getValue() == TypeConversion.TIME)
+ SequenceUtil.convertToTime(out);
+ else
+ SequenceUtil.convertToStack(out);
+ outputSequence.setValue(out);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("Type Wanted", type);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("out", outputSequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/convert/ConvertType.java b/src/main/java/plugins/tprovoost/sequenceblocks/convert/ConvertType.java
new file mode 100644
index 0000000000000000000000000000000000000000..0ec910c079fb9de5b9768bfaf77ce9a819140c9a
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/convert/ConvertType.java
@@ -0,0 +1,57 @@
+package plugins.tprovoost.sequenceblocks.convert;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import icy.type.DataType;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarEnum;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class ConvertType extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarEnum<DataType> type = new VarEnum<DataType>("Type Wanted", DataType.UBYTE);
+ final protected VarSequence inputSequence = new VarSequence("sequence", null);
+ final protected VarSequence outputSequence = new VarSequence("converted", null);
+ final protected VarBoolean rescale = new VarBoolean("Rescale", Boolean.TRUE);
+
+ @Override
+ public void run()
+ {
+ Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ outputSequence.setValue(SequenceUtil.convertToType(s, type.getValue(), rescale.getValue().booleanValue()));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("Type Wanted", type);
+ inputMap.add("Rescale", rescale);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("converted", outputSequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/convert/Resize.java b/src/main/java/plugins/tprovoost/sequenceblocks/convert/Resize.java
new file mode 100644
index 0000000000000000000000000000000000000000..b222d0f51980e8838a83101c485c9a8b8ae8a1a2
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/convert/Resize.java
@@ -0,0 +1,92 @@
+package plugins.tprovoost.sequenceblocks.convert;
+
+import icy.image.IcyBufferedImageUtil.FilterType;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+
+import javax.swing.SwingConstants;
+
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarEnum;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+public class Resize extends Plugin implements SequenceBlock, PluginBundled
+{
+ protected enum Proportional
+ {
+ NO, TO_WIDTH, TO_HEIGHT
+ };
+
+ final protected VarSequence EZseq = new VarSequence("Sequence", null);
+ final protected VarInteger EZsizew = new VarInteger("Width", 320);
+ final protected VarInteger EZsizeh = new VarInteger("Height", 200);
+ final protected VarEnum<Proportional> EZproportional = new VarEnum<Proportional>("Proportional", Proportional.NO);
+ final protected VarBoolean EZscale = new VarBoolean("Scale content", Boolean.TRUE);
+ final protected VarEnum<FilterType> EZtype = new VarEnum<FilterType>("Filter", FilterType.BICUBIC);
+ final protected VarSequence varOut = new VarSequence("Out", null);
+
+ @Override
+ public void run()
+ {
+ Sequence s;
+ int w, h;
+ FilterType type;
+
+ // EZ PLUG
+ s = EZseq.getValue();
+ w = EZsizew.getValue().intValue();
+ h = EZsizeh.getValue().intValue();
+ type = EZtype.getValue();
+
+ if (s == null || w <= 0 || h <= 0)
+ throw new VarException(null, "No sequence chosen for resize, or wrong size.");
+
+ double scale = 1d * s.getWidth() / s.getHeight();
+ switch (EZproportional.getValue())
+ {
+ case NO:
+ break;
+ case TO_WIDTH:
+ h = (int) (w / scale);
+ break;
+ case TO_HEIGHT:
+ w = (int) (scale * h);
+ break;
+ }
+
+ if (EZscale.getValue().booleanValue())
+ varOut.setValue(SequenceUtil.scale(s, w, h, type));
+ else
+ varOut.setValue(SequenceUtil.scale(s, w, h, false, SwingConstants.CENTER, SwingConstants.CENTER, type));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("Sequence", EZseq);
+ inputMap.add("Width", EZsizew);
+ inputMap.add("Height", EZsizeh);
+ inputMap.add("Proportional", EZproportional);
+ inputMap.add("Filter", EZtype);
+ inputMap.add("Scale content", EZscale);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("Out", varOut);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/creation/CombineChannels.java b/src/main/java/plugins/tprovoost/sequenceblocks/creation/CombineChannels.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1fc9e1f6ab9986312da533bd14eb6995e3d58a7
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/creation/CombineChannels.java
@@ -0,0 +1,89 @@
+package plugins.tprovoost.sequenceblocks.creation;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarIntegerArrayNative;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class CombineChannels extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence 1", null);
+ final protected VarSequence inputSequence2 = new VarSequence("Sequence 2", null);
+ final protected VarSequence outputSequence = new VarSequence("Merged", null);
+ final protected VarIntegerArrayNative channelIdx = new VarIntegerArrayNative("Channel(s) 1", new int[] {0});
+ final protected VarIntegerArrayNative channelIdx2 = new VarIntegerArrayNative("Channel(s) 2", new int[] {0});
+ final protected VarBoolean fillStackHole = new VarBoolean("Fill stack hole", Boolean.TRUE);
+ final protected VarBoolean fitToMaxSize = new VarBoolean("Fit to max size", Boolean.TRUE);
+
+ @Override
+ public void run()
+ {
+ Sequence s = inputSequence.getValue();
+ Sequence s2 = inputSequence2.getValue();
+
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence 1 is null.");
+ if (s2 == null)
+ throw new VarException(inputSequence2, "Input sequence 2 is null.");
+
+ int[] channels1 = channelIdx.getValue();
+ int[] channels2 = channelIdx2.getValue();
+ int sizeC1 = channels1.length;
+ int sizeC2 = channels2.length;
+
+ // Because of concatC, it is necessary to create a sequence[] and int[] of the same size,
+ // and duplicate the sequence as many times in the first as necessary.
+ Sequence[] sequences = new Sequence[sizeC1 + sizeC2];
+ int channels[] = new int[sizeC1 + sizeC2];
+
+ for (int i = 0; i < sizeC1; ++i)
+ {
+ sequences[i] = s;
+ channels[i] = channels1[i];
+ }
+ for (int i = 0; i < sizeC2; ++i)
+ {
+ sequences[sizeC1 + i] = s2;
+ channels[sizeC1 + i] = channels2[i];
+ }
+
+ final Sequence res = SequenceUtil.concatC(sequences, channels, fillStackHole.getValue().booleanValue(),
+ fitToMaxSize.getValue().booleanValue(), null);
+
+ outputSequence.setValue(res);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence 1", inputSequence);
+ inputMap.add("Channel 1", channelIdx);
+ inputMap.add("sequence 2", inputSequence2);
+ inputMap.add("Channel 2", channelIdx2);
+ inputMap.add("fit to max size", fitToMaxSize);
+ inputMap.add("fill stack hole", fillStackHole);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("out", outputSequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/creation/CreateSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/creation/CreateSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..a133b94e6c608e5d912586d90084bed0b526f516
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/creation/CreateSequence.java
@@ -0,0 +1,45 @@
+package plugins.tprovoost.sequenceblocks.creation;
+
+import icy.image.IcyBufferedImage;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class CreateSequence extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<IcyBufferedImage> in = new Var<IcyBufferedImage>("image (optional)", IcyBufferedImage.class);
+ final protected VarSequence out = new VarSequence("sequence", null);
+
+ @Override
+ public void run()
+ {
+ out.setValue(new Sequence(in.getValue()));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("image (optional)", in);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("sequence", out);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/creation/DuplicateSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/creation/DuplicateSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..3379d9d69b177f8b4042ec975f642ec13eb76161
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/creation/DuplicateSequence.java
@@ -0,0 +1,48 @@
+package plugins.tprovoost.sequenceblocks.creation;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class DuplicateSequence extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence in = new VarSequence("sequence", null);
+ final protected VarSequence out = new VarSequence("duplicated", null);
+
+ @Override
+ public void run()
+ {
+ Sequence s = in.getValue();
+ if (s == null)
+ throw new VarException(in, "Input Sequence is null.");
+ out.setValue(SequenceUtil.getCopy(s));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", in);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("duplicated", out);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/extract/CropCZT.java b/src/main/java/plugins/tprovoost/sequenceblocks/extract/CropCZT.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ffa86cedabf80fd2f6c2df656f67a8e267010bb
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/extract/CropCZT.java
@@ -0,0 +1,84 @@
+package plugins.tprovoost.sequenceblocks.extract;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import icy.type.rectangle.Rectangle5D;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+public class CropCZT extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSeq = new VarSequence("Sequence", null);
+ final protected VarInteger varStartC = new VarInteger("Start index C", 0);
+ final protected VarInteger varSizeC = new VarInteger("Size C", 1);
+ final protected VarInteger varStartZ = new VarInteger("Start index Z", 0);
+ final protected VarInteger varSizeZ = new VarInteger("Size Z", 1);
+ final protected VarInteger varStartT = new VarInteger("Start index T", 0);
+ final protected VarInteger varSizeT = new VarInteger("Size T", 1);
+ final protected VarSequence varOut = new VarSequence("Out", null);
+
+ @Override
+ public void run()
+ {
+ final Sequence seq;
+ final int startX, sizeX;
+ final int startY, sizeY;
+ final int startC, sizeC;
+ final int startZ, sizeZ;
+ final int startT, sizeT;
+
+ // EZ PLUG
+ seq = varSeq.getValue();
+
+ if (seq == null)
+ throw new VarException(varSeq, "No sequence chosen !");
+
+ startC = Math.min(varStartC.getValue().intValue(), seq.getSizeC() - 1);
+ sizeC = Math.min(varSizeC.getValue().intValue(), seq.getSizeC() - startC);
+ startZ = Math.min(varStartZ.getValue().intValue(), seq.getSizeZ() - 1);
+ sizeZ = Math.min(varSizeZ.getValue().intValue(), seq.getSizeZ() - startZ);
+ startT = Math.min(varStartT.getValue().intValue(), seq.getSizeT() - 1);
+ sizeT = Math.min(varSizeT.getValue().intValue(), seq.getSizeT() - startT);
+
+ startX = 0;
+ sizeX = seq.getSizeX();
+ startY = 0;
+ sizeY = seq.getSizeY();
+
+ if ((sizeC <= 0) || (sizeZ <= 0) || (sizeT <= 0))
+ throw new VarException(null, "Size C/Z/T cannot be <= 0 !");
+
+ varOut.setValue(SequenceUtil.getSubSequence(seq,
+ new Rectangle5D.Integer(startX, startY, startZ, startT, startC, sizeX, sizeY, sizeZ, sizeT, sizeC)));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("Sequence", varSeq);
+ inputMap.add("Start index C", varStartC);
+ inputMap.add("Size C", varSizeC);
+ inputMap.add("Start index Z", varStartZ);
+ inputMap.add("Size Z", varSizeZ);
+ inputMap.add("Start index T", varStartT);
+ inputMap.add("Size T", varSizeT);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("Out", varOut);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/extract/CropSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/extract/CropSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..8379e58ac9ea4c6463923fd0a91c39de50fc4176
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/extract/CropSequence.java
@@ -0,0 +1,84 @@
+package plugins.tprovoost.sequenceblocks.extract;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import icy.roi.ROIUtil;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import icy.type.collection.CollectionUtil;
+import icy.util.ShapeUtil.BooleanOperator;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarMutable;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class CropSequence extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ VarMutable inputROIs = new VarMutable("ROI(s)", null)
+ {
+ @Override
+ public boolean isAssignableFrom(@SuppressWarnings("rawtypes") Var source)
+ {
+ return (ROI.class == source.getType()) || (ROI[].class == source.getType());
+ }
+ };
+ final protected VarSequence outputSequence = new VarSequence("Cropped", null);
+
+ @Override
+ public void run()
+ {
+ outputSequence.setValue(null);
+
+ final Sequence s = inputSequence.getValue();
+ if (s == null)
+ return;
+
+ final Object obj = inputROIs.getValue();
+ if (obj == null)
+ return;
+
+ final List<ROI> rois;
+
+ if (obj instanceof ROI)
+ {
+ rois = new ArrayList<ROI>();
+ rois.add((ROI) obj);
+ }
+ else
+ rois = CollectionUtil.asList((ROI[]) obj);
+
+ final ROI roi = ROIUtil.merge(rois, BooleanOperator.OR);
+
+ outputSequence.setValue(SequenceUtil.getSubSequence(s, roi));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("roi", inputROIs);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("cropped", outputSequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractChannel.java b/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractChannel.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ed5c38a906119a45c9443916dcbc0f64b407303
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractChannel.java
@@ -0,0 +1,59 @@
+package plugins.tprovoost.sequenceblocks.extract;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class ExtractChannel extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarSequence outputSequence = new VarSequence("Extracted", null);
+ final protected VarInteger channelIdx = new VarInteger("Channel", 0);
+
+ @Override
+ public void run()
+ {
+ final Sequence s = inputSequence.getValue();
+ final int channel = channelIdx.getValue().intValue();
+
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+ if (channel < 0 || channel >= s.getSizeC())
+ throw new VarException(channelIdx, "Channel index must be between 0 and " + (s.getSizeC() - 1));
+
+ final Sequence res = SequenceUtil.extractChannel(s, channelIdx.getValue().intValue());
+ res.setName(s.getName() + " - channel: " + channelIdx.getValue());
+
+ outputSequence.setValue(res);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("channel", channelIdx);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("extracted", outputSequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractMultiChannels.java b/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractMultiChannels.java
new file mode 100644
index 0000000000000000000000000000000000000000..56f892e270db6be695126a830ba2288a3c6fd34c
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractMultiChannels.java
@@ -0,0 +1,53 @@
+package plugins.tprovoost.sequenceblocks.extract;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarIntegerArrayNative;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class ExtractMultiChannels extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarSequence outputSequence = new VarSequence("Extracted", null);
+ final protected VarIntegerArrayNative channelIdx = new VarIntegerArrayNative("Channel(s)", new int[] {0});
+
+ @Override
+ public void run()
+ {
+ Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+ Sequence res = SequenceUtil.extractChannels(s, channelIdx.getValue());
+ res.setName(s.getName() + " - channel: " + channelIdx.getValue());
+ outputSequence.setValue(res);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("Channel", channelIdx);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("extracted", outputSequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractSlice.java b/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractSlice.java
new file mode 100644
index 0000000000000000000000000000000000000000..d579387491349753cca9cd09c52da5f1251b42ff
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractSlice.java
@@ -0,0 +1,52 @@
+package plugins.tprovoost.sequenceblocks.extract;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class ExtractSlice extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarSequence outputSequence = new VarSequence("Extracted", null);
+ final protected VarInteger chosenZ = new VarInteger("Z", 0);
+
+ @Override
+ public void run()
+ {
+ Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+ Sequence extracted = SequenceUtil.extractSlice(s, chosenZ.getValue().intValue());
+ outputSequence.setValue(extracted);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("Z pos", chosenZ);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("extracted", outputSequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractTime.java b/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractTime.java
new file mode 100644
index 0000000000000000000000000000000000000000..67004582a278dc3e3a131b459f585dd3240ee3d9
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/extract/ExtractTime.java
@@ -0,0 +1,52 @@
+package plugins.tprovoost.sequenceblocks.extract;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class ExtractTime extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarSequence outputSequence = new VarSequence("Extracted", null);
+ final protected VarInteger chosenT = new VarInteger("T", 0);
+
+ @Override
+ public void run()
+ {
+ Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+ Sequence extracted = SequenceUtil.extractFrame(s, chosenT.getValue().intValue());
+ outputSequence.setValue(extracted);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("T pos", chosenT);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("extracted", outputSequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/files/IsFileValid.java b/src/main/java/plugins/tprovoost/sequenceblocks/files/IsFileValid.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b250ea63ee1f64ff2098b761f9ae3420856928f
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/files/IsFileValid.java
@@ -0,0 +1,67 @@
+package plugins.tprovoost.sequenceblocks.files;
+
+import java.io.File;
+
+import icy.file.Loader;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarMutable;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to know if a file represents an image file
+ *
+ * @author Stephane
+ */
+public class IsFileValid extends Plugin implements PluginLibrary, SequenceBlock, PluginBundled
+{
+ final protected VarMutable f_in = new VarMutable("File", null)
+ {
+ @Override
+ public boolean isAssignableFrom(@SuppressWarnings("rawtypes") Var source)
+ {
+ return String.class == source.getType() || File.class == source.getType();
+ }
+ };
+ final protected VarBoolean result = new VarBoolean("Valid", Boolean.FALSE);
+
+ @Override
+ public void run()
+ {
+ final Object obj = f_in.getValue();
+ if (obj != null)
+ {
+ final File f;
+
+ if (obj instanceof String)
+ f = new File((String) obj);
+ else
+ f = (File) obj;
+
+ result.setValue(Boolean.valueOf(Loader.isSupportedImageFile(f.getAbsolutePath())));
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("file", f_in);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("valid", result);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/files/LoadMetadata.java b/src/main/java/plugins/tprovoost/sequenceblocks/files/LoadMetadata.java
new file mode 100644
index 0000000000000000000000000000000000000000..18d6f4f772b5345e9bc3a93cac28576b594cf0eb
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/files/LoadMetadata.java
@@ -0,0 +1,85 @@
+package plugins.tprovoost.sequenceblocks.files;
+
+import java.io.File;
+
+import icy.file.Loader;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.MetaDataUtil;
+import ome.xml.meta.OMEXMLMetadata;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarMutable;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to load Sequence metadata from a file
+ *
+ * @author Stephane
+ */
+public class LoadMetadata extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarMutable f_in = new VarMutable("File", null)
+ {
+ @Override
+ public boolean isAssignableFrom(@SuppressWarnings("rawtypes") Var source)
+ {
+ return (String.class == source.getType()) || (File.class == source.getType());
+ }
+ };
+ final protected Var<OMEXMLMetadata> output = new Var<OMEXMLMetadata>("Metadata", OMEXMLMetadata.class);
+ final protected VarInteger numSerie = new VarInteger("Series number", 1);
+
+ @Override
+ public void run()
+ {
+ final Object obj = f_in.getValue();
+ if (obj != null)
+ {
+ final File f;
+
+ if (obj instanceof String)
+ f = new File((String) obj);
+ else
+ f = (File) obj;
+
+ try
+ {
+ final OMEXMLMetadata meta = Loader.getOMEXMLMetaData(f.getAbsolutePath());
+
+ if (meta != null)
+ {
+ output.setValue(meta);
+ numSerie.setValue(Integer.valueOf(MetaDataUtil.getNumSeries(meta)));
+ }
+ }
+ catch (Exception e)
+ {
+ throw new VarException(null, e.getMessage());
+ }
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("file", f_in);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("Metadata", output);
+ outputMap.add("Serie number", numSerie);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/files/LoadSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/files/LoadSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..a0135c26ff104affc10665ff975f57d31dca0090
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/files/LoadSequence.java
@@ -0,0 +1,74 @@
+package plugins.tprovoost.sequenceblocks.files;
+
+import java.io.File;
+
+import icy.file.Loader;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarMutable;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to load a Sequence from a file
+ *
+ * @author Stephane
+ */
+public class LoadSequence extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarMutable f_in = new VarMutable("File", null)
+ {
+ @Override
+ public boolean isAssignableFrom(@SuppressWarnings("rawtypes") Var source)
+ {
+ return (String.class == source.getType()) || (File.class == source.getType());
+ }
+ };
+ final protected VarInteger serie_in = new VarInteger("Series", 0);
+ final protected VarSequence outputSequence = new VarSequence("Sequence", null);
+
+ @Override
+ public void run()
+ {
+ final Object obj = f_in.getValue();
+ if (obj != null)
+ {
+ final File f;
+
+ if (obj instanceof String)
+ f = new File((String) obj);
+ else
+ f = (File) obj;
+
+ // if (f.isDirectory())
+ // throw new VarException("file should not be a directory.");
+
+ outputSequence.setValue(Loader.loadSequence(f.getAbsolutePath(), serie_in.getValue().intValue(), false));
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("file", f_in);
+ inputMap.add("serie", serie_in);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("sequence", outputSequence);
+
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/files/LoadSubSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/files/LoadSubSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..27861d6e9ba7ff4355f2378d207eef31e5495789
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/files/LoadSubSequence.java
@@ -0,0 +1,137 @@
+package plugins.tprovoost.sequenceblocks.files;
+
+import java.io.File;
+
+import icy.file.Loader;
+import icy.file.SequenceFileImporter;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import plugins.adufour.blocks.tools.io.IOBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarMutable;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to returns a Sequence with the given parameters from the specified closed) SequenceFileImporter.
+ *
+ * @author Stephane
+ */
+public class LoadSubSequence extends Plugin implements IOBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<SequenceFileImporter> importer;
+ final protected VarMutable file;
+ final protected VarInteger series;
+ final protected VarInteger resolution;
+ final protected VarROIArray region;
+ final protected VarInteger minZIndex;
+ final protected VarInteger maxZIndex;
+ final protected VarInteger minTIndex;
+ final protected VarInteger maxTIndex;
+ final protected VarInteger cIndex;
+ final protected VarBoolean showProgress;
+
+ final protected VarSequence sequence;
+
+ public LoadSubSequence()
+ {
+ super();
+
+ importer = new Var<SequenceFileImporter>("Importer", SequenceFileImporter.class);
+ file = new VarMutable("File", null)
+ {
+ @Override
+ public boolean isAssignableFrom(@SuppressWarnings("rawtypes") Var source)
+ {
+ return (String.class == source.getType()) || (File.class == source.getType());
+ }
+ };
+ series = new VarInteger("Series", 0);
+ resolution = new VarInteger("Resolution (0=full, 1=1/2, ..)", 0);
+ region = new VarROIArray("XY region (ROI)", null);
+ minZIndex = new VarInteger("Z min (slice)", -1);
+ maxZIndex = new VarInteger("Z max (slice)", -1);
+ minTIndex = new VarInteger("T min (frame)", -1);
+ maxTIndex = new VarInteger("T max (frame)", -1);
+ cIndex = new VarInteger("C (channel) index", -1);
+ showProgress = new VarBoolean("Show progress", Boolean.FALSE);
+
+ sequence = new VarSequence("Sequence", null);
+ }
+
+ @Override
+ public void run()
+ {
+ final String path;
+ final Object obj = file.getValue();
+
+ if (obj != null)
+ {
+ if (obj instanceof String)
+ path = (String) obj;
+ else
+ path = ((File) obj).getAbsolutePath();
+ }
+ else
+ throw new VarException(file, "File is null !");
+
+ // here importer can be null so we don't test for it
+ final SequenceFileImporter imp = importer.getValue();
+ final int s = series.getValue().intValue();
+ final int r = resolution.getValue().intValue();
+ final ROI[] rois = region.getValue();
+ final ROI roi = ((rois != null) && (rois.length > 0)) ? rois[0] : null;
+ final int minZ = minZIndex.getValue().intValue();
+ final int maxZ = maxZIndex.getValue().intValue();
+ final int minT = minTIndex.getValue().intValue();
+ final int maxT = maxTIndex.getValue().intValue();
+ final int c = cIndex.getValue().intValue();
+ final boolean progress = showProgress.getValue().booleanValue();
+
+ try
+ {
+ sequence.setValue(Loader.loadSequence(imp, path, s, r,
+ (roi != null) ? roi.getBounds5D().toRectangle2D().getBounds() : null, minZ, maxZ, minT, maxT, c,
+ false, progress));
+ }
+ catch (Exception e)
+ {
+ throw new VarException(importer, e.getMessage());
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("file", file);
+ inputMap.add("importer", importer);
+ inputMap.add("series", series);
+ inputMap.add("resolution", resolution);
+ inputMap.add("region", region);
+ inputMap.add("minZ", minZIndex);
+ inputMap.add("maxZ", maxZIndex);
+ inputMap.add("minT", minTIndex);
+ inputMap.add("maxT", maxTIndex);
+ inputMap.add("cIndex", cIndex);
+ inputMap.add("showProgress", showProgress);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("sequence", sequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/files/SaveMetadata.java b/src/main/java/plugins/tprovoost/sequenceblocks/files/SaveMetadata.java
new file mode 100644
index 0000000000000000000000000000000000000000..da349443a7c1a076f753fa90ce8357d351de78aa
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/files/SaveMetadata.java
@@ -0,0 +1,51 @@
+package plugins.tprovoost.sequenceblocks.files;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to save Sequence metadata
+ *
+ * @author Stephane
+ */
+public class SaveMetadata extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence sequence = new VarSequence("Sequence", null);
+ final protected VarBoolean success = new VarBoolean("Success", Boolean.FALSE);
+
+ @Override
+ public void run()
+ {
+ Sequence s = sequence.getValue();
+ if (s == null)
+ throw new VarException(sequence, "Sequence is null");
+
+ success.setValue(Boolean.valueOf(s.saveXMLData()));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", sequence);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("success", success);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/files/SaveSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/files/SaveSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..98e0a217d376abab46e8ca183f7d8d76f60cf758
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/files/SaveSequence.java
@@ -0,0 +1,98 @@
+package plugins.tprovoost.sequenceblocks.files;
+
+import java.io.File;
+
+import icy.file.FileUtil;
+import icy.file.ImageFileFormat;
+import icy.file.Saver;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarEnum;
+import plugins.adufour.vars.lang.VarMutable;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to save a Sequence into a file
+ *
+ * @author Stephane
+ */
+public class SaveSequence extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarMutable f_in = new VarMutable("File", null)
+ {
+ @Override
+ public boolean isAssignableFrom(@SuppressWarnings("rawtypes") Var source)
+ {
+ return String.class == source.getType() || File.class == source.getType();
+ }
+ };
+ final protected VarBoolean overwriteForce = new VarBoolean("Overwrite", Boolean.TRUE);
+ final protected VarBoolean multipleFile = new VarBoolean("Multiple file", Boolean.FALSE);
+ final protected VarSequence sequence = new VarSequence("Sequence", null);
+ final protected VarEnum<ImageFileFormat> format = new VarEnum<ImageFileFormat>("Format", ImageFileFormat.TIFF);
+
+ @Override
+ public void run()
+ {
+ final Sequence seq = sequence.getValue();
+
+ if (seq != null)
+ {
+ final Object obj = f_in.getValue();
+
+ if (obj != null)
+ {
+ String path;
+
+ if (obj instanceof String)
+ path = (String) obj;
+ else
+ path = ((File) obj).getAbsolutePath();
+
+ if (FileUtil.isDirectory(path))
+ path += FileUtil.separator + FileUtil.getFileName(seq.getOutputFilename(false));
+
+ // force extension depending file format
+ path = FileUtil.setExtension(path, "." + format.getValue().getExtensions()[0]);
+
+ // cannot overwrite ??
+ if (FileUtil.exists(path) && !overwriteForce.getValue().booleanValue())
+ throw new VarException(f_in,
+ "File already exists. If you want to overwrite, please check the \"overwrite\" field.");
+
+ // save sequence
+ Saver.save(seq, new File(path), multipleFile.getValue().booleanValue(), false);
+ }
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("file", f_in);
+ inputMap.add("sequence", sequence);
+ inputMap.add("format", format);
+ inputMap.add("overwrite", overwriteForce);
+ inputMap.add("multiple file", multipleFile);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/images/AddImage.java b/src/main/java/plugins/tprovoost/sequenceblocks/images/AddImage.java
new file mode 100644
index 0000000000000000000000000000000000000000..35c88c4382df3f77107de3bb9941afcc29644ffd
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/images/AddImage.java
@@ -0,0 +1,52 @@
+package plugins.tprovoost.sequenceblocks.images;
+
+import icy.image.IcyBufferedImage;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Add an image to the Sequence.
+ *
+ * @author thomasprovoost
+ */
+public class AddImage extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<IcyBufferedImage> in = new Var<IcyBufferedImage>("Image", IcyBufferedImage.class);
+ final protected VarSequence varSeq = new VarSequence("Sequence", null);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSeq.getValue();
+ if (s == null)
+ throw new VarException(varSeq, "Input sequence is null.");
+ s.addImage(in.getValue());
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSeq);
+ inputMap.add("image", in);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/images/AsImageArray.java b/src/main/java/plugins/tprovoost/sequenceblocks/images/AsImageArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..6179b1a66f700887799fc1cf7dab0f8cc0468865
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/images/AsImageArray.java
@@ -0,0 +1,51 @@
+package plugins.tprovoost.sequenceblocks.images;
+
+import icy.image.IcyBufferedImage;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Returns all images from the Sequence as an image array.
+ *
+ * @author thomasprovoost
+ */
+public class AsImageArray extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarArray<IcyBufferedImage> out = new VarArray<IcyBufferedImage>("Image array", IcyBufferedImage[].class, null);
+ final protected VarSequence varSeq = new VarSequence("Sequence", null);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSeq.getValue();
+ if (s == null)
+ throw new VarException(varSeq, "Input sequence is null.");
+ out.setValue(s.getAllImage().toArray(new IcyBufferedImage[0]));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSeq);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("image array", out);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/images/GetImage.java b/src/main/java/plugins/tprovoost/sequenceblocks/images/GetImage.java
new file mode 100644
index 0000000000000000000000000000000000000000..748afec03790b1bf400c205071f10a4999cf8aea
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/images/GetImage.java
@@ -0,0 +1,56 @@
+package plugins.tprovoost.sequenceblocks.images;
+
+import icy.image.IcyBufferedImage;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Get the image at the given [T,Z] position from the Sequence.
+ *
+ * @author thomasprovoost
+ */
+public class GetImage extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence varSeq = new VarSequence("Sequence", null);
+ final protected VarInteger imgIdxT = new VarInteger("T", -1);
+ final protected VarInteger imgIdxZ = new VarInteger("Z", -1);
+ final protected Var<IcyBufferedImage> out = new Var<IcyBufferedImage>("out", IcyBufferedImage.class);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSeq.getValue();
+ if (s == null)
+ throw new VarException(varSeq, "Input sequence is null.");
+ out.setValue(s.getImage(imgIdxT.getValue().intValue(), imgIdxZ.getValue().intValue()));
+ }
+
+ @Override
+ public void declareInput(final VarList inputMap)
+ {
+ inputMap.add("sequence", varSeq);
+ inputMap.add("Idx T", imgIdxT);
+ inputMap.add("Idx Z", imgIdxZ);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("out", out);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/images/RemoveImage.java b/src/main/java/plugins/tprovoost/sequenceblocks/images/RemoveImage.java
new file mode 100644
index 0000000000000000000000000000000000000000..1380a864c2f5bab815ef5cb69c66b4ff11c2d6a9
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/images/RemoveImage.java
@@ -0,0 +1,54 @@
+package plugins.tprovoost.sequenceblocks.images;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Remove an image from the Sequence.
+ *
+ * @author thomasprovoost
+ */
+public class RemoveImage extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ VarSequence varSeq = new VarSequence("Sequence", null);
+ VarInteger imgIdxT = new VarInteger("T", 0);
+ VarInteger imgIdxZ = new VarInteger("Z", 0);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSeq.getValue();
+ if (s == null)
+ throw new VarException(varSeq, "Input sequence is null !");
+
+ s.removeImage(imgIdxT.getValue().intValue(), imgIdxZ.getValue().intValue());
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSeq);
+ inputMap.add("Idx T", imgIdxT);
+ inputMap.add("Idx Z", imgIdxZ);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/images/SetImage.java b/src/main/java/plugins/tprovoost/sequenceblocks/images/SetImage.java
new file mode 100644
index 0000000000000000000000000000000000000000..b185d7d1c243fcdf156c856ddf008bf5968a3ee0
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/images/SetImage.java
@@ -0,0 +1,57 @@
+package plugins.tprovoost.sequenceblocks.images;
+
+import icy.image.IcyBufferedImage;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Set an image at the given [T,Z] position from the Sequence.
+ *
+ * @author thomasprovoost
+ */
+public class SetImage extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ Var<IcyBufferedImage> in = new Var<IcyBufferedImage>("Image", IcyBufferedImage.class);
+ VarSequence varSeq = new VarSequence("Sequence", null);
+ VarInteger imgIdxT = new VarInteger("T", 0);
+ VarInteger imgIdxZ = new VarInteger("Z", 0);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSeq.getValue();
+ if (s == null)
+ throw new VarException(varSeq, "Input sequence is null.");
+ s.setImage(imgIdxT.getValue().intValue(), imgIdxZ.getValue().intValue(), in.getValue());
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSeq);
+ inputMap.add("image", in);
+ inputMap.add("Idx T", imgIdxT);
+ inputMap.add("Idx Z", imgIdxZ);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/importer/PositionedSequenceFileImporter.java b/src/main/java/plugins/tprovoost/sequenceblocks/importer/PositionedSequenceFileImporter.java
new file mode 100644
index 0000000000000000000000000000000000000000..75a25a734560b0e221fe3677d94ec14f70b49e26
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/importer/PositionedSequenceFileImporter.java
@@ -0,0 +1,91 @@
+/**
+ *
+ */
+package plugins.tprovoost.sequenceblocks.importer;
+
+import java.awt.Rectangle;
+import java.io.IOException;
+
+import icy.common.exception.UnsupportedFormatException;
+import icy.file.SequenceFileImporter;
+import icy.sequence.MetaDataUtil;
+import ome.xml.meta.OMEXMLMetadata;
+
+/**
+ * This class allow to use a {@link SequenceFileImporter} while storing a current position information to make its usage
+ * more convenient with Protocols.
+ *
+ * @author Stephane
+ */
+public class PositionedSequenceFileImporter
+{
+ public SequenceFileImporter importer;
+ protected OMEXMLMetadata metadata;
+ public int s;
+ public int t;
+ public int z;
+ public int c;
+ public Rectangle xyRegion;
+
+ public PositionedSequenceFileImporter(SequenceFileImporter importer, OMEXMLMetadata metadata, int s, int t, int z,
+ int c, Rectangle xyRegion)
+ {
+ super();
+
+ this.importer = importer;
+ this.xyRegion = xyRegion;
+ this.metadata = metadata;
+ this.s = s;
+ this.t = t;
+ this.z = z;
+ this.c = c;
+ }
+
+ public PositionedSequenceFileImporter(SequenceFileImporter importer)
+ {
+ this(importer, null, -1, -1, -1, -1, null);
+ }
+
+ public PositionedSequenceFileImporter(PositionedSequenceFileImporter positionedImporter)
+ {
+ this(positionedImporter.importer, positionedImporter.metadata, positionedImporter.s, positionedImporter.t,
+ positionedImporter.z, positionedImporter.c, positionedImporter.xyRegion);
+ }
+
+ public OMEXMLMetadata getMetadata() throws UnsupportedFormatException, IOException
+ {
+ // not yet defined --> take it from importer if possible
+ if ((metadata == null) && (importer.getOpened() != null))
+ {
+ metadata = importer.getOMEXMLMetaData();
+ // clean the metadata
+ MetaDataUtil.clean(metadata);
+ }
+
+ return metadata;
+ }
+
+ @Override
+ public String toString()
+ {
+ String result;
+
+ if (importer != null)
+ result = importer.getClass().getSimpleName();
+ else
+ result = "No importer";
+
+ if (s != -1)
+ result += " S=" + s;
+ if (t != -1)
+ result += " T=" + t;
+ if (z != -1)
+ result += " Z=" + z;
+ if (c != -1)
+ result += " C=" + c;
+ if (xyRegion != null)
+ result += " XY=" + xyRegion;
+
+ return result;
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterClose.java b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterClose.java
new file mode 100644
index 0000000000000000000000000000000000000000..ccaa55b117d14f8adc510e572f5945f6e7bae6e3
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterClose.java
@@ -0,0 +1,63 @@
+package plugins.tprovoost.sequenceblocks.importer;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import plugins.adufour.blocks.tools.io.IOBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to close currently opened SequenceFileImporter.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterClose extends Plugin implements IOBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<PositionedSequenceFileImporter> importer;
+
+ public SequenceFileImporterClose()
+ {
+ super();
+
+ importer = new Var<PositionedSequenceFileImporter>("Importer", PositionedSequenceFileImporter.class);
+ }
+
+ @Override
+ public void run()
+ {
+ final PositionedSequenceFileImporter pi = importer.getValue();
+
+ if (pi == null)
+ throw new VarException(importer, "Importer is null !");
+
+ try
+ {
+ pi.importer.close();
+ }
+ catch (Exception e)
+ {
+ throw new VarException(importer, e.getMessage());
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("importer", importer);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetImage.java b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetImage.java
new file mode 100644
index 0000000000000000000000000000000000000000..3720a15cafe134f661fc1b06283f41292e2f9546
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetImage.java
@@ -0,0 +1,119 @@
+package plugins.tprovoost.sequenceblocks.importer;
+
+import java.awt.Rectangle;
+
+import icy.file.SequenceFileImporter;
+import icy.image.IcyBufferedImage;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import plugins.adufour.blocks.tools.io.IOBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to returns an image from the given parameters and opened SequenceFileImporter.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterGetImage extends Plugin implements IOBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<PositionedSequenceFileImporter> importer;
+ final protected VarInteger series;
+ final protected VarInteger resolution;
+ final protected VarROIArray region;
+ final protected VarInteger zIndex;
+ final protected VarInteger tIndex;
+ final protected VarInteger cIndex;
+
+ final protected Var<IcyBufferedImage> image;
+
+ public SequenceFileImporterGetImage()
+ {
+ super();
+
+ importer = new Var<PositionedSequenceFileImporter>("Importer", PositionedSequenceFileImporter.class);
+ series = new VarInteger("Series", 0);
+ resolution = new VarInteger("Resolution (0=full, 1=1/2, ..)", 0);
+ region = new VarROIArray("XY region (ROI)", null);
+ zIndex = new VarInteger("Z (slice) index", 0);
+ tIndex = new VarInteger("T (frame) index", 0);
+ cIndex = new VarInteger("C (channel) index", -1);
+
+ image = new Var<IcyBufferedImage>("Image", IcyBufferedImage.class);
+ }
+
+ @Override
+ public void run()
+ {
+ final PositionedSequenceFileImporter pi = importer.getValue();
+
+ if (pi == null)
+ throw new VarException(importer, "Importer is null !");
+
+ final SequenceFileImporter imp = pi.importer;
+
+ if (imp.getOpened() == null)
+ throw new VarException(importer, "Importer is not opened !");
+
+ final int res = resolution.getValue().intValue();
+ final ROI[] rois = region.getValue();
+
+ int s = series.getValue().intValue();
+ int z = zIndex.getValue().intValue();
+ int t = tIndex.getValue().intValue();
+ int c = cIndex.getValue().intValue();
+ Rectangle rect = ((rois != null) && (rois.length > 0)) ? rois[0].getBounds5D().toRectangle2D().getBounds()
+ : null;
+
+ // default values ? use internal position if any defined
+ if ((s == 0) && (pi.s != -1))
+ s = pi.s;
+ if ((z == 0) && (pi.z != -1))
+ z = pi.z;
+ if ((t == 0) && (pi.t != -1))
+ t = pi.t;
+ if ((c == 0) && (pi.c != -1))
+ c = pi.c;
+ if ((rect == null) && (pi.xyRegion != null))
+ rect = pi.xyRegion;
+
+ try
+ {
+ image.setValue(imp.getImage(s, res, rect, z, t, c));
+ }
+ catch (Exception e)
+ {
+ throw new VarException(importer, e.getMessage());
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("importer", importer);
+ inputMap.add("series", series);
+ inputMap.add("resolution", resolution);
+ inputMap.add("region", region);
+ inputMap.add("zIndex", zIndex);
+ inputMap.add("tIndex", tIndex);
+ inputMap.add("cIndex", cIndex);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("image", image);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetMetadata.java b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetMetadata.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb20523d043a5223b1b18d31e160d73aad35d1f7
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetMetadata.java
@@ -0,0 +1,84 @@
+package plugins.tprovoost.sequenceblocks.importer;
+
+import icy.file.SequenceFileImporter;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.MetaDataUtil;
+import ome.xml.meta.OMEXMLMetadata;
+import plugins.adufour.blocks.tools.io.IOBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+import plugins.tprovoost.sequenceblocks.infos.ReadMetadata;
+
+/**
+ * Block to returns the metadata from the specified opened SequenceFileImporter.
+ *
+ * @see ReadMetadata
+ * @author Stephane
+ */
+public class SequenceFileImporterGetMetadata extends Plugin implements IOBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<PositionedSequenceFileImporter> importer;
+ final protected Var<OMEXMLMetadata> metadata;
+ final protected VarInteger numSeries;
+
+ public SequenceFileImporterGetMetadata()
+ {
+ super();
+
+ importer = new Var<PositionedSequenceFileImporter>("Importer", PositionedSequenceFileImporter.class);
+ metadata = new Var<OMEXMLMetadata>("Metadata", OMEXMLMetadata.class);
+ numSeries = new VarInteger("Series number", 1);
+ }
+
+ @Override
+ public void run()
+ {
+ final PositionedSequenceFileImporter pi = importer.getValue();
+
+ if (pi == null)
+ throw new VarException(importer, "Importer is null !");
+
+ final SequenceFileImporter imp = pi.importer;
+
+ if (imp.getOpened() == null)
+ throw new VarException(importer, "Importer is not opened !");
+
+ try
+ {
+ final OMEXMLMetadata meta = imp.getOMEXMLMetaData();
+
+ metadata.setValue(meta);
+
+ if (meta != null)
+ numSeries.setValue(Integer.valueOf(MetaDataUtil.getNumSeries(meta)));
+ }
+ catch (Exception e)
+ {
+ throw new VarException(importer, e.getMessage());
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("importer", importer);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("metadata", metadata);
+ outputMap.add("numSerie", numSeries);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetThumbnail.java b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetThumbnail.java
new file mode 100644
index 0000000000000000000000000000000000000000..7303276842548ded54afe8d661314495a7c26825
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetThumbnail.java
@@ -0,0 +1,78 @@
+package plugins.tprovoost.sequenceblocks.importer;
+
+import icy.file.SequenceFileImporter;
+import icy.image.IcyBufferedImage;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import plugins.adufour.blocks.tools.io.IOBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to returns a thumbnail from the specified opened SequenceFileImporter.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterGetThumbnail extends Plugin implements IOBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<PositionedSequenceFileImporter> importer;
+ final protected VarInteger series;
+ final protected Var<IcyBufferedImage> thumbnail;
+
+ public SequenceFileImporterGetThumbnail()
+ {
+ super();
+
+ importer = new Var<PositionedSequenceFileImporter>("Importer", PositionedSequenceFileImporter.class);
+ series = new VarInteger("Series", 0);
+ thumbnail = new Var<IcyBufferedImage>("Thumbnail", IcyBufferedImage.class);
+ }
+
+ @Override
+ public void run()
+ {
+ final PositionedSequenceFileImporter pi = importer.getValue();
+
+ if (pi == null)
+ throw new VarException(importer, "Importer is null !");
+
+ final SequenceFileImporter imp = pi.importer;
+
+ if (imp.getOpened() == null)
+ throw new VarException(importer, "Importer is not opened !");
+
+ final int s = series.getValue().intValue();
+
+ try
+ {
+ thumbnail.setValue(imp.getThumbnail(s));
+ }
+ catch (Exception e)
+ {
+ throw new VarException(importer, e.getMessage());
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("importer", importer);
+ inputMap.add("series", series);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("thumbnail", thumbnail);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetTileSize.java b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetTileSize.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fa5e34a9b7ac14f519ce2b3e907c26fe8879d71
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterGetTileSize.java
@@ -0,0 +1,81 @@
+package plugins.tprovoost.sequenceblocks.importer;
+
+import icy.file.SequenceFileImporter;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import plugins.adufour.blocks.tools.io.IOBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to returns the optimal tile size for region reading from the specified opened SequenceFileImporter.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterGetTileSize extends Plugin implements IOBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<PositionedSequenceFileImporter> importer;
+ final protected VarInteger series;
+ final protected VarInteger tileW;
+ final protected VarInteger tileH;
+
+ public SequenceFileImporterGetTileSize()
+ {
+ super();
+
+ importer = new Var<PositionedSequenceFileImporter>("Importer", PositionedSequenceFileImporter.class);
+ series = new VarInteger("Series", 0);
+ tileW = new VarInteger("Tile width", 0);
+ tileH = new VarInteger("Tile height", 0);
+ }
+
+ @Override
+ public void run()
+ {
+ final PositionedSequenceFileImporter pi = importer.getValue();
+
+ if (pi == null)
+ throw new VarException(importer, "Importer is null !");
+
+ final SequenceFileImporter imp = pi.importer;
+
+ if (imp.getOpened() == null)
+ throw new VarException(importer, "Importer is not opened !");
+
+ final int s = series.getValue().intValue();
+
+ try
+ {
+ tileW.setValue(Integer.valueOf(imp.getTileWidth(s)));
+ tileH.setValue(Integer.valueOf(imp.getTileHeight(s)));
+ }
+ catch (Exception e)
+ {
+ throw new VarException(importer, e.getMessage());
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("importer", importer);
+ inputMap.add("series", series);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("tileW", tileW);
+ outputMap.add("tileH", tileH);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterLoadSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterLoadSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..34c8ba2d6a387750d1b97aef4b1300a5f8c6dda8
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterLoadSequence.java
@@ -0,0 +1,140 @@
+package plugins.tprovoost.sequenceblocks.importer;
+
+import java.awt.Rectangle;
+
+import icy.file.Loader;
+import icy.file.SequenceFileImporter;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import ome.xml.meta.OMEXMLMetadata;
+import plugins.adufour.blocks.tools.io.IOBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to returns a Sequence from the given parameters and opened SequenceFileImporter.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterLoadSequence extends Plugin implements IOBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<PositionedSequenceFileImporter> importer;
+ final protected VarInteger series;
+ final protected VarInteger resolution;
+ final protected VarROIArray region;
+ final protected VarInteger minZIndex;
+ final protected VarInteger maxZIndex;
+ final protected VarInteger minTIndex;
+ final protected VarInteger maxTIndex;
+ final protected VarInteger cIndex;
+
+ final protected VarSequence sequence;
+
+ public SequenceFileImporterLoadSequence()
+ {
+ super();
+
+ importer = new Var<PositionedSequenceFileImporter>("Importer", PositionedSequenceFileImporter.class);
+
+ series = new VarInteger("Series", 0);
+ resolution = new VarInteger("Resolution (0=full, 1=1/2, ..)", 0);
+ region = new VarROIArray("XY region (ROI)", null);
+ minZIndex = new VarInteger("Z min (slice)", -1);
+ maxZIndex = new VarInteger("Z max (slice)", -1);
+ minTIndex = new VarInteger("T min (frame)", -1);
+ maxTIndex = new VarInteger("T max (frame)", -1);
+ cIndex = new VarInteger("C (channel) index", -1);
+
+ sequence = new VarSequence("Sequence", null);
+ }
+
+ @Override
+ public void run()
+ {
+ final PositionedSequenceFileImporter pi = importer.getValue();
+
+ if (pi == null)
+ throw new VarException(importer, "Importer is null !");
+
+ final SequenceFileImporter imp = pi.importer;
+
+ if (imp.getOpened() == null)
+ throw new VarException(importer, "Importer is not opened !");
+
+ final int res = resolution.getValue().intValue();
+ final ROI[] rois = region.getValue();
+
+ int s = series.getValue().intValue();
+ int minZ = minZIndex.getValue().intValue();
+ int maxZ = maxZIndex.getValue().intValue();
+ int minT = minTIndex.getValue().intValue();
+ int maxT = maxTIndex.getValue().intValue();
+ int c = cIndex.getValue().intValue();
+ Rectangle rect = ((rois != null) && (rois.length > 0)) ? rois[0].getBounds5D().toRectangle2D().getBounds()
+ : null;
+
+ // default values ? use internal position if any defined
+ if ((s == 0) && (pi.s != -1))
+ s = pi.s;
+ if ((minZ == -1) && (maxZ == -1) && (pi.z != -1))
+ {
+ minZ = pi.z;
+ maxZ = pi.z;
+ }
+ if ((minT == -1) && (maxT == -1) && (pi.t != -1))
+ {
+ minT = pi.t;
+ maxT = pi.t;
+ }
+ if ((c == 0) && (pi.c != -1))
+ c = pi.c;
+ if ((rect == null) && (pi.xyRegion != null))
+ rect = pi.xyRegion;
+
+ try
+ {
+
+ // get metadata
+ final OMEXMLMetadata meta = pi.getMetadata();
+
+ sequence.setValue(Loader.internalLoadSingle(imp, meta, s, res, rect, minZ, maxZ, minT, maxT, c, false, null));
+ }
+ catch (Exception e)
+ {
+ throw new VarException(importer, e.getMessage());
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("importer", importer);
+ inputMap.add("series", series);
+ inputMap.add("resolution", resolution);
+ inputMap.add("region", region);
+ inputMap.add("minZ", minZIndex);
+ inputMap.add("maxZ", maxZIndex);
+ inputMap.add("minT", minTIndex);
+ inputMap.add("maxT", maxTIndex);
+ inputMap.add("cIndex", cIndex);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("sequence", sequence);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterOpen.java b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterOpen.java
new file mode 100644
index 0000000000000000000000000000000000000000..720b9c63b4d5c097cfbe28a86e91cb24b2bb62cf
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/importer/SequenceFileImporterOpen.java
@@ -0,0 +1,147 @@
+package plugins.tprovoost.sequenceblocks.importer;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import icy.file.Loader;
+import icy.file.SequenceFileImporter;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.util.ClassUtil;
+import plugins.adufour.blocks.tools.io.IOBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.gui.model.ValueSelectionModel;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarMutable;
+import plugins.adufour.vars.lang.VarString;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to open a file with a given SequenceFileImporter.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterOpen extends Plugin implements IOBlock, PluginLibrary, PluginBundled
+{
+ final static String ID_AUTO = "Automatic";
+
+ final protected VarString importerName;
+ final protected Var<PositionedSequenceFileImporter> importer;
+ final protected VarMutable file;
+ final protected VarInteger flag;
+
+ // internal
+ final protected Map<String, SequenceFileImporter> importersMap;
+
+ public SequenceFileImporterOpen()
+ {
+ super();
+
+ final List<String> importersName = new ArrayList<String>();
+ final List<SequenceFileImporter> importers = Loader.getSequenceFileImporters();
+
+ importerName = new VarString("Select importer", "", 1 + importers.size());
+ // build importer map
+ importersMap = new HashMap<String, SequenceFileImporter>();
+
+ // automatic selection
+ importersName.add(ID_AUTO);
+ importersMap.put(ID_AUTO, null);
+ for (SequenceFileImporter importer : importers)
+ {
+ String className = ClassUtil.getBaseClassName(importer.getClass().getName());
+ final int ind = className.lastIndexOf('.');
+
+ // just get final class name without package name
+ if (ind > -1)
+ className = className.substring(ind + 1, className.length());
+
+ importersName.add(className);
+ importersMap.put(className, importer);
+ }
+
+ // initialize importer selector field
+ importerName.setDefaultEditorModel(new ValueSelectionModel<String>(
+ importersName.toArray(new String[importersName.size()]), importersName.get(0), false));
+
+ importer = new Var<PositionedSequenceFileImporter>("Importer", PositionedSequenceFileImporter.class);
+ file = new VarMutable("File", null)
+ {
+ @SuppressWarnings("rawtypes")
+ @Override
+ public boolean isAssignableFrom(Var source)
+ {
+ return (String.class == source.getType()) || (File.class == source.getType());
+ }
+ };
+ flag = new VarInteger("Flag", 0);
+ }
+
+ @SuppressWarnings("resource")
+ @Override
+ public void run()
+ {
+ final String path;
+ final Object obj = file.getValue();
+
+ if (obj != null)
+ {
+ if (obj instanceof String)
+ path = (String) obj;
+ else
+ path = ((File) obj).getAbsolutePath();
+ }
+ else
+ throw new VarException(file, "File is null !");
+
+ // get selected importer
+ SequenceFileImporter imp = importersMap.get(importerName.getValue());
+
+ // automatic selection from input file ?
+ if (imp == null)
+ imp = Loader.getSequenceFileImporter(path, true);
+
+ // cannot get importer ?
+ if (imp == null)
+ throw new VarException(importer, "Cannot find an importer for file: '" + path + "' !");
+
+ // set importer
+ importer.setValue(new PositionedSequenceFileImporter(imp));
+
+ try
+ {
+ // try to open the importer
+ imp.open(path, flag.getValue().intValue());
+ }
+ catch (Exception e)
+ {
+ throw new VarException(importer, e.getMessage());
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("name", importerName);
+ inputMap.add("file", file);
+ inputMap.add("flag", flag);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("importer", importer);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/CreateLinearColormap.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/CreateLinearColormap.java
new file mode 100644
index 0000000000000000000000000000000000000000..7616d670b2551fcd5204130fdfdbf22202e0562b
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/CreateLinearColormap.java
@@ -0,0 +1,48 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.image.colormap.LinearColorMap;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+
+import java.awt.Color;
+
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarColor;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to create a linear colormap from a color value
+ *
+ * @author Stephane
+ * @see SetColormap
+ */
+public class CreateLinearColormap extends Plugin implements SequenceBlock, PluginBundled
+{
+ private VarColor color = new VarColor("Color", Color.white);
+ private VarColormap colormap = new VarColormap("Color map", LinearColorMap.gray_);
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("input", color);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("output", colormap);
+ }
+
+ @Override
+ public void run()
+ {
+ colormap.setValue(new LinearColorMap("color", color.getValue()));
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/Dimensions.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/Dimensions.java
new file mode 100644
index 0000000000000000000000000000000000000000..3dbc2dff82153ccc62d3547281d0e248b8168d99
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/Dimensions.java
@@ -0,0 +1,61 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class Dimensions extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ VarSequence varSeq = new VarSequence("Sequence", null);
+ VarInteger sizeZ = new VarInteger("Size Z", 1);
+ VarInteger sizeT = new VarInteger("Size T", 1);
+ VarInteger sizeC = new VarInteger("Size C", 1);
+ VarInteger width = new VarInteger("Width", 1);
+ VarInteger height = new VarInteger("Height", 1);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSeq.getValue();
+ if (s == null)
+ throw new VarException(varSeq, "Input sequence is null.");
+
+ width.setValue(Integer.valueOf(s.getWidth()));
+ height.setValue(Integer.valueOf(s.getHeight()));
+ sizeC.setValue(Integer.valueOf(s.getSizeC()));
+ sizeZ.setValue(Integer.valueOf(s.getSizeZ()));
+ sizeT.setValue(Integer.valueOf(s.getSizeT()));
+ }
+
+ @Override
+ public void declareInput(final VarList inputMap)
+ {
+ inputMap.add("sequence", varSeq);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("width", width);
+ outputMap.add("height", height);
+ outputMap.add("size C", sizeC);
+ outputMap.add("size Z", sizeZ);
+ outputMap.add("size T", sizeT);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/EzVarColormap.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/EzVarColormap.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3fd86c23413c14e645f90e032087fcd3ccc22d3
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/EzVarColormap.java
@@ -0,0 +1,19 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.image.colormap.IcyColorMap;
+import plugins.adufour.ezplug.EzVar;
+import plugins.tprovoost.sequenceblocks.infos.VarColormap.ColormapSelectionModel;
+
+public class EzVarColormap extends EzVar<IcyColorMap>
+{
+ /**
+ * Constructs a new variable that handles colormap data.
+ *
+ * @param varName
+ * the parameter name
+ */
+ public EzVarColormap(String varName, IcyColorMap defaultValue)
+ {
+ super(new VarColormap(varName, defaultValue), new ColormapSelectionModel());
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetChannelName.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetChannelName.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba5f734027cccd8e2ab694f83b4c793d471de962
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetChannelName.java
@@ -0,0 +1,55 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.lang.VarString;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class GetChannelName extends Plugin implements SequenceBlock, PluginBundled
+{
+ private VarSequence varSequence = new VarSequence("Sequence", null);
+ private VarInteger varIdx = new VarInteger("Channel", 0);
+ private VarString varName = new VarString("Name", "");
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+ if (s == null)
+ throw new VarException(varSequence, "Sequence is null");
+
+ int index = varIdx.getValue().intValue();
+ if (index < 0 || index >= s.getSizeC())
+ throw new VarException(varIdx, "Wrong channel index.");
+
+ varName.setValue(s.getChannelName(index));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ inputMap.add("index", varIdx);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("name", varName);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetChannelsName.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetChannelsName.java
new file mode 100644
index 0000000000000000000000000000000000000000..5506b01bcf956881edec07454d70287f18e01ab8
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetChannelsName.java
@@ -0,0 +1,61 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to retrieve all channels name from a given sequence
+ *
+ * @author Stephane
+ * @see GetChannelName
+ * @see SetChannelsName
+ */
+public class GetChannelsName extends Plugin implements SequenceBlock, PluginBundled
+{
+ private VarSequence varSequence = new VarSequence("Sequence", null);
+ private VarArray<String> varNames = new VarArray<String>("Names", String[].class, new String[0]);
+
+ @Override
+ public void run()
+ {
+ final Sequence s = varSequence.getValue();
+ if (s == null)
+ throw new VarException(varSequence, "Sequence is null");
+
+ final List<String> names = new ArrayList<String>();
+
+ for (int c = 0; c < s.getSizeC(); c++)
+ names.add(s.getChannelName(c));
+
+ varNames.setValue(names.toArray(new String[names.size()]));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("names", varNames);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetColormap.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetColormap.java
new file mode 100644
index 0000000000000000000000000000000000000000..98a564d4f6d2b9ffe6071199647b7e6ed2a6c67e
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetColormap.java
@@ -0,0 +1,60 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.image.colormap.LinearColorMap;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.BlocksException;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to retrieve a channel colormap from a given sequence
+ *
+ * @author Stephane
+ * @see SetColormap
+ */
+public class GetColormap extends Plugin implements SequenceBlock, PluginBundled
+{
+ private VarSequence sequenceIn = new VarSequence("Sequence", null);
+ private VarInteger numChannel = new VarInteger("Channel", 0);
+ private VarColormap colormap = new VarColormap("Color map", LinearColorMap.gray_);
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("input", sequenceIn);
+ inputMap.add("numChannel", numChannel);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("output", colormap);
+ }
+
+ @Override
+ public void run()
+ {
+ final Sequence seq = sequenceIn.getValue();
+
+ if (seq != null)
+ {
+ final int ch = numChannel.getValue().intValue();
+
+ if (ch < seq.getSizeC())
+ colormap.setValue(seq.getColorMap(ch));
+ else
+ throw new BlocksException("Block 'Get Colormap': illegal channel number for this sequence !", true);
+ }
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetColormaps.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetColormaps.java
new file mode 100644
index 0000000000000000000000000000000000000000..dcc86d74a15cb9efbce5cb6c060bcce80c2976af
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetColormaps.java
@@ -0,0 +1,62 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.image.colormap.IcyColorMap;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to retrieve all channels colormap from a given sequence
+ *
+ * @author Stephane
+ * @see SetColormaps
+ */
+public class GetColormaps extends Plugin implements SequenceBlock, PluginBundled
+{
+ private VarSequence sequenceIn = new VarSequence("Sequence", null);
+ private VarArray<IcyColorMap> colormaps = new VarArray<IcyColorMap>("Color maps", IcyColorMap[].class,
+ new IcyColorMap[0]);
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("input", sequenceIn);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("Colormaps", colormaps);
+ }
+
+ @Override
+ public void run()
+ {
+ final Sequence seq = sequenceIn.getValue();
+ if (seq == null)
+ throw new VarException(sequenceIn, "Sequence is null");
+
+ final List<IcyColorMap> cms = new ArrayList<IcyColorMap>();
+
+ for (int c = 0; c < seq.getSizeC(); c++)
+ cms.add(seq.getColorMap(c));
+
+ colormaps.setValue(cms.toArray(new IcyColorMap[cms.size()]));
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetDataType.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetDataType.java
new file mode 100644
index 0000000000000000000000000000000000000000..d47fe2d536199705304b10a7d7c95529846b3040
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetDataType.java
@@ -0,0 +1,53 @@
+/**
+ *
+ */
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import icy.type.DataType;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarEnum;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Returns the DataType of the Sequence object
+ *
+ * @author Stephane
+ */
+public class GetDataType extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected VarEnum<DataType> type = new VarEnum<DataType>("Data type", DataType.UBYTE);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+ if (s == null)
+ throw new VarException(varSequence, "Sequence is null");
+ type.setValue(s.getDataType_());
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("type", type);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetFileName.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetFileName.java
new file mode 100644
index 0000000000000000000000000000000000000000..477a91549d9c19cffc6ad3aa69f178a3ca2b3cc5
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetFileName.java
@@ -0,0 +1,69 @@
+/**
+ *
+ */
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.file.FileUtil;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.lang.VarString;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Returns the origin filename (from where the sequence has been loaded / saved)
+ *
+ * @author Stephane
+ */
+public class GetFileName extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected VarString filename = new VarString("Filename", "");
+ final protected VarBoolean withFolder = new VarBoolean("Folder", Boolean.TRUE);
+ final protected VarBoolean withExtension = new VarBoolean("Extension", Boolean.TRUE);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+
+ if (s == null)
+ throw new VarException(varSequence, "Sequence is null");
+
+ String result = s.getFilename();
+
+ // remove folder information ?
+ if (!withFolder.getValue().booleanValue())
+ result = FileUtil.getFileName(result);
+ // remove extension ?
+ if (!withExtension.getValue().booleanValue())
+ FileUtil.setExtension(result, "");
+
+ filename.setValue(result);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ inputMap.add("folder", withFolder);
+ inputMap.add("extension", withExtension);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("name", filename);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetMetaData.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetMetaData.java
new file mode 100644
index 0000000000000000000000000000000000000000..0145c1f401d8fefa77b991faf6701e189b6b7d55
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetMetaData.java
@@ -0,0 +1,106 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import java.awt.Rectangle;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import ome.xml.meta.OMEXMLMetadata;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarDouble;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.lang.VarString;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to return metadata information from a Sequence object.
+ *
+ * @see ReadMetadata
+ * @author Stephane
+ */
+public class GetMetaData extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected Var<OMEXMLMetadata> metaData = new Var<OMEXMLMetadata>("Metadata", OMEXMLMetadata.class);
+ final protected VarString name = new VarString("Name", "");
+ final protected VarInteger seriesIndex = new VarInteger("Series index", 0);
+ final protected VarDouble pxSizeX = new VarDouble("Pixel Size X (µm)", 1d);
+ final protected VarDouble pxSizeY = new VarDouble("Pixel Size Y (µm)", 1d);
+ final protected VarDouble pxSizeZ = new VarDouble("Pixel Size Z (µm)", 1d);
+ final protected VarDouble timeIntT = new VarDouble("Time interval T (s)", 100d);
+ final protected VarDouble positionX = new VarDouble("Position X (µm)", 0d);
+ final protected VarDouble positionY = new VarDouble("Position Y (µm)", 0d);
+ final protected VarDouble positionZ = new VarDouble("Position Z (µm)", 0d);
+ final protected VarInteger originResolution = new VarInteger("Resolution", 0);
+ final protected Var<Rectangle> originRegion = new Var<Rectangle>("Region", new Rectangle());
+ final protected VarInteger originZMin = new VarInteger("Z min", -1);
+ final protected VarInteger originZMax = new VarInteger("Z max", -1);
+ final protected VarInteger originTMin = new VarInteger("T min", -1);
+ final protected VarInteger originTMax = new VarInteger("T max", -1);
+ final protected VarInteger originChannel = new VarInteger("Channel", -1);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+
+ if (s == null)
+ throw new VarException(varSequence, "Sequence is null");
+
+ metaData.setValue(s.getOMEXMLMetadata());
+ name.setValue(s.getName());
+ seriesIndex.setValue(Integer.valueOf(s.getSeries()));
+ pxSizeX.setValue(Double.valueOf(s.getPixelSizeX()));
+ pxSizeY.setValue(Double.valueOf(s.getPixelSizeY()));
+ pxSizeZ.setValue(Double.valueOf(s.getPixelSizeZ()));
+ timeIntT.setValue(Double.valueOf(s.getTimeInterval()));
+ positionX.setValue(Double.valueOf(s.getPositionX()));
+ positionY.setValue(Double.valueOf(s.getPositionY()));
+ positionZ.setValue(Double.valueOf(s.getPositionZ()));
+ originResolution.setValue(Integer.valueOf(s.getOriginResolution()));
+ originRegion.setValue(s.getOriginXYRegion());
+ originZMin.setValue(Integer.valueOf(s.getOriginZMin()));
+ originZMax.setValue(Integer.valueOf(s.getOriginZMax()));
+ originTMin.setValue(Integer.valueOf(s.getOriginTMin()));
+ originTMax.setValue(Integer.valueOf(s.getOriginTMax()));
+ originChannel.setValue(Integer.valueOf(s.getOriginChannel()));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("metadata", metaData);
+ outputMap.add("name", name);
+ outputMap.add("seriesIndex", seriesIndex);
+ outputMap.add("Pixel Size X (mm)", pxSizeX);
+ outputMap.add("Pixel Size Y (mm)", pxSizeY);
+ outputMap.add("Pixel Size Z (mm)", pxSizeZ);
+ outputMap.add("Time interval T (ms)", timeIntT);
+ outputMap.add("positionx", positionX);
+ outputMap.add("positiony", positionY);
+ outputMap.add("positionz", positionZ);
+ outputMap.add("originResolution", originResolution);
+ outputMap.add("originRegion", originRegion);
+ outputMap.add("originZMin", originZMin);
+ outputMap.add("originZMax", originZMax);
+ outputMap.add("originTMin", originTMin);
+ outputMap.add("originTMax", originTMax);
+ outputMap.add("originChannel", originChannel);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetName.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetName.java
new file mode 100644
index 0000000000000000000000000000000000000000..c102a40c24970e75a1bdf82c514f1955de652010
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetName.java
@@ -0,0 +1,49 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.lang.VarString;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Returns the name of the Sequence object
+ *
+ * @author Stephane
+ */
+public class GetName extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected VarString name = new VarString("Name", "");
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+ if (s == null)
+ throw new VarException(varSequence, "Sequence is null");
+ name.setValue(s.getName());
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("name", name);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetOutputFilename.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetOutputFilename.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e9deece814f71e8189f2a742ad60f668014b4b2
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetOutputFilename.java
@@ -0,0 +1,64 @@
+/**
+ *
+ */
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.file.FileUtil;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.lang.VarString;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Returns the output filename generated from origin filename and internal partitioning information
+ *
+ * @author Stephane
+ */
+public class GetOutputFilename extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected VarString outFilename = new VarString("Output filename", "");
+ final protected VarBoolean withFolder = new VarBoolean("Folder", Boolean.TRUE);
+ final protected VarBoolean withExtension = new VarBoolean("Extension", Boolean.TRUE);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+ if (s == null)
+ throw new VarException(varSequence, "Sequence is null");
+
+ String result = s.getOutputFilename(withExtension.getValue().booleanValue());
+
+ if (!withFolder.getValue().booleanValue())
+ result = FileUtil.getFileName(result);
+
+ outFilename.setValue(result);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ inputMap.add("folder", withFolder);
+ inputMap.add("extension", withExtension);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("outFilename", outFilename);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetResolution.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetResolution.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa738a9126e0bd4f5746af5d8b2bf057b0bb9770
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetResolution.java
@@ -0,0 +1,65 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarDouble;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to return pixel size and time interval information from a Sequence object.
+ *
+ * @see ReadMetadata
+ * @see GetMetaData
+ * @author Stephane
+ */
+public class GetResolution extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected VarDouble pxSizeX = new VarDouble("Pixel Size X (µm)", 1d);
+ final protected VarDouble pxSizeY = new VarDouble("Pixel Size Y (µm)", 1d);
+ final protected VarDouble pxSizeZ = new VarDouble("Pixel Size Z (µm)", 1d);
+ final protected VarDouble timeIntT = new VarDouble("Time interval T (s)", 0.1d);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+ if (s != null)
+ {
+ pxSizeX.setValue(Double.valueOf(s.getPixelSizeX()));
+ pxSizeY.setValue(Double.valueOf(s.getPixelSizeY()));
+ pxSizeZ.setValue(Double.valueOf(s.getPixelSizeZ()));
+ timeIntT.setValue(Double.valueOf(s.getTimeInterval()));
+ }
+ else
+ {
+ throw new VarException(varSequence, "Sequence is null");
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("Pixel Size X (µm)", pxSizeX);
+ outputMap.add("Pixel Size Y (µm)", pxSizeY);
+ outputMap.add("Pixel Size Z (µm)", pxSizeZ);
+ outputMap.add("Time interval T (s)", timeIntT);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetRoisAsRegion.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetRoisAsRegion.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ddd6e77724d7081410026336469affdf294b105
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/GetRoisAsRegion.java
@@ -0,0 +1,100 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import java.awt.Rectangle;
+import java.util.ArrayList;
+import java.util.List;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarBoolean;
+import plugins.adufour.vars.lang.VarEnum;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.kernel.roi.roi2d.ROI2DRectangle;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to retrieve ROI(s) from a Sequence as 2D Rectangular regions.<br>
+ * The <i>origin resolution</i> parameter indicate if we want to rescale ROI to the original image resolution in case we
+ * have a Sequence which represents a sub resolution of the original image.
+ *
+ * @author Stephane
+ */
+public class GetRoisAsRegion extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ public static enum TypeSelection
+ {
+ ALL, SELECTED
+ };
+
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarEnum<TypeSelection> type = new VarEnum<TypeSelection>("ROI(s) to get", TypeSelection.ALL);
+ final protected VarBoolean originResolution = new VarBoolean("Origin resolution", Boolean.TRUE);
+ final protected VarROIArray regionsRois = new VarROIArray("Region ROI(s)", null);
+
+ @Override
+ public void run()
+ {
+ final Sequence sequence = inputSequence.getValue();
+ if (sequence == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ final List<ROI> rois;
+ final List<ROI2DRectangle> result = new ArrayList<ROI2DRectangle>();
+
+ switch (type.getValue())
+ {
+ default:
+ rois = sequence.getROIs();
+ break;
+ case SELECTED:
+ rois = sequence.getSelectedROIs();
+ break;
+ }
+
+ final boolean scale = originResolution.getValue().booleanValue();
+
+ // build rectangular ROI(s)
+ for (ROI roi : rois)
+ {
+ // get ROI 2D bounds
+ Rectangle rect = roi.getBounds5D().toRectangle2D().getBounds();
+
+ // scale if needed
+ if (scale)
+ rect = SequenceUtil.getOriginRectangle(rect, sequence);
+
+ // add to result
+ result.add(new ROI2DRectangle(rect));
+ }
+
+ regionsRois.setValue(result.toArray(new ROI[result.size()]));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("type", type);
+ inputMap.add("originResolution", originResolution);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("regionsRois", regionsRois);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/ReadMetadata.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/ReadMetadata.java
new file mode 100644
index 0000000000000000000000000000000000000000..e492453568e9e0341ce5e4e3af3c63efbfef6b0f
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/ReadMetadata.java
@@ -0,0 +1,107 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.MetaDataUtil;
+import ome.xml.meta.OMEXMLMetadata;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarDouble;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarString;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+import plugins.tprovoost.sequenceblocks.files.LoadMetadata;
+
+/**
+ * Block to return main informations from a metadata object.
+ *
+ * @see LoadMetadata
+ * @author Stephane
+ */
+public class ReadMetadata extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected Var<OMEXMLMetadata> metadata = new Var<OMEXMLMetadata>("Metadata", OMEXMLMetadata.class);
+ final protected VarInteger serie = new VarInteger("Series", 0);
+
+ final protected VarInteger numSerie = new VarInteger("Num serie", 1);
+ final protected VarString name = new VarString("Name", "");
+ final protected VarInteger sizeX = new VarInteger("Size X", 1);
+ final protected VarInteger sizeY = new VarInteger("Size Y", 1);
+ final protected VarInteger sizeC = new VarInteger("Size C", 1);
+ final protected VarInteger sizeZ = new VarInteger("Size Z", 1);
+ final protected VarInteger sizeT = new VarInteger("Size T", 1);
+ final protected VarDouble pxSizeX = new VarDouble("Pixel Size X (µm)", 1d);
+ final protected VarDouble pxSizeY = new VarDouble("Pixel Size Y (µm)", 1d);
+ final protected VarDouble pxSizeZ = new VarDouble("Pixel Size Z (µm)", 1d);
+ final protected VarDouble timeIntT = new VarDouble("Time interval T (s)", 100d);
+ final protected VarDouble positionX = new VarDouble("Position X (µm)", 0d);
+ final protected VarDouble positionY = new VarDouble("Position Y (µm)", 0d);
+ final protected VarDouble positionZ = new VarDouble("Position Z (µm)", 0d);
+
+ @Override
+ public void run()
+ {
+ final OMEXMLMetadata meta = metadata.getValue();
+ if (meta == null)
+ throw new VarException(metadata, "Metadata is null !");
+
+ final int s = serie.getValue().intValue();
+ final int numS = MetaDataUtil.getNumSeries(meta);
+
+ numSerie.setValue(Integer.valueOf(numS));
+
+ if (s >= numS)
+ throw new VarException(serie, "Serie index must be between 0 and " + (numS - 1));
+
+ name.setValue(MetaDataUtil.getName(meta, s));
+ sizeX.setValue(Integer.valueOf(MetaDataUtil.getSizeX(meta, s)));
+ sizeY.setValue(Integer.valueOf(MetaDataUtil.getSizeY(meta, s)));
+ sizeZ.setValue(Integer.valueOf(MetaDataUtil.getSizeZ(meta, s)));
+ sizeT.setValue(Integer.valueOf(MetaDataUtil.getSizeT(meta, s)));
+ sizeC.setValue(Integer.valueOf(MetaDataUtil.getSizeC(meta, s)));
+ pxSizeX.setValue(Double.valueOf(MetaDataUtil.getPixelSizeX(meta, s, pxSizeX.getDefaultValue().doubleValue())));
+ pxSizeY.setValue(Double.valueOf(MetaDataUtil.getPixelSizeY(meta, s, pxSizeY.getDefaultValue().doubleValue())));
+ pxSizeZ.setValue(Double.valueOf(MetaDataUtil.getPixelSizeZ(meta, s, pxSizeZ.getDefaultValue().doubleValue())));
+ timeIntT.setValue(
+ Double.valueOf(MetaDataUtil.getTimeInterval(meta, s, timeIntT.getDefaultValue().doubleValue())));
+ // get position of first plane only for now
+ positionX.setValue(Double.valueOf(MetaDataUtil.getPositionX(meta, s, 0, 0, 0, 0d)));
+ positionY.setValue(Double.valueOf(MetaDataUtil.getPositionY(meta, s, 0, 0, 0, 0d)));
+ positionZ.setValue(Double.valueOf(MetaDataUtil.getPositionZ(meta, s, 0, 0, 0, 0d)));
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("Metadata", metadata);
+ inputMap.add("Serie", serie);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ outputMap.add("numSerie", numSerie);
+ outputMap.add("Name", name);
+ outputMap.add("Size X", sizeX);
+ outputMap.add("Size Y", sizeY);
+ outputMap.add("Size C", sizeC);
+ outputMap.add("Size Z", sizeZ);
+ outputMap.add("Size T", sizeT);
+ outputMap.add("Pixel Size X (mm)", pxSizeX);
+ outputMap.add("Pixel Size Y (mm)", pxSizeY);
+ outputMap.add("Pixel Size Z (mm)", pxSizeZ);
+ outputMap.add("Time interval T (ms)", timeIntT);
+ outputMap.add("positionx", positionX);
+ outputMap.add("positiony", positionY);
+ outputMap.add("positionz", positionZ);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetChannelName.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetChannelName.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b94357b2ac6bb9d4efe7325543df343145e5d61
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetChannelName.java
@@ -0,0 +1,65 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import icy.util.StringUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.lang.VarString;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to set channel name of the specified sequence
+ *
+ * @author Stephane
+ * @see GetChannelsName
+ * @see SetChannelName
+ */
+public class SetChannelName extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected VarString varName = new VarString("Name", "");
+ final protected VarInteger idx = new VarInteger("Channel", 0);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+ if (s == null)
+ throw new VarException(varSequence, "Sequence is null");
+
+ int index = idx.getValue().intValue();
+ if (index < 0 || index >= s.getSizeC())
+ throw new VarException(idx, "Wrong channel index.");
+
+ String name = varName.getName();
+ if (StringUtil.isEmpty(name))
+ throw new VarException(varName, "Name cannot be empty");
+
+ s.setChannelName(index, varName.getValue());
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ inputMap.add("index", idx);
+ inputMap.add("name", varName);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetChannelsName.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetChannelsName.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce421ee89527de3d6832dc3c34518688f9ec77f7
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetChannelsName.java
@@ -0,0 +1,58 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to set all channels name of the specified sequence
+ *
+ * @author Stephane
+ * @see GetChannelsName
+ * @see SetChannelName
+ */
+public class SetChannelsName extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected VarArray<String> varNames = new VarArray<String>("Names", String[].class, new String[0]);
+
+ @Override
+ public void run()
+ {
+ final Sequence s = varSequence.getValue();
+ if (s == null)
+ throw new VarException(varSequence, "Sequence is null");
+
+ final String[] names = varNames.getValue();
+ if (names == null)
+ throw new VarException(varNames, "Names is null");
+
+ for (int c = 0; c < Math.min(s.getSizeC(), names.length); c++)
+ s.setChannelName(c, names[c]);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ inputMap.add("names", varNames);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetColormap.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetColormap.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a7e57c1cd7786371b07acf5e884e00fec5858a7
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetColormap.java
@@ -0,0 +1,57 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.image.colormap.IcyColorMap;
+import icy.image.colormap.LinearColorMap;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.BlocksException;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+public class SetColormap extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence sequenceIn = new VarSequence("Sequence", null);
+ final protected VarInteger numChannel = new VarInteger("Channel", 0);
+ final protected VarColormap colormap = new VarColormap("Color map", LinearColorMap.gray_);
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("input", sequenceIn);
+ inputMap.add("numChannel", numChannel);
+ inputMap.add("colormap", colormap);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ // no output here
+ }
+
+ @Override
+ public void run()
+ {
+ final Sequence seq = sequenceIn.getValue();
+
+ if (seq != null)
+ {
+ final int ch = numChannel.getValue().intValue();
+ final IcyColorMap map = colormap.getValue();
+
+ if ((ch < seq.getSizeC()) && (map != null))
+ seq.setColormap(ch, map, map.isAlpha());
+ else
+ throw new BlocksException("Block 'Set Colormap': illegal channel number for this sequence !", true);
+ }
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetColormaps.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetColormaps.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e0d9e548fb48112eaf9a319d8b32c0d7919ed78
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetColormaps.java
@@ -0,0 +1,53 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.image.colormap.IcyColorMap;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+public class SetColormaps extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence sequenceIn = new VarSequence("Input", null);
+ final protected VarArray<IcyColorMap> colormaps = new VarArray<IcyColorMap>("Color maps", IcyColorMap[].class,
+ new IcyColorMap[0]);
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("input", sequenceIn);
+ inputMap.add("colormaps", colormaps);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ // no output here
+ }
+
+ @Override
+ public void run()
+ {
+ final Sequence seq = sequenceIn.getValue();
+ if (seq == null)
+ throw new VarException(sequenceIn, "Sequence is null");
+
+ final IcyColorMap[] cms = colormaps.getValue();
+ if (cms == null)
+ throw new VarException(colormaps, "Color maps is null");
+
+ for (int c = 0; c < Math.min(seq.getSizeC(), cms.length); c++)
+ seq.setColormap(c, cms[c], cms[c].isAlpha());
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetName.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetName.java
new file mode 100644
index 0000000000000000000000000000000000000000..2cf4be88bac22d6ae353bc140d801201eb931d4f
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetName.java
@@ -0,0 +1,53 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.lang.VarString;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class SetName extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected VarString name = new VarString("Name", "");
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+ if (s != null)
+ {
+ s.setName(name.getValue());
+ }
+ else
+ {
+ throw new VarException(varSequence, "Sequence is null");
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ inputMap.add("name", name);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetResolution.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetResolution.java
new file mode 100644
index 0000000000000000000000000000000000000000..e821818efdecc404e913293f558acb0567cf11f1
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/SetResolution.java
@@ -0,0 +1,70 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarDouble;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * @author thomasprovoost
+ */
+public class SetResolution extends Plugin implements SequenceBlock, PluginBundled
+{
+ final protected VarSequence varSequence = new VarSequence("Sequence", null);
+ final protected VarDouble pxSizeX = new VarDouble("Pixel Size X (µm)", 1d);
+ final protected VarDouble pxSizeY = new VarDouble("Pixel Size Y (µm)", 1d);
+ final protected VarDouble pxSizeZ = new VarDouble("Pixel Size Z (µm)", 1d);
+ final protected VarDouble timeIntT = new VarDouble("Time interval T (s)", 100d);
+
+ @Override
+ public void run()
+ {
+ Sequence s = varSequence.getValue();
+
+ if (s != null)
+ {
+ double x = pxSizeX.getValue().doubleValue();
+ double y = pxSizeY.getValue().doubleValue();
+ double z = pxSizeZ.getValue().doubleValue();
+ double ti = timeIntT.getValue().doubleValue();
+ if (x != -1)
+ s.setPixelSizeX(x);
+ if (y != -1)
+ s.setPixelSizeY(y);
+ if (z != -1)
+ s.setPixelSizeZ(z);
+ if (ti != -1)
+ s.setTimeInterval(ti);
+ } else
+ {
+ throw new VarException(varSequence, "Sequence is null");
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", varSequence);
+ inputMap.add("PxSize X (µm)", pxSizeX);
+ inputMap.add("PxSize Y (µm)", pxSizeY);
+ inputMap.add("PxSize Z (µm)", pxSizeZ);
+ inputMap.add("Time interval T (s)", timeIntT);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/infos/VarColormap.java b/src/main/java/plugins/tprovoost/sequenceblocks/infos/VarColormap.java
new file mode 100644
index 0000000000000000000000000000000000000000..017f8b950f6b668f493e16b8085eebd77cd6913a
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/infos/VarColormap.java
@@ -0,0 +1,90 @@
+package plugins.tprovoost.sequenceblocks.infos;
+
+import javax.swing.JComboBox;
+
+import org.w3c.dom.Node;
+
+import icy.gui.component.renderer.ColormapComboBoxRenderer;
+import icy.image.colormap.IcyColorMap;
+import icy.image.colormap.LinearColorMap;
+import icy.util.XMLUtil;
+import plugins.adufour.vars.gui.VarEditor;
+import plugins.adufour.vars.gui.model.ValueSelectionModel;
+import plugins.adufour.vars.gui.swing.ComboBox;
+import plugins.adufour.vars.lang.Var;
+
+/**
+ * Define a specific Var type for ColorMap object
+ *
+ * @author emilie
+ */
+public class VarColormap extends Var<IcyColorMap>
+{
+ public static class ColormapSelectionModel extends ValueSelectionModel<IcyColorMap>
+ {
+ public ColormapSelectionModel()
+ {
+ super(IcyColorMap.getAllColorMaps(true, true).toArray(new IcyColorMap[0]), LinearColorMap.gray_, false);
+ }
+
+ @Override
+ public boolean isValid(IcyColorMap value)
+ {
+ return true;
+ }
+ }
+
+ public final String ID_NODE = "colormap";
+
+ /**
+ * Create a new VarColormap with given name and default value
+ */
+ public VarColormap(String name, IcyColorMap defaultValue)
+ {
+ super(name, new ColormapSelectionModel());
+ }
+
+ @Override
+ public VarEditor<IcyColorMap> createVarEditor()
+ {
+ // create the var editor (combo box type here)
+ final ComboBox<IcyColorMap> result = new ComboBox<IcyColorMap>(this);
+ // get the editor component
+ final JComboBox combo = result.getEditorComponent();
+ // and set a specific renderer
+ combo.setRenderer(new ColormapComboBoxRenderer(combo));
+
+ return result;
+ }
+
+ @Override
+ public boolean loadFromXML(Node node)
+ {
+ try
+ {
+ final IcyColorMap map = new IcyColorMap();
+ map.loadFromXML(XMLUtil.setElement(node, ID_NODE));
+ setValue(map);
+
+ return true;
+ }
+ catch (Exception e)
+ {
+ return false;
+ }
+ }
+
+ @Override
+ public boolean saveToXML(Node node) throws UnsupportedOperationException
+ {
+ try
+ {
+ getValue().saveToXML(XMLUtil.setElement(node, ID_NODE));
+ return true;
+ }
+ catch (Exception e)
+ {
+ return false;
+ }
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceChannelBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceChannelBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..f227dcdf5f39c9831fca6562ccaf1e5788b66547
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceChannelBatch.java
@@ -0,0 +1,77 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.lang.Batch;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Simple batch loop to iterate over all C channel from an input Sequence.
+ *
+ * @author Stephane
+ */
+public class SequenceChannelBatch extends Batch implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ // important to not initialize and create them in getBatchSource() and getBatchElement()
+ protected VarSequence inputSequence;
+ protected VarSequence element;
+
+ public SequenceChannelBatch()
+ {
+ super();
+ }
+
+ @Override
+ public VarSequence getBatchSource()
+ {
+ // initialize variable if needed
+ if (inputSequence == null)
+ inputSequence = new VarSequence("Sequence", null);
+
+ return inputSequence;
+ }
+
+ @Override
+ public VarSequence getBatchElement()
+ {
+ // initialize element if needed
+ if (element == null)
+ element = new VarSequence("Channel Sequence", null);
+
+ return element;
+ }
+
+ @Override
+ public void initializeLoop()
+ {
+ final Sequence value = inputSequence.getValue();
+
+ if (value == null)
+ throw new VarException(inputSequence, "No input sequence indicated");
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set result in element
+ element.setValue(
+ SequenceUtil.extractChannel(inputSequence.getValue(), getIterationCounter().getValue().intValue()));
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= inputSequence.getValue().getSizeC();
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..782c76cf22a1fcc65214f96af01bd64148f79d4c
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterBatch.java
@@ -0,0 +1,70 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import icy.file.SequenceFileImporter;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import plugins.adufour.blocks.lang.Batch;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+import plugins.tprovoost.sequenceblocks.importer.PositionedSequenceFileImporter;
+
+/**
+ * Base abstract class for {@link SequenceFileImporter} batch loop.
+ *
+ * @author Stephane
+ */
+public abstract class SequenceFileImporterBatch extends Batch implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ // important to not initialize and create them in getBatchSource() and getBatchElement()
+ protected Var<PositionedSequenceFileImporter> positionedImporter;
+ protected Var<PositionedSequenceFileImporter> element;
+
+ // internal
+ protected int limit;
+
+ @Override
+ public Var<PositionedSequenceFileImporter> getBatchSource()
+ {
+ // initialize variable if needed
+ if (positionedImporter == null)
+ positionedImporter = new Var<PositionedSequenceFileImporter>("Importer",
+ PositionedSequenceFileImporter.class);
+
+ return positionedImporter;
+ }
+
+ @Override
+ public Var<PositionedSequenceFileImporter> getBatchElement()
+ {
+ // initialize element if needed
+ if (element == null)
+ element = new Var<PositionedSequenceFileImporter>("Loop importer", PositionedSequenceFileImporter.class);
+
+ return element;
+ }
+
+ @Override
+ public void initializeLoop()
+ {
+ final PositionedSequenceFileImporter value = positionedImporter.getValue();
+
+ if (value == null)
+ throw new VarException(positionedImporter, "Input importer is null !");
+
+ final SequenceFileImporter imp = value.importer;
+
+ if (imp.getOpened() == null)
+ throw new VarException(positionedImporter, "Importer is not opened !");
+
+ // init element with a copy of current positioned importer
+ element.setValue(new PositionedSequenceFileImporter(value));
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterChannelBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterChannelBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..46640c56371c0c1eade6faae2c6d3a23d531ce35
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterChannelBatch.java
@@ -0,0 +1,54 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import icy.file.SequenceFileImporter;
+import icy.sequence.MetaDataUtil;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.importer.PositionedSequenceFileImporter;
+
+/**
+ * Simple batch loop to iterate over all C channel from specified opened {@link SequenceFileImporter} object.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterChannelBatch extends SequenceFileImporterBatch
+{
+ @Override
+ public void initializeLoop()
+ {
+ super.initializeLoop();
+
+ final PositionedSequenceFileImporter pi = positionedImporter.getValue();
+
+ try
+ {
+ // can iterate over C dimension ?
+ if (pi.c == -1)
+ limit = MetaDataUtil.getSizeC(pi.getMetadata(), (pi.s == -1) ? 0 : pi.s);
+ else
+ limit = 1;
+ }
+ catch (Exception e)
+ {
+ throw new VarException(element,
+ "Error while initializing SequenceFileImporter channel batch: " + e.getMessage());
+ }
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set current position C
+ if (positionedImporter.getValue().c == -1)
+ {
+ element.getValue().c = getIterationCounter().getValue().intValue();
+ // force element changed event so loop get correctly executed
+ element.valueChanged(element, element.getValue(), element.getValue());
+ }
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= limit;
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterFrameBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterFrameBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..e91d5f4ff98aba478bb7aa82b97957726f288141
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterFrameBatch.java
@@ -0,0 +1,54 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import icy.file.SequenceFileImporter;
+import icy.sequence.MetaDataUtil;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.importer.PositionedSequenceFileImporter;
+
+/**
+ * Simple batch loop to iterate over all T frame from the specified opened {@link SequenceFileImporter} object.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterFrameBatch extends SequenceFileImporterBatch
+{
+ @Override
+ public void initializeLoop()
+ {
+ super.initializeLoop();
+
+ final PositionedSequenceFileImporter pi = positionedImporter.getValue();
+
+ try
+ {
+ // can iterate over T dimension ?
+ if (pi.t == -1)
+ limit = MetaDataUtil.getSizeT(pi.getMetadata(), (pi.s == -1) ? 0 : pi.s);
+ else
+ limit = 1;
+ }
+ catch (Exception e)
+ {
+ throw new VarException(element,
+ "Error while initializing SequenceFileImporter frame batch: " + e.getMessage());
+ }
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set current position T
+ if (positionedImporter.getValue().t == -1)
+ {
+ element.getValue().t = getIterationCounter().getValue().intValue();
+ // force element changed event so loop get correctly executed
+ element.valueChanged(element, element.getValue(), element.getValue());
+ }
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= limit;
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterRegionBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterRegionBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..0bbd8bb263a02730c16eb1c2aa4fac2fd7dad8cd
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterRegionBatch.java
@@ -0,0 +1,137 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import java.awt.Rectangle;
+import java.awt.geom.Rectangle2D;
+import java.util.ArrayList;
+import java.util.List;
+
+import icy.file.SequenceFileImporter;
+import icy.roi.ROI;
+import icy.sequence.MetaDataUtil;
+import icy.type.rectangle.Rectangle2DUtil;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.importer.PositionedSequenceFileImporter;
+
+/**
+ * Simple batch loop to iterate over a set of XY region defined by ROIs from the specified opened
+ * {@link SequenceFileImporter} object.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterRegionBatch extends SequenceFileImporterBatch
+{
+ protected VarROIArray rois;
+ protected VarInteger inputRoisResolution;
+ protected VarInteger inputRoisMargin;
+ protected List<Rectangle> regions;
+
+ @Override
+ public void initializeLoop()
+ {
+ super.initializeLoop();
+
+ final PositionedSequenceFileImporter pi = positionedImporter.getValue();
+
+ // can iterate over XY dimension ?
+ if ((pi.xyRegion == null) && (rois.getValue() != null))
+ {
+ final int s = (pi.s == -1) ? 0 : pi.s;
+ final Rectangle regionMask;
+
+ try
+ {
+ // mask for region
+ regionMask = new Rectangle(0, 0, MetaDataUtil.getSizeX(pi.getMetadata(), s),
+ MetaDataUtil.getSizeY(pi.getMetadata(), s));
+ }
+ catch (Exception e)
+ {
+ throw new VarException(element,
+ "Error while initializing SequenceFileImporter region batch: " + e.getMessage());
+ }
+
+ final double scaleFactor = Math.pow(2, inputRoisResolution.getValue().doubleValue());
+ final double margeFactor = 1d + (inputRoisMargin.getValue().doubleValue() / 100d);
+
+ // build 2D regions from ROI
+ regions = new ArrayList<Rectangle>();
+ for (ROI roi : rois.getValue())
+ {
+ Rectangle2D region = roi.getBounds5D().toRectangle2D();
+
+ // convert to full resolution if needed
+ if (scaleFactor != 1d)
+ region = Rectangle2DUtil.getScaledRectangle(region, scaleFactor, false, true);
+ // apply marge factor if needed
+ if (margeFactor != 1d)
+ region = Rectangle2DUtil.getScaledRectangle(region, margeFactor, true, false);
+
+ // use regionMask to limit to image region
+ regions.add(region.getBounds().intersection(regionMask));
+ }
+
+ // set limit
+ limit = regions.size();
+ }
+ else
+ limit = 1;
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set current position XY region
+ if (positionedImporter.getValue().xyRegion == null)
+ {
+ element.getValue().xyRegion = regions.get(getIterationCounter().getValue().intValue());
+ // force element changed event so loop get correctly executed
+ element.valueChanged(element, element.getValue(), element.getValue());
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ super.declareInput(inputMap);
+
+ // lazy creation
+ if (rois == null)
+ rois = new VarROIArray("XY regions (ROIs)");
+ if (inputRoisResolution == null)
+ inputRoisResolution = new VarInteger("ROIs resolution", 0);
+ if (inputRoisMargin == null)
+ inputRoisMargin = new VarInteger("ROIs margin", 20);
+
+ inputMap.add("regions", rois);
+ inputMap.add("inputResolution", inputRoisResolution);
+ inputMap.add("inputRoisMarge", inputRoisMargin);
+ }
+
+ @Override
+ public void declareLoopVariables(List<Var<?>> loopVariables)
+ {
+ // lazy creation
+ if (rois == null)
+ rois = new VarROIArray("XY regions (ROIs)");
+ if (inputRoisResolution == null)
+ inputRoisResolution = new VarInteger("ROIs resolution", 0);
+ if (inputRoisMargin == null)
+ inputRoisMargin = new VarInteger("ROIs margin", 20);
+
+ loopVariables.add(rois);
+ loopVariables.add(inputRoisResolution);
+ loopVariables.add(inputRoisMargin);
+
+ super.declareLoopVariables(loopVariables);
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= limit;
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterSeriesBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterSeriesBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..255c14ceb98dbccc3ec8b09e5a4db47f420a240f
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterSeriesBatch.java
@@ -0,0 +1,48 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import icy.file.SequenceFileImporter;
+import icy.sequence.MetaDataUtil;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.importer.PositionedSequenceFileImporter;
+
+/**
+ * Simple batch loop to iterate over all series from the specified opened {@link SequenceFileImporter} object.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterSeriesBatch extends SequenceFileImporterBatch
+{
+ @Override
+ public void initializeLoop()
+ {
+ super.initializeLoop();
+
+ final PositionedSequenceFileImporter pi = positionedImporter.getValue();
+
+ try
+ {
+ // force series iteration as by default series is set to 0
+ limit = MetaDataUtil.getNumSeries(pi.getMetadata());
+ }
+ catch (Exception e)
+ {
+ throw new VarException(element,
+ "Error while initializing SequenceFileImporter series batch: " + e.getMessage());
+ }
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set current position S
+ element.getValue().s = getIterationCounter().getValue().intValue();
+ // force element changed event so loop get correctly executed
+ element.valueChanged(element, element.getValue(), element.getValue());
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= limit;
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterSliceBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterSliceBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..061b76de2ce25f577b22617ab6d0e5ec2b1049a7
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterSliceBatch.java
@@ -0,0 +1,54 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import icy.file.SequenceFileImporter;
+import icy.sequence.MetaDataUtil;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.importer.PositionedSequenceFileImporter;
+
+/**
+ * Simple batch loop to iterate over all Z slice from specified opened {@link SequenceFileImporter} object.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterSliceBatch extends SequenceFileImporterBatch
+{
+ @Override
+ public void initializeLoop()
+ {
+ super.initializeLoop();
+
+ final PositionedSequenceFileImporter pi = positionedImporter.getValue();
+
+ try
+ {
+ // can iterate over Z dimension ?
+ if (pi.z == -1)
+ limit = MetaDataUtil.getSizeZ(pi.getMetadata(), (pi.s == -1) ? 0 : pi.s);
+ else
+ limit = 1;
+ }
+ catch (Exception e)
+ {
+ throw new VarException(element,
+ "Error while initializing SequenceFileImporter slice batch: " + e.getMessage());
+ }
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set current position Z
+ if (positionedImporter.getValue().z == -1)
+ {
+ element.getValue().z = getIterationCounter().getValue().intValue();
+ // force element changed event so loop get correctly executed
+ element.valueChanged(element, element.getValue(), element.getValue());
+ }
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= limit;
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterTileBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterTileBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..5386fb6de960654e2274d0f96aebebc51482b1a6
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFileImporterTileBatch.java
@@ -0,0 +1,109 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import java.awt.Rectangle;
+import java.util.List;
+
+import icy.file.SequenceFileImporter;
+import icy.image.ImageUtil;
+import icy.sequence.MetaDataUtil;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.importer.PositionedSequenceFileImporter;
+
+/**
+ * Simple batch loop to iterate over all XY tile from the specified opened {@link SequenceFileImporter} object.
+ *
+ * @author Stephane
+ */
+public class SequenceFileImporterTileBatch extends SequenceFileImporterBatch
+{
+ protected final VarInteger tileW;
+ protected final VarInteger tileH;
+
+ protected List<Rectangle> tiles;
+
+ public SequenceFileImporterTileBatch()
+ {
+ super();
+
+ tileW = new VarInteger("Tile width (-1 = auto)", 0);
+ tileH = new VarInteger("Tile height (-1 = auto)", 0);
+ }
+
+ @Override
+ public void initializeLoop()
+ {
+ super.initializeLoop();
+
+ final PositionedSequenceFileImporter pi = positionedImporter.getValue();
+
+ // can iterate over XY dimension ?
+ if (pi.xyRegion == null)
+ {
+ final SequenceFileImporter imp = pi.importer;
+ final int s = (pi.s == -1) ? 0 : pi.s;
+ final int sizeX;
+ final int sizeY;
+ int tw;
+ int th;
+
+ try
+ {
+ sizeX = MetaDataUtil.getSizeX(pi.getMetadata(), s);
+ sizeY = MetaDataUtil.getSizeY(pi.getMetadata(), s);
+
+ tw = tileW.getValue().intValue();
+ th = tileH.getValue().intValue();
+ // auto ? --> get it from importer
+ if (tw == -1)
+ tw = imp.getTileWidth(s);
+ // auto ? --> get it from importer
+ if (th == -1)
+ th = imp.getTileHeight(s);
+ }
+ catch (Exception e)
+ {
+ throw new VarException(positionedImporter,
+ "Error while initializing SequenceFileImporter tile batch: " + e.getMessage());
+ }
+
+ // any size supported ? --> use 1024 by default
+ if (tw == -1)
+ tw = 1024;
+ // tile loading not supported ? --> use full width
+ else if (tw == 0)
+ tw = sizeX;
+ // any size supported ? --> use 1024 by default
+ if (th == -1)
+ th = 1024;
+ // tile loading not supported ? --> use full height
+ else if (th == 0)
+ th = sizeY;
+
+ // get tiles
+ tiles = ImageUtil.getTileList(sizeX, sizeY, tw, th);
+ // set limit
+ limit = tiles.size();
+ }
+ else
+ limit = 1;
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set current position XY region
+ if (positionedImporter.getValue().xyRegion == null)
+ {
+ element.getValue().xyRegion = tiles.get(getIterationCounter().getValue().intValue());
+ // force element changed event so loop get correctly executed
+ element.valueChanged(element, element.getValue(), element.getValue());
+ }
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= limit;
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFrameBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFrameBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..d06b0a6c91a7b520f7eb72e5bdeb9e26a14cf6e2
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceFrameBatch.java
@@ -0,0 +1,76 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.lang.Batch;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Simple batch loop to iterate over all T frame from an input Sequence.
+ *
+ * @author Stephane
+ */
+public class SequenceFrameBatch extends Batch implements PluginLibrary, PluginBundled
+{
+ // important to not initialize and create them in getBatchSource() and getBatchElement()
+ protected VarSequence inputSequence;
+ protected VarSequence element;
+
+ public SequenceFrameBatch()
+ {
+ super();
+ }
+
+ @Override
+ public VarSequence getBatchSource()
+ {
+ // initialize variable if needed
+ if (inputSequence == null)
+ inputSequence = new VarSequence("Sequence", null);
+
+ return inputSequence;
+ }
+
+ @Override
+ public VarSequence getBatchElement()
+ {
+ // initialize element if needed
+ if (element == null)
+ element = new VarSequence("Channel Sequence", null);
+
+ return element;
+ }
+
+ @Override
+ public void initializeLoop()
+ {
+ final Sequence value = inputSequence.getValue();
+
+ if (value == null)
+ throw new VarException(inputSequence, "No input sequence indicated");
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set result in element
+ element.setValue(
+ SequenceUtil.extractFrame(inputSequence.getValue(), getIterationCounter().getValue().intValue()));
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= inputSequence.getValue().getSizeT();
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceRegionBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceRegionBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..548ba91b6ad96f97bda809d1c73ab7538d72fd88
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceRegionBatch.java
@@ -0,0 +1,104 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import java.util.List;
+
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.lang.Batch;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.Var;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Simple batch loop to iterate over a set of Region (ROIs) from an input Sequence.
+ *
+ * @author Stephane
+ */
+public class SequenceRegionBatch extends Batch implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ // important to not initialize and create them in getBatchSource() and getBatchElement()
+ protected VarSequence inputSequence;
+ protected VarSequence element;
+ protected final VarROIArray rois;
+
+ public SequenceRegionBatch()
+ {
+ super();
+
+ rois = new VarROIArray("ROI(s)");
+ }
+
+ @Override
+ public VarSequence getBatchSource()
+ {
+ // initialize variable if needed
+ if (inputSequence == null)
+ inputSequence = new VarSequence("Sequence", null);
+
+ return inputSequence;
+ }
+
+ @Override
+ public VarSequence getBatchElement()
+ {
+ // initialize element if needed
+ if (element == null)
+ element = new VarSequence("Channel Sequence", null);
+
+ return element;
+ }
+
+ @Override
+ public void initializeLoop()
+ {
+ final Sequence value = inputSequence.getValue();
+
+ if (value == null)
+ throw new VarException(inputSequence, "No input sequence indicated");
+
+ if (rois.getValue() == null)
+ throw new VarException(rois, "No roi(s) indicated --> no region to iterate over");
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set result in element
+ element.setValue(SequenceUtil.getSubSequence(inputSequence.getValue(),
+ rois.getValue()[getIterationCounter().getValue().intValue()]));
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= rois.getValue().length;
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ super.declareInput(inputMap);
+
+ inputMap.add("ROIs", rois);
+ }
+
+ @Override
+ public void declareLoopVariables(List<Var<?>> loopVariables)
+ {
+ super.declareLoopVariables(loopVariables);
+
+ loopVariables.add(rois);
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceSliceBatch.java b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceSliceBatch.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a0440a7b96052163ea9f147b768379c7330620b
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/loop/SequenceSliceBatch.java
@@ -0,0 +1,77 @@
+package plugins.tprovoost.sequenceblocks.loop;
+
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.lang.Batch;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Simple batch loop to iterate over all Z slice from an input Sequence.
+ *
+ * @author Stephane
+ */
+public class SequenceSliceBatch extends Batch implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ // important to not initialize and create them in getBatchSource() and getBatchElement()
+ protected VarSequence inputSequence;
+ protected VarSequence element;
+
+ public SequenceSliceBatch()
+ {
+ super();
+ }
+
+ @Override
+ public VarSequence getBatchSource()
+ {
+ // initialize variable if needed
+ if (inputSequence == null)
+ inputSequence = new VarSequence("Sequence", null);
+
+ return inputSequence;
+ }
+
+ @Override
+ public VarSequence getBatchElement()
+ {
+ // initialize element if needed
+ if (element == null)
+ element = new VarSequence("Channel Sequence", null);
+
+ return element;
+ }
+
+ @Override
+ public void initializeLoop()
+ {
+ final Sequence value = inputSequence.getValue();
+
+ if (value == null)
+ throw new VarException(inputSequence, "No input sequence indicated");
+ }
+
+ @Override
+ public void beforeIteration()
+ {
+ // set result in element
+ element.setValue(
+ SequenceUtil.extractSlice(inputSequence.getValue(), getIterationCounter().getValue().intValue()));
+ }
+
+ @Override
+ public boolean isStopConditionReached()
+ {
+ return getIterationCounter().getValue().intValue() >= inputSequence.getValue().getSizeZ();
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/op/AdditiveFillSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/op/AdditiveFillSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec957c70ac0a0a08c7a85c7a221d0a5d52030143
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/op/AdditiveFillSequence.java
@@ -0,0 +1,95 @@
+/**
+ *
+ */
+package plugins.tprovoost.sequenceblocks.op;
+
+import icy.image.ImageDataIterator;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceDataIterator;
+import icy.type.DataIterator;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to do additive fill of area inside the ROI regions with the specified value.<br>
+ * The result of this operation is similar to heatmap production from ROIs.
+ *
+ * @author Stephane
+ */
+public class AdditiveFillSequence extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarROIArray rois = new VarROIArray("Roi(s)");
+
+ @Override
+ public void run()
+ {
+ final Sequence sequence = inputSequence.getValue();
+ if (sequence == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ if (rois.getValue() != null)
+ {
+ for (ROI roi : rois.getValue())
+ doAdditiveFill(sequence, roi, 1d);
+
+ sequence.dataChanged();
+ }
+ }
+
+ public static void doAdditiveFill(Sequence sequence, ROI roi, double value)
+ {
+ doAdditiveFill(new SequenceDataIterator(sequence, roi), value);
+ }
+
+ public static void doAdditiveFill(DataIterator it, double value)
+ {
+ it.reset();
+
+ while (!it.done())
+ {
+ it.set(it.get() + value);
+ it.next();
+ }
+
+ try
+ {
+ // not really nice to do that here, but it's to preserve backward compatibility
+ if (it instanceof SequenceDataIterator)
+ ((SequenceDataIterator) it).flush();
+ else if (it instanceof ImageDataIterator)
+ ((ImageDataIterator) it).flush();
+ }
+ catch (Throwable t)
+ {
+ // ignore
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("rois", rois);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/op/FillInnerSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/op/FillInnerSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..39c7c63ee2de233e5ddee6c3454eb67caf67e002
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/op/FillInnerSequence.java
@@ -0,0 +1,69 @@
+/**
+ *
+ */
+package plugins.tprovoost.sequenceblocks.op;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceDataIterator;
+import icy.type.DataIteratorUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarDouble;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to fill area inside the ROI regions with the specified value
+ *
+ * @author Stephane
+ */
+public class FillInnerSequence extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarROIArray rois = new VarROIArray("Roi(s)");
+ final protected VarDouble fillValue = new VarDouble("Value", 0d);
+
+ @Override
+ public void run()
+ {
+ final Sequence sequence = inputSequence.getValue();
+ if (sequence == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ if (rois.getValue() != null)
+ {
+ final double value = fillValue.getValue().doubleValue();
+
+ for (ROI roi : rois.getValue())
+ DataIteratorUtil.set(new SequenceDataIterator(sequence, roi), value);
+
+ sequence.dataChanged();
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("rois", rois);
+ inputMap.add("value", fillValue);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/op/FillOuterSequence.java b/src/main/java/plugins/tprovoost/sequenceblocks/op/FillOuterSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e3faea781fd71a5675b3b2af8afefbbdeebda37
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/op/FillOuterSequence.java
@@ -0,0 +1,83 @@
+/**
+ *
+ */
+package plugins.tprovoost.sequenceblocks.op;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import icy.roi.ROIUtil;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceDataIterator;
+import icy.type.DataIteratorUtil;
+import icy.type.collection.CollectionUtil;
+import icy.util.ShapeUtil.BooleanOperator;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarDouble;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.kernel.roi.roi5d.ROI5DStackRectangle;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to fill area outside the ROI regions with the specified value
+ *
+ * @author Stephane
+ */
+public class FillOuterSequence extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarROIArray rois = new VarROIArray("Roi(s)");
+ final protected VarDouble fillValue = new VarDouble("Value", 0d);
+
+ @Override
+ public void run()
+ {
+ final Sequence sequence = inputSequence.getValue();
+ if (sequence == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ if (rois.getValue() != null)
+ {
+ try
+ {
+ final ROI roiUnion = ROIUtil.merge(CollectionUtil.asList(rois.getValue()), BooleanOperator.OR);
+ final ROI roiSeq = new ROI5DStackRectangle(sequence.getBounds5D());
+ final ROI roi = roiSeq.getSubtraction(roiUnion);
+
+ final double value = fillValue.getValue().doubleValue();
+
+ DataIteratorUtil.set(new SequenceDataIterator(sequence, roi), value);
+
+ sequence.dataChanged();
+ }
+ catch (UnsupportedOperationException e)
+ {
+ throw new VarException(rois, e.getMessage());
+ }
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("rois", rois);
+ inputMap.add("value", fillValue);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveAllRois.java b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveAllRois.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ce1c1a3f93ff24a7ce22bb92fabf8f5e050f5f3
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveAllRois.java
@@ -0,0 +1,50 @@
+package plugins.tprovoost.sequenceblocks.remove;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to remove all the {@link ROI} from a Sequence
+ *
+ * @author Stephane
+ */
+public class RemoveAllRois extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+
+ @Override
+ public void run()
+ {
+ final Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ s.removeAllROI(false);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveChannel.java b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveChannel.java
new file mode 100644
index 0000000000000000000000000000000000000000..946b5cbc21e7dfffa7e3c27a32ae1b5a9c9c3342
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveChannel.java
@@ -0,0 +1,59 @@
+package plugins.tprovoost.sequenceblocks.remove;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to remove a channel from a Sequence
+ *
+ * @author Stephane
+ */
+public class RemoveChannel extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarInteger channelIdx = new VarInteger("Channel", 0);
+
+ @Override
+ public void run()
+ {
+ Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+ if (s.getSizeC() == 1)
+ throw new VarException(inputSequence, "Cannot remove channel on single channel image");
+
+ int channel = channelIdx.getValue().intValue();
+ if (channel < 0 || channel >= s.getSizeC())
+ throw new VarException(channelIdx, "Channel index must be between 0 and " + (s.getSizeC() - 1));
+
+ SequenceUtil.removeChannel(s, channel);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("channel", channelIdx);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveFrame.java b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveFrame.java
new file mode 100644
index 0000000000000000000000000000000000000000..4583bfd0a3ca4801db761ef27456083f5bf5e16b
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveFrame.java
@@ -0,0 +1,53 @@
+package plugins.tprovoost.sequenceblocks.remove;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to remove a frame from a Sequence
+ *
+ * @author Stephane
+ */
+public class RemoveFrame extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarInteger frameInd = new VarInteger("Frame", 0);
+
+ @Override
+ public void run()
+ {
+ Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ SequenceUtil.removeTAndShift(s, frameInd.getValue().intValue());
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("frame", frameInd);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveOverlays.java b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveOverlays.java
new file mode 100644
index 0000000000000000000000000000000000000000..78d90d27ef9c2723d56d26ecd3833807357e1b1d
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveOverlays.java
@@ -0,0 +1,69 @@
+/**
+ *
+ */
+package plugins.tprovoost.sequenceblocks.remove;
+
+import icy.painter.Overlay;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to remove one or several {@link Overlay} from a {@link Sequence}
+ *
+ * @author Stephane
+ */
+public class RemoveOverlays extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarArray<Overlay> overlays = new VarArray<Overlay>("Overlay(s)", Overlay[].class, new Overlay[0]);
+
+ @Override
+ public void run()
+ {
+ final Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ final Overlay[] o = overlays.getValue();
+ if (o != null)
+ {
+ s.beginUpdate();
+ try
+ {
+ for (Overlay overlay : o)
+ s.removeOverlay(overlay);
+ }
+ finally
+ {
+ s.endUpdate();
+ }
+ }
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("overlay(s)", overlays);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveRois.java b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveRois.java
new file mode 100644
index 0000000000000000000000000000000000000000..2866f0d39c92863ae77de550b4a3296bff843ece
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveRois.java
@@ -0,0 +1,58 @@
+package plugins.tprovoost.sequenceblocks.remove;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.roi.ROI;
+import icy.sequence.Sequence;
+
+import java.util.Arrays;
+
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarROIArray;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to remove one or several {@link ROI} from a Sequence
+ *
+ * @author Stephane
+ */
+public class RemoveRois extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarROIArray rois = new VarROIArray("Roi(s)");
+
+ @Override
+ public void run()
+ {
+ final Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ final ROI[] r = rois.getValue();
+ if (r != null)
+ s.removeROIs(Arrays.asList(r), false);
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("rois(s)", rois);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
diff --git a/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveSlice.java b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveSlice.java
new file mode 100644
index 0000000000000000000000000000000000000000..56fecece3e81d0ca07b1b386f7c6cf953674e677
--- /dev/null
+++ b/src/main/java/plugins/tprovoost/sequenceblocks/remove/RemoveSlice.java
@@ -0,0 +1,53 @@
+package plugins.tprovoost.sequenceblocks.remove;
+
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginBundled;
+import icy.plugin.interface_.PluginLibrary;
+import icy.sequence.Sequence;
+import icy.sequence.SequenceUtil;
+import plugins.adufour.blocks.tools.sequence.SequenceBlock;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.vars.lang.VarInteger;
+import plugins.adufour.vars.lang.VarSequence;
+import plugins.adufour.vars.util.VarException;
+import plugins.tprovoost.sequenceblocks.SequenceBlocks;
+
+/**
+ * Block to remove a Z slice from a Sequence
+ *
+ * @author Stephane
+ */
+public class RemoveSlice extends Plugin implements SequenceBlock, PluginLibrary, PluginBundled
+{
+ final protected VarSequence inputSequence = new VarSequence("Sequence", null);
+ final protected VarInteger sliceInd = new VarInteger("Slice", 0);
+
+ @Override
+ public void run()
+ {
+ Sequence s = inputSequence.getValue();
+ if (s == null)
+ throw new VarException(inputSequence, "Input sequence is null.");
+
+ SequenceUtil.removeZAndShift(s, sliceInd.getValue().intValue());
+ }
+
+ @Override
+ public void declareInput(VarList inputMap)
+ {
+ inputMap.add("sequence", inputSequence);
+ inputMap.add("slice", sliceInd);
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap)
+ {
+ //
+ }
+
+ @Override
+ public String getMainPluginClassName()
+ {
+ return SequenceBlocks.class.getName();
+ }
+}
\ No newline at end of file
diff --git a/src/main/resources/SequenceBlocks.xml b/src/main/resources/SequenceBlocks.xml
new file mode 100644
index 0000000000000000000000000000000000000000..352d4eb38a0aeb6a81adc1c6631cac5464888c03
--- /dev/null
+++ b/src/main/resources/SequenceBlocks.xml
@@ -0,0 +1,22 @@
+<?xml version='1.0' encoding='ISO-8859-1' standalone='no'?>
+<root>
+<url><![CDATA[http://www.bioimageanalysis.org/icy/repository/getXMLPluginFile.php?pluginId=182&beta=0]]></url><name>Sequence Blocks</name><version>1.0.0.1</version><required_kernel_version>1.2.5.0</required_kernel_version><kernel_ver>1.2.5.0</kernel_ver><jar_url><![CDATA[http://www.bioimageanalysis.org/icy/repository/getJarFile.php?pluginId=182&beta=0]]></jar_url><icon_url><![CDATA[http://bioimageanalysis.org/icy/image.php?idAttach=1256]]></icon_url><image_url></image_url><description><![CDATA[This plugin allows one to use various basic sequence operations within Blocks.]]></description><classname><![CDATA[plugins.tprovoost.sequenceblocks.SequenceBlocks]]></classname><author><![CDATA[tprovoost - Thomas Provoost]]></author><changelog><![CDATA[-
+Version 1.0.0.1
+Date 2012-06-22 15:17:27
+
+Added Description to the Blocks.
+Corrected Save Sequence block name.
+
+-
+Version 1.0.0.0
+Date 2012-06-21 15:37:19
+
+First real version.
+
+-
+Version 0.0.1.0
+Date 2012-06-21 15:00:05
+
+
+
+]]></changelog><dependencies><dependency><classname>plugins.adufour.blocks.Blocks</classname><version>0.0.0.1</version></dependency></dependencies></root>
\ No newline at end of file
diff --git a/src/main/resources/SequenceBlocks_icon.png b/src/main/resources/SequenceBlocks_icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..9a70e1f10004bbd8666695af79be78770dadbd1b
Binary files /dev/null and b/src/main/resources/SequenceBlocks_icon.png differ