No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Dec 18, 06:40

View Options

	diff --git a/DeconvolutionLab2/DeconvolutionLab2.config b/DeconvolutionLab2/DeconvolutionLab2.config
	index 728fdc7..73ba193 100644
	--- a/DeconvolutionLab2/DeconvolutionLab2.config
	+++ b/DeconvolutionLab2/DeconvolutionLab2.config
	@@ -1,82 +1,83 @@
	#DeconvolutionLab2 [Beta 1]
	#DeconvolutionLab2 [Beta 1]
	-#Fri Feb 03 09:17:03 CET 2017
	+#Fri Feb 03 14:47:43 CET 2017
	Algorithm.FISTA.iterations=10
	Algorithm.FISTA.reg=0.1
	Algorithm.FISTA.scale=3
	Algorithm.FISTA.step=1.0
	Algorithm.FISTA.wavelets=Haar
	Algorithm.ICTM.iterations=10
	-Algorithm.ICTM.reg=0.1
	+Algorithm.ICTM.reg=\ 1.0000
	Algorithm.ICTM.step=1.0
	Algorithm.ISTA.iterations=10
	Algorithm.ISTA.reg=0.1
	Algorithm.ISTA.scale=3
	Algorithm.ISTA.step=1.0
	Algorithm.ISTA.wavelets=Haar
	Algorithm.LW+.iterations=10
	Algorithm.LW+.step=1.0
	Algorithm.LW.iterations=10
	Algorithm.LW.step=1.0
	Algorithm.RIF.reg=0.1
	Algorithm.RL.iterations=10
	Algorithm.RLTV.reg=0.1
	Algorithm.SIM.gaussian.mean=0.0
	Algorithm.SIM.gaussian.stdev=1.0
	Algorithm.SIM.poisson=0.0
	Algorithm.TM.iterations=10
	Algorithm.TM.reg=0.1
	Algorithm.TM.step=1.0
	Algorithm.TRIF.reg=0.1
	Algorithm.VC.iterations=10
	Algorithm.VC.step=1.0
	-Algorithm.algorithm=Landweber
	+Algorithm.algorithm=Iterative Contraint Tikhonov-Miller
	Border.apoxy=Uniform
	Border.apoz=Uniform
	Border.extxy=0
	Border.extz=0
	Border.normalization=1
	Border.padxy=None
	Border.padz=None
	Controller.constraint.enable=false
	Controller.constraint.snapshot=1
	Controller.constraint.value=No
	Controller.reference.enable=false
	Controller.reference.snapshot=1
	Controller.reference.value=
	Controller.residu.enable=false
	Controller.residu.snapshot=1
	Controller.residu.value=0.01
	Controller.savestats.enable=false
	Controller.savestats.snapshot=1
	Controller.savestats.value=Stats
	Controller.showstats.enable=false
	Controller.showstats.snapshot=1
	Controller.showstats.value=Stats
	-DeconvolutionLab.MainDialog.location.h=579
	-DeconvolutionLab.MainDialog.location.w=573
	-DeconvolutionLab.MainDialog.location.x=124
	-DeconvolutionLab.MainDialog.location.y=52
	+DeconvolutionLab.MainDialog.location.h=507
	+DeconvolutionLab.MainDialog.location.w=503
	+DeconvolutionLab.MainDialog.location.x=190
	+DeconvolutionLab.MainDialog.location.y=268
	Fourier.dim=XYZ
	Fourier.epsilon=1E-6
	Fourier.fft=Academic
	Image.image.row0=Cube;synthetic;Cube 100.0 0.0 10.0 1.0 size 128 128 32 ;null
	Image.image.row1=resolution;directory;/Users/dsage/Desktop/DeconvolutionLab2-Course/resolution;null
	Image.image.selected=Cube;synthetic;Cube 100.0 0.0 10.0 1.0 size 128 128 32 ;null
	Language.headless=Run (Headless)
	Language.job=Job
	Language.language=ImageJ Macro
	-Output.output.row0=mip @1;MI1;;;;\u2713;null;null
	-Output.output.selected=mip @1;MI1;;;;\u2713;null;null
	-PSF.psf.row0=MotionBlur2D;synthetic;MotionBlur2D 100.0 0.0 3.0 3.0 3.0 size 128 128 32 ;
	+Output.output.row0=ortho;OR1;;;;\u2713;\u2713;null
	+Output.output.row1=ortho;OR1;;;;\u2713;;null
	+Output.output.selected=ortho;OR1;;;;\u2713;;null
	+PSF.psf.row0=MotionBlur2D;synthetic;MotionBlur2D 100.0 0.0 3.0 3.0 3.0 size 128 128 32 ;null
	PSF.psf.row1=Airy;synthetic;Airy 100.0 0.0 1.0 size 128 128 32 ;null
	PSF.psf.row2=Defocus;synthetic;Defocus 100.0 0.0 3.0 10.0 10.0 size 3 3 100 ;null
	-PSF.psf.selected=MotionBlur2D;synthetic;MotionBlur2D 100.0 0.0 3.0 3.0 3.0 size 128 128 32 ;
	+PSF.psf.selected=Airy;synthetic;Airy 100.0 0.0 1.0 size 128 128 32 ;null
	Watcher.disable.console=false
	Watcher.disable.display=false
	Watcher.disable.multithreading=false
	Watcher.disable.table=false
	Watcher.path=/Users/dsage/git/deconvolution/DeconvolutionLab2
	Watcher.time.value=3600
	Watcher.time=No time limitation
	Watcher.verbose=Verbose\: log
	diff --git a/DeconvolutionLab2/src/deconvolution/Deconvolution.java b/DeconvolutionLab2/src/deconvolution/Deconvolution.java
	index 7ebf639..16de499 100644
	--- a/DeconvolutionLab2/src/deconvolution/Deconvolution.java
	+++ b/DeconvolutionLab2/src/deconvolution/Deconvolution.java
	@@ -1,662 +1,663 @@
	/*
	* DeconvolutionLab2
	*
	* Conditions of use: You are free to use this software for research or
	* educational purposes. In addition, we expect you to include adequate
	* citations and acknowledgments whenever you present or publish results that
	* are based on it.
	*
	* Reference: DeconvolutionLab2: An Open-Source Software for Deconvolution
	* Microscopy D. Sage, L. Donati, F. Soulez, D. Fortun, G. Schmit, A. Seitz,
	* R. Guiet, C. Vonesch, M Unser, Methods of Elsevier, 2017.
	*/

	/*
	* Copyright 2010-2017 Biomedical Imaging Group at the EPFL.
	*
	* This file is part of DeconvolutionLab2 (DL2).
	*
	* DL2 is free software: you can redistribute it and/or modify it under the
	* terms of the GNU General Public License as published by the Free Software
	* Foundation, either version 3 of the License, or (at your option) any later
	* version.
	*
	* DL2 is distributed in the hope that it will be useful, but WITHOUT ANY
	* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	* A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License along with
	* DL2. If not, see <http://www.gnu.org/licenses/>.
	*/

	package deconvolution;

	import java.io.File;
	import java.util.ArrayList;

	import javax.swing.JFrame;

	import deconvolution.algorithm.AbstractAlgorithm;
	import deconvolution.algorithm.Controller;
	import deconvolutionlab.Lab;
	import deconvolutionlab.Output;
	import deconvolutionlab.OutputCollection;
	import deconvolutionlab.monitor.AbstractMonitor;
	import deconvolutionlab.monitor.ConsoleMonitor;
	import deconvolutionlab.monitor.Monitors;
	+import deconvolutionlab.monitor.StatusMonitor;
	import deconvolutionlab.monitor.TableMonitor;
	import deconvolutionlab.monitor.Verbose;
	import fft.AbstractFFT;
	import fft.AbstractFFTLibrary;
	import fft.FFT;
	import lab.tools.NumFormat;
	import signal.RealSignal;
	import signal.apodization.AbstractApodization;
	import signal.apodization.Apodization;
	import signal.apodization.UniformApodization;
	import signal.factory.SignalFactory;
	import signal.padding.Padding;

	public class Deconvolution implements Runnable {

	private AbstractAlgorithm algo = null;

	private String path;
	private Monitors monitors = Monitors.createDefaultMonitor();
	private Verbose verbose = Verbose.Log;
	private Controller controller;
	private OutputCollection outs;

	private Padding padding = new Padding();
	private Apodization apodization = new Apodization();
	private double factorNormalization = 1.0;
	private AbstractFFTLibrary fftlib;

	private String command = "";
	private boolean live = false;

	private ArrayList<String> report = new ArrayList<String>();

	private String name = "";
	private boolean exit = false;

	private boolean watcherMonitor = true;
	private boolean watcherConsole = true;
	private boolean watcherDisplay = true;
	private boolean watcherMultithreading = true;

	private ArrayList<DeconvolutionListener> listeners = new ArrayList<DeconvolutionListener>();

	public Deconvolution(String command) {
	super();
	monitors = Monitors.createDefaultMonitor();
	this.command = command;
	decode();
	}

	public void setCommand(String command) {
	this.command = command;
	decode();
	}

	public String getCommand() {
	return command;
	}

	public Monitors getMonitors() {
	if (monitors == null)
	return Monitors.createDefaultMonitor();
	return monitors;
	}

	/**
	* This method runs the deconvolution without graphical user interface.
	*
	* @param exit
	* System.exit call is true
	*/
	public void deconvolve(boolean exit) {
	this.exit = exit;

	monitors = new Monitors();
	if (watcherConsole)
	monitors.add(new ConsoleMonitor());

	if (watcherMonitor) {
	TableMonitor m = new TableMonitor(440, 440);
	monitors.add(m);
	String t = algo == null ? "Monitor " + name : name + " " + algo.getName();
	JFrame frame = new JFrame(t);
	frame.add(m.getPanel());
	frame.pack();
	frame.setVisible(true);
	}

	if (fftlib == null) {
	run();
	return;
	}
	if (!fftlib.isMultithreadable()) {
	run();
	return;
	}

	if (watcherMultithreading) {
	Thread thread = new Thread(this);
	thread.setPriority(Thread.MIN_PRIORITY);
	thread.start();
	}
	else {
	run();
	}

	}

	/**
	* This method runs the deconvolution with a graphical user interface.
	*
	* @param job
	* Name of the job of deconvolution
	* @param exit
	* System.exit call is true
	*/
	public void launch(String job, boolean exit) {
	this.name = job;
	this.exit = exit;
	DeconvolutionDialog d = new DeconvolutionDialog(this);
	-
	monitors = new Monitors();
	+ monitors.add(new StatusMonitor(d.getProgressBar()));
	if (watcherConsole)
	monitors.add(new ConsoleMonitor());

	if (watcherMonitor) {
	TableMonitor m = new TableMonitor(440, 440);
	monitors.add(m);
	d.addTableMonitor("Monitor", m);
	}

	}

	public void decode() {

	algo = null;

	path = System.getProperty("user.dir");
	if (monitors==null)
	monitors = Monitors.createDefaultMonitor();
	verbose = Verbose.Log;

	controller = new Controller();
	outs = new OutputCollection();

	padding = new Padding();
	apodization = new Apodization();
	factorNormalization = 1.0;
	fftlib = FFT.getLibraryByName("Academic");

	live = false;

	ArrayList<Token> tokens = Command.parse(command);
	for (Token token : tokens) {
	if (token.keyword.equalsIgnoreCase("-algorithm"))
	algo = Command.decodeAlgorithm(token, controller);

	if (token.keyword.equalsIgnoreCase("-disable")) {
	watcherMonitor = Command.decodeDisable(token, "monitor");
	watcherConsole = Command.decodeDisable(token, "console");
	watcherDisplay = Command.decodeDisable(token, "display");
	watcherMultithreading = Command.decodeDisable(token, "multithreading");
	}

	if (token.keyword.equalsIgnoreCase("-verbose"))
	verbose = Verbose.getByName(token.parameters);

	if (token.keyword.equalsIgnoreCase("-path") && !token.parameters.equalsIgnoreCase("current")) {
	path = token.parameters;
	}

	if (token.keyword.equalsIgnoreCase("-fft"))
	fftlib = FFT.getLibraryByName(token.parameters);

	if (token.keyword.equalsIgnoreCase("-pad"))
	padding = Command.decodePadding(token);
	if (token.keyword.equalsIgnoreCase("-apo"))
	apodization = Command.decodeApodization(token);
	if (token.keyword.equalsIgnoreCase("-norm"))
	factorNormalization = Command.decodeNormalization(token);
	if (token.keyword.equalsIgnoreCase("-constraint"))
	Command.decodeController(token, controller);
	if (token.keyword.equalsIgnoreCase("-time"))
	Command.decodeController(token, controller);
	if (token.keyword.equalsIgnoreCase("-residu"))
	Command.decodeController(token, controller);
	if (token.keyword.equalsIgnoreCase("-reference"))
	Command.decodeController(token, controller);
	if (token.keyword.equalsIgnoreCase("-savestats"))
	Command.decodeController(token, controller);
	if (token.keyword.equalsIgnoreCase("-showstats"))
	Command.decodeController(token, controller);

	if (token.keyword.equals("-out")) {
	Output out = Command.decodeOut(token);
	if (out != null)
	outs.add(out);
	}
	}

	if (name.equals("") && algo != null)
	name = algo.getShortname();

	}

	public void setApodization(ArrayList<AbstractApodization> apos) {
	AbstractApodization apoXY = new UniformApodization();
	AbstractApodization apoZ = new UniformApodization();
	if (apos.size() >= 1)
	apoXY = apos.get(0);
	if (apos.size() >= 2)
	apoZ = apos.get(1);
	this.apodization = new Apodization(apoXY, apoXY, apoZ);
	}

	@Override
	public void run() {
	double chrono = System.nanoTime();

	for(DeconvolutionListener listener : listeners)
	listener.started();

	live = true;
	if (monitors != null)
	monitors.setVerbose(verbose);

	report.add("Path: " + checkPath(path));
	monitors.log("Path: " + checkPath(path));

	RealSignal image = openImage();

	if (image == null) {
	monitors.error("Image: Not valid " + command);
	report.add("Image: Not valid");
	if (exit)
	System.exit(-101);
	return;
	}
	report.add("Image: " + image.dimAsString());

	monitors.log("Image: " + image.nx + " x " + image.ny + " x " + image.nz);
	RealSignal y = padding.pad(monitors, getApodization().apodize(monitors, image));

	RealSignal psf = openPSF();
	if (psf == null) {
	monitors.error("PSF: not valid");
	report.add("PSF: Not valid");
	if (exit)
	System.exit(-102);
	return;
	}
	report.add("PSF: " + psf.dimAsString());

	monitors.log("PSF: " + psf.nx + " x " + psf.ny + " x " + psf.nz);
	monitors.log("PSF: normalization " + (factorNormalization <= 0 ? "no" : factorNormalization));
	RealSignal h = psf.changeSizeAs(y).normalize(factorNormalization);

	if (algo == null) {
	monitors.error("Algorithm: not valid");
	if (exit)
	System.exit(-103);
	return;
	}

	if (controller == null) {
	monitors.error("Controller: not valid");
	if (exit)
	System.exit(-104);
	return;
	}

	AbstractFFT fft;
	if (fftlib != null)
	fft = FFT.createFFT(monitors, fftlib, image.nx, image.ny, image.nz);
	else
	fft = FFT.createDefaultFFT(monitors, image.nx, image.ny, image.nz);
	report.add("FFT: " + fft.getName());

	algo.setFFT(fft);
	controller.setFFT(fft);

	algo.setController(controller);
	if (outs != null) {
	outs.setPath(path);
	controller.setOutputs(outs);
	}

	monitors.log("Algorithm: " + algo.getName());
	report.add("Algorithm: " + algo.getName());

	RealSignal x = algo.run(monitors, y, h, true);

	RealSignal result = padding.crop(monitors, x);

	if (outs != null)
	outs.executeFinal(monitors, result, controller);

	live = false;
	for(DeconvolutionListener listener : listeners)
	listener.finish();

	report.add("End " + algo.getName() + " in " + NumFormat.time(System.nanoTime()-chrono));

	if (watcherDisplay)
	Lab.show(monitors, result, "Result of " + algo.getShortname());

	if (exit) {
	System.out.println("End");
	System.exit(0);
	}

	}

	/**
	* This methods make a recap of the deconvolution. Useful before starting the processing.
	*
	* @return list of messages to print
	*/
	public ArrayList<String> recap() {
	ArrayList<String> lines = new ArrayList<String>();
	Token image = Command.extract(command, "-image");
	if (image == null)
	lines.add("<b>Image</b>: <span color=\"red\">keyword -image not found</span>");
	else
	lines.add("<b>Image</b>: " + image.parameters);

	String norm = (factorNormalization < 0 ? " (no normalization)" : " (normalization to " + factorNormalization + ")");
	Token psf = Command.extract(command, "-psf");
	if (psf == null)
	lines.add("<b>PSF</b>: <span color=\"red\">keyword -psf not found</span>");
	else
	lines.add("<b>PSF</b>: " + psf.parameters + norm);

	if (algo == null) {
	lines.add("<b>Algorithm</b>: <span color=\"red\">not valid</span>");
	}
	else {
	Controller controller = algo.getController();
	String con = ", " + controller.getConstraintAsString() + " constraint";
	lines.add("<b>Algorithm</b>: " + algo.toString() + con);
	lines.add("<b>Stopping Criteria</b>: " + controller.getStoppingCriteria(algo));
	lines.add("<b>Reference</b>: " + controller.getReference());
	lines.add("<b>Stats</b>: " + controller.getShowStats() + " " + controller.getSaveStats());
	lines.add("<b>Padding</b>: " + padding.toString());
	lines.add("<b>Apodization</b>: " + apodization.toString());
	if (algo.getFFT() != null)
	lines.add("<b>FFT</b>: " + algo.getFFT().getName());
	}
	lines.add("<b>Path</b>: " + path);

	lines.add("<b>Verbose</b>: " + verbose.name().toLowerCase());
	lines.add("<b>Monitor</b>: " + (watcherMonitor ? "on" : "off"));
	lines.add("<b>Console</b>: " + (watcherConsole ? "on" : "off"));
	lines.add("<b>Final Display</b>: " + (watcherDisplay ? "on" : "off"));
	lines.add("<b>Multithreading</b>: " + (watcherMultithreading ? "on" : "off"));

	if (outs == null)
	lines.add("<b>Outputs</b>: not valid");
	else
	lines.addAll(outs.getInformation());
	return lines;
	}

	public ArrayList<String> checkAlgo() {
	ArrayList<String> lines = new ArrayList<String>();
	RealSignal image = openImage();
	if (image == null) {
	lines.add("No valid input image");
	return lines;
	}
	if (padding == null) {
	lines.add("No valid padding");
	return lines;
	}
	if (apodization == null) {
	lines.add("No valid apodization");
	return lines;
	}
	RealSignal psf = openPSF();
	if (psf == null) {
	lines.add("No valid PSF");
	return lines;
	}
	if (algo == null) {
	lines.add("No valid algorithm");
	return lines;
	}

	Controller controller = algo.getController();
	RealSignal y = padding.pad(monitors, getApodization().apodize(monitors, image));
	RealSignal h = psf.changeSizeAs(y).normalize(factorNormalization);

	int iter = controller.getIterationMax();
	algo.getController().setIterationMax(1);
	RealSignal x = algo.run(monitors, y, h, true);
	Lab.show(monitors, x, "Estimate after 1 iteration");
	lines.add("Time: " + NumFormat.seconds(controller.getTimeNano()));
	lines.add("Peak Memory: " + controller.getMemoryAsString());
	controller.setIterationMax(iter);
	return lines;
	}

	public ArrayList<String> checkImage() {
	ArrayList<String> lines = new ArrayList<String>();
	RealSignal image = openImage();
	if (image == null) {
	lines.add("No valid input image");
	return lines;
	}
	if (padding == null) {
	lines.add("No valid padding");
	return lines;
	}
	if (apodization == null) {
	lines.add("No valid apodization");
	return lines;
	}

	RealSignal signal = padding.pad(monitors, getApodization().apodize(monitors, image));
	lines.add("<b>Image</b>");
	lines.add("Original size " + image.dimAsString() + " padded to " + signal.dimAsString());
	lines.add("Original: " + formatStats(image));
	lines.add("Preprocessing: " + formatStats(signal));

	Lab.show(monitors, signal, "Image");
	return lines;
	}

	public ArrayList<String> checkPSF() {
	ArrayList<String> lines = new ArrayList<String>();
	RealSignal image = openImage();
	if (image == null) {
	lines.add("No valid input image");
	return lines;
	}
	if (padding == null) {
	lines.add("No valid padding");
	return lines;
	}
	if (apodization == null) {
	lines.add("No valid apodization");
	return lines;
	}

	RealSignal psf = openPSF();
	if (psf == null) {
	lines.add("No valid PSF");
	return lines;
	}

	RealSignal signal = padding.pad(monitors, getApodization().apodize(monitors, image));
	RealSignal h = psf.changeSizeAs(signal);
	lines.add("<b>PSF</b>");
	lines.add("Original size " + psf.dimAsString() + " padded to " + h.dimAsString());

	String e = NumFormat.nice(h.getEnergy());

	h.normalize(factorNormalization);
	lines.add("Original: " + formatStats(psf));
	lines.add("Preprocessing: " + formatStats(h));
	lines.add("Energy = " + e + " and after normalization=" + NumFormat.nice(h.getEnergy()));
	Lab.show(monitors, h, "Padded and Normalized PSF");
	return lines;
	}

	public ArrayList<String> getDeconvolutionReports() {
	return report;
	}

	public String getName() {
	return name;
	}

	public boolean isLive() {
	return live;
	}

	public void abort() {
	live = false;
	algo.getController().abort();
	}

	public Padding getPadding1() {
	return padding;
	}

	public Apodization getApodization() {
	return apodization;
	}

	public OutputCollection getOuts() {
	return outs;
	}

	public AbstractAlgorithm getAlgo() {
	return algo;
	}

	public String getPath() {
	return path;
	}

	public String checkPath(String path) {
	File dir = new File(path);
	if (dir.exists()) {
	if (dir.isDirectory()) {
	if (dir.canWrite())
	return path + " (writable)";
	else
	return path + " (non-writable)";
	}
	else {
	return path + " (non-directory)";
	}
	}
	else {
	return path + " (not-valid)";
	}
	}

	public RealSignal openImage() {
	Token token = Command.extract(command, "-image");
	if (token == null)
	return null;
	if (token.parameters.startsWith(">>>"))
	return null;
	return getImage(monitors, token);
	}

	public RealSignal openPSF() {
	Token token = Command.extract(command, "-psf");
	if (token == null)
	return null;
	if (token.parameters.startsWith(">>>"))
	return null;
	return getImage(monitors, token);
	}

	private RealSignal getImage(Monitors monitors, Token token) {
	String arg = token.option.trim();
	String cmd = token.parameters.substring(arg.length(), token.parameters.length()).trim();

	if (arg.equalsIgnoreCase("synthetic")) {
	String parts[] = cmd.split(" ");
	if (parts.length <= 0)
	return null;
	String shape = parts[0];
	for (String name : SignalFactory.getAllName()) {
	if (shape.equalsIgnoreCase(name.toLowerCase())) {
	double params[] = Command.parseNumeric(cmd);
	SignalFactory factory = SignalFactory.getFactoryByName(shape);
	if (factory == null)
	return null;
	double amplitude = params.length > 0 ? params[0] : 1;
	double background = params.length > 1 ? params[1] : 0;
	factory.intensity(background, amplitude);
	int np = factory.getParameters().length;
	double[] features = new double[np];
	for (int i = 0; i < Math.min(np, params.length); i++)
	features[i] = params[i + 2];
	factory.setParameters(features);
	int nx = params.length > np + 2 ? (int) Math.round(params[np + 2]) : 128;
	int ny = params.length > np + 3 ? (int) Math.round(params[np + 3]) : 128;
	int nz = params.length > np + 4 ? (int) Math.round(params[np + 4]) : 128;
	double cx = params.length > np + 5 ? params[np + 5] : 0.5;
	double cy = params.length > np + 6 ? params[np + 6] : 0.5;
	double cz = params.length > np + 7 ? params[np + 7] : 0.5;
	factory = factory.center(cx, cy, cz);
	RealSignal x = factory.generate(nx, ny, nz);
	return x;
	}
	}
	}
	if (arg.equalsIgnoreCase("file") \|\| arg.equalsIgnoreCase("dir") \|\| arg.equalsIgnoreCase("directory")) {
	RealSignal signal = null;
	File file = new File(path + File.separator + cmd);
	if (file != null) {
	if (file.isFile())
	signal = Lab.open(monitors, path + File.separator + cmd);
	if (file.isDirectory())
	signal = Lab.openDir(monitors, path + File.separator + cmd);
	}
	if (signal == null) {
	File local = new File(cmd);
	if (local != null) {
	if (local.isFile())
	signal = Lab.open(monitors, cmd);
	if (local.isDirectory())
	signal = Lab.openDir(monitors, cmd);
	}
	}
	return signal;

	}

	if (arg.equalsIgnoreCase("platform")) {
	return Lab.getImager().create(cmd);
	}

	return null;
	}

	private static String formatStats(RealSignal x) {
	float stats[] = x.getStats();
	String s = " mean=" + NumFormat.nice(stats[0]);
	s += " stdev=" + NumFormat.nice(stats[1]);
	s += " min=" + NumFormat.nice(stats[3]);
	s += " max=" + NumFormat.nice(stats[2]);
	return s;
	}

	public void addDeconvolutionListener(DeconvolutionListener listener) {
	listeners.add(listener);
	}

	}
	diff --git a/DeconvolutionLab2/src/deconvolution/DeconvolutionDialog.java b/DeconvolutionLab2/src/deconvolution/DeconvolutionDialog.java
	index 2bd4aff..7d7f83f 100644
	--- a/DeconvolutionLab2/src/deconvolution/DeconvolutionDialog.java
	+++ b/DeconvolutionLab2/src/deconvolution/DeconvolutionDialog.java
	@@ -1,299 +1,319 @@
	/*
	* DeconvolutionLab2
	*
	* Conditions of use: You are free to use this software for research or
	* educational purposes. In addition, we expect you to include adequate
	* citations and acknowledgments whenever you present or publish results that
	* are based on it.
	*
	* Reference: DeconvolutionLab2: An Open-Source Software for Deconvolution
	* Microscopy D. Sage, L. Donati, F. Soulez, D. Fortun, G. Schmit, A. Seitz,
	* R. Guiet, C. Vonesch, M Unser, Methods of Elsevier, 2017.
	*/

	/*
	* Copyright 2010-2017 Biomedical Imaging Group at the EPFL.
	*
	* This file is part of DeconvolutionLab2 (DL2).
	*
	* DL2 is free software: you can redistribute it and/or modify it under the
	* terms of the GNU General Public License as published by the Free Software
	* Foundation, either version 3 of the License, or (at your option) any later
	* version.
	*
	* DL2 is distributed in the hope that it will be useful, but WITHOUT ANY
	* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	* A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License along with
	* DL2. If not, see <http://www.gnu.org/licenses/>.
	*/

	package deconvolution;

	-import ij.gui.GUI;
	-
	import java.awt.BorderLayout;
	import java.awt.Dimension;
	import java.awt.GridLayout;
	+import java.awt.Point;
	+import java.awt.Toolkit;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import java.awt.event.KeyEvent;
	import java.awt.event.KeyListener;
	import java.text.SimpleDateFormat;
	import java.util.ArrayList;
	import java.util.Date;

	import javax.swing.BorderFactory;
	import javax.swing.BoxLayout;
	import javax.swing.JButton;
	import javax.swing.JDialog;
	import javax.swing.JFrame;
	import javax.swing.JLabel;
	import javax.swing.JPanel;
	import javax.swing.JProgressBar;
	import javax.swing.JTabbedPane;
	import javax.swing.JToolBar;
	import javax.swing.text.BadLocationException;

	import lab.component.HTMLPane;
	import lab.system.SystemBar;
	import deconvolutionlab.Lab;
	import deconvolutionlab.monitor.StatusMonitor;
	import deconvolutionlab.monitor.TableMonitor;

	public class DeconvolutionDialog extends JDialog implements ActionListener, Runnable, KeyListener, DeconvolutionListener {

	public enum State {NOTDEFINED, READY, RUN, FINISH};

	private JButton bnStart = new JButton("Run");
	private JButton bnQuit = new JButton("Quit");
	private JButton bnRecap = new JButton("Recap");
	private JButton bnImage = new JButton("Check Image");
	private JButton bnPSF = new JButton("Check PSF");
	private JButton bnAlgo = new JButton("Check Algo");
	private JButton bnHelp = new JButton("Help");
	private JTabbedPane tab = new JTabbedPane();

	private HTMLPane pnCommand;
	private HTMLPane pnResume;

	private JButton job = null;
	private Thread thread = null;

	private Deconvolution deconvolution;
	private State state = State.NOTDEFINED;
	-
	+ private JProgressBar progress = new JProgressBar();
	+
	+ public static Point location = new Point(0, 0);
	+
	public DeconvolutionDialog(Deconvolution deconvolution) {
	super(new JFrame(), deconvolution.getName() + " " + new SimpleDateFormat("dd/MM/yy HH:m:s").format(new Date()));

	this.deconvolution = deconvolution;
	- JProgressBar status = new JProgressBar();
	- deconvolution.getMonitors().add(new StatusMonitor(status));

	pnCommand = new HTMLPane("Monaco", 100, 100);
	pnCommand.append("p", deconvolution.getCommand());
	- pnResume = new HTMLPane("Verdana", 600, 150);
	+ pnResume = new HTMLPane("Verdana", 450, 150);

	tab.add("Resume", pnResume.getPane());

	pnCommand.setEditable(true);
	pnCommand.addKeyListener(this);
	JPanel bn = new JPanel();
	bn.setLayout(new GridLayout(1, 5));
	bn.setBorder(BorderFactory.createEtchedBorder());
	bn.add(bnRecap);
	bn.add(bnImage);
	bn.add(bnPSF);
	bn.add(bnAlgo);
	bn.add(bnStart);

	- status.setAlignmentX(JLabel.CENTER_ALIGNMENT);
	- status.setBorder(BorderFactory.createLoweredBevelBorder());
	+ progress.setAlignmentX(JLabel.CENTER_ALIGNMENT);
	+ progress.setBorder(BorderFactory.createLoweredBevelBorder());
	JToolBar statusBar = new JToolBar();
	statusBar.setBorder(BorderFactory.createLoweredBevelBorder());
	statusBar.setFloatable(false);
	statusBar.setLayout(new BorderLayout());
	statusBar.add(bnHelp, BorderLayout.WEST);
	- statusBar.add(status, BorderLayout.CENTER);
	+ statusBar.add(progress, BorderLayout.CENTER);
	statusBar.add(bnQuit, BorderLayout.EAST);

	JPanel bottom = new JPanel();
	bottom.setLayout(new BoxLayout(bottom, BoxLayout.PAGE_AXIS));
	bottom.add(bn);
	bottom.add(new SystemBar(200));
	bottom.add(statusBar);

	JPanel panel = new JPanel();
	panel.setLayout(new BorderLayout());
	panel.add(pnCommand.getPane(), BorderLayout.NORTH);
	panel.add(bottom, BorderLayout.SOUTH);
	panel.add(tab, BorderLayout.CENTER);

	add(panel);
	bnQuit.addActionListener(this);
	bnStart.addActionListener(this);
	bnPSF.addActionListener(this);
	bnImage.addActionListener(this);
	bnAlgo.addActionListener(this);
	bnRecap.addActionListener(this);
	bnHelp.addActionListener(this);
	deconvolution.addDeconvolutionListener(this);

	setMinimumSize(new Dimension(400, 200));
	+ setLocation(location);
	+
	pack();
	- GUI.center(this);
	+ location.x = location.x + 20;
	+ location.y = location.y + 20;
	+
	+ Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
	+ double width = screenSize.getWidth();
	+ double height = screenSize.getHeight();
	+ if (location.x + 400 > width)
	+ location.x = 0;
	+ if (location.y + 200 > height)
	+ location.y = 0;
	+
	setVisible(true);

	print(deconvolution.recap());
	state = State.READY;
	}

	@Override
	public void actionPerformed(ActionEvent e) {

	if (e.getSource() == bnStart) {
	if (state == State.FINISH)
	print(deconvolution.getDeconvolutionReports());
	else if (thread == null) {
	job = bnStart;
	thread = new Thread(this);
	thread.setPriority(Thread.MIN_PRIORITY);
	thread.start();
	}
	else {
	finish();
	if (deconvolution != null)
	deconvolution.abort();
	}
	}
	else if (e.getSource() == bnRecap) {
	if (thread == null) {
	job = bnRecap;
	thread = new Thread(this);
	thread.setPriority(Thread.MIN_PRIORITY);
	thread.start();
	}
	}
	else if (e.getSource() == bnImage) {
	if (thread == null) {
	job = bnImage;
	thread = new Thread(this);
	thread.setPriority(Thread.MIN_PRIORITY);
	thread.start();
	}
	}
	else if (e.getSource() == bnPSF) {
	if (thread == null) {
	job = bnPSF;
	thread = new Thread(this);
	thread.setPriority(Thread.MIN_PRIORITY);
	thread.start();
	}
	}
	else if (e.getSource() == bnAlgo) {
	if (thread == null) {
	job = bnAlgo;
	thread = new Thread(this);
	thread.setPriority(Thread.MIN_PRIORITY);
	thread.start();
	}
	}

	else if (e.getSource() == bnQuit) {
	dispose();
	}
	else if (e.getSource() == bnHelp)
	Lab.help();
	}

	@Override
	public void run() {

	bnRecap.setEnabled(false);
	bnAlgo.setEnabled(false);
	bnPSF.setEnabled(false);
	bnImage.setEnabled(false);
	bnStart.setEnabled(false);
	String command = pnCommand.getText();
	deconvolution.setCommand(command);
	if (job == bnStart) {
	if (tab.getTabCount() > 1)
	tab.setSelectedIndex(1);
	else
	print(deconvolution.recap());
	deconvolution.run();
	print(deconvolution.getDeconvolutionReports());
	}
	else if (job == bnRecap) {
	tab.setSelectedIndex(0);
	print(deconvolution.recap());
	}
	else if (job == bnImage) {
	tab.setSelectedIndex(0);
	print(deconvolution.checkImage());
	}
	else if (job == bnPSF) {
	tab.setSelectedIndex(0);
	print(deconvolution.checkPSF());
	}
	else if (job == bnAlgo) {
	tab.setSelectedIndex(0);
	print(deconvolution.checkAlgo());
	}
	bnRecap.setEnabled(true);
	bnAlgo.setEnabled(true);
	bnPSF.setEnabled(true);
	bnImage.setEnabled(true);
	bnStart.setEnabled(true);
	thread = null;
	}

	private void print(ArrayList<String> lines) {
	pnResume.clear();
	for (String line : lines)
	pnResume.append("p", line);
	}

	public void addTableMonitor(String title, TableMonitor tm) {
	tab.add(title, tm.getPanel());
	}

	@Override
	public void keyTyped(KeyEvent e) {
	}

	@Override
	public void keyPressed(KeyEvent e) {
	}

	@Override
	public void keyReleased(KeyEvent e) {
	try {
	int len = pnCommand.getDocument().getLength();
	String command = pnCommand.getDocument().getText(0, len);
	deconvolution.setCommand(command);
	print(deconvolution.recap());
	}
	catch (BadLocationException e1) {
	e1.printStackTrace();
	}
	}

	@Override
	public void started() {
	bnStart.setEnabled(true);
	bnStart.setText("Abort");
	state = State.RUN;
	- tab.setSelectedIndex(0);
	}

	@Override
	public void finish() {
	bnStart.setEnabled(true);
	bnStart.setText("Report");
	state = State.FINISH;
	tab.setSelectedIndex(0);
	}
	+
	+ public JProgressBar getProgressBar() {
	+ return progress;
	+ }
	+
	+ public static void setLocationLaunch(Point l) {
	+ location = l;
	+ }

	}
	diff --git a/DeconvolutionLab2/src/deconvolutionlab/dialog/LabDialog.java b/DeconvolutionLab2/src/deconvolutionlab/dialog/LabDialog.java
	index 2540c63..eb6a80c 100644
	--- a/DeconvolutionLab2/src/deconvolutionlab/dialog/LabDialog.java
	+++ b/DeconvolutionLab2/src/deconvolutionlab/dialog/LabDialog.java
	@@ -1,365 +1,371 @@
	/*
	* DeconvolutionLab2
	*
	* Conditions of use: You are free to use this software for research or
	* educational purposes. In addition, we expect you to include adequate
	* citations and acknowledgments whenever you present or publish results that
	* are based on it.
	*
	* Reference: DeconvolutionLab2: An Open-Source Software for Deconvolution
	* Microscopy D. Sage, L. Donati, F. Soulez, D. Fortun, G. Schmit, A. Seitz,
	* R. Guiet, C. Vonesch, M Unser, Methods of Elsevier, 2017.
	*/

	/*
	* Copyright 2010-2017 Biomedical Imaging Group at the EPFL.
	*
	* This file is part of DeconvolutionLab2 (DL2).
	*
	* DL2 is free software: you can redistribute it and/or modify it under the
	* terms of the GNU General Public License as published by the Free Software
	* Foundation, either version 3 of the License, or (at your option) any later
	* version.
	*
	* DL2 is distributed in the hope that it will be useful, but WITHOUT ANY
	* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	* A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License along with
	* DL2. If not, see <http://www.gnu.org/licenses/>.
	*/

	package deconvolutionlab.dialog;

	import java.awt.BorderLayout;
	import java.awt.Dimension;
	import java.awt.GridLayout;
	+import java.awt.Point;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import java.awt.event.ComponentEvent;
	import java.awt.event.ComponentListener;
	import java.awt.event.WindowEvent;
	import java.awt.event.WindowListener;
	import java.util.ArrayList;

	import javax.swing.BorderFactory;
	import javax.swing.JButton;
	import javax.swing.JDialog;
	import javax.swing.JFrame;
	import javax.swing.JPanel;
	import javax.swing.JTabbedPane;
	import javax.swing.border.Border;
	import javax.swing.event.ChangeEvent;
	import javax.swing.event.ChangeListener;

	import deconvolution.Command;
	import deconvolution.Deconvolution;
	+import deconvolution.DeconvolutionDialog;
	import deconvolutionlab.Config;
	import deconvolutionlab.Constants;
	import deconvolutionlab.Lab;
	import deconvolutionlab.Platform;
	import deconvolutionlab.modules.AboutModule;
	import deconvolutionlab.modules.AbstractModule;
	import deconvolutionlab.modules.AlgorithmModule;
	import deconvolutionlab.modules.BatchModule;
	import deconvolutionlab.modules.BorderModule;
	import deconvolutionlab.modules.CommandModule;
	import deconvolutionlab.modules.ConfigModule;
	import deconvolutionlab.modules.ControllerModule;
	import deconvolutionlab.modules.FFTModule;
	import deconvolutionlab.modules.GroupedModulePanel;
	import deconvolutionlab.modules.ImageModule;
	import deconvolutionlab.modules.LanguageModule;
	import deconvolutionlab.modules.LicenceModule;
	import deconvolutionlab.modules.WatcherModule;
	import deconvolutionlab.modules.OutputModule;
	import deconvolutionlab.modules.PSFModule;
	import lab.component.PanelImage;
	import lab.system.SystemPanel;

	public class LabDialog extends JDialog implements ComponentListener, ActionListener, ChangeListener, WindowListener {

	private JTabbedPane tab = new JTabbedPane();
	private JButton bnHelp = new JButton("Help");
	private JButton bnClose = new JButton("Close");
	private JButton bnQuit = new JButton("Quit");
	private JButton bnBatch = new JButton("Batch");
	private JButton bnRun = new JButton("Run");
	private JButton bnLaunch = new JButton("Launch");
	private JButton bnSystem = new JButton("System");

	private ImageModule image;
	private PSFModule psf;
	private AlgorithmModule algo;
	private AboutModule about;
	private LicenceModule licence;
	private OutputModule output;
	private FFTModule fourier;
	private BorderModule border;
	private ConfigModule config;
	private BatchModule batch;
	private LanguageModule language;
	private CommandModule command;
	private WatcherModule watcher;

	private ControllerModule controller;

	private GroupedModulePanel panelDeconv;
	private GroupedModulePanel panelAdvanc;
	private GroupedModulePanel panelProgra;
	private GroupedModulePanel panelAbout;
	private AbstractModule modules[];

	public LabDialog() {
	super(new JFrame(), Constants.name);
	image = new ImageModule(false);
	psf = new PSFModule(false);
	algo = new AlgorithmModule(true);
	output = new OutputModule(true);
	fourier = new FFTModule(false);
	border = new BorderModule(false);
	controller = new ControllerModule(false);
	batch = new BatchModule(false);
	language = new LanguageModule(false);
	about = new AboutModule(true);
	licence = new LicenceModule(false);
	config = new ConfigModule(false);
	command = new CommandModule();
	watcher = new WatcherModule(false);

	doDialog();
	- modules = new AbstractModule[] { image, psf, algo, output, controller, border, fourier, watcher };
	+ modules = new AbstractModule[] { image, psf, algo, output, controller, border, fourier, watcher, batch };

	Command.active(modules, command);
	Command.command();

	addWindowListener(this);
	addComponentListener(this);
	((GroupedModulePanel) tab.getSelectedComponent()).organize();
	setMinimumSize(new Dimension(500, 500));
	Config.registerFrame("DeconvolutionLab", "MainDialog", this);

	pack();
	setVisible(true);
	Config.load();
	sizeModule();
	Command.command();
	image.update();
	psf.update();
	output.update();
	}

	private void doDialog() {

	panelDeconv = new GroupedModulePanel(buildDeconvolutionPanel(), this);
	panelAdvanc = new GroupedModulePanel(buildAdvancedPanel(), this);
	panelProgra = new GroupedModulePanel(buildProgrammingPanel(), this);
	panelAbout = new GroupedModulePanel(buildAboutPanel(), this);
	PanelImage bottom = new PanelImage("celegans.jpg");
	bottom.setLayout(new GridLayout(1, 7));
	Border b2 = BorderFactory.createEmptyBorder(10, 10, 10, 10);
	bottom.setBorder(b2);

	bottom.add(bnHelp);
	bottom.add(bnSystem);
	bottom.add(bnQuit);
	bottom.add(bnClose);
	bottom.add(bnBatch);
	bottom.add(bnRun);
	bottom.add(bnLaunch);

	tab.add("Deconvolution", panelDeconv);
	tab.add("Advanced", panelAdvanc);
	tab.add("Programming", panelProgra);
	tab.add("About", panelAbout);
	tab.addChangeListener(this);

	JPanel base = new JPanel(new BorderLayout());
	base.add(bottom, BorderLayout.CENTER);
	//base.add(statusBar, BorderLayout.SOUTH);

	add(tab, BorderLayout.CENTER);
	add(base, BorderLayout.SOUTH);

	bnBatch.addActionListener(this);
	bnRun.addActionListener(this);
	bnLaunch.addActionListener(this);
	bnClose.addActionListener(this);
	bnHelp.addActionListener(this);
	bnQuit.addActionListener(this);
	bnSystem.addActionListener(this);

	}

	@Override
	public void actionPerformed(ActionEvent e) {

	if (e.getSource() == bnHelp) {
	Lab.help();
	}
	else if (e.getSource() == bnSystem) {
	SystemPanel.show(400, 400);
	}
	else if (e.getSource() == bnClose) {
	Config.store();
	close();
	dispose();
	}
	else if (e.getSource() == bnQuit) {
	close();
	dispose();
	}
	else if (e.getSource() == bnBatch) {
	tab.setSelectedIndex(2);
	batch.expand();
	+ sizeModule();
	new BatchDialog(batch);
	}
	else if (e.getSource() == bnLaunch) {
	new Deconvolution(Command.command()).launch("", false);
	}
	else if (e.getSource() == bnRun) {
	new Deconvolution(Command.command()).deconvolve(false);
	}
	}

	@Override
	public void stateChanged(ChangeEvent e) {
	((GroupedModulePanel) tab.getSelectedComponent()).organize();
	Command.command();
	}

	private ArrayList<AbstractModule> buildDeconvolutionPanel() {
	ArrayList<AbstractModule> list = new ArrayList<AbstractModule>();
	list.add(image);
	list.add(psf);
	list.add(algo);
	list.add(watcher);
	return list;
	}

	private ArrayList<AbstractModule> buildAdvancedPanel() {
	ArrayList<AbstractModule> list = new ArrayList<AbstractModule>();
	list.add(output);
	list.add(controller);
	list.add(border);
	list.add(fourier);
	return list;
	}

	private ArrayList<AbstractModule> buildProgrammingPanel() {
	ArrayList<AbstractModule> list = new ArrayList<AbstractModule>();
	+ list.add(batch);
	list.add(command);
	list.add(language);
	- list.add(batch);
	return list;
	}

	private ArrayList<AbstractModule> buildAboutPanel() {
	ArrayList<AbstractModule> list = new ArrayList<AbstractModule>();
	list.add(about);
	list.add(licence);
	list.add(config);
	return list;
	}

	@Override
	public void windowOpened(WindowEvent e) {
	}

	@Override
	public void windowClosing(WindowEvent e) {
	Config.store();
	close();
	dispose();
	}

	@Override
	public void windowClosed(WindowEvent e) {
	}

	@Override
	public void windowIconified(WindowEvent e) {
	}

	@Override
	public void windowDeiconified(WindowEvent e) {
	}

	@Override
	public void windowActivated(WindowEvent e) {
	}

	@Override
	public void windowDeactivated(WindowEvent e) {
	}

	private void close() {
	for (AbstractModule module : modules)
	module.close();
	bnLaunch.removeActionListener(this);
	bnRun.removeActionListener(this);
	bnBatch.removeActionListener(this);
	bnClose.removeActionListener(this);
	bnHelp.removeActionListener(this);
	bnQuit.removeActionListener(this);
	removeWindowListener(this);
	}

	@Override
	public void dispose() {
	super.dispose();
	if (Lab.getPlatform() == Platform.STANDALONE) System.exit(0);
	}

	@Override
	public void componentResized(ComponentEvent e) {
	sizeModule();
	}

	@Override
	public void componentMoved(ComponentEvent e) {
	+ Point p = this.getLocation();
	+ p.x += this.getWidth();
	+ DeconvolutionDialog.setLocationLaunch(p);
	}

	@Override
	public void componentShown(ComponentEvent e) {
	sizeModule();
	}

	@Override
	public void componentHidden(ComponentEvent e) {
	}

	public void sizeModule() {
	if (tab.getSelectedIndex() == 0) sizePanel(panelDeconv);
	if (tab.getSelectedIndex() == 1) sizePanel(panelAdvanc);
	if (tab.getSelectedIndex() == 2) sizePanel(panelProgra);
	if (tab.getSelectedIndex() == 3) sizePanel(panelAbout);
	}

	private void sizePanel(GroupedModulePanel panel) {
	Dimension dim = getSize();
	int hpc = 60;
	int npc = hpc * panel.getModules().size();
	Dimension small = new Dimension(dim.width, hpc);
	Dimension large = new Dimension(dim.width, dim.height - npc);
	for (AbstractModule module : panel.getModules()) {
	if (module.isExpanded()) {
	module.setPreferredSize(large);
	module.setMaximumSize(large);
	module.setMinimumSize(small);
	module.getExpandedPanel().setPreferredSize(large);
	module.getExpandedPanel().setMaximumSize(large);
	module.getExpandedPanel().setMinimumSize(small);

	}
	else {
	module.setPreferredSize(small);
	module.setMaximumSize(small);
	module.setMinimumSize(small);
	module.getCollapsedPanel().setPreferredSize(small);
	module.getCollapsedPanel().setMaximumSize(small);
	module.getCollapsedPanel().setMinimumSize(small);
	}
	}
	}
	}
	diff --git a/DeconvolutionLab2/src/deconvolutionlab/modules/BatchModule.java b/DeconvolutionLab2/src/deconvolutionlab/modules/BatchModule.java
	index 7e08089..e68c434 100644
	--- a/DeconvolutionLab2/src/deconvolutionlab/modules/BatchModule.java
	+++ b/DeconvolutionLab2/src/deconvolutionlab/modules/BatchModule.java
	@@ -1,188 +1,189 @@
	/*
	* DeconvolutionLab2
	*
	* Conditions of use: You are free to use this software for research or
	* educational purposes. In addition, we expect you to include adequate
	* citations and acknowledgments whenever you present or publish results that
	* are based on it.
	*
	* Reference: DeconvolutionLab2: An Open-Source Software for Deconvolution
	* Microscopy D. Sage, L. Donati, F. Soulez, D. Fortun, G. Schmit, A. Seitz,
	* R. Guiet, C. Vonesch, M Unser, Methods of Elsevier, 2017.
	*/

	/*
	* Copyright 2010-2017 Biomedical Imaging Group at the EPFL.
	*
	* This file is part of DeconvolutionLab2 (DL2).
	*
	* DL2 is free software: you can redistribute it and/or modify it under the
	* terms of the GNU General Public License as published by the Free Software
	* Foundation, either version 3 of the License, or (at your option) any later
	* version.
	*
	* DL2 is distributed in the hope that it will be useful, but WITHOUT ANY
	* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	* A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License along with
	* DL2. If not, see <http://www.gnu.org/licenses/>.
	*/

	package deconvolutionlab.modules;

	import java.awt.BorderLayout;
	import java.awt.GridLayout;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import java.awt.event.MouseEvent;
	import java.awt.event.MouseListener;
	import java.util.ArrayList;

	import javax.swing.BorderFactory;
	import javax.swing.JButton;
	import javax.swing.JPanel;
	import javax.swing.JToolBar;
	import javax.swing.ListSelectionModel;

	import deconvolution.Deconvolution;
	import deconvolutionlab.Constants;
	import lab.component.CustomizedColumn;
	import lab.component.CustomizedTable;

	public class BatchModule extends AbstractModule implements MouseListener, ActionListener {

	private CustomizedTable table;
	private JButton bnScript;
	private JButton bnRunAll;
	private JButton bnRunJob;
	private JButton bnLaunchAll;
	private JButton bnLaunchJob;

	public BatchModule(boolean expanded) {
	super("Batch", "", "", "", expanded);
	}

	@Override
	public String getCommand() {
	return "DeconvolutionLab2 " + Constants.version;
	}

	@Override
	public JPanel buildExpandedPanel() {

	bnScript = new JButton("Create Script (not yet implemented)");
	bnRunAll = new JButton("Run All Jobs");
	bnRunJob = new JButton("Run Selected Jobs");
	bnLaunchAll = new JButton("Launch All Jobs");
	bnLaunchJob = new JButton("Launch Selected Jobs");

	ArrayList<CustomizedColumn> columns = new ArrayList<CustomizedColumn>();
	columns.add(new CustomizedColumn("Job", String.class, 120, false));
	columns.add(new CustomizedColumn("Command", String.class, Constants.widthGUI, false));
	columns.add(new CustomizedColumn("", String.class, 30, "\u232B", "Delete this job"));

	table = new CustomizedTable(columns, true);
	table.getColumnModel().getColumn(2).setMaxWidth(30);
	table.getColumnModel().getColumn(2).setMinWidth(30);
	table.addMouseListener(this);
	table.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

	JToolBar pn = new JToolBar("Controls Batch");
	pn.setBorder(BorderFactory.createEmptyBorder());
	pn.setLayout(new GridLayout(1, 5));
	pn.setFloatable(false);
	pn.add(bnScript);
	pn.add(bnRunAll);
	pn.add(bnRunJob);
	pn.add(bnLaunchAll);
	pn.add(bnLaunchJob);

	JPanel panel = new JPanel(new BorderLayout());
	panel.add(table.getPane(100, 100), BorderLayout.CENTER);
	panel.add(pn, BorderLayout.SOUTH);
	getAction1Button().addActionListener(this);

	bnScript.addActionListener(this);
	bnRunAll.addActionListener(this);
	bnRunJob.addActionListener(this);
	bnLaunchAll.addActionListener(this);
	bnLaunchJob.addActionListener(this);
	return panel;
	}

	@Override
	public void actionPerformed(ActionEvent e) {
	+ super.actionPerformed(e);
	if (e.getSource() == bnRunJob) {
	int rows[] = table.getSelectedRows();
	for (int row : rows) {
	new Deconvolution(table.getCell(row, 1)).deconvolve(false);
	}
	}
	else if (e.getSource() == bnLaunchJob) {
	int rows[] = table.getSelectedRows();
	for (int row : rows) {
	new Deconvolution(table.getCell(row, 1)).launch(table.getCell(row, 0), false);
	}
	}
	else if (e.getSource() == bnRunAll) {
	for (int row = 0; row < table.getRowCount(); row++) {
	new Deconvolution(table.getCell(row, 1)).deconvolve(false);
	}
	}
	else if (e.getSource() == bnLaunchAll) {
	for (int row = 0; row < table.getRowCount(); row++) {
	new Deconvolution(table.getCell(row, 1)).launch(table.getCell(row, 0), false);
	}
	}
	}

	private void update() {
	setSynopsis("" + table.getRowCount() + " jobs");
	}

	public int getCountJob() {
	return table.getRowCount();
	}

	public void addJob(String name, String command) {
	table.append(new String[] { name, command, "" });
	update();
	}

	@Override
	public void mouseClicked(MouseEvent e) {
	if (e.getSource() == table) {
	int row = table.getSelectedRow();
	if (row < 0)
	return;
	if (table.getSelectedColumn() == 2) {
	table.removeRow(row);
	if (table.getRowCount() > 0)
	table.setRowSelectionInterval(0, 0);
	}
	}
	update();
	}

	@Override
	public void mousePressed(MouseEvent e) {
	}

	@Override
	public void mouseReleased(MouseEvent e) {
	}

	@Override
	public void mouseEntered(MouseEvent e) {
	}

	@Override
	public void mouseExited(MouseEvent e) {
	}

	@Override
	public void close() {
	getAction1Button().removeActionListener(this);
	}
	}

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions