No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Tue, Jul 23, 13:26

View Options

	diff --git a/DeconvolutionLab2/plugins.config b/DeconvolutionLab2/plugins.config
	index 2831334..37416fd 100644
	--- a/DeconvolutionLab2/plugins.config
	+++ b/DeconvolutionLab2/plugins.config
	@@ -1,15 +1,12 @@
	# Name: DeconvolutionLab 2

	# Daniel Sage
	# Biomedical Imaging Group
	# Ecole Polytechnique Federale de Lausanne (EPFL), Lausanne, Switzerland

	# Date: 11 July 2016

	-Plugins>DeconvolutionLab2, "DeconvolutionLab2 Lab", DeconvolutionLab2_Lab
	-Plugins>DeconvolutionLab2, "DeconvolutionLab2 Launch", DeconvolutionLab2_Launch
	-Plugins>DeconvolutionLab2, "DeconvolutionLab2 Run", DeconvolutionLab2_Run
	-Plugins>DeconvolutionLab2, "DeconvolutionLab2 FFT", DeconvolutionLab2_FFT
	-Plugins>DeconvolutionLab2, "DeconvolutionLab2 Help", DeconvolutionLab2_Help
	-
	-
	+Plugins>DeconvolutionLab2, Lab, "DeconvolutionLab2 Lab", DeconvolutionLab2_Lab
	+Plugins>DeconvolutionLab2, Run, "DeconvolutionLab2 Run", DeconvolutionLab2_Run
	+Plugins>DeconvolutionLab2, Launch, "DeconvolutionLab2 Launch", DeconvolutionLab2_Launch
	+Plugins>DeconvolutionLab2, Help, "DeconvolutionLab2 Help", DeconvolutionLab2_Help
	diff --git a/DeconvolutionLab2/src/deconvolution/Command.java b/DeconvolutionLab2/src/deconvolution/Command.java
	index 6a66a7d..ba2839f 100644
	--- a/DeconvolutionLab2/src/deconvolution/Command.java
	+++ b/DeconvolutionLab2/src/deconvolution/Command.java
	@@ -1,432 +1,432 @@
	/*
	* 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.IJ;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import bilib.tools.Files;
	import bilib.tools.NumFormat;
	import deconvolution.algorithm.AbstractAlgorithm;
	import deconvolution.algorithm.Algorithm;
	import deconvolution.algorithm.Controller;
	import deconvolutionlab.Constants;
	import deconvolutionlab.module.AbstractModule;
	import deconvolutionlab.module.CommandModule;
	import deconvolutionlab.monitor.ConsoleMonitor;
	import deconvolutionlab.monitor.Monitors;
	import deconvolutionlab.monitor.TableMonitor;
	import deconvolutionlab.monitor.Verbose;
	import deconvolutionlab.output.Output;
	import deconvolutionlab.output.Output.View;
	import fft.FFT;
	import signal.Constraint;
	import signal.Operations;
	import signal.apodization.AbstractApodization;
	import signal.apodization.Apodization;
	import signal.apodization.UniformApodization;
	import signal.padding.AbstractPadding;
	import signal.padding.NoPadding;
	import signal.padding.Padding;
	import wavelets.Wavelets;

	public class Command {

	public static String keywords[] = { "-image", "-psf", "-algorithm", "-path", "-disable", "-verbose", "-monitor", "-display", "-multithreading", "-system", "-stats", "-constraint", "-time", "-residu", "-reference", "-out", "-pad", "-apo", "-norm", "-fft", "-epsilon" };

	private static AbstractModule modules[];
	private static CommandModule command;

	public static void active(AbstractModule[] m, CommandModule c) {
	modules = m;
	command = c;
	}

	public static String command() {
	if (modules == null)
	return "";
	String cmd = "";
	for (AbstractModule m : modules)
	cmd += m.getCommand() + " ";

	if (command != null)
	command.setCommand(cmd);
	return cmd;
	}

	public static Controller decodeController(String command) {

	Controller controller = new Controller();

	ArrayList<Token> tokens = parse(command);
	for (Token token : tokens) {
	if (token.keyword.equalsIgnoreCase("-path")) {
	if (token.parameters.trim().equals("current"))
	controller.setPath(Files.getWorkingDirectory());
	else if (token.parameters.trim().equals("home"))
	controller.setPath(Files.getHomeDirectory());
	else if (token.parameters.trim().equals("desktop"))
	controller.setPath(Files.getDesktopDirectory());
	else
	controller.setPath(token.parameters);
	}
	if (token.keyword.equalsIgnoreCase("-monitor"))
	controller.setMonitors(decodeMonitors(token.parameters));

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

	if (token.keyword.equalsIgnoreCase("-system"))
	controller.setSystem(decodeBoolean(token.parameters));

	if (token.keyword.equalsIgnoreCase("-multithreading"))
	controller.setMultithreading(decodeBoolean(token.parameters));

	if (token.keyword.equalsIgnoreCase("-display"))
	controller.setDisplayFinal(decodeBoolean(token.parameters));

	if (token.keyword.equalsIgnoreCase("-stats"))
	controller.setStats(decodeStats(token));

	if (token.keyword.equalsIgnoreCase("-constraint"))
	controller.setConstraint(decodeConstraint(token));

	if (token.keyword.equalsIgnoreCase("-time"))
	controller.setTimeLimit(decodeTimeLimit(token));

	if (token.keyword.equalsIgnoreCase("-residu"))
	controller.setResiduMin(decodeResidu(token));

	if (token.keyword.equalsIgnoreCase("-reference"))
	- controller.setReference(token.parameters);
	+ controller.setReferenceName(token.parameters);

	if (token.keyword.equalsIgnoreCase("-pad"))
	controller.setPadding(decodePadding(token));

	if (token.keyword.equalsIgnoreCase("-apo"))
	controller.setApodization(decodeApodization(token));

	if (token.keyword.equalsIgnoreCase("-norm"))
	controller.setNormalizationPSF(decodeNormalization(token));

	if (token.keyword.equalsIgnoreCase("-epsilon"))
	Operations.epsilon = NumFormat.parseNumber(token.parameters, 1e-6);

	if (token.keyword.equalsIgnoreCase("-fft"))
	controller.setFFT(FFT.getLibraryByName(token.parameters).getDefaultFFT());

	if (token.keyword.equalsIgnoreCase("-epsilon"))
	Operations.epsilon = NumFormat.parseNumber(token.parameters, 1e-6);

	if (token.keyword.equals("-out")) {
	Output out = decodeOut(token);
	if (out != null)
	controller.addOutput(out);
	}
	}
	return controller;
	}

	public static AbstractAlgorithm decodeAlgorithm(String command) {
	AbstractAlgorithm algo = Algorithm.getDefaultAlgorithm();
	ArrayList<Token> tokens = parse(command);
	for (Token token : tokens) {
	if (token.keyword.equalsIgnoreCase("-algorithm"))
	algo = Command.decodeAlgorithm(token);
	}
	return algo;
	}

	/**
	* This methods first segments the command line, then create all the tokens
	* of the command line
	*
	* @param command
	* Command line
	* @return the list of tokens extracted from the command line
	*/
	public static ArrayList<Token> parse(String command) {

	ArrayList<CommandSegment> segments = new ArrayList<CommandSegment>();
	for (String keyword : keywords)
	segments.addAll(findSegment(command, keyword));
	Collections.sort(segments);

	ArrayList<Token> tokens = new ArrayList<Token>();
	for (int i = 0; i < segments.size(); i++) {
	String keyword = segments.get(i).keyword;
	int begin = segments.get(i).index + keyword.length() + 1;
	int end = (i < segments.size() - 1 ? segments.get(i + 1).index : command.length());
	Token token = new Token(keyword, command, begin, end);
	tokens.add(token);
	}
	return tokens;
	}

	public static Token extract(String command, String keyword) {
	ArrayList<Token> tokens = parse(command);
	for (Token token : tokens)
	if (token.keyword.equalsIgnoreCase(keyword))
	return token;
	return (Token) null;
	}

	public static double[] parseNumeric(String line) {
	ArrayList<String> num = new ArrayList<String>();
	Pattern p = Pattern.compile("[-+]?[0-9]+[.]?[0-9]*([eE][-+]?[0-9]+)?");
	Matcher m = p.matcher(line);
	while (m.find()) {
	num.add(m.group());
	}
	double number[] = new double[num.size()];
	for (int i = 0; i < num.size(); i++)
	number[i] = Double.parseDouble(num.get(i));
	return number;
	}

	public static ArrayList<CommandSegment> findSegment(String command, String keyword) {
	ArrayList<CommandSegment> segments = new ArrayList<CommandSegment>();
	String regex = "(?<!\\w)" + keyword + "(?!\\w)";
	if (command == null)
	return segments;
	Matcher matcher = Pattern.compile(regex).matcher(command);
	while (matcher.find()) {
	segments.add(new CommandSegment(keyword, matcher.start()));
	}
	return segments;
	}

	public static String extractOptions(String command) {
	ArrayList<CommandSegment> segments = new ArrayList<CommandSegment>();
	for (String keyword : keywords)
	segments.addAll(findSegment(command, keyword));
	Collections.sort(segments);

	String options = "";
	for (int i = 0; i < segments.size(); i++) {
	String keyword = segments.get(i).keyword;
	int begin = segments.get(i).index + keyword.length() + 1;
	int end = (i < segments.size() - 1 ? segments.get(i + 1).index : command.length());
	if (keyword != "-image" && keyword != "-psf" && keyword != "-algorithm")
	options += keyword + " " + command.substring(begin, end);
	}
	return options;
	}

	public static AbstractAlgorithm decodeAlgorithm(Token token) {
	String option = token.option;
	AbstractAlgorithm algo = Algorithm.createAlgorithm(option);
	double params[] = parseNumeric(token.parameters);

	if (params != null) {
	algo.setParameters(params);
	}

	if (algo.isWaveletsBased()) {
	for (String wavelet : Wavelets.getWaveletsAsArray()) {
	int pos = token.parameters.toLowerCase().indexOf(wavelet.toLowerCase());
	if (pos >= 0)
	algo.setWavelets(wavelet);
	}
	}
	return algo;
	}

	public static Output decodeOut(Token token) {
	int freq = 0;
	String line = token.parameters;
	String parts[] = token.parameters.split(" ");
	for (int i = 0; i < Math.min(2, parts.length); i++) {
	if (parts[i].startsWith("@"))
	freq = (int) NumFormat.parseNumber(parts[i], 0);
	}

	String p = token.parameters.toLowerCase();
	Output out = null;
	if (p.startsWith("stack"))
	out = new Output(View.STACK, freq, line.substring("stack".length(), line.length()));
	if (p.startsWith("series"))
	out = new Output(View.SERIES, freq, line.substring("series".length(), line.length()));
	if (p.startsWith("mip"))
	out = new Output(View.MIP, freq, line.substring("mip".length(), line.length()));
	if (p.startsWith("ortho"))
	out = new Output(View.ORTHO, freq, line.substring("ortho".length(), line.length()));
	if (p.startsWith("figure"))
	out = new Output(View.FIGURE, freq, line.substring("figure".length(), line.length()));
	if (p.startsWith("planar"))
	out = new Output(View.PLANAR, freq, line.substring("planar".length(), line.length()));

	return out;
	}

	public static double decodeNormalization(Token token) {
	if (token.parameters.toLowerCase().endsWith("no"))
	return 0;
	else
	return NumFormat.parseNumber(token.parameters, 1);
	}

	public static Stats decodeStats(Token token) {
	String parts[] = token.parameters.toLowerCase().split(" ");
	int m = 0;
	for (String p : parts) {
	if (p.startsWith("no") \|\| p.equals("false") \|\| p.equals("0"))
	return new Stats(Stats.Mode.NO);
	if (p.equals("1"))
	return new Stats(Stats.Mode.SHOW);
	if (p.equals("2"))
	return new Stats(Stats.Mode.SAVE);
	if (p.equals("3"))
	return new Stats(Stats.Mode.SHOWSAVE);
	if (p.equals("show"))
	m += 1;
	if (p.equals("save"))
	m += 2;
	}
	if (m==1)
	return new Stats(Stats.Mode.SHOW);
	if (m==2)
	return new Stats(Stats.Mode.SAVE);
	if (m==3)
	return new Stats(Stats.Mode.SHOWSAVE);
	return new Stats(Stats.Mode.NO);

	}

	public static Constraint.Mode decodeConstraint(Token token) {
	String p = token.parameters.toLowerCase();
	if (p.startsWith("non"))
	return Constraint.Mode.NONNEGATIVE;
	if (p.startsWith("no"))
	return Constraint.Mode.NO;
	if (p.startsWith("clip"))
	return Constraint.Mode.CLIPPED;
	if (p.equals("0"))
	return Constraint.Mode.NO;
	return Constraint.Mode.NO;
	}

	public static double decodeResidu(Token token) {
	if (token.parameters.toLowerCase().endsWith("no"))
	return -1;
	else
	return NumFormat.parseNumber(token.parameters, 1);
	}

	public static double decodeTimeLimit(Token token) {
	if (token.parameters.toLowerCase().endsWith("no"))
	return -1;
	else
	return NumFormat.parseNumber(token.parameters, 1);
	}

	public static Padding decodePadding(Token token) {
	AbstractPadding padXY = new NoPadding();
	AbstractPadding padZ = new NoPadding();
	String param = token.parameters.trim();
	String[] parts = param.split(" ");
	if (parts.length > 0)
	padXY = Padding.getByShortname(parts[0].trim());
	if (parts.length > 1)
	padZ = Padding.getByShortname(parts[1].trim());
	double[] ext = NumFormat.parseNumbers(param);
	int extXY = 0;
	if (ext.length > 0)
	extXY = (int) Math.round(ext[0]);
	int extZ = 0;
	if (ext.length > 1)
	extZ = (int) Math.round(ext[1]);

	return new Padding(padXY, padXY, padZ, extXY, extXY, extZ);
	}

	public static Apodization decodeApodization(Token token) {
	AbstractApodization apoXY = new UniformApodization();
	AbstractApodization apoZ = new UniformApodization();
	String[] parts = token.parameters.trim().split(" ");
	if (parts.length >= 1)
	apoXY = Apodization.getByShortname(parts[0].trim());
	if (parts.length >= 2)
	apoZ = Apodization.getByShortname(parts[1].trim());
	return new Apodization(apoXY, apoXY, apoZ);
	}

	public static String getPath() {
	command();
	ArrayList<Token> tokens = parse(command.getCommand());
	String path = System.getProperty("user.dir");
	for (Token token : tokens)
	if (token.keyword.equalsIgnoreCase("-path") && !token.parameters.equalsIgnoreCase("current"))
	path = token.parameters;
	return path;
	}

	public static Monitors decodeMonitors(String cmd) {
	String parts[] = cmd.toLowerCase().split(" ");
	Monitors monitors = new Monitors();
	for (String p : parts) {
	if (p.equals("0") \|\| p.startsWith("no"))
	monitors.clear();
	if (p.equals("1") \|\| p.startsWith("console"))
	monitors.add(new ConsoleMonitor());
	if (p.equals("2"))
	monitors.add(new TableMonitor(Constants.widthGUI, 240));
	if (p.equals("3")) {
	monitors.add(new ConsoleMonitor());
	monitors.add(new TableMonitor(Constants.widthGUI, 240));
	}
	if (p.equals("console"))
	monitors.add(new ConsoleMonitor());
	if (p.equals("table"))
	monitors.add(new TableMonitor(Constants.widthGUI, 240));
	}
	return monitors;
	}

	public static boolean decodeBoolean(String cmd) {
	String p = cmd.toLowerCase();
	if (p.startsWith("no"))
	return false;
	if (p.equals("0"))
	return false;
	if (p.equals("false"))
	return false;
	if (p.startsWith("dis"))
	return false;
	return true;
	}

	}
	diff --git a/DeconvolutionLab2/src/deconvolution/Deconvolution.java b/DeconvolutionLab2/src/deconvolution/Deconvolution.java
	index d3b0936..0e66cb9 100644
	--- a/DeconvolutionLab2/src/deconvolution/Deconvolution.java
	+++ b/DeconvolutionLab2/src/deconvolution/Deconvolution.java
	@@ -1,410 +1,410 @@
	/*
	* 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.IJ;

	import java.io.File;

	import bilib.tools.NumFormat;
	import deconvolution.algorithm.AbstractAlgorithm;
	import deconvolution.algorithm.Controller;
	import deconvolutionlab.Lab;
	import deconvolutionlab.monitor.AbstractMonitor;
	import deconvolutionlab.monitor.Monitors;
	import deconvolutionlab.monitor.StatusMonitor;
	import deconvolutionlab.monitor.TableMonitor;
	import deconvolutionlab.output.Output;
	import signal.RealSignal;
	import signal.SignalCollector;

	/**
	* This class is the main class to run deconvolution with or without user interface.
	*
	* All the parameters are given in the command line (String variable command).
	*
	* @author Daniel Sage
	*
	*/
	public class Deconvolution implements Runnable {

	public enum Finish {
	DIE, ALIVE, KILL
	};

	private AbstractAlgorithm algo = null;
	private Controller controller = new Controller();
	private String command = "";
	private Features report = new Features();
	private String name = "";
	public RealSignal image;
	public RealSignal psf;
	private RealSignal deconvolvedImage;
	private Finish finish = Finish.DIE;
	private DeconvolutionDialog dialog;

	private boolean embeddedStats = false;

	public Deconvolution(String name, String command) {
	this.name = name;
	this.finish = Finish.DIE;
	setCommand(command);
	}

	public Deconvolution(String name, String command, Finish finish) {
	this.name = name;
	this.finish = finish;
	setCommand(command);
	}

	public void setCommand(String command) {
	this.command = command;
	controller = Command.decodeController(command);
	algo = Command.decodeAlgorithm(command);
	algo.setController(controller);
	this.command = command;
	if (name.equals("") && algo != null)
	name = algo.getShortnames()[0];
	}

	public RealSignal deconvolve() {
	return deconvolve(image, psf);
	}

	public RealSignal deconvolve(RealSignal image, RealSignal psf) {
	this.image = image;
	this.psf = psf;
	for(AbstractMonitor monitor : controller.getMonitors())
	if (monitor instanceof TableMonitor)
	Lab.setVisible(((TableMonitor)monitor).getPanel(), "Monitor of " + name, 10, 10);

	if (controller.getFFT() == null) {
	run();
	return deconvolvedImage;
	}

	if (!controller.getFFT().isMultithreadable()) {
	run();
	return deconvolvedImage;
	}

	if (controller.isMultithreading()) {
	Thread thread = new Thread(this);
	thread.setPriority(Thread.MIN_PRIORITY);
	thread.start();
	}
	else {
	run();
	}
	return deconvolvedImage;
	}

	/**
	* This method runs the deconvolution with a graphical user interface.
	*/
	public void launch() {
	embeddedStats = true;
	dialog = new DeconvolutionDialog(DeconvolutionDialog.Module.ALL, this);
	Lab.setVisible(dialog, false);
	}

	@Override
	public void run() {
	double chrono = System.nanoTime();
	Monitors monitors = controller.getMonitors();

	report.add("Path", controller.toStringPath());

	if (image == null)
	image = openImage();

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

	psf = openPSF();

	if (psf == null) {
	monitors.error("PSF: not valid");
	report.add("PSF", "Not valid");
	if (finish == Finish.KILL)
	System.exit(-102);
	return;
	}
	report.add("PSF", psf.dimAsString());

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

	report.add("FFT", controller.getFFT().getName());
	report.add("Algorithm", algo.getName());

	if (embeddedStats) {
	TableMonitor tableMonitor = null;
	for(AbstractMonitor monitor : controller.getMonitors())
	if (monitor instanceof TableMonitor)
	tableMonitor = (TableMonitor)monitor;
	if (controller.getStats().getMode() == Stats.Mode.SHOW \|\| controller.getStats().getMode() == Stats.Mode.SHOWSAVE) {
	controller.getStats().setEmbeddedInFrame(embeddedStats);
	dialog.addStats(controller.getStats());
	}
	if (tableMonitor != null) {
	dialog.addMonitor(tableMonitor);
	}
	}
	algo.setController(controller);
	deconvolvedImage = algo.run(image, psf);

	report.add("End", NumFormat.time(System.nanoTime() - chrono));


	if (finish == Finish.KILL) {
	System.out.println("End");
	System.exit(0);
	}

	if (finish == Finish.DIE)
	die();
	}

	public void close() {
	if (dialog != null)
	dialog.dispose();
	SignalCollector.free(image);
	SignalCollector.free(psf);
	SignalCollector.free(deconvolvedImage);
	algo = null;
	image = null;
	psf = null;
	deconvolvedImage = null;
	System.gc();
	}

	public void die() {
	SignalCollector.free(image);
	SignalCollector.free(psf);
	}

	/**
	* This methods make a recap of the deconvolution. Useful before starting
	* the processing.
	*
	* @return list of messages to print
	*/
	public Features recap() {
	Features features = new Features();
	Token image = Command.extract(command, "-image");
	features.add("Image", image == null ? "keyword -image not found" : image.parameters);
	double norm = controller.getNormalizationPSF();
	String normf = (norm < 0 ? " (no normalization)" : " (normalization to " + norm + ")");
	Token psf = Command.extract(command, "-psf");
	features.add("PSF", psf == null ? "keyword -psf not found" : psf.parameters + " norm:" + normf);

	if (algo == null) {
	features.add("Algorithm", "not valid>");
	}
	else {
	Controller controller = algo.getController();
	features.add("Algorithm", algo.toString());
	features.add("Stopping Criteria", controller.getStoppingCriteriaAsString(algo));
	- features.add("Reference", controller.getReference());
	+ features.add("Reference", controller.getReferenceName());
	features.add("Constraint", controller.getConstraintAsString());
	features.add("Padding", controller.getPadding().toString());
	features.add("Apodization", controller.getApodization().toString());
	features.add("FFT", controller.getFFT() == null ? "null" : controller.getFFT().getName());
	}
	features.add("Path", controller.getPath());

	String s = "[" + controller.getVerbose().name() + "] ";
	for(AbstractMonitor monitor : controller.getMonitors())
	s+= monitor.getName() + " ";
	features.add("Monitor", s);
	if (controller.getStats() != null)
	features.add("Stats", controller.getStats().toStringStats());
	features.add("Running", controller.toStringRunning());

	for (Output out : controller.getOuts())
	features.add("Output " + out.getName(), out.toString());

	controller.getMonitors().log("Recap deconvolution parameters");
	return features;
	}

	public Features checkOutput() {
	Features features = new Features();
	if (deconvolvedImage == null) {
	features.add("Image", "No valid output image");
	return features;
	}
	float stati[] = deconvolvedImage.getStats();
	int sizi = deconvolvedImage.nx * deconvolvedImage.ny * deconvolvedImage.nz;
	float totali = stati[0] * sizi;
	features.add("<html><b>Deconvolved Image</b></html>", "");
	features.add("Size", deconvolvedImage.dimAsString() + " " + NumFormat.bytes(sizi * 4));
	features.add("Mean (stdev)", NumFormat.nice(stati[0]) + " (" + NumFormat.nice(stati[3]) + ")");
	features.add("Min ... Max", NumFormat.nice(stati[1]) + " ... " + NumFormat.nice(stati[2]));
	features.add("Energy (int)", NumFormat.nice(stati[5]) + " (" + NumFormat.nice(totali) + ")");
	return features;
	}

	public void abort() {
	algo.getController().abort();
	}

	public RealSignal openImage() {
	Token token = Command.extract(command, "-image");

	if (token == null)
	return null;

	if (token.parameters.startsWith(">>>"))
	return null;
	String arg = token.option.trim();

	String cmd = token.parameters.substring(arg.length(), token.parameters.length()).trim();

	image = createRealSignal(controller.getMonitors(), arg, cmd, controller.getPath());
	controller.getMonitors().log("Open image " + arg + " " + cmd);

	return image;
	}

	public RealSignal openPSF() {
	Token token = Command.extract(command, "-psf");
	if (token == null)
	return null;
	if (token.parameters.startsWith(">>>"))
	return null;
	String arg = token.option.trim();
	String cmd = token.parameters.substring(arg.length(), token.parameters.length()).trim();
	psf = createRealSignal(controller.getMonitors(), arg, cmd, controller.getPath());
	controller.getMonitors().log("Open PSF " + arg + " " + cmd);
	return psf;
	}

	private static RealSignal createRealSignal(Monitors monitors, String arg, String cmd, String path) {
	RealSignal signal = null;
	if (arg.equalsIgnoreCase("synthetic")) {
	signal = Lab.createSynthetic(monitors, cmd);
	}

	if (arg.equalsIgnoreCase("platform")) {
	signal = Lab.getImage(monitors, cmd);
	}

	if (arg.equalsIgnoreCase("file")) {
	File file = new File(path + File.separator + cmd);
	if (file != null) {
	if (file.isFile())
	signal = Lab.openFile(monitors, path + File.separator + cmd);
	}
	if (signal == null) {
	File local = new File(cmd);
	if (local != null) {
	if (local.isFile())
	signal = Lab.openFile(monitors, cmd);
	}
	}
	}

	if (arg.equalsIgnoreCase("dir") \|\| arg.equalsIgnoreCase("directory")) {
	File file = new File(path + File.separator + cmd);
	if (file != null) {
	if (file.isDirectory())
	signal = Lab.openDir(monitors, path + File.separator + cmd);
	}
	if (signal == null) {
	File local = new File(cmd);
	if (local != null) {
	if (local.isDirectory())
	signal = Lab.openDir(monitors, cmd);
	}
	}
	}
	return signal;
	}

	public void setAlgorithm(AbstractAlgorithm algo) {
	this.algo = algo;
	}

	public AbstractAlgorithm getAlgorithm() {
	return algo;
	}

	public void setController(Controller controller) {
	this.controller = controller;
	}

	public Controller getController() {
	return controller;
	}

	public RealSignal getOutput() {
	return deconvolvedImage;
	}

	public RealSignal getImage() {
	return image;
	}

	public RealSignal getPSF() {
	return psf;
	}

	public Features getDeconvolutionReports() {
	return report;
	}

	public String getName() {
	return name;
	}

	public Monitors getMonitors() {
	return controller.getMonitors();
	}

	public String getCommand() {
	return command;
	}

	}
	diff --git a/DeconvolutionLab2/src/deconvolution/algorithm/AbstractAlgorithm.java b/DeconvolutionLab2/src/deconvolution/algorithm/AbstractAlgorithm.java
	index 1566acd..76b202d 100644
	--- a/DeconvolutionLab2/src/deconvolution/algorithm/AbstractAlgorithm.java
	+++ b/DeconvolutionLab2/src/deconvolution/algorithm/AbstractAlgorithm.java
	@@ -1,479 +1,479 @@
	/*
	* 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.algorithm;

	import java.util.ArrayList;
	import java.util.concurrent.Callable;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Executors;
	import java.util.concurrent.Future;

	import signal.Constraint;
	import signal.RealSignal;
	import signal.SignalCollector;
	import signal.apodization.Apodization;
	import signal.padding.Padding;
	import bilib.tools.NumFormat;
	import deconvolution.Stats;
	import deconvolutionlab.Lab;
	import deconvolutionlab.monitor.Monitors;
	import deconvolutionlab.monitor.Verbose;
	import deconvolutionlab.output.Output;
	import deconvolutionlab.system.SystemInfo;
	import fft.AbstractFFT;
	import fft.FFT;

	/**
	* This class is the common part of every algorithm of deconvolution.
	*
	* @author Daniel Sage
	*
	*/
	public abstract class AbstractAlgorithm implements Callable<RealSignal> {

	/** y is the input signal of the deconvolution. */
	protected RealSignal y;

	/** h is the PSF signal for the deconvolution. */
	protected RealSignal h;

	protected boolean threaded;

	/** Optimized implementation in term of memory footprint */
	protected boolean optimizedMemoryFootprint;

	protected int iterMax = 0;

	protected AbstractFFT fft;
	protected Controller controller;

	public AbstractAlgorithm() {
	setController(new Controller());
	optimizedMemoryFootprint = true;
	threaded = true;
	fft = FFT.getFastestFFT().getDefaultFFT();
	}

	public AbstractAlgorithm(Controller controller) {
	this.controller = controller;
	optimizedMemoryFootprint = true;
	threaded = true;
	fft = FFT.getFastestFFT().getDefaultFFT();
	}

	public void setOptimizedMemoryFootprint(boolean optimizedMemoryFootprint) {
	this.optimizedMemoryFootprint = optimizedMemoryFootprint;
	}

	public abstract String getName();
	public abstract String[] getShortnames();
	public abstract double getMemoryFootprintRatio();
	public abstract int getComplexityNumberofFFT();
	public abstract boolean isRegularized();
	public abstract boolean isStepControllable();
	public abstract boolean isIterative();
	public abstract boolean isWaveletsBased();
	public abstract AbstractAlgorithm setParameters(double... params);
	public abstract double getRegularizationFactor();
	public abstract double getStepFactor();
	public abstract double[] getParameters();

	public abstract double[] getDefaultParameters();

	public RealSignal run(RealSignal image, RealSignal psf) {

	String sn = getShortnames()[0];
	String algoParam = sn + "(" + getParametersAsString() + ")";
	if (controller.isSystem())
	SystemInfo.activate();

	Padding pad = controller.getPadding();
	Apodization apo = controller.getApodization();
	double norm = controller.getNormalizationPSF();

	controller.setAlgoName(algoParam);
	fft = controller.getFFT();
	controller.setIterationsMax(iterMax);

	if (image == null)
	return null;

	if (psf == null)
	return null;

	// Prepare the controller and the outputs

	Monitors monitors = controller.getMonitors();
	monitors.setVerbose(controller.getVerbose());
	monitors.log("Path: " + controller.toStringPath());
	monitors.log("Algorithm: " + getName());

	// Prepare the signal and the PSF
	y = pad.pad(monitors, image);
	y.setName("y");
	apo.apodize(monitors, y);
	monitors.log("Input: " + y.dimAsString());
	h = psf.changeSizeAs(y);
	h.setName("h");
	h.normalize(norm);
	monitors.log("PSF: " + h.dimAsString() + " normalized " + (norm <= 0 ? "no" : norm));

	String iterations = (isIterative() ? iterMax + " iterations" : "direct");

	controller.setIterationsMax(iterMax);

	monitors.log(sn + " is starting (" + iterations + ")");
	controller.setMonitors(monitors);

	controller.start(y);
	h.circular();

	// FFT
	fft.init(monitors, y.nx, y.ny, y.nz);
	controller.setFFT(fft);

	monitors.log(sn + " data ready");
	monitors.log(algoParam);

	RealSignal x = null;

	try {
	if (threaded == true) {
	ExecutorService pool = Executors.newSingleThreadExecutor();
	Future<RealSignal> future = pool.submit(this);
	x = future.get();
	}
	else {
	x = call();
	}
	}
	catch (InterruptedException ex) {
	ex.printStackTrace();
	x = y.duplicate();
	}
	catch (ExecutionException ex) {
	ex.printStackTrace();
	x = y.duplicate();
	}
	catch (Exception e) {
	e.printStackTrace();
	x = y.duplicate();
	}
	SignalCollector.free(y);
	SignalCollector.free(h);
	x.setName("x");
	RealSignal result = pad.crop(monitors, x);

	controller.finish(result);
	monitors.log(getName() + " is finished");

	SignalCollector.free(x);

	if (controller.isDisplayFinal())
	Lab.show(monitors, result, "Final Display of " + sn);

	result.setName("Out of " + algoParam);

	monitors.log("End of " + sn + " in " + NumFormat.seconds(controller.getTimeNano()) + " and " + controller.getMemoryAsString());

	return result;
	}

	public AbstractAlgorithm noPopup() {
	return this.disableDisplayFinal().disableSystem();
	}

	public AbstractAlgorithm setController(Controller controller) {
	this.controller = controller;
	return this;
	}

	public Controller getController() {
	return controller;
	}

	public int getIterationsMax() {
	return iterMax;
	}

	public int getIterations() {
	return controller.getIterations();
	}

	public double getTime() {
	return controller.getTimeNano();
	}

	public double getMemory() {
	return controller.getMemory();
	}

	public double getResidu() {
	return controller.getResidu();
	}

	public double getSNR() {
	return controller.getSNR();
	}

	public double getPSNR() {
	return controller.getPSNR();
	}

	public void setWavelets(String waveletsName) {
	}

	@Override
	public String toString() {
	String s = "";
	s += getName();
	s += (isIterative() ? ", " + iterMax + " iterations" : " (direct)");
	s += (isRegularized() ? ", &lambda=" + NumFormat.nice(getRegularizationFactor()) : "");
	s += (isStepControllable() ? ", &gamma=" + NumFormat.nice(getStepFactor()) : "");
	return s;
	}

	public String getParametersAsString() {
	double p[] = getParameters();
	String param = "";
	for (int i = 0; i < p.length; i++)
	if (i == p.length - 1)
	param += NumFormat.nice(p[i]);
	else
	param += NumFormat.nice(p[i]) + ", ";
	return param;
	}


	public AbstractFFT getFFT() {
	return controller.getFFT();
	}

	public AbstractAlgorithm setFFT(AbstractFFT fft) {
	this.fft = fft;
	controller.setFFT(fft);
	return this;
	}

	public String getPath() {
	return controller.getPath();
	}

	public AbstractAlgorithm setPath(String path) {
	controller.setPath(path);
	return this;
	}

	public boolean isSystem() {
	return controller.isSystem();
	}

	public AbstractAlgorithm enableSystem() {
	controller.setSystem(true);
	return this;
	}

	public AbstractAlgorithm disableSystem() {
	controller.setSystem(false);
	return this;
	}

	public boolean isMultithreading() {
	return controller.isMultithreading();
	}

	public AbstractAlgorithm enableMultithreading() {
	controller.setMultithreading(true);
	return this;
	}

	public AbstractAlgorithm disableMultithreading() {
	controller.setMultithreading(false);
	return this;
	}

	public boolean isDisplayFinal() {
	return controller.isDisplayFinal();
	}

	public AbstractAlgorithm enableDisplayFinal() {
	controller.setDisplayFinal(true);
	return this;
	}

	public AbstractAlgorithm disableDisplayFinal() {
	controller.setDisplayFinal(false);
	return this;
	}

	public double getNormalizationPSF() {
	return controller.getNormalizationPSF();
	}

	public AbstractAlgorithm setNormalizationPSF(double normalizationPSF) {
	controller.setNormalizationPSF(normalizationPSF);
	return this;
	}

	public double getEpsilon() {
	return controller.getEpsilon();
	}

	public AbstractAlgorithm setEpsilon(double epsilon) {
	controller.setEpsilon(epsilon);
	return this;
	}

	public Padding getPadding() {
	return controller.getPadding();
	}

	public AbstractAlgorithm setPadding(Padding padding) {
	controller.setPadding(padding);
	return this;
	}

	public Apodization getApodization() {
	return controller.getApodization();
	}

	public AbstractAlgorithm setApodization(Apodization apodization) {
	controller.setApodization(apodization);
	return this;
	}

	public Monitors getMonitors() {
	return controller.getMonitors();
	}

	public AbstractAlgorithm setMonitors(Monitors monitors) {
	controller.setMonitors(monitors);
	return this;
	}

	public Verbose getVerbose() {
	return controller.getVerbose();
	}

	public AbstractAlgorithm setVerbose(Verbose verbose) {
	controller.setVerbose(verbose);
	return this;
	}

	public Constraint.Mode getConstraint() {
	return controller.getConstraint();
	}

	public AbstractAlgorithm setConstraint(Constraint.Mode constraint) {
	controller.setConstraint(constraint);
	return this;
	}

	public Stats getStats() {
	return controller.getStats();
	}

	public AbstractAlgorithm setStats(Stats stats) {
	controller.setStats(stats);
	return this;
	}

	public AbstractAlgorithm showStats() {
	controller.setStats(new Stats(Stats.Mode.SHOW));
	return this;
	}

	public AbstractAlgorithm saveStats(Stats stats) {
	controller.setStats(new Stats(Stats.Mode.SAVE));
	return this;
	}

	public AbstractAlgorithm setStats() {
	controller.setStats(new Stats(Stats.Mode.SHOWSAVE));
	return this;
	}

	public double getResiduMin() {
	return controller.getResiduMin();
	}

	public AbstractAlgorithm setResiduMin(double residuMin) {
	controller.setResiduMin(residuMin);
	return this;
	}

	public double getTimeLimit() {
	return controller.getTimeLimit();
	}

	public AbstractAlgorithm setTimeLimit(double timeLimit) {
	controller.setTimeLimit(timeLimit);
	return this;
	}

	- public String getReference() {
	+ public RealSignal getReference() {
	return controller.getReference();
	}

	- public AbstractAlgorithm setReference(String reference) {
	- controller.setReference(reference);
	+ public AbstractAlgorithm setReference(RealSignal ref) {
	+ controller.setReference(ref);
	return this;
	}

	public ArrayList<Output> getOuts() {
	return controller.getOuts();
	}

	public AbstractAlgorithm setOuts(ArrayList<Output> outs) {
	controller.setOuts(outs);
	return this;
	}

	public AbstractAlgorithm addOutput(Output out) {
	controller.addOutput(out);
	return this;
	}

	public String getParametersToString() {
	double params[] = getParameters();
	if (params != null) {
	if (params.length > 0) {
	String s = " ";
	for (double param : params)
	s += NumFormat.nice(param) + " ";
	return s;
	}
	}
	return "parameter-free";
	}
	}
	diff --git a/DeconvolutionLab2/src/deconvolution/algorithm/Controller.java b/DeconvolutionLab2/src/deconvolution/algorithm/Controller.java
	index 19b958c..2e48691 100644
	--- a/DeconvolutionLab2/src/deconvolution/algorithm/Controller.java
	+++ b/DeconvolutionLab2/src/deconvolution/algorithm/Controller.java
	@@ -1,650 +1,669 @@
	/*
	* 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.algorithm;

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

	import signal.Assessment;
	import signal.ComplexSignal;
	import signal.Constraint;
	import signal.RealSignal;
	import signal.apodization.Apodization;
	import signal.padding.Padding;
	import bilib.tools.Files;
	import bilib.tools.NumFormat;
	import deconvolution.Deconvolution;
	import deconvolution.Stats;
	import deconvolutionlab.Constants;
	import deconvolutionlab.monitor.AbstractMonitor;
	import deconvolutionlab.monitor.ConsoleMonitor;
	import deconvolutionlab.monitor.Monitors;
	import deconvolutionlab.monitor.TableMonitor;
	import deconvolutionlab.monitor.Verbose;
	import deconvolutionlab.output.Output;
	import deconvolutionlab.system.SystemUsage;
	import fft.AbstractFFT;
	import fft.FFT;

	/**
	* This is an important class to manage all the common task of the algorithm.
	* The method start() is called before at the starting of the algorithm. The
	* method ends() is called at the end of every iterations for the iterative
	* algorithm. It returns true if one the stopping criteria is true. The method
	* finish() is called when the algorithm is completely terminated.
	*
	* @author Daniel Sage
	*
	*/
	public class Controller {

	private String path;
	private boolean system;
	private boolean multithreading;
	private boolean displayFinal;
	private double normalizationPSF;
	private double epsilon;

	private Padding padding;
	private Apodization apodization;
	private ArrayList<Output> outs;
	private Stats stats;
	private Constraint.Mode constraintMode;
	private double residuMin;
	private double timeLimit;
	- private String reference;
	+ private String referenceName;
	private Monitors monitors;
	private Verbose verbose;
	private AbstractFFT fft;

	private int iterationsMax = 100;

	private boolean doResidu = false;
	private boolean doTime = false;
	private boolean doReference = false;
	private boolean doConstraint = false;
	private boolean abort = false;

	private double timeStarting = 0;
	private double memoryStarting = 0;
	private double residu = Double.MAX_VALUE;
	private int iterations = 0;
	private double memoryPeak = 0;
	private double snr = 0;
	private double psnr = 0;

	private RealSignal refImage;
	private RealSignal prevImage;
	private RealSignal x;

	private Timer timer;

	private String algoName = "";

	public Controller() {
	doResidu = false;
	doTime = false;
	doReference = false;
	doConstraint = false;
	timeStarting = System.nanoTime();

	setPath(Files.getWorkingDirectory());
	setSystem(true);
	setMultithreading(true);
	setDisplayFinal(true);
	setFFT(FFT.getFastestFFT().getDefaultFFT());
	setNormalizationPSF(1);
	setEpsilon(1e-6);
	setPadding(new Padding());
	setApodization(new Apodization());

	monitors = new Monitors();
	monitors.add(new ConsoleMonitor());
	monitors.add(new TableMonitor(Constants.widthGUI, 240));

	setVerbose(Verbose.Log);
	setStats(new Stats(Stats.Mode.NO));
	setConstraint(Constraint.Mode.NO);
	setResiduMin(-1);
	setTimeLimit(-1);
	- setReference("");
	+ setReference(null);
	setOuts(new ArrayList<Output>());
	}

	public void setAlgoName(String algoName) {
	this.algoName = algoName;
	}

	public void setFFT(AbstractFFT fft) {
	this.fft = fft;
	}

	public void abort() {
	this.abort = true;
	}

	public void setIterationsMax(int iterationsMax) {
	this.iterationsMax = iterationsMax;
	}

	public boolean needSpatialComputation() {
	return doConstraint \|\| doResidu \|\| doReference;
	}

	/**
	* Call one time at the beginning of the algorithms
	*
	* @param x
	* the input signal
	*/
	public void start(RealSignal x) {
	this.x = x;

	stats.show();
	stats.addInput(x);

	iterations = 0;
	timer = new Timer();
	timer.schedule(new Updater(), 0, 100);
	timeStarting = System.nanoTime();
	memoryStarting = SystemUsage.getHeapUsed();

	if (doConstraint && x != null)
	Constraint.setModel(x);

	if (doReference) {
	- refImage = new Deconvolution("Reference", "-image file " + reference).openImage();
	+ refImage = new Deconvolution("Reference", "-image file " + referenceName).openImage();
	if (refImage == null)
	- monitors.error("Impossible to load the reference image " + reference);
	+ monitors.error("Impossible to load the reference image " + referenceName);
	else
	monitors.log("Reference image loaded");
	}
	for (Output out : outs)
	out.executeStarting(monitors, x, this);

	this.prevImage = x;
	}

	public boolean ends(ComplexSignal X) {

	boolean out = false;
	for (Output output : outs)
	out = out \| output.is(iterations);

	if (doConstraint \|\| doResidu \|\| doReference \|\| out) {
	if (fft == null)
	fft = FFT.createDefaultFFT(monitors, X.nx, X.ny, X.nz);
	x = fft.inverse(X, x);
	return ends(x);
	}

	return ends((RealSignal) null);
	}

	public boolean ends(RealSignal x) {
	this.x = x;

	if (doConstraint \|\| doResidu \|\| doReference)
	compute(iterations, x, doConstraint, doResidu, doReference);

	for (Output out : outs)
	out.executeIterative(monitors, x, this, iterations);

	iterations++;
	double p = iterations * 100.0 / iterationsMax;
	monitors.progress("Iterative " + iterations + "/" + iterationsMax, p);
	double timeElapsed = getTimeSecond();
	boolean stopIter = (iterations >= iterationsMax);
	boolean stopTime = doTime && (timeElapsed >= timeLimit);
	boolean stopResd = doResidu && (residu <= residuMin);
	monitors.log("@" + iterations + " Time: " + NumFormat.seconds(timeElapsed*1e9));

	String pnsrText = doReference ? "" + psnr : "n/a";
	String snrText = doReference ? "" + snr : "n/a";
	String residuText = doResidu ? "" + residu : "n/a";
	stats.add(x, iterations, NumFormat.seconds(getTimeNano()), pnsrText, snrText, residuText);

	String prefix = "Stopped>> by ";
	if (abort)
	monitors.log(prefix + "abort");
	if (stopIter)
	monitors.log(prefix + "iteration " + iterations + " > " + iterationsMax);
	if (stopTime)
	monitors.log(prefix + "time " + timeElapsed + " > " + timeLimit);
	if (stopResd)
	monitors.log(prefix + "residu " + NumFormat.nice(residu) + " < " + NumFormat.nice(residuMin));

	return abort \| stopIter \| stopTime \| stopResd;
	}

	public void finish(RealSignal x) {
	this.x = x;

	boolean ref = doReference;
	boolean con = doConstraint;
	boolean res = doResidu;
	if (con \|\| res \|\| ref)
	compute(iterations, x, con, res, ref);

	String pnsrText = doReference ? ""+psnr : "n/a";
	String snrText = doReference ? ""+snr : "n/a";
	String residuText = doResidu ? "" + residu : "n/a";
	stats.addOutput(x, algoName, NumFormat.seconds(getTimeNano()), pnsrText, snrText, residuText);

	stats.save(monitors, path);

	for (Output out : outs)
	out.executeFinal(monitors, x, this);

	monitors.log("Time: " + NumFormat.seconds(getTimeNano()) + " Peak:" + getMemoryAsString());
	if (timer != null)
	timer.cancel();
	}

	private void compute(int iterations, RealSignal x, boolean con, boolean res, boolean ref) {
	if (x == null)
	return;

	if (con && constraintMode != null)
	new Constraint(monitors).apply(x, constraintMode);

	if (ref && refImage != null) {
	String s = "";
	psnr = Assessment.psnr(x, refImage);
	snr = Assessment.snr(x, refImage);
	s += " PSNR: " + NumFormat.nice(psnr);
	s += " SNR: " + NumFormat.nice(snr);
	monitors.log("@" + iterations + " " + s);
	}

	residu = Double.MAX_VALUE;
	if (res && prevImage != null) {
	residu = Assessment.relativeResidu(x, prevImage);
	prevImage = x.duplicate();
	monitors.log("@" + iterations + " Residu: " + NumFormat.nice(residu));
	}
	}

	public double getTimeNano() {
	return (System.nanoTime() - timeStarting);
	}

	public double getTimeSecond() {
	return (System.nanoTime() - timeStarting) * 1e-9;
	}

	public String getConstraintAsString() {
	if (!doConstraint)
	return "no";
	if (constraintMode == null)
	return "null";
	return constraintMode.name().toLowerCase();
	}

	public String getStoppingCriteriaAsString(AbstractAlgorithm algo) {
	String stop = algo.isIterative() ? "iterations limit=" + algo.getIterationsMax() + ", " : "direct, ";
	stop += doTime ? ", time limit=" + NumFormat.nice(timeLimit * 1e-9) : " no time limit" + ", ";
	stop += doResidu ? ", residu limit=" + NumFormat.nice(residuMin) : " no residu limit";
	return stop;
	}

	public double getMemory() {
	return memoryPeak - memoryStarting;
	}

	public String getMemoryAsString() {
	return NumFormat.bytes(getMemory());
	}

	public int getIterations() {
	return iterations;
	}

	public double getSNR() {
	return snr;
	}

	public double getPSNR() {
	return psnr;
	}

	public double getResidu() {
	return residu;
	}

	private void update() {
	memoryPeak = Math.max(memoryPeak, SystemUsage.getHeapUsed());
	}

	public AbstractFFT getFFT() {
	return fft;
	}

	/**
	* @return the path
	*/
	public String getPath() {
	return path;
	}

	/**
	* @param path
	* the path to set
	*/
	public void setPath(String path) {
	this.path = path;
	}

	/**
	* @return the system
	*/
	public boolean isSystem() {
	return system;
	}

	/**
	* @param system
	* the system to set
	*/
	public void setSystem(boolean system) {
	this.system = system;
	}

	/**
	* @return the multithreading
	*/
	public boolean isMultithreading() {
	return multithreading;
	}

	/**
	* @param multithreading
	* the multithreading to set
	*/
	public void setMultithreading(boolean multithreading) {
	this.multithreading = multithreading;
	}

	/**
	* @return the displayFinal
	*/
	public boolean isDisplayFinal() {
	return displayFinal;
	}

	/**
	* @param displayFinal
	* the displayFinal to set
	*/
	public void setDisplayFinal(boolean displayFinal) {
	this.displayFinal = displayFinal;
	}

	/**
	* @return the normalizationPSF
	*/
	public double getNormalizationPSF() {
	return normalizationPSF;
	}

	/**
	* @param normalizationPSF
	* the normalizationPSF to set
	*/
	public void setNormalizationPSF(double normalizationPSF) {
	this.normalizationPSF = normalizationPSF;
	}

	/**
	* @return the epsilon
	*/
	public double getEpsilon() {
	return epsilon;
	}

	/**
	* @param epsilon
	* the epsilon to set
	*/
	public void setEpsilon(double epsilon) {
	this.epsilon = epsilon;
	}

	/**
	* @return the padding
	*/
	public Padding getPadding() {
	return padding;
	}

	/**
	* @param padding
	* the padding to set
	*/
	public void setPadding(Padding padding) {
	this.padding = padding;
	}

	/**
	* @return the apodization
	*/
	public Apodization getApodization() {
	return apodization;
	}

	/**
	* @param apodization
	* the apodization to set
	*/
	public void setApodization(Apodization apodization) {
	this.apodization = apodization;
	}

	/**
	* @return the monitors
	*/
	public Monitors getMonitors() {
	if (monitors == null)
	return Monitors.createDefaultMonitor();
	return monitors;
	}

	/**
	* @param monitors
	* the monitors to set
	*/
	public void setMonitors(Monitors monitors) {
	this.monitors = monitors;
	}

	/**
	* @return the verbose
	*/
	public Verbose getVerbose() {
	return verbose;
	}

	/**
	* @param verbose
	* the verbose to set
	*/
	public void setVerbose(Verbose verbose) {
	this.verbose = verbose;
	}

	public Constraint.Mode getConstraint() {
	return constraintMode;
	}

	public void setConstraint(Constraint.Mode constraintMode) {
	doConstraint = constraintMode != Constraint.Mode.NO;
	this.constraintMode = constraintMode;
	}

	/**
	* @return the stats
	*/
	public Stats getStats() {
	return stats;
	}

	/**
	* @param stats
	* the stats to set
	*/
	public void setStats(Stats stats) {
	this.stats = stats;
	}

	/**
	* @return the residuMin
	*/
	public double getResiduMin() {
	return residuMin;
	}

	/**
	* @param residuMin
	* the residuMin to set
	*/
	public void setResiduMin(double residuMin) {
	doResidu = residuMin > 0;
	this.residuMin = residuMin;
	}

	/**
	* @return the timeLimit
	*/
	public double getTimeLimit() {
	return timeLimit;
	}

	/**
	* @param timeLimit
	* the timeLimit to set
	*/
	public void setTimeLimit(double timeLimit) {
	doTime = timeLimit > 0;
	this.timeLimit = timeLimit;
	}

	/**
	* @return the reference
	*/
	- public String getReference() {
	- return reference;
	+ public String getReferenceName() {
	+ return referenceName;
	}

	/**
	* @param reference
	* the reference to set
	*/
	- public void setReference(String reference) {
	+ public void setReferenceName(String referenceName) {
	doReference = false;
	- if (reference == null)
	+ if (referenceName == null)
	return;
	- if (reference.equals(""))
	+ if (referenceName.equals(""))
	return;
	doReference = true;
	- this.reference = reference;
	+ this.referenceName = referenceName;
	+ }
	+
	+ /**
	+ * @return the reference
	+ */
	+ public RealSignal getReference() {
	+ return refImage;
	+ }
	+
	+ /**
	+ * @param reference
	+ * the reference to set
	+ */
	+ public void setReference(RealSignal refImage) {
	+ doReference = false;
	+ if (refImage == null)
	+ return;
	+ doReference = true;
	+ this.refImage = refImage;
	}

	/**
	* @return the outs
	*/
	public ArrayList<Output> getOuts() {
	return outs;
	}

	/**
	* @param outs
	* the outs to set
	*/
	public void setOuts(ArrayList<Output> outs) {
	this.outs = outs;
	}

	public void addOutput(Output out) {
	this.outs.add(out);
	}

	public String toStringMonitor() {
	String s = "[" + verbose.name().toLowerCase() + "] ";
	for (AbstractMonitor monitor : monitors) {
	s += "" + monitor.getName() + " ";
	}
	return s;
	}

	public Stats.Mode getStatsMode() {
	return stats.getMode();
	}

	public void setStatsMode(Stats.Mode mode) {
	this.stats = new Stats(mode);
	}

	public String toStringRunning() {
	String s = "";
	s += "system " + (system ? "shown" : "hidden ");
	s += ", multithreading " + (multithreading ? "on" : "off ");
	s += ", display final " + (displayFinal ? "on " : "off ");
	return s;
	}

	public String toStringPath() {
	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)";
	}
	}

	private class Updater extends TimerTask {
	@Override
	public void run() {
	update();
	}
	}
	}
	diff --git a/DeconvolutionLab2/src/imagej/IJImager.java b/DeconvolutionLab2/src/imagej/IJImager.java
	index 3157c19..335fc91 100644
	--- a/DeconvolutionLab2/src/imagej/IJImager.java
	+++ b/DeconvolutionLab2/src/imagej/IJImager.java
	@@ -1,351 +1,353 @@
	/*
	* 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 imagej;

	import java.awt.BorderLayout;
	import java.awt.Dimension;
	import java.awt.GridLayout;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import java.awt.event.WindowEvent;
	import java.awt.event.WindowListener;

	import javax.swing.BorderFactory;
	import javax.swing.DefaultListModel;
	import javax.swing.JButton;
	import javax.swing.JDialog;
	import javax.swing.JFrame;
	import javax.swing.JLabel;
	import javax.swing.JList;
	import javax.swing.JPanel;
	import javax.swing.JScrollPane;
	import javax.swing.ListSelectionModel;

	import deconvolutionlab.Imager;
	import ij.ImagePlus;
	import ij.ImageStack;
	import ij.WindowManager;
	import ij.gui.GUI;
	import ij.io.FileSaver;
	import ij.io.Opener;
	import ij.process.FloatProcessor;
	import ij.process.ImageProcessor;
	import signal.ComplexComponent;
	import signal.ComplexSignal;
	import signal.RealSignal;

	public class IJImager extends Imager {

	@Override
	public Platform getPlatform() {
	return Imager.Platform.IMAGEJ;
	}

	@Override
	public void setVisible(JDialog dialog, boolean modal) {
	if (modal) {
	dialog.setModal(modal);
	GUI.center(dialog);
	}
	dialog.pack();
	dialog.setVisible(true);
	}

	public static RealSignal create(ImagePlus imp) {
	int nx = imp.getWidth();
	int ny = imp.getHeight();
	int nz = imp.getStackSize();
	- RealSignal signal = new RealSignal("ij-" + imp.getTitle(), nx, ny, nz);
	+ RealSignal signal = new RealSignal(imp.getTitle(), nx, ny, nz);
	for (int k = 0; k < nz; k++) {
	ImageProcessor ip = imp.getStack().getProcessor(k + 1).convertToFloat();
	signal.setXY(k, (float[]) ip.getPixels());
	}
	return signal;
	}

	@Override
	public RealSignal getActiveImage() {
	return build(WindowManager.getCurrentImage());
	}

	@Override
	public RealSignal getImageByName(String name) {
	ImagePlus imp = null;
	if (name.equalsIgnoreCase("active"))
	imp = WindowManager.getCurrentImage();
	else
	imp = WindowManager.getImage(name);
	if (imp == null)
	imp = WindowManager.getCurrentImage();
	return build(imp);
	}

	@Override
	public RealSignal open(String filename) {
	Opener opener = new Opener();
	ImagePlus imp = opener.openImage(filename);
	if (imp == null)
	return null;
	return build(imp);
	}

	@Override
	public void show(RealSignal signal, String title, Imager.Type type, int z) {
	ImagePlus imp = build(signal, type);
	if (imp != null) {
	imp.setTitle(title);
	int nz = imp.getStackSize();
	imp.show();
	imp.setSlice(Math.max(1, Math.min(nz, z)));
	imp.getProcessor().resetMinAndMax();
	}
	}

	- public ContainerImage createContainer(String title) {
	+ @Override
	+ public ContainerImage createContainer(String title) {
	return new ContainerImage();
	}

	@Override
	public void append(ContainerImage container, RealSignal signal, String title, Imager.Type type) {
	ImagePlus cont = (ImagePlus) container.object;
	if (container.object == null) {
	ImageStack stack = new ImageStack(signal.nx, signal.ny);
	stack.addSlice(build(signal, type).getProcessor());
	stack.addSlice(build(signal, type).getProcessor());
	container.object = new ImagePlus(title, stack);
	((ImagePlus)container.object).show();
	}
	else {
	cont.getStack().addSlice(build(signal, type).getProcessor());
	cont.setSlice(cont.getStack().getSize());
	cont.updateAndDraw();
	cont.getProcessor().resetMinAndMax();
	}
	}

	@Override
	public void save(RealSignal signal, String filename, Imager.Type type) {
	ImagePlus imp = build(signal, type);
	if (imp != null) {
	if (imp.getStackSize() == 1) {
	new FileSaver(imp).saveAsTiff(filename);
	}
	else {
	new FileSaver(imp).saveAsTiffStack(filename);
	}
	}
	}

	@Override
	public void show(ComplexSignal signal, String title, ComplexComponent complex) {
	ImageStack stack = new ImageStack(signal.nx, signal.ny);
	for (int k = 0; k < signal.nz; k++) {
	float[] plane = null;
	switch (complex) {
	case REAL:
	plane = signal.getRealXY(k);
	break;
	case IMAGINARY:
	plane = signal.getImagXY(k);
	break;
	case MODULE:
	plane = signal.getModuleXY(k);
	break;
	default:
	plane = signal.getModuleXY_dB(k);
	}
	stack.addSlice(new FloatProcessor(signal.nx, signal.ny, plane));
	}
	new ImagePlus(title, stack).show();
	}

	private RealSignal build(ImagePlus imp) {
	if (imp == null)
	return null;
	int nx = imp.getWidth();
	int ny = imp.getHeight();
	int nz = imp.getStackSize();
	RealSignal signal = new RealSignal("ij-" + imp.getTitle(), nx, ny, nz);
	for (int k = 0; k < nz; k++) {
	ImageProcessor ip = imp.getStack().getProcessor(k + 1).convertToFloat();
	signal.setXY(k, (float[]) ip.getPixels());
	}
	return signal;
	}

	private ImagePlus build(RealSignal signal, Imager.Type type) {
	if (signal == null)
	return null;

	ImageStack stack = new ImageStack(signal.nx, signal.ny);
	for (int k = 0; k < signal.nz; k++) {
	ImageProcessor ip = new FloatProcessor(signal.nx, signal.ny, signal.getXY(k));
	switch (type) {
	case BYTE:
	stack.addSlice(ip.convertToByteProcessor(false));
	break;
	case SHORT:
	stack.addSlice(ip.convertToShortProcessor(false));
	break;
	case FLOAT:
	stack.addSlice(ip);
	default:
	break;
	}
	}
	return new ImagePlus("", stack);
	}

	@Override
	public String getName() {
	return "ImageJ";
	}

	@Override
	public boolean isSelectable() {
	return true;
	}

	@Override
	public String getSelectedImage() {
	Dialog dialog = new Dialog();
	dialog.setVisible(true);
	if (dialog.wasCancel())
	return "";
	return dialog.getName();
	}

	public class Dialog extends JDialog implements ActionListener, WindowListener {

	private JList<String> list;
	private JButton bnOK = new JButton("OK");
	private JButton bnCancel = new JButton("Cancel");
	private boolean cancel = false;
	private String name = "";

	public Dialog() {
	super(new JFrame(), "Image Selection");

	JPanel bn = new JPanel(new GridLayout(1, 2));
	bn.add(bnCancel);
	bn.add(bnOK);

	JPanel panel = new JPanel(new BorderLayout());
	int[] ids = WindowManager.getIDList();

	if (ids != null) {
	DefaultListModel listModel = new DefaultListModel();
	list = new JList(listModel);
	for (int id : ids) {
	ImagePlus idp = WindowManager.getImage(id);
	if (idp != null) {
	((DefaultListModel) listModel).addElement(idp.getTitle());
	}
	}
	list.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
	JScrollPane listScroller = new JScrollPane(list);
	listScroller.setPreferredSize(new Dimension(250, 80));
	panel.add(listScroller, BorderLayout.CENTER);
	}
	else {
	panel.add(new JLabel("No open images."));
	}
	panel.add(bn, BorderLayout.SOUTH);
	panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
	bnOK.addActionListener(this);
	bnCancel.addActionListener(this);
	add(panel);
	pack();
	addWindowListener(this);
	GUI.center(this);
	setModal(true);
	}

	@Override
	public void actionPerformed(ActionEvent e) {
	bnOK.removeActionListener(this);
	bnCancel.removeActionListener(this);
	if (e.getSource() == bnCancel) {
	cancel = true;
	name = "";
	dispose();
	return;
	}
	else if (e.getSource() == bnOK) {
	cancel = false;
	name = (String) list.getSelectedValue();
	dispose();
	}
	}

	- public String getName() {
	+ @Override
	+ public String getName() {
	return name;
	}

	public boolean wasCancel() {
	return cancel;
	}

	@Override
	public void windowOpened(WindowEvent e) {
	}

	@Override
	public void windowClosing(WindowEvent e) {
	dispose();
	cancel = true;
	name = "";
	return;
	}

	@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) {
	}
	}

	}

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions