Did you spot something wrong or missing on this page? If you have an account on this TWiki, you can fix it yourself by editing the page. If you don't have an account, you can send a message to the Editorial Board to tell us about it. Thank you in advance!
Adding tools to HIPE
Tools are processing units that operate on specific data elements.
From the Java point of view, a tool is an implementation of the
Tool
interface.
Tasks are examples of tools within HIPE. In this case,
TaskTool
is used under the hood. See the topic on
WritingTasks for details.
If a data element is selected, a list of tools that can operate on that element should appear.
Double clicking on the tool will open an associated view (for non-task tools) or a dialogue window for settings parameters (for task tools).
This section explains the following:
- How you can create a tool and register it, so that it becomes available for specific data.
- How you can make HIPE aware of an existing Task.
- How your task can react better to an active data element.
- The default task dialogue window.
- How you can implement and contribute a specific parameter editor
- How to deprecate tasks and task parameters
Adding a task as a HIPE tool
Registering tasks
You can made you task globally available to the system by specifying an instance of that task within a Jython file (usually called __init__.py
for HIPE internal modules) that is read by HIPE at startup (see My first Java HIPE task). For example:
# __init__.py file
compute = ComputeTask()
This is fine if you just want to load your task. To make your task appear classified in the Tasks view, you should create and register your task in the same step as follows (the system will create the task variable for you, with the proper name):
from herschel.ia.task.views import TaskToolRegistry
toolRegistry = TaskToolRegistry.getInstance()
toolRegistry.register(ComputeTask())
You can also specify that your task belongs to one or more Category
:
from herschel.ia.gui.kernel.Tool import Category
toolRegistry.register(ComputeTask(), [Category.IMAGE, Category.PACS]))
To select the prime input parameter, modify your task constructor as follows:
class ComputeTask extends Task {
ComputeTask() {
super("compute");
prime = new TaskParameter("spectrum", SpecificProduct.class)
:
getSignature().setPrimeInput(prime)
}
}
Otherwise the first added input parameter of your task will be its prime input.
For your task to appear in the Applicable category whenever the user selects a suitable variable, you still need to define a Validator. See Validating prime input below.
Tasks Naming Conventions
Tasks registered in HIPE should follow the naming conventions shown in this example:
- Name of the class:
ReduceTask
- Name of the task (given by
getName()
): reduce
- Name of the task variable in Jython:
reduce
(created automatically when registered)
For naming tasks follow the Java conventions, that is, use camelCase and avoid underscores: reduceLight
is valid, reduce_light
is not. HIPE displays info log messages for invalid task names. Note that task names are used as variable names (of type Task
) automatically created when starting HIPE.
Validating prime input
In most cases, the type of the prime input is not enough to determine whether a task is applicable to a variable. Your task may only run on a SpecificProduct
if it contains certain contents: a typical example is a SPIRE task operating on an ObservationContext: clearly, such task should not be listed when a HIFI observation is selected.
This is why you must write a ParameterValidator
to restrict a task to certain product contents:
prime = new TaskParameter("spectrum", SpecificProduct.class)
prime.setParameterValidator(new ParameterValidatorAdapter() {
public void validate(Object value) throws ParameterValidationException {
SpecificProduct s = (SpecificProduct)value;
if (! ( _[logic that would validate the contents of the value]_ )) {
throw new ParameterValidationException( _[reason]_ );
}
}
});
In Jython, your can define your own ParameterValidatorAdapter
classes, although we suggest that you use Java validator classes:
from herschel.ia.gui.kernel import ParameterValidatorAdapter, ParameterValidationException
class MyVal(ParameterValidatorAdapter):
def validate(self, val):
if (val < 0 or val > 10):
raise ParameterValidationException("Bad value " + str(val) + ", must be between 0 and 10")
And you can assign instances to your parameters
p.parameterValidator = MyVal()
Also, a prebuilt confirming (always returns true) Validator is available in TaskParameter :
parameter.setParameterValidator(TaskParameter.TRUE_VALIDATOR);
Note how the validation logic is now within the parameter validation block, rather than in the preamble or execution block of your task. One advantage is that the execution block of your task can concentrate on the core algorithm.
A validator is mandatory for the task to appear in the Applicable category of the Tasks view. If your task really is very general and applies to a given variable type with no exceptions, write a dummy validator that always accepts input values (or use TaskParameter.TRUE_VALIDATOR
).
Task dialogue windows
HIPE generates a default input dialog for all registered tasks. The dialog has three sections: Input, Output and Info, each of which can be collapsed. The following two figures show the interface of the crop
task, with extended and collapsed sections:
Parameters are listed in two columns. HIPE lists the parameters from left to right and top to bottom. If a single input or output parameter is present or if its gui is detected as "big" (for example JFilePathModifier), it fills a whole line.
This automatic layout may not suit your task for several reasons:
- A parameter may need several input fields (see for instance the
angle
parameter of the rotate
task, in the figure below).
- You may only want to provide a sub-set of parameters (and leave the full set to expert users on the command line).
- You may want to organise your parameters by putting a border around a group of parameters.
- You may want to have more informative tooltips, labels or even input fields that are more suitable to your task.
If you want to organise your parameters by grouping them in tabs, you can define groups. See Task.getGroups()
The following sections explore three ways to customise your task dialogue windows:
- Parameter modifiers
- Signature components
- Custom task panels
Parameter modifiers
Each parameter field in the input area of a task dialogue window corresponds to a Modifier
object. HIPE adds Modifier
objects according to the types of input parameters in the task signature.
For instance, the crop
task displays five input parameters: image
, row1
, column1
, row2
, column2
:
HIPE provides modifiers for the simple types Boolean
, Integer
, Float
, Long
, Double
, String
and few more, so there is still a lot of room for improvements and contributions. You can find the general available modifiers in the herschel.ia.gui.apps.modifier
package; please consult the Javadoc of your HIPE installation.
If no default modifier fits your task parameter, you can implement a custom Modifier
and register it to the system. You can also write your specific Modifier
for one of the already available types. In that case, you can create your modifier in a custom Signature Component.
NOTE:
The following behaviours and limitations are present in the provided modifiers:
- While you can always write
SomeTask(param = null)
on the command line, using a task dialog you will get SomeTask()
: the task will interpret null
as if the parameter has been ignored by the user.
- Modifiers have no notion of the optionality of parameters: if they have a valid value, they will return it. The task machinery will not generate a parameter assignment if the value equals the default. See Task Preferences to change the default behaviour.
- Specialized modifiers will mark as erroneous any variables incompatible with the type (dynamically), but will accept any variable.
- If you want your parameter to support dropping a set of variables (multiple selection in Variables View) your parameter must be of type
java.util.List
(or Object
). [Note that list or Pylist will not work]
Showing default values
There are several places where users would like to see the default values of parameters: log messages showing full task invocations, outlines of tasks, generations of task commands from GUIs. With the request to provide full task invocations (including all defaults) default values must be fed to Jython so these parameters must produce a valid Jython expression that maps to the default value. If that is not the case errors would be produced when invoking that task with full parameters. To avoid these errors, the framework will generate a safe string (
taskName.getParameter(paramName).defaultValue
). This is not informative to the end user so, you should provide the Jython string representation of the default value of your parameter by using
TaskParameter.setDefaultValueString(String)
.
Note that to fully support editing modifiers, that is, task parameter GUI elements that allow to generate-edit values (vs just pass variables) full support for generating Jython values must be provided. Most basic and usual types are supported but if this is not the case then you need to provide a Jython converter that supports your type.
Defining Jython converters
If the type of parameter you use does not have a good way to be written as valid Jython code (it falls back to using toString() on the value from the selection) you may need to register a
JythonConverter.
For example, you have a parameter of type X and a modifier for X that has an editor. If you edit the value, when you press Accept the framework will try to generate a Jython expression that creates that value to be assigned to the parameter in the task call.
If there is no
JythonConverter
for X or
X.toString()
does not generate a valid (syntactically or type-wise) Jython expression, the generated command will not execute due to syntax errors or incompatibility with the type the parameter expects.
In many cases, you can define a parameter of a simple type (Object or List) and do the conversion yourself to the proper type in the execute of your method.
Note that the mechanism for showing defaults does not rely on toString() working for all types, so it generates safe Jython to avoid unwanted errors.
So, if you task has a parameter with an editable (that generates values, vs only using already defined variables) modifier the system may not generate the expected values for this type from the modifier. If that is the case, then the module that defines the type (class) of the modifier can:
- Implement a JythonConverter
- Register it
In Java:
JythonConverter<MyType> myConverter = new AbstractJythonConverter<MyType>() {
@Override
public Class<? extends MyType> getType() {
return MyType.class;
}
@Override
public String convert(MyType object) {
return "MyType(" + JythonConverters.toJython(object.getArg()) + ")"; //if your type has a 1-arg constructor of a type already registered, for example
}
};
JythonConverters.register(myConverter);
Implementing a modifier
Your modifier should extend AbstractModifier
, which in turn implements the Modifier
interface. Both reside in the ia.gui.apps.modifier
package. The Modifier
interface consists of two explicit contracts:
- Support of drag and drop features (by indirectly extending
setVariableSelection
and getVariableSelection
in the ia.gui.kernel
package)
- Support object inspection (via the
setObject
and getObject
methods)
Modifiers must also honour two implicit contracts:
- Deriving from
JComponent
- If registered in the Extension Registry, providing an empty constructor
Registering a modifier
You can register your modifier via the Extension Registry with the following syntax (please note the name of the factory: factory.modifier
):
REGISTRY.register(COMPONENT,Extension(
"MyModifier",
"herschel.ia.mymodifier.MyModifier",
"factory.modifier",
"herschel.ia.MyClass")
Be aware that the registration is system-wise, so it overrides any other registered modifier for that type.
In case the modifier you have created is only applicable to a specific task or even to a specific parameter of a specific task, you can simply assign it to the applicable task parameter:
// YourTask constructor
public YourTask() {
addTaskParameter(new TaskParameter("someInput", MyClass.class));
...
}
// Customise your modifiers
@Override
public Map<String, Modifier> getCustomModifiers() {
Map<String, Modifier> map = new LinkedHashMap<String, Modifier>();
map.put("someInput", new MyModifier());
return map;
}
Signature components
In case the default input area based on modifiers does not fit your needs, you can replace it by your own implementation, and register it to the system. The following sections show you how this is done.
Implementing a task signature component
You can create a task signature component by extending JTaskSignatureComponent
in the ia.task.gui.dialog
package, and providing your own implementation of the makeModifierMap()
method.
The JTaskSignatureComponent
class implements the TaskSignatureComponent
interface, which consists of four explicit contracts:
- Support the
setVariableSelection
for initial assignment from the Tool Window
- Assign the Signature to display (
setSignature
)
- Return a map of parameters and assigned values (in
Map<TaskParameter, VariableSelection> getParameters
)
- Clear and check user inputs implementations (used by the default buttons)
Task signature components must also honour two implicit contracts:
- Deriving from
JComponent
- If registered in the Extension Registry, providing an empty constructor
Conventions for labels for input parameters: to construct the labels of your parameters you can use the static function of class JTaskSignatureComponent public static JLabel getDecoratedLabel(TaskParameter tp, boolean isPrimeInput, String altName)
it provides a decorated label (including tooltip) that follows the standard style. For the function to work properly your task parameters should be fully configured (for example, the parameter description will be the tooltip of the label) if present.
For example, if you want to use a custom Signature Component that just wants to use JFilePathModifier
for a parameter aimed for a file name, you could do it like this:
public class MySignatureComponent extends JTaskSignatureComponent {
private static final long serialVersionUID = 1L;
protected Map<TaskParameter, Modifier> makeModifierMap() {
SignatureApi signature = getSignature();
Map<TaskParameter, Modifier> m = new LinkedHashMap<TaskParameter, Modifier>();
m.put(signature.getTaskParameter("file"), new JFilePathModifier(SAVE));
m.put(signature.getTaskParameter("number"), new JIntegerModifier());
return m;
}
}
NOTE:
You no longer need a signature component to choose your own modifiers for your task (and link them with events ...): Task has a new function public Map<String, Modifier> getCustomModifiers()
where you can do just that, see above "Register a Modifier".
Register a Task Signature Component
The registration of the Task Signature Component is done again in the __init__.py
via the Extension Registry with the usual syntax (please note the name of the factory: factory.editor.tool.task.signature).
REGISTRY.register(COMPONENT,Extension(
"Rotate Signature",
"herschel.ia.task.example.RotateSignatureComponent",
"factory.editor.tool.task.signature",
"herschel.ia.image.RotateTask"))
See also the Extension Registry documentation for more details.
Custom Task Dialogs
Eventually, if the above options still do not accommodate you needs you can replace the the default Task Panel with your own implementation
If this is the case you need to:
- Implement a Task Panel
- Register it to the system.
Implement a Task Panel
The ia.task.gui.dialog.TaskPanel interface consists of three explicit contracts:
- Support the setVariableSelection for initial assignment from the Tool Window
- Assign the Task to display ( the setTask)
- Notify request of executions to the framework by
- Allow for setting the Site Event handler for notifying request of execution (the setSiteEventHandler method)
- Notify the execution requests calling the trigger method of
herschel.ia.gui.kernel.SiteEventHandler
passing a herschel.ia.gui.kernel.event.CommandExecutionRequestEvent
.
You can create this event through the herschel.ia.task.gui.dialog.TaskCommandExecutionEventFactory
. Note that the factory uses preference Editors & Viewers/Task Dialog/fullCommand to generate lomg or short forms for the commands.
- Return the
javax.swing.Actions
for running the task and resetting (clear) the signature (the actions that are invoked when pressing "Accept" and "Clear" buttons, if present), to allow to execute them from the toolbar of HIPE. The simplest implementation would be to create and assign those actions to your buttons in your setTask(TaskApi)
method and then to return them from the buttons when asked:
public Action getRunAction() {
return runbutton.getAction();
}
public Action getResetAction() {
return resetButton.getAction();
}
and the two implicit contracts inherited by the Extension Registry
- Be JComponent
- Have an empty constructor
The Rotate Panel example (herschel.ia.task.example.RotatePanel):
Register a Task Panel
The registration of the Task Panel Component is done again in the __init__.py
via the Extension Registry with the usual syntax (please note the name of the factory: factory.editor.tool.task.signature).
REGISTRY.register(COMPONENT,Extension(
"Rotate Task Panel",
"herschel.ia.task.example.RotatePanel",
"factory.editor.tool.task",
"herschel.ia.image.RotateTask"));
See also the Extension Registry documentation for more details.
Adding a Tool that is not a Task
If you have an existing task and want to make it available in HIPE, you just need to follow the steps described in the above section.
Now, a task has its limitations. It is somewhat an atomic operation for which you provide some inputs and expect some result.
Therefore, it is not expected for acting interactively with a user, and it is not meant for holding internal state either, that a user can modify during its execution.
If you need more flexibility, you can write your own implementation of the Tool
interface.
Besides, you would most probably need a viewer associated to your tool, for letting the user interact with it.
This follows in some way the MVC pattern: your target data is the Model, your associated viewer is the View, and your tool is the Controller.
Tool Implementation
In order to write a tool, Tool
interface needs to be implemented. Instead of doing it directly, it is encouraged to extend AbstractTool
.
The information to be provided is passed to one of its constructors in a super
call from the derived class:
/** Constructor for a tool with a single parameter and general category. */
protected AbstractTool(String name, Parameter primeInput)
/** Constructor for a tool with a single input parameter. */
protected AbstractTool(String name, Parameter primeInput, Category... categories)
/** Constructor for a tool with multiple input parameters and general category. */
protected AbstractTool(String name, Parameter primeInput, List<? extends Parameter> inputs)
/** Constructor with all arguments. */
protected AbstractTool(String name,
Parameter primeInput,
List<? extends Parameter> inputs,
Category... categories)
You provide the variable types you are interested in within the prime input: just return a herschel.ia.gui.kernel.ToolParameter
initiated with the proper class of data you want to handle:
new ToolParameter("data", MyTargetDataType.class)
More conditions for checking whether the tool can react on a particular variable can be added by providing a ParameterValidator
to the prime input.
The actual job to be done can be delegated to a third object (the "tool object"), or just be executed by the tool class itself.
This latter case is the default; otherwise, you need to call setToolObject(Object toolObject)
in your constructor.
Moreover, you may return the categories you think the tool is meaningful for, by providing the proper ones in the super
call.
Naming conventions
Conventions for names of a tool class and its variable in the Tasks view are similar than those for tasks. For example, a tool for spectrum filtering could be called:
Name of the Class : SpectrumFilterTool
Name of the Tool (getName()) : spectrumFilter
Name of the variable in Jython : spectrumFilter
Tool Viewer
Every tool has an associated viewer, which must implement EditorComponent
(by extending AbstractEditorComponent
or one of its subclasses).
Tool Registry
Once you have your tool and the corresponding viewer, you need to register them like this:
# Associate the tool with the viewer
REGISTRY.register(COMPONENT,Extension(
"Spectrum Filter Tool",
"herschel.path.to.SpectrumFilterToolComponent",
"factory.editor.tool",
"herschel.path.to.SpectrumFilterTool"))
# Register the tool so it is automatically available for the proper variables in HIPE
from herschel.ia.gui.kernel import ToolRegistry
from herschel.path.to import SpectrumFilterTool
spectrumFilter = SpectrumFilterTool()
ToolRegistry.getInstance().register(spectrumFilter)
__all__ = [ "spectrumFilter", "SpectrumFilterTool", ... ]
Communicating Tool & Viewer
In the viewer, you can access the tool and the selected data within the makeEditorContent
method provided by AbstractEditorComponent
.
At this point, you can let the tool know about the viewer as well, if you want:
protected boolean makeEditorContent() {
// Get the tool and the selected data
ToolSelection selection = getSelection();
Tool tool = selection.getTool();
Object data = selection.getSelection().getValue();
// Optional - you would need to provide a setViewer method
((MyTool)tool).setViewer(this);
// Build the editor contents ...
}
Example
This simple reproducible example wraps up the just explained steps altogether.
It is just a button whose label is changed by the tool when the user clicks on it:
1. The tool class
public class SimpleButtonTool extends AbstractTool {
private ArrayData _data = null;
private boolean _flag = true;
public SimpleButtonTool() {
super("simpleButton", new ToolParameter("data", ArrayData.class));
}
void setData(ArrayData data) {
_data = data;
}
void updateLabel(JButton button) {
boolean hasData = _data != null;
button.setEnabled(hasData);
if (hasData) {
int size = _data.getSize();
int rank = _data.getRank();
button.setText("Data has " + (_flag? "size " + size : "rank " + rank));
_flag = !_flag;
} else {
button.setText("No data selected");
}
}
}
2. The viewer class
public class SimpleButtonToolComponent extends AbstractEditorComponent<ToolSelection> {
private static final long serialVersionUID = 1L;
private static int _counter = 1;
private SimpleButtonTool _tool;
protected Class<ToolSelection> getSelectionType() {
return ToolSelection.class;
}
protected boolean makeEditorContent() {
final JButton button = new JButton();
setName("Button Tool " + _counter++);
ToolSelection toolSelection = getSelection();
_tool = (SimpleButtonTool)toolSelection.getTool();
Selection selection = toolSelection.getSelection();
if (selection != null) {
_tool.setData((ArrayData)selection.getValue());
}
_tool.updateLabel(button);
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
_tool.updateLabel(button);
}
});
add(button);
return true;
}
public Icon getComponentIcon() {
return IconLibrary.VARIABLE;
}
}
3. The registration
COMPONENT = ExtensionRegistry.COMPONENT
REGISTRY = ExtensionRegistry.getInstance()
REGISTRY.register(COMPONENT,Extension(
"Button Tool",
"herschel.path.to.SimpleButtonToolComponent",
"factory.editor.tool",
"herschel.path.to.SimpleButtonTool"))
from herschel.ia.gui.kernel import ToolRegistry
from herschel.path.to import SimpleButtonTool
simpleButton = SimpleButtonTool()
ToolRegistry.getInstance().register(simpleButton)
# cleanup
del(ExtensionRegistry, Extension, REGISTRY, COMPONENT)
__all__ = [ "simpleButton", "SimpleButtonTool" ]
4. Executing the example
For executing this simple tool, just include it in a package owned by you, open the workbench in HIPE, and execute the following in the console:
x = Int1d.range(12)
y = Double2d([[1,2,3],[4,5,6]])
Then open the x and y variables with the Button Tool and click the button: its label is updated by the tool.
Triggering Events
For a full detailed section about triggering events have a look at DpHipeCommonUtilities.
Deprecating Tasks
Tasks provide support for ease of evolution. During a long project some functionalities are extended, reduced or even removed.
The basic mechanism involves keeping a deprecated copy than informs, complains and guides until the removal.
This is an extract of the information contained in the Task FAQ
For tasks, the framework has been extended with:
- A new String attribute
deprecatedWith
for tasks.
- When executed, it will throw a warning and a log message.
- Default GUI will show this message too.
-
TaskUtil.makeDoc(task)
will add deprecation message too for removals. Note that doc is effectively "final" (only read once by Jython).
- Task View will show deprecation info in the tooltip.
- Outline will show the deprecation.
For task parameters, the framework has been extended with:
- New String attributes
deprecatedWith
and deprecates
for task parameters.
- When executed, your
preamble
will "update" user code and log a warning.
- Default GUI will not show deprecated parameters.
-
TaskUtil.makeDoc(task)
will add deprecation info to deprecated parameters.
- Task View will show deprecation info in the tooltip.
- Outline will show the deprecation.
Use cases:
- Changing names of parameters
- Changing the name of a task
- Removing a task
Changing names of parameters
For a more detailed analysis (outputs) see Task FAQ. Here we assume it is an input parameter. It involves keeping the old deprecated during a release
- Rename the parameter to the NEWNAME
- Copy the parameter at the end of the signature (with the old name OLDNAME) as optional and set the value of the
deprecatedWith
attribute
- Add a
preamble
to your task that copies values from OLDNAME parameter to NEWNAME parameter and logs warnings. It should call the parent preamble
at the end.
- Add info to the Registry of removed names for taskname.OLDNAME and do not forget to update JExamples and JTags
Changing the name of a task
- Rename the task (NEWNAME, both in source and
init.py
)
- Add another instance in the
init.py
, changing the name
(OLDNAME) and deprecatedWith
attributes. Export the new task instance, but do not register it.
- Add info to the Registry of removed names either now or when you finally remove the OLDNAME instance.
Removing a task
- Deprecate the code
- Set
deprecatedWith
before calling makeDoc
- Remove registration from
init.py
(but keep imports)
- Once the deprecation period is over, all the code (source, init) will be removed and info added to the Registry of removed names.
Your comments