Alida - User contributions [en]

Java quick

2016-03-17T16:16:07Z

Posch: /* Graphical workflow editor: Grappa */

Here we introduce Alida's operator concept with some code snippets of <code>ALDOperator</code> and sub-classed demo operators.
we focus on Alida's capabilities to automatically generate user interfaces.

= First operator =

As a first example of an Alida operator we implement the row or column wise
sum for a 2D array of Doubles.
The class <code>MatrixSum</code> extending <code>ALDOperator</code> features three member variables
holding the input 2D array, an enum to indicate the mode of summation (<code>ROW</code> or <code>COLUMN</code>), and
an 1D array of the sums to be computed and returned by the operator.
Alida requires only to annotate these members with the @Parameter annotation
which declares

* the direction (<code>IN</code>, <code>OUT</code>, <code>INOUT</code>),
* whether the parameter is required,
* an optional textual description,
* and a label used, e.g. in the graphical user interface automatically generated
to execute the operator.

It is important to add a public standard constructor (without arguments)
to be able to use Java's reflection mechanism.
Finally, the abstract method <code>operate()</code> of <code>ALDOperator</code> has to be overridden
implementing the functionality of the operator.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class MatrixSum extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,

/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows?")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* 1D Array of sums.
*/
@Parameter( label= "sums",
direction = Parameter.Direction.OUT, description = "Row or column wise sums.")
private Double[] sums = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public MatrixSum() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public MatrixSum(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() {
if ( matrix == null )
sums = null;

// calculate sums
if ( summarizeMode == SummarizeMode.ROW ) {
sums = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
sums[row] = 0.0;
for ( int col = 0 ; col < matrix[0].length ; col++ )
sums[row] += matrix[row][col];
}
} else {
sums = new Double[matrix[0].length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
sums[col] = 0.0;
for ( int row = 0 ; row < matrix.length ; row++ )
sums[col] += matrix[row][col];
}
}
}
</pre>

These are the basic requirements for the operator to be used on the programming level.
An example of this use is included in the example in the next section.

If we further annotate the class with
<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL)
</pre>
this is all needed to also facilitate
execution of this operator via a graphical and a command line user interface
automatically generated by Alida.
(Setting <code>level=ALDAOperator.Level.APPLICATION</code> declares this operator an application
which is used in the GUI to control display of available operators.)

== Invocation via a graphical user interface ==

Alida comes with one single application to execute Alida operators
with a automatically generated graphical user interface which may be
started from command line by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunnerGUI
</pre>

This will pop up a window to choose an operator to execute.
Arranged according to the package structure all operators allows to be executed
via the graphical user interface according to their <code>genericExecutionMode</code>
are displayed.
Initially packages are unfolded up to a predefined depth.
Unfold the demo package, select <code>MatrixSum</code>, and choose the "Configure Operator" button.
This will pop up another window which allows you to configure the input parameters
of the operator.
Important note: After finishing to input the data matrix entering the final matrix elements
you have to select a previous matrix element due to subtle AWT details.
For the enumeration to select the mode Alida has automatically generated
a combo box to allow convenient selections.
If you are finished with the parameter configuration you want to invoke the operator
using the run button.
On completion of <code>MatrixSum</code> the interface will pop up the result window which allows you
to inspect the outcome of the operation.

== Invocation via command line ==

The command line user interface of Alida allows to invoke all Alida operator
properly annotated to allows generic execution.

You may invoke the matrix summation operator by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]' sums=-
</pre>
which returns as result on standard output
<pre>
sums = [6.0,15.0]
</pre>

Parameter values are specified as name=value pairs.
Alida's syntax for 2D array should be self-explanatory from this example.
As the mode of summation is not supplied as a parameter its default is used

Note, the command
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
</pre>
will return no output as the command line user interface returns only output parameters requested.

The enumeration defined in <code>MatrixSum</code> is supported by the
user interface without further action required as shown in the next example.
This also demonstrates redirection of output
to a file, sums.out in this case.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
summarizeMode=COLUMN sums=@sums.out+
</pre>
Input can be read from file as well:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix=@data sums=-+
</pre>

where the file data contains the string defining the matrix, e.g., <code>[[1,2,3],[4,5,6]]</code>

= Adding more features to an operator =

We now generalize this example to realize not only summation over rows or
columns, but arbitrary summarizing operations.
This shows Alida's feature to allow an operator as parameter of another operator.

== Implementation ==

First we generalize <code>ALDArraySum</code> to the operator <code>ApplyToMatrix</code>
which also takes a 2D array and an enum indicating the mode of marginalization (<code>ROW</code> or <code>COLUMN</code>).
It takes an additional input parameter which specifies the operation to be applied on each
row or column.

This parameter is itself an Alida operator and of type <code>ALDSummarizeArrayOp</code>
which is implemented as an abstract class.
This abstract operator defines a summarizing operator
which takes a 1D array as input and returns a summarizing scalar.
As this is an abstract class there is no need to override the <code>operate()</code>
method, however some getter and setter methods are provided.

<pre>
@Parameter( label= "Input 1D array", required = true,
direction = Parameter.Direction.IN, description = "Input array (1D).")
protected Double[] data;

/**
* Summarizing scalar
*/
@Parameter( label= "Summarizing scalar",
direction = Parameter.Direction.OUT, description = "Summarizing scalar of the 1D arra")
protected Double summary = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDSummarizeArrayOp() throws ALDOperatorException {
}

/**
* Returns the 1D array
* @return data array
*/
public Double[] getData() {
return this.data;
}

/**
* Sets the 1D array
* @param data
*/
public void setData( Double[] data) {
this.data = data;
}

</pre>

Now we add concrete examples of such a summarizing operation, in this case
summation (<code>ALDArraySum</code>), to return the mean (<code>ALDArrayMean</code>), and the minimum (<code>ALDArrayMin</code>).
Each implements the <code>operate()</code> method and has to supply a standard constructor.
In this example we add another constructor for convenience.
This operators are declared as operators on the standard in contrast to
application level, as they are not expected to be invoked as an application.
However, setting the level to standard in the menu of the graphical user interface
stills allows their execution.
When extending the abstract super class it is necessary to annotate the
class with <code>@ALDDerivedClass</code> in order to allow Alida's dataIO mechanism to find the derived class
in the automatically generated user interface.
This holds for other parameter types as well.
More specifically, if an instance of a class is to be supplied in an automatically
generated user interface as a value for a parameter of one of its super classes,
Alida requires the annotation <code>@ALDDerivedClass</code>.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.STANDARD)
public class ALDArraySum extends ALDSummarizeArrayOp {

@Override
protected void operate() {
summary = 0.0;
for ( int i = 0 ; i < data.length ; i++ )
summary += data[i];
}

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDArraySum() throws ALDOperatorException {
}

</pre>

Now we are ready to implement
the <code>ApplyToMatrix</code> operator, which also demonstrates supplemental parameters.
This supplementals, e.g., control debugging output or returning of intermediate results.
For demo purposes we declare a supplemental input parameter <code>returnElapsedTime</code>.
If it is set to true the operator will return the elapsed time in a second
supplemental parameter with direction output.

Again, the operation is implemented in the <code>operate()</code> method and the remainder of the
class supplies getter and setter methods for convenience.
The <code>operate()</code> method give also an example of the invocation of an operator on the
programming level.
In this case, an instance of the operator is already passed as a parameter.
Its parameters are set, in this case each 1D array to be summarized in turn.
Upon return from the method <code>runOp()</code> the results may be retrieved from the operator object,
in this example with the <code>getSummary()</code> method.
Besides getter and setter methods as implemented in each operator
Alida provides also a generic get and set methods applicable to
all parameters of an operator.
Note, that the operator is not invoked by its <code>operate()</code> method, but via
the <code>runOp()</code> method implemented the base class <code>ALDOperator</code>.
This methods validates the parameters before invocation of <code>operate()</code>.
Furthermore, it take all necessary measures for Alida's processing
history which automatically logs
all manipulative actions on the data and corresponding parameter settings.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class ApplyToMatrix extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,
/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows.")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* Summarizing opererator
*/
@Parameter( label= "Summarizing operator", required = true,
direction = Parameter.Direction.IN, description = "Specifies the summarizing operation to apply")
private ALDSummarizeArrayOp summarizeOp;

/**
* 1D Array of summaries.
*/
@Parameter( label= "summaries",
direction = Parameter.Direction.OUT, description = "Row or column wise summaries")
private Double[] summaries = null;

/**
* Supplemental to request elapsed time to be returned
*/
@Parameter( label= "Return elapsed time",
direction = Parameter.Direction.IN, description = "Request elapsed time consumed to be returned",
supplemental=true)
private boolean returnElapsedTime = false;

/**
* Elpased time
*/
@Parameter( label= "Elapsed time",
direction = Parameter.Direction.OUT, description = "Elapsed time of operation in milliseconds",
supplemental=true)
private long elapsedTime;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ApplyToMatrix() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public ApplyToMatrix(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() throws ALDOperatorException,ALDProcessingDAGException {
if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis();

if ( matrix == null )
summaries = null;

// calculate summaries
if ( summarizeMode == SummarizeMode.ROW ) {
summaries = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
summarizeOp.setData(matrix[row]);
summarizeOp.runOp();
summaries[row] = summarizeOp.getSummary();
}
} else {
summaries = new Double[matrix[0].length];
Double[] tmp = new Double[matrix.length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
for ( int row = 0 ; row < matrix.length ; row++ )
tmp[row] = matrix[row][col];

summarizeOp.setData(tmp);
summarizeOp.runOp();
summaries[col] = summarizeOp.getSummary();
}
}

if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis() - elapsedTime;
}

// ==============================================================
// Getter and setter methods
/** Get value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @return value of returnElapsedTime
*/
public boolean getReturnElapsedTime(){
return returnElapsedTime;
}

/** Set value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @param value New value of returnElapsedTime
*/
public void setReturnElapsedTime( boolean value){
this.returnElapsedTime = value;
}
</pre>

== Invocation via a graphical user interface ==

If the graphical interface is still running just select our new operator
and begin to configure it.
For the parameter summarizing operator you have a choice of all operators extending
the abstract operator <code>ALDSummarizeArrayOp</code>.
All which is necessary on the implementation side is proper annotation of the extending
classes with <code>@ALDDerivedClass</code>.
As the selected operator may have its own parameters you may want to configure it.
In our example this is not necessary as the input array is, of course, supplied
by the <code>ApplyToMatrix</code> operator.
Do not forget to input your data before hitting the run button.
After return, again a result window give you the results of the operation.
Note, if you did not tick Return elapsed time" this window will show zero
for the time elapsed as the operator has not been request to stop the time.

== Invocation via command line ==

When invoking the <code>ApplyToMatrix</code> operator from command line
we have to handle derived classes as value for parameters.
In the graphical user interface Alida features a combo box where
we may choose from.
In the command line interface Alida allows to prefix the value of a parameter
with a derived class to be passed to the operator.
This is necessary as Alida as, of course, no way to itself
decide if and which derived class is to be used.
Alida's syntax is to enclose the class name in a dollar sign and a colon.
As evident in the following example, abbreviations are of the fully
qualified class name are accepted as long as they are unambiguous.
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW \
summarizeOp='<math>ALDArrayMean:{}' \
summaries=-
</pre>
results in
<pre>
summaries = [2.0,5.0]
</pre>

<code>ALDOpRunner</code> may be persuaded to show all operators derived from <code>ALDSummarizeArrayOp</code>
and known within the user interface if we enter an invalid class name:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner \
Apply matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW summarizeOp='</math>dd:{}' \
summaries=-
</pre>
yields
<pre>
ALDStandardizedDataIOCmdline::readData found 0 derived classes matching <dd>
derived classes available:
de.unihalle.informatik.Alida.demo.ALDArrayMean
de.unihalle.informatik.Alida.demo.ALDArrayMin
de.unihalle.informatik.Alida.demo.ALDArraySum
ERROR: reading parameter <summarizeOp> returns null
</pre>

Supplemental parameters are handled like other parameters
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=COLUMN \
summarizeOp='<math>ALDArrayMin:{}' \
summaries=- \
returnElapsedTime=true \
elapsedTime=-
</pre>
gives
<pre>
summaries = [1.0,2.0,3.0]
elapsedTime = 4
</pre>

= Adding more data types as parameters =

Alida provides automatic IO of primitive data types, enumerations, arrays, collections,
and operators.
In addition so called parameterized classes are supported.
Any Java class may be declared to be a parameterized class in Alida
by annotating the class <code>@ALDParametrizedClass</code> as shown in the
class <code>ExperimentalData1D</code>.
All member variables to be known to and handled by Alida's user interface
simply need to be annotated with <code>@ALDClassParameter</code>.

Here we implement a toy version of experimental data <code>ExperimentalData1D</code>.
A complete experiment contains
data of a time series of measurements of variable length.
Additional information is a descriptive string, the time resolution in milliseconds,
and whether baseline correction has been applied.

The class is annotated by <code>@ALDParametrizedClass</code>, and
and all members to be handle in Alida'a user interfaces are
to be annotated with <code>@ALDParametrizedClass</code>.
The label field has the same semantics as for parameters of operators.
These annotations are the only implementational overhead
to allow Alida to automatically generate user interfaces
where the parameterized class acts as a parameter.

<pre>
@ALDParametrizedClass
public class ExperimentalData1D extends ALDData {

/** Description */
@ALDClassParameter(label="description", dataIOOrder = 1)
private String description = null;

/** The data */
@ALDClassParameter(label="data", dataIOOrder = 2)
private Double[] data = null;

/** Are the data baseline corrected? */
@ALDClassParameter(label="Baseline corrected",
dataIOOrder = 3)
private boolean baselineCorrected = false;

@ALDClassParameter(label="Time resolution in milliseconds", dataIOOrder = 4)
private Float timeResolution = Float.NaN;

/**
* Standard constructor is required
*/
public ExperimentalData1D() {
}

/** Constructor for an experiment.
* Baseline correction is assumed to be false and nothung known about
* the time resolution.
*
* @param description a textual description of the experiment
* @param data measurements
*/
public ExperimentalData1D( String description, Double[] data) {
this( description, data, false, Float.NaN);
}
</pre>

This is shown below for a simple normalizing operator <code>SmoothData1D</code>
which takes experimental data as input an returns a new instance
of <code>ExperimentalData</code> which contains smoothed data.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class SmoothData1D extends ALDOperator {

public enum SmoothingMethod {
MEDIAN, MEAN, GAUSSIAN
}

/** 1D Experiment
*/
@Parameter( label= "1D Experiment", required = true,
direction = Parameter.Direction.IN,
description = "1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D experiment;

/** Smoothing method
*/
@Parameter( label = "Smoothing method", required = true,
direction = Parameter.Direction.IN,
callback = "smoothingMethodChanged",
description = "Smoothing method",
paramModificationMode = ParameterModificationMode.MODIFIES_INTERFACE,
dataIOOrder = 2)
SmoothingMethod smoothingMethod = SmoothingMethod.MEDIAN;

/** Window width
*/
@Parameter( label = "Window width", required = true,
direction = Parameter.Direction.IN,
description = "Window width (should be uneven)",
dataIOOrder = 3)
Integer width = 3;

/** Standard deviation of Gaussian
*/
@Parameter( label = "Standdard deviation of Gaussian", required = true,
direction = Parameter.Direction.IN,
description = "Standdard deviation of Gaussian",
dataIOOrder = 3)
Float sigma = 1.0F;

/** Smoothed 1D Experiment
*/
@Parameter( label= "Smothed 1D Experiment",
direction = Parameter.Direction.OUT,
description = "Smothed1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D smoothedExperiment;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public SmoothData1D() throws ALDOperatorException {
// necessary handle dynamic parameters correctly
smoothingMethodChanged();
}

@Override
protected void operate() {
this.fireOperatorExecutionProgressEvent(
new ALDOperatorExecutionProgressEvent(this,
"Starting to smooth 1D Data..."));

Double[] smoothedData;
if ( smoothingMethod == SmoothingMethod.MEDIAN) {
smoothedData = median( experiment.getData(), this.width);
} else {
smoothedData = smoothByConvolution();
}

smoothedExperiment = new ExperimentalData1D( experiment.getDescription() + " (smoothed)",
smoothedData, experiment.isBaselineCorrected(), experiment.getTimeResolution());
}
</pre>

This mechanism applies in a recursive fashion, i.e. a parameterized class may
(recursively) contain a member variable which itself is a parametrized class.
Likewise, an operator acting as a parameter of another operator
may in turn have a parameter of type <code>ALDOperator</code>.

== Invocation via a graphical user interface ==

Invoking and configuring <code>SmoothData1D</code> from the graphical user interface
shows as the only required parameter the experimental data.
This parameterized class can be configured in a separate window
very similar to to configuration of operators.
Likewise the resulting normalized experimental data
may be inspected in their own window.

Obviously this is a toy example, as we would not expect the measurements to
be entered manually, but rather stored and read from file in a specialized format.
This is one of the rare cases where
custom data IO provider need to be implemented, in this
case for <code>ExperimentalData1D</code>.

== Invocation via command line ==

Again, invocation from command line is provided by Alida in an automatic
way with no further implementational overhead.
The syntax for parameterized classes es a comma separated list of name=value pairs
enclosed in curly brackets where name refers to annotated member variables of
the parameterized class.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner SmoothData1D \
experiment='{ baselineCorrected=false , \
description="my experiment" , \
data=[1.0,2.0,2.2,3.3,2.0,1.0,1.0,1.0,1.0,2.0,3.3,2.0] }' \
smoothingMethod=GAUSSIAN \
smoothedExperiment=-
</pre>
yields
<pre>
smoothedExperiment = { baselineCorrected=false ,
data=[1.28,1.85,2.37,2.76,2.05,1.23,1.01,1.01,1.23,2.05,2.73,2.35] ,
timeResolution=NaN ,
description="my experiment" (smoothed) }
</pre>

If a class derived from <code>ExperimentalData1D</code> was to be supplied to the operator,
the curly brackets can be prefixed by a derive class definition starting with a dollar sign
and ending with a colon as shown for the summarizing operators above.

= Graphical workflow editor: Grappa =
Most of the time complex data analysis tasks cannot be solved by only applying a
single operator to the data. Rather, selections of various operators need to be
combined into more sophisticated workflows to extract desired result data.
Alida inherently supports the development of such workflows.
Grappa, the Graphical Programming
Editor for Alida, allows for designing and manipulating workflows via graph edit operations, hence, offers
an intuitive interface and large flexibility for developing workflows.

A workflow in Alida is defined as a graph data structure. Each node of the graph represents an Alida operator, while edges between
different nodes encode the flow of data and control. Each node owns a selection of input and output ports which are associated with the
operator's parameters. Consequently, edges are directed, i.e., an edge always
connects an output port of one operator node with an input port of another. Grappa visualizes such workflow graphs and supports manual editing, manipulation, and also workflow execution
and analysis of results.

Grappa can be started using the following command:

<code>java de.unihalle.informatik.Alida.tools.ALDGrappaRunner</code>

Grappa's main window is
basically divided into two sections. On the left, the node selection menu is
visible, while on the right the workbench area is located.
In addition, the window features a menubar for configuring Grappa, loading and
saving workflows, and accessing the online help. At the bottom of the window a
panel displaying status and progress messages is available.

A demo workflow is supplied with the distribution. To load this workflow right click into the workbench area to pop up the
context menue. Select <code>'Load'</code> navigate to the base directory where you unpacked the distribution.
From there navigate further to <code>share/examples/workflows</code> select <code>Demo.awf</code>
and load the sample workflow. This workflow is also described in manual of Alida.

== Operator node selection menu ==
In the selection menu on the left of Grappa's main window all Alida operators found in the
classpath upon initialization are listed as potential nodes for Grappa workflows.
In analogy to the graphical user interface
they are arranged in a hierarchical ordering
according to their package structure. The different package subtrees can be
folded and unfolded by double-clicking on a folder's name in the selection tree,
or by single-clicking on the circle displayed left to the folder icon. Above the
tree view an operator filter is available which allows to select operators
according to their names. For filtering, enter a substring into the text
field and press the return key.
Operator nodes can be added to a workflow by double-clicking on the operator
name. A new operator node is then instantiated in the top left corner of the
corresponding workflow tab, i.e., the active workflow (see below).
Alternatively, an operator can be selected by clicking once on its name
and afterwards clicking once on the position in the workflow tab where the new
operator node should be positioned.

== Workbench area ==
Workflows can be designed and executed in the workbench area on the right of the main window. It allows for instantiating
multiple workflows in parallel where each workflow is linked to an individual tab of the workbench panel.
A new workflow tab can be added via the item <code>'New'</code> in the context menu of the workbench.
The context menu is displayed upon right-click on an empty location of the workbench area.
Upon selecting the item <code>'New'</code> a new tab is added to the workbench panel.
By default, the name of the new workflow is 'Untitled', but it can easily be
renamed via the corresponding item <code>'Rename'</code> in the context menu. Via this
menu it is also possible to close a workflow tab if no longer required. Note
that its contents are lost if not saved before! The currently selected tab in
the workbench contains the active workflow which can be edited and where
new operator nodes can be added as outlined in the previous subsection.

For each operator selected via the selection menu, a
node in terms of a rectangle is added to the currently active workflow. Above the rectangle
the name of the operator is displayed, while on its left and right side the operator's input and output ports are shown as circles and
squares. Circles are associated with operator parameters of directions <code>IN</code> or <code>OUT</code>, while squares refer to parameters with
direction <code>INOUT</code>. The latter ports are duplicated on both sides of the node.
The colors of the circles indicate their type. Blue circles refer to required parameters, yellow circles are associated with optional
parameters, and red circles are linked to supplemental parameters. To the left and right of the ports,
respectively, the name of the corresponding parameters are written.
Once operator nodes have been added to a workflow, they can easily be dragged
and repositioned as well as resized via intuitive mouse actions.

For each operator node a context menu can be popped up by clicking the node with the right mouse
button. From this menu it is possible to delete the node (item <code>'Remove'</code>), or to configure the
view via the item <code>'Options'</code>. It, e.g., allows to select the set of operator parameter ports
to be shown, i.e. either all parameters or just the subset of non-expert parameters. From the
context menu of a node it is also possible to configure the node (item <code>'Configure'</code>).

On selecting the item for
configuration, a window is displayed which allows to enter parameter values.
The window is automatically generated, i.e., actually the same
mechanisms as for executing operators via the graphical operator runner are applied. Accordingly,
the configuration window is identical to the corresponding operator control
window and shares the same layout, except for the control buttons and the batch
mode tab which are missing.

Operator parameters for a certain node can directly be specified via the
configuration window, they can be loaded from a proper parameter file in XML
format, or they
can be configured by dragging edges between ports of different nodes with the
mouse to propagate output data from one node as input data to another. To add an
edge, move the mouse over an output port of a node until the port is surrounded
by a green square, then press the left mouse button. Subsequently, while keeping
the button pressed, move the mouse to the desired input port of another node.
Once a green rectangle shows up around the target input port, release the
button. Note that on dragging edges Grappa performs type and validity checks.
Only ports being associated with compatible parameter data types can be
linked to each other. Two parameter data types are compatible if they are
either equal, the target data type is a super class of the source data type, or
if Alida has access to a converter allowing to transform the source data type
into the target type. Also
edges are forbidden that would induce cycles into the workflow graph.

Nodes in a workflow can have different states indicated by the color of their border.
Red framed nodes are not ready for execution, i.e., their configuration is not
complete. If a node is readily configured and can directly be executed, its
border has a yellow color, while nodes that are configured, however, require
additional input data from preceeding operator nodes have an orange color.
Prior to executing these orange nodes it is, thus, necessary to execute the
preceeding nodes first.
Note that Grappa takes care of such dependencies, i.e., automatically executes
nodes first from which result data is required for proper workflow or node
execution. The state of a node is updated by Grappa in real-time, i.e., each
change in its configuration directly invokes internal checkings and may result in a change of the node's color.

Grappa offers various modes for executing a
complete workflow or parts of it.
From the context menu of the workbench the item
<code>'Run'</code> is available which executes the complete workflow, i.e., all nodes
currently present on the tab. From the context menu of a single node and its <code>'Run ...'</code> item also the whole workflow can be executed (item <code>'Workflow'</code>).
Alternatively, via the item <code>'Nodes from here'</code> it is possible to only execute the nodes of the workflow subgraph for which the
current node is the root (of course considering required dependencies). Finally, the item <code>'Node'</code> allows for running the workflow
until the node in question. As mentioned before, Grappa automatically takes care
of resolving dependencies, i.e., upon executing a node all nodes having a yellow
or orange border and being predecessors of the node in question are also executed. Note that the execution of a workflow will fail if one of the nodes is still colored red, or if a node does not produce proper output data required by others.

After successful execution of the workflow or a subset of nodes, the colors of
the corresponding nodes change to green indicating that result data are
available. For all terminal nodes having no successor the result frames are
automatically opened.
For all other nodes the result data can graphically be examined via the nodes'
context menus from which the result windows can manually be opened.
Once a node has been executed and is colored in green, it is not possible to
re-execute the node until its configuration, or at least the configuration of
one of its preceeding nodes, was changed.

== Menubar ==
The Grappa main window features a menubar offering quick
access to the basic functions of Grappa and some additional convenience functionality simplifying
the work with the editor.

Via the menu item <code>'File'</code> workflows can be saved to and read from
disk. By saving a workflow currently two files are written to disk, one containing the information
about the nodes and their configuration, and one storing graphical information
regarding the current workflow layout. Both are required to load a workflow
again. The first one has the extension <code>'.awf'</code>, the latter one the
extension <code>'.awf.gui'</code>.

Via the menu item <code>'Workflow'</code> new workflows can be added and existing ones be renamed,
closed, executed or interrupted.
Alida supports two categories of
operators, i.e. operators mainly dedicated to direct application by non-expert users
and operators for special tasks and expert usage. Via the item <code>'Options'</code> the menubar allows
to switch the view in the selection menu between both categories. Also progress messages triggered by the
operator node during execution and optionally shown in the status panel can be enabled or
disabled via this menu. Finally, the menu item <code>'Help'</code> grants access to Alida's online help system
where information about its functionality and descriptions of the operators can be found.

Java quick

2016-02-23T22:32:51Z

Posch: /* Graphical workflow editor: Grappa */

Here we introduce Alida's operator concept with some code snippets of <code>ALDOperator</code> and sub-classed demo operators.
we focus on Alida's capabilities to automatically generate user interfaces.

= First operator =

As a first example of an Alida operator we implement the row or column wise
sum for a 2D array of Doubles.
The class <code>MatrixSum</code> extending <code>ALDOperator</code> features three member variables
holding the input 2D array, an enum to indicate the mode of summation (<code>ROW</code> or <code>COLUMN</code>), and
an 1D array of the sums to be computed and returned by the operator.
Alida requires only to annotate these members with the @Parameter annotation
which declares

* the direction (<code>IN</code>, <code>OUT</code>, <code>INOUT</code>),
* whether the parameter is required,
* an optional textual description,
* and a label used, e.g. in the graphical user interface automatically generated
to execute the operator.

It is important to add a public standard constructor (without arguments)
to be able to use Java's reflection mechanism.
Finally, the abstract method <code>operate()</code> of <code>ALDOperator</code> has to be overridden
implementing the functionality of the operator.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class MatrixSum extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,

/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows?")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* 1D Array of sums.
*/
@Parameter( label= "sums",
direction = Parameter.Direction.OUT, description = "Row or column wise sums.")
private Double[] sums = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public MatrixSum() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public MatrixSum(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() {
if ( matrix == null )
sums = null;

// calculate sums
if ( summarizeMode == SummarizeMode.ROW ) {
sums = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
sums[row] = 0.0;
for ( int col = 0 ; col < matrix[0].length ; col++ )
sums[row] += matrix[row][col];
}
} else {
sums = new Double[matrix[0].length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
sums[col] = 0.0;
for ( int row = 0 ; row < matrix.length ; row++ )
sums[col] += matrix[row][col];
}
}
}
</pre>

These are the basic requirements for the operator to be used on the programming level.
An example of this use is included in the example in the next section.

If we further annotate the class with
<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL)
</pre>
this is all needed to also facilitate
execution of this operator via a graphical and a command line user interface
automatically generated by Alida.
(Setting <code>level=ALDAOperator.Level.APPLICATION</code> declares this operator an application
which is used in the GUI to control display of available operators.)

== Invocation via a graphical user interface ==

Alida comes with one single application to execute Alida operators
with a automatically generated graphical user interface which may be
started from command line by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunnerGUI
</pre>

This will pop up a window to choose an operator to execute.
Arranged according to the package structure all operators allows to be executed
via the graphical user interface according to their <code>genericExecutionMode</code>
are displayed.
Initially packages are unfolded up to a predefined depth.
Unfold the demo package, select <code>MatrixSum</code>, and choose the "Configure Operator" button.
This will pop up another window which allows you to configure the input parameters
of the operator.
Important note: After finishing to input the data matrix entering the final matrix elements
you have to select a previous matrix element due to subtle AWT details.
For the enumeration to select the mode Alida has automatically generated
a combo box to allow convenient selections.
If you are finished with the parameter configuration you want to invoke the operator
using the run button.
On completion of <code>MatrixSum</code> the interface will pop up the result window which allows you
to inspect the outcome of the operation.

== Invocation via command line ==

The command line user interface of Alida allows to invoke all Alida operator
properly annotated to allows generic execution.

You may invoke the matrix summation operator by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]' sums=-
</pre>
which returns as result on standard output
<pre>
sums = [6.0,15.0]
</pre>

Parameter values are specified as name=value pairs.
Alida's syntax for 2D array should be self-explanatory from this example.
As the mode of summation is not supplied as a parameter its default is used

Note, the command
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
</pre>
will return no output as the command line user interface returns only output parameters requested.

The enumeration defined in <code>MatrixSum</code> is supported by the
user interface without further action required as shown in the next example.
This also demonstrates redirection of output
to a file, sums.out in this case.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
summarizeMode=COLUMN sums=@sums.out+
</pre>
Input can be read from file as well:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix=@data sums=-+
</pre>

where the file data contains the string defining the matrix, e.g., <code>[[1,2,3],[4,5,6]]</code>

= Adding more features to an operator =

We now generalize this example to realize not only summation over rows or
columns, but arbitrary summarizing operations.
This shows Alida's feature to allow an operator as parameter of another operator.

== Implementation ==

First we generalize <code>ALDArraySum</code> to the operator <code>ApplyToMatrix</code>
which also takes a 2D array and an enum indicating the mode of marginalization (<code>ROW</code> or <code>COLUMN</code>).
It takes an additional input parameter which specifies the operation to be applied on each
row or column.

This parameter is itself an Alida operator and of type <code>ALDSummarizeArrayOp</code>
which is implemented as an abstract class.
This abstract operator defines a summarizing operator
which takes a 1D array as input and returns a summarizing scalar.
As this is an abstract class there is no need to override the <code>operate()</code>
method, however some getter and setter methods are provided.

<pre>
@Parameter( label= "Input 1D array", required = true,
direction = Parameter.Direction.IN, description = "Input array (1D).")
protected Double[] data;

/**
* Summarizing scalar
*/
@Parameter( label= "Summarizing scalar",
direction = Parameter.Direction.OUT, description = "Summarizing scalar of the 1D arra")
protected Double summary = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDSummarizeArrayOp() throws ALDOperatorException {
}

/**
* Returns the 1D array
* @return data array
*/
public Double[] getData() {
return this.data;
}

/**
* Sets the 1D array
* @param data
*/
public void setData( Double[] data) {
this.data = data;
}

</pre>

Now we add concrete examples of such a summarizing operation, in this case
summation (<code>ALDArraySum</code>), to return the mean (<code>ALDArrayMean</code>), and the minimum (<code>ALDArrayMin</code>).
Each implements the <code>operate()</code> method and has to supply a standard constructor.
In this example we add another constructor for convenience.
This operators are declared as operators on the standard in contrast to
application level, as they are not expected to be invoked as an application.
However, setting the level to standard in the menu of the graphical user interface
stills allows their execution.
When extending the abstract super class it is necessary to annotate the
class with <code>@ALDDerivedClass</code> in order to allow Alida's dataIO mechanism to find the derived class
in the automatically generated user interface.
This holds for other parameter types as well.
More specifically, if an instance of a class is to be supplied in an automatically
generated user interface as a value for a parameter of one of its super classes,
Alida requires the annotation <code>@ALDDerivedClass</code>.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.STANDARD)
public class ALDArraySum extends ALDSummarizeArrayOp {

@Override
protected void operate() {
summary = 0.0;
for ( int i = 0 ; i < data.length ; i++ )
summary += data[i];
}

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDArraySum() throws ALDOperatorException {
}

</pre>

Now we are ready to implement
the <code>ApplyToMatrix</code> operator, which also demonstrates supplemental parameters.
This supplementals, e.g., control debugging output or returning of intermediate results.
For demo purposes we declare a supplemental input parameter <code>returnElapsedTime</code>.
If it is set to true the operator will return the elapsed time in a second
supplemental parameter with direction output.

Again, the operation is implemented in the <code>operate()</code> method and the remainder of the
class supplies getter and setter methods for convenience.
The <code>operate()</code> method give also an example of the invocation of an operator on the
programming level.
In this case, an instance of the operator is already passed as a parameter.
Its parameters are set, in this case each 1D array to be summarized in turn.
Upon return from the method <code>runOp()</code> the results may be retrieved from the operator object,
in this example with the <code>getSummary()</code> method.
Besides getter and setter methods as implemented in each operator
Alida provides also a generic get and set methods applicable to
all parameters of an operator.
Note, that the operator is not invoked by its <code>operate()</code> method, but via
the <code>runOp()</code> method implemented the base class <code>ALDOperator</code>.
This methods validates the parameters before invocation of <code>operate()</code>.
Furthermore, it take all necessary measures for Alida's processing
history which automatically logs
all manipulative actions on the data and corresponding parameter settings.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class ApplyToMatrix extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,
/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows.")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* Summarizing opererator
*/
@Parameter( label= "Summarizing operator", required = true,
direction = Parameter.Direction.IN, description = "Specifies the summarizing operation to apply")
private ALDSummarizeArrayOp summarizeOp;

/**
* 1D Array of summaries.
*/
@Parameter( label= "summaries",
direction = Parameter.Direction.OUT, description = "Row or column wise summaries")
private Double[] summaries = null;

/**
* Supplemental to request elapsed time to be returned
*/
@Parameter( label= "Return elapsed time",
direction = Parameter.Direction.IN, description = "Request elapsed time consumed to be returned",
supplemental=true)
private boolean returnElapsedTime = false;

/**
* Elpased time
*/
@Parameter( label= "Elapsed time",
direction = Parameter.Direction.OUT, description = "Elapsed time of operation in milliseconds",
supplemental=true)
private long elapsedTime;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ApplyToMatrix() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public ApplyToMatrix(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() throws ALDOperatorException,ALDProcessingDAGException {
if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis();

if ( matrix == null )
summaries = null;

// calculate summaries
if ( summarizeMode == SummarizeMode.ROW ) {
summaries = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
summarizeOp.setData(matrix[row]);
summarizeOp.runOp();
summaries[row] = summarizeOp.getSummary();
}
} else {
summaries = new Double[matrix[0].length];
Double[] tmp = new Double[matrix.length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
for ( int row = 0 ; row < matrix.length ; row++ )
tmp[row] = matrix[row][col];

summarizeOp.setData(tmp);
summarizeOp.runOp();
summaries[col] = summarizeOp.getSummary();
}
}

if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis() - elapsedTime;
}

// ==============================================================
// Getter and setter methods
/** Get value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @return value of returnElapsedTime
*/
public boolean getReturnElapsedTime(){
return returnElapsedTime;
}

/** Set value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @param value New value of returnElapsedTime
*/
public void setReturnElapsedTime( boolean value){
this.returnElapsedTime = value;
}
</pre>

== Invocation via a graphical user interface ==

If the graphical interface is still running just select our new operator
and begin to configure it.
For the parameter summarizing operator you have a choice of all operators extending
the abstract operator <code>ALDSummarizeArrayOp</code>.
All which is necessary on the implementation side is proper annotation of the extending
classes with <code>@ALDDerivedClass</code>.
As the selected operator may have its own parameters you may want to configure it.
In our example this is not necessary as the input array is, of course, supplied
by the <code>ApplyToMatrix</code> operator.
Do not forget to input your data before hitting the run button.
After return, again a result window give you the results of the operation.
Note, if you did not tick Return elapsed time" this window will show zero
for the time elapsed as the operator has not been request to stop the time.

== Invocation via command line ==

When invoking the <code>ApplyToMatrix</code> operator from command line
we have to handle derived classes as value for parameters.
In the graphical user interface Alida features a combo box where
we may choose from.
In the command line interface Alida allows to prefix the value of a parameter
with a derived class to be passed to the operator.
This is necessary as Alida as, of course, no way to itself
decide if and which derived class is to be used.
Alida's syntax is to enclose the class name in a dollar sign and a colon.
As evident in the following example, abbreviations are of the fully
qualified class name are accepted as long as they are unambiguous.
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW \
summarizeOp='<math>ALDArrayMean:{}' \
summaries=-
</pre>
results in
<pre>
summaries = [2.0,5.0]
</pre>

<code>ALDOpRunner</code> may be persuaded to show all operators derived from <code>ALDSummarizeArrayOp</code>
and known within the user interface if we enter an invalid class name:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner \
Apply matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW summarizeOp='</math>dd:{}' \
summaries=-
</pre>
yields
<pre>
ALDStandardizedDataIOCmdline::readData found 0 derived classes matching <dd>
derived classes available:
de.unihalle.informatik.Alida.demo.ALDArrayMean
de.unihalle.informatik.Alida.demo.ALDArrayMin
de.unihalle.informatik.Alida.demo.ALDArraySum
ERROR: reading parameter <summarizeOp> returns null
</pre>

Supplemental parameters are handled like other parameters
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=COLUMN \
summarizeOp='<math>ALDArrayMin:{}' \
summaries=- \
returnElapsedTime=true \
elapsedTime=-
</pre>
gives
<pre>
summaries = [1.0,2.0,3.0]
elapsedTime = 4
</pre>

= Adding more data types as parameters =

Alida provides automatic IO of primitive data types, enumerations, arrays, collections,
and operators.
In addition so called parameterized classes are supported.
Any Java class may be declared to be a parameterized class in Alida
by annotating the class <code>@ALDParametrizedClass</code> as shown in the
class <code>ExperimentalData1D</code>.
All member variables to be known to and handled by Alida's user interface
simply need to be annotated with <code>@ALDClassParameter</code>.

Here we implement a toy version of experimental data <code>ExperimentalData1D</code>.
A complete experiment contains
data of a time series of measurements of variable length.
Additional information is a descriptive string, the time resolution in milliseconds,
and whether baseline correction has been applied.

The class is annotated by <code>@ALDParametrizedClass</code>, and
and all members to be handle in Alida'a user interfaces are
to be annotated with <code>@ALDParametrizedClass</code>.
The label field has the same semantics as for parameters of operators.
These annotations are the only implementational overhead
to allow Alida to automatically generate user interfaces
where the parameterized class acts as a parameter.

<pre>
@ALDParametrizedClass
public class ExperimentalData1D extends ALDData {

/** Description */
@ALDClassParameter(label="description", dataIOOrder = 1)
private String description = null;

/** The data */
@ALDClassParameter(label="data", dataIOOrder = 2)
private Double[] data = null;

/** Are the data baseline corrected? */
@ALDClassParameter(label="Baseline corrected",
dataIOOrder = 3)
private boolean baselineCorrected = false;

@ALDClassParameter(label="Time resolution in milliseconds", dataIOOrder = 4)
private Float timeResolution = Float.NaN;

/**
* Standard constructor is required
*/
public ExperimentalData1D() {
}

/** Constructor for an experiment.
* Baseline correction is assumed to be false and nothung known about
* the time resolution.
*
* @param description a textual description of the experiment
* @param data measurements
*/
public ExperimentalData1D( String description, Double[] data) {
this( description, data, false, Float.NaN);
}
</pre>

This is shown below for a simple normalizing operator <code>SmoothData1D</code>
which takes experimental data as input an returns a new instance
of <code>ExperimentalData</code> which contains smoothed data.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class SmoothData1D extends ALDOperator {

public enum SmoothingMethod {
MEDIAN, MEAN, GAUSSIAN
}

/** 1D Experiment
*/
@Parameter( label= "1D Experiment", required = true,
direction = Parameter.Direction.IN,
description = "1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D experiment;

/** Smoothing method
*/
@Parameter( label = "Smoothing method", required = true,
direction = Parameter.Direction.IN,
callback = "smoothingMethodChanged",
description = "Smoothing method",
paramModificationMode = ParameterModificationMode.MODIFIES_INTERFACE,
dataIOOrder = 2)
SmoothingMethod smoothingMethod = SmoothingMethod.MEDIAN;

/** Window width
*/
@Parameter( label = "Window width", required = true,
direction = Parameter.Direction.IN,
description = "Window width (should be uneven)",
dataIOOrder = 3)
Integer width = 3;

/** Standard deviation of Gaussian
*/
@Parameter( label = "Standdard deviation of Gaussian", required = true,
direction = Parameter.Direction.IN,
description = "Standdard deviation of Gaussian",
dataIOOrder = 3)
Float sigma = 1.0F;

/** Smoothed 1D Experiment
*/
@Parameter( label= "Smothed 1D Experiment",
direction = Parameter.Direction.OUT,
description = "Smothed1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D smoothedExperiment;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public SmoothData1D() throws ALDOperatorException {
// necessary handle dynamic parameters correctly
smoothingMethodChanged();
}

@Override
protected void operate() {
this.fireOperatorExecutionProgressEvent(
new ALDOperatorExecutionProgressEvent(this,
"Starting to smooth 1D Data..."));

Double[] smoothedData;
if ( smoothingMethod == SmoothingMethod.MEDIAN) {
smoothedData = median( experiment.getData(), this.width);
} else {
smoothedData = smoothByConvolution();
}

smoothedExperiment = new ExperimentalData1D( experiment.getDescription() + " (smoothed)",
smoothedData, experiment.isBaselineCorrected(), experiment.getTimeResolution());
}
</pre>

This mechanism applies in a recursive fashion, i.e. a parameterized class may
(recursively) contain a member variable which itself is a parametrized class.
Likewise, an operator acting as a parameter of another operator
may in turn have a parameter of type <code>ALDOperator</code>.

== Invocation via a graphical user interface ==

Invoking and configuring <code>SmoothData1D</code> from the graphical user interface
shows as the only required parameter the experimental data.
This parameterized class can be configured in a separate window
very similar to to configuration of operators.
Likewise the resulting normalized experimental data
may be inspected in their own window.

Obviously this is a toy example, as we would not expect the measurements to
be entered manually, but rather stored and read from file in a specialized format.
This is one of the rare cases where
custom data IO provider need to be implemented, in this
case for <code>ExperimentalData1D</code>.

== Invocation via command line ==

Again, invocation from command line is provided by Alida in an automatic
way with no further implementational overhead.
The syntax for parameterized classes es a comma separated list of name=value pairs
enclosed in curly brackets where name refers to annotated member variables of
the parameterized class.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner SmoothData1D \
experiment='{ baselineCorrected=false , \
description="my experiment" , \
data=[1.0,2.0,2.2,3.3,2.0,1.0,1.0,1.0,1.0,2.0,3.3,2.0] }' \
smoothingMethod=GAUSSIAN \
smoothedExperiment=-
</pre>
yields
<pre>
smoothedExperiment = { baselineCorrected=false ,
data=[1.28,1.85,2.37,2.76,2.05,1.23,1.01,1.01,1.23,2.05,2.73,2.35] ,
timeResolution=NaN ,
description="my experiment" (smoothed) }
</pre>

If a class derived from <code>ExperimentalData1D</code> was to be supplied to the operator,
the curly brackets can be prefixed by a derive class definition starting with a dollar sign
and ending with a colon as shown for the summarizing operators above.

= Graphical workflow editor: Grappa =
Most of the time complex data analysis tasks cannot be solved by only applying a
single operator to the data. Rather, selections of various operators need to be
combined into more sophisticated workflows to extract desired result data.
Alida inherently supports the development of such workflows.
Grappa, the Graphical Programming
Editor for Alida, allows for designing and manipulating workflows via graph edit operations, hence, offers
an intuitive interface and large flexibility for developing workflows.

A workflow in Alida is defined as a graph data structure. Each node of the graph represents an Alida operator, while edges between
different nodes encode the flow of data and control. Each node owns a selection of input and output ports which are associated with the
operator's parameters. Consequently, edges are directed, i.e., an edge always
connects an output port of one operator node with an input port of another. Grappa visualizes such workflow graphs and supports manual editing, manipulation, and also workflow execution
and analysis of results.

Grappa can be started using the following command:

<code>java de.unihalle.informatik.Alida.tools.ALDGrappaRunner</code>

Grappa's main window is
basically divided into two sections. On the left, the node selection menu is
visible, while on the right the workbench area is located.
In addition, the window features a menubar for configuring Grappa, loading and
saving workflows, and accessing the online help. At the bottom of the window a
panel displaying status and progress messages is available.

== Operator node selection menu ==
In the selection menu on the left of Grappa's main window all Alida operators found in the
classpath upon initialization are listed as potential nodes for Grappa workflows.
In analogy to the graphical user interface
they are arranged in a hierarchical ordering
according to their package structure. The different package subtrees can be
folded and unfolded by double-clicking on a folder's name in the selection tree,
or by single-clicking on the circle displayed left to the folder icon. Above the
tree view an operator filter is available which allows to select operators
according to their names. For filtering, enter a substring into the text
field and press the return key.
Operator nodes can be added to a workflow by double-clicking on the operator
name. A new operator node is then instantiated in the top left corner of the
corresponding workflow tab, i.e., the active workflow (see below).
Alternatively, an operator can be selected by clicking once on its name
and afterwards clicking once on the position in the workflow tab where the new
operator node should be positioned.

== Workbench area ==
Workflows can be designed and executed in the workbench area on the right of the main window. It allows for instantiating
multiple workflows in parallel where each workflow is linked to an individual tab of the workbench panel.
A new workflow tab can be added via the item <code>'New'</code> in the context menu of the workbench.
The context menu is displayed upon right-click on an empty location of the workbench area.
Upon selecting the item <code>'New'</code> a new tab is added to the workbench panel.
By default, the name of the new workflow is 'Untitled', but it can easily be
renamed via the corresponding item <code>'Rename'</code> in the context menu. Via this
menu it is also possible to close a workflow tab if no longer required. Note
that its contents are lost if not saved before! The currently selected tab in
the workbench contains the active workflow which can be edited and where
new operator nodes can be added as outlined in the previous subsection.

For each operator selected via the selection menu, a
node in terms of a rectangle is added to the currently active workflow. Above the rectangle
the name of the operator is displayed, while on its left and right side the operator's input and output ports are shown as circles and
squares. Circles are associated with operator parameters of directions <code>IN</code> or <code>OUT</code>, while squares refer to parameters with
direction <code>INOUT</code>. The latter ports are duplicated on both sides of the node.
The colors of the circles indicate their type. Blue circles refer to required parameters, yellow circles are associated with optional
parameters, and red circles are linked to supplemental parameters. To the left and right of the ports,
respectively, the name of the corresponding parameters are written.
Once operator nodes have been added to a workflow, they can easily be dragged
and repositioned as well as resized via intuitive mouse actions.

For each operator node a context menu can be popped up by clicking the node with the right mouse
button. From this menu it is possible to delete the node (item <code>'Remove'</code>), or to configure the
view via the item <code>'Options'</code>. It, e.g., allows to select the set of operator parameter ports
to be shown, i.e. either all parameters or just the subset of non-expert parameters. From the
context menu of a node it is also possible to configure the node (item <code>'Configure'</code>).

On selecting the item for
configuration, a window is displayed which allows to enter parameter values.
The window is automatically generated, i.e., actually the same
mechanisms as for executing operators via the graphical operator runner are applied. Accordingly,
the configuration window is identical to the corresponding operator control
window and shares the same layout, except for the control buttons and the batch
mode tab which are missing.

Operator parameters for a certain node can directly be specified via the
configuration window, they can be loaded from a proper parameter file in XML
format, or they
can be configured by dragging edges between ports of different nodes with the
mouse to propagate output data from one node as input data to another. To add an
edge, move the mouse over an output port of a node until the port is surrounded
by a green square, then press the left mouse button. Subsequently, while keeping
the button pressed, move the mouse to the desired input port of another node.
Once a green rectangle shows up around the target input port, release the
button. Note that on dragging edges Grappa performs type and validity checks.
Only ports being associated with compatible parameter data types can be
linked to each other. Two parameter data types are compatible if they are
either equal, the target data type is a super class of the source data type, or
if Alida has access to a converter allowing to transform the source data type
into the target type. Also
edges are forbidden that would induce cycles into the workflow graph.

Nodes in a workflow can have different states indicated by the color of their border.
Red framed nodes are not ready for execution, i.e., their configuration is not
complete. If a node is readily configured and can directly be executed, its
border has a yellow color, while nodes that are configured, however, require
additional input data from preceeding operator nodes have an orange color.
Prior to executing these orange nodes it is, thus, necessary to execute the
preceeding nodes first.
Note that Grappa takes care of such dependencies, i.e., automatically executes
nodes first from which result data is required for proper workflow or node
execution. The state of a node is updated by Grappa in real-time, i.e., each
change in its configuration directly invokes internal checkings and may result in a change of the node's color.

Grappa offers various modes for executing a
complete workflow or parts of it.
From the context menu of the workbench the item
<code>'Run'</code> is available which executes the complete workflow, i.e., all nodes
currently present on the tab. From the context menu of a single node and its <code>'Run ...'</code> item also the whole workflow can be executed (item <code>'Workflow'</code>).
Alternatively, via the item <code>'Nodes from here'</code> it is possible to only execute the nodes of the workflow subgraph for which the
current node is the root (of course considering required dependencies). Finally, the item <code>'Node'</code> allows for running the workflow
until the node in question. As mentioned before, Grappa automatically takes care
of resolving dependencies, i.e., upon executing a node all nodes having a yellow
or orange border and being predecessors of the node in question are also executed. Note that the execution of a workflow will fail if one of the nodes is still colored red, or if a node does not produce proper output data required by others.

After successful execution of the workflow or a subset of nodes, the colors of
the corresponding nodes change to green indicating that result data are
available. For all terminal nodes having no successor the result frames are
automatically opened.
For all other nodes the result data can graphically be examined via the nodes'
context menus from which the result windows can manually be opened.
Once a node has been executed and is colored in green, it is not possible to
re-execute the node until its configuration, or at least the configuration of
one of its preceeding nodes, was changed.

== Menubar ==
The Grappa main window features a menubar offering quick
access to the basic functions of Grappa and some additional convenience functionality simplifying
the work with the editor.

Via the menu item <code>'File'</code> workflows can be saved to and read from
disk. By saving a workflow currently two files are written to disk, one containing the information
about the nodes and their configuration, and one storing graphical information
regarding the current workflow layout. Both are required to load a workflow
again. The first one has the extension <code>'.awf'</code>, the latter one the
extension <code>'.awf.gui'</code>.

Via the menu item <code>'Workflow'</code> new workflows can be added and existing ones be renamed,
closed, executed or interrupted.
Alida supports two categories of
operators, i.e. operators mainly dedicated to direct application by non-expert users
and operators for special tasks and expert usage. Via the item <code>'Options'</code> the menubar allows
to switch the view in the selection menu between both categories. Also progress messages triggered by the
operator node during execution and optionally shown in the status panel can be enabled or
disabled via this menu. Finally, the menu item <code>'Help'</code> grants access to Alida's online help system
where information about its functionality and descriptions of the operators can be found.

Java quick

2016-02-23T22:31:21Z

Posch: /* Menubar and shortcuts */

Here we introduce Alida's operator concept with some code snippets of <code>ALDOperator</code> and sub-classed demo operators.
we focus on Alida's capabilities to automatically generate user interfaces.

= First operator =

As a first example of an Alida operator we implement the row or column wise
sum for a 2D array of Doubles.
The class <code>MatrixSum</code> extending <code>ALDOperator</code> features three member variables
holding the input 2D array, an enum to indicate the mode of summation (<code>ROW</code> or <code>COLUMN</code>), and
an 1D array of the sums to be computed and returned by the operator.
Alida requires only to annotate these members with the @Parameter annotation
which declares

* the direction (<code>IN</code>, <code>OUT</code>, <code>INOUT</code>),
* whether the parameter is required,
* an optional textual description,
* and a label used, e.g. in the graphical user interface automatically generated
to execute the operator.

It is important to add a public standard constructor (without arguments)
to be able to use Java's reflection mechanism.
Finally, the abstract method <code>operate()</code> of <code>ALDOperator</code> has to be overridden
implementing the functionality of the operator.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class MatrixSum extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,

/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows?")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* 1D Array of sums.
*/
@Parameter( label= "sums",
direction = Parameter.Direction.OUT, description = "Row or column wise sums.")
private Double[] sums = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public MatrixSum() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public MatrixSum(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() {
if ( matrix == null )
sums = null;

// calculate sums
if ( summarizeMode == SummarizeMode.ROW ) {
sums = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
sums[row] = 0.0;
for ( int col = 0 ; col < matrix[0].length ; col++ )
sums[row] += matrix[row][col];
}
} else {
sums = new Double[matrix[0].length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
sums[col] = 0.0;
for ( int row = 0 ; row < matrix.length ; row++ )
sums[col] += matrix[row][col];
}
}
}
</pre>

These are the basic requirements for the operator to be used on the programming level.
An example of this use is included in the example in the next section.

If we further annotate the class with
<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL)
</pre>
this is all needed to also facilitate
execution of this operator via a graphical and a command line user interface
automatically generated by Alida.
(Setting <code>level=ALDAOperator.Level.APPLICATION</code> declares this operator an application
which is used in the GUI to control display of available operators.)

== Invocation via a graphical user interface ==

Alida comes with one single application to execute Alida operators
with a automatically generated graphical user interface which may be
started from command line by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunnerGUI
</pre>

This will pop up a window to choose an operator to execute.
Arranged according to the package structure all operators allows to be executed
via the graphical user interface according to their <code>genericExecutionMode</code>
are displayed.
Initially packages are unfolded up to a predefined depth.
Unfold the demo package, select <code>MatrixSum</code>, and choose the "Configure Operator" button.
This will pop up another window which allows you to configure the input parameters
of the operator.
Important note: After finishing to input the data matrix entering the final matrix elements
you have to select a previous matrix element due to subtle AWT details.
For the enumeration to select the mode Alida has automatically generated
a combo box to allow convenient selections.
If you are finished with the parameter configuration you want to invoke the operator
using the run button.
On completion of <code>MatrixSum</code> the interface will pop up the result window which allows you
to inspect the outcome of the operation.

== Invocation via command line ==

The command line user interface of Alida allows to invoke all Alida operator
properly annotated to allows generic execution.

You may invoke the matrix summation operator by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]' sums=-
</pre>
which returns as result on standard output
<pre>
sums = [6.0,15.0]
</pre>

Parameter values are specified as name=value pairs.
Alida's syntax for 2D array should be self-explanatory from this example.
As the mode of summation is not supplied as a parameter its default is used

Note, the command
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
</pre>
will return no output as the command line user interface returns only output parameters requested.

The enumeration defined in <code>MatrixSum</code> is supported by the
user interface without further action required as shown in the next example.
This also demonstrates redirection of output
to a file, sums.out in this case.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
summarizeMode=COLUMN sums=@sums.out+
</pre>
Input can be read from file as well:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix=@data sums=-+
</pre>

where the file data contains the string defining the matrix, e.g., <code>[[1,2,3],[4,5,6]]</code>

= Adding more features to an operator =

We now generalize this example to realize not only summation over rows or
columns, but arbitrary summarizing operations.
This shows Alida's feature to allow an operator as parameter of another operator.

== Implementation ==

First we generalize <code>ALDArraySum</code> to the operator <code>ApplyToMatrix</code>
which also takes a 2D array and an enum indicating the mode of marginalization (<code>ROW</code> or <code>COLUMN</code>).
It takes an additional input parameter which specifies the operation to be applied on each
row or column.

This parameter is itself an Alida operator and of type <code>ALDSummarizeArrayOp</code>
which is implemented as an abstract class.
This abstract operator defines a summarizing operator
which takes a 1D array as input and returns a summarizing scalar.
As this is an abstract class there is no need to override the <code>operate()</code>
method, however some getter and setter methods are provided.

<pre>
@Parameter( label= "Input 1D array", required = true,
direction = Parameter.Direction.IN, description = "Input array (1D).")
protected Double[] data;

/**
* Summarizing scalar
*/
@Parameter( label= "Summarizing scalar",
direction = Parameter.Direction.OUT, description = "Summarizing scalar of the 1D arra")
protected Double summary = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDSummarizeArrayOp() throws ALDOperatorException {
}

/**
* Returns the 1D array
* @return data array
*/
public Double[] getData() {
return this.data;
}

/**
* Sets the 1D array
* @param data
*/
public void setData( Double[] data) {
this.data = data;
}

</pre>

Now we add concrete examples of such a summarizing operation, in this case
summation (<code>ALDArraySum</code>), to return the mean (<code>ALDArrayMean</code>), and the minimum (<code>ALDArrayMin</code>).
Each implements the <code>operate()</code> method and has to supply a standard constructor.
In this example we add another constructor for convenience.
This operators are declared as operators on the standard in contrast to
application level, as they are not expected to be invoked as an application.
However, setting the level to standard in the menu of the graphical user interface
stills allows their execution.
When extending the abstract super class it is necessary to annotate the
class with <code>@ALDDerivedClass</code> in order to allow Alida's dataIO mechanism to find the derived class
in the automatically generated user interface.
This holds for other parameter types as well.
More specifically, if an instance of a class is to be supplied in an automatically
generated user interface as a value for a parameter of one of its super classes,
Alida requires the annotation <code>@ALDDerivedClass</code>.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.STANDARD)
public class ALDArraySum extends ALDSummarizeArrayOp {

@Override
protected void operate() {
summary = 0.0;
for ( int i = 0 ; i < data.length ; i++ )
summary += data[i];
}

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDArraySum() throws ALDOperatorException {
}

</pre>

Now we are ready to implement
the <code>ApplyToMatrix</code> operator, which also demonstrates supplemental parameters.
This supplementals, e.g., control debugging output or returning of intermediate results.
For demo purposes we declare a supplemental input parameter <code>returnElapsedTime</code>.
If it is set to true the operator will return the elapsed time in a second
supplemental parameter with direction output.

Again, the operation is implemented in the <code>operate()</code> method and the remainder of the
class supplies getter and setter methods for convenience.
The <code>operate()</code> method give also an example of the invocation of an operator on the
programming level.
In this case, an instance of the operator is already passed as a parameter.
Its parameters are set, in this case each 1D array to be summarized in turn.
Upon return from the method <code>runOp()</code> the results may be retrieved from the operator object,
in this example with the <code>getSummary()</code> method.
Besides getter and setter methods as implemented in each operator
Alida provides also a generic get and set methods applicable to
all parameters of an operator.
Note, that the operator is not invoked by its <code>operate()</code> method, but via
the <code>runOp()</code> method implemented the base class <code>ALDOperator</code>.
This methods validates the parameters before invocation of <code>operate()</code>.
Furthermore, it take all necessary measures for Alida's processing
history which automatically logs
all manipulative actions on the data and corresponding parameter settings.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class ApplyToMatrix extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,
/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows.")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* Summarizing opererator
*/
@Parameter( label= "Summarizing operator", required = true,
direction = Parameter.Direction.IN, description = "Specifies the summarizing operation to apply")
private ALDSummarizeArrayOp summarizeOp;

/**
* 1D Array of summaries.
*/
@Parameter( label= "summaries",
direction = Parameter.Direction.OUT, description = "Row or column wise summaries")
private Double[] summaries = null;

/**
* Supplemental to request elapsed time to be returned
*/
@Parameter( label= "Return elapsed time",
direction = Parameter.Direction.IN, description = "Request elapsed time consumed to be returned",
supplemental=true)
private boolean returnElapsedTime = false;

/**
* Elpased time
*/
@Parameter( label= "Elapsed time",
direction = Parameter.Direction.OUT, description = "Elapsed time of operation in milliseconds",
supplemental=true)
private long elapsedTime;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ApplyToMatrix() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public ApplyToMatrix(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() throws ALDOperatorException,ALDProcessingDAGException {
if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis();

if ( matrix == null )
summaries = null;

// calculate summaries
if ( summarizeMode == SummarizeMode.ROW ) {
summaries = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
summarizeOp.setData(matrix[row]);
summarizeOp.runOp();
summaries[row] = summarizeOp.getSummary();
}
} else {
summaries = new Double[matrix[0].length];
Double[] tmp = new Double[matrix.length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
for ( int row = 0 ; row < matrix.length ; row++ )
tmp[row] = matrix[row][col];

summarizeOp.setData(tmp);
summarizeOp.runOp();
summaries[col] = summarizeOp.getSummary();
}
}

if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis() - elapsedTime;
}

// ==============================================================
// Getter and setter methods
/** Get value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @return value of returnElapsedTime
*/
public boolean getReturnElapsedTime(){
return returnElapsedTime;
}

/** Set value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @param value New value of returnElapsedTime
*/
public void setReturnElapsedTime( boolean value){
this.returnElapsedTime = value;
}
</pre>

== Invocation via a graphical user interface ==

If the graphical interface is still running just select our new operator
and begin to configure it.
For the parameter summarizing operator you have a choice of all operators extending
the abstract operator <code>ALDSummarizeArrayOp</code>.
All which is necessary on the implementation side is proper annotation of the extending
classes with <code>@ALDDerivedClass</code>.
As the selected operator may have its own parameters you may want to configure it.
In our example this is not necessary as the input array is, of course, supplied
by the <code>ApplyToMatrix</code> operator.
Do not forget to input your data before hitting the run button.
After return, again a result window give you the results of the operation.
Note, if you did not tick Return elapsed time" this window will show zero
for the time elapsed as the operator has not been request to stop the time.

== Invocation via command line ==

When invoking the <code>ApplyToMatrix</code> operator from command line
we have to handle derived classes as value for parameters.
In the graphical user interface Alida features a combo box where
we may choose from.
In the command line interface Alida allows to prefix the value of a parameter
with a derived class to be passed to the operator.
This is necessary as Alida as, of course, no way to itself
decide if and which derived class is to be used.
Alida's syntax is to enclose the class name in a dollar sign and a colon.
As evident in the following example, abbreviations are of the fully
qualified class name are accepted as long as they are unambiguous.
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW \
summarizeOp='<math>ALDArrayMean:{}' \
summaries=-
</pre>
results in
<pre>
summaries = [2.0,5.0]
</pre>

<code>ALDOpRunner</code> may be persuaded to show all operators derived from <code>ALDSummarizeArrayOp</code>
and known within the user interface if we enter an invalid class name:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner \
Apply matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW summarizeOp='</math>dd:{}' \
summaries=-
</pre>
yields
<pre>
ALDStandardizedDataIOCmdline::readData found 0 derived classes matching <dd>
derived classes available:
de.unihalle.informatik.Alida.demo.ALDArrayMean
de.unihalle.informatik.Alida.demo.ALDArrayMin
de.unihalle.informatik.Alida.demo.ALDArraySum
ERROR: reading parameter <summarizeOp> returns null
</pre>

Supplemental parameters are handled like other parameters
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=COLUMN \
summarizeOp='<math>ALDArrayMin:{}' \
summaries=- \
returnElapsedTime=true \
elapsedTime=-
</pre>
gives
<pre>
summaries = [1.0,2.0,3.0]
elapsedTime = 4
</pre>

= Adding more data types as parameters =

Alida provides automatic IO of primitive data types, enumerations, arrays, collections,
and operators.
In addition so called parameterized classes are supported.
Any Java class may be declared to be a parameterized class in Alida
by annotating the class <code>@ALDParametrizedClass</code> as shown in the
class <code>ExperimentalData1D</code>.
All member variables to be known to and handled by Alida's user interface
simply need to be annotated with <code>@ALDClassParameter</code>.

Here we implement a toy version of experimental data <code>ExperimentalData1D</code>.
A complete experiment contains
data of a time series of measurements of variable length.
Additional information is a descriptive string, the time resolution in milliseconds,
and whether baseline correction has been applied.

The class is annotated by <code>@ALDParametrizedClass</code>, and
and all members to be handle in Alida'a user interfaces are
to be annotated with <code>@ALDParametrizedClass</code>.
The label field has the same semantics as for parameters of operators.
These annotations are the only implementational overhead
to allow Alida to automatically generate user interfaces
where the parameterized class acts as a parameter.

<pre>
@ALDParametrizedClass
public class ExperimentalData1D extends ALDData {

/** Description */
@ALDClassParameter(label="description", dataIOOrder = 1)
private String description = null;

/** The data */
@ALDClassParameter(label="data", dataIOOrder = 2)
private Double[] data = null;

/** Are the data baseline corrected? */
@ALDClassParameter(label="Baseline corrected",
dataIOOrder = 3)
private boolean baselineCorrected = false;

@ALDClassParameter(label="Time resolution in milliseconds", dataIOOrder = 4)
private Float timeResolution = Float.NaN;

/**
* Standard constructor is required
*/
public ExperimentalData1D() {
}

/** Constructor for an experiment.
* Baseline correction is assumed to be false and nothung known about
* the time resolution.
*
* @param description a textual description of the experiment
* @param data measurements
*/
public ExperimentalData1D( String description, Double[] data) {
this( description, data, false, Float.NaN);
}
</pre>

This is shown below for a simple normalizing operator <code>SmoothData1D</code>
which takes experimental data as input an returns a new instance
of <code>ExperimentalData</code> which contains smoothed data.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class SmoothData1D extends ALDOperator {

public enum SmoothingMethod {
MEDIAN, MEAN, GAUSSIAN
}

/** 1D Experiment
*/
@Parameter( label= "1D Experiment", required = true,
direction = Parameter.Direction.IN,
description = "1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D experiment;

/** Smoothing method
*/
@Parameter( label = "Smoothing method", required = true,
direction = Parameter.Direction.IN,
callback = "smoothingMethodChanged",
description = "Smoothing method",
paramModificationMode = ParameterModificationMode.MODIFIES_INTERFACE,
dataIOOrder = 2)
SmoothingMethod smoothingMethod = SmoothingMethod.MEDIAN;

/** Window width
*/
@Parameter( label = "Window width", required = true,
direction = Parameter.Direction.IN,
description = "Window width (should be uneven)",
dataIOOrder = 3)
Integer width = 3;

/** Standard deviation of Gaussian
*/
@Parameter( label = "Standdard deviation of Gaussian", required = true,
direction = Parameter.Direction.IN,
description = "Standdard deviation of Gaussian",
dataIOOrder = 3)
Float sigma = 1.0F;

/** Smoothed 1D Experiment
*/
@Parameter( label= "Smothed 1D Experiment",
direction = Parameter.Direction.OUT,
description = "Smothed1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D smoothedExperiment;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public SmoothData1D() throws ALDOperatorException {
// necessary handle dynamic parameters correctly
smoothingMethodChanged();
}

@Override
protected void operate() {
this.fireOperatorExecutionProgressEvent(
new ALDOperatorExecutionProgressEvent(this,
"Starting to smooth 1D Data..."));

Double[] smoothedData;
if ( smoothingMethod == SmoothingMethod.MEDIAN) {
smoothedData = median( experiment.getData(), this.width);
} else {
smoothedData = smoothByConvolution();
}

smoothedExperiment = new ExperimentalData1D( experiment.getDescription() + " (smoothed)",
smoothedData, experiment.isBaselineCorrected(), experiment.getTimeResolution());
}
</pre>

This mechanism applies in a recursive fashion, i.e. a parameterized class may
(recursively) contain a member variable which itself is a parametrized class.
Likewise, an operator acting as a parameter of another operator
may in turn have a parameter of type <code>ALDOperator</code>.

== Invocation via a graphical user interface ==

Invoking and configuring <code>SmoothData1D</code> from the graphical user interface
shows as the only required parameter the experimental data.
This parameterized class can be configured in a separate window
very similar to to configuration of operators.
Likewise the resulting normalized experimental data
may be inspected in their own window.

Obviously this is a toy example, as we would not expect the measurements to
be entered manually, but rather stored and read from file in a specialized format.
This is one of the rare cases where
custom data IO provider need to be implemented, in this
case for <code>ExperimentalData1D</code>.

== Invocation via command line ==

Again, invocation from command line is provided by Alida in an automatic
way with no further implementational overhead.
The syntax for parameterized classes es a comma separated list of name=value pairs
enclosed in curly brackets where name refers to annotated member variables of
the parameterized class.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner SmoothData1D \
experiment='{ baselineCorrected=false , \
description="my experiment" , \
data=[1.0,2.0,2.2,3.3,2.0,1.0,1.0,1.0,1.0,2.0,3.3,2.0] }' \
smoothingMethod=GAUSSIAN \
smoothedExperiment=-
</pre>
yields
<pre>
smoothedExperiment = { baselineCorrected=false ,
data=[1.28,1.85,2.37,2.76,2.05,1.23,1.01,1.01,1.23,2.05,2.73,2.35] ,
timeResolution=NaN ,
description="my experiment" (smoothed) }
</pre>

If a class derived from <code>ExperimentalData1D</code> was to be supplied to the operator,
the curly brackets can be prefixed by a derive class definition starting with a dollar sign
and ending with a colon as shown for the summarizing operators above.

= Graphical workflow editor: Grappa =
Most of the time complex data analysis tasks cannot be solved by only applying a
single operator to the data. Rather, selections of various operators need to be
combined into more sophisticated workflows to extract desired result data.
Alida inherently supports the development of such workflows.
Grappa, the Graphical Programming
Editor for Alida, allows for designing and manipulating workflows via graph edit operations, hence, offers
an intuitive interface and large flexibility for developing workflows.

A workflow in Alida is defined as a graph data structure. Each node of the graph represents an Alida operator, while edges between
different nodes encode the flow of data and control. Each node owns a selection of input and output ports which are associated with the
operator's parameters. Consequently, edges are directed, i.e., an edge always
connects an output port of one operator node with an input port of another. Grappa visualizes such workflow graphs and supports manual editing, manipulation, and also workflow execution
and analysis of results.

Grappa can be started using the following command:

<code>java de.unihalle.informatik.Alida.tools.ALDGrappaRunner</code>

Grappa's main window is
basically divided into two sections. On the left, the node selection menu is
visible, while on the right the workbench area is located.
In addition, the window features a menubar for configuring Grappa, loading and
saving workflows, and accessing the online help. At the bottom of the window a
panel displaying status and progress messages is available.

== Operator node selection menu ==
In the selection menu on the left of Grappa's main window all Alida operators found in the
classpath upon initialization are listed as potential nodes for Grappa workflows.
In analogy to the graphical user interface
they are arranged in a hierarchical ordering
according to their package structure. The different package subtrees can be
folded and unfolded by double-clicking on a folder's name in the selection tree,
or by single-clicking on the circle displayed left to the folder icon. Above the
tree view an operator filter is available which allows to select operators
according to their names. For filtering, enter a substring into the text
field and press the return key.
Operator nodes can be added to a workflow by double-clicking on the operator
name. A new operator node is then instantiated in the top left corner of the
corresponding workflow tab, i.e., the active workflow (see below).
Alternatively, an operator can be selected by clicking once on its name
and afterwards clicking once on the position in the workflow tab where the new
operator node should be positioned.

== Workbench area ==
Workflows can be designed and executed in the workbench area on the right of the main window. It allows for instantiating
multiple workflows in parallel where each workflow is linked to an individual tab of the workbench panel.
A new workflow tab can be added via the item <code>'New'</code> in the context menu of the workbench.
The context menu is displayed upon right-click on an empty location of the workbench area.
Upon selecting the item <code>'New'</code> a new tab is added to the workbench panel.
By default, the name of the new workflow is 'Untitled', but it can easily be
renamed via the corresponding item <code>'Rename'</code> in the context menu. Via this
menu it is also possible to close a workflow tab if no longer required. Note
that its contents are lost if not saved before! The currently selected tab in
the workbench contains the active workflow which can be edited and where
new operator nodes can be added as outlined in the previous subsection.

For each operator selected via the selection menu, a
node in terms of a rectangle is added to the currently active workflow. Above the rectangle
the name of the operator is displayed, while on its left and right side the operator's input and output ports are shown as circles and
squares. Circles are associated with operator parameters of directions <code>IN</code> or <code>OUT</code>, while squares refer to parameters with
direction <code>INOUT</code>. The latter ports are duplicated on both sides of the node.
The colors of the circles indicate their type. Blue circles refer to required parameters, yellow circles are associated with optional
parameters, and red circles are linked to supplemental parameters. To the left and right of the ports,
respectively, the name of the corresponding parameters are written.
Once operator nodes have been added to a workflow, they can easily be dragged
and repositioned as well as resized via intuitive mouse actions.

For each operator node a context menu can be popped up by clicking the node with the right mouse
button. From this menu it is possible to delete the node (item <code>'Remove'</code>), or to configure the
view via the item <code>'Options'</code>. It, e.g., allows to select the set of operator parameter ports
to be shown, i.e. either all parameters or just the subset of non-expert parameters. From the
context menu of a node it is also possible to configure the node (item <code>'Configure'</code>).

On selecting the item for
configuration, a window is displayed which allows to enter parameter values.
The window is automatically generated, i.e., actually the same
mechanisms as for executing operators via the graphical operator runner are applied. Accordingly,
the configuration window is identical to the corresponding operator control
window and shares the same layout, except for the control buttons and the batch
mode tab which are missing.

Operator parameters for a certain node can directly be specified via the
configuration window, they can be loaded from a proper parameter file in XML
format, or they
can be configured by dragging edges between ports of different nodes with the
mouse to propagate output data from one node as input data to another. To add an
edge, move the mouse over an output port of a node until the port is surrounded
by a green square, then press the left mouse button. Subsequently, while keeping
the button pressed, move the mouse to the desired input port of another node.
Once a green rectangle shows up around the target input port, release the
button. Note that on dragging edges Grappa performs type and validity checks.
Only ports being associated with compatible parameter data types can be
linked to each other. Two parameter data types are compatible if they are
either equal, the target data type is a super class of the source data type, or
if Alida has access to a converter allowing to transform the source data type
into the target type. Also
edges are forbidden that would induce cycles into the workflow graph.

Nodes in a workflow can have different states indicated by the color of their border.
Red framed nodes are not ready for execution, i.e., their configuration is not
complete. If a node is readily configured and can directly be executed, its
border has a yellow color, while nodes that are configured, however, require
additional input data from preceeding operator nodes have an orange color.
Prior to executing these orange nodes it is, thus, necessary to execute the
preceeding nodes first.
Note that Grappa takes care of such dependencies, i.e., automatically executes
nodes first from which result data is required for proper workflow or node
execution. The state of a node is updated by Grappa in real-time, i.e., each
change in its configuration directly invokes internal checkings and may result in a change of the node's color.

Grappa offers various modes for executing a
complete workflow or parts of it.
From the context menu of the workbench the item
<code>'Run'</code> is available which executes the complete workflow, i.e., all nodes
currently present on the tab. From the context menu of a single node and its <code>'Run\ldots'</code> item also the whole workflow can be executed (item <code>'Workflow'</code>).
Alternatively, via the item <code>'Nodes from here'</code> it is possible to only execute the nodes of the workflow subgraph for which the
current node is the root (of course considering required dependencies). Finally, the item <code>'Node'</code> allows for running the workflow
until the node in question. As mentioned before, Grappa automatically takes care
of resolving dependencies, i.e., upon executing a node all nodes having a yellow
or orange border and being predecessors of the node in question are also executed. Note that the execution of a workflow will fail if one of the nodes is still colored red, or if a node does not produce proper output data required by others.

After successful execution of the workflow or a subset of nodes, the colors of
the corresponding nodes change to green indicating that result data are
available. For all terminal nodes having no successor the result frames are
automatically opened.
For all other nodes the result data can graphically be examined via the nodes'
context menus from which the result windows can manually be opened.
Once a node has been executed and is colored in green, it is not possible to
re-execute the node until its configuration, or at least the configuration of
one of its preceeding nodes, was changed.

== Menubar ==
The Grappa main window features a menubar offering quick
access to the basic functions of Grappa and some additional convenience functionality simplifying
the work with the editor.

Via the menu item <code>'File'</code> workflows can be saved to and read from
disk. By saving a workflow currently two files are written to disk, one containing the information
about the nodes and their configuration, and one storing graphical information
regarding the current workflow layout. Both are required to load a workflow
again. The first one has the extension <code>'.awf'</code>, the latter one the
extension <code>'.awf.gui'</code>.

Via the menu item <code>'Workflow'</code> new workflows can be added and existing ones be renamed,
closed, executed or interrupted.
Alida supports two categories of
operators, i.e. operators mainly dedicated to direct application by non-expert users
and operators for special tasks and expert usage. Via the item <code>'Options'</code> the menubar allows
to switch the view in the selection menu between both categories. Also progress messages triggered by the
operator node during execution and optionally shown in the status panel can be enabled or
disabled via this menu. Finally, the menu item <code>'Help'</code> grants access to Alida's online help system
where information about its functionality and descriptions of the operators can be found.

Java quick

2016-02-23T22:30:50Z

Posch: /* Graphical workflow editor: Grappa */

Here we introduce Alida's operator concept with some code snippets of <code>ALDOperator</code> and sub-classed demo operators.
we focus on Alida's capabilities to automatically generate user interfaces.

= First operator =

As a first example of an Alida operator we implement the row or column wise
sum for a 2D array of Doubles.
The class <code>MatrixSum</code> extending <code>ALDOperator</code> features three member variables
holding the input 2D array, an enum to indicate the mode of summation (<code>ROW</code> or <code>COLUMN</code>), and
an 1D array of the sums to be computed and returned by the operator.
Alida requires only to annotate these members with the @Parameter annotation
which declares

* the direction (<code>IN</code>, <code>OUT</code>, <code>INOUT</code>),
* whether the parameter is required,
* an optional textual description,
* and a label used, e.g. in the graphical user interface automatically generated
to execute the operator.

It is important to add a public standard constructor (without arguments)
to be able to use Java's reflection mechanism.
Finally, the abstract method <code>operate()</code> of <code>ALDOperator</code> has to be overridden
implementing the functionality of the operator.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class MatrixSum extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,

/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows?")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* 1D Array of sums.
*/
@Parameter( label= "sums",
direction = Parameter.Direction.OUT, description = "Row or column wise sums.")
private Double[] sums = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public MatrixSum() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public MatrixSum(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() {
if ( matrix == null )
sums = null;

// calculate sums
if ( summarizeMode == SummarizeMode.ROW ) {
sums = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
sums[row] = 0.0;
for ( int col = 0 ; col < matrix[0].length ; col++ )
sums[row] += matrix[row][col];
}
} else {
sums = new Double[matrix[0].length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
sums[col] = 0.0;
for ( int row = 0 ; row < matrix.length ; row++ )
sums[col] += matrix[row][col];
}
}
}
</pre>

These are the basic requirements for the operator to be used on the programming level.
An example of this use is included in the example in the next section.

If we further annotate the class with
<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL)
</pre>
this is all needed to also facilitate
execution of this operator via a graphical and a command line user interface
automatically generated by Alida.
(Setting <code>level=ALDAOperator.Level.APPLICATION</code> declares this operator an application
which is used in the GUI to control display of available operators.)

== Invocation via a graphical user interface ==

Alida comes with one single application to execute Alida operators
with a automatically generated graphical user interface which may be
started from command line by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunnerGUI
</pre>

This will pop up a window to choose an operator to execute.
Arranged according to the package structure all operators allows to be executed
via the graphical user interface according to their <code>genericExecutionMode</code>
are displayed.
Initially packages are unfolded up to a predefined depth.
Unfold the demo package, select <code>MatrixSum</code>, and choose the "Configure Operator" button.
This will pop up another window which allows you to configure the input parameters
of the operator.
Important note: After finishing to input the data matrix entering the final matrix elements
you have to select a previous matrix element due to subtle AWT details.
For the enumeration to select the mode Alida has automatically generated
a combo box to allow convenient selections.
If you are finished with the parameter configuration you want to invoke the operator
using the run button.
On completion of <code>MatrixSum</code> the interface will pop up the result window which allows you
to inspect the outcome of the operation.

== Invocation via command line ==

The command line user interface of Alida allows to invoke all Alida operator
properly annotated to allows generic execution.

You may invoke the matrix summation operator by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]' sums=-
</pre>
which returns as result on standard output
<pre>
sums = [6.0,15.0]
</pre>

Parameter values are specified as name=value pairs.
Alida's syntax for 2D array should be self-explanatory from this example.
As the mode of summation is not supplied as a parameter its default is used

Note, the command
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
</pre>
will return no output as the command line user interface returns only output parameters requested.

The enumeration defined in <code>MatrixSum</code> is supported by the
user interface without further action required as shown in the next example.
This also demonstrates redirection of output
to a file, sums.out in this case.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
summarizeMode=COLUMN sums=@sums.out+
</pre>
Input can be read from file as well:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix=@data sums=-+
</pre>

where the file data contains the string defining the matrix, e.g., <code>[[1,2,3],[4,5,6]]</code>

= Adding more features to an operator =

We now generalize this example to realize not only summation over rows or
columns, but arbitrary summarizing operations.
This shows Alida's feature to allow an operator as parameter of another operator.

== Implementation ==

First we generalize <code>ALDArraySum</code> to the operator <code>ApplyToMatrix</code>
which also takes a 2D array and an enum indicating the mode of marginalization (<code>ROW</code> or <code>COLUMN</code>).
It takes an additional input parameter which specifies the operation to be applied on each
row or column.

This parameter is itself an Alida operator and of type <code>ALDSummarizeArrayOp</code>
which is implemented as an abstract class.
This abstract operator defines a summarizing operator
which takes a 1D array as input and returns a summarizing scalar.
As this is an abstract class there is no need to override the <code>operate()</code>
method, however some getter and setter methods are provided.

<pre>
@Parameter( label= "Input 1D array", required = true,
direction = Parameter.Direction.IN, description = "Input array (1D).")
protected Double[] data;

/**
* Summarizing scalar
*/
@Parameter( label= "Summarizing scalar",
direction = Parameter.Direction.OUT, description = "Summarizing scalar of the 1D arra")
protected Double summary = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDSummarizeArrayOp() throws ALDOperatorException {
}

/**
* Returns the 1D array
* @return data array
*/
public Double[] getData() {
return this.data;
}

/**
* Sets the 1D array
* @param data
*/
public void setData( Double[] data) {
this.data = data;
}

</pre>

Now we add concrete examples of such a summarizing operation, in this case
summation (<code>ALDArraySum</code>), to return the mean (<code>ALDArrayMean</code>), and the minimum (<code>ALDArrayMin</code>).
Each implements the <code>operate()</code> method and has to supply a standard constructor.
In this example we add another constructor for convenience.
This operators are declared as operators on the standard in contrast to
application level, as they are not expected to be invoked as an application.
However, setting the level to standard in the menu of the graphical user interface
stills allows their execution.
When extending the abstract super class it is necessary to annotate the
class with <code>@ALDDerivedClass</code> in order to allow Alida's dataIO mechanism to find the derived class
in the automatically generated user interface.
This holds for other parameter types as well.
More specifically, if an instance of a class is to be supplied in an automatically
generated user interface as a value for a parameter of one of its super classes,
Alida requires the annotation <code>@ALDDerivedClass</code>.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.STANDARD)
public class ALDArraySum extends ALDSummarizeArrayOp {

@Override
protected void operate() {
summary = 0.0;
for ( int i = 0 ; i < data.length ; i++ )
summary += data[i];
}

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDArraySum() throws ALDOperatorException {
}

</pre>

Now we are ready to implement
the <code>ApplyToMatrix</code> operator, which also demonstrates supplemental parameters.
This supplementals, e.g., control debugging output or returning of intermediate results.
For demo purposes we declare a supplemental input parameter <code>returnElapsedTime</code>.
If it is set to true the operator will return the elapsed time in a second
supplemental parameter with direction output.

Again, the operation is implemented in the <code>operate()</code> method and the remainder of the
class supplies getter and setter methods for convenience.
The <code>operate()</code> method give also an example of the invocation of an operator on the
programming level.
In this case, an instance of the operator is already passed as a parameter.
Its parameters are set, in this case each 1D array to be summarized in turn.
Upon return from the method <code>runOp()</code> the results may be retrieved from the operator object,
in this example with the <code>getSummary()</code> method.
Besides getter and setter methods as implemented in each operator
Alida provides also a generic get and set methods applicable to
all parameters of an operator.
Note, that the operator is not invoked by its <code>operate()</code> method, but via
the <code>runOp()</code> method implemented the base class <code>ALDOperator</code>.
This methods validates the parameters before invocation of <code>operate()</code>.
Furthermore, it take all necessary measures for Alida's processing
history which automatically logs
all manipulative actions on the data and corresponding parameter settings.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class ApplyToMatrix extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,
/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows.")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* Summarizing opererator
*/
@Parameter( label= "Summarizing operator", required = true,
direction = Parameter.Direction.IN, description = "Specifies the summarizing operation to apply")
private ALDSummarizeArrayOp summarizeOp;

/**
* 1D Array of summaries.
*/
@Parameter( label= "summaries",
direction = Parameter.Direction.OUT, description = "Row or column wise summaries")
private Double[] summaries = null;

/**
* Supplemental to request elapsed time to be returned
*/
@Parameter( label= "Return elapsed time",
direction = Parameter.Direction.IN, description = "Request elapsed time consumed to be returned",
supplemental=true)
private boolean returnElapsedTime = false;

/**
* Elpased time
*/
@Parameter( label= "Elapsed time",
direction = Parameter.Direction.OUT, description = "Elapsed time of operation in milliseconds",
supplemental=true)
private long elapsedTime;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ApplyToMatrix() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public ApplyToMatrix(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() throws ALDOperatorException,ALDProcessingDAGException {
if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis();

if ( matrix == null )
summaries = null;

// calculate summaries
if ( summarizeMode == SummarizeMode.ROW ) {
summaries = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
summarizeOp.setData(matrix[row]);
summarizeOp.runOp();
summaries[row] = summarizeOp.getSummary();
}
} else {
summaries = new Double[matrix[0].length];
Double[] tmp = new Double[matrix.length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
for ( int row = 0 ; row < matrix.length ; row++ )
tmp[row] = matrix[row][col];

summarizeOp.setData(tmp);
summarizeOp.runOp();
summaries[col] = summarizeOp.getSummary();
}
}

if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis() - elapsedTime;
}

// ==============================================================
// Getter and setter methods
/** Get value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @return value of returnElapsedTime
*/
public boolean getReturnElapsedTime(){
return returnElapsedTime;
}

/** Set value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @param value New value of returnElapsedTime
*/
public void setReturnElapsedTime( boolean value){
this.returnElapsedTime = value;
}
</pre>

== Invocation via a graphical user interface ==

If the graphical interface is still running just select our new operator
and begin to configure it.
For the parameter summarizing operator you have a choice of all operators extending
the abstract operator <code>ALDSummarizeArrayOp</code>.
All which is necessary on the implementation side is proper annotation of the extending
classes with <code>@ALDDerivedClass</code>.
As the selected operator may have its own parameters you may want to configure it.
In our example this is not necessary as the input array is, of course, supplied
by the <code>ApplyToMatrix</code> operator.
Do not forget to input your data before hitting the run button.
After return, again a result window give you the results of the operation.
Note, if you did not tick Return elapsed time" this window will show zero
for the time elapsed as the operator has not been request to stop the time.

== Invocation via command line ==

When invoking the <code>ApplyToMatrix</code> operator from command line
we have to handle derived classes as value for parameters.
In the graphical user interface Alida features a combo box where
we may choose from.
In the command line interface Alida allows to prefix the value of a parameter
with a derived class to be passed to the operator.
This is necessary as Alida as, of course, no way to itself
decide if and which derived class is to be used.
Alida's syntax is to enclose the class name in a dollar sign and a colon.
As evident in the following example, abbreviations are of the fully
qualified class name are accepted as long as they are unambiguous.
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW \
summarizeOp='<math>ALDArrayMean:{}' \
summaries=-
</pre>
results in
<pre>
summaries = [2.0,5.0]
</pre>

<code>ALDOpRunner</code> may be persuaded to show all operators derived from <code>ALDSummarizeArrayOp</code>
and known within the user interface if we enter an invalid class name:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner \
Apply matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW summarizeOp='</math>dd:{}' \
summaries=-
</pre>
yields
<pre>
ALDStandardizedDataIOCmdline::readData found 0 derived classes matching <dd>
derived classes available:
de.unihalle.informatik.Alida.demo.ALDArrayMean
de.unihalle.informatik.Alida.demo.ALDArrayMin
de.unihalle.informatik.Alida.demo.ALDArraySum
ERROR: reading parameter <summarizeOp> returns null
</pre>

Supplemental parameters are handled like other parameters
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=COLUMN \
summarizeOp='<math>ALDArrayMin:{}' \
summaries=- \
returnElapsedTime=true \
elapsedTime=-
</pre>
gives
<pre>
summaries = [1.0,2.0,3.0]
elapsedTime = 4
</pre>

= Adding more data types as parameters =

Alida provides automatic IO of primitive data types, enumerations, arrays, collections,
and operators.
In addition so called parameterized classes are supported.
Any Java class may be declared to be a parameterized class in Alida
by annotating the class <code>@ALDParametrizedClass</code> as shown in the
class <code>ExperimentalData1D</code>.
All member variables to be known to and handled by Alida's user interface
simply need to be annotated with <code>@ALDClassParameter</code>.

Here we implement a toy version of experimental data <code>ExperimentalData1D</code>.
A complete experiment contains
data of a time series of measurements of variable length.
Additional information is a descriptive string, the time resolution in milliseconds,
and whether baseline correction has been applied.

The class is annotated by <code>@ALDParametrizedClass</code>, and
and all members to be handle in Alida'a user interfaces are
to be annotated with <code>@ALDParametrizedClass</code>.
The label field has the same semantics as for parameters of operators.
These annotations are the only implementational overhead
to allow Alida to automatically generate user interfaces
where the parameterized class acts as a parameter.

<pre>
@ALDParametrizedClass
public class ExperimentalData1D extends ALDData {

/** Description */
@ALDClassParameter(label="description", dataIOOrder = 1)
private String description = null;

/** The data */
@ALDClassParameter(label="data", dataIOOrder = 2)
private Double[] data = null;

/** Are the data baseline corrected? */
@ALDClassParameter(label="Baseline corrected",
dataIOOrder = 3)
private boolean baselineCorrected = false;

@ALDClassParameter(label="Time resolution in milliseconds", dataIOOrder = 4)
private Float timeResolution = Float.NaN;

/**
* Standard constructor is required
*/
public ExperimentalData1D() {
}

/** Constructor for an experiment.
* Baseline correction is assumed to be false and nothung known about
* the time resolution.
*
* @param description a textual description of the experiment
* @param data measurements
*/
public ExperimentalData1D( String description, Double[] data) {
this( description, data, false, Float.NaN);
}
</pre>

This is shown below for a simple normalizing operator <code>SmoothData1D</code>
which takes experimental data as input an returns a new instance
of <code>ExperimentalData</code> which contains smoothed data.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class SmoothData1D extends ALDOperator {

public enum SmoothingMethod {
MEDIAN, MEAN, GAUSSIAN
}

/** 1D Experiment
*/
@Parameter( label= "1D Experiment", required = true,
direction = Parameter.Direction.IN,
description = "1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D experiment;

/** Smoothing method
*/
@Parameter( label = "Smoothing method", required = true,
direction = Parameter.Direction.IN,
callback = "smoothingMethodChanged",
description = "Smoothing method",
paramModificationMode = ParameterModificationMode.MODIFIES_INTERFACE,
dataIOOrder = 2)
SmoothingMethod smoothingMethod = SmoothingMethod.MEDIAN;

/** Window width
*/
@Parameter( label = "Window width", required = true,
direction = Parameter.Direction.IN,
description = "Window width (should be uneven)",
dataIOOrder = 3)
Integer width = 3;

/** Standard deviation of Gaussian
*/
@Parameter( label = "Standdard deviation of Gaussian", required = true,
direction = Parameter.Direction.IN,
description = "Standdard deviation of Gaussian",
dataIOOrder = 3)
Float sigma = 1.0F;

/** Smoothed 1D Experiment
*/
@Parameter( label= "Smothed 1D Experiment",
direction = Parameter.Direction.OUT,
description = "Smothed1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D smoothedExperiment;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public SmoothData1D() throws ALDOperatorException {
// necessary handle dynamic parameters correctly
smoothingMethodChanged();
}

@Override
protected void operate() {
this.fireOperatorExecutionProgressEvent(
new ALDOperatorExecutionProgressEvent(this,
"Starting to smooth 1D Data..."));

Double[] smoothedData;
if ( smoothingMethod == SmoothingMethod.MEDIAN) {
smoothedData = median( experiment.getData(), this.width);
} else {
smoothedData = smoothByConvolution();
}

smoothedExperiment = new ExperimentalData1D( experiment.getDescription() + " (smoothed)",
smoothedData, experiment.isBaselineCorrected(), experiment.getTimeResolution());
}
</pre>

This mechanism applies in a recursive fashion, i.e. a parameterized class may
(recursively) contain a member variable which itself is a parametrized class.
Likewise, an operator acting as a parameter of another operator
may in turn have a parameter of type <code>ALDOperator</code>.

== Invocation via a graphical user interface ==

Invoking and configuring <code>SmoothData1D</code> from the graphical user interface
shows as the only required parameter the experimental data.
This parameterized class can be configured in a separate window
very similar to to configuration of operators.
Likewise the resulting normalized experimental data
may be inspected in their own window.

Obviously this is a toy example, as we would not expect the measurements to
be entered manually, but rather stored and read from file in a specialized format.
This is one of the rare cases where
custom data IO provider need to be implemented, in this
case for <code>ExperimentalData1D</code>.

== Invocation via command line ==

Again, invocation from command line is provided by Alida in an automatic
way with no further implementational overhead.
The syntax for parameterized classes es a comma separated list of name=value pairs
enclosed in curly brackets where name refers to annotated member variables of
the parameterized class.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner SmoothData1D \
experiment='{ baselineCorrected=false , \
description="my experiment" , \
data=[1.0,2.0,2.2,3.3,2.0,1.0,1.0,1.0,1.0,2.0,3.3,2.0] }' \
smoothingMethod=GAUSSIAN \
smoothedExperiment=-
</pre>
yields
<pre>
smoothedExperiment = { baselineCorrected=false ,
data=[1.28,1.85,2.37,2.76,2.05,1.23,1.01,1.01,1.23,2.05,2.73,2.35] ,
timeResolution=NaN ,
description="my experiment" (smoothed) }
</pre>

If a class derived from <code>ExperimentalData1D</code> was to be supplied to the operator,
the curly brackets can be prefixed by a derive class definition starting with a dollar sign
and ending with a colon as shown for the summarizing operators above.

= Graphical workflow editor: Grappa =
Most of the time complex data analysis tasks cannot be solved by only applying a
single operator to the data. Rather, selections of various operators need to be
combined into more sophisticated workflows to extract desired result data.
Alida inherently supports the development of such workflows.
Grappa, the Graphical Programming
Editor for Alida, allows for designing and manipulating workflows via graph edit operations, hence, offers
an intuitive interface and large flexibility for developing workflows.

A workflow in Alida is defined as a graph data structure. Each node of the graph represents an Alida operator, while edges between
different nodes encode the flow of data and control. Each node owns a selection of input and output ports which are associated with the
operator's parameters. Consequently, edges are directed, i.e., an edge always
connects an output port of one operator node with an input port of another. Grappa visualizes such workflow graphs and supports manual editing, manipulation, and also workflow execution
and analysis of results.

Grappa can be started using the following command:

<code>java de.unihalle.informatik.Alida.tools.ALDGrappaRunner</code>

Grappa's main window is
basically divided into two sections. On the left, the node selection menu is
visible, while on the right the workbench area is located.
In addition, the window features a menubar for configuring Grappa, loading and
saving workflows, and accessing the online help. At the bottom of the window a
panel displaying status and progress messages is available.

== Operator node selection menu ==
In the selection menu on the left of Grappa's main window all Alida operators found in the
classpath upon initialization are listed as potential nodes for Grappa workflows.
In analogy to the graphical user interface
they are arranged in a hierarchical ordering
according to their package structure. The different package subtrees can be
folded and unfolded by double-clicking on a folder's name in the selection tree,
or by single-clicking on the circle displayed left to the folder icon. Above the
tree view an operator filter is available which allows to select operators
according to their names. For filtering, enter a substring into the text
field and press the return key.
Operator nodes can be added to a workflow by double-clicking on the operator
name. A new operator node is then instantiated in the top left corner of the
corresponding workflow tab, i.e., the active workflow (see below).
Alternatively, an operator can be selected by clicking once on its name
and afterwards clicking once on the position in the workflow tab where the new
operator node should be positioned.

== Workbench area ==
Workflows can be designed and executed in the workbench area on the right of the main window. It allows for instantiating
multiple workflows in parallel where each workflow is linked to an individual tab of the workbench panel.
A new workflow tab can be added via the item <code>'New'</code> in the context menu of the workbench.
The context menu is displayed upon right-click on an empty location of the workbench area.
Upon selecting the item <code>'New'</code> a new tab is added to the workbench panel.
By default, the name of the new workflow is 'Untitled', but it can easily be
renamed via the corresponding item <code>'Rename'</code> in the context menu. Via this
menu it is also possible to close a workflow tab if no longer required. Note
that its contents are lost if not saved before! The currently selected tab in
the workbench contains the active workflow which can be edited and where
new operator nodes can be added as outlined in the previous subsection.

For each operator selected via the selection menu, a
node in terms of a rectangle is added to the currently active workflow. Above the rectangle
the name of the operator is displayed, while on its left and right side the operator's input and output ports are shown as circles and
squares. Circles are associated with operator parameters of directions <code>IN</code> or <code>OUT</code>, while squares refer to parameters with
direction <code>INOUT</code>. The latter ports are duplicated on both sides of the node.
The colors of the circles indicate their type. Blue circles refer to required parameters, yellow circles are associated with optional
parameters, and red circles are linked to supplemental parameters. To the left and right of the ports,
respectively, the name of the corresponding parameters are written.
Once operator nodes have been added to a workflow, they can easily be dragged
and repositioned as well as resized via intuitive mouse actions.

For each operator node a context menu can be popped up by clicking the node with the right mouse
button. From this menu it is possible to delete the node (item <code>'Remove'</code>), or to configure the
view via the item <code>'Options'</code>. It, e.g., allows to select the set of operator parameter ports
to be shown, i.e. either all parameters or just the subset of non-expert parameters. From the
context menu of a node it is also possible to configure the node (item <code>'Configure'</code>).

On selecting the item for
configuration, a window is displayed which allows to enter parameter values.
The window is automatically generated, i.e., actually the same
mechanisms as for executing operators via the graphical operator runner are applied. Accordingly,
the configuration window is identical to the corresponding operator control
window and shares the same layout, except for the control buttons and the batch
mode tab which are missing.

Operator parameters for a certain node can directly be specified via the
configuration window, they can be loaded from a proper parameter file in XML
format, or they
can be configured by dragging edges between ports of different nodes with the
mouse to propagate output data from one node as input data to another. To add an
edge, move the mouse over an output port of a node until the port is surrounded
by a green square, then press the left mouse button. Subsequently, while keeping
the button pressed, move the mouse to the desired input port of another node.
Once a green rectangle shows up around the target input port, release the
button. Note that on dragging edges Grappa performs type and validity checks.
Only ports being associated with compatible parameter data types can be
linked to each other. Two parameter data types are compatible if they are
either equal, the target data type is a super class of the source data type, or
if Alida has access to a converter allowing to transform the source data type
into the target type. Also
edges are forbidden that would induce cycles into the workflow graph.

Nodes in a workflow can have different states indicated by the color of their border.
Red framed nodes are not ready for execution, i.e., their configuration is not
complete. If a node is readily configured and can directly be executed, its
border has a yellow color, while nodes that are configured, however, require
additional input data from preceeding operator nodes have an orange color.
Prior to executing these orange nodes it is, thus, necessary to execute the
preceeding nodes first.
Note that Grappa takes care of such dependencies, i.e., automatically executes
nodes first from which result data is required for proper workflow or node
execution. The state of a node is updated by Grappa in real-time, i.e., each
change in its configuration directly invokes internal checkings and may result in a change of the node's color.

Grappa offers various modes for executing a
complete workflow or parts of it.
From the context menu of the workbench the item
<code>'Run'</code> is available which executes the complete workflow, i.e., all nodes
currently present on the tab. From the context menu of a single node and its <code>'Run\ldots'</code> item also the whole workflow can be executed (item <code>'Workflow'</code>).
Alternatively, via the item <code>'Nodes from here'</code> it is possible to only execute the nodes of the workflow subgraph for which the
current node is the root (of course considering required dependencies). Finally, the item <code>'Node'</code> allows for running the workflow
until the node in question. As mentioned before, Grappa automatically takes care
of resolving dependencies, i.e., upon executing a node all nodes having a yellow
or orange border and being predecessors of the node in question are also executed. Note that the execution of a workflow will fail if one of the nodes is still colored red, or if a node does not produce proper output data required by others.

After successful execution of the workflow or a subset of nodes, the colors of
the corresponding nodes change to green indicating that result data are
available. For all terminal nodes having no successor the result frames are
automatically opened.
For all other nodes the result data can graphically be examined via the nodes'
context menus from which the result windows can manually be opened.
Once a node has been executed and is colored in green, it is not possible to
re-execute the node until its configuration, or at least the configuration of
one of its preceeding nodes, was changed.

== Menubar and shortcuts ==
The Grappa main window features a menubar offering quick
access to the basic functions of Grappa and some additional convenience functionality simplifying
the work with the editor.

Via the menu item <code>'File'</code> workflows can be saved to and read from
disk. By saving a workflow currently two files are written to disk, one containing the information
about the nodes and their configuration, and one storing graphical information
regarding the current workflow layout. Both are required to load a workflow
again. The first one has the extension <code>'.awf'</code>, the latter one the
extension <code>'.awf.gui'</code>.

Via the menu item <code>'Workflow'</code> new workflows can be added and existing ones be renamed,
closed, executed or interrupted.
Alida supports two categories of
operators, i.e. operators mainly dedicated to direct application by non-expert users
and operators for special tasks and expert usage. Via the item <code>'Options'</code> the menubar allows
to switch the view in the selection menu between both categories. Also progress messages triggered by the
operator node during execution and optionally shown in the status panel can be enabled or
disabled via this menu. Finally, the menu item <code>'Help'</code> grants access to Alida's online help system
where information about its functionality and descriptions of the operators can be found.

Java quick

2016-02-23T22:20:49Z

Posch:

Here we introduce Alida's operator concept with some code snippets of <code>ALDOperator</code> and sub-classed demo operators.
we focus on Alida's capabilities to automatically generate user interfaces.

= First operator =

As a first example of an Alida operator we implement the row or column wise
sum for a 2D array of Doubles.
The class <code>MatrixSum</code> extending <code>ALDOperator</code> features three member variables
holding the input 2D array, an enum to indicate the mode of summation (<code>ROW</code> or <code>COLUMN</code>), and
an 1D array of the sums to be computed and returned by the operator.
Alida requires only to annotate these members with the @Parameter annotation
which declares

* the direction (<code>IN</code>, <code>OUT</code>, <code>INOUT</code>),
* whether the parameter is required,
* an optional textual description,
* and a label used, e.g. in the graphical user interface automatically generated
to execute the operator.

It is important to add a public standard constructor (without arguments)
to be able to use Java's reflection mechanism.
Finally, the abstract method <code>operate()</code> of <code>ALDOperator</code> has to be overridden
implementing the functionality of the operator.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class MatrixSum extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,

/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows?")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* 1D Array of sums.
*/
@Parameter( label= "sums",
direction = Parameter.Direction.OUT, description = "Row or column wise sums.")
private Double[] sums = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public MatrixSum() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public MatrixSum(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() {
if ( matrix == null )
sums = null;

// calculate sums
if ( summarizeMode == SummarizeMode.ROW ) {
sums = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
sums[row] = 0.0;
for ( int col = 0 ; col < matrix[0].length ; col++ )
sums[row] += matrix[row][col];
}
} else {
sums = new Double[matrix[0].length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
sums[col] = 0.0;
for ( int row = 0 ; row < matrix.length ; row++ )
sums[col] += matrix[row][col];
}
}
}
</pre>

These are the basic requirements for the operator to be used on the programming level.
An example of this use is included in the example in the next section.

If we further annotate the class with
<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL)
</pre>
this is all needed to also facilitate
execution of this operator via a graphical and a command line user interface
automatically generated by Alida.
(Setting <code>level=ALDAOperator.Level.APPLICATION</code> declares this operator an application
which is used in the GUI to control display of available operators.)

== Invocation via a graphical user interface ==

Alida comes with one single application to execute Alida operators
with a automatically generated graphical user interface which may be
started from command line by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunnerGUI
</pre>

This will pop up a window to choose an operator to execute.
Arranged according to the package structure all operators allows to be executed
via the graphical user interface according to their <code>genericExecutionMode</code>
are displayed.
Initially packages are unfolded up to a predefined depth.
Unfold the demo package, select <code>MatrixSum</code>, and choose the "Configure Operator" button.
This will pop up another window which allows you to configure the input parameters
of the operator.
Important note: After finishing to input the data matrix entering the final matrix elements
you have to select a previous matrix element due to subtle AWT details.
For the enumeration to select the mode Alida has automatically generated
a combo box to allow convenient selections.
If you are finished with the parameter configuration you want to invoke the operator
using the run button.
On completion of <code>MatrixSum</code> the interface will pop up the result window which allows you
to inspect the outcome of the operation.

== Invocation via command line ==

The command line user interface of Alida allows to invoke all Alida operator
properly annotated to allows generic execution.

You may invoke the matrix summation operator by
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]' sums=-
</pre>
which returns as result on standard output
<pre>
sums = [6.0,15.0]
</pre>

Parameter values are specified as name=value pairs.
Alida's syntax for 2D array should be self-explanatory from this example.
As the mode of summation is not supplied as a parameter its default is used

Note, the command
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
</pre>
will return no output as the command line user interface returns only output parameters requested.

The enumeration defined in <code>MatrixSum</code> is supported by the
user interface without further action required as shown in the next example.
This also demonstrates redirection of output
to a file, sums.out in this case.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix='[[1,2,3],[4,5,6]]'
summarizeMode=COLUMN sums=@sums.out+
</pre>
Input can be read from file as well:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner MatrixSum matrix=@data sums=-+
</pre>

where the file data contains the string defining the matrix, e.g., <code>[[1,2,3],[4,5,6]]</code>

= Adding more features to an operator =

We now generalize this example to realize not only summation over rows or
columns, but arbitrary summarizing operations.
This shows Alida's feature to allow an operator as parameter of another operator.

== Implementation ==

First we generalize <code>ALDArraySum</code> to the operator <code>ApplyToMatrix</code>
which also takes a 2D array and an enum indicating the mode of marginalization (<code>ROW</code> or <code>COLUMN</code>).
It takes an additional input parameter which specifies the operation to be applied on each
row or column.

This parameter is itself an Alida operator and of type <code>ALDSummarizeArrayOp</code>
which is implemented as an abstract class.
This abstract operator defines a summarizing operator
which takes a 1D array as input and returns a summarizing scalar.
As this is an abstract class there is no need to override the <code>operate()</code>
method, however some getter and setter methods are provided.

<pre>
@Parameter( label= "Input 1D array", required = true,
direction = Parameter.Direction.IN, description = "Input array (1D).")
protected Double[] data;

/**
* Summarizing scalar
*/
@Parameter( label= "Summarizing scalar",
direction = Parameter.Direction.OUT, description = "Summarizing scalar of the 1D arra")
protected Double summary = null;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDSummarizeArrayOp() throws ALDOperatorException {
}

/**
* Returns the 1D array
* @return data array
*/
public Double[] getData() {
return this.data;
}

/**
* Sets the 1D array
* @param data
*/
public void setData( Double[] data) {
this.data = data;
}

</pre>

Now we add concrete examples of such a summarizing operation, in this case
summation (<code>ALDArraySum</code>), to return the mean (<code>ALDArrayMean</code>), and the minimum (<code>ALDArrayMin</code>).
Each implements the <code>operate()</code> method and has to supply a standard constructor.
In this example we add another constructor for convenience.
This operators are declared as operators on the standard in contrast to
application level, as they are not expected to be invoked as an application.
However, setting the level to standard in the menu of the graphical user interface
stills allows their execution.
When extending the abstract super class it is necessary to annotate the
class with <code>@ALDDerivedClass</code> in order to allow Alida's dataIO mechanism to find the derived class
in the automatically generated user interface.
This holds for other parameter types as well.
More specifically, if an instance of a class is to be supplied in an automatically
generated user interface as a value for a parameter of one of its super classes,
Alida requires the annotation <code>@ALDDerivedClass</code>.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.STANDARD)
public class ALDArraySum extends ALDSummarizeArrayOp {

@Override
protected void operate() {
summary = 0.0;
for ( int i = 0 ; i < data.length ; i++ )
summary += data[i];
}

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ALDArraySum() throws ALDOperatorException {
}

</pre>

Now we are ready to implement
the <code>ApplyToMatrix</code> operator, which also demonstrates supplemental parameters.
This supplementals, e.g., control debugging output or returning of intermediate results.
For demo purposes we declare a supplemental input parameter <code>returnElapsedTime</code>.
If it is set to true the operator will return the elapsed time in a second
supplemental parameter with direction output.

Again, the operation is implemented in the <code>operate()</code> method and the remainder of the
class supplies getter and setter methods for convenience.
The <code>operate()</code> method give also an example of the invocation of an operator on the
programming level.
In this case, an instance of the operator is already passed as a parameter.
Its parameters are set, in this case each 1D array to be summarized in turn.
Upon return from the method <code>runOp()</code> the results may be retrieved from the operator object,
in this example with the <code>getSummary()</code> method.
Besides getter and setter methods as implemented in each operator
Alida provides also a generic get and set methods applicable to
all parameters of an operator.
Note, that the operator is not invoked by its <code>operate()</code> method, but via
the <code>runOp()</code> method implemented the base class <code>ALDOperator</code>.
This methods validates the parameters before invocation of <code>operate()</code>.
Furthermore, it take all necessary measures for Alida's processing
history which automatically logs
all manipulative actions on the data and corresponding parameter settings.

<pre>
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class ApplyToMatrix extends ALDOperator {

/** Choose row or colum wise sum
*/
public static enum SummarizeMode {
/** row wise */
ROW,
/** column wise */
COLUMN
}

/**
* Input matrix
*/
@Parameter( label= "Input matrix", required = true,
direction = Parameter.Direction.IN, description = "Input matrix.")
private Double[][] matrix;

/**
* Mode of summarizing
*/
@Parameter( label= "Summarize mode", required = true,
direction = Parameter.Direction.IN, description = "Sum over columns or rows.")
private SummarizeMode summarizeMode = SummarizeMode.ROW;

/**
* Summarizing opererator
*/
@Parameter( label= "Summarizing operator", required = true,
direction = Parameter.Direction.IN, description = "Specifies the summarizing operation to apply")
private ALDSummarizeArrayOp summarizeOp;

/**
* 1D Array of summaries.
*/
@Parameter( label= "summaries",
direction = Parameter.Direction.OUT, description = "Row or column wise summaries")
private Double[] summaries = null;

/**
* Supplemental to request elapsed time to be returned
*/
@Parameter( label= "Return elapsed time",
direction = Parameter.Direction.IN, description = "Request elapsed time consumed to be returned",
supplemental=true)
private boolean returnElapsedTime = false;

/**
* Elpased time
*/
@Parameter( label= "Elapsed time",
direction = Parameter.Direction.OUT, description = "Elapsed time of operation in milliseconds",
supplemental=true)
private long elapsedTime;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public ApplyToMatrix() throws ALDOperatorException {
}

/**
* Constructor.
*
* @param matrix Input matrix.
* @throws ALDOperatorException
*/
public ApplyToMatrix(Double[] [] matrix) throws ALDOperatorException {
this.matrix = matrix;
}

@Override
protected void operate() throws ALDOperatorException,ALDProcessingDAGException {
if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis();

if ( matrix == null )
summaries = null;

// calculate summaries
if ( summarizeMode == SummarizeMode.ROW ) {
summaries = new Double[matrix.length];
for ( int row = 0 ; row < matrix.length ; row++ ) {
summarizeOp.setData(matrix[row]);
summarizeOp.runOp();
summaries[row] = summarizeOp.getSummary();
}
} else {
summaries = new Double[matrix[0].length];
Double[] tmp = new Double[matrix.length];
for ( int col = 0 ; col < matrix[0].length ; col++ ) {
for ( int row = 0 ; row < matrix.length ; row++ )
tmp[row] = matrix[row][col];

summarizeOp.setData(tmp);
summarizeOp.runOp();
summaries[col] = summarizeOp.getSummary();
}
}

if ( returnElapsedTime )
elapsedTime = System.currentTimeMillis() - elapsedTime;
}

// ==============================================================
// Getter and setter methods
/** Get value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @return value of returnElapsedTime
*/
public boolean getReturnElapsedTime(){
return returnElapsedTime;
}

/** Set value of returnElapsedTime.
* Explanation: Request elapsed time consumed to be returned.
* @param value New value of returnElapsedTime
*/
public void setReturnElapsedTime( boolean value){
this.returnElapsedTime = value;
}
</pre>

== Invocation via a graphical user interface ==

If the graphical interface is still running just select our new operator
and begin to configure it.
For the parameter summarizing operator you have a choice of all operators extending
the abstract operator <code>ALDSummarizeArrayOp</code>.
All which is necessary on the implementation side is proper annotation of the extending
classes with <code>@ALDDerivedClass</code>.
As the selected operator may have its own parameters you may want to configure it.
In our example this is not necessary as the input array is, of course, supplied
by the <code>ApplyToMatrix</code> operator.
Do not forget to input your data before hitting the run button.
After return, again a result window give you the results of the operation.
Note, if you did not tick Return elapsed time" this window will show zero
for the time elapsed as the operator has not been request to stop the time.

== Invocation via command line ==

When invoking the <code>ApplyToMatrix</code> operator from command line
we have to handle derived classes as value for parameters.
In the graphical user interface Alida features a combo box where
we may choose from.
In the command line interface Alida allows to prefix the value of a parameter
with a derived class to be passed to the operator.
This is necessary as Alida as, of course, no way to itself
decide if and which derived class is to be used.
Alida's syntax is to enclose the class name in a dollar sign and a colon.
As evident in the following example, abbreviations are of the fully
qualified class name are accepted as long as they are unambiguous.
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW \
summarizeOp='<math>ALDArrayMean:{}' \
summaries=-
</pre>
results in
<pre>
summaries = [2.0,5.0]
</pre>

<code>ALDOpRunner</code> may be persuaded to show all operators derived from <code>ALDSummarizeArrayOp</code>
and known within the user interface if we enter an invalid class name:
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner \
Apply matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=ROW summarizeOp='</math>dd:{}' \
summaries=-
</pre>
yields
<pre>
ALDStandardizedDataIOCmdline::readData found 0 derived classes matching <dd>
derived classes available:
de.unihalle.informatik.Alida.demo.ALDArrayMean
de.unihalle.informatik.Alida.demo.ALDArrayMin
de.unihalle.informatik.Alida.demo.ALDArraySum
ERROR: reading parameter <summarizeOp> returns null
</pre>

Supplemental parameters are handled like other parameters
<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner Apply \
matrix='[[1,2,3],[4,5,6]]' \
summarizeMode=COLUMN \
summarizeOp='<math>ALDArrayMin:{}' \
summaries=- \
returnElapsedTime=true \
elapsedTime=-
</pre>
gives
<pre>
summaries = [1.0,2.0,3.0]
elapsedTime = 4
</pre>

= Adding more data types as parameters =

Alida provides automatic IO of primitive data types, enumerations, arrays, collections,
and operators.
In addition so called parameterized classes are supported.
Any Java class may be declared to be a parameterized class in Alida
by annotating the class <code>@ALDParametrizedClass</code> as shown in the
class <code>ExperimentalData1D</code>.
All member variables to be known to and handled by Alida's user interface
simply need to be annotated with <code>@ALDClassParameter</code>.

Here we implement a toy version of experimental data <code>ExperimentalData1D</code>.
A complete experiment contains
data of a time series of measurements of variable length.
Additional information is a descriptive string, the time resolution in milliseconds,
and whether baseline correction has been applied.

The class is annotated by <code>@ALDParametrizedClass</code>, and
and all members to be handle in Alida'a user interfaces are
to be annotated with <code>@ALDParametrizedClass</code>.
The label field has the same semantics as for parameters of operators.
These annotations are the only implementational overhead
to allow Alida to automatically generate user interfaces
where the parameterized class acts as a parameter.

<pre>
@ALDParametrizedClass
public class ExperimentalData1D extends ALDData {

/** Description */
@ALDClassParameter(label="description", dataIOOrder = 1)
private String description = null;

/** The data */
@ALDClassParameter(label="data", dataIOOrder = 2)
private Double[] data = null;

/** Are the data baseline corrected? */
@ALDClassParameter(label="Baseline corrected",
dataIOOrder = 3)
private boolean baselineCorrected = false;

@ALDClassParameter(label="Time resolution in milliseconds", dataIOOrder = 4)
private Float timeResolution = Float.NaN;

/**
* Standard constructor is required
*/
public ExperimentalData1D() {
}

/** Constructor for an experiment.
* Baseline correction is assumed to be false and nothung known about
* the time resolution.
*
* @param description a textual description of the experiment
* @param data measurements
*/
public ExperimentalData1D( String description, Double[] data) {
this( description, data, false, Float.NaN);
}
</pre>

This is shown below for a simple normalizing operator <code>SmoothData1D</code>
which takes experimental data as input an returns a new instance
of <code>ExperimentalData</code> which contains smoothed data.

<pre>
@ALDDerivedClass
@ALDAOperator(genericExecutionMode=ALDAOperator.ExecutionMode.ALL,
level=ALDAOperator.Level.APPLICATION)
public class SmoothData1D extends ALDOperator {

public enum SmoothingMethod {
MEDIAN, MEAN, GAUSSIAN
}

/** 1D Experiment
*/
@Parameter( label= "1D Experiment", required = true,
direction = Parameter.Direction.IN,
description = "1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D experiment;

/** Smoothing method
*/
@Parameter( label = "Smoothing method", required = true,
direction = Parameter.Direction.IN,
callback = "smoothingMethodChanged",
description = "Smoothing method",
paramModificationMode = ParameterModificationMode.MODIFIES_INTERFACE,
dataIOOrder = 2)
SmoothingMethod smoothingMethod = SmoothingMethod.MEDIAN;

/** Window width
*/
@Parameter( label = "Window width", required = true,
direction = Parameter.Direction.IN,
description = "Window width (should be uneven)",
dataIOOrder = 3)
Integer width = 3;

/** Standard deviation of Gaussian
*/
@Parameter( label = "Standdard deviation of Gaussian", required = true,
direction = Parameter.Direction.IN,
description = "Standdard deviation of Gaussian",
dataIOOrder = 3)
Float sigma = 1.0F;

/** Smoothed 1D Experiment
*/
@Parameter( label= "Smothed 1D Experiment",
direction = Parameter.Direction.OUT,
description = "Smothed1D Experiment",
dataIOOrder = 1)
protected ExperimentalData1D smoothedExperiment;

/**
* Default constructor.
* @throws ALDOperatorException
*/
public SmoothData1D() throws ALDOperatorException {
// necessary handle dynamic parameters correctly
smoothingMethodChanged();
}

@Override
protected void operate() {
this.fireOperatorExecutionProgressEvent(
new ALDOperatorExecutionProgressEvent(this,
"Starting to smooth 1D Data..."));

Double[] smoothedData;
if ( smoothingMethod == SmoothingMethod.MEDIAN) {
smoothedData = median( experiment.getData(), this.width);
} else {
smoothedData = smoothByConvolution();
}

smoothedExperiment = new ExperimentalData1D( experiment.getDescription() + " (smoothed)",
smoothedData, experiment.isBaselineCorrected(), experiment.getTimeResolution());
}
</pre>

This mechanism applies in a recursive fashion, i.e. a parameterized class may
(recursively) contain a member variable which itself is a parametrized class.
Likewise, an operator acting as a parameter of another operator
may in turn have a parameter of type <code>ALDOperator</code>.

== Invocation via a graphical user interface ==

Invoking and configuring <code>SmoothData1D</code> from the graphical user interface
shows as the only required parameter the experimental data.
This parameterized class can be configured in a separate window
very similar to to configuration of operators.
Likewise the resulting normalized experimental data
may be inspected in their own window.

Obviously this is a toy example, as we would not expect the measurements to
be entered manually, but rather stored and read from file in a specialized format.
This is one of the rare cases where
custom data IO provider need to be implemented, in this
case for <code>ExperimentalData1D</code>.

== Invocation via command line ==

Again, invocation from command line is provided by Alida in an automatic
way with no further implementational overhead.
The syntax for parameterized classes es a comma separated list of name=value pairs
enclosed in curly brackets where name refers to annotated member variables of
the parameterized class.

<pre>
java de.unihalle.informatik.Alida.tools.ALDOpRunner SmoothData1D \
experiment='{ baselineCorrected=false , \
description="my experiment" , \
data=[1.0,2.0,2.2,3.3,2.0,1.0,1.0,1.0,1.0,2.0,3.3,2.0] }' \
smoothingMethod=GAUSSIAN \
smoothedExperiment=-
</pre>
yields
<pre>
smoothedExperiment = { baselineCorrected=false ,
data=[1.28,1.85,2.37,2.76,2.05,1.23,1.01,1.01,1.23,2.05,2.73,2.35] ,
timeResolution=NaN ,
description="my experiment" (smoothed) }
</pre>

If a class derived from <code>ExperimentalData1D</code> was to be supplied to the operator,
the curly brackets can be prefixed by a derive class definition starting with a dollar sign
and ending with a colon as shown for the summarizing operators above.

= Graphical workflow editor: Grappa =
Most of the time complex data analysis tasks cannot be solved by only applying a
single operator to the data. Rather, selections of various operators need to be
combined into more sophisticated {\em workflows} to extract desired result data.
Alida inherently supports the development of such workflows.
Grappa, the Graphical Programming
Editor for Alida allows for designing and manipulating workflows via graph edit operations, hence, offers
an intuitive interface and large flexibility for developing workflows.

A workflow in Alida is defined as a graph data structure. Each node of the graph represents an Alida operator, while edges between
different nodes encode the flow of data and control. Each node owns a selection of input and output ports which are associated with the
operator's parameters. Consequently, edges are directed, i.e., an edge always
connects an output port of one operator node with an input port of another. Grappa visualizes such workflow graphs and supports manual editing, manipulation, and also workflow execution
and analysis of results.

Java quick

2016-02-23T12:12:09Z

Posch: /* Adding more data types as parameters */

Java quick

2016-02-23T12:10:06Z

Posch: /* Adding more data types as parameters */

Installation

2012-12-20T14:25:14Z

Posch: /* Java */

On this page you find install instructions for Alida in C++ and in Java.

== Java ==

Extract the download Alida_bin.zip and change the current working directory to the top level directory
of the extracted files.

You can start grappa using
<pre>
tcsh share/scripts/runAlida.tcsh
</pre>

or

<pre>
bash share/scripts/runAlida.bash
</pre>

If you grant execute permissions to these scripts you can start them directly, e.g.
<pre>
share/scripts/runAlida.tcsh
</pre>

If you in addition modify the variable ALIDA_HOME in these scripts you can start them from any
any directory.

To start the graphical user interface to configure and start operators you may use
<pre>
share/scripts/runAlida.tcsh guioprunner
</pre>

The command line interface is invoked, e.g., via
<pre>
share/scripts/runAlida.tcsh oprunner -h
</pre>
which displays the help message.

== C++ ==
The C++ implementation of Alida currently works only on Linux machines.
For installing Alida perform the following steps:

# Download the tar or zip archive from the [[Downloads]] section of this website.
# Extract the archive to a directory of your choice which we denote by ''ALIDA_HOME'' in the following.
# Download [http://loki-lib.sourceforge.net/index.php?n=Main.HomePage Loki], i.e. go to the [http://sourceforge.net/projects/loki-lib/files/Loki/ SourceForge project page] and download release 0.1.7 of the Loki library.
# Extract the Loki archive to the folder ''ALIDA_HOME/external''. Alternatively you can extract it somewhere else and set a link to that directory in ''ALIDA_HOME/external''.
# Define an environment variable ''''ALIDA_CPP'''' with the path of your Alida installation, i.e. the path of ''ALIDA_HOME''.
# Enter the directory ''ALIDA_HOME/src'' and type 'make'.
# The demo operator and the command line operator runner will be built. To run the demo operator, enter the directory ''ALIDA_HOME/src/runner/o.<your-machine>'' and execute it with

<pre>./ALDOpRunner DemoOperator intval=4711 doubleval=0.999999 floatval=0.123 stringval="Alida-Cpp"</pre>

==== Optional: include OpenCV demo operator and provider ====

To activate the OpenCV demo you need to have the OpenCV available on your system. Install instructions can be found [http://opencv.willowgarage.com/wiki/InstallGuide here]. 
To build the OpenCV related classes of Alida edit the configuration file ''ALIDA_HOME/src/config.mk''. 
On top of the file you find a configuration section which defines three variables:

<pre>
#############################################################################
# user-specific configuration
#############################################################################

OPENCV_SUPPORT = no
OPENCV_INCLUDE = /usr/include
OPENCV_LIB = /usr/lib
</pre>

Change the value of '''OPENCV_SUPPORT''' to 'yes' and set include and library path variables according to your OpenCV installation. 
Afterwards rebuild Alida by running 'make clean all'. The OpenCV demo operator can be run with
<pre>
./ALDOpRunner DemoOperatorOpenCV inputImg=<example_image> sigma=151
</pre>

Main Page

2012-12-20T13:59:45Z

Posch: /* News */

== [[News]] ==

* 12/20/2010 Release of version 2.0. This version includes the graphical editor '''Grappa''' to compose workflows of operators.

* 11/10/2012: Updated version of Chipory available for download.

* 26/07/2012: Alida will be presented at the '''''ImageJ User & Developer Conference 2012''''' to be held at the end of October in Mondorf-les-Bains, Luxembourg. There will be a poster presentation combined with a demo entitled [http://imagejconf.tudor.lu/program/poster/birgit_moeller996310491 '''Automatic Generation of Processing Histories using Alida''']. It will provide an introduction to the processing history mechanism implemented in Alida, and its usage. Also a talk will be given about our new graphical editor ''Grappa'' entitled '''Graphical Programming in Alida and ImageJ 2.0 with Grappa'''.

* 12/07/2012: New release of chipory ready for download

* 21/03/2012: Alida will be presented at the '''''IEEE International Symposium on Biomedical Imaging (ISBI)''''' to be held at the end of April in Barcelona. There will be a poster presentation combined with a demo at the '''''Bioimage Analysis Workshop on Open Source Software''''' held in conjunction with ISBI. The title will be '''ALIDA - Automatic generation of user interfaces for data analysis algorithms'''.

* 12/03/2012: The Alida concept now features a prototypical implementation in C++! It supports generic operator execution from command line. Release 0.1 is available now from the download page.

* 02/03/2012: Alida release 1.2 has just been published! You can get the new version in the download section! Main new feature: generic user interface generation for operators to use them from commandline and via a Swing GUI!

== Alida - Advanced Library for Integrated Development of Data Analysis Applications ==

...formerly known as Alida - Automatic Logging of Process Information in Data Analysis

Alida defines a concept for designing libraries and toolkits in data analysis. It supports and simplifies integrated algorithm development by inherently joining algorithm implementation, automatic analysis process documentation and fully generic generation of user interfaces. In Alida each data analysis or manipulation action is realized in terms of an operator that acts on given data to produce desired output data. As all operators implement a common interface definition, their input and output parameters are accessible in a standardized manner, and they can also be invoced in a predefined way.

Calls to operators not only produce data analysis results, but are at the same time registered within the framework together with all input and output objects as well as parameters settings of the various operators. These data acquired during an analysis process and the order of operator calls form a directed graph datastructure containing all relevant information for later reconstruction or verification of the analysis procedure. Alida allows to make the directed graph datastructure explicit in terms of XML representations which can be visually explored with appropriate graphical frontends like Chipory, or might be stored in data bases for archival purposes.

Alida's operator concept is well-suited to ease algorithm development and their application to real-world problems by non-expert users. Due to the operator interface definition and the unified handling of operators it is for example possible to automatically generate user interfaces for operators, i.e. graphical frontends or commanline interfaces.

== Licensing information ==
Alida is free software: you can redistribute it and/or modify under the terms of the [http://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3] or (at your option) any later version as published by the [http://www.fsf.org/ Free Software Foundation].

== Current releases ==

==== Java ====
You can download Alida's Java implementation in version 1.2 [[Downloads | here]]. 
You can find the API documentation for this release [http://www2.informatik.uni-halle.de/agprbio/alida/api/java/index.html here]. 

==== C++ ====
You can download Alida's prototypical C++ implementation in version 0.1 [[Downloads | here]]. 
You can find the API documentation for this release [http://www2.informatik.uni-halle.de/agprbio/alida/api/cpp/index.html here]. 

== Manual ==
Alida offers you a user and programmer manual you can download [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/manual/AlidaManual.pdf here]. Note that the manual is currently focussed on the mature Java implementation, but it will be updated in near future to cover both implementations.

== Bug reports & Feature requests ==
Bug reports and feature requests can be submitted via the [http://www2.informatik.uni-halle.de/agprbio/mitobo-bts/bug_report_page.php bugtracking system] or by mail to [mailto:alida@informatik.uni-halle.de alida@informatik.uni-halle.de]. 
Before reporting a new bug, please check if that bug has already been submitted in the [http://www2.informatik.uni-halle.de/agprbio/mitobo-bts/view_all_bug_page.php report list].

Downloads

2012-12-20T13:26:48Z

Posch: /* Java implementation */

= Java implementation =

== Requirements ==
Alida's implementation in Java requires Java 1.6 or later.
Alida requires some external jars which are included in the Alida binary zipfile since V2.0.

For earlier versions the following external jars are needed to use Alida:

* [http://xmlbeans.apache.org/ XMLBeans], Version 2.5.0
* [http://xstream.codehaus.org/ XStream], Version 1.3.1
* [http://javahelp.java.net/ JavaHelp], Version 2.0_05

In addition, Alida requires some more libraries which are in-house developments:

* Alida also requires some graphml extensions to be found in '''''aldgraphml.jar'''''.
* The graphical operator runner features an online help system based on [http://javahelp.java.net/ JavaHelp System] which is included in '''Alida-Help.jar'''.

If you download the Alida binary zipfile you will find these two libraries in the subdirectory ''intjars'' of the zipfile. Make sure that all of them are in the classpath when executing the operator runners. 

== Current release (v2.0)==
* Alida Java Binaries [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin.zip zip] (includes Alida binaries, license information and the file ''aldgraphml.jar'' with Alida's extensions of graphml)
* Alida Java Sources [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src.zip zip] (includes only the sources, license files and some READMEs on how to use and compile Alida)
* Alida Java API [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api.zip zip] (includes Javadocs of Alida's API)
 

== Archive of Alida's Java releases ==

{| border = "1" cellpadding = "5pt" cellspacing = "0" style = "border-color: #DDD; text-align: center; width: 80%"
! Version
! Binaries
! Sources
! API
! Date
|-
| 2.0
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-2.0.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-2.0.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-2.0.zip zip]
| March 2nd, 2012
|-
|-
| 1.2
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-1.2.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-1.2.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-1.2.zip zip]
| March 2nd, 2012
|-
| 1.1
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-1.1.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-1.1.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-1.1.zip zip]
| Sep 14th, 2011
|-
| 1.0
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-1.0.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-1.0.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-1.0.zip zip]
| May 9th, 2011
|}
 

= C++ implementation =

Alida's implementation in C++ requires Linux as operating system.

The following external libraries are needed:

* [http://loki-lib.sourceforge.net/index.php?n=Main.HomePage Loki], Version 0.17

Optionally a prototypical implementation of an OpenCV wrapper is included for which the OpenCV library is required:
* [http://opencv.willowgarage.com/wiki/ OpenCV], Version 2.1 or higher (refer to the [[Installation]] section for details on compiling the OpenCV wrapper)

== Current release (v0.1)==
* Alida C++ Sources [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_src.zip zip] (includes the sources, license files and some READMEs on how to use and compile Alida)
* Alida C++ API [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_api.zip zip] (includes Doxygen documentation of Alida's C++ API)
 

== Archive of Alida's C++ releases ==

{| border = "1" cellpadding = "5pt" cellspacing = "0" style = "border-color: #DDD; text-align: center; width: 80%"
! Version
! Sources
! API
! Date
|-
| 0.1
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_src-0.1.zip zip] [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_src-0.1.tgz tgz]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_api-0.1.zip zip] [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_api-0.1.tgz tgz]
| March 12th, 2012
|}
 

= Manual =

Detailed information about Alida, its API and usage, can be found in the user and programmer manual.

* Alida-Manual, Version 1.3 [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/manual/AlidaManual.pdf pdf]
 

= Additional resources =

* '''Chipory''' - a graph visualization tool for displaying MiToBo history graphs Chipory is an extended version of the [http://www.cs.bilkent.edu.tr/~ivis/chisio.html Chisio software] developed at the Bilkent University in Turkey.
 
The zip file below contains all necessary files. Download this file and unpack it into a folder of your choice.

* To use Chipory on a Linux system with 32-bit architecture just type './Chipory.sh'. 
* In case that your machine has a 64-bit architecture running Linux, call './Chipory_64.sh'. 
* For Windows with 32-bit architecture a self extracting installer including an executable of Chipory is available.
 
Download the current release as of 7-12-2012:
* Chipory binary [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/Chipory.zip zip]
* self extracting installer for Windows [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/chipory-setup.exe chipory-setup.exe]
Source code for Chipory is available upon request.
 

= Logo =

* Alida logo as [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/Alida_logo.pdf PDF]

Downloads

2012-12-20T13:25:49Z

Posch: /* Requirements */

= Java implementation =

== Requirements ==
Alida's implementation in Java requires Java 1.6 or later.
Alida requires some external jars which are included in the Alida binary zipfile since V2.0.

For earlier versions the following external jars are needed to use Alida:

* [http://xmlbeans.apache.org/ XMLBeans], Version 2.5.0
* [http://xstream.codehaus.org/ XStream], Version 1.3.1
* [http://javahelp.java.net/ JavaHelp], Version 2.0_05

In addition, Alida requires some more libraries which are in-house developments:

* Alida also requires some graphml extensions to be found in '''''aldgraphml.jar'''''.
* The graphical operator runner features an online help system based on [http://javahelp.java.net/ JavaHelp System] which is included in '''Alida-Help.jar'''.

If you download the Alida binary zipfile you will find these two libraries in the subdirectory ''intjars'' of the zipfile. Make sure that all of them are in the classpath when executing the operator runners. 

== Current release (v1.2)==
* Alida Java Binaries [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin.zip zip] (includes Alida binaries, license information and the file ''aldgraphml.jar'' with Alida's extensions of graphml)
* Alida Java Sources [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src.zip zip] (includes only the sources, license files and some READMEs on how to use and compile Alida)
* Alida Java API [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api.zip zip] (includes Javadocs of Alida's API)
 

== Archive of Alida's Java releases ==

{| border = "1" cellpadding = "5pt" cellspacing = "0" style = "border-color: #DDD; text-align: center; width: 80%"
! Version
! Binaries
! Sources
! API
! Date
|-
| 1.2
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-1.2.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-1.2.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-1.2.zip zip]
| March 2nd, 2012
|-
| 1.1
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-1.1.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-1.1.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-1.1.zip zip]
| Sep 14th, 2011
|-
| 1.0
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-1.0.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-1.0.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-1.0.zip zip]
| May 9th, 2011
|}
 

= C++ implementation =

Alida's implementation in C++ requires Linux as operating system.

The following external libraries are needed:

* [http://loki-lib.sourceforge.net/index.php?n=Main.HomePage Loki], Version 0.17

Optionally a prototypical implementation of an OpenCV wrapper is included for which the OpenCV library is required:
* [http://opencv.willowgarage.com/wiki/ OpenCV], Version 2.1 or higher (refer to the [[Installation]] section for details on compiling the OpenCV wrapper)

== Current release (v0.1)==
* Alida C++ Sources [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_src.zip zip] (includes the sources, license files and some READMEs on how to use and compile Alida)
* Alida C++ API [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_api.zip zip] (includes Doxygen documentation of Alida's C++ API)
 

== Archive of Alida's C++ releases ==

{| border = "1" cellpadding = "5pt" cellspacing = "0" style = "border-color: #DDD; text-align: center; width: 80%"
! Version
! Sources
! API
! Date
|-
| 0.1
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_src-0.1.zip zip] [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_src-0.1.tgz tgz]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_api-0.1.zip zip] [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_api-0.1.tgz tgz]
| March 12th, 2012
|}
 

= Manual =

Detailed information about Alida, its API and usage, can be found in the user and programmer manual.

* Alida-Manual, Version 1.3 [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/manual/AlidaManual.pdf pdf]
 

= Additional resources =

* '''Chipory''' - a graph visualization tool for displaying MiToBo history graphs Chipory is an extended version of the [http://www.cs.bilkent.edu.tr/~ivis/chisio.html Chisio software] developed at the Bilkent University in Turkey.
 
The zip file below contains all necessary files. Download this file and unpack it into a folder of your choice.

* To use Chipory on a Linux system with 32-bit architecture just type './Chipory.sh'. 
* In case that your machine has a 64-bit architecture running Linux, call './Chipory_64.sh'. 
* For Windows with 32-bit architecture a self extracting installer including an executable of Chipory is available.
 
Download the current release as of 7-12-2012:
* Chipory binary [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/Chipory.zip zip]
* self extracting installer for Windows [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/chipory-setup.exe chipory-setup.exe]
Source code for Chipory is available upon request.
 

= Logo =

* Alida logo as [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/Alida_logo.pdf PDF]

Main Page

2012-10-11T09:16:57Z

Posch:

== [[News]] ==

* 11/10/2012: Updated version of Chipory available for download.

* 26/07/2012: Alida will be presented at the '''''ImageJ User & Developer Conference 2012''''' to be held at the end of October in Mondorf-les-Bains, Luxembourg. There will be a poster presentation combined with a demo entitled [http://imagejconf.tudor.lu/program/poster/birgit_moeller996310491 '''Automatic Generation of Processing Histories using Alida''']. It will provide an introduction to the processing history mechanism implemented in Alida, and its usage. Also a talk will be given about our new graphical editor ''Grappa'' entitled '''Graphical Programming in Alida and ImageJ 2.0 with Grappa'''.

* 12/07/2012: New release of chipory ready for download

* 21/03/2012: Alida will be presented at the '''''IEEE International Symposium on Biomedical Imaging (ISBI)''''' to be held at the end of April in Barcelona. There will be a poster presentation combined with a demo at the '''''Bioimage Analysis Workshop on Open Source Software''''' held in conjunction with ISBI. The title will be '''ALIDA - Automatic generation of user interfaces for data analysis algorithms'''.

* 12/03/2012: The Alida concept now features a prototypical implementation in C++! It supports generic operator execution from command line. Release 0.1 is available now from the download page.

* 02/03/2012: Alida release 1.2 has just been published! You can get the new version in the download section! Main new feature: generic user interface generation for operators to use them from commandline and via a Swing GUI!

== Alida - Advanced Library for Integrated Development of Data Analysis Applications ==

...formerly known as Alida - Automatic Logging of Process Information in Data Analysis

Alida defines a concept for designing libraries and toolkits in data analysis. It supports and simplifies integrated algorithm development by inherently joining algorithm implementation, automatic analysis process documentation and fully generic generation of user interfaces. In Alida each data analysis or manipulation action is realized in terms of an operator that acts on given data to produce desired output data. As all operators implement a common interface definition, their input and output parameters are accessible in a standardized manner, and they can also be invoced in a predefined way.

Calls to operators not only produce data analysis results, but are at the same time registered within the framework together with all input and output objects as well as parameters settings of the various operators. These data acquired during an analysis process and the order of operator calls form a directed graph datastructure containing all relevant information for later reconstruction or verification of the analysis procedure. Alida allows to make the directed graph datastructure explicit in terms of XML representations which can be visually explored with appropriate graphical frontends like Chipory, or might be stored in data bases for archival purposes.

Alida's operator concept is well-suited to ease algorithm development and their application to real-world problems by non-expert users. Due to the operator interface definition and the unified handling of operators it is for example possible to automatically generate user interfaces for operators, i.e. graphical frontends or commanline interfaces.

== Licensing information ==
Alida is free software: you can redistribute it and/or modify under the terms of the [http://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3] or (at your option) any later version as published by the [http://www.fsf.org/ Free Software Foundation].

== Current releases ==

==== Java ====
You can download Alida's Java implementation in version 1.2 [[Downloads | here]]. 
You can find the API documentation for this release [http://www2.informatik.uni-halle.de/agprbio/alida/api/java/index.html here]. 

==== C++ ====
You can download Alida's prototypical C++ implementation in version 0.1 [[Downloads | here]]. 
You can find the API documentation for this release [http://www2.informatik.uni-halle.de/agprbio/alida/api/cpp/index.html here]. 

== Manual ==
Alida offers you a user and programmer manual you can download [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/manual/AlidaManual.pdf here]. Note that the manual is currently focussed on the mature Java implementation, but it will be updated in near future to cover both implementations.

== Bug reports & Feature requests ==
Bug reports and feature requests can be submitted via the [http://www2.informatik.uni-halle.de/agprbio/mitobo-bts/bug_report_page.php bugtracking system] or by mail to [mailto:alida@informatik.uni-halle.de alida@informatik.uni-halle.de]. 
Before reporting a new bug, please check if that bug has already been submitted in the [http://www2.informatik.uni-halle.de/agprbio/mitobo-bts/view_all_bug_page.php report list].

Main Page

2012-07-12T14:31:27Z

Posch: /* News */

== [[News]] ==

* 12/07/2012: New release of chipory ready for download

* 21/03/2012: Alida will be presented at the '''''IEEE International Symposium on Biomedical Imaging (ISBI)''''' to be held at the end of April in Barcelona. There will be a poster presentation combined with a demo at the '''''Bioimage Analysis Workshop on Open Source Software''''' held in conjunction with ISBI. The title will be '''ALIDA - Automatic generation of user interfaces for data analysis algorithms'''.

* 12/03/2012: The Alida concept now features a prototypical implementation in C++! It supports generic operator execution from command line. Release 0.1 is available now from the download page.

* 02/03/2012: Alida release 1.2 has just been published! You can get the new version in the download section! Main new feature: generic user interface generation for operators to use them from commandline and via a Swing GUI!

== Alida - Advanced Library for Integrated Development of Data Analysis Applications ==

...formerly known as Alida - Automatic Logging of Process Information in Data Analysis

Alida defines a concept for designing libraries and toolkits in data analysis. It supports and simplifies integrated algorithm development by inherently joining algorithm implementation, automatic analysis process documentation and fully generic generation of user interfaces. In Alida each data analysis or manipulation action is realized in terms of an operator that acts on given data to produce desired output data. As all operators implement a common interface definition, their input and output parameters are accessible in a standardized manner, and they can also be invoced in a predefined way.

Calls to operators not only produce data analysis results, but are at the same time registered within the framework together with all input and output objects as well as parameters settings of the various operators. These data acquired during an analysis process and the order of operator calls form a directed graph datastructure containing all relevant information for later reconstruction or verification of the analysis procedure. Alida allows to make the directed graph datastructure explicit in terms of XML representations which can be visually explored with appropriate graphical frontends like Chipory, or might be stored in data bases for archival purposes.

Alida's operator concept is well-suited to ease algorithm development and their application to real-world problems by non-expert users. Due to the operator interface definition and the unified handling of operators it is for example possible to automatically generate user interfaces for operators, i.e. graphical frontends or commanline interfaces.

== Licensing information ==
Alida is free software: you can redistribute it and/or modify under the terms of the [http://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3] or (at your option) any later version as published by the [http://www.fsf.org/ Free Software Foundation].

== Current releases ==

==== Java ====
You can download Alida's Java implementation in version 1.2 [[Downloads | here]]. 
You can find the API documentation for this release [http://www2.informatik.uni-halle.de/agprbio/alida/api/java/index.html here]. 

==== C++ ====
You can download Alida's prototypical C++ implementation in version 0.1 [[Downloads | here]]. 
You can find the API documentation for this release [http://www2.informatik.uni-halle.de/agprbio/alida/api/cpp/index.html here]. 

== Manual ==
Alida offers you a user and programmer manual you can download [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/manual/AlidaManual.pdf here]. Note that the manual is currently focussed on the mature Java implementation, but it will be updated in near future to cover both implementations.

== Bug reports & Feature requests ==
Bug reports and feature requests can be submitted via the [http://www2.informatik.uni-halle.de/agprbio/mitobo-bts/bug_report_page.php bugtracking system] or by mail to [mailto:alida@informatik.uni-halle.de alida@informatik.uni-halle.de]. 
Before reporting a new bug, please check if that bug has already been submitted in the [http://www2.informatik.uni-halle.de/agprbio/mitobo-bts/view_all_bug_page.php report list].

Downloads

2012-07-12T14:30:00Z

Posch: /* Additional resources */

= Java implementation =

== Requirements ==
Alida's implementation in Java requires Java 1.6 or later.

The following external jars are needed to use Alida:

* [http://xmlbeans.apache.org/ XMLBeans], Version 2.5.0
* [http://xstream.codehaus.org/ XStream], Version 1.3.1
* [http://javahelp.java.net/ JavaHelp], Version 2.0_05

In addition, Alida requires some more libraries which are either in-house developments or result from modifications of other libraries:

* We use a slightly modified version of [http://http://sezpoz.java.net/ SezPoz] for annotation indexing. You can get the modified version [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/sezpoz-1.9-alida.jar here].
* Alida also requires some graphml extensions to be found in '''''aldgraphml.jar''''' [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/aldgraphml.jar jar].
* The graphical operator runner features an online help system based on [http://javahelp.java.net/ JavaHelp System], the corresponding '''Alida-Help.jar''' can be found [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/Alida-Help.jar here].

If you download the Alida binary zipfile you will find these two libraries in the subdirectory ''intjars'' of the zipfile. Make sure that all of them are in the classpath when executing the operator runners. 

== Current release (v1.2)==
* Alida Java Binaries [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin.zip zip] (includes Alida binaries, license information and the file ''aldgraphml.jar'' with Alida's extensions of graphml)
* Alida Java Sources [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src.zip zip] (includes only the sources, license files and some READMEs on how to use and compile Alida)
* Alida Java API [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api.zip zip] (includes Javadocs of Alida's API)
 

== Archive of Alida's Java releases ==

{| border = "1" cellpadding = "5pt" cellspacing = "0" style = "border-color: #DDD; text-align: center; width: 80%"
! Version
! Binaries
! Sources
! API
! Date
|-
| 1.2
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-1.2.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-1.2.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-1.2.zip zip]
| March 2nd, 2012
|-
| 1.1
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-1.1.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-1.1.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-1.1.zip zip]
| Sep 14th, 2011
|-
| 1.0
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_bin-1.0.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_src-1.0.zip zip]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/java/Alida_api-1.0.zip zip]
| May 9th, 2011
|}
 

= C++ implementation =

Alida's implementation in C++ requires Linux as operating system.

The following external libraries are needed:

* [http://loki-lib.sourceforge.net/index.php?n=Main.HomePage Loki], Version 0.17

Optionally a prototypical implementation of an OpenCV wrapper is included for which the OpenCV library is required:
* [http://opencv.willowgarage.com/wiki/ OpenCV], Version 2.1 or higher (refer to the [[Installation]] section for details on compiling the OpenCV wrapper)

== Current release (v0.1)==
* Alida C++ Sources [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_src.zip zip] (includes the sources, license files and some READMEs on how to use and compile Alida)
* Alida C++ API [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_api.zip zip] (includes Doxygen documentation of Alida's C++ API)
 

== Archive of Alida's C++ releases ==

{| border = "1" cellpadding = "5pt" cellspacing = "0" style = "border-color: #DDD; text-align: center; width: 80%"
! Version
! Sources
! API
! Date
|-
| 0.1
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_src-0.1.zip zip] [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_src-0.1.tgz tgz]
| [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_api-0.1.zip zip] [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/cpp/Alida-Cpp_api-0.1.tgz tgz]
| March 12th, 2012
|}
 

= Manual =

Detailed information about Alida, its API and usage, can be found in the user and programmer manual.

* Alida-Manual, Version 1.3 [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/manual/AlidaManual.pdf pdf]
 

= Additional resources =

* '''Chipory''' - a graph visualization tool for displaying MiToBo history graphs Chipory is an extended version of the [http://www.cs.bilkent.edu.tr/~ivis/chisio.html Chisio software] developed at the Bilkent University in Turkey.
 
The zip file below contains all necessary files. Download this file and unpack it into a folder of your choice.

* To use Chipory on a Linux system with 32-bit architecture just type './Chipory.sh'. 
* In case that your machine has a 64-bit architecture running Linux, call './Chipory_64.sh'. 
* For Windows with 32-bit architecture a self extracting installer including an executable of Chipory is available.
 
Download the current release as of 7-12-2012:
* Chipory binary [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/Chipory.zip zip]
* self extracting installer for Windows [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/chipory-setup.exe chipory-setup.exe]
Source code for Chipory is available upon request.
 

= Logo =

* Alida logo as [http://www2.informatik.uni-halle.de/agprbio/alida/downloads/Alida_logo.pdf PDF]

Downloads

2011-05-05T09:13:53Z

Posch: /* Additional resources */

__NOTOC__
== Requirements ==
Alida requires Java 1.6 or later.

The following external jars are needed to use Alida:

* [http://xmlbeans.apache.org/ XMLBeans], Version 2.5.0
* [http://xstream.codehaus.org/ XStream], Version 1.3.1

Alida also requires some graphml extensions to be find in '''''aldgraphml.jar''''' [http://www.informatik.uni-halle.de/alida/downloads/aldgraphml.jar jar]. 
If you download the Alida binary zipfile you will find the library in subdirectory intjars in the zipfile. 

== Current release (v0.9)==
* Alida Binaries [http://www.informatik.uni-halle.de/alida/downloads/Alida_bin-1.0.zip zip] (includes Alida binaries, license information and the file ''aldgraphml.jar'' with Alida's extensions of graphml)
* Alida Sources [http://www.informatik.uni-halle.de/alida/downloads/Alida_src-1.0.zip zip] (includes only the sources, license files and some READMEs on how to use and compile Alida)
* Alida API [http://www.informatik.uni-halle.de/alida/downloads/Alida_api-1.0.zip zip] (includes Javadocs of Alida's API)
 

== All versions of Alida ==

{| border = "1" cellpadding = "5pt" cellspacing = "0" style = "border-color: #DDD; text-align: center; width: 80%"
! Version
! Binaries
! Sources
! API
! Date
|-
| 1.0
| [http://www.informatik.uni-halle.de/alida/downloads/Alida_bin-1.0.zip zip]
| [http://www.informatik.uni-halle.de/alida/downloads/Alida_src-1.0.zip zip]
| [http://www.informatik.uni-halle.de/alida/downloads/Alida_api-1.0.zip zip]
| May 9th, 2011
|}
 

== Manual ==

Detailed information about Alida, its API and usage, can be found in the user and programmer manual.

* Alida-Manual, Version 1.0 [http://www.informatik.uni-halle.de/alida/downloads/manual/AlidaManual.pdf pdf]
 

== Additional resources ==

* '''Chipory''' - a graph visualization tool for displaying MiToBo history graphs Chipory is an extended version of the [http://www.cs.bilkent.edu.tr/~ivis/chisio.html Chisio software] developed at the Bilkent University in Turkey.
 
The zip file below contains all necessary files. Download this file and unpack it into a folder of your choice.

* To use Chipory on a Linux system with 32-bit architecture just type './Chipory.sh'. 
* In case that your machine has a 64-bit architecture running Linux, call './Chipory_64.sh'. 
* For Windows with 32-bit architecture a self extracting installer including an executable of Chipory is available.
 
Download the current release:
[http
* Chipory binary [http://www.informatik.uni-halle.de/alida/downloads/Chipory.zip zip]
* self extracting installer for Windows [http://www.informatik.uni-halle.de/alida/downloads/chipory-setup.exe chipory-setup.exe]
Source code for Chipory is available upon request.
 

== Logo ==

* Chipory logo as [http://www.informatik.uni-halle.de/mitobo/downloads/MiToBo_logo.pdf PDF] or [http://www.informatik.uni-halle.de/mitobo/downloads/MiToBo_logo.png PNG]