Uses of Interface
adams.core.CleanUpHandler
-
-
Uses of CleanUpHandler in adams.core
Classes in adams.core that implement CleanUpHandler Modifier and Type Class Description class
Variables
A container for storing variables and their values. -
Uses of CleanUpHandler in adams.core.command
Subinterfaces of CleanUpHandler in adams.core.command Modifier and Type Interface Description interface
AsyncCapableExternalCommand
Interface for external commands that support asynchronous mode.interface
ExternalCommand
Interface for classes that execute external commands.interface
ExternalCommandWithOptions
Interface for external commands that take options.interface
ExternalCommandWithProgrammaticArguments
Interface for external commands that support programmatic options that get folded into the command.Classes in adams.core.command that implement CleanUpHandler Modifier and Type Class Description class
AbstractAsyncCapableExternalCommand
Ancestor for external commands that can be run in blocking or async mode.class
AbstractAsyncCapableExternalCommandWithOptions
Ancestor for commands that can be run in async mode that support options.class
AbstractExternalCommand
Ancestor for external commands.class
AbstractExternalCommandWithOptions
Ancestor for commands that take options. -
Uses of CleanUpHandler in adams.core.command.output
Subinterfaces of CleanUpHandler in adams.core.command.output Modifier and Type Interface Description interface
OutputFormatter
Interface .Classes in adams.core.command.output that implement CleanUpHandler Modifier and Type Class Description class
AbstractOutputFormatter
Ancestor for output formatters.class
LineSplit
Splits the incoming data on the new line character and forwards string arrays.class
PassThrough
Simply forwards the received output without any processing. -
Uses of CleanUpHandler in adams.core.command.stderr
Subinterfaces of CleanUpHandler in adams.core.command.stderr Modifier and Type Interface Description interface
StdErrProcessor
Interface for classes that process stderr output.Classes in adams.core.command.stderr that implement CleanUpHandler Modifier and Type Class Description class
AbstractStdErrProcessor
Ancestor for processing the command output received on stderr.class
CallableActorSink
Forwards the data to the callable actor sink.class
Enqueue
Adds the output from stderr to the specified queue.class
Log
Outputs the data received from the command's stderr via its logger instance.class
Null
Simply suppresses any output. -
Uses of CleanUpHandler in adams.core.command.stdout
Subinterfaces of CleanUpHandler in adams.core.command.stdout Modifier and Type Interface Description interface
StdOutProcessor
Interface for classes that process stdout output.Classes in adams.core.command.stdout that implement CleanUpHandler Modifier and Type Class Description class
AbstractStdOutProcessor
Ancestor for processing the command output received on stdout.class
CallableActorSink
Forwards the data to the callable actor sink.class
Enqueue
Adds the output from stdout to the specified queue.class
Log
Outputs the data received from the command's stdout via its logger instance.class
Null
Simply suppresses any output. -
Uses of CleanUpHandler in adams.core.logging
Classes in adams.core.logging that implement CleanUpHandler Modifier and Type Class Description class
Logger
Simple logger class. -
Uses of CleanUpHandler in adams.core.net
Classes in adams.core.net that implement CleanUpHandler Modifier and Type Class Description class
AbstractSendEmail
Ancestor for classes that can send emails.class
ApacheSendEmail
Uses Apache commons-netSMTPClient
orSMTPSClient
for sending emails.class
JavaMailSendEmail
Uses JavaMail for sending emails.class
SimpleApacheSendEmail
Uses Apache commons-email for sending emails. -
Uses of CleanUpHandler in adams.core.option
Subinterfaces of CleanUpHandler in adams.core.option Modifier and Type Interface Description interface
DebugOptionProducer<O,I>
Indicator interface for option producers that generate debugging output.interface
OptionConsumer<C,V>
Interface for classes that set the option values based on the input data.interface
OptionConsumerWithOptionHandling<C,V>
Interface for option consumers that offer option handling.interface
OptionProducer<O,I>
Interface for classes that generate output from visiting the options.interface
OptionProducerWithOptionHandling<O,I>
Interface for option producers that offer option handling.Classes in adams.core.option that implement CleanUpHandler Modifier and Type Class Description class
AbstractActorJavaCodeProducer
Ancestor for producers that generate Java code from actors.class
AbstractArgumentOption
The ancestor of all option classes that take an argument.class
AbstractDocumentationProducer<O>
Ancestor for producers that generate documentation that is split into two parts: 1.class
AbstractFlowJavaCodeProducer
Ancestor for producers that generate Java code from flows.class
AbstractJavaCodeProducer
Ancestor for producers that generate Java code.class
AbstractNumericOption<T extends Number>
Handles options with numeric arguments.class
AbstractOption
The ancestor of all option classes.class
AbstractOptionConsumer<C,V>
Sets the option values based on the input data.class
AbstractOptionProducer<O,I>
Generates output from visiting the options.class
AbstractRecursiveOptionConsumer<C,V>
Generates output from visiting the options recursively.class
AbstractRecursiveOptionProducer<O,I>
Generates output from visiting the options recursively.class
AbstractRecursiveOptionProducerWithOptionHandling<O,I>
Ancestor for recursive option producers that offer option handling.class
ActorExecutionClassProducer
Generates a wrapper class for executing an actor.class
ApplyActorProducer
Generates a Java class that allows executing/applying an actor as a method.class
ArrayConsumer
Parses a string array of options.class
ArrayProducer
Generates the string array format that is used on the command-line.class
BaseObjectOption
Option class for BaseObject derived classes.class
BooleanOption
Option for boolean flags.class
ByteOption
Handles options with Byte arguments.class
ClassOption
Option class for OptionHandler options.class
CommandlineHelpProducer
Generates the help for the command-line.class
CompactFlowConsumer
Reads nested, compact actor flow format.class
CompactFlowProducer
Generates nested, compact actor flow format.class
CustomHooksOption
Option class for options with custom hooks for valueOf and toString.class
DatabaseActorExecutionClassProducer
Generates a wrapper for an actor that works in conjunction with a database.class
DebugNestedProducer
Nested producer that outputs format useful for debugging purposes.class
DoubleOption
Handles options with Double arguments.class
EnumOption
Option class for enums.class
FloatOption
Handles options with Float arguments.class
FlowJUnitTestProducer
Generates a JUnit test case for flows.class
FlowStructureDotProducer
Outputs the flow structure in DOT (GraphViz) format.class
FlowStructureGraphMLProducer
Outputs the flow structure in GraphML XML format.class
HtmlHelpProducer
Generates the help for the GUI, i.e., HTML output.class
HtmlParametersProducer
Generates HTML output of the parameters of an object (non-recursive).class
IntegerOption
Handles options with Integer arguments.class
JavaInstantiationProducer
Generates Java code for instantiating the object.class
JsonConsumer
Recreates objects from a JSON representation.class
JsonProducer
Generates the JSON format.class
LongOption
Handles options with Long arguments.class
MaterializedArrayProducer
Specialized ArrayProducer that resolves "callable actor references" into concrete options.class
NestedConsumer
Parses a nested ArrayList of options.class
NestedProducer
Generates the nested format.class
OptionManager
Class for managing option definitions.class
ShortOption
Handles options with Short arguments.class
StringOption
Handles options with string arguments.class
XhtmlProducer
Generates documentation in XHTML. -
Uses of CleanUpHandler in adams.data.baseline
Classes in adams.data.baseline that implement CleanUpHandler Modifier and Type Class Description class
AbstractBaselineCorrection<T extends DataContainer>
Abstract base class for baseline correction schemes.static class
AbstractBaselineCorrection.BaselineCorrectionJob<T extends DataContainer>
A job class specific to baseline correction schemes.class
AbstractDatabaseConnectionBaselineCorrection<T extends DataContainer>
Ancestor for baseline correction schemes that require database access.class
AbstractLinearRegressionBased<T extends DataContainer>
Abstract ancestor for linear regression based baseline correction schemes.class
AbstractLOWESSBased<T extends DataContainer>
Ancestor for LOWESS-based baseline correction schemes.class
AbstractSavitzkyGolayBased<T extends DataContainer>
Ancestor for SavitzkyGolay-based baseline correction schemes.class
PassThrough
Dummy scheme, performs no basline correction at all.class
SlidingWindow<T extends DataContainer>
Applies a baseline correction scheme on partitions of the data with a sliding window approach.class
TimeseriesLOWESSBased
A baseline correction scheme that uses LOWESS smoothing to determine the baseline.
For more information see:
WikiPedia.class
TimeseriesSavitzkyGolayBased
A baseline correction scheme that uses SavitzkyGolay smoothing to determine the baseline.
For more information see:
A. -
Uses of CleanUpHandler in adams.data.boofcv.features
Classes in adams.data.boofcv.features that implement CleanUpHandler Modifier and Type Class Description class
AbstractBoofCVFeatureGenerator
Abstract base class for BoofCV feature generation.class
AbstractScript
Ancestor for BoofCV feature generator scripts.class
AbstractScriptedFeatureGenerator
Abstract ancestor for BoofCV feature generator that execute external scripts.class
FilteredBoofCVFeatureGenerator
Applies the filter (an image transformer) to the image first before generating the features from the transformed images.class
Histogram
Generates a histogram from the image.class
MultiBoofCVFeatureGenerator
Applies multiple generators to the same image and merges the generate a feature vectors side-by-side.class
Otsu
Computes the variance based threshold using Otsu's method from an input image (gray scale; boofcv.struct.image.GrayU8).
For more information see:
WikiPedia.class
Pixels
Gets all the pixels of the image.class
Scripted
A feature generator that uses any scripting handler for processing the data with a script located in the specified file. -
Uses of CleanUpHandler in adams.data.boofcv.transformer
Classes in adams.data.boofcv.transformer that implement CleanUpHandler Modifier and Type Class Description class
AbstractBoofCVTransformer
Abstract base class for BoofCV transformations.class
AbstractScript
Ancestor for BoofCV transformer scripts.class
AbstractScriptedTransformer
Abstract ancestor for transformers that execute external scripts.class
Binary
Creates a binary image.class
BinaryContours
Uses the BoofCV binary contours algorithm to detect edges in a binary image.class
CannyEdgeDetection
Performs edge detection using the Canny Edge detection algorithm.
For more information on the algorithm, see:
WikiPedia.class
Dilate4
Applies the BoofCV dilate4 algorithm to a binary image.class
Dilate8
Applies the BoofCV dilate8 algorithm to a binary image.class
Erode4
Applies the BoofCV erode4 algorithm to a binary image.class
Erode8
Applies the BoofCV erode8 algorithm to a binary image.class
Gray8
Transforms the image into an 8-bit gray image.class
ImageType
Turns an image into the specified type of image.class
Inverter
Takes a binary image in the BoofCV Unsigned Int 8 format and inverts each pixel.class
MultiTransformer
Applies the specified BoofCV transformers one after the other.class
PassThrough
A dummy transform that just passes the image through.class
Scripted
An image transformer that uses any scripting handler for processing the data with a script located in the specified file.class
Sharpen4
Applies a Laplacian-4 based sharpen filter to the image.class
Sharpen8
Applies a Laplacian-8 based sharpen filter to the image.class
SuperPixels
Takes an image and divides it into super pixels.
For more information see:
http://boofcv.org/index.php?title=Tutorial_Image_Segmentation
class
WaveletDenoise
Removes noise using wavelet transformation. -
Uses of CleanUpHandler in adams.data.conversion
Subinterfaces of CleanUpHandler in adams.data.conversion Modifier and Type Interface Description interface
BufferedImageToOtherFormatConversion
Indicator interface for conversion that convert aBufferedImageContainer
into another format.interface
Conversion
Interface for conversion schemes.interface
ConversionFromString
Indicator interface for conversion schemes that turn strings into other objects.interface
ConversionToString
Indicator interface for conversion schemes that convert objects to strings.interface
ConversionWithInitialization
For conversions that require an initialization first.interface
OtherFormatToBufferedImageConversion
Indicator interface for conversions that convert another format into aBufferedImageContainer
.Classes in adams.data.conversion that implement CleanUpHandler Modifier and Type Class Description class
AbstractConversion
Ancestor for all conversions.class
AbstractConversionFromString
Ancestor for conversion schemes that convert strings into other objects.class
AbstractConversionToString
Ancestor for conversion schemes that convert objects into strings.class
AbstractImageToByteArray
Converts an image into a byte array.class
AbstractInPlaceSpreadSheetConversion
Ancestor for spreadsheet conversion that allow working on the incoming data rather than on a copy (to conserve memory).class
AbstractMatchWekaInstanceAgainstHeader
Ancestor for classes that match Instance objects against Instances headers.class
AbstractMatrixToSpreadSheet
Ancestor for conversions that turn a matrix of some type into a spreadsheet.class
AbstractObjectToJson
Converts the Map into a JSON object.class
AbstractScript
Ancestor for conversion scripts.class
AbstractScriptedConversion
Abstract ancestor for actors that execute external scripts.class
AbstractSpreadSheetColumnConverter<T>
Ancestor for column converter schemes.class
AbstractSpreadSheetConversion
Ancestor for conversion schemes that transform one spreadsheet into another one.class
AbstractSpreadSheetToMatrix<T>
Ancestor for conversions that turn a spreadsheet into a matrix of some data type.class
AbstractStringConversion
Ancestor for string conversion schemes.class
AbstractSwapObject
Ancestor for classes that swap all occurrences of one object for another.class
AbstractValidateString
Ancestor for string conversions that ensure a string only contains valid characters according to some rules.class
AdamsInstanceToWekaInstance
Converts adams.data.instance.Instance objects into weka.core.Instance ones.class
AnyImageToByteArray
Turns any image container into a byte array.class
AnyImageToOpenCV
Turns an Image container into an OpenCV container.class
AnyToCommandline
Generates a commandline string from any object.class
AnyToString
Turns any object into a String, using its 'toString()' method.class
ArrayToCollection
Deprecated.class
ArrayToJsonArray
Turns an object array into a JSON array.class
ArrayToReport
Turns an array into a report.class
ArrayToYamlString
Converts the object array into a YAML string.class
BackQuote
Backquotes, i.e., escapes with a backslash, characters like quotes (single and double), new lines, tabs.
See also:
adams.data.conversion.Quote
adams.data.conversion.UnQuote
adams.data.conversion.UnBackQuote
Valid options are:class
Base64ToByteArray
Decodes a base64 string into a byte array.class
Base64ToString
Decodes a base64 string.class
BaseDateTimeMsecToString
Turns a BaseDateTimeMsec format string into a String, evaluted using user-supplied start and end dates (ignored if future INF dates).
Example: 2015-12-01 07:13:12.034 +3 MINUTE
(<date>|NOW|-INF|+INF|START|END) [expr (MILLISECOND|SECOND|MINUTE|HOUR|DAY|BUSINESSDAY|WEEK|MONTH|YEAR)]*
expr ::= ( expr )
| - expr
| + expr
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr % expr
| expr ^ expr
| abs ( expr )
| sqrt ( expr )
| log ( expr )
| exp ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| NUMBER
class
BaseDateTimeToString
Turns a BaseDateTime format string into a String, evaluted using user-supplied start and end dates (ignored if future INF dates).
Example: 2015-12-01 07:13:12 +3 MINUTE
(<date>|NOW|-INF|+INF|START|END) [expr (SECOND|MINUTE|HOUR|DAY|BUSINESSDAY|WEEK|MONTH|YEAR)]*
expr ::= ( expr )
| - expr
| + expr
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr % expr
| expr ^ expr
| abs ( expr )
| sqrt ( expr )
| log ( expr )
| exp ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| NUMBER
class
BaseDateToString
Turns a BaseDate format string into a String, evaluted using user-supplied start and end dates (ignored if future INF dates).
Example: 2015-12-01 +3 DAY
(<date>|NOW|-INF|+INF|START|END) [expr (DAY|BUSINESSDAY|WEEK|MONTH|YEAR)]*
expr ::= ( expr )
| - expr
| + expr
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr % expr
| expr ^ expr
| abs ( expr )
| sqrt ( expr )
| log ( expr )
| exp ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| NUMBER
class
BaseTimeToString
Turns a BaseTime format string into a String, evaluted using user-supplied start and end times (ignored if future INF times).
Example: 07:13:12 +3 MINUTE
(<date>|NOW|-INF|+INF|START|END) [expr (SECOND|MINUTE|HOUR)]*
expr ::= ( expr )
| - expr
| + expr
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr % expr
| expr ^ expr
| abs ( expr )
| sqrt ( expr )
| log ( expr )
| exp ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| NUMBER
class
BlobContainerToByteArray
Obtains the byte array content of a adams.data.blob.BlobContainer and forwards that.class
BoofCVToBufferedImage
Turns a BoofCV container into a BufferedImage one.class
BooleanToString
Turns a Boolean into a String.class
BreakUpString
Breaks up a string into multiple lines if wider than the specified number of columns.class
BufferedImageBitmaskContainerToBufferedImages
Turns the bitmask container back into an array of containers for BufferedImage objects, with the image being the first and the bitmasks the other elements.
The incoming report gets cloned into all of the outgoing containers.class
BufferedImagesToBufferedImageBitmaskContainer
Turns the BufferedImage containers into a container with image (index=0) and bitmasks (index>=1).
Only the report from the first container is transferred.class
BufferedImageSupporterToBufferedImageContainer
Converts a adams.data.image.BufferedImageSupporter to a adams.data.image.BufferedImageContainer
class
BufferedImageToBoofCV
Turns a BufferedImage container into a BoofCV one.class
BufferedImageToBufferedImage
Dummy conversion, performs no conversion at all.class
BufferedImageToByteArray
Turns a BufferedImage object into a byte array.class
ByteArrayToBase64
Encodes a byte array as base64 string.class
ByteArrayToBlobContainer
Wraps the byte array in a adams.data.blob.BlobContainer, which allows the storage of meta-data using the attached report and/or notes.class
ByteArrayToBufferedImage
Converts the byte array representating a binary image (e.g., JPG or PNG) into a BufferedImage container.class
ByteArrayToImageContainer
class
ByteArrayToJavaObject
Deserializes a Java object from the byte array.class
ByteArrayToPrimitiveArray
Turns a byte array (IEE754) into a primitive array.class
ByteArrayToString
Turns a byte array into a String.class
ByteToHex
Turns a Byte into a hexadecimal string.class
ByteToInt
Turns a Byte into an Integer.class
ByteToString
Turns a Byte into a String.class
CharArrayToString
Turns a char array into a String.class
CollectionToArray
Turns a collection into an array.class
ColorToHex
Turns a color object into its hexa-decimal representation, e.g., '#ffffff'.class
CommandlineToAny
Turns a command-line into an object.class
ContainerToSpreadSheet
Converts any container into a SpreadSheet object.class
ConvertDateTimeType
Turns instances of the specified input date/time type into instances of the specified output date/time type.class
ConvertSpreadSheetRows
Converts the rows in the spreadsheet into a new format.class
DateTimeTypeToString
Turns instances of the specified date/time type into a string using the specified format.class
DOMNodeListToArray
Turns a DOM org.w3c.dom.NodeList into an array of org.w3c.dom.Node.class
DOMNodeToString
Turns a org.w3c.dom.Node DOM object into a String.class
DOMToProperties
Flattens a DOM object (or node) into a Properties object.class
DOMToString
Turns a org.w3c.dom.Node or org.w3c.dom.Document DOM object into a String.
In case of org.w3c.dom.Node objects, the owner document is converted to String.class
DoubleMatrixToBufferedImage
Turns a matrix of double values into a BufferedImage.class
DoubleMatrixToMat5Array
Turns a double matrix into a 2-dimensional Matlab matrix array.class
DoubleMatrixToSpreadSheet
Converts a double matrix into a SpreadSheet object.class
DoubleToFloat
Turns a Double into a Float.class
DoubleToInt
Turns a Double into an Integer.class
DoubleToLong
Turns a Double into a Long.class
DoubleToString
Turns a Double into a String.class
EmailToPlainText
Turns an Email object into a plain text string.class
ExcelDoubleColumnToDate
Converts the specified double column to a date column.class
ExcelDoubleColumnToDateTime
Converts the specified double column to a date/time column.class
ExtractDateTimeField
Extracts the specified field from a date/time type.
A custom format string can be used with field CUSTOM.class
ExtractSimpleContainerContent
Obtains the content of a adams.data.container.AbstractSimpleContainer derived class and forwards that.class
FieldToString
Turns a Field object into a String.class
FileToString
Turns a File object into a String.class
FloatToDouble
Turns a Float into a Double.class
Groovy
A conversion that uses a Groovy script for processing the data.class
HashCode
Generates the hash code of an arbitrary object, using the object's hashcode() method.class
HexToByte
Turns a hexadecimal string into a Byte.class
HexToColor
Turns a hexa-decimal representation of a color, e.g., '#ffffff' into a color object again.class
HexToInt
Turns a hexadecimal string into an Integer.class
HtmlCharacterEntitiesToString
Turns HTML character entities like '<' into their character representations like '<'.class
ImageContainerToByteArray
class
ImageContainerToSpreadSheet
Turns the image of an image container into a spreadsheet for viewing the pixel values.class
InformativeStatistic
Turns the statistics obtained from a adams.data.statistics.InformativeStatisticSupporter into a spreadsheet.class
IntToByte
Turns an Integer into a Byte.class
IntToDouble
Turns an Integer into a Double.class
IntToHex
Turns an Integer into a hexadecimal string.class
IntToLong
Turns an Integer into a Long.class
IntToRoman
Converts an integer (1-3999) into a roman numeral string (eg 'MCM').class
IntToString
Turns an Integer into a String.
Can be optionally formatted using a byte format string.class
JavaObjectToByteArray
Serializes the Java Object into a byte array.class
JoinOptions
Assumes the string array to be an option array and joins them into a single string.class
JsonArrayToArray
Turns a JSON array into an object array.class
JsonArrayToList
class
JsonObjectToMap
Turns a JSON object into a map.class
JsonToReport
Turns a JSON string into a report.
Input format:
{
"Sample ID": "someid",
"GLV2": 1.123,
"valid": true
}
class
JsonToSpreadSheet
Turns a JSON object into a spreadsheet, essentially flattening it.class
JsonToString
Turns a JSON object/array into a string.class
LeftPad
Left pads a string up to a maximum number of characters.class
ListToJson
Converts the java.util.List into a JSON object.class
ListToJsonArray
Turns a Java list into a JSON array.class
ListToYamlString
Converts the java.util.List object into a YAML string.class
LocatedObjectsToReport
Converts the array of LocatedObject instances to a report.class
LocatedObjectToRectangle
Converts a adams.flow.transformer.locateobjects.LocatedObject to a rectangle.class
LongToDouble
Turns a Long into a Double.class
LongToInt
Turns a Long into an Integer.class
LongToString
Turns a Long into a String.
Can be optionally formatted using a byte format string.class
LowerCase
Turns a String into a lowercase String.class
MapToJson
Converts the java.util.Map into a JSON object.class
MapToKeyValuePairs
Converts the java.util.Map into key-value pairs.class
MapToMat5File
Converts a map into a Matlab file object.
Supported nested elements:
- java.util.Map
- Matlab array/struct
- spreadsheet
- Double matrix
class
MapToMat5Struct
Converts a map into a Matlab struct object.
Supported nested elements:
- java.util.Map
- Matlab array/struct
- spreadsheet
- Double matrix
class
MapToReport
Turns a map object into a report.class
MapToSpreadSheet
Turns a java.util.Map object into a SpreadSheet object.class
MapToString
Turns a map object into a simple string.
When encountering date objects as values, they get turned into a string using: yyyy-MM-dd HH:mm:ss
Output format:
<key>:
<value>
class
MapToWekaInstance
Converts a map into a Weka Instance, using the provided storage object (Instances) as template.class
MapToYamlString
Converts the java.util.Map object into a YAML string.class
Mat5ArrayToDoubleMatrix
Converts a 2-dimensional Matlab array into a double matrix.class
Mat5ArrayToSpreadSheet
Turns the Matlab array into a spreadsheet.class
Mat5ArrayToString
Converts matrices into a textual representation, otherwise just outputs the dimensions.class
Mat5CharToString
class
Mat5FileToMap
Turns the Mat5File data structure into a nested map.class
Mat5StructToMap
Turns the Matlab struct into a map.
In case of multi-dimensional (outermost) structs, an index can be supplied to retrieve just a single element instead of all of them.class
MatchWekaInstanceAgainstFileHeader
Matches an Instance against a dataset header loaded from a file, i.e., it automatically converts STRING attributes into NOMINAL ones and vice versa.
The file can be any format that WEKA recognizes.class
MatchWekaInstanceAgainstStorageHeader
Matches an Instance against a dataset header from storage, i.e., it automatically converts STRING attributes into NOMINAL ones and vice versa.class
MathExpression
Evaluates a mathematical expression.
The input value (double or integer) can be accessed via 'X'.
Variables are supported as well, e.g.: pow(X,@{exp}) with '@{exp}' being a variable available at execution time.
The following grammar is used for the expressions:
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
| has ( variable )
| isNaN ( expr )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] ) (find 'search' in 'expr', return 1-based position)
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
| str ( expr )
| str ( expr , numdecimals )
| str ( expr , decimalformat )
| ext ( file_str ) (extracts extension from file)
| replaceext ( file_str, ext_str ) (replaces the extension of the file with the new one)
;
Notes:
- Variables are either all upper case letters (e.g., "ABC") or any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'.
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
Maximum
If the numbers passing through get above the defined maximum, the maximum is returned instead.class
Minimum
If the numbers passing through fall below the defined minimum, the minimum is returned instead.class
MovingAverage
Computes the average on a window of numbers that have passed through and outputs the average.class
MultiConversion
Meta-conversion that allows the chaining of multiple conversions.class
NotesSubset
Generates a subset of a adams.data.Notes object.class
NotesToSpreadSheet
Turns an adams.data.Notes object into a SpreadSheet object.class
NotesToString
Turns an adams.data.Notes object into a string.class
NumberToByte
Turns an Number into a Byte.class
NumberToDouble
Turns an Number into a Double.class
NumberToFloat
Turns an Number into a Float.class
NumberToInt
Turns an Number into a Int.class
NumberToLong
Turns an Number into a Long.class
ObjectAnnotationsToImageSegmentationLayers
Converts the annotations to image segmentation layers.class
ObjectArrayToPrimitiveArray
Converts an object array to its primitive counterpart.class
ObjectContainerToObject
Obtains the object content of a adams.data.container.ObjectContainer and forwards that.class
ObjectToObject
Dummy converter, does not perform any conversion.class
ObjectToObjectContainer
Wraps the object in a adams.data.container.ObjectContainer, which allows the storage of meta-data using the attached report and/or notes.class
OpenCVToBufferedImage
Turns an OpenCV container into a BufferedImage one.class
PathSplit
Splits the path into its individual parts.
Handles forward slashes and backslashes.
Drive letters and servers from UNC paths are handled as separate part.class
Point2DToString
Turns a java.awt.geom.Point2D into a string of the format 'x y'.class
PrettyPrintXML
Turns the XML string into a pretty-printed XML string.
See also:
adams.data.conversion.XMLToDOM
adams.data.conversion.DOMToString
class
PrimitiveArrayToByteArray
Turns a primitive array into a byte array (IEE754).class
PrimitiveArrayToObjectArray
Converts a primitive array to its object counterpart.class
PropertiesToKeyValuePairs
Converts the java.util.Properties into key-value pairs.class
PropertiesToMap
Turns a Properties object into a java.util.Map.class
PropertiesToSpreadSheet
Turns a properties object into a spreadsheet with two columns, one for the key and one for the value.class
PropertiesToString
Turns a Properties object into a String.class
QuadrilateralLocationCenter
Determines the center of the quadrilateral object and returns them as a java.awt.geom.Point2D.class
QuadrilateralLocationToString
Turns a quadrilateral object into a string of the format 'A.x A.y B.x B.y C.x C.y D.x D.y'.class
Quote
Surrounds a string with quotes (single or double), if necessary due to blanks or other characters (new line, tab) in the string.
However, you can also 'force' the quoting.
See also:
adams.data.conversion.UnQuote
adams.data.conversion.BackQuote
adams.data.conversion.UnBackQuote
class
RectangleCenter
Determines the center of the rectangle and returns them as a java.awt.geom.Point2D.class
RectangleToString
Turns a rectangle into a string of the format 'x y w h' or 'x0 y0 x1 y1'.class
RemoteCommandToString
Turns a remote command into a string.class
RenameSpreadSheet
Renames the spreadsheet.class
RenameSpreadSheetColumn
Renames a single column in a spreadsheet.class
ReplaceFileExtension
Interprets the string as file name and replaces its extension with the provided one.class
ReportArrayToMap
Converts the incoming report array into a map using the sample ID as key.class
ReportToJson
Turns a report into a JSON string.
Output format:
{
"Sample ID": "someid",
"GLV2": 1.123,
"valid": true
}
class
ReportToMap
Turns a Report object into a java.util.Map.class
ReportToSpreadSheet
Turns a report into a spreadsheet.class
ReportToString
Generates a string representation from the report using the specified report writer.class
ReportToWekaInstance
Converts a report into a weka.core.Instance objects.class
RightPad
Right pads a string up to a maximum number of characters.class
RomanToInt
Converts a roman numeral string (eg 'MCM') into an integer (eg 1900).class
Round
Rounds double values and turns them into integers..class
RowArrayToSpreadSheet
Converts a an array of spreadsheet rows into a single spreadsheet.class
Scripted
A conversion that uses any scripting handler for processing the data with a script located in the specified file.class
SideBySideDiffToString
Turns a side-by-side diff object into a string.class
SimpleAsciiToUnicode
Turns an ASCII string into a Unicode one, by replacing hexadecimal unicode character representations like '\xf3' with their unicode characters.
For instance, "D'\xe1'cil" becomes "Dácil".class
SimpleUnicodeToAscii
Turns a Unicode string into an ASCII one, by replacing the Unicode characters with something like '\xf3' (including the single quotes).
For instance, "Dácil" becomes "D'\xe1'cil".class
SplitOptions
Assumes the string to be an option string and splits it into its individual elements.class
SpreadSheetAddFormulaColumn
Adds a column with a user-supploed formula for the specified rows.class
SpreadSheetAddFormulaRow
Adds a row with a user-supplied formula for the specified columns.class
SpreadSheetAddRowID
Adds an ID column to the spreadsheet, using the row index as value.class
SpreadSheetAddSumColumn
Adds a column with 'sum' formulas for the specified rows.class
SpreadSheetAddSumRow
Adds a row with 'sum' formulas for the specified columns.class
SpreadSheetAnyColumnToString
Converts the specified spreadsheet column from any type to string.class
SpreadSheetBinarize
Binarizes the non-numeric columns in the selected column range by creating a new column for each of the labels.class
SpreadSheetCellFinderToPositions
Deprecated.class
SpreadSheetCellLocationToCoordinates
Turns the cell location obtained from a cell finder into an integer array with the 1-based coordinates (row/column).class
SpreadSheetCellLocationToPosition
Turns the cell location obtained from a cell finder into a position (like 'A2').class
SpreadSheetColumnFinderToRange
Turns the columns that the specified column finder locates into a 1-based range string.class
SpreadSheetColumnsToReport
Turns spreadsheet columns into reports.class
SpreadSheetDoubleColumnToLong
Converts the specified spreadsheet column from double to long.
Simply uses the Double's 'longValue()' method.class
SpreadSheetDoubleColumnToString
Converts the specified spreadsheet double column to string.class
SpreadSheetEscapeColumnName
Escapes a column name (if necessary) to be used in a column range expression.class
SpreadSheetHeaderToMat5Array
Converts the spreadsheet header with the column names into a Matlab array.class
SpreadSheetInsertCellLocation
Replaces the specified placeholder with a cell location generated from the user-supplied row and column.class
SpreadSheetInsertColumnPosition
Replaces the specified placeholder with a column string (e.g., BG) generated from the user-supplied column.class
SpreadSheetJoinColumns
Merges two or more columns in a spreadsheet into a single column.
Columns can be out-of-order.class
SpreadSheetLongColumnToDouble
Converts the specified spreadsheet column from long to double.
Simply uses the cell's 'toDouble()' method.class
SpreadSheetMaterializeFormulas
Finds cells with formulas in a spreadsheet and replaces the cell content with the value calculated by the formula.class
SpreadSheetObjectColumnToString
Converts the specified spreadsheet column from the object type to string.class
SpreadSheetRowFinderToRange
Turns the rows that the specified row finder locates into a 1-based range string.class
SpreadSheetRowsToReport
Turns spreadsheet rows into report.class
SpreadSheetSplitColumn
Splits the string representation of the cells of a column into multiple columns using a regular expression.class
SpreadSheetStringColumnToBoolean
Converts the specified spreadsheet column from string to boolean.class
SpreadSheetStringColumnToDate
Converts the specified spreadsheet column from string to date, according to the provided format.
For more information on the format, see Javadoc of 'java.text.SimpleDateFormat' class:
http://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html
Valid options are:class
SpreadSheetStringColumnToDateTime
Converts the specified spreadsheet column from string to date/time, according to the provided format.
For more information on the format, see Javadoc of 'java.text.SimpleDateFormat' class:
http://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html
Valid options are:class
SpreadSheetStringColumnToDateTimeMsec
Converts the specified spreadsheet column from string to date/time/msec, according to the provided format.
For more information on the format, see Javadoc of 'java.text.SimpleDateFormat' class:
http://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html
Valid options are:class
SpreadSheetStringColumnToDouble
Converts the specified spreadsheet column from string to double, according to the provided format.
For more information on the format, see Javadoc of 'java.text.DecimalFormat' class:
http://docs.oracle.com/javase/6/docs/api/java/text/DecimalFormat.html
Valid options are:class
SpreadSheetStringColumnToLong
Converts the specified spreadsheet column from string to long, according to the provided format.
For more information on the format, see Javadoc of 'java.text.DecimalFormat' class:
http://docs.oracle.com/javase/6/docs/api/java/text/DecimalFormat.html
Valid options are:class
SpreadSheetStringColumnToObject
Converts the specified spreadsheet column from string to an object, using the specified handler.class
SpreadSheetStringColumnToTime
Converts the specified spreadsheet column from string to time, according to the provided format.
For more information on the format, see Javadoc of 'java.text.SimpleTimeFormat' class:
http://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html
class
SpreadSheetStringColumnToTimeMsec
Converts the specified spreadsheet column from string to time/msec, according to the provided format.
For more information on the format, see Javadoc of 'java.text.SimpleTimeFormat' class:
http://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html
class
SpreadSheetSupporterToSpreadSheet
class
SpreadSheetToCreateTableStatement
Turns a spreadsheet into a SQL 'CREATE TABLE' statement.
Requires two columns: column names, SQL column types.
An optional 3rd column can be used to indicate whether a column is to be used as an index (boolean).class
SpreadSheetToDataset
Turns a spreadsheet object into a dataset object.class
SpreadSheetToDoubleMatrix
Turns a spreadsheet into a double matrix, using only the numeric columns.class
SpreadSheetToJson
Turns a spreadsheet into a JSON array.class
SpreadSheetToMap
Turns two columns (key and value) of a spreadsheet into a map object of the specified type.class
SpreadSheetToMat5Array
Converts a spreadsheet to a Matlab array (either matrix or a cell array)
class
SpreadSheetToNumeric
Turns a spreadsheet into a purely numeric one.
Missing cells can get replaced with a specified value or skipped.
Booleans gets turned into 0/1 (false/true).
Date/time types get turned into numeric ones by using their Java epoch.
Strings (per column) get a 0-based index assigned in the order they appear.
Any other cell type get flagged as missing or, if provided, set to the unhandled value.class
SpreadSheetToRowArray
Converts a spreadsheet into an array of spreadsheet rows.class
SpreadSheetToString
Turns a spreadsheet into a string using the specified spreadsheet writer.class
SpreadSheetToStringMatrix
Turns a spreadsheet into a string matrix.class
SpreadSheetToTimeseries
Turns a SpreadSheet object into a Timeseries.class
SpreadSheetToWekaInstances
Generates a weka.core.Instances object from a SpreadSheet object.
If there are too many unique lables for a NOMINAL attribute, it gets turned into a STRING attribute (see 'maxLabels' property).class
SpreadSheetUnescapeColumnName
Unescapes a column name (if necessary) that was to be used in a column range expression.class
SpreadSheetUniqueColumnNames
Ensures that column names are unique.class
SpreadSheetUseRowAsHeader
Uses the values of the specified data row for the header.class
StringArrayToURLParameters
Turns a string array into parameters of a URL, e.g., '?k1=v1&k2=v2' (uses java.net.URLEncoder).class
StringExpression
Evaluates a string expression.
Variables are supported as well, e.g.: pow(X,@{exp}) with '@{exp}' being a variable available at execution time.
The following grammar is used for the expressions:
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
| has ( variable )
| isNaN ( expr )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] ) (find 'search' in 'expr', return 1-based position)
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
| str ( expr )
| str ( expr , numdecimals )
| str ( expr , decimalformat )
| ext ( file_str ) (extracts extension from file)
| replaceext ( file_str, ext_str ) (replaces the extension of the file with the new one)
# array functions
| len[gth] ( array )
| get ( array , index )
;
Notes:
- Variables are either all upper case letters (e.g., "ABC") or any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- 'index' for function 'get' starts at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
StringMatrixToSpreadSheet
Converts a string matrix into a SpreadSheet object.class
StringToBase64
Encodes a string as base64.class
StringToBoolean
Turns a String into a Boolean, ie any string regardless of case that matches 'true' returns true otherwise false.class
StringToByte
Turns a String into a Byte.class
StringToByteArray
Converts a string into a byte array.class
StringToCharArray
Converts a string into a char array.class
StringToCustomStringRepresentation
Turns a String into an object of a class with an associated object editor that has implements adams.gui.goe.CustomStringRepresentationHandler.class
StringToDateTimeType
Parses a string and turns it into an instance of the specified date/time type.class
StringToDouble
Turns a String into a Double.class
StringToField
Turns a String into a Field object.class
StringToFile
Turns a String into a File object.class
StringToHtmlCharacterEntities
Turns a string into valid HTML, replacing characters like '<', '>' etc with their character entities.class
StringToInt
Turns a String into an Integer.class
StringToJson
Turns a string into a JSON object or array.class
StringToLong
Turns a String into a Long.class
StringToMat5Array
Converts a string like '[1, 2; 3, 4]' into a Matlab matrix.class
StringToPoint2D
class
StringToProperties
Turns a String into a Properties object.class
StringToQuadrilateralLocation
Converts a string into a adams.core.base.QuadrilateralLocation object.class
StringToRectangle
Converts a string into a adams.core.base.BaseRectangle object, using 'x y w h' or 'x0 y0 x1 y1'.class
StringToRemoteCommand
Parses the String and turns it into a RemoteCommand object.class
StringToReport
Reads the report from the incoming string using the specified report reader.class
StringToSpreadSheet
Turns a string representation of a spreadsheet into a SpreadSheet object, using the specified reader setup.class
StringToString
Dummy converter, does not perform any conversion.class
StringToTextContainer
Wraps the String in a adams.data.text.TextContainer, which allows the storage of meta-data using the attached report and/or notes.class
StringToURL
Turns a String into a URL object.class
StringToValidFileName
Turns any string into a valid file name.class
StringToValidStorageName
Turns any string into a valid storage name.class
StringToValidVariableName
Turns any string into a valid variable name.class
SwapObjects
Swaps all occurrences of one object with another one.class
SwapPLS
Swaps one PLS filter for another.class
TextContainerToString
Obtains the string content of a adams.data.text.TextContainer and forwards that.class
TextRenderer
Turns incoming objects into their textual representation, either automatic detection based on their data type or by explicitly specifying a renderer.
See also:
adams.flow.transformer.TextRenderer
class
TimeseriesToArray
Turns the values of a timeseries into a Double array.class
TimeseriesToSpreadSheet
Turns a timeseries into a SpreadSheet object.class
TimeseriesToWekaInstances
Turns a timeseries into a WEKA Instances object.class
TimeToString
Turns a number representing milli-seconds since 1970 (Java date) into a String.
For more information on formatting the date, see:
Javadoc.class
TransposeSpreadSheet
Transposes a spreadsheet, i.e., swaps columns with rows.class
UnBackQuote
Reverses backquoting, i.e., removes the escaping with backslash, restoring characters like quotes (single and double), new lines, tabs.
See also:
adams.data.conversion.Quote
adams.data.conversion.UnQuote
adams.data.conversion.BackQuote
Valid options are:class
UnknownToUnknown
Dummy converter, does not perform any conversion.class
UnQuote
Removes the quotes (single or double) surrounding a string.class
UpperCase
Turns a String into an uppercase String.class
URLDecode
Decodes the URL encoded string back to a regular string (uses java.net.URLDecoder).class
URLEncode
Encodes the string to make it usable within a URL (uses java.net.URLEncoder).class
URLParametersToStringArray
Turns URL parameters like '...?k1=v1&k2=v2' back into a string array (uses java.net.URLDecoder).class
URLToString
Turns a URL object into a String.class
UseForwardSlashes
Converts backslashes in file names to forward slashes.
Does not touch the '\\' prefix of UNC paths.class
WekaCapabilitiesToInstances
Turns a weka.core.Capabilities object into a Weka dataset filled with random data that is compatible with these capabilities.class
WekaCapabilitiesToSpreadSheet
Turns a weka.core.Capabilities object into a spreadsheet, listing all individual capabilities and whether they are supported.class
WekaCommandToCode
Applies a commandline converter to the incoming commandline to generate code.
Uses the following project:
https://github.com/fracpete/command-to-code-weka-package
class
WekaDrawableToString
Extracts the string representation of a weka.core.Drawable object, e.g., the tree representation of a decision tree or the graph of a BayesNet.class
WekaEvaluationToCostCurve
Generates cost-curve data from a WEKA Evaluation object.class
WekaEvaluationToMarginCurve
Generates margin-curve data from a WEKA Evaluation object.class
WekaEvaluationToThresholdCurve
Generates threshold-curve data from a WEKA Evaluation object.class
WekaForecastContainerToArray
Turns a series of predictions of a adams.flow.container.WekaForecastContainer container into a Double array.class
WekaForecastContainerToTimeseries
Turns a series of predictions of a adams.flow.container.WekaForecastContainer container into a adams.data.timeseries.Timeseries.class
WekaInstancesToSpreadSheet
Generates a spreadsheet from a weka.core.Instances object.class
WekaInstancesToTimeseries
Turns a WEKA Instances object into a Timeseries.class
WekaInstanceToAdamsInstance
Converts weka.core.Instance objects into adams.data.instance.Instance ones.class
WekaInstanceToMap
Turns the Weka Instance into a Map, with the attribute names the keys.class
WekaPackageToMap
Turns the Weka Package into a Map.class
WekaPredictionContainerToSpreadSheet
Turns a WEKA prediction container into a SpreadSheet object.class
XMLToDOM
Turns an XML string into a org.w3c.dom.Document DOM object.class
YamlStringToList
Converts the YAML string into a java.util.Map object.class
YamlStringToMap
Converts the YAML string into a java.util.Map object. -
Uses of CleanUpHandler in adams.data.filter
Subinterfaces of CleanUpHandler in adams.data.filter Modifier and Type Interface Description interface
BatchFilter<T extends DataContainer>
Interface for filters that can filter multiple data containers in one go.interface
Filter<T extends DataContainer>
Interface for filters.interface
TrainableBatchFilter<T extends DataContainer>
Interface for trainable batch filters.Classes in adams.data.filter that implement CleanUpHandler Modifier and Type Class Description class
AbstractAutocorrelation<T extends DataContainer>
Abstract ancestor for autocorrelation filters.class
AbstractBatchFilter<T extends DataContainer>
Ancestor for batch filters.class
AbstractDatabaseConnectionFilter<T extends DataContainer>
Ancestor for filters that require database access.class
AbstractDerivative<T extends DataContainer>
Abstract ancestor for Derivative filters.class
AbstractEquiDistance<T extends DataContainer>
Abstract ancestor for filters that equi-distance the data.class
AbstractEquiDistanceWithOffset<T extends DataContainer>
Abstract ancestor for filters that equi-distance the data.class
AbstractFastWavelet<T extends DataContainer>
Abstract ancestor for Wavelet filters based on the JSci library.class
AbstractFFT<T extends DataContainer>
Abstract ancestor for Fast Fourier Transform filters based on the JSci library.class
AbstractFilter<T extends DataContainer>
Abstract base class for filters.static class
AbstractFilter.FilterJob<T extends DataContainer>
A job class specific to Filters.class
AbstractHistogram<T extends DataContainer>
Ancestor for filters that generate a histogram from the incoming data.class
AbstractLOWESS<T extends DataContainer>
Abstract ancestor for LOWESS filters.class
AbstractPreFilter<T extends DataContainer>
Abstract ancestor for filters that use pre-filtered data as the basis for manipulating the original data.class
AbstractSavitzkyGolay<T extends DataContainer>
Abstract ancestor for Savitzky-Golay filters.class
AbstractSAX<T extends DataContainer>
Ancestor for SAX filters.class
AbstractScript
Ancestor for filter scripts.class
AbstractScriptedFilter
Abstract ancestor for filters that execute external scripts.class
AbstractSimpleSavitzkyGolay<T extends DataContainer>
Abstract ancestor for simple Savitzky-Golay filters.class
BaselineCorrection<T extends DataContainer>
A filter that runs a baseline correction scheme over the data.class
DownSample<T extends DataContainer>
A filter that returns only every n-th data point.class
DownSize<T extends DataContainer>
A filter that picks a specified number of evenly spaced data points from the data.class
Groovy
A filter that uses a Groovy script for processing the data.class
MultiFilter<T extends DataContainer>
A meta-filter that runs multiple filters over the data.class
OutlierDetector<T extends DataContainer>
A filter that runs an outlier detector over the data and attaches the generated detections as notes to the chromatogram.class
PassThrough<T extends DataContainer>
A dummy filter that just passes the data through.class
RemoveNoise<T extends DataContainer & Mergeable>
A filter that removes noise from the data with a user-supplied noise level algorithm.class
ReportFilter<T extends DataContainer>
A filter that modifies the reports of data containers being passed through.class
Scripted
A filter that uses any scripting handler for processing the data with a script located in the specified file.class
Smoothing<T extends DataContainer>
A filter that runs a smoothing scheme over the data.class
TimeseriesAutocorrelation
Performs autocorrelation on the timeseries.class
TimeseriesChangeResolution
Generates a new timeseries with a (user-defined) fixed-length interval between data points.class
TimeseriesDerivative
A filter for generating derivatives of timeseries data.class
TimeseriesEquiDistance
A filter for interpolating the values of a time series.class
TimeseriesFastWavelet
A filter that transforms the data with a wavelet.
For more information see:
(2009).class
TimeseriesFFT
A filter that transforms the data with Fast Fourier Transform.
For more information see:
Mark Hale (2009).class
TimeseriesHistogram
Generates a histogram from the timeseries.class
TimeseriesLOWESS
A filter that applies LOWESS smoothing.
For more information see:
WikiPedia.class
TimeseriesResetTimestamps
Resets the timestamps, makes them start at the specified date/time.class
TimeseriesRound
Rounds the values of the timeseries points.class
TimeseriesRowNorm
Row wise normalization.class
TimeseriesSavitzkyGolay
A filter that applies Savitzky-Golay smoothing.
For more information see:
A.class
TimeseriesSAX
Performs Symbolic Aggregate approXimation (SAX).
The data must be normalized using adams.data.filter.RowNorm beforehand.
For more information see:
Chiu, B., Keogh, E., Lonardi, S.class
TimeseriesSetStart
Sets the starting point of the timeseries to a new fixed timestamp and all other data points accordingly.class
TimeseriesShiftTimestamps
Shifts the timestamps of the timeseries by a calculated amount.
The amount is either the difference between the 'new' timestamp and a timestamp from the report or a supplied timestamp.
Accepted date formats (unless custom format specified):
yyyy-MM-dd HH:mm:ss
yyyy-MM-dd HH:mm:ss.S
yyyy-MM-dd
class
TimeseriesShiftValues
Shifts the values of the timeseries by the specified amount (up or down, depending on the sign).class
TimeseriesValueSubset
Generates a new timeseries with the first block of values that fits between the specified min/max (both included).class
TimeseriesWindow
Leaves only the specified window in the timeseries (borders included).
The matching can be inverted, i.e., everything but the window is returned. -
Uses of CleanUpHandler in adams.data.image
Subinterfaces of CleanUpHandler in adams.data.image Modifier and Type Interface Description interface
ImageTransformer<T extends AbstractImageContainer>
Abstract base class for AbstractImage transformations.Classes in adams.data.image that implement CleanUpHandler Modifier and Type Class Description class
AbstractImageFeatureGenerator<T extends AbstractImageContainer>
Abstract base class for AbstractImage feature generation.class
AbstractImageTransformer<T extends AbstractImageContainer>
Abstract base class for AbstractImage transformations. -
Uses of CleanUpHandler in adams.data.image.features
Classes in adams.data.image.features that implement CleanUpHandler Modifier and Type Class Description class
AbstractBufferedImageFeatureGenerator
Abstract base class for BufferedImage feature generators.class
AbstractCountColor
Ancestor for feature generators that count pixels based on color.class
AbstractScript
Ancestor for BufferedImage feature generator scripts.class
AbstractScriptedFeatureGenerator
Abstract ancestor for BufferedImage feature generator that execute external scripts.class
Barcode
Decodes any barcode in the image.class
BasicStatistics
Calculates min/max/mean/median/stdev for each channel (R,G,B).class
ColorCounts
Counts the occurrences of colors in the image (alpha channel gets ignored).class
CountColor
Counts the occurrences of a specific color (alpha channel gets ignored).class
CountColorOutside
class
Dimensions
Outputs the dimensions of the image: width, height, area, ratio.class
Eccentricity
Computes the eccentricity of the object.class
Entropy
Calculates the Shannon entropy of an image.
Original code taken from here:
http://stackoverflow.com/a/22280200
class
FilteredBufferedImageFeatureGenerator
Applies the filter (an image transformer) to the image first before generating the features from the transformed images.class
Histogram
Turns an image into a histogram.
In case of an 8-bit histogram, the image must already be converted to a gray image.
The number of bins per channel can be chosen as well (1-256).class
HusMoments
Calculates Hu's moments.class
Max
Simply outputs the RGB value of the brightest pixel.class
Min
Simply outputs the RGB value of the darkest pixel.class
Moment
Computes the specified moment.class
MultiBufferedImageFeatureGenerator
Applies multiple generators to the same image and merges the generated a feature vectors side-by-side.class
OrientationVector
Generates a vector thatclass
PixelClassifications
Generates a feature vector for each pixel classification that is stored in the image's report.
Pixel classifications are generated with the adams.flow.transformer.PixelSelector transformer, using the adams.flow.transformer.pixelselector.AddClassification action.
Automatically adds the classification label associated with a classification position in the report as a separate attribute.class
Pixels
Gets all the pixels of the image.class
Scripted
A feature generator that uses any scripting handler for processing the data with a script located in the specified file. -
Uses of CleanUpHandler in adams.data.image.transformer
Subinterfaces of CleanUpHandler in adams.data.image.transformer Modifier and Type Interface Description interface
ImageColorizer
Interface for image colorizers (only for making it easier to select them in the GUI).interface
ImageColorizerWithColorProvider
Interface for image colorizers that support a color provider.Classes in adams.data.image.transformer that implement CleanUpHandler Modifier and Type Class Description class
AbstractBufferedImageTransformer
Abstract base class for BufferedImage transformations.class
AbstractScript
Ancestor for JAI transformer scripts.class
AbstractScriptedTransformer
Abstract ancestor for transformers that execute external scripts.class
Binary
Turns an image into a binary image, using a grayscale threshold to determine which pixels are black (below) and which are white (equal to or above).class
BinaryMask
Generates a binary image from the input and uses this mask to determine which pixels get replaced by the specified replacement color.class
BlueChannelColorizer
Interprets the values in the blue channel (e.g., used by image segmentation frameworks) of the images as indices and replaces them with colors from the specified color provider.class
ChangeCanvasSize
Places the image on a canvas of specified size based on the anchor.class
Cropping
Crops the images passing through using the specified crop algorithm.class
DownSample
Generates a smaller image by taken every nth pixel (on the x and y axis).class
FixObjects
Ensures that no invalid object shapes are present in the report.class
GaussianBlur
Performs a gaussian blur.
Original code taken from here:
http://www.jhlabs.com/ip/blurring.html
Valid options are:class
GrayOrIndexedColorizer
Colorizes grayscale or indexed images using the specified color provider.
Other images types get converted to grayscale first.class
Grayscale
Generates a grayscale images using the specified luminance parameters.class
ImageFilter
Applies an ImageFilter to the buffered image.class
ImageType
Turns an image into the specified type of image.class
LaplaceOfGaussian
Applies the Laplacian of Gaussian (LoG) to the image, using the following formula
(x^2 + y^2 - 2*sigma^2) / sigma^4 * exp(-(x^2 +y^2) / (2*sigma^2)
For more information on LoG, see:
http://fourier.eng.hmc.edu/e161/lectures/gradient/node8.html
class
LaplaceOperator
Applies the Laplace operator, using the following matrix:
0 1 0
1 -4 1
0 1 0
For more information on the Laplace operator, see:
http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=laplacian#laplacian
class
LocalMedianFilter
TODO: what class does.class
MaxRGB
class
MinRGB
class
MinRGBOld
class
MultiTransformer
Applies the specified JAI transformers one after the other.class
ObjectAnnotationsMask
Only leaves pixels in the image that are covered by the object annotations (= masking).class
PassThrough
A dummy transform that just passes the image through.class
ReplaceColors
Allows replacing one color with another.class
ReplacePredominantColor
Allows replacing the predominant color with another.class
Resize
Resizes the image to predefined width and height.
For more information on the scaling types, see:
https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/Image.html
class
Scripted
An image transformer that uses any scripting handler for processing the data with a script located in the specified file.class
SplitChannels
Splits the image into the specified separate RGB channels.class
SplitChannelsHSV
Splits the image into the specified separate HSV channels.class
SplitChannelsYIQ
Splits the image into the specified separate YIQ channels.class
SplitChannelsYUV
Splits the image into the specified separate YUV channels.class
SubImages
Produces subimages from the input image using the specified generator.class
SuppliedImageMask
Masks out regions on the image using a supplied image from internal storage, making them transparent.class
ThresholdReplacement
Replaces pixels of the image that fall below or above (depending on configuration) a user defined threshold in the grayscale space with the supplied replacement color.
Can be replaced to remove dark or light splotches.class
TrimapColorizer
Colorizes trimap images using the specified color provider.class
WhiteBalance
Processes the images passing through using the specified white balance algorithm.class
XScreenMask
Masks out a color by making it transparent. -
Uses of CleanUpHandler in adams.data.instances
Classes in adams.data.instances that implement CleanUpHandler Modifier and Type Class Description class
AbstractInstanceGenerator<T extends DataContainer & ReportHandler>
Abstract base class for schemes that turn temperature profiles into weka.core.Instance objects. -
Uses of CleanUpHandler in adams.data.io.input
Classes in adams.data.io.input that implement CleanUpHandler Modifier and Type Class Description class
AbstractDataContainerReader<T extends DataContainer>
Abstract ancestor for readers that read files in various formats and turn them into data containers.class
AbstractReportReader<T extends Report>
Abstract ancestor for readers that read files in various formats and creates a reports.class
AbstractSimpleCSVReportReader<T extends Report>
Abstract ancestor for reports to be written in CSV format.class
AbstractSimpleJsonReportReader<T extends Report>
Abstract ancestor for reports to be written in CSV format.class
AbstractSimpleReportReader<T extends Report>
Abstract ancestor for reports to be written in properties format.class
AbstractTimeseriesReader
Ancestor for timeseries readers.class
CocoAnnotationsReportReader
Loads COCO annotations from the JSON file, with one report per image.
Handles only segmentations with polygons (not RLE) and only one polygon per annotation.class
DeepLabCutCSVReader
Reads point annotations into multiple reports from DeepLabCut's CSV format.class
DefaultSimpleCSVReportReader
Default implementation of a report reader of the simple CSV format.class
DefaultSimpleJsonReportReader
Default implementation of a report reader of the simple Json format.class
DefaultSimpleReportReader
Default implementation of a report reader of the simple format.class
DetectronAnnotationsReportReader
Interprets rectangle annotations present in Detectron annotations JSON file.class
ImageClassificationGridSpreadSheetReader
Turns grid cells in the spreadsheet with labels ('label=score') into object locations.
Spreadsheet format:
y,x,label1,label2,...
0,0,cat=0.98,,...
0,1,,,...
0,2,dog=0.9,cat=0.2,...class
ImageClassificationJsonReportReader
Retrieves the label with the highest score from the JSON file and stores them in a report.
JSON file format: { LABEL1: SCORE1; LABEL2: SCORE2; }
class
ImageClassificationSpreadSheetReportReader
Retrieves the label with the highest score from the spreadsheet and stores them in a report.class
InstanceReader
Reads WEKA datasets in various formats.class
ObjectLocationsSpreadSheetReader
Reads object locations from a spreadsheet into a report.
Top/left column is required.
Either right/bottom or width/height need to be supplied.
In addition, polygon coordinates (X and Y coordinates as comma-separated lists in two separate columns) can be read as well.
If the coordinates/dimensions represent normalized ones (ie 0-1), then specify the width/height of the image to relate them back to actual pixel-based sizes.class
OpexObjectLocationsReader
Reads object locations from JSON generated by the opex library.
See more:
https://github.com/WaikatoLink2020/objdet-predictions-exchange-format
class
PascalVOCObjectLocationsReader
Reads object locations in Pascal VOC format.
See more:
https://github.com/WaikatoLink2020/objdet-predictions-exchange-format
class
SimpleTimeseriesReader
Reader for the simple timeseries data format, CSV-like with preceding comments.class
SpreadSheetTimeseriesReader
Reads timeseries containers from columns of a spreadsheet.
A new container is started, whenever the value of the ID column changes (hence you need to ensure that the data is ordered on this column).
However, it is not required to have an ID column present.class
VggXmlAnnotationReportReader
Reads XML image annotation files, like used in the pets dataset:
http://www.robots.ox.ac.uk/~vgg/data/pets/
class
ViaAnnotationsReportReader
Interprets polygon annotations generated by VGG Image Annotator.
For more information, see:
http://www.robots.ox.ac.uk/~vgg/software/via/
class
YoloAnnotationsReportReader
Reads text files with YOLO object annotations, one object definition per line:
BBox format:
- format: <object-class> <x> <y> <width> <height>
- object-class: 0-based index
- x/y: normalized center of annotation
- width/height: normalized width/height
- Normalization uses image width/height
Polygon format:
- format: <object-class> <x0> <y0> <x1> <y1>...
- object-class: 0-based index
- x/y: normalized polygon point
-
Uses of CleanUpHandler in adams.data.io.output
Classes in adams.data.io.output that implement CleanUpHandler Modifier and Type Class Description class
AbstractDataContainerWriter<T extends DataContainer>
Abstract ancestor for writers that write data containers to files in various formats.class
AbstractMultiReportWriter<T extends Report>
Ancestor for report writers that write multiple reports into a single file.class
AbstractReportWriter<T extends Report>
Abstract ancestor for writers that write reports to files in various formats.class
AbstractSimpleCSVReportWriter<T extends Report>
Abstract ancestor for writing reports in CSV format.class
AbstractSimpleJsonReportWriter<T extends Report>
Abstract ancestor for writing reports in Json format.class
AbstractSimpleReportWriter<T extends Report>
Abstract ancestor for writing reports in properties format.class
AbstractTimeseriesWriter
Ancestor for timeseries writers.class
DeepLabCutCSVWriter
Writes point annotations from multiple reports in DeepLabCut's CSV format.
Expects the filename to be stored in the 'File' report field.class
DefaultSimpleCSVReportWriter
Default implementation of a report writer of the simple CSV format.class
DefaultSimpleJsonReportWriter
Default implementation of a report writer of the simple Json format.class
DefaultSimpleReportWriter
Default implementation of a report writer of the simple format.class
ObjectLocationsSpreadSheetWriter
class
OpexObjectLocationsWriter
Writes polygon annotations in VGG Image Annotator JSON format.
For more information, see:
http://www.robots.ox.ac.uk/~vgg/software/via/
class
SimpleTimeseriesWriter
Writer for the simply timeseries format, CSV-like with preceding comments.class
SpreadSheetTimeseriesWriter
Writes timeseries data using a spreadsheet writer.class
ViaAnnotationsReportWriter
Writes polygon annotations in VGG Image Annotator JSON format.
For more information, see:
http://www.robots.ox.ac.uk/~vgg/software/via/
class
YoloAnnotationsReportWriter
Writes text files with YOLO object annotations, one object definition per line:
BBox format:
- format: <object-class> <x> <y> <width> <height>
- object-class: 0-based index
- x/y: normalized center of annotation
- width/height: normalized width/height
- Normalization uses image width/height
Polygon format:
- format: <object-class> <x0> <y0> <x1> <y1>...
- object-class: 0-based index
- x/y: normalized polygon point
-
Uses of CleanUpHandler in adams.data.jai.features
Classes in adams.data.jai.features that implement CleanUpHandler Modifier and Type Class Description class
DFT
Performs discrete fourier transform (DFT).class
Histogram
Turns an image into a histogram.
In case of an 8-bit histogram, the image must already be converted to a gray image.
The number of bins per channel can be chosen as well (1-256). -
Uses of CleanUpHandler in adams.data.jai.transformer
Classes in adams.data.jai.transformer that implement CleanUpHandler Modifier and Type Class Description class
AbstractJAITransformer
Abstract base class for JAI transformations.class
AbstractScript
Ancestor for JAI transformer scripts.class
AbstractScriptedTransformer
Abstract ancestor for transformers that execute external scripts.class
Brightness
Brightens or darkens an image using the specified factor and offset.
factor: <0=darken image, >0=brighten image.class
ChangeOrientation
Ensures that the image has the specified orientation.class
Dilate
class
Erode
class
Flip
Flips an image.class
Gray8
Transforms the image into an 8-bit gray image.class
IndexedColors
Turns an RGB image into one with an indexed color palette.class
Invert
Inverts the image.class
Resize
Resizes the image to predefined width and height.class
Rotate
Rotates an image by a defined number of degrees.class
Scripted
An image transformer that uses any scripting handler for processing the data with a script located in the specified file. -
Uses of CleanUpHandler in adams.data.lire.features
Classes in adams.data.lire.features that implement CleanUpHandler Modifier and Type Class Description class
AutoColorCorrelogram
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.AutoColorCorrelogram.
For more information on the LIRE project, see:
http://www.lire-project.net/
For more information see:
Huang, J.; Kumar, S.class
BasicFeatures
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.BasicFeatures.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
BinaryPatternsPyramid
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.BinaryPatternsPyramid.
Works the same way as PHOG, but instead of measuring the orientation of gradients, this class uses a histogram of rotation-invariant local binary patterns.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
CEDD
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.CEDD.
For more information, see:
Savvas A.class
ColorLayout
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.ColorLayout.
For extracting & comparing MPEG-7 based CBIR descriptor ColorLayout.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
EdgeHistogram
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.EdgeHistogram.
Implements the EdgeHistogram descriptor from the MPEG-7 standard.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
FCTH
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.FCTH.
For more information, see:
Savvas A.class
FuzzyColorHistogram
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.FuzzyColorHistogram.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
FuzzyOpponentHistogram
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.FuzzyOpponentHistogram.
For more information, see:
van de Sande, K.E.A., Gevers, T., Snoek, C.G.M.class
Gabor
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.Gabor.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
JCD
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.JCD.
Joining CEDD and FCTH in one histogram.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
JointHistogram
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.joint.JointHistogram.
For more information, see:
Mathias Lux, Savvas A.class
JpegCoefficientHistogram
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.JpegCoefficientHistogram.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
LocalBinaryPatterns
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.LocalBinaryPatterns.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
LocalBinaryPatternsAndOpponent
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.joint.LocalBinaryPatternsAndOpponent.
For more information, see:
Mathias Lux, Savvas A.class
LuminanceLayout
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.LuminanceLayout.
Intended for grayscale or B/W images.class
OpponentHistogram
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.OpponentHistogram.
For more information, see:
van de Sande, K.E.A., Gevers, T., Snoek, C.G.M.class
PHOG
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.PHOG.
For more information, see:
Anna Bosch, Andrew Zisserman & Xavier Munoz: Representing shape with a spatial pyramid kernel.class
RankAndOpponent
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.joint.RankAndOpponent.
For more information, see:
Mathias Lux, Savvas A.class
RotationInvariantLocalBinaryPatterns
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.RotationInvariantLocalBinaryPatterns.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
ScalableColor
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.ScalableColor.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
SimpleCentrist
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.centrist.SimpleCentrist.
For more information, see:
Jianxin Wu; Rehg, J.M.class
SimpleColorHistogram
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.SimpleColorHistogram.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
SpatialPyramidAutoColorCorrelogram
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.spatialpyramid.SPACC.
For more information, see:
Mathias Lux, Savvas A.class
SpatialPyramidCEDD
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.spatialpyramid.SPCEDD.
For more information, see:
Savvas A.class
SpatialPyramidCentrist
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.centrist.SpatialPyramidCentrist.
For more information, see:
Jianxin Wu; Rehg, J.M.class
SpatialPyramidFCTH
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.spatialpyramid.SPFCTH.
For more information, see:
Savvas A.class
SpatialPyramidJCD
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.spatialpyramid.SPJCD.
Joining CEDD and FCTH in one histogram.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
SpatialPyramidLocalBinaryPatterns
Generates features using net.semanticmetadata.lire.imageanalysis.features.global.spatialpyramid.SPLBP.
For more information on the LIRE project, see:
http://www.lire-project.net/
class
Tamura
Generates features using net.semanticmetadata.lire.imageanalysis.Tamura.
For more information on the LIRE project, see:
http://www.lire-project.net/
-
Uses of CleanUpHandler in adams.data.noise
Classes in adams.data.noise that implement CleanUpHandler Modifier and Type Class Description class
AbstractDatabaseConnectionDenoiser<T extends DataContainer>
Ancestor for denoisers that require database access.class
AbstractDenoiser<T extends DataContainer>
An abstract super class for algorithms that remove noise from data.static class
AbstractDenoiser.DenoiserJob<T extends DataContainer>
A job class specific to denoisers.class
PassThrough
A dummy denoiser, which removes no noise at all. -
Uses of CleanUpHandler in adams.data.opencv.features
Classes in adams.data.opencv.features that implement CleanUpHandler Modifier and Type Class Description class
AbstractOpenCVFeatureGenerator
Abstract base class for OpenCV feature generators.class
AbstractScript
Ancestor for OpenCV feature generator scripts.class
AbstractScriptedFeatureGenerator
Abstract ancestor for OpenCV feature generator that execute external scripts.class
Histogram
Computes a histogram from the incoming image.class
MultiOpenCVFeatureGenerator
Applies multiple generators to the same image and merges the generate a feature vectors side-by-side.class
Otsu
Computes the threshold using Otsu's method
class
Scripted
A feature generator that uses any scripting handler for processing the data with a script located in the specified file. -
Uses of CleanUpHandler in adams.data.opencv.transformer
Classes in adams.data.opencv.transformer that implement CleanUpHandler Modifier and Type Class Description class
AbstractOpenCVTransformer
Abstract base class for OpenCV transformations.class
AbstractScript
Ancestor for OpenCV transformer scripts.class
AbstractScriptedTransformer
Abstract ancestor for transformers that execute external scripts.class
Blur
Blurs the image using the normalized box filter.
For more information see:
https://docs.opencv.org/4.6.0/d4/d86/group__imgproc__filter.html#ga8c45db9afe636703801b0b2e440fce37
class
ConvertType
Converts the image according to the conversion code.class
GaussianBlur
Applies Gaussian blur to the image.
For more information see:
https://docs.opencv.org/4.6.0/d4/d86/group__imgproc__filter.html#gaabe8c836e97159a9193fb0b11ac52cf1
class
MultiTransformer
Applies the specified OpenCV transformers one after the other.class
PassThrough
A dummy transform that just passes the image through.class
Resize
Resizes the image, either using absolute width/height or factors for x/y.class
Scripted
An image transformer that uses any scripting handler for processing the data with a script located in the specified file.class
SplitChannels
class
Threshold
Generates a binary image using the specified image. -
Uses of CleanUpHandler in adams.data.outlier
Subinterfaces of CleanUpHandler in adams.data.outlier Modifier and Type Interface Description interface
OutlierDetector<T extends DataContainer>
Interface for outlier detectors.interface
TrainableOutlierDetector<T extends DataContainer>
Interface for trainable outlier detectors.Classes in adams.data.outlier that implement CleanUpHandler Modifier and Type Class Description class
AbstractDatabaseConnectionOutlierDetector<T extends DataContainer>
Ancestor for outlier detectors that require a database connection.class
AbstractOutlierDetector<T extends DataContainer>
Abstract base class for outlier detectors.static class
AbstractOutlierDetector.DetectorJob<T extends DataContainer>
A job class specific to outlier detectors.class
AbstractScript
Ancestor for outlier detector scripts.class
AbstractScriptedOutlierDetector
Abstract ancestor for outlier detectors that execute external scripts.class
Excluded
Checks whether the 'Excluded' flag has been set in the report.class
FieldRequired
Checks whether the specified field is present in the report.class
FilteredOutlierDetector<T extends DataContainer>
A meta detector that first filters the data through a filter before pushing it through the base detector.class
Groovy
An outlier detector that uses a Groovy script for processing the data.class
MinMax
Detects data containers where a report value is too high/low.class
MultiOutlierDetector<T extends DataContainer>
A meta-detector that runs multiple outlier detectors over the data.class
PassThrough
A dummy detector that detects nothing.class
Scripted
An outlier detector that uses any scripting handler for processing the data with a script located in the specified file.class
StringMatcher
Checks whether the specified string field is available in the report and the value matches the specified regular expression.class
TargetRequired
Checks whether the specified target field is available in the report.class
TimeseriesMinPoints
Ensures that a minimum number of points in the timeseries have the specified minimum value.class
TimeseriesRange
Ensures that timeseries values lie within the defined range.class
TimeseriesTimestampCheck
Checks whether the timestamp with the specified index meets the condition (eg before or after the supplied timestamp). -
Uses of CleanUpHandler in adams.data.smoothing
Classes in adams.data.smoothing that implement CleanUpHandler Modifier and Type Class Description class
AbstractDatabaseConnectionSmoother<T extends DataContainer>
Ancestor for filters that require database access.class
AbstractLOWESSBased<T extends DataContainer>
Abstract ancestor for LOWESS-based smoothers.class
AbstractSavitzkyGolayBased<T extends DataContainer>
Abstract ancestor for Savitzky-Golay-based smoothers.class
AbstractSlidingWindow<T extends DataContainer>
Abstract sliding window smoother.class
AbstractSmoother<T extends DataContainer>
Abstract base class for smoothing schemes.static class
AbstractSmoother.SmootherJob<T extends DataContainer>
A job class specific to smoothing schemes.class
PassThrough
A dummy smoother that just passes the data through.class
TimeseriesLOWESSBased
A LOWESS based smoothing algorithm.
For more information on LOWESS see:
WikiPedia.class
TimeseriesSavitzkyGolayBased
A Savitzky-Golay based smoothing algorithm.
It uses a Savitzky-Golay filter with derivative order 0 and adding of mass-spec data turned on.
For more information on Savitzky-Golay see:
A.class
TimeseriesSlidingWindow
Uses a sliding window for determining the median/average inside the window. -
Uses of CleanUpHandler in adams.data.statistics
Classes in adams.data.statistics that implement CleanUpHandler Modifier and Type Class Description class
AbstractDataStatistic<T extends DataContainer>
A class for statistics about data.class
TimeseriesStatistic<T extends Timeseries>
Statistical information specific to a Timeseries. -
Uses of CleanUpHandler in adams.data.timeseries
Classes in adams.data.timeseries that implement CleanUpHandler Modifier and Type Class Description class
AbstractMetaTimeseriesFeatureGenerator
Ancestor for generators that use a base generator.class
AbstractTimeseriesFeatureGenerator<T extends Timeseries>
Abstract base class forTimeseries
feature generation.class
AddMetaData
Meta-generator that can add database ID and container ID.class
FixedNumFeatures
Meta-feature-generator that ensures that the generated output has a fixed number of data points.
In case of filler type FIRST, the data gets inserted at the start, as opposed to at the end when using LAST.
NUMERIC/STRING/BOOLEAN use the appropriate filler value that the user specified.
The MISSING_* types just add a missing value of the appropriate data type.class
Values
Simple feature generator that just outputs all the values of a timeseries. -
Uses of CleanUpHandler in adams.data.weka.evaluator
Classes in adams.data.weka.evaluator that implement CleanUpHandler Modifier and Type Class Description class
AbstractCrossvalidatedInstanceEvaluator<T extends AbstractCrossvalidatedInstanceEvaluator.EvaluationContainer>
Ancestor for evalutors that use cross-validation for initialization.class
AbstractDatasetInstanceEvaluator
Ancestor for evaluators that need a data set for initialization.class
AbstractInstanceEvaluator
Ancestor for evaluators that evaluate weka.core.Instance objects.class
IntervalEstimatorBased
Uses a classifier that produces confidence intervals.class
PassThrough
A dummy evaluator that OKs all data. -
Uses of CleanUpHandler in adams.flow.control
Subinterfaces of CleanUpHandler in adams.flow.control Modifier and Type Interface Description interface
AtomicExecution
Interface for actors that can be configured to finish execution first before attempting to be stopped.interface
FlowStructureModifier
Interface for actors that modify the flow structure somehow.interface
LocalScopeHandler
Interface for actor handlers that provide a local scope for their sub-actors.interface
ScopeHandler
For actors that define a scope like theFlow
orLocalScopeTrigger
actor.interface
StorageHandler
Interface for actors that allow the storing of temporary data.Classes in adams.flow.control that implement CleanUpHandler Modifier and Type Class Description class
AbstractConnectedControlActor
Ancestor for all actors that control (connected) sub-actors in some way.class
AbstractContainerUpdater
Ancestor for control actors that update a specific value of a container using the defined sub-actors.class
AbstractControlActor
Ancestor for all actors that control sub-actors in some way.class
AbstractDataContainerFileChecker<T extends DataContainer>
Abstract ancestor for transformers that check data container files whether they are consistents before passing on the file/file arrays.class
AbstractDirectedControlActor
Ancestor for all actors that control sub-actors in some way.class
AbstractDirector
Manages the execution of actors.class
AbstractTee
Abstract ancestor for actors that tee-off tokens.class
ArrayGenerate
Applies all sub-actors to the input token and generates an array from the collected output.
Each of the branches is expected to produce at most one output token (ideally one per branch, otherwise there will be null elements in the output array).class
ArrayProcess
Applies all sub-actors to each of the array elements.static class
ArrayProcess.ArrayElementJob
For processing a single array element.class
Block
Blocks the propagation of tokens if the condition evaluates to 'true', therefore acts like the 'continue' control statement.
In case of integer or double tokens that arrive at the input, these can be accessed in the expression via 'X'.
The following grammar is used for evaluating the boolean expressions (depends on the selected condition):
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| log ( expr )
| exp ( expr )
| sin ( expr )
| cos ( expr )
| tan ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] )
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
;
Notes:
- Variables are either all upper case letters (e.g., "ABC") or any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
Branch
Branches off the flow into several sub-branches, each being supplied with a copy of the same object being passed into this meta-actor.class
Breakpoint
Allows to pause the execution of the flow when this actor is reached and the condition evaluates to 'true'.class
CallableActorScreenshot
Takes a screenshot of a callable actor whenever a token passes through.
The screenshot can either be written to disk (and the input token is forwarded), or the screenshot is forwarded as adams.data.image.BufferedImageContainer (dropping the input token).class
Cast
Casts the incoming data to the specified classname.class
ClearCallableDisplay
Clears the referenced callable graphical actor whenever a token passes through.class
CloseCallableDisplay
Closes the referenced callable graphical actor whenever a token passes through.class
CollectionProcess
Applies all sub-actors to each of the collection elements.class
ConditionalSequence
The sequence gets only executed if the condition holds true.class
ConditionalSubProcess
Encapsulates a sequence of flow items.class
ConditionalTee
Tees off the tokens if the condition evaluates to 'true'.class
ConditionalTrigger
Executes the tee-actor whenever a token gets passed through.class
ContainerValuePicker
Picks a named value from any container object and tees it off.
With the 'switch-outputs' option it is possible to forward the named value and teeing off the container instead.
If 'ignore missing' is turned off, any value that cannot be found will generate an error logging message and, in case of switched outputs, an actual error.class
Count
Counts the number of tokens that pass through and meet the condition and tees off the current count every n-th token.class
DesktopScreenshot
Takes a screenshot of the desktop whenever a token passes through.class
FileProcessor
class
Flow
Container object for actors, used for executing a flow.class
ForceFlush
Forces all actors that implement adams.flow.core.FlushSupporter
See also:
adams.flow.sink.DumpFile
Input/output:
- accepts:
adams.flow.core.Unknown
- generates:
adams.flow.core.Unknown
class
FreeMemory
Attempts to free up memory of the sub-flow that it belongs to.
This actor is useful in case when sub-flows are only executed once, but still keep their data-structures and gobble up unnecessary memory.class
GC
Calls the garbage collector.class
HeapDump
Generates a heapdump and saves it to the specified file (with .hprof extension) whenever a token passes through.class
IfStorageValue
An If-Then-Else source actor for storage values.static class
IfStorageValue.IfStorageValueDirector
A specialized director for an IfStorageValue control actor.class
IfThenElse
Emulates an If-Then-Else construct.static class
IfThenElse.IfThenElseDirector
A specialized director for an AbstractIfThenElse control actor.class
Injector
Injects a string token into the token sequence.
The string can be inject before or after the current token.class
InputOutputListener
Listens to the input/output tokens of the sub-actors, sending them to callable actors.class
Inspect
Allows the user to inspect tokens with the specified viewer.
Inspection can be done interactively, allowing the user to drop tokens, or non-interactively, with the viewer updating whenever a token passes through.
Of course, this actor should only be used during development for debugging purposes as can slow down the execution significantly depending on how expensive the view generation is.class
JDeps
Runs jdeps on the classname arriving at the input.
The application's classpath is automatically added to the command-line if no classpath directories or jars are provided.
Classpath directories and jars get combined, but directories take precedence over jars.class
JMap
Runs jmap whenever a token gets passed through.class
LaunchTee
Launches the sub-flow in a separate thread each time a token arrives.
Internally, a adams.flow.control.LocalScopeTee is used to manage the scope and forward the token.class
LaunchTrigger
Launches the sub-flow in a separate thread each time a token arrives.
Internally, a adams.flow.control.LocalScopeTrigger is used to manage the scope.class
LoadBalancer
Runs the specified 'load actor' in as many separate threads as specified with the 'num-threads' parameter.
Always uses a copy of the variables.
NB: no callable transformer or sink allowed.class
LocalScopeSubProcess
Provides a local scope for the sub-actors.
It is possible to 'propagate' or 'leak' variables and storage items from within the local scope back to the output scope.class
LocalScopeTee
Executes the sub-actors whenever a token gets passed through, just like the adams.flow.control.Tee actor, but also provides its own scope for variables and internal storage.
It is possible to 'propagate' or 'leak' variables and storage items from within the local scope back to the output scope.class
LocalScopeTransformer
Provides a local scope for the sub-actors.
It is possible to 'propagate' or 'leak' variables and storage items from within the local scope back to the output scope.class
LocalScopeTrigger
Executes the sub-actors whenever a token gets passed through, just like the adams.flow.control.Trigger actor, but also provides its own scope for variables and internal storage.
It is possible to 'propagate' or 'leak' variables and storage items from within the local scope back to the output scope.class
MissionControl
Displays a control panel for pausing/resuming/stopping the flow.
Useful when executing flows from command-line with the flow runner, offering a minimal control interface.class
MutableConnectedControlActor
Abstract superclass for actors that allow their sub-actors to modified (adding, removing, editing).class
MutableControlActor
Abstract superclass for actors that allow their sub-actors to modified (adding, removing, editing).class
Once
Tees off a token only once to its sub-actors.
However, this can be reset when the monitored variable changes.class
PlotContainerUpdater
Applies all sub-actors to process either the selected value of the plot container.class
PlotProcessor
Applies the specified processing algorithm to the stream of plot containers passing through.class
RaiseError
Raises a java.lang.Error if the condition evaluates to 'true', using the provided error message.
See also:
adams.flow.control.TryCatch
Input/output:
- accepts:
adams.flow.core.Unknown
- generates:
adams.flow.core.Unknown
class
Rejector
Rejects data containers with errors attached.class
RemoteExecutionTrigger
Transfers the actors below itself, the specified storage items and variables using the specified connection for remote execution.
Uses the adams.scripting.command.flow.RemoteFlowExecution remote command behind the scenes.class
RemoveOutliers
Allows the user to interactively remove outliers.
You can toggle the 'outlier' state of individual points by left-clicking them.You can also toggle whole regions by selecting a polygon around them: use SHIFT+left-click to place vertices and SHIFT+right-click to finish the polygon.class
Sequence
Encapsulates a sequence of flow items.class
SequentialDirector
Manages the execution of actors in sequential order.class
SetContainerValue
Updates a single item in the container passing through, using either the data obtained from a callable actor or a storage item.
Using the 'force' option, additional meta-data can be stored in the container as well.class
SinkReset
Resets all sub-actors in case the monitored variable changed since the last execution.class
Sleep
Waits for a fixed amount of milliseconds.class
SourceReset
Resets all sub-actors in case the monitored variable changed since the last execution.class
Stop
Stops the execution of the flow when triggered.class
StorageValueSequence
After executing a sequence of actors, the stored item is forwarded in the flow.class
SubProcess
Encapsulates a sequence of flow items.static class
SubProcess.SubProcessDirector
A specialized director for the SubProcess actor.class
Switch
Emulates a Switch control statement.static class
Switch.SwitchDirector
A specialized director for the Switch control actor.class
Tee
Allows to tap into the flow and tee-off tokens.class
TimedSubProcess
Encapsulates a sequence of flow items.class
TimedTee
Allows to tap into the flow and tee-off tokens.
Times how long the sub-flow execution takes and sends the time in milli-seconds (as double) in a adams.flow.container.TimingContainer container to the specified callable actor.class
TimedTrigger
Executes the subs-actors whenever a token gets passed through.class
TransformerReset
Resets all sub-actors in case the monitored variable changed since the last execution.class
Trigger
Executes the tee-actor whenever a token gets passed through.class
TriggerEvent
Triggers the specified event.class
TriggerOnce
Triggers the sub-flow only once.
However, this can be reset when the monitored variable changes.class
TryCatch
Safe-guards the execution of the 'try' sequence of actors.class
UpdateCallableDisplay
Updates callable display actors that implement adams.flow.core.DataPlotUpdaterHandler.class
UpdateContainerValue
Applies all sub-actors to process the specified value of the container passing through.class
UpdateProperties
Updates the properties of the sub-actor using the values associated with the specfiied variables.class
WhileLoop
Emulates a while-loop. -
Uses of CleanUpHandler in adams.flow.control.plotprocessor
Classes in adams.flow.control.plotprocessor that implement CleanUpHandler Modifier and Type Class Description class
AbstractPlotProcessor
Ancestor for processors of plot containers.class
AbstractPlotProcessorWithBuffer<T>
Ancestor for post-processors that work on a buffer of plot containers.class
Expression
Applies a mathematical function to the data (separately for X and Y).
Values can be accessed using 'xN' and 'yN' with 'N' being the 1-based index in the current window.class
LOWESS
A processor that applies LOWESS smoothing.
For more information see:
WikiPedia.class
PassThrough
Dummy processor which never generates any new containers.class
SavitzkyGolay
A processor that applies SavitzkyGolay smoothing.
For more information see:
A.class
SimpleSavitzkyGolay
A processor that applies SimpleSavitzkyGolay smoothing.
For more information see:
A. -
Uses of CleanUpHandler in adams.flow.core
Subinterfaces of CleanUpHandler in adams.flow.core Modifier and Type Interface Description interface
Actor
Interface for actors.interface
ActorHandler
For actors that handle "sub-actors".interface
ActorReferenceHandler
Interface for actors that manage callable actors.interface
ActorWithConditionalEquivalent
Actors that have an conditional equivalent, i.e., one that implementsBooleanConditionSupporter
.interface
ActorWithTimedEquivalent
Actors that have a timed equivalent, i.e., one that implementsTimedActor
.interface
ArrayProvider
For actors that can output the items either as an array or one-by-one.interface
AutogeneratedActor
Indicator interface for actors that have been automatically generated.interface
AutomatableInteractiveActor
Interface for actors that interact with the user, but can also be automated, e.g., for testing purposes.interface
AutoStartSupporter
Interface for actors that support "auto-start" functionality.interface
ConnectionHandler
For actors that handle "sub-actors" that are connected.interface
ControlActor
Indicator interface for control actors.interface
DaemonEvent
Indicator interface for events that run in the background and will get executed when the Events actor gets executed.interface
DataInfoActor
Indicator interface for actors that produce information on data structures.interface
DisplayTypeSupporter
Interface for actors that allow how their graphical output is being displayed.interface
DryRunSupporter
Interface for actors that support dry runs.interface
DynamicInitializer
Interface for actors that can be initialized at runtime and files may not be present at startup time.interface
DynamicModelLoaderSupporter
Interface for classes that support model loading.interface
ErrorScopeRestrictor
Interface for actors that restrict the error scope.interface
Event
Indicator interface for actors that can be used with the Events standalone.interface
FixedNameActorHandler
Interface for actor handlers that use fixed names for their sub-actors, e.g., IfThenElse.interface
Flushable
Interface for actors that can be flushed, i.e., the execution stopped without actually stopping the actor.interface
FlushSupporter
Interface for actors that can be flushed.interface
InactiveActor
Indicator interface for actors that have been "put to sleep".interface
InputConsumer
Interface for flow actors that can process input tokens.interface
InteractiveActor
Interface for actors that interact with the user.interface
InteractiveActorWithCustomParentComponent
Interface for interactive actors that allow the selection of a custom parent component using a callable actor; instead of just using the outer dialog/frame.interface
KeyManagerFactoryProvider
Interface for actors that provide an instance to aKeyManagerFactory
.interface
LazySetupSupporter
Interface for actors that optionally perform aActor.setUp()
call first time they get executed.interface
MutableActorHandler
Interface for actors that allow to add/remove sub-actors as well.interface
OptionalOneTimeInitializer
Interface for actors that can be fixed to be only initialized once.interface
OptionalPasswordPrompt
Interface for actors that prompt the user to enter a password in case no password currently provided.interface
OptionalStopRestrictor
Interface for stop restrictors that can turn on/off stop restrictions.interface
OutputProducer
Interface for flow actors that generate output.interface
PauseStateHandler
Interface for actors that manage the pause state in some sense.interface
PropertiesUpdater
Interface for actors that update one or more properties of a Java object using variables.interface
PyroCall
Interface for Pyro4 method calls.interface
PyroInputConsumer
Interface for Pyro calls that can process input.interface
PyroOutputProducer
Interface for Pyro calls that generate output.interface
RemoteExecutionHandler
Interface for actors that manage remote execution.interface
RestorableActor
Interface for actors that can save their state to disk and restore it again next time they are run.interface
SortableActorHandler
Interface for actor handlers that can sort their child actors.interface
SSLContextProvider
Interface for actors that provide access to an instance ofSSLContext
.interface
StopModeSupporter
Interface for actors that support a specific stop mode.interface
StopRestrictor
Interface for actors that can limit the scope of theStop
control actor or other actors that can stop the execution.interface
SubFlowWrapUp
Interface for actors that can wrap-up (i.e., save memory) their sub-actors and, if need be, re-initialize again.interface
TimedActor
Interface for actors that time their execution and send the timing data to a callable actor.interface
TokenEventHandler
Interface for actors that supportTokenEvent
s and handleTokenListener
s.interface
TriggerableEvent
Indicator interface for events that can be triggered with the TriggerEvent actor.interface
TrustManagerFactoryProvider
Interface for actors that provide an instance to aTrustManagerFactory
.interface
WeakExternalActor
Indicator interface for weak external actor handlers, which are only used at design time and deactivated at runtime.Classes in adams.flow.core that implement CleanUpHandler Modifier and Type Class Description class
AbstractActor
Abstract base class for actors.class
AbstractBaseExternalActor
Ancestor of actors that load another actor from disk and execute it.class
AbstractCallableActor
Abstract ancestor for all actors that access callable actors.class
AbstractCallableActorPropertyUpdater
Abstract ancestor for actors that manipulate properties of callable actors, e.g., WEKA classes.class
AbstractCopyCallableActor
Ancestor for actors that use a copy of a callable actor.class
AbstractDisplay
Ancestor for actors that display stuff.class
AbstractExternalActor
Ancestor of actors that load another actor from disk and execute it.class
AbstractGroovyActor
Abstract ancestor for actors that execute Groovy scripts.class
AbstractIncludeExternalActor
Ancestor for actors that get replaced with the externally stored actor.class
AbstractPropertyUpdater
Abstract ancestor for actors that manipulate properties of objects.class
AbstractPyroCall
Ancestor for Pyro4 method calls.class
AbstractScriptedActor
Abstract ancestor for actors that execute external scripts.class
AbstractScriptingHandlerActor
Abstract ancestor for actors that execute external scripts using a scripting handler.class
AbstractTemplate
Abstract ancestor for all actors that use a template to generate the actual actor/sub-flow to be executed.class
FlowVariables
Enhanced variable management, which allows referencing callable actors in variable names ("@{callable:actorname}") in order to obtain output value of actor. -
Uses of CleanUpHandler in adams.flow.execution
Subinterfaces of CleanUpHandler in adams.flow.execution Modifier and Type Interface Description interface
FlowExecutionListener
Interface for classes that record flow execution events.interface
GraphicalFlowExecutionListener
Interface for listeners that supply graphical output in from of a panel.interface
TimedFlowExecutionListener
Interface for listeners that performs updates/etc at regular intervals.Classes in adams.flow.execution that implement CleanUpHandler Modifier and Type Class Description class
AbstractFlowExecutionListener
Ancestor for execution listeners.class
AbstractFlowExecutionListenerWithTable
Ancestor for graphical listeners that display their data in a table.class
AbstractGraphicalFlowExecutionListener
Ancestor for graphical listeners.class
AbstractTimedFlowExecutionListenerWithTable
Ancestor for listeners that use tables and update them at regular intervals.class
CurrentlyExecuted
Shows what actors are currently being executed.class
Debug
Allows the user to define breakpoints that suspend the execution of the flow, allowing the inspection of the current flow state.
Tokens can only inspected during 'preInput', 'preExecute' and 'postOutput' of Breakpoint control actors.class
ExecutionCounter
Counts how often an actor was executed.
The final counts can be written to a log file in CSV format.class
ExecutionLog
Generates a trace file with all activity logged, uses stdout when the log file is pointing to a directory.class
MultiListener
A meta-listener that executes all sub-listeners sequentially.class
NullListener
Dummy listener, does nothing.class
RemoteFlowListener
Listens on the specified port, returns the currently running flow setup.class
Time
Shows how much time actors are taking in their method calls (gets accumulated). -
Uses of CleanUpHandler in adams.flow.execution.debug
Classes in adams.flow.execution.debug that implement CleanUpHandler Modifier and Type Class Description class
BreakpointPanel
Panel for managing the breakpoints.class
ControlPanel
A little dialog for controlling the breakpoint. -
Uses of CleanUpHandler in adams.flow.setup
Classes in adams.flow.setup that implement CleanUpHandler Modifier and Type Class Description class
FlowSetupWorker
A specialized SwingWorker class for executing FlowSetups. -
Uses of CleanUpHandler in adams.flow.sink
Subinterfaces of CleanUpHandler in adams.flow.sink Modifier and Type Interface Description interface
DisplayPanel
Interface for panels that can be created from tokens.interface
DisplayPanelProvider
Interface for graphical sinks that can also generate a panel from scratch for a new token.interface
MergeableDisplayPanel<T extends MergeableDisplayPanel>
SpecializedDisplayPanel
that can be merged with another panel.interface
UpdateableDisplayPanel
Extends theDisplayPanel
interface to allow accessing a potentially updated input token.Classes in adams.flow.sink that implement CleanUpHandler Modifier and Type Class Description class
AbstractAppendableFileWriter
Ancestor for file writers that allow appending to the file instead of just replacing any existing files.class
AbstractComponentDisplayPanel
Ancestor for panels that can be created from tokens and supply the underlying component.class
AbstractDbSink
Ancestor for sinks that use the database.class
AbstractDisplay
Ancestor for actors that display stuff.class
AbstractDisplayPanel
Ancestor for panels that can be created from tokens.class
AbstractFileWriter
Ancestor for sinks that write to output files.class
AbstractGraphicalDisplay
Ancestor for actors that display stuff.class
AbstractGraphicsGenerator
Ancestor for actors that generate graphics of some kind.class
AbstractScript
Ancestor for sink script actors.class
AbstractSink
Ancestor for all flow items that function as sink.class
AbstractTextAndComponentDisplayPanel
Ancestor for panels that can be created from tokens and supply the underlying component or text.class
AbstractTextDisplayPanel
Ancestor for panels that can be created from tokens and supply the underlying text.class
AbstractTextualDisplay
Ancestor for actors that display textual stuff.class
AbstractWekaModelWriter
Ancestor for actors that serialize models.class
ActualVsPredictedPlot
Plots actual vs predicted columns obtained from a spreadsheet.class
ArrayDisplay
Displays the array elements in a single panel.class
AutogeneratedSink
Encapsulates a sequence of auto-generated actors.
Can be removed with the adams.flow.processor.RemoveAutogeneratedActors processor.class
BinaryFileWriter
Writes a byte array or adams.data.blob.BlobContainer to a binary file.class
BoxPlot
* Actor for displaying box plots.
*
* For more information, see:
* http://en.wikipedia.org/wiki/Box_plot *
Valid options are:class
Browser
Displays a URL in a webbrowser.
By default, the system's default browser is used.class
CallableSink
Lets a callable sink consume the input tokens.class
Canvas
General purpose drawing canvas.class
CloseInputStream
Closes the incoming input stream instance.
See also:
adams.flow.source.InputStreamGenerator
Input/output:
- accepts:
java.io.InputStream
class
CloseReader
Closes the incoming reader instance.
See also:
adams.flow.source.ReaderGenerator
Input/output:
- accepts:
java.io.Reader
class
Console
Non-graphical actor that outputs any object that arrives at its input port via the 'toString()' method on stdout.class
ContainerDisplay
Actor for displaying a spreadsheet.class
ControlChartPlot
Actor for generating control chart plots.
The plot needs to be initialized with a class adams.flow.container.ControlChartContainer.class
CopyCallableSink
Copies a callable sink to consume the tokens.class
Display
Actor that outputs any object that arrives at its input port via the 'toString()' method.class
DisplayPanelGrid
Sink that places a panel in the grid for each each arriving token.
Uses the user-defined panel provider for creating the panels.class
DisplayPanelManager
Actor that displays a 'history' of panels created by the selected panel provider.class
DOMDisplay
Displays a DOM node object as tree structure.class
DownloadFile
Downloads a file from a URL and saves it locally.
Also handles basic authentication when using URLs like this:
http://user:pass@domain.com/url
Input/output:
- accepts:
java.lang.String
java.net.URL
class
DumpFile
Actor that just dumps any input token into a separate line of the specified output file.class
EmailFileWriter
Actor that writes Email objects to files.class
EmailViewer
Actor for displaying an email object.class
EnQueue
Enqueues the incoming data in the specified queue in internal storage.class
Exec
Pipes the incoming data, after converting it using the provided conversion scheme, into the started process.class
ExternalSink
Sink that executes an external sink actor stored on disk.class
FileBrowser
Displays the file or directory with the system's file browser.class
FilePreview
Actor for previewing file contents.static class
FilePreview.FilePreviewDisplayPanel
CustomDisplayPanel
.class
FlowDisplay
Displays an actor or flow.class
FlowFileWriter
Writes the incoming actor(s) to a file.
A custom flow writer can be specified.class
FourInOneDisplay
Actor for displaying a four-in-one plot.class
Groovy
A sink that uses a Groovy script for processing the token(s).class
Histogram
Generates a histogram based on the incoming data.class
HistoryDisplay
Actor that outputs any object that arrives at its input port via the 'toString()' method in a separate 'history' entry.class
Html4Display
Viewer for HTML 4.class
ImageFileWriter
Writes the image to disk using the specified writer.class
ImageHistogram
Displays a histogram of a gray image or histograms per channel for color image.class
ImageSegmentationFileWriter
Write image segmentation containers using the specified writer.class
ImageSegmentationViewer
Displays image segmentation containers.static class
ImageSegmentationViewer.ImageSegmentationViewerDisplayPanel
CustomDisplayPanel
.class
ImageViewer
Actor for displaying an image.static class
ImageViewer.ImageViewerDisplayPanel
CustomDisplayPanel
.class
InactiveSink
Encapsulates a sequence of inactive actors.
Can be removed with the adams.flow.processor.ReactivateActors processor.class
IncludeExternalSink
Includes an external sink.class
IndexedSplitsRunsWriter
Reads indexed splits runs from disk using the specified writer.class
InformationDialog
Displays the incoming message in a message box.class
JavaLogging
Uses the Java logging framework to output the incoming data.
Simply uses an object's 'toString()' method.class
JFreeChartFileWriter
Generates a JFreeChart plot and writes the bitmap to a file.class
JFreeChartPlot
Generates and displays a plot using JFreeChart.class
JsonDisplay
Displays a JSON object as tree structure.class
JsonFileWriter
Writes a JSON object/array to a file.class
LargeObjectDbWriter
Allows storing large objects in a SQL database.class
LogDumper
Actor that stores LogEntry objects in a file (CSV format).class
Logger
Actor that stores LogEntry objects in the Log table.class
LogViewer
Actor that displays LogEntry objects, but doesn't store them in the database.class
Mat5FileWriter
Writes the Mat5File object to the specified file.class
MatrixPlot
Actor for displaying a matrix of scatter plots
Valid options are:class
MenuItem
Launches a menu item from the main menu.class
MergeFiles
Combines the incoming files in a single one.class
NotesWriter
Saves the notes attached to a data structure to a text file.class
Null
Actor that gobbles up all tokens, like '/dev/null' in Unix.class
ObjectPreview
Actor for previewing file contents.static class
ObjectPreview.FilePreviewDisplayPanel
CustomDisplayPanel
.class
ObjectViewer
Allows to inspect any object using ADAMS' inspection capabilities.class
OpenFile
Opens the incoming file with the appropriate platform-specific application.
Does nothing in a headless (non-graphical) environment.class
PasteFiles
Generates a single file from combined lines from the input files.class
PDFCloseDocument
Closes the incoming PDF document, writing out its content.
The PDF document can be generated with adams.flow.source.PDFNewDocument and appended using adams.flow.transformer.PDFAppendDocument.
See also:
adams.flow.source.PDFNewDocument
adams.flow.transformer.PDFAppendDocument
Input/output:
- accepts:
adams.flow.transformer.pdfproclet.PDFGenerator
class
PDFViewer
Actor for displaying PDF files.class
PlotContainerSink
Actor that outputs the plot containers in various formats.class
ProbabilityPlotDisplay
Actor for displaying a probability plot
Valid options are:class
ProgrammaticSink
For programmatically hooking into a flow and receive tokens.class
ProgressBar
Displays a progress bar.class
PropertiesDisplay
Displays a Properties object as table.class
PropertiesFileWriter
Writes a Java properties object to a file.class
Publish
Publishes the incoming data using the specified publish/subscribe handler in storage.class
PyroSink
Consumes data using a Pyro4 call.
For more information see:
https://pythonhosted.org/Pyro4/
https://github.com/irmen/Pyrolite
Input/output:
- accepts:
java.lang.Object
class
RemoteCommandWriter
Sends a command to the remote host defined by the connection settings.
Unsuccessful commands can be store on disk to retry later.class
ReportDisplay
Displays reports.class
ScatterDisplay
Actor for displaying a scatter plot of one attribute vs another.class
Screenshot
Actor that takes screenshots of graphical components.class
Scripted
A sink that uses an exterrnal script for processing the token(s).class
SendEmail
Actor for sending emails.class
SendNotification
Sends the incoming message string via the configured notification scheme.class
SendRemoteCommand
Sends a command to the remote host defined by the connection settings.
Unsuccessful commands can be store on disk to retry later.class
SequencePlotter
Actor that plots sequences over time.
See also:
adams.flow.sink.SimplePlot
Input/output:
- accepts:
adams.flow.container.SequencePlotterContainer
adams.flow.container.SequencePlotterContainer[]
Container information:
- adams.flow.container.SequencePlotterContainer: PlotName, X, Y, Content type, Error X, Error Y, MetaData
class
Serialize
Saves a Java object to a file using the specified object writer.class
SideBySideDiff
Actor for displaying a side-by-side diff.class
SimpleLogging
Turns the incoming objects into strings, formats them with the selected formatter and then outputs them with the specified output(s).class
SimplePlot
Actor for generating simple plots.
See also:
adams.flow.sink.SequencePlotter
Input/output:
- accepts:
adams.flow.container.SequencePlotterContainer
adams.flow.container.SequencePlotterContainer[]
Container information:
- adams.flow.container.SequencePlotterContainer: PlotName, X, Y, Content type, Error X, Error Y, MetaData
class
Socket
Just outputs the data to the specified socket.
Any incoming data that isn't a byte array gets converted to a string and its bytes (using the specified encoding) are then transmitted.
See also:
adams.flow.source.Socket
Input/output:
- accepts:
java.lang.Object
byte[]
java.lang.Byte[]
class
SpreadSheetDbWriter
Transfers a SpreadSheet object into a database.class
SpreadSheetDisplay
Actor for displaying a spreadsheet.
Custom background for negative/positive values can be specified as well.static class
SpreadSheetDisplay.SpreadSheetDisplayPanel
CustomDisplayPanel
.class
SpreadSheetFileWriter
Actor that writes SpreadSheet objects to files.class
SpreadSheetRowViewer
Actor for displaying spreadsheet rows in a graphical way, like the 'Spreadsheet Explorer' tool.class
StringTree
Generates a tree from the strings arriving at the input, splitting them into parts using the specified separator.class
TemplateSink
Lets a sink generated from a template consume the input tokens.class
TextWriter
Writes incoming textual data to a text file.class
TimeseriesDisplay
Actor that displays timeseries.protected class
TimeseriesDisplay.DisplayPanel
Panel to be used inDisplayPanelManager
sink.class
WebSocketClient
Sends the incoming data to a websocket server and forwards the received data.class
WekaAttributeSummary
Displays an attribute summary.class
WekaClassifierErrors
Actor for displaying classifier errors.class
WekaCostBenefitAnalysis
Actor for displaying a cost benefit analysis dialog.class
WekaCostCurve
Actor for displaying a cost curve.class
WekaDatabaseWriter
Actor for saving a weka.core.Instances object in a database.
The relation name of the incoming dataset can be used to replace the current filename (path and extension are kept).class
WekaExperimentFileWriter
Saves an experiment file.class
WekaExperimentGenerator
Generates an experiment setup that can be used in conjunction with the Experiment transformer actor.class
WekaFileWriter
Actor for saving a weka.core.Instances object as file.
The relation name of the incoming dataset can be used to replace the current filename (path and extension are kept).class
WekaGraphVisualizer
Displays BayesNet graphs in XML or BIF notation
Either displays the contents of a file or an object that implements weka.core.Drawable and generates a BayesNet graph.class
WekaInstancesDisplay
Actor for displaying a weka.core.Instances object in table format.class
WekaInstancesPlot
Actor for plotting one attribute vs another.class
WekaInstanceViewer
Actor for displaying adams.data.instance.Instance objects in a graphical way (using the internal format), like the 'Instance Explorer' tool.class
WekaMarginCurve
Actor for displaying margin errors.class
WekaModelWriter
Actor for saving a model (classifier or clusterer) alongside an optional header (i.e., weka.core.Instances object) as file.class
WekaThresholdCurve
Actor for displaying threshold curves, like ROC or precision/recall.class
WekaTreeVisualizer
Displays trees in dot notation.class
XMLFileWriter
Writes a org.w3c.dom.Document to an XML file.
In case of org.w3c.dom.Node objects, the owning document is written to disk.class
YamlFileWriter
Writes a Map object to a YAML file.
http://yaml.org/
Input/output:
- accepts:
java.util.Map
java.util.List
class
ZScoreDisplay
Actor for displaying a z score plot
Valid options are: -
Uses of CleanUpHandler in adams.flow.sink.pyrosink
Classes in adams.flow.sink.pyrosink that implement CleanUpHandler Modifier and Type Class Description class
AbstractPyroSink
Ancestor for Pyro calls that consume data but don't produce any output.class
Generic
Generic call, just forwards any data to the remote object.class
Null
Dummy, does nothing. -
Uses of CleanUpHandler in adams.flow.sink.sequenceplotter
Classes in adams.flow.sink.sequenceplotter that implement CleanUpHandler Modifier and Type Class Description class
ErrorCircleHitDetector
Detects selections of error circles.class
ErrorCrossHitDetector
Detects selections of error crosses.class
SequencePlotterPanel
The panel that plots all the sequences. -
Uses of CleanUpHandler in adams.flow.source
Subinterfaces of CleanUpHandler in adams.flow.source Modifier and Type Interface Description interface
ConditionalIdSupplier
Interface for ID suppliers that use a conditions object.Classes in adams.flow.source that implement CleanUpHandler Modifier and Type Class Description class
AbstractArrayProvider
Ancestor for source actors that can output items one by one or as a single array.class
AbstractBufferingSource
Ancestor for queues that need to buffer output from eg another process.class
AbstractConditionalIdSupplier
Abstract ancestor for ID suppliers that use a conditions object.class
AbstractDatabaseIdSupplier
Abstract ancestor for ID suppliers.class
AbstractDatabaseMetaData
Ancestor for sources that output the database meta-data.class
AbstractDbArrayProvider
Ancestor for array providers that use the database.class
AbstractDbSource
Ancestor for sources that access the database..class
AbstractForLoop
Abstract ancestor for for-loops.class
AbstractIdSupplier
Abstract ancestor for ID suppliers.class
AbstractInstrumentSupplier
Abstract ancestor for instrument suppliers.class
AbstractInteractiveArrayProvider
Ancestor for interactive sources that can provide the output as an array or one-by-one.class
AbstractInteractiveSource
Ancestor for source actors that interact with the user.class
AbstractListTables
Ancestor for sources that list tables from a database.class
AbstractPythonExecution
Ancestor for sources that execute a Python executable.class
AbstractScript
Ancestor for source script actors.class
AbstractSelectObjects
Ancestor for sources that promp the user to select a number of objects to be broadcasted as tokens.class
AbstractSimpleDbSource
Ancestor for simple sources that use the database.class
AbstractSimpleSource
Ancestor for sources that just output a single token.class
AbstractSimpleSourceWithPropertiesUpdating
Ancestor for simple sources that allow changing the object's properties using variables.class
AbstractSource
Ancestor of all flow items that act as sources of tokens.class
AbstractSpreadSheetDbReader
Ancestor for spreadsheet database readers.class
AbstractWekaSetupGenerator<T>
Abstract ancestor for setup generator sources.class
AutogeneratedSource
Encapsulates a sequence of auto-generated actors, with the last one generating the output for this meta-source.
Can be removed with the adams.flow.processor.RemoveAutogeneratedActors processor.class
CallableSource
Broadcasts the generated output tokens from the source.class
ColorProvider
Uses the configured color provider to generate a number of colors.class
CombineArrays
Combines the storage items representing arrays into a single array.
When not supplying an array class the type of the first array is used.class
CombineCollections
class
CombineStorage
Outputs the expanded string generated from the specified combination expression (variables and storage placeholders).class
CombineVariables
Outputs the expanded string generated from the specified combination expression.class
Command
Runs an external system command and broadcasts the generated output (stdout and/or stderr) continuously, opposed to adams.flow.source.Exec which waits for the command to finish.
See also:
adams.flow.source.Exec
Input/output:
- generates:
java.lang.String
class
CopyCallableSource
Broadcasts the generated output tokens from the copied callable source.class
Counter
Outputs the specified counter as spreadsheet, with two columns: 'Key' and 'Count'.class
CurrentFlow
Outputs the current flow, i.e., itself.class
CurrentTime
class
DatabaseMetaData
Outputs the meta-data of the current database connection.class
DeQueue
Polls the specified queue in internal storage for an item, blocks till an item is available.
NB: The user needs to stop the flow as the DeQueue source will never stop, as it assumes that there will be more data coming through.class
DirectoryLister
Returns the contents of a directory (files/dirs).class
DirectorySupplier
Supplies directories.class
DumpStorage
Outputs the storage names and the string representation of their associated values in the specified format.class
DumpVariables
Outputs the variable names and their associated values in the specified format.class
EnterManyValues
Pops up a dialog, prompting the user to enter one or more values.class
EnterValue
Pops up a dialog, prompting the user to enter a value.class
Exec
Runs an external system command and broadcasts the generated output (stdout or stderr).
See also:
adams.flow.source.Exec
Input/output:
- generates:
java.lang.String
class
ExternalSource
Source that executes an external source actor stored on disk.class
FilenameGenerator
Uses the specified filename generator to output a filename.
NB: Generators that require an object to pass through won't work with this source.
See also:
adams.flow.transformer.FilenameGenerator
Input/output:
- generates:
java.lang.String
class
FileSupplier
Supplies files.class
FileSystemSearch
Uses the specified search algorithm to perform a file system search and returns the located items.class
ForLoop
Emulates the following for-loop for integer IDs:
- positive step size:
for (int i = lower; i <= upper; i += step)
- negative step size:
for (int i = upper; i >= lower; i += step)
The integers can be output as a single array as well.class
FTPLister
Deprecated.class
GetEnvironmentVariable
Outputs the value of the specified environment variable.class
GetSystemProperty
Outputs the value of the specified Java system property.class
Groovy
A source that uses a Groovy script for generating the token(s).class
HashSet
Outputs the specified hashset as spreadsheet, with one column called 'Value' by default.class
HttpRequest
Submits the (optional) form parameters to the specified URL and forwards the retrieved HTML as text.
Cookies can be retrieved and stored in internal storage, to be re-used with the next request.class
Idle
Simulates an endless loop, which only exits if the flow is stopped.
Essentially blocking any following actors, never outputs anything.class
InactiveSource
Encapsulates a sequence of flow items, with the last one generating the output for this meta-source.
Can be removed with the adams.flow.processor.ReactivateActors processor.class
IncludeExternalSource
Includes an external source.class
InputStreamGenerator
Uses the specified generator to instantiate an input stream instance.
See also:
adams.flow.sink.CloseInputStream
Input/output:
- generates:
java.io.InputStream
class
IntegerRange
Outputs the integers defined by the range expression.class
LargeObjectDbReader
Allows reading of large objects from a SQL database.class
ListCallableActors
class
ListEnvironmentVariables
Outputs the names of the currently set environment variables.class
ListStorageNames
Outputs the names of the currently available storage items.class
ListSystemProperties
Outputs the names of the currently set Java system properties.class
ListTables
Lists tables of the current database connection.class
ListVariables
Outputs the names of the currently available variables.class
LookUp
Forwards the value associated with the given key, using the specified lookup table from internal storage.class
LookUpTable
Outputs the specified lookup table as spreadsheet, containing to columns: Key with the keys and Value with the associated values.class
MakeContainer
Assembles a container with data obtained from either callable actors or storage items.class
MathExpression
Evaluates a mathematical expression.
Variables are supported as well, e.g.: pow(X,@{exp}) with '@{exp}' being a variable available at execution time.
The following grammar is used for the expressions:
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
| isNaN ( expr )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] )
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
;
Notes:
- Variables are either all upper case letters (e.g., "ABC") or any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'.
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
MemoryUsage
Outputs the memory usage.
The generated map has the following keys:
- init_heap
- max_heap
- used_heap
- committed_heap
- init_non_heap
- max_non_heap
- used_non_heap
- committed_non_heap
Input/output:
- generates:
java.util.Map
class
ModuleInfo
Outputs a spreadsheet with information about modules available.class
NewArray
Generates a new array of the specified class with the given dimensions.
Dimensions are given as follows: [x], with x being the number of elements.class
NewCollection
Generates a new (and empty) collection of the specified type.class
NewDOMDocument
Creates a new DOM document, e.g., for assembling XML files.class
NewFlow
Outputs the flow generated by the specified template.class
NewImage
Generates an empty image with the specified dimensions (Type: RGB or ARBG).class
NewJsonStructure
Generates an empty JSON data structure of the specified type.class
NewList
Generates a list string based on the items produced by the generator and the specified separator.class
NewMap
Generates a new java.util.Map object using the specified implementation class.class
NewMat5File
Creates an empty Mat5File object.class
NewMat5Matrix
Creates a new Matlab matrix.class
NewMat5Struct
class
NewProperties
Generates a new Properties object.class
NewRemoteCommand
Configures and forwards a remote command.class
NewReport
Generates a new instance of the specified report class.class
NewSpreadSheet
Generates an empty spreadsheet.class
NewTempFile
class
Null
Dummy source, generates no output.class
OpenCVDeviceFrameGrabber
Grabs frames from the specified device and forwards them as image containers.class
OptionProducer
Generates string output from the current flow using the specified option producer.class
OptionTraverser
Traverses the options of the flow at run-time.
Used for debugging purposes.class
PasteFromClipboard
Pops up a dialog, prompting the user to accept content from clipboard.class
PDFNewDocument
Creates an empty PDF document.
Needs to be finalized with adams.flow.sink.PDFCloseDocument.
The output of this source can be processed by adams.flow.transformer.PDFAppendDocument.
See also:
adams.flow.transformer.PDFAppendDocument
adams.flow.sink.PDFCloseDocument
Input/output:
- generates:
adams.flow.transformer.pdfproclet.PDFGenerator
class
PipExec
Executes pip with the specified options and broadcasts the generated output (stdout and/or stderr) continuously.class
PyroSource
Generates data using a Pyro4 call
For more information see:
https://pythonhosted.org/Pyro4/
https://github.com/irmen/Pyrolite
Input/output:
- generates:
java.lang.Object
class
PythonExec
Executes the specified Python script with the specified options and broadcasts the generated output (stdout and/or stderr) continuously.class
PythonVenvExec
Executes the specified executable in a Python virtual environment with the specified options and broadcasts the generated output (stdout and/or stderr) continuously.
Fails if the specified environment does not contain any 'activate' scripts typically found in such directories.class
RandomNumberGenerator
Random number generator.class
ReaderGenerator
Uses the specified generator to instantiate a reader instance.
See also:
adams.flow.sink.CloseReader
Input/output:
- generates:
java.io.InputStream
class
RSync
Supports synchronization using rsync.
In case of an error, the stderr output is forwarded, otherwise stdout output.class
Rsync4jRsyncBinary
Outputs the rsync binary used by the rsync4j library.class
Rsync4jSshBinary
Outputs the ssh binary used by the rsync4j library.class
Scripted
A source that uses an external script for generating the token(s).class
SelectCharset
Prompts the user to select a character set.class
SelectDateTime
Pops up a dialog, prompting the user to select a date/time, date or time value.class
SelectDirectory
Pops up a directory chooser dialog, prompting the user to select a directory.class
SelectFile
Pops up a file chooser dialog, prompting the user to select one or more files.class
SelectObjects
Allows the user to select an arbitrary number of objects from the specified class hierarchy using the GenericObjectArray.
It is possible to use this dialog for other objects as well that don't belong to a class hierarchy, e.g., adams.core.base.BaseString.class
SequenceSource
Encapsulates a sequence of flow items, with the last one generating the output for this meta-source.static class
SequenceSource.SequenceSourceDirector
A specialized director for the SequenceSource actor.class
SimpleRSync
An rsync wrapper with a reduced set of options.class
Socket
Listens on the specified port for incoming data.
Can either output raw byte arrays or strings (using the specified encoding).
See also:
adams.flow.sink.Socket
Input/output:
- generates:
byte[]
class
SpecifiedActor
Outputs the actor identified by the actor path.class
SpreadSheetDbReader
Returns a spreadsheet object generated from an SQL query.
To optimize memory consumption, you can return the result of the query in chunks of a specified size.class
SQLIdSupplier
Executes an SQL statement for generating the IDs.
Variables are automatically expanded.class
SSHExec
Runs a system command via ssh on a remote machine and broadcasts the generated output (stdout or stderr).
For more information see:
(2011).class
Start
Outputs merely a NullToken.class
StorageForLoop
Emulates the following for-loop:
- positive step size:
for (int i = lower; i <= upper; i += step)
- negative step size:
for (int i = upper; i >= lower; i += step)
In each iteration, the specified variable gets updated with the current value of the for-loop variable.class
StorageValue
Outputs the value associated with the specified name from temporary storage.
Does nothing if the storage value isn't present.
By supplying a cache name, the value can be obtained from a LRU cache instead of the regular storage.class
StorageValuesArray
Outputs the values associated with the specified names from temporary storage as an array.class
StringConstants
A source for strings.class
StringExpression
Evaluates a string expression.
Variables are supported as well, e.g.: pow(X,@{exp}) with '@{exp}' being a variable available at execution time.
The following grammar is used for the expressions:
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
| isNaN ( expr )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] )
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
# array functions
| len[gth] ( array )
| get ( array , index )
;
Notes:
- Variables are either all upper case letters (e.g., "ABC") or any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- 'index' for function 'get' starts at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
SwitchedSource
class
TemplateSource
Broadcasts the generated output tokens from the (template) source.class
TimeseriesDbReader
Outputs timeseries containers generated from an SQL SELECT statement.
A new container is started, whenever the value of the ID column changes (hence you need to ensure that the data is ordered on this column).class
URLSupplier
Supplies multiple URLs (uniform resource locators).class
Variable
Outputs the string value of the specified variable.
Does nothing if the variable hasn't been set.class
VariablesArray
Outputs the values associated with the specified variable names as a string array.class
WekaAssociatorSetup
Outputs an instance of the specified associator.class
WekaClassifierGenerator
Generates multiple classifier setups.class
WekaClassifierSetup
Outputs an instance of the specified classifier.class
WekaClustererGenerator
Generates multiple clusterer setups.class
WekaClustererSetup
Outputs an instance of the specified clusterer.class
WekaDatabaseReader
Executes a query and returns the data either in batch or incremental mode.class
WekaDataGenerator
Generates artificial data using a Weka data generator.class
WekaFilterGenerator
Generates multiple filter setups.class
WekaForecasterSetup
Outputs a configured instance of a Weka Forecaster.class
WekaForecasting
Uses a serialized model to perform predictions on the data being passed through.
The model can also be obtained from a callable actor, if the model file is pointing to a directory.class
WekaNewExperiment
Generates a new ADAMS experiment setup.class
WekaNewInstances
Generates an empty dataset, based on the attribute types and names specified.
Nominal attributes are generated with an empty set of labels.class
WekaPackageManagerAction
Executes the specified action and forwards the generated output.class
WekaSelectDataset
Pops up a file chooser dialog, prompting the user to select one or more datasets.class
WekaSelectObjects
Allows the user to select an arbitrary number of Weka objects from the specified class hierarchy using the GenericObjectArray.class
ZipArrays
Aligns the corresponding elements of the storage arrays into row-based arrays. -
Uses of CleanUpHandler in adams.flow.source.pyrosource
Classes in adams.flow.source.pyrosource that implement CleanUpHandler Modifier and Type Class Description class
AbstractPyroSource
Ancestor for Pyro calls that generate output.class
Generic
Generic call, just retrieves any data from the remote object.class
Null
Dummy, outputs nothing. -
Uses of CleanUpHandler in adams.flow.standalone
Subinterfaces of CleanUpHandler in adams.flow.standalone Modifier and Type Interface Description interface
AbstractDatabaseConnectionProvider
Interface for database connection providers.interface
DatabaseConnectionProvider
Interface for database connection providers.interface
StandaloneGroup<T extends Actor>
Interface for a group of standalones.interface
StandaloneGroupItem<T extends Actor>
The element of a standalone group.interface
StandaloneMutableGroup<T extends Actor>
Interface for a mutable group of standalones.Classes in adams.flow.standalone that implement CleanUpHandler Modifier and Type Class Description class
AbstractCallableDatabaseConnection
Ancestor for callable database connection standalones.class
AbstractDatabaseCheck
Ancestor for standalone actors that check project-specific database connections.class
AbstractDatabaseConnection
Ancestor for standalone actors providing a database connection different from the system-wide one.class
AbstractDbStandalone
Ancestor for standalones that use the database.class
AbstractMultiView
Ancestor for graphical actors that display multiple views.static class
AbstractMultiView.ViewWrapper
A wrapper for the actual actors.class
AbstractMutableActorDaemonEvent<E,P>
Ancestor for daemon events that handle sub-actors.class
AbstractMutableStandaloneGroupItem<T extends Actor>
Ancestor for group items that can contain other actors.class
AbstractScript
Ancestor for singleton script actors.class
AbstractStandalone
Ancestor for all flow items that neither generate nor process tokens.class
AbstractStandaloneGroup<T extends Actor>
Ancestor for fixed-sized groups.class
AbstractStandaloneGroupItem<T extends StandaloneGroup>
Ancestor of a standalone group item.class
AbstractStandaloneGroupItemGroup<S extends Actor,E extends Actor>
Ancestor for group items that form a group themselves.class
AbstractStandaloneGroupItemMutableGroup<S extends Actor,E extends Actor>
Ancestor for group items that form a group themselves.class
AbstractStandaloneMutableGroup<T extends Actor>
Ancestor for mutable groups of standalones.class
AutogeneratedStandalone
Container for auto-generated standalone actors.
Can be removed with the adams.flow.processor.RemoveAutogeneratedActors processor.class
CallableActors
Container for actors that need to be accessed via their name.static class
CallableActors.CallableActorsDirector
Dummy director.class
CallableDatabaseConnection
References a database connection provider of type adams.flow.standalone.DatabaseConnectionProvider.class
ConditionalStandalones
Executes the sub-actors only when the boolean condition evaluates to 'true'.class
ConsoleWindow
Displays the messages that are output in the system's 'Console window'.class
CopyCallableStandalone
Executes the copied callable standalone.class
CounterInit
Creates an empty counter in internal storage under the specified name.class
Cron
Executes an actor according to a pre-defined schedule.
Note: since the actor merely starts the cron scheduler in the background, the actor finishes the execution pretty much immediately.class
DatabaseCheck
First, the actor checks whether the connection to the database is established.class
DatabaseConnection
For initializing an ADAMS database connection that differs from the system-wide one.class
DelayedEvent
Executes its sub-flow after a predefined number of milli-seconds.class
DeleteDir
Deletes the dirs that match the regular expression below the specified directory.class
DeleteFile
Deletes the files that match the regular expression below the specified directory.class
DeleteStorageValue
Removes the specified value (or the ones that match the regular expression) from temporary storage.
By supplying a cache name, the value can be removed from a LRU cache instead of the regular storage.class
DeleteVariable
Removes a variable by name or the variables that match the regular expression.class
DeserializeToStorage
Deserializes a model from a file with the specified object reader and stores it directly in storage.
It is also possible to define multiple storage name / file name pairs, to make the deserialization of large amounts of files more efficient.class
DirWatch
class
Events
Container for event actors.class
ExecSQL
Executes a SQL statement, which does not return a result set, like INSERT, UPDATE, DELETE, CREATE.class
ExternalFlow
Allows to execute a complete external Flow rather than just an external actor.class
ExternalStandalone
Standalone that executes an external standalone actor stored on disk.
For executing whole flows, use the adams.flow.standalone.ExternalFlow standalone actor instead.
See also:
adams.flow.standalone.ExternalFlow
class
FTPConnection
Provides access to a FTP host.
If debugging is enabled, the FTP commands issued by other actors will get printed as debug output of this actor.class
GridView
Displays multiple graphical actors in a grid.class
Groovy
A standalone that executes a Groovy script.class
HashSetInit
Creates an empty hashset in internal storage under the specified name.
Initial string values can be supplied as well, which can be transformed using the specified conversion.
See also:
adams.flow.transformer.HashSetInit
adams.flow.transformer.HashSetAdd
adams.flow.source.HashSet
adams.flow.condition.bool.HashSet
class
InactiveStandalone
Container for inactive standalone actors.
Can be activated with the adams.flow.processor.ReactivateActors processor.class
IncludeExternalStandalone
Includes an external standalone.class
InitPublishSubscribe
Initializes a publish/subscribe data structure in internal storage.class
InitStorageCache
Adds a LRU cache in the responsible storage handler (usually the Flow actor).class
Java
Calls the main method of a Java class.class
JavaExec
Forks off a new JVM with the same classpath by default.class
JobRunnerInstance
Acts as job execution pool for classes implementing adams.multiprocess.JobRunnerSupporter.
See also:
adams.multiprocess.JobRunnerSupporter
class
JobRunnerSetup
Defines the job runner setup to use for parallel/distributed computation.class
LogEvent
Listens to the global log record handler and processes records that passed the specified filter(s).
This allows, for instance, the output of log messages into a log file.
By default, log records are only processed if the sub-actors are not currently being executed.class
LookUpInit
Initializes an empty look up table in storage.
See also:
adams.flow.transformer.LookUpAdd
class
MakeDir
Creates the user-supplied directory if not already existing.class
MemoryMonitor
Monitors the memory (used/committed heap vs maximum heap).Every number of seconds ('sampleInterval'), the memory consumption, i.e., 'heap used', is sampled, keeping the specified number of latest samples ('numSamples').
Once the specified number of samples have been reached, it is checked whether the specified percentage of samples ('coverage') reaches or exceeds the threshold percentage of the maximum heap has been exceeded ('threshold').class
Null
Dummy standalone, does nothing.class
PyroNameServer
Defines the Pyro nameserver to use.class
PyroStandalone
Transforms data using a Pyro4 call
For more information see:
https://pythonhosted.org/Pyro4/
https://github.com/irmen/Pyrolite
class
PythonEnvironment
Defines what Python executables to use within this context.
On Linux, you can enforce using the system-wide Python 3 executables by supplying '3' as suffix, which gets appended to the executables.class
QueueEvent
Executes its sub-flow after a predefined number of milli-seconds.class
QueueInit
Creates an empty queue in internal storage under the specified name.class
RegisterFlow
Simply registers the flow with the running flows registry.class
RemoteScriptingEngine
Starts/stops a scripting engine for remote commands.class
Scripted
A standalone that executes an external script.class
SetManyVariables
Sets the values of the variables.
Optionally, the specified values can be expanded, in case it is made up of variables itself.
Grammar for mathematical expressions (value type 'MATH_EXPRESSION, MATH_EXPRESSION_ROUND'):
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
| has ( variable )
| isNaN ( expr )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] ) (find 'search' in 'expr', return 1-based position)
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
| str ( expr )
| str ( expr , numdecimals )
| str ( expr , decimalformat )
| ext ( file_str ) (extracts extension from file)
| replaceext ( file_str, ext_str ) (replaces the extension of the file with the new one)
;
Notes:
- Variables are either all alphanumeric and _, starting with uppercase letter (e.g., "ABc_12"),
any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]") or
enclosed by single quotes (e.g., "'Hello World'").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'.
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
SetProperty
Deprecated.class
SetVariable
Sets the value of a variable.
Optionally, the specified value can be expanded, in case it is made up of variables itself.
It is also possible to override the variable value with the value obtained from an environment variable.
Grammar for mathematical expressions (value type 'MATH_EXPRESSION, MATH_EXPRESSION_ROUND'):
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
| has ( variable )
| isNaN ( expr )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] ) (find 'search' in 'expr', return 1-based position)
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
| str ( expr )
| str ( expr , numdecimals )
| str ( expr , decimalformat )
| ext ( file_str ) (extracts extension from file)
| replaceext ( file_str, ext_str ) (replaces the extension of the file with the new one)
;
Notes:
- Variables are either all alphanumeric and _, starting with uppercase letter (e.g., "ABc_12"),
any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]") or
enclosed by single quotes (e.g., "'Hello World'").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'.
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
SMBConnection
Provides access to a remote host via SMB.class
SMTPConnection
SMTP server setup for overriding default parameters.class
SSHConnection
Provides access to a remote host via SSH.
For more information see:
(2011).class
Standalones
Container for standalone actors.class
Stopwatch
Stops the execution time of the flow, till either the user stops the flow or the flow finishes by itself
Valid options are:class
TableCleanUp
Runs a table cleaner.class
TabView
Displays multiple graphical actors in a tabbed pane.class
TemplateStandalone
Generates a standalone actor/sub-flow from a template.class
TesseractConfiguration
Setup parameters for tesseract.
For more information see:
https://github.com/tesseract-ocr/tesseract
Valid options are:class
Tool
Runs a tool.class
VariableChangedEvent
Listens to a any changes to the specified variable.
This allows, for instance, the monitoring of a variable.
Enable the 'noDiscard' property to process all change events - NB: this can slow down the system significantly.class
WeakExternalStandalone
class
WebSocketServer
Starts and runs a websocket server.class
WekaPackageManagerAction
Executes the specified action and forwards the generated output. -
Uses of CleanUpHandler in adams.flow.standalone.pyrostandalone
Classes in adams.flow.standalone.pyrostandalone that implement CleanUpHandler Modifier and Type Class Description class
AbstractPyroStandalone
Ancestor for Pyro calls that neither take input nor produce output.class
Generic
Generic call, just forwards any data to the remote object.class
Null
Dummy, does nothing. -
Uses of CleanUpHandler in adams.flow.template
Subinterfaces of CleanUpHandler in adams.flow.template Modifier and Type Interface Description interface
ActorTemplateUser
Interface for actors that make use for actor templates.Classes in adams.flow.template that implement CleanUpHandler Modifier and Type Class Description class
AbstractScriptedTemplate
Abstract ancestor for templates that execute external scripts.class
Groovy
Uses a Groovy script to generate a sub-flow.class
Scripted
Uses a Groovy script to generate a sub-flow. -
Uses of CleanUpHandler in adams.flow.transformer
Subinterfaces of CleanUpHandler in adams.flow.transformer Modifier and Type Interface Description interface
DataContainerDbReader<T extends DataContainer>
Interface for actors that read containers from the database.interface
DataContainerDbWriter<T extends DataContainer & DatabaseIDHandler>
Interface for actors that import data containers into the database.interface
FeatureGenerator<T>
General interface for feature generating actors.interface
SpreadSheetMergeActor
Indicator interface for actors that merge spreadsheets.interface
WekaMergeInstancesActor
Interface for transformers that merge Weka Instances.Classes in adams.flow.transformer that implement CleanUpHandler Modifier and Type Class Description class
AbstractArrayProvider
Ancestor for transformer actors that can output items one by one or as a single array.class
AbstractCallableWekaClassifierEvaluator
Ancestor for classifier evaluators that make use of a callable classifier.class
AbstractCallableWekaClustererEvaluator
Ancestor for clusterer evaluators that make use of a callable clusterer.class
AbstractContainerValueExtractor
Ancestor for transformers that extract values from a container.class
AbstractDataContainerAdd<T extends DataContainer>
Ancestor for transformers that superimpose the incoming data container on one available from storage (or if not available, put the current one in storage) and forward the combined data container.class
AbstractDataContainerAppend<T extends DataContainer>
Ancestor for transformers that append the incoming data container to one available from storage (or if not available, put the current one in storage) and forward the combined data container.class
AbstractDataContainerDbReader<T extends DataContainer>
Ancestor for transformers that read containers from the database.class
AbstractDataContainerDbWriter<T extends DataContainer & DatabaseIDHandler>
Abstract ancestor for actors that import data containers into the database.class
AbstractDataContainerFileImport<T extends DataContainer>
Abstract ancestor for actors that import data containers.class
AbstractDataContainerFileReader<T extends DataContainer>
Abstract ancestor for actors that read data containers from disk.class
AbstractDataContainerFileWriter<T extends DataContainer>
Abstract ancestor for transformer actors that write data containers to disk.class
AbstractDataContainerTransformer
Ancestor for actors that transform data containers.class
AbstractDataProcessor
Abstract ancestor for classes that process data on disk.class
AbstractDbArrayProvider
Ancestor for array providers that use the database.class
AbstractDbDataProcessor
Abstract ancestor for data processors that use a database.class
AbstractDbTransformer
Abstract ancestor for transformers that query a database.class
AbstractDeleteDataContainer<T extends DataContainer>
Ancestor for transformers that delete containers from the database.class
AbstractDeleteDbReportValue<T extends Report>
Ancestor for transformers that delete values from a report in the database whenever a token passes through.class
AbstractDeleteReportValue
Ancestor for transformers that delete values from a report.class
AbstractDeleteReportValueByExpression
Ancestor for transformers that delete field/value from a report if the boolean expression evaluates to true.class
AbstractFilter
Ancestor for domain-specific filter transformers.class
AbstractGetReportValue
Ancestor for transformers that retrieve a value from a report.class
AbstractInPlaceSpreadSheetTransformer
Ancestor for spreadsheet transformers that allow the processing to happen in-place, rather than on a copy of the data.class
AbstractInstanceGenerator<T extends DataContainer>
Ancestor for transformers that turn data containers into WEKA Instance objects.class
AbstractInteractiveTransformer
Ancestor for transformers that interact with the user.class
AbstractInteractiveTransformerDialog
Ancestor for graphical actors that are interactive.class
AbstractMultiCompress
Abstract ancestor for compression algorithms that allow the compression of multiple files (incl directory structure).class
AbstractMultiDecompress
Ancestor for compression schemes that manage archives with multiple files (incl directory structure) like zip archives.class
AbstractProcessWekaInstanceWithModel<T>
Ancestor for transformers that user models for processing Instance objects, e.g., classifiers making predictions.class
AbstractReportDbReader<T extends Report,I>
Abstract ancestor for actors that load reports from the database.class
AbstractReportDbUpdater
Ancestor for transformers that updateReport
objects or reports that are part of aMutableReportHandler
object.class
AbstractReportDbWriter<T extends Report,I>
Abstract ancestor for actors that write reports to the database.class
AbstractReportDbWriterByDBID<T extends Report>
Abstract ancestor for actors that write reports to the database.class
AbstractReportDbWriterByID<T extends Report>
Abstract ancestor for actors that write reports to the database.class
AbstractReportFileImport<T extends Report>
Abstract ancestor for report import actors.class
AbstractReportFileReader<T extends Report>
Abstract ancestor for report file reader transformers.class
AbstractReportFileWriter<T extends Report>
Abstract ancestor for actors that write reports to disk.class
AbstractReportValueDbWriter<T extends Report>
Abstract ancestor for actors that write report values to the database.class
AbstractScript
Ancestor for transformer script actors.class
AbstractSetReportValue
Ancestor for transformers that update the value of field in a report.class
AbstractSingleCompress
Ancestor for compression algorithms that only take a single file, like gzip.class
AbstractSingleDecompress
Ancestor for decompression algorithms that only work with archives that consists of a single file, like gunzip.class
AbstractSpreadSheetTransformer
Ancestor for transformers that work on spreadsheets and also output spreadsheets again.class
AbstractStringOperation
Ancestor for transformers that perform operations on strings.class
AbstractTransformer
Ancestor for all flow items that process an input token and generate an output token.class
AbstractTransformerWithPropertiesUpdating
Ancestor for transformers that allow changing the object's properties using variables.class
AbstractWekaClassifierEvaluator
Ancestor for transformers that evaluate classifiers.class
AbstractWekaModelReader
Ancestor for actors that deserialize models.class
AbstractWekaPredictionsTransformer
Ancestor for transformers that convert the predictions stored in an Evaluation object into a different format.class
AccessDatabaseInfo
Outputs information on a MS Access database.class
AddDOMAttribute
Adds a new attribute to the incoming org.w3c.dom.Node and forwards the new updated node.class
AddDOMNode
Adds a new node below the incoming org.w3c.dom.Node and forwards the new node.
In case of an incoming org.w3c.dom.Document, the node gets added below the root node.class
AddNote
Adds a note to the notes handler passing through.
Pre-defined note types:
- ERROR:
- WARNING:
- PROCESS INFORMATION
Input/output:
- accepts:
adams.data.NotesHandler
- generates:
adams.data.NotesHandler
class
AppendName
Appends the suffix to the file/directory being passed through.
By default, the appropriate separator (forward slash or backslash) gets inserted between the file/directory and suffix.class
ArrayCombinations
Turns an array of any type into a sequence of array combinations of given size.class
ArrayHistogramRanges
Outputs the ranges generated by adams.data.statistics.ArrayHistogram using the incoming double array or matrix.
In case of an array, the data-type and location are ignored.class
ArrayLength
Determines the length of an array.class
ArrayReverse
Reverses the order of the elements in the array.class
ArrayStatistic
Generates statistics from a double array or matrix.class
ArraySubset
Generates a subset of the array, using the specified array elements.class
ArraySubsetGeneration
class
ArrayToChunks
Splits an array into chunks of a specified size.class
ArrayToCollection
Turns an array into a collection.class
ArrayToSequence
Turns an array of any type into a sequence of tokens.class
ArrayToVariables
class
AutogeneratedTransformer
Encapsulates a sequence of auto-generated actors.class
BaseName
Extracts the name of the file/directory passing through, i.e., any preceding directory gets stripped.class
BinaryFileReader
Reads a binary file and forwards the content byte by byte or as byte array.class
BoofCVDetectLines
Detects lines in images (Hough line detector based on polar parametrization).class
BoofCVDetectLineSegments
Detects line segments in images (line RANSAC).class
BoofCVFeatureGenerator
Applies a BoofCV feature generator to the incoming image and outputs the generated features.class
BoofCVMultiImageOperation
Applies a BoofCV multi-image operation to the incoming image(s) and outputs the generated image(s).class
BoofCVTransformer
Applies a BoofCV transformation to the incoming image and outputs the generated image(s).class
BufferedImageFeatureGenerator
Applies an JAI flattener to the incoming image and outputs the generated features.class
BufferedImageMultiImageOperation
Applies a BufferedImage multi-image operation to the incoming image(s) and outputs the generated image(s).class
BufferedImageTransformer
Applies a BufferedImage transformation to the incoming image and outputs the generated image(s).class
Bzip2
Creates a bzip2 archive from a single file.class
CallableTransformer
Feeds tokens into a callable transformer and broadcasts the generated output tokens.class
ChangeImageObjectPrefix
Uses the specified object finder to locate objects and then applies the object filter to the located objects.class
ChangeReportFieldPrefixes
Replaces the specified old prefixes with the new one.class
ClassSelector
Sets (or unsets) the class index/indices.class
CollectionAppend
Appends the elements of the incoming collection to the one in storage.
If there is none in storage yet, a copy of the incoming collection will simply get stored in storage.
The combined collection is then forwarded.class
CollectionInsert
Inserts an object in the collection using the specified position.
The object can be retrieved from a callable actor or from storage.
If the collection does not implement the java.util.List interface and the insertion is not at the end, the insertion will fail.
See also:
adams.flow.transformer.StorageCollectionInsert
Input/output:
- accepts:
java.util.Collection
- generates:
java.util.Collection
class
CollectionSize
class
CollectionSubset
Generates a subset of the collection, using the specified elements.class
CollectionToArray
Turns a collection of any type into an array.class
CollectionToSequence
Turns a collection of any type into a sequence of tokens.class
ColorProvider
Outputs a color for each token passing through.
If the color provider implements adams.gui.visualization.core.ColorProviderWithNameSupport then the color associated with the incoming string token is forwarded.
The color provider can be reset using the specified variable.class
CompareObjectLocations
Visualizes object locations (annotations and predicted) for the incoming image side-by-side.
Only forwards the image container when accepted.class
CompareObjects
Compares two objects using the specified compare algorithm and forwards the output of the comparison.class
CompareObjectTypes
Compares the object types between objects from the two reports.
The first report is considered 'ground truth'.class
ConfirmationDialog
Pops up a confirmation dialog, prompting the user to select 'yes', 'no' or 'cancel'.
If no custom tokens are used, the current token is only forwarded when the user selects 'yes'.class
ConfusionMatrix
Generates a confusion matrix from the specified actual and predicted columns containing class labels.
Can take a probability column (of prediction) into account for generating weighted counts.class
ContainerToStorage
Extracts the specified values from the container passing through and makes them available as storage items.class
ContainerToVariables
Extracts the specified values from the container passing through and makes them available as variables.class
ControlChart
Applies a control chart algorithm to the data.class
Convert
Converts data from one format into another.class
ConvertFeatures
Turns the raw features generated by a feature converter (stored in a adams.flow.container.FeatureConverterContainer) into a specific format using the user-defined feature converter.
If an array of containers is received, the get merged first, i.e., placed side-by-side.class
Copy
Creates copies of the tokens being passed through.class
CopyCallableTransformer
Feeds tokens into the copy of a callable transformer and broadcasts the generated output tokens.class
CopyFile
Copies the file received on its input port to the target directory if it matches the provided regular expression.
In case of a directory, the directory gets copied recursively.
If required, you can also provide a new filename (just the name, no path).
The generated target file/directory gets forwarded in the flow.class
CopyToClipboard
Copies the data in this token to the system's clipboard using the specified clipboard manager.class
CounterAdd
Passes a value through the specified counter.class
CounterInit
Creates a counter from a column in a spreadsheet or an array.class
CountObjectsInPolygon
Counts the objects in the report passing through that fall into the defined region.
Partial hits can be counted as well, using their percentage in overlap as count.class
CountObjectsInRegion
Counts the objects in the report passing through that fall into the defined region.
Partial hits can be counted as well, using their percentage in overlap as count.class
CreateEmail
Actor for creating emails to be sent.class
DatasetFilter
Applies the batch filter to the dataset.class
DatasetRowFilter
Applies the stream filter to the rows.class
DateTimeTypeDifference
Computes the difference between the two date/time types of the incoming array (of length 2) by subtracting the second element from the first one.class
DecodeBarcode
Decodes the data in a barcode using the specified decoder.class
DeleteFile
Deletes the file/directory (or files/directories) received on its input port if it matches the provided regular expression.
In case of directories, deletion is performed recursively (if a directory matches, then the content gets deleted regardless whether it matches the regular expression or not).class
DeleteJsonValue
class
DeleteMapValue
Deletes the specified key/value pair from the map passing through.class
DeleteOverlappingImageObjects
Cleans up overlapping objects, e.g., multiple predicted bounding boxes per object.class
DeletePropertyValue
Deletes the specified property from the Properties object passing through.class
DeleteReportValue
Deletes values from a report.class
DeleteReportValueByExpression
class
DeleteStorageValue
Removes the specified value (or the ones that match the regular expression) from temporary storage whenever a token passes through.
By supplying a cache name, the value can be removed from a LRU cache instead of the regular storage.class
DeleteVariable
Removes a variable by name or the variables that match the regular expression.class
Deserialize
Deserializes a previously serialized Java object from a file.class
DetermineOverlappingAreas
class
DetermineOverlappingObjects
Computes the overlap of objects with the specified report from storage (or itself) using the specified algorithm.class
Diff
Compares two files or two string arrays and generates a diff representation.
In case of BRIEF, the output is whether the two files/arrays are different.class
DirName
Extracts the directory part of the file/directory passing through, i.e., any trailing name part gets stripped.
See also:
adams.flow.transformer.AppendName
adams.flow.transformer.PrependDir
adams.flow.transformer.RelativeDir
adams.flow.transformer.BaseName
adams.flow.transformer.FileExtension
Input/output:
- accepts:
java.lang.String
java.lang.String[]
java.io.File
java.io.File[]
- generates:
java.lang.String
java.lang.String[]
java.io.File
java.io.File[]
class
DownloadContent
Downloads the raw, textual content from a URL and forwards it.Also handles basic authentication when using URLs like this:
http://user:pass@domain.com/url
Input/output:
- accepts:
java.lang.String
adams.core.base.BaseURL
java.net.URL
- generates:
java.lang.String
class
Draw
Performs a draw operation on an image.class
EmailFileReader
Reads email(s) from a file.class
EncodeBarcode
class
ExecuteActor
Executes the actor passing through and forwards it once finished.
If the actor is an instance of adams.flow.execution.FlowExecutionListeningSupporter and flow execution listening enabled, then the specified flow execution listener gets attached.class
ExecuteJobs
Executes the incoming jobs.class
ExecuteRemoteCommand
Executes the incoming commands.class
ExifTagOperation
Performs the specified EXIF operation on the incoming data.class
ExpandStorage
Expands all the storage items (using their string representation) and variables in the string(s) passing through.
A string can consist of arbitrary strings and the following special placeholders:
- variables: @{...}
- storage placeholders: %{...}
Input/output:
- accepts:
java.lang.String
java.lang.String[]
- generates:
java.lang.String
java.lang.String[]
class
ExpandVariables
Expands all the variables in the string(s) passing through.A string can consist of arbitrary strings and the following special placeholder for variables:
@{...}
Input/output:
- accepts:
java.lang.String
java.lang.String[]
- generates:
java.lang.String
java.lang.String[]
class
ExternalTransformer
Transformer that executes an external transformer actor stored on disk.class
FileChanged
Checks whether the input file has changed using the specified monitor.
Must be initialized once with the same file.class
FileExtension
Extracts the file extension from the file (the part after the '.').
If no dot is in the file name, then an empty string gets forwarded.
See also:
adams.flow.transformer.AppendName
adams.flow.transformer.PrependDir
adams.flow.transformer.RelativeDir
adams.flow.transformer.DirName
adams.flow.transformer.BaseName
Input/output:
- accepts:
java.lang.String
java.lang.String[]
java.io.File
java.io.File[]
- generates:
java.lang.String
java.lang.String[]
class
FileInfo
Outputs information for a path (file/directory).class
FilenameGenerator
Passes the incoming token through the generator to generate and forward a filename.
See also:
adams.flow.source.FilenameGenerator
Input/output:
- accepts:
adams.flow.core.Unknown
- generates:
java.lang.String
class
FileTailer
Monitors a text file for data being appended, e.g., log files.class
FilterMap
Applies the specified filter to the map object passing through.class
FindInFile
Searches the incoming (text) file for the specified search string, output the boolean search result.class
FlowFileReader
Reads the flow file and outputs the actor(s).
A custom reader can be specified in case of reading from files, but must be specified when reading from java.io.Reader or java.io.InputStream objects.class
FTPDelete
Deletes a remote file and forwards the file name.class
FTPDisconnect
Closes the currently open FTP session.
Simply passes through any tokens.class
FTPGet
Downloads a remote file and forwards the local file name.class
FTPNoOp
Sends a NOOP command to the FTP server whenever a token passes through.class
FTPSend
Uploads a file to a remote directory.
The file name of a successful upload gets forwarded.class
GenerateFileBasedDataset
Applies the specified generator to the incoming dataset container.
See also:
adams.flow.control.SetContainerValue
adams.flow.transformer.PrepareFileBasedDataset
Input/output:
- accepts:
adams.flow.container.FileBasedDatasetContainer
- generates:
java.lang.String
Container information:
- adams.flow.container.FileBasedDatasetContainer: Train, Test, Validation, Negative
class
GetArrayElement
Picks an element from an array and forwards only this element.class
GetDatabaseID
Returns the database ID of the database ID handler passing through.class
GetID
Returns the ID of the ID handler passing through.class
GetImageObjectIndices
Uses the specified object finder to locate objects and forwards the indices.class
GetImageObjectMetaData
Retrieves the meta-data of the incoming adams.flow.transformer.locateobjects.LocatedObject object.class
GetImageObjects
Uses the specified object finder to locate objects and forwards the objects.class
GetJsonKeys
Outputs all the keys of the JSON Object passing through.class
GetJsonValue
Obtains the value associated with the specified key from the JSON object passing through.
Null values are only forwarded if requested.class
GetListElement
Picks an element from a list and forwards only this element.class
GetMapKeys
Forwards all the sorted (string) keys of the map.class
GetMapValue
Obtains the value associated with the specified key from Map object received as input and forwards it.class
GetNotes
Returns the notes of the notes handler passing through.class
GetObjectProperty
Retrieves a value from an object's property using a bean property path.
A bean property consists usually of a get and set method, e.g.:
- setDebug(boolean)
- boolean getDebug()
The property name for this pair is:
debug
Input/output:
- accepts:
java.lang.Object
- generates:
adams.flow.core.Unknown
class
GetProperties
Outputs the names of all Java Bean properties of the incoming object.class
GetProperty
Obtains the current property value of the object passing through.class
GetPropertyNames
Outputs all the keys of the properties object passing through.class
GetPropertyValue
Obtains the value(s) associated with the keys that match the specified regular expression from the Properties object passing through.
Null values are only forwarded if requested.class
GetRemoteCommandPayload
Returns the underlying payload objects (if any) from the incoming remote command.
Depending on request/response flag, it outputs the corresponding payload objects.
Does not forward anything if the array is empty.class
GetReport
Returns the report of the report handler passing through.class
GetReportValue
Retrieves a value from a report.class
GetStorageValue
Retrieves a value from internal storage using the incoming string token as name.class
Groovy
A transformer that uses a Groovy script for processing the token(s).class
GroupByRegExp
Groups the incoming strings into sub-groups.class
GUNZIP
Decompresses an archive that was compressed with gzip.class
GZIP
Creates a GZIP archive from a single file.class
HashSetAdd
Adds a value to the specified hashset.class
HashSetInit
Creates a hashset from a column in a spreadsheet or an array.class
HashSetRemove
Removes a value from the specified hashset.class
HexReplace
Allows to find and replace characters in hex notation.class
HttpPostFile
Uploads the incoming file via HTTP POST to the specified URL as 'multipart/form-data'.
Additional form fields can be supplied as well.class
HttpRequest
Sends the incoming text/bytes payload to the specified URL (with optional HTTP headers) and forwards the retrieved HTML as text.class
IDGenerator
Generates IDs from the objects it receives on its input and forwards the generated IDs.class
ImageAnnotator
Allows the user to label objects located on the image and pass on this enriched meta-data.class
ImageFileReader
Reads any file format that the specified image reader supports.
If meta-data is associated with the image, then this can be loaded as well.class
ImageInfo
Obtains information from the picture passing through.class
ImageLabeler
Allows the user to label images, setting a report field in the meta-data.
Any logged interaction will get added as JSON under interaction-log in the report.class
ImageMetaData
Returns any EXIF or IPTC and basic image information as a spreadsheet.class
ImageObjectAnnotator
User interface for annotating objects in images.class
ImageObjectFilter
Uses the specified object finder to locate objects and then applies the object filter to the located objects.class
ImageObjectIndexOffset
Offsets the object index.class
ImageObjectInfo
Outputs the requested type of information for either the incoming adams.flow.transformer.locateobjects.LocatedObject or the specified image object in the report.class
ImageObjectOverlap
Computes the overlap of objects with the specified report from storage.
It stores the overlap percentage of the highest overlap found (overlap_highest) and the total number of overlaps greater than the specified minimum (overlap_count).
If a label key (located object meta-data) has been supplied, then the label of the object with the highest overlap gets stored as well (overlap_label_highest) and whether the labels match (overlap_label_highest_match)
Input/output:
- accepts:
adams.data.image.AbstractImageContainer
adams.data.report.Report
adams.data.report.ReportHandler
- generates:
adams.data.image.AbstractImageContainer
adams.data.report.Report
adams.data.report.ReportHandler
class
ImageObjectOverlapMatrix
Generates a matrix of overlapping image objects (annotations vs predictions) and their labels.
When outputting not just overlaps, a separate column 'Overlap' is output as well, indicating whether this row represents an overlap ('yes') or not ('no')
Input/output:
- accepts:
adams.data.image.AbstractImageContainer
adams.data.report.Report
adams.data.report.ReportHandler
- generates:
adams.data.spreadsheet.SpreadSheet
class
ImageObjectToVariables
Converts the parameters of an image object into variables.
Meta-data can be turned into variables as well.class
ImagePreparation
Preprocesses an image.class
ImageSegmentationAnnotator
User interface for annotating images for image segmentation.class
ImageSegmentationContainerFilter
Applies a Image Segmentation container filter to the incoming container(s) and outputs the generated data.class
ImageSegmentationContainerOperation
Applies a Image Segmentation container operation to the incoming container(s) and outputs the generated data.class
ImageSegmentationFileReader
Reads image segmentation file formats using the specified reader and forwards a container with the data.class
ImageSharpness
Determines whether images are in focus ('sharp') using the specified algorithm.class
InactiveTransformer
Encapsulates a sequence of inactive actors.class
IncludeExternalTransformer
Includes an external transformer.class
IncStorageValue
Increments the value of a storage value by either an integer or double increment.
If the storage value has not been set yet, it will get set to 0.
If the storage value contains a non-numerical value, no increment will be performed.
It is also possible to directly output the updated storage value (while discarding the input token).class
IncVariable
Increments the value of a variable by either an integer or double increment.
If the variable has not been set yet, it will get set to 0.
If the variable contains a non-numerical value, no increment will be performed.
It is also possible to directly output the updated variable (while discarding the input token).class
IndexedSplitsRunsEvaluation
Uses the specified evaluation for evaluating the incoming data.class
IndexedSplitsRunsGenerator
Uses the specified generator for generating indexed splits from the incoming data.class
IndexedSplitsRunsPredictions
Uses the specified generator for generating predictions from indexed splits for the incoming data.class
IndexedSplitsRunsReader
Reads indexed splits runs from disk using the specified reader.class
IntersectOverUnion
Computes the Intersect Over Union (IOU) of objects with the specified report from storage.
It stores the highest IOU found (iou_highest) and the total number of iou greater than the specified minimum (iou_count).
If a label key (located object meta-data) has been supplied, then the label of the object with the highest iou gets stored as well (iou_label_highest) and whether the labels match (iou_label_highest_match)
Input/output:
- accepts:
adams.data.image.AbstractImageContainer
adams.data.report.Report
adams.data.report.ReportHandler
- generates:
adams.data.image.AbstractImageContainer
adams.data.report.Report
adams.data.report.ReportHandler
class
JsonFileReader
Reads a JSON file and forwards the parsed JSON object.
If it is know beforehand, whether the JSON file contains an object or an array, the output type can be specified.class
LocateObjects
Locates objects in an image and forwards an image per located object, cropped around the object.class
LookUp
Forwards the value associated with the key that the actor gets as input, using the specified lookup table from internal storage.class
LookUpAdd
Adds key-value pairs to the specified lookup table.
The input can either an array or a spreadsheet.
If the input is an array, it must have length 2, with the first element the key and the second one the value.class
LookUpInit
Creates a lookup table from a spreadsheet, using one column as key and another one as value.class
LookUpRemove
Removes a key/value pair from the specified lookup table.class
LookUpUpdate
Updates the lookup table (in form of a spreadsheet) that passes through using the specified rules.
The rules can contain variables.
The rules use the following grammar:
expr_list ::= expr_list expr_part | expr_part
expr_part ::= conditional | assignment
conditional ::= if expr then assignments end
| if expr then assignments else assignments end
assignments ::= assignments assignment | assignment
assignment ::=
VARIABLE := expr;
| all ( "regexp" ) := expr;
expr ::= ( expr )
| NUMBER
| STRING
| BOOLEAN
| VARIABLE
| true
| false
| -expr
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr
| not expr
| expr and expr
| expr or expr
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr % expr
| expr ^ expr
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
Notes:
- Variables are either all alphanumeric and -/_ (e.g., "ABc_1-2") or any character
apart from "'" enclosed by "'" and "'" (e.g., "'Hello World'").
- The 'all' method applies the value to all the values in the lookup table
that match the regular expression.
- Variables starting with '_' are considered local and don't get transferred back out.
Input/output:
- accepts:
adams.data.spreadsheet.SpreadSheet
- generates:
adams.data.spreadsheet.SpreadSheet
class
Lzf
Creates a LZF archive from a single file.class
Lzma
Creates a LZMA (7zip) archive from a single file.class
MakeDir
Creates the directory accepted on the input port if not already existing.class
MakeForecastPlotContainer
Creates a named containers for the SequencePlotter actor using the incoming forecasts.class
MakeJFreeChartDataset
Generates a JFreeChart dataset from the incoming spreadsheet.class
MakeLogEntry
Creates a log entry from the incoming token.class
MakePlotContainer
Creates a named container for the SequencePlotter actor.
In case of Double arrays arriving at the input, they must have length 2 for X and Y, 4 for X/Y/Y-Error (low/high) or 6 X/Y/X-Error (low-high)/Y-Error (low-high).
Integer arrays can only have the length 2.
It is also possible, depending on the plotter sink setup, to use strings for x and/or y.
In order to force an update of the plot, overriding the current plot-updater setup, you can create a special plot container of type UPDATE and send that to the plot (can be triggered with a null-token, e.g., from a adams.flow.source.Start source).class
MapToStorageValues
Stores the map content in internal storage.
Only the map keys that match the regular expression are turned into storage values.class
MapToVariables
Turns the map content into variables.
Only the map keys that match the regular expression are turned into variables.class
MapVariableIterator
Iterates over the keys of the incoming map and sets variables for current key and variable.class
Mat5ArrayInfo
Provides information on a Matlab5 array.class
Mat5ArraySubset
Outputs either a single value (all dimensions in index specified) from an array or a subset (if one or more dimensions left empty).
Only arrays of type us.hebi.matlab.mat.types.Matrix are currently supported.class
Mat5FileAddArray
Adds an array to the matlab file object using the specified name.
The array can be retrieved from a callable actor or from storage.class
Mat5FileAddMap
Adds the elements of a map to the matlab file object using the names from the map.
The map can be retrieved from a callable actor or from storage.class
Mat5FileGetArray
Retrieves the specified array from the mat file object.class
Mat5FileInfo
Provides information from a .mat file.class
Mat5FileReader
Loads a Matlab file in mat5 format.class
Mat5GetMatrixElement
Retrieves the specified matrix element.class
Mat5GetStructField
Retrieves the specified struct field.class
Mat5SetMatrixElement
Sets the specified element in the matrix passing through.
The value gets parsed automatically according to the element type.class
Mat5SetStructField
Sets obtained array under the specified field name.class
Mat5StructInfo
Provides information from a Matlab struct object.class
MatchReportFields
Outputs all fields that match the regular expression.class
MathExpression
Evaluates a mathematical expression.
The input value (double or integer) can be accessed via 'X'.
Variables are supported as well, e.g.: pow(X,@{exp}) with '@{exp}' being a variable available at execution time.
The following grammar is used for the expressions:
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
| isNaN ( expr )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] )
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
;
Notes:
- Variables are either all upper case letters (e.g., "ABC") or any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'.
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
Max
Returns the maximum value from a double/int array or the index of the maximum value.class
MergeObjectLocations
Merges the object locations in the report of the container passing through with the one obtained from storage.
The 'overlap action' determines what to do if objects overlap.
With the 'check type' you can still trigger a 'skip' if the type values of the two overlapping objects differ.
For simply merging all objects, choose a minOverlapRatio of 0.0 and the OverlapAction of KEEP.class
MergeReport
Allows the report (or the report of a report handler) passing through to to be merged with another one.class
MergeReportFromMap
Merges the passing through report handler/report objects with the referenced map of report objects in storage.class
MessageDigest
Generates a message digest and forwards that.class
MimeType
Determines the mime type of a file.class
Min
Returns the minimum value from a double/int array or the index of the minimum value.class
MoveFile
Moves a file to a different location (or just renames it).
Source and target can be swapped as well.
Simply forwards the input token if moving was successful.class
MultiMapOperation
Applies the specified operation the incoming map array.class
MultiMat5MatrixOperation
Applies a multi-matrix operation to the incoming matrix(s) and outputs the generated matrix(s).class
MultiSpreadSheetOperation
Applies the specified operation the incoming spreadsheet array.class
NegativeRegions
Uses the specified generator for generating negative regions for the image passing through.class
ObjectArrayToPrimitiveArray
Turns an object array into an primitive one.class
OpenCVFeatureGenerator
Applies a OpenCV feature generator to the incoming image and outputs the generated features.class
OpenCVMultiImageOperation
Applies a BoofCV multi-image operation to the incoming image(s) and outputs the generated image(s).class
OpenCVTransformer
Applies a OpenCV transformation to the incoming image and outputs the generated image(s).class
OptionProducer
Generates string output from the object passing through using the specified option producer.class
OutlierDetector
Applies the outlier detector and either outputs the updated data container or a flow container with the data and the detection results.class
PassThrough
Dummy transformer that passes tokens through.class
PDFAppendDocument
Modifies the incoming PDF document generated by adams.flow.source.PDFNewDocument using the PDF processors on either the specified input file or storage item.
Needs to be finalized with adams.flow.sink.PDFCloseDocument.
If a file name is received as input, it is assumed that this is an existing PDF file and gets appended.
See also:
adams.flow.source.PDFNewDocument
adams.flow.sink.PDFCloseDocument
Input/output:
- accepts:
adams.flow.transformer.pdfproclet.PDFGenerator
java.lang.String
java.io.File
- generates:
adams.flow.transformer.pdfproclet.PDFGenerator
class
PDFCreate
Actor for generating PDF files.class
PDFExtract
Actor for extracting a range of pages from a PDF file.class
PDFExtractImages
Actor for extracting the images from a PDF file.class
PDFExtractText
Actor for extracting the text of a range of pages from a PDF file.class
PDFGenerate
class
PDFInfo
Outputs information on a PDF file.class
PDFMerge
Actor for merging multiple PDF files.
Forwards the name of the generated file.class
PDFMetaData
Actor for extracting the meta-data from a PDF.class
PDFPageCount
Actor for extracting the page count from a PDF file.class
PDFRenderPages
Actor for rendering pages of a PDF file as images.class
PDFStamp
Actor for stamping pages in a PDF with a custom overlay.class
PixelSelector
Allows the user to select pixels.class
PredictionEccentricity
Treats the predictions from a regressor as an image and computes the 'eccentricity' of the actual vs predicted plot.class
PrepareFileBasedDataset
Processes the incoming files and generates a dataset container.
See also:
adams.flow.control.SetContainerValue
adams.flow.transformer.GenerateFileBasedDataset
Input/output:
- accepts:
java.lang.String[]
- generates:
adams.flow.container.FileBasedDatasetContainer
Container information:
- adams.flow.container.FileBasedDatasetContainer: Train, Test, Validation, Negative
class
PrependDir
Prepends the prefix to the file/directory being passed through.
By default, the appropriate separator (forward slash or backslash) gets inserted between the file/directory and prefix.class
PrimitiveArrayToObjectArray
Turns a primitive array into an object one.class
ProcessActor
Applies the specified processor to the incoming actor and forwards the result.
For processors implementing adams.flow.processor.ModifyingProcessor the modified actor is forwarded (or, if not modified, the original one), all others just forward the incoming actor.
If the processor should implement adams.flow.processor.ListingProcessor then any generated list gets stored as string array in the outgoing container as well.
Processors implementing adams.flow.processor.GraphicalOutputProducingProcessor can optionall display the graphical output as well (off by default).class
ProgrammaticTokenListener
Transformer that allows other, non-flow code to 'listen on the wire' of the data being processed.
Typically used for flows that are executed as background jobs in the user interface.
Listeners get removed once the flow finishes (wrapUp method).class
PropertiesFileReader
Reads a Java Properties file.class
PropertiesToVariables
Turns the properties into variables.
Only the property keys that match the regular expression are turned into variables.class
PyroTransformer
Transforms data using a Pyro4 call
For more information see:
https://pythonhosted.org/Pyro4/
https://github.com/irmen/Pyrolite
Input/output:
- accepts:
java.lang.Object
- generates:
java.lang.Object
class
PythonExpandScript
Loads the Python script received as input, expands any variables and placeholders, saves it to the specified output file and forwards the output file name.class
RelativeDir
Removes the prefix from the file/directory being passed through to turn them into relative ones.
See also:
adams.flow.transformer.BaseName
adams.flow.transformer.DirName
adams.flow.transformer.AppendName
adams.flow.transformer.PrependDir
adams.flow.transformer.FileExtension
Input/output:
- accepts:
java.lang.String
java.lang.String[]
java.io.File
java.io.File[]
- generates:
java.lang.String
java.lang.String[]
java.io.File
java.io.File[]
class
RemoteCommandReader
Loads the remote command from the incoming file.class
RemoveImageObject
Removes the specified image object.class
RemoveOverlappingImageObjects
Cleans up overlapping objects, e.g., multiple predicted bounding boxes per object.class
ReportDbUpdater
Adds all the data to the report (or reporthandler's report) passing through that the SQL statement returns.
The {ID} placeholder can be used in the SQL statement to represent the current handler's ID.
The following types of SQL statements are supported:
- multiple rows of key-value pairs.
- single row, with the key being the column name.
Input/output:
- accepts:
adams.data.report.Report
adams.data.report.MutableReportHandler
- generates:
adams.data.report.Report
adams.data.report.MutableReportHandler
class
ReportField
Returns all the fields in a report or the report from a report handling object that match the provided regular expression.class
ReportFileReader
Loads a file containing a report from disk with a specified reader and passes it on.class
ReportFileWriter
Saves a report to disk with the specified writer and passes the absolute filename on.
As filename/directory name (depending on the writer) the database ID of the report is used (below the specified output directory).class
ReportMathExpression
Evaluates a mathematical expression based on report values.
Either outputs the updated report or the report handler if that allows updating the report.class
ReportToStorage
Stores all report fields that match the provided regular expression in internal storage.class
ReportToVariables
Turns all report fields that match the provided regular expression into variables.class
Round
Performs 'round', 'ceiling' or 'floor' on double tokens and generates integers.class
ScaleReportObjects
Scales the objects in the report using the provided scale factors.
Processes the following suffixes of all the report fields that match the provided prefix:
- .x
- .y
- .width
- .height
Input/output:
- accepts:
adams.data.report.Report
adams.data.report.ReportHandler
- generates:
adams.data.report.Report
adams.data.report.ReportHandler
class
ScpFrom
Downloads a remote file and forwards the local file name using secure copy (SCP).
For more information see:
(2011).class
ScpTo
Uploads a file to a remote directory using secure copy (SCP).
The file name of a successful upload gets forwarded.
For more information see:
(2011).class
Scripted
A transformer that uses an external script for processing the token(s).class
SelectArraySubset
Allows the user to select a subset of the incoming array to be forwarded in the flow.class
SequenceToArray
Turns a sequence of tokens into arrays with a specified length.
In case of unspecified length (ie -1), an array containing all elements collected so far is output each time a token arrives, i.e., the internal buffer never gets reset.class
SequenceToCollection
Turns a sequence of tokens into a collection.
In case of unspecified length (ie -1), a collection containing all elements collected so far is output each time a token arrives, i.e., the internal buffer never gets reset.class
SetArrayElement
Sets an element of an array and forwards the updated array.class
SetDatabaseID
Updates the database ID of the database ID handler passing through with the provided 'ID' value.class
SetID
Updates the ID of the ID handler passing through with the provided 'ID' value.class
SetImageObjectMetaData
Sets meta-data in the incoming adams.flow.transformer.locateobjects.LocatedObject object.class
SetJsonValue
Sets a value in a JSON object, using the specified path.
The value can be either supplied as string using the 'value' property, obtained from a callable actor (property 'source') or from a storage item (property 'storage').class
SetManyVariables
Sets the values of the variables whenever a token passes through, but does not use the token's value.
Optionally, the specified values can be expanded, in case it is made up of variables itself.
Grammar for mathematical expressions (value type 'MATH_EXPRESSION, MATH_EXPRESSION_ROUND'):
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
| has ( variable )
| isNaN ( expr )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] ) (find 'search' in 'expr', return 1-based position)
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
| str ( expr )
| str ( expr , numdecimals )
| str ( expr , decimalformat )
| ext ( file_str ) (extracts extension from file)
| replaceext ( file_str, ext_str ) (replaces the extension of the file with the new one)
;
Notes:
- Variables are either all alphanumeric and _, starting with uppercase letter (e.g., "ABc_12"),
any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]") or
enclosed by single quotes (e.g., "'Hello World'").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'.
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
SetMapValue
Sets a value in a java.util.Map object.
The value can be either supplied as string using the 'value' property, obtained from a callable actor (property 'source') or from a storage item (property 'storage').class
SetPlotContainerValue
Updates a value of a plot container before it is being displayed in the SequencePlotter sink.class
SetProperty
Sets the property of a callable actor whenever a token passes through.
Note: this actor just sets the value, but performs no re-initialization or similar of the modified object.
The transformer just forwards tokens that it receives after the property has been set.class
SetPropertyValue
Sets a property in a properties object.class
SetReportFromFile
Loads a report from disk and replaces the current one in the token passing through.class
SetReportFromSource
Obtains a report from a callable source and replaces the current one in the token passing through.class
SetReportValue
Sets a value in a report.class
SetStorageFlag
Stores the flag value in storage using the specified name whenever a token passes through.class
SetStorageValue
Stores the payload of the token passing through under the specified name in temporary storage.class
SetSystemProperty
Sets a Java system property when it is executed.class
SetVariable
Sets the value of a variable.class
SFTPDelete
Deletes a remote file via secure FTP (SFTP) and forwards the deleted file name.
For more information see:
(2011).class
SFTPGet
Downloads a remote file and forwards the local file name via secure FTP (SFTP).
For more information see:
(2011).class
SFTPSend
Uploads a file to a remote directory using secure FTP (SFTP).
The file name of a successful upload gets forwarded.
For more information see:
(2011).class
SimpleStringReplace
Performs a string replacement, using String.replace(.., ...).
If the 'replace' string contains both, variables and placeholders, then first all variables are expanded and then the placeholders.class
SMBGet
Downloads a remote file and forwards the local file name (SMB, Windows share).
Host and remote directory can be left empty if the incoming filename consists of a fully qualified URL, e.g.: smb://host/share/dir/file.txt
Input/output:
- accepts:
java.lang.String
- generates:
java.lang.String
class
SMBSend
Uploads a file to a remote directory (SMB, Windows share).
The file name of a successful upload gets forwarded.
Input/output:
- accepts:
java.lang.String
- generates:
java.lang.String
class
Sort
Actor for sorting arrays.class
SplitFile
Splits the file into several smaller files using the specified splitter algorithm.class
SpreadSheetAggregate
Aggregates rows (min, max, avg, etc) in a spreadsheet using key columns.
All numeric columns in the specified aggregrate range (excluding the key columns) get aggregated.class
SpreadSheetAnonymize
Anonymizes a range of columns in a spreadsheet.class
SpreadSheetAppend
Appends the incoming spreadsheet to one in storage.
If there is none in storage yet, the incoming spreadsheet will simply get stored in storage.
The spreadsheets need not have the same structure, but it is assumed that column names are unique within a spreadsheet.
The combined spreadsheet is then forwarded.class
SpreadSheetAppendComments
Appends the comments of the spreadsheet.class
SpreadSheetCellFinder
Outputs the cell locations that the cell finder located.class
SpreadSheetCellSelector
Lets the user highlight cells in a spreadsheet which get output:
- spreadsheet with coordinates (1-based row and column) and the associated value of the selected cell
- spreadsheet with all un-selected cells set to missing
Usage:
You select cells by left-clicking on them and/or holding the left mouse button and moving the mouse over the cells that you want to select.
You can unselect cells in the same fashion, by holding the shift key in addition.static class
SpreadSheetCellSelector.TableModel
Custom model that stores whether a cell has been selected or not.class
SpreadSheetCollapse
Uses the specified key columns to identify groups of rows.class
SpreadSheetColumnFilter
Filters spreadsheets using the specified column finder.
The output contains all the columns that the specified finder selected.class
SpreadSheetColumnIterator
Iterates through all columns of a spreadsheet and outputs the names.
The columns can be limited with the range parameter and furthermore with the regular expression applied to the names.
Instead of outputting the names, it is also possible to output the 1-based indices.class
SpreadSheetColumnsByName
Creates a new spreadsheet with the columns that matched the regular expression.class
SpreadSheetColumnStatistic
Generates statistics for a chosen colunm.class
SpreadSheetCommonIDs
Extracts the common IDs from two or more spreadsheets.
Matching sense can be inverted, i.e., the IDs not in common are output.class
SpreadSheetConvertCells
Finds cells in a spreadsheet and converts them with a conversion scheme.
If the conversion scheme generates a adams.data.spreadsheet.SpreadSheet object itself, this will get merged with the enclosing one: any additional columns get added and the content of the first row gets added to the row the converted cell belongs to.class
SpreadSheetConvertHeaderCells
Converts the header cells of a spreadsheet with a conversion scheme.class
SpreadSheetCopyColumns
Copies a range of columns to a specific position in the spreadsheets coming through.class
SpreadSheetCopyRows
Copies a range of columnrows to a specific position in the spreadsheets coming through.class
SpreadSheetDifference
Computes the difference of the numeric cells between two spreadsheets.
The values of the second spreadsheet are subtracted from the first one.
If no 'key' columns are defined, the current order of rows is used for comparison.class
SpreadSheetExtractArray
Extracts a column or row of data from a SpreadSheet object.class
SpreadSheetFileReader
Reads a spreadsheet file and forwards the content.class
SpreadSheetFilter
Applies the specified spreadsheet filter to the data.static class
SpreadSheetFilter.FilterJob
class
SpreadSheetGetCell
Extracts one or more values from a spreadsheet.class
SpreadSheetGetColumnIndex
Obtain the 1-based indices of columns that match a user-specified regular expression.class
SpreadSheetGetHeaderCell
Extracts a single value from a spreadsheet's header.class
SpreadSheetHistogramRanges
Outputs the ranges generated by adams.data.statistics.ArrayHistogram using the incoming adams.data.spreadsheet.SpreadSheet object.
If cells aren't numeric or missing, a default value of zero is used.class
SpreadSheetInfo
Outputs statistics of a SpreadSheet object.class
SpreadSheetInsertColumn
Inserts a column at a specific position into spreadsheets coming through.
The cells are initialized with a pre-defined value.class
SpreadSheetInsertRow
Inserts a row at a specific position into spreadsheets coming through.
The cells are initialized with a pre-defined value.class
SpreadSheetInsertRowScore
Inserts a score column at a specific position into spreadsheets coming through.class
SpreadSheetMatrixStatistic
Generates statistics for the spreadsheet.class
SpreadSheetMerge
Merges two or more spreadsheets.class
SpreadSheetMethodMerge
Merges 2 or more spreadsheets into a single spreadsheet, using a selectable merge method.class
SpreadSheetPlotGenerator
Outputs plot containers generated from a spreadsheet.class
SpreadSheetQuery
Applies a query (SELECT, UPDATE, DELETE) on a spreadsheet.
Variables are supported as well, e.g., : SELECT * WHERE Blah = @{val} with 'val' being a variable available at execution time.
The following grammar is used for the query:
expr_list ::= expr_list expr_part | expr_part;
expr_part ::= select | update | delete;
select ::= SELECT col_list [limit]
| SELECT col_list WHERE cond_list [limit]
| SELECT col_list ORDER BY order_list [limit]
| SELECT col_list WHERE cond_list ORDER BY order_list [limit]
| SELECT agg_list
| SELECT agg_list GROUP BY col_list
| SELECT agg_list HAVING cond_list
| SELECT agg_list GROUP BY col_list HAVING cond_list
;
update ::= UPDATE SET upd_list
| UPDATE SET upd_list WHERE cond_list
;
delete ::= DELETE WHERE cond_list
;
col_list ::= col_list COMMA col
| col
| SELECT NUMBER [subsample: <1 = percent; >= 1 number of rows]
;
col ::= *
| COLUMN
| COLUMN AS COLUMN
;
upd_list ::= upd_list COMMA upd | upd;
upd ::= COLUMN = value
;
order_list::= order_list COMMA order | order;
order ::= COLUMN
| COLUMN ASC
| COLUMN DESC
;
cond_list ::= cond_list cond
| cond
;
cond ::= COLUMN < value
| COLUMN <= value
| COLUMN = value
| COLUMN <> value
| COLUMN >= value
| COLUMN > value
| COLUMN REGEXP STRING
| COLUMN IS NULL
| CELLTYPE ( COLUMN ) = "numeric|long|double|boolean|string|time|date|datetime|timestamp|object|missing"
| ( cond )
| cond:c1 AND cond:c2
| cond:c1 OR cond:c2
| NOT cond
;
value ::= NUMBER
| STRING
| PARSE ( "number" , STRING )
| PARSE ( "date" , STRING )
| PARSE ( "time" , STRING )
| PARSE ( "timestamp" , STRING )
;
limit ::= LIMIT NUMBER:max
| LIMIT NUMBER:offset , NUMBER:max
;
agg_list ::= agg_list COMMA agg
| agg
;
agg ::= COUNT [(*)] [AS COLUMN]
| MIN ( COLUMN ) [AS COLUMN]
| MAX ( COLUMN ) [AS COLUMN]
| RANGE ( COLUMN ) [AS COLUMN] (= MIN - MAX)
| MEAN ( COLUMN ) [AS COLUMN]
| AVERAGE ( COLUMN ) [AS COLUMN]
| STDEV ( COLUMN ) [AS COLUMN]
| STDEVP ( COLUMN ) [AS COLUMN]
| SUM ( COLUMN ) [AS COLUMN]
| IQR ( COLUMN ) [AS COLUMN]
| INTERQUARTILE ( COLUMN ) [AS COLUMN]
Notes:
- time format: 'HH:mm'
- date format: 'yyyy-MM-dd'
- timestamp format: 'yyyy-MM-dd HH:mm'
- STRING is referring to characters enclosed by double quotes
- COLUMN is either a string with no blanks (consisting of letters, numbers, hyphen or underscore; eg 'MyCol-1') or a bracket enclosed string when containing blanks (eg '[Some other col]')
- columns used in the ORDER BY clause must be present in the SELECT part; also, any alias given to them in SELECT must be used instead of original column name
Input/output:
- accepts:
adams.data.spreadsheet.SpreadSheet
- generates:
adams.data.spreadsheet.SpreadSheet
class
SpreadSheetRandomSystematicSample
Performs random systematic sampling on the rows of the incoming spreadsheet.
Divides the rows into N blocks with N being the sample size.class
SpreadSheetRemoveColumn
Removes the column(s) at the specific position from spreadsheets coming through.class
SpreadSheetRemoveRow
Removes one or more rows at the specific position from spreadsheets coming through.class
SpreadSheetReorderColumns
Reorders the columns in a spreadsheet according to a user-supplied order.class
SpreadSheetReorderRows
Reorders the rows in a spreadsheet according to a user-supplied order.class
SpreadSheetReplaceCellValue
Replaces cell values that match a regular expression with a predefined value.class
SpreadSheetRowBinning
Applies a binning algorithm to the values from the specified binning column to filter the rows into specific bins.
A new column is then added containing the corresponding bin index.class
SpreadSheetRowBuffer
Can act in two different ways:
1.class
SpreadSheetRowFilter
Filters spreadsheets using the specified row finder.
The output contains all the rows that the specified finder selected.class
SpreadSheetRowStatistic
Generates statistics for a chosen row.class
SpreadSheetRowToTimeseries
Turns a spreadsheet row into a timeseries.
Columns for timestamps and values are extracted using the regular expressions, the timestamp columns are optional.class
SpreadSheetSelectSubset
Allows the user to select a subset of the incoming spreadsheet to be forwarded in the flow.class
SpreadSheetSetCell
Sets the value of the specified cells in a spreadsheet.class
SpreadSheetSetHeaderCell
Sets a single header cell value in a spreadsheet.class
SpreadSheetSort
Sorts the rows of the spreadsheet according to the selected column indices and sort order (ascending/descending).class
SpreadSheetSortColumns
Reorders a user-defined subset of columns by name using the specified comparator.class
SpreadSheetStatistic
Generates statistics from a SpreadSheet object.
If cells aren't numeric or missing, a default value of zero is used.class
SpreadSheetStorageRowIterator
Iterates through a defined range of rows.class
SpreadSheetSubset
Extracts a subset of rows/columns from a spreadsheet.class
SpreadSheetSubsetByValue
Generates subsets from a spreadsheet, grouped by the same string value in the specified column.
For instance, if a spreadsheet has 3 unique values (A, B, C) in column 2, then 3 subsheets will generated, each containing the rows that have the value A, B or C.class
SpreadSheetSubsetFromGroup
Splits the spreadsheet into subsets using the supplied column and then returns the specified range of rows from each generated subset.
The spreadsheet is expected to be sorted on the grouping column.class
SpreadSheetToTimeseries
Extracts one or more timeseries from a spreadsheet.
It uses one column ('ID') to identify all the rows that belong to a single timeseries.class
SpreadSheetTransformCells
Finds cells in a spreadsheet and transforms them with a callable transformer.
In case of transformers having Object or Unknown in their types of classes that they accept, no proper type can be inferred automatically.class
SpreadSheetTransformHeaderCells
Transforms header cells with a callable transformer.
In case of transformers having Object or Unknown in their types of classes that they accept, no proper type can be inferred automatically.class
SpreadSheetVariableRowIterator
Iterates through a defined range of rows.class
StorageCollectionInsert
Inserts the object passing through to the collection in storage at the specified position.
After inserting the object successfully, just forwards the object.
If the collection does not implement the java.util.List interface and the insertion is not at the end, the insertion will fail.
See also:
adams.flow.transformer.CollectionInsert
Input/output:
- accepts:
adams.flow.core.Unknown
- generates:
adams.flow.core.Unknown
class
StorageJFreeChartAddSeries
Generates a series from the incoming spreadsheet and adds it to the specified JFreeChart dataset in storage.
After inserting the object successfully, just forwards the object.class
StringArraySplit
Uses a regular expression to identify the string that triggers one or more splits in a string array, resulting in smaller arrays being output.
What is done with the string triggering the split, is defined in the split handling option, e.g., discard it.
Useful actor for splitting a log file into individual entry chunks.class
StringCut
Cuts out a part of a string.class
StringExpression
Evaluates a string expression.
The input string can be accessed via 'X'.
Variables are supported as well, e.g.: pow(X,@{exp}) with '@{exp}' being a variable available at execution time.
The following grammar is used for the expressions:
expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;
expr ::= ( expr )
# data types
| number
| string
| boolean
| date
# constants
| true
| false
| pi
| e
| now()
| today()
# negating numeric value
| -expr
# comparisons
| expr < expr
| expr <= expr
| expr > expr
| expr >= expr
| expr = expr
| expr != expr (or: expr <> expr)
# boolean operations
| ! expr (or: not expr)
| expr & expr (or: expr and expr)
| expr | expr (or: expr or expr)
| if[else] ( expr , expr (if true) , expr (if false) )
| ifmissing ( variable , expr (default value if variable is missing) )
| isNaN ( expr )
# arithmetics
| expr + expr
| expr - expr
| expr * expr
| expr / expr
| expr ^ expr (power of)
| expr % expr (modulo)
;
# numeric functions
| abs ( expr )
| sqrt ( expr )
| cbrt ( expr )
| log ( expr )
| log10 ( expr )
| exp ( expr )
| sin ( expr )
| sinh ( expr )
| cos ( expr )
| cosh ( expr )
| tan ( expr )
| tanh ( expr )
| atan ( expr )
| atan2 ( exprY , exprX )
| hypot ( exprX , exprY )
| signum ( expr )
| rint ( expr )
| floor ( expr )
| pow[er] ( expr , expr )
| ceil ( expr )
| min ( expr1 , expr2 )
| max ( expr1 , expr2 )
| year ( expr )
| month ( expr )
| day ( expr )
| hour ( expr )
| minute ( expr )
| second ( expr )
| weekday ( expr )
| weeknum ( expr )
# string functions
| substr ( expr , start [, end] )
| left ( expr , len )
| mid ( expr , start , len )
| right ( expr , len )
| rept ( expr , count )
| concatenate ( expr1 , expr2 [, expr3-5] )
| lower[case] ( expr )
| upper[case] ( expr )
| trim ( expr )
| matches ( expr , regexp )
| trim ( expr )
| len[gth] ( str )
| find ( search , expr [, pos] )
| replace ( str , pos , len , newstr )
| substitute ( str , find , replace [, occurrences] )
# array functions
| len[gth] ( array )
| get ( array , index )
;
Notes:
- Variables are either all upper case letters (e.g., "ABC") or any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- 'index' for function 'get' starts at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
e.g.class
StringIndent
Indents the string with the specified character.
Splits multi-line strings first and processes each line separately.class
StringIndexOf
Determines the position of a substring in the string passing through.
The generated index is 1-based, with 0 indicating that the substring could not be located.class
StringInsert
Inserts a user-specified string at a specific position into tokens coming through.
The actor is most useful when attaching a variable to the 'value' option, which allows the value to change dynamically then.class
StringJoin
Creates a single string out of an array of strings.class
StringLength
Determines the length of a string.class
StringMatcher
Lets string tokens only pass if they match the regular expression.class
StringRangeCut
Cuts out a parts of a string.class
StringReplace
Performs a string replacement, using either String.replaceFirst(...) or String.replaceAll(...).class
StringSanitizer
Removes all characters that haven't been specified as 'acceptable' characters.class
StringSplit
Splits a string using a regular expression.class
StringTrim
Trims strings, i.e., removes leading/trailing whitespaces.class
SubStringCount
Determines the position of a substring in the string passing through.
The generated index is 1-based, with 0 indicating that the substring could not be located.class
SummaryStatistics
Calculates the selected summary statistics and outputs a spreadsheet.class
SwapVariables
Swaps the values of the two variables around, whenever a token passes through.class
Tar
Creates a Tar file containing one or more files.class
TemplateTransformer
Feeds tokens into an actor generated from a template and broadcasts the generated output tokens.class
TesseractOCR
Applies OCR to the incoming image file using Tesseract.
In case of successful OCR, either the file names of the generated files are broadcast or the combined text of the files.
NB: The actor deletes all files that have the same prefix as the specified output base.class
TextFileReader
Reads a text file and forwards the content.
This actor takes the file to read as input.class
TextRenderer
Turns incoming objects into their textual representation, either automatic detection based on their data type or by explicitly specifying a renderer.class
TimeseriesAdd
Appends the incoming timeseries to the one available from storage.
If none yet available from storage, then the current one simply put into storage.
If the timeseries already contains elements with the same timestamp, then these will get replaced by the current ones.class
TimeseriesAppend
Appends the incoming timeseries to the one available from storage.
If none yet available from storage, then the current one simply put into storage.
If the timeseries already contains elements with the same timestamp, then these will get replaced by the current ones.class
TimeseriesDbReader
Outputs timeseries containers generated from an SQL SELECT statement.
A new container is started, whenever the value of the ID column changes (hence you need to ensure that the data is ordered on this column).class
TimeseriesFeatureGenerator
Applies a timeseries feature generator to the incoming timeseries and outputs the generated features.class
TimeseriesFileReader
Loads a file/directory containing spectrums from disk with a specified reader and passes them on.class
TimeseriesFileWriter
Saves a spectrum to disk with the specified writer and passes the absolute filename on.
As filename/directory name (depending on the writer) the database ID of the spectrum is used (below the specified output directory).class
TimeseriesFilter
Filters data using the specified filter.class
TimeseriesInfo
Outputs information for a timeseries.class
TimeseriesReportDbUpdater
Adds all the data to the report of the timeseries passing through that the SQL statement returns.
The {ID} placeholder can be used in the SQL statement to represent the current timeseries' ID.
The following types of SQL statements are supported:
- multiple rows of key-value pairs.
- single row, with the key being the column name.
Input/output:
- accepts:
adams.data.timeseries.Timeseries
- generates:
adams.data.timeseries.Timeseries
class
TimeseriesSplit
Splits the incoming timeseries into sub-series using the specified splitter algorithm.class
Timestamp
Creates a timestamp string whenever it receives an input token.class
Tool
Runs a tool.class
Touch
Like the Unix 'touch' command, updates the 'last modified' timestamp of the file coming through.
By default, it creates the file if it doesn't exist.class
UnBzip2
Decompresses an archive that was compressed with bzip2.class
UniqueID
Ensures that all passing through tokens that implement adams.data.id.MutableIDHandler have a unique ID.
All other tokens are just forwarded as is.class
UnLzf
Decompresses an archive that was compressed with LZF.class
UnLzma
Decompresses an archive that was compressed with LZMA (7zip).class
UnRAR
Unrars a RAR archive and broadcasts the full file names of the extracted files.class
UnTar
Decompresses a Tar archive and broadcasts the full file names of the extracted files.class
UnXz
Decompresses an archive that was compressed with XZ.class
UnZIP
Unzips a ZIP archive and broadcasts the full file names of the extracted files.class
UnZstd
Decompresses an archive that was compressed with Zstd.class
UpdateProperty
Updates the property of the object passing through with the specified value.class
ViaAnnotationsToReports
Converts the JSON object passing through to Reports.class
WaitForFile
Waits for the file passing through to become available, i.e., not in use by another process.class
WekaAccumulatedError
Generates plot containers from an evaluation object's predictions.class
WekaAggregateEvaluations
Aggregates incoming weka.classifiers.Evaluation objects and forwards the current aggregated state.class
WekaAttributeIterator
Iterates through all attributes of a dataset and outputs the names.
The attributes can be limited with the range parameter and furthermore with the regular expression applied to the names.
Instead of outputting the names, it is also possible to output the 1-based indices.class
WekaAttributeSelection
Performs attribute selection on the incoming data.
In case of input in form of a class adams.flow.container.WekaTrainTestSetContainer object, the train and test sets stored in the container are being used.
NB: In case of cross-validation no reduced or transformed data can get generated!
Input/output:
- accepts:
weka.core.Instances
adams.flow.container.WekaTrainTestSetContainer
- generates:
adams.flow.container.WekaAttributeSelectionContainer
Container information:
- adams.flow.container.WekaTrainTestSetContainer: Train, Test, Seed, FoldNumber, FoldCount, Train original indices, Test original indices
- adams.flow.container.WekaAttributeSelectionContainer: Train, Reduced, Transformed, Test, Test reduced, Test transformed, Evaluation, Statistics, Selected attributes, Seed, FoldCount
class
WekaAttributeSelectionSummary
Outputs a summary string of the attribute selection.class
WekaBootstrapping
Performs bootstrapping on the incoming evaluation and outputs a spreadsheet where each row represents the results from bootstrapping sub-sample.class
WekaChooseAttributes
Lets the user select attributes interactively to use down the track.
Internally, a weka.filters.unsupervised.attribute.Remove WEKA filter is constructed from the selection, to remove the attributes that the user didn't select.class
WekaClassifierInfo
Outputs information of a trained weka.classifiers.Classifier object.class
WekaClassifierOptimizer
Evaluates a classifier optimizer on an incoming dataset.class
WekaClassifierRanker
Performs a quick evaluation using cross-validation on a single dataset (or evaluation on a separate test set if the number of folds is less than 2) to rank the classifiers received on the input and forwarding the x best ones.static class
WekaClassifierRanker.RankingJob
A job class specific to ranking classifiers.class
WekaClassifierSetupProcessor
Applies the specified processor to the incoming array of classifiers, e.g., for generating new or filtered setups.class
WekaClassifying
Uses a serialized model to perform predictions on the data being passed through.
The following order is used to obtain the model (when using AUTO):
1.class
WekaClassSelector
Sets the class index.class
WekaClusterAssignments
Outputs the cluster assignments from the evaluation.class
WekaClustererInfo
Outputs information of a trained weka.clusterers.Clusterer object.class
WekaClustererPostProcessor
Applies the specified post-processor to the cluster container (adams.flow.container.WekaModelContainer)
See also:
adams.flow.transformer.WekaTrainClusterer
Input/output:
- accepts:
adams.flow.container.WekaModelContainer
- generates:
adams.flow.container.WekaModelContainer
Container information:
- adams.flow.container.WekaModelContainer: Model, Header, Dataset
class
WekaClusterEvaluationSummary
Generates a summary string of the weka.clusterers.ClusterEvaluation objects that it receives.class
WekaClustering
Uses a serialized model to cluster data being passed through.
The following order is used to obtain the model (when using AUTO):
1.class
WekaCrossValidationClustererEvaluator
Cross-validates a clusterer on an incoming dataset.class
WekaCrossValidationEvaluator
Cross-validates a classifier on an incoming dataset.class
WekaCrossValidationSplit
Generates train/test pairs like during a cross-validation run.class
WekaDatasetsMerge
Merges 2 or more datasets into a single dataset, under a selectable merge method.class
WekaDatasetSplit
Splits the incoming dataset into sub-sets using the specified splitter.class
WekaEnsembleGenerator
Uses the specified generator to create ensembles from the incoming data.class
WekaEvaluationInfo
Outputs information about a Weka weka.classifiers.Evaluation object.class
WekaEvaluationPostProcessor
Applies the specified post-processor to the incoming Evaluation data.class
WekaEvaluationSummary
Generates a summary string of the weka.classifiers.Evaluation objects that it receives.class
WekaEvaluationValuePicker
Picks a specific value from an evaluation object.class
WekaEvaluationValues
Generates a spreadsheet from statistics of an Evaluation object.class
WekaExperiment
Represents a Weka experiment, stored in a file.class
WekaExperimentEvaluation
Generates evaluation output of an experiment that was run previously.class
WekaExperimentExecution
Executes an experiment.class
WekaExperimentFileReader
Loads an experiment file.class
WekaExtractArray
Extracts a column or row of data from a weka.core.Instances or SpreadSheet object.
Only numeric columns can be returned.class
WekaExtractPLSMatrix
Transformer that allows the extraction of internal PLS filter/classifier matrices, forwarding them as spreadsheets.class
WekaFileReader
Reads any file format that Weka's converters can handle and returns the full dataset or single weka.core.Instance objects.class
WekaFilter
Filters Instances/Instance objects using the specified filter.
When re-using a trained filter, ensure that 'initializeOnce' is checked.
The following order is used to obtain the model (when using AUTO):
1.static class
WekaFilter.BatchFilterJob
class
WekaGenericPLSMatrixAccess
Transformer that allows the extraction of internal PLS filter/classifier matrices, forwarding them as spreadsheets.
See the respective PLS implementation for details on available matrix names (derived from: weka.filters.supervised.attribute.pls.AbstractPLS)
Input/output:
- accepts:
weka.classifiers.Classifier
weka.filters.Filter
weka.core.GenericPLSMatrixAccess
adams.flow.container.WekaModelContainer
- generates:
adams.data.spreadsheet.SpreadSheet
Container information:
- adams.flow.container.WekaModelContainer: Model, Header, Dataset
class
WekaGeneticAlgorithm
Applies the genetic algorithm to the incoming dataset.
Forwards the best setup(s) after the algorithm finishes.
A callable sink can be specified for receiving intermediate performance results.class
WekaGeneticAlgorithmInitializer
Populates a adams.flow.container.WekaGeneticAlgorithmInitializationContainer container from the data obtained from the incoming setup (in properties format, can be gzip compressed).class
WekaGetCapabilities
Retrieves the capabilities of a weka.core.CapabilitiesHandler (eg filter or classifier) and forwards them.class
WekaGetInstancesValue
Retrieves a value from a WEKA Instances object.
Notes:
- date and relational values are forwarded as strings
- missing values are output as '?' (without the single quotes)
Input/output:
- accepts:
weka.core.Instances
- generates:
java.lang.Double
java.lang.String
class
WekaGetInstanceValue
Retrieves a value from a WEKA Instance object.
Notes:
- date and relational values are forwarded as strings
- missing values are output as '?' (without the single quotes)
- the 'attribute name' option overrides the 'index' option
Input/output:
- accepts:
weka.core.Instance
- generates:
java.lang.Double
java.lang.String
Valid options are:class
WekaInstanceBuffer
Can act in two different ways:
1.class
WekaInstanceDumper
Dumps weka.core.Instance objects into an ARFF file.class
WekaInstanceEvaluator
Adds a new attribute to the data being passed through (normally 'evaluation') and sets the value to the evaluation value returned by the chosen evaluator scheme.class
WekaInstanceFileReader
Loads a WEKA dataset from disk with a specified reader and passes on the adams.core.instance.Instance objects.class
WekaInstancesAppend
Creates one large dataset by appending all one after the other.class
WekaInstancesHistogramRanges
Outputs the ranges generated by adams.data.statistics.ArrayHistogram using the incoming weka.core.Instances object.
The actor just uses the internal format (double array) and does not check whether the attributes are actually numeric.class
WekaInstancesInfo
Outputs statistics of a weka.core.Instances object.
FULL_ATTRIBUTE and FULL_CLASS output a spreadsheet with detailed attribute statistics.class
WekaInstancesMerge
Merges multiple datasets, either from file or using Instances/Instance objects.
If no 'ID' attribute is named, then all datasets must contain the same number of rows.
Attributes can be excluded from ending up in the final dataset via a regular expression.class
WekaInstancesStatistic
Generates statistics from a weka.core.Instances object.
The actor just uses the internal format (double array) and does not check whether the attributes are actually numeric.class
WekaInstanceStreamPlotGenerator
Generates plot containers from a range of attributes of the weka.core.Instance objects being passed through.
The generator merely uses the internal data representation for generating the Y value of the plot container.class
WekaModelReader
Actor for loading a model (classifier or clusterer).class
WekaMultiLabelSplitter
Splits a dataset containing multiple class attributes ('multi-label') into separate datasets with only a single class attribute.class
WekaNearestNeighborSearch
Outputs the specified number of nearest neighbors for the incoming Weka Instance.
The data used for the nearest neighbor search is either obtained from storage.class
WekaNewInstance
Creates a new weka.core.Instance-derived object, with all values marked as missing.
The class implementing the weka.core.Instance interface needs to have a constructor that takes the number of attributes as sole parameter.class
WekaPackageManagerAction
Applies the selected Weka Package Manager action to the incoming data and forwards the generated output.class
WekaPredictionsToInstances
Generates weka.core.Instances from the predictions of an Evaluation object.class
WekaPredictionsToSpreadSheet
Generates a SpreadSheet object from the predictions of an Evaluation object.
See also:
adams.flow.transformer.WekaSpreadSheetToPredictions
Input/output:
- accepts:
weka.classifiers.Evaluation
adams.flow.container.WekaEvaluationContainer
- generates:
adams.data.spreadsheet.SpreadSheet
Container information:
- adams.flow.container.WekaEvaluationContainer: Evaluation, Model, Prediction output, Original indices
class
WekaPrimeForecaster
Primes a forecaster with the incoming data and outputs the updated forecaster alongside the training header (in a model container).class
WekaPrincipalComponents
Performs principal components analysis on the incoming data and outputs the loadings and the transformed data as spreadsheet array.
Automatically filters out attributes that cannot be handled by PCA.class
WekaRandomSplit
Splits a dataset into a training and test set according to a specified split percentage.class
WekaRegexToRange
Produces a range string from a regular expression describing attributes.class
WekaRelationName
Deprecated.class
WekaRenameRelation
Modifies relation names.class
WekaReorderAttributesToReference
Reorders the attributes of the Instance/Instances passing through according to the provided reference dataset (callable actor or reference file).
This ensures that the generated data always has the same structure as the reference dataset.class
WekaRepeatedCrossValidationEvaluator
Performs repeated cross-validation a classifier on an incoming dataset.class
WekaRepeatedCrossValidationOutput
Generates output from the incoming repeated cross-validation data.class
WekaSetInstancesValue
Sets a value in a WEKA Instances object.
Notes:
- relational values cannot be set
- '?' (without single quotes) is interpreted as missing value
Input/output:
- accepts:
weka.core.Instances
- generates:
weka.core.Instances
class
WekaSetInstanceValue
Sets a value in a WEKA Instance.
Notes:
- relational values cannot be set
- '?' (without single quotes) is interpreted as missing value
Input/output:
- accepts:
weka.core.Instance
- generates:
weka.core.Instance
Valid options are:class
WekaSplitGenerator
class
WekaSpreadSheetToPredictions
Turns the predictions stored in the incoming spreadsheet (actual and predicted) into a Weka weka.classifiers.Evaluation object.
For recreating the predictions of a nominal class, the class distributions must be present in the spreadsheet as well.
See also:
adams.flow.transformer.WekaPredictionsToSpreadSheet
Input/output:
- accepts:
adams.data.spreadsheet.SpreadSheet
- generates:
weka.classifiers.Evaluation
class
WekaStoreInstance
Appends the incoming weka.core.Instance to the dataset in storage.class
WekaStreamEvaluator
Evaluates an incremental classifier on a data stream using prequential evaluation (first evaluate, then train).class
WekaStreamFilter
Filters Instance objects using the specified filter.class
WekaSubsets
Splits the dataset based on the unique values of the specified attribute: all rows with the same unique value form a subset.class
WekaTestSetClustererEvaluator
Evaluates a trained clusterer (obtained from input) on the dataset obtained from the callable actor.
If a class attribute is set, a classes-to-clusters evaluation is performed automatically
Input/output:
- accepts:
weka.clusterers.Clusterer
adams.flow.container.WekaModelContainer
- generates:
adams.flow.container.WekaClusterEvaluationContainer
Container information:
- adams.flow.container.WekaModelContainer: Model, Header, Dataset
- adams.flow.container.WekaClusterEvaluationContainer: Evaluation, Model, Log-likelohood
class
WekaTestSetEvaluator
Evaluates a trained classifier (obtained from input) on the dataset obtained from the callable actor.static class
WekaTestSetEvaluator.EvaluateJob
class
WekaTextDirectoryReader
Loads all text files in a directory and uses the subdirectory names as class labels.class
WekaTrainAssociator
Trains an associator based on the incoming dataset and outputs the built associator alongside the training header and rules (in a model container)..static class
WekaTrainAssociator.TrainJob
class
WekaTrainClassifier
Trains a classifier based on the incoming dataset and outputs the built classifier alongside the training header (in a model container).
Incremental training is performed, if the input are weka.core.Instance objects and the classifier implements weka.classifiers.UpdateableClassifier.static class
WekaTrainClassifier.BatchTrainJob
class
WekaTrainClusterer
Trains a clusterer based on the incoming dataset and output the built clusterer alongside the training header (in a model container).
Incremental training is performed, if the input are weka.core.Instance objects and the clusterer implements weka.clusterers.UpdateableClusterer.static class
WekaTrainClusterer.BatchTrainJob
class
WekaTrainForecaster
Trains a forecaster based on the incoming dataset and outputs the built model alongside the training header (in a model container).class
WekaTrainTestSetClustererEvaluator
Trains a clusterer on an incoming training dataset (from a container) and then evaluates it on the test set (also from a container).
The clusterer setup being used in the evaluation is a callable 'Clusterer' actor.
If a class attribute is set, a classes-to-clusters evaluation is performed automatically
Input/output:
- accepts:
adams.flow.container.WekaTrainTestSetContainer
- generates:
adams.flow.container.WekaClusterEvaluationContainer
Container information:
- adams.flow.container.WekaTrainTestSetContainer: Train, Test, Seed, FoldNumber, FoldCount
- adams.flow.container.WekaClusterEvaluationContainer: Evaluation, Model, Log-likelohood
class
WekaTrainTestSetEvaluator
Trains a classifier on an incoming training dataset (from a container) and then evaluates it on the test set (also from a container).
The classifier setup being used in the evaluation is a callable 'Classifier' actor.static class
WekaTrainTestSetEvaluator.EvaluateJob
class
XMLFileReader
Reads an XML file and forwards the parsed org.w3c.dom.Document object.class
XPath
Applies XPath to the DOM document object.class
XSLT
Applies an XSLT stylesheet to the DOM document object.class
Xz
Creates a XZ archive from a single file.class
YamlFileReader
Reads a YAML file and forwards the generated Map object.
http://yaml.org/
Input/output:
- accepts:
java.lang.String
java.io.File
- generates:
java.util.Map
class
ZIP
Creates a ZIP file containing one or more files.class
Zstd
Creates a Zstd archive from a single file. -
Uses of CleanUpHandler in adams.flow.transformer.locateobjects
Classes in adams.flow.transformer.locateobjects that implement CleanUpHandler Modifier and Type Class Description class
AbstractMetaObjectLocator
Ancestor for object locators that enhance a base locator.class
AbstractObjectLocator
Ancestor for algorithms that locate objects in images.class
BinaryContours
Uses the BoofCV contour-finding algorithm to locate objects.class
CannyBinary
Uses the BoofCV canny binary algorithm to locate objects.class
CannyEdges
Uses the BoofCV canny edges algorithm to locate objects.class
ChangeCanvasSize
Places the located objects obtained from the base locator on a canvas of specified size at the specified position.class
CroppedLocator
Uses the defined crop algorithm to first crop the image before locating objects.class
PassThrough
Dummy, just forwards container with input image.class
SizeFilter
Allows filtering the located objects based on the min/max width/height.class
XScreenMaskLocator
Using the XScreenMask, this locator masks out the background plate (similar to a green screening process)then proceeds to find blobs in the resultant image. -
Uses of CleanUpHandler in adams.flow.transformer.pixelselector
Classes in adams.flow.transformer.pixelselector that implement CleanUpHandler Modifier and Type Class Description class
AbstractColorProviderPixelSelectorOverlay
Overlay that uses a color provider for the painting the various elements of the overlay.class
AbstractPixelSelectorAction
Ancestor for actions for thePixelSelector
interactive transformer.class
AbstractPixelSelectorOverlay
Ancestor for overlays in the pixel selector GUI, making use of the data stored in the report.class
AbstractSingleColorPixelSelectorOverlay
Overlay that uses a single, user-defined color.class
AddClassification
Allows the user to select a pixel location and add a corresponding classification for it.
Stores the location with prefix 'Pixel.X.' and 'Pixel.Y.' and the classification using 'Classification.' as prefix.class
BottomRightCorner
Allows the user to select a pixel location of the bottom-right corner.
Stores the location in 'Pixel.Right' and 'Pixel.Bottom'.class
ClassificationOverlay
Highlights the chosen classifications.
Some actions that generate data for this overlay:
adams.flow.transformer.pixelselector.AddClassification
Valid options are:class
PixelSelectorPanel
Combines an ImagePanel and a Report table.class
RectangleOverlay
Simply highlights the selected pixel
Some actions that generate data for this overlay:
adams.flow.transformer.pixelselector.TopLeftCorner
adams.flow.transformer.pixelselector.BottomRightCorner
Valid options are:class
SimpleOverlay
Simply highlights the selected pixel
Some actions that generate data for this overlay:
adams.flow.transformer.pixelselector.SimpleSelect
Valid options are:class
SimpleSelect
Allows the user to select a pixel location.
Stores the location in 'Pixel.X' and 'Pixel.Y'.class
TopLeftCorner
Allows the user to select a pixel location of the top-left corner.
Stores the location in 'Pixel.Left' and 'Pixel.Top'. -
Uses of CleanUpHandler in adams.flow.transformer.pyrotransformer
Classes in adams.flow.transformer.pyrotransformer that implement CleanUpHandler Modifier and Type Class Description class
AbstractPyroTransformer
Ancestor for Pyro calls that transform data.class
ExampleGreeting
Uses the call described here: https://pythonhosted.org/Pyro4/intro.html#with-a-name-serverclass
Generic
Generic call, just forwards any data to the remote object.class
Null
Dummy, does nothing. -
Uses of CleanUpHandler in adams.gui.action
Subinterfaces of CleanUpHandler in adams.gui.action Modifier and Type Interface Description interface
BaseAction
Extended interface for actions.interface
BaseActionWithGroup
Action that offers a group name to be used for sorting.interface
PropertiesAction<T>
Ancestor for actions that use a Properties file as basis for shortcuts, icons and mnemonics.Classes in adams.gui.action that implement CleanUpHandler Modifier and Type Class Description class
AbstractActionWithDialog<D extends Dialog>
Actions that have an optional dialog associated which needs cleaning up.class
AbstractBaseAction
Action with some methods added for convenience.class
AbstractBaseActionWithGroup
Ancestor for actions that support a group.class
AbstractPropertiesAction<T,D extends Dialog>
Ancestor for actions that use a Properties file as basis for shortcuts, icons and mnemonics.class
AbstractPropertiesCheckBoxMenuItemAction<T,D extends Dialog>
Ancestor for checkbox menu item actions.class
AbstractPropertiesMenuItemAction<T,D extends Dialog>
Ancestor for simple menu item actions.class
AbstractPropertiesSubMenuAction<T,D extends Dialog>
Ancestor for actions in the flow editor that generate a submenu.class
ToggleAction
A specialized action class for menu items derived from JCheckBoxMenuItem. -
Uses of CleanUpHandler in adams.gui.application
Subinterfaces of CleanUpHandler in adams.gui.application Modifier and Type Interface Description interface
Child
The interface for the child frames/windows.Classes in adams.gui.application that implement CleanUpHandler Modifier and Type Class Description class
ChildFrame
Specialized JFrame class. -
Uses of CleanUpHandler in adams.gui.chooser
Subinterfaces of CleanUpHandler in adams.gui.chooser Modifier and Type Interface Description interface
RemoteDirectorySetup
Interface for setup classes that define access to remote directories.Classes in adams.gui.chooser that implement CleanUpHandler Modifier and Type Class Description class
AbstractChooserPanel<T>
A panel that contains a text field with the current choice and a button for bringing up a dialog offering the choice.class
AbstractChooserPanelWithIOSupport<T>
Ancestor for chooser panels that handle directory listers.class
AbstractDateBasedChooserPanel<T extends Date>
Ancestor for chooser panels that useDate
objects.class
BaseTextChooserPanel
A panel that contains a text field with the current text and a button to bring up a text editor dialog.class
ColorChooserPanel
A panel that contains a text field with the current Color (in hex notation) and a button for bringing up a Color dialog.class
DatasetFileChooserPanel
A panel that contains a text field with the current file and a button for bringing up a ConverterFileChooser.class
DateChooserPanel
Represents a text field and a button to open up a dialog for selecting a date.class
DateTimeChooserPanel
Represents a text field and a button to open up a dialog for selecting a date/time.class
DirectoryChooserPanel
A panel that contains a text field with the current directory and a button for bringing up a BaseDirectoryChooser.class
FieldChooserPanel
A panel that contains a text field with the current field and a button for bringing up a dialog for selecting from all available fields.class
FileChooserPanel
A panel that contains a text field with the current file/directory and a button for bringing up a BaseFileChooser.class
FontChooserPanel
A panel that contains a text field with the current Font and a button for bringing up a Font dialog.class
FtpDirectoryChooserPanel
Chooser for remote directories (via SFTP).class
FtpRemoteDirectorySetup
For configuring an SSH connection and remote directory.class
SelectOptionPanel
Allows the user to select either a single or multiple options from a list of available options.class
SftpDirectoryChooserPanel
Chooser for remote directories (via SFTP).class
SftpRemoteDirectorySetup
For configuring an SSH connection and remote directory.class
SmbDirectoryChooserPanel
Chooser for remote directories (via SMB).class
SmbRemoteDirectorySetup
For configuring an SMB connection and remote directory.class
SpreadSheetFileChooserPanel
A panel that contains a text field with the current file and a button for bringing up a SpreadSheetFileChooser.class
SpreadSheetQueryChooserPanel
A panel that contains a text field with the current spreadsheet query and a button for bringing up an editor for the query.class
SQLStatementChooserPanel
A panel that contains a text field with the current SQL statement and a button for bringing up an editor for the SQL statement.class
TimeChooserPanel
Represents a text field and a button to open up a dialog for selecting a date. -
Uses of CleanUpHandler in adams.gui.core
Classes in adams.gui.core that implement CleanUpHandler Modifier and Type Class Description class
DetachablePanel
Ancestor for panels that can be detached in a frame and also reattached again.class
MultiPagePane
Manages multiple pages, like JTabbedPane manages multiple tabs.static class
MultiPagePane.DetachablePage
class
SplitPanelWithOptionalComponents
A panel that has optional left/top or right/bottom components.class
SpreadSheetTableModel
The table model for displaying a SpreadSheet object.class
Undo
A general Undo/Redo-mechanism: stores objects either in memory or on disk. -
Uses of CleanUpHandler in adams.gui.dialog
Classes in adams.gui.dialog that implement CleanUpHandler Modifier and Type Class Description class
AbstractReplaceDialog<T>
A dialog that allows the user to select a field to find and replace with another one.class
ReplaceFieldDialog
A dialog that allows the user to select a field to find and replace with another one. -
Uses of CleanUpHandler in adams.gui.flow
Subinterfaces of CleanUpHandler in adams.gui.flow Modifier and Type Interface Description interface
FlowWorkerHandler
Interface for classes that can make use of theFlowWorker
worker class.Classes in adams.gui.flow that implement CleanUpHandler Modifier and Type Class Description class
FlowMultiPagePane
Specialized tabbed pane for Flow panels.class
FlowPanel
A panel for setting up, modifying, saving and loading "simple" flows.class
FlowRunnerPanel
Panel that allows the execution of flows. -
Uses of CleanUpHandler in adams.gui.flow.menu
Subinterfaces of CleanUpHandler in adams.gui.flow.menu Modifier and Type Interface Description interface
FlowEditorAction
Interface for menu items in the menu of the flow editor.Classes in adams.gui.flow.menu that implement CleanUpHandler Modifier and Type Class Description class
AbstractFlowEditorCheckBoxMenuItemAction
Ancestor for checkbox menu item actions in the flow editor.class
AbstractFlowEditorMenuItemAction
Ancestor for simple menu item actions in the flow editor.class
AbstractFlowEditorSubMenuAction
Ancestor for actions in the flow editor that generate a submenu.class
ActiveClearGraphicalOutput
Removes all graphical output.class
ActiveDebug
Executes the active flow in debug mode.class
ActiveDisplayErrors
Displays errors from last run.class
ActiveGC
Enables/disables running GC after active flow execution.class
ActiveHeadless
Enables/disables headless mode for active flow.class
ActiveKill
Kills the active flow.class
ActivePauseResume
Pauses/resumes the active flow.class
ActiveRun
Executes the flow flagged as active (if any).class
ActiveStop
Stops the active flow.class
ActiveStorage
Brings up dialog with current storage items.class
ActiveValidateSetup
Validates the active setup.class
ActiveVariables
Brings up dialog with current variables of the active flow.class
EditCheckVariables
Checks the variable usage.class
EditCleanUpFlow
Cleans up the flow.class
EditClearClipboard
Clears the system clipboard.class
EditDiff
Shows differences between versions of flows.class
EditEnableUndo
Enables/disables undo.class
EditFind
Opens find dialog.class
EditIgnoreNameChanges
Enables/disables ignoring of actor name changes.class
EditInteractiveActors
Enables/disables interactive actors.class
EditListTODOs
Opens dialog for listing TODOs.class
EditLocateActor
Opens dialog for locating actor.class
EditLocateStorageName
Opens dialog for locating a storage item.class
EditLocateVariable
Opens dialog for locating a variable.class
EditProcessActors
Applies an actor processor.class
EditRedo
Performs redo.class
EditTimedActors
Enables/disables timed actors.class
EditUndo
Performs undo.class
FileCheckOnSave
Enables/disables flow check before saving.class
FileClose
Closes the editor.class
FileClosePage
Lets user close a page.class
FileExport
Lets user export a flow.class
FileImport
Lets user import a flow.class
FileNewFlow
Opens a new tab with an emptyFlow
.class
FileNewFromClipboard
Opens a new tab with the actor from the clipboard.class
FileOpen
Lets user open a flow.class
FileProperties
Displays properties of a flow.class
FileRevert
Lets user revert a flow to version from disk.class
FileSave
Lets user save a flow.class
FileSaveAs
Lets user save a flow under new filename.class
HelpActors
Shows help on actors.class
HelpBooleanExpression
Shows help on boolean expressions.class
HelpClasses
Shows help on classes.class
HelpMathematicalExpression
Shows help on mathematical expressions.class
HelpStringExpression
Shows help on string expressions.class
HelpVariables
Shows help on variables.class
RunClearGraphicalOutput
Removes all graphical output.class
RunDebug
Executes the flow in debug mode.class
RunDisableAllBreakpoints
Disables all breakpoints.class
RunDisplayErrors
Displays errors from last run.class
RunEnableAllBreakpoints
Enables all breakpoints.class
RunGC
Enables/disables running GC after flow execution.class
RunHeadless
Enables/disables headless mode.class
RunKill
Kills the flow.class
RunParseError
Opens dialog for parsing an error.class
RunPauseResume
Pauses/resumes the flow.class
RunRemoveAllBreakpoints
Removes all breakpoints.class
RunRun
Executes the flow.class
RunRunAll
Executes all the flow.class
RunStop
Stops the flow.class
RunStopAll
Stops all the flow.class
RunStorage
Brings up dialog with current storage items.class
RunValidateSetup
Validates the current setup.class
RunVariables
Brings up dialog with current variables.class
ViewFullExpansion
Fully expands the flow and displays it in a new tab.class
ViewRedraw
Redraws the flow.class
ViewShowAnnotations
Enables/disables annotation visibility.class
ViewShowInputOutput
Enables/disables input/output hints visibility.class
ViewShowQuickInfo
Enables/disables quickinfo visibility.class
ViewShowSource
Displays the source of the flow.class
ViewShowToolbar
Enables/disables toolbar visibility.class
ViewStatistics
Displays statistics about the flow.class
ViewZoom
Sets the zoom level of the flow.class
WindowDuplicateInTab
Duplicates the flow in a new page.class
WindowDuplicateInWindow
Duplicates the flow in a new window.class
WindowHalfHeight
Adjust the height to half the screen.class
WindowHalfWidth
Adjust the width to half the screen.class
WindowMoveToNewWindow
Moves the tab to a new editor window.class
WindowNew
Opens a new editor window. -
Uses of CleanUpHandler in adams.gui.flow.notificationareaaction
Classes in adams.gui.flow.notificationareaaction that implement CleanUpHandler Modifier and Type Class Description class
AbstractNotificationAreaAction
Ancestor for actions on the notification area of the flow editor.class
CloseAndCleanUp
Closes the area panel and cleans up GUI output.class
Copy
Copies the content to the clipboard.class
Print
Lets the user print the content.class
Save
Saves the content to a file.class
SendErrorReport
Sends an error report to the support email address (if configured). -
Uses of CleanUpHandler in adams.gui.flow.tab
Classes in adams.gui.flow.tab that implement CleanUpHandler Modifier and Type Class Description class
FlowTabManager
Specialized JTabbedPane for managing tabs in the flow editor. -
Uses of CleanUpHandler in adams.gui.flow.tabhandler
Classes in adams.gui.flow.tabhandler that implement CleanUpHandler Modifier and Type Class Description class
AbstractTabHandler
Ancestor for tab handlers.class
GraphicalActorProcessorHandler
Manages the output from actor processors.class
GraphicalFlowExecutionListenersHandler
For managing registered flow execution listeners.class
ParsedErrorHandler
Manages the output from actor processors.class
RegisteredDisplaysHandler
For managing registered displays. -
Uses of CleanUpHandler in adams.gui.flow.tree
Classes in adams.gui.flow.tree that implement CleanUpHandler Modifier and Type Class Description class
ClipboardActorContainer
A simple container for multiple actors, for easy copying to and retrieving from the clipboard.class
Tree
A custom tree for displaying the structure of a flow.class
TreeOperations
Performs complex operations on the tree, like adding, removing, enclosing actors. -
Uses of CleanUpHandler in adams.gui.flow.tree.menu
Subinterfaces of CleanUpHandler in adams.gui.flow.tree.menu Modifier and Type Interface Description interface
TreePopupAction
Interface for menu items in the popup menu of the flow tree.Classes in adams.gui.flow.tree.menu that implement CleanUpHandler Modifier and Type Class Description class
AbstractAddBreakpointAction
Ancestor for adding breakpoint actors.class
AbstractAddMostCommonActorAction
Ancestor for actions that add most common actors.class
AbstractCompareActors
Ancestor for performing a diff on two actors.class
AbstractEncloseActor
Ancestor for menu items that can enclose selected actors in an actor handler.class
AbstractFromTemplateAction
Ancestor for template actions.class
AbstractTreePopupMenuItemAction
Ancestor for menu items in the popup menu of the flow tree.class
AbstractTreePopupSubMenuAction
Ancestor for menu items in the popup menu of the flow tree.class
AddActor
Menu for adding actors.class
AddActorAfter
For adding an actor after the current position.class
AddActorBeneath
For adding an actor beneath the current one.class
AddActorHere
For adding an actor at the current position.class
AddBookmark
Adds bookmarks for the selected actors.class
AddBreakpoint
Menu for adding breakpoints.class
AddBreakpointAfter
For adding a breakpoint after the current position.class
AddBreakpointBeneath
For adding a breakpoint beneath the current actor.class
AddBreakpointHere
For adding a breakpoint at the current position.class
AddFromTemplate
Menu for adding actors.class
AddFromTemplateAfter
For adding a subflow generated from a template after the current position.class
AddFromTemplateBeneath
For adding a subflow generated from a template beneath the current actor.class
AddFromTemplateHere
For adding a subflow generated from a template at the current position.class
AddMostCommonActor
Menu for adding most common actors.class
AddMostCommonActorAfter
For adding one of the most common actors after.class
AddMostCommonActorBeneath
For adding one of the most common actors beneath.class
AddMostCommonActorHere
For adding one of the most common actors here.class
AnnotateActor
Shortcut for annotating actors.class
AttachBreakpointHere
Attaches a breakpoint to the selected actor using its full name for aPathBreakpoint
.class
AttachListener
Allows the attaching of flow execution listeners.class
Bookmark
Submenu for adding/removing bookmarks.class
CleanUpActorName
For cleaning up an actor name.class
CollapseAll
For collapsing all actors below the currently selected one.class
CompareActors
Performs a diff on two actors.class
CompareJustActors
Performs a diff on two actors.class
CompareSubFlows
Performs a diff on two actors.class
CopyActor
For copying the currently selected actor(s) and placing them on the clipboard.class
CopyActorCommandline
For copying the currently selected actor and placing it on the clipboard.class
CopyActorMore
Menu for additional copy actions.class
CopyActorName
For copying the name of the currently selected actor on the clipboard.class
CopyActorPath
For copying the path(s) of the currently selected actor(s) and placing them on the clipboard.class
CopyActorPlainText
For copying the currently selected actor(s) and placing them on the clipboard.class
CreateCallableActor
Menu for turning actors into callable actors, using the specified callable actor handler.class
CutActor
For cutting out the currently selected actor(s) and placing them on the clipboard.class
EditActor
For editing/showing the options of an actor.class
EditExternalFlow
For editing an external flow.class
EditListeners
For editing currently attached listeners.class
EncloseActor
For enclosing the actors in an actor handler.class
EncloseActorAll
Menu item for enclosing actors in all available actor handlers.class
EncloseActorCommon
Menu item for enclosing actors in common actor handlers.class
EncloseActorCompact
Menu item for enclosing actors in all/common/special actor handlers.class
EncloseActorSpecial
Menu item for enclosing actors in special actor handlers.class
ExpandAll
For expanding all actors below the currently selected one.class
ExpandCollapseExternalFlow
For expanding/collapsing of an external flow.class
ExportActor
For exporting an actor, eg to Java code.class
ExternalFlow
Submenu for handling external flows.class
ExternalizeActor
For turning an actor into an external one.class
FindUsages
Finds usages of callable actors, variables and storage items.class
GoTo
Jumps to the callable actor reference by this actor.class
Help
For showing the help dialog for an actor.class
InspectMemory
Memory inspection sub-menu.class
InspectMemoryDetails
For analyzing the memory consumption of an actor.class
InspectMemorySize
For analyzing the memory consumption of a sub-tree.class
LastTemplate
For adding a subflow generated from a template, using the most recently used template scheme and insert position.class
Listeners
Manages listeners (add/remove).class
MakeConditional
For turning an actor into its conditonal equivalent.class
MakeInteractive
Takes one or more SetVariable standalones and turns them into a EnterManyValues actor inside a Trigger.class
MakeTimed
For turning an actor into its timed equivalent.class
MaterializeExternalActor
Materializes (= includes) an external actor.class
MenuHeader
Adds a disabled menu item to the popup menu with the name of the current actor.class
PasteActor
Menu for adding actors.class
PasteActorAfter
For pasting the actor(s) from the clipboard after the current position.class
PasteActorBeneath
For pasting the actor(s) from the clipboard beneath the current actor.class
PasteActorHere
For pasting the actor(s) from the clipboard at the current position.class
PullUpActor
For pulling up actors below a mutable actor handler, replacing the actor handler with them.class
RemoveActor
For removing actors.class
RemoveBookmark
For removing breakpoints either below currently selected node or everywhere (if no actor selected).class
RemoveBreakpoints
For removing breakpoints either below currently selected node or everywhere (if no actor selected).class
RemoveListeners
Allows the removal of attached flow execution listeners.class
RenameActor
For renaming actors.class
RunToHere
Attaches a one-off breakpoint to the selected actor using its full name for aPathBreakpoint
.class
Separator
Adds a separator to the menu.class
SwapActor
For swapping one actor with another.class
ToggleState
For enabling/disabling actors. -
Uses of CleanUpHandler in adams.gui.flow.tree.quickaction
Subinterfaces of CleanUpHandler in adams.gui.flow.tree.quickaction Modifier and Type Interface Description interface
TreeQuickAction
Interface for menu items in the quick action menu of the flow tree.Classes in adams.gui.flow.tree.quickaction that implement CleanUpHandler Modifier and Type Class Description class
AbstractGOEQuickAction
Ancestor for GOE-based quick actions.class
AbstractTreeQuickMenuItemAction
Ancestor for menu items in the quick action menu of the flow tree.class
ChangeCallableActor
Changes the callable actor that is being referenced.class
ChangeExternalActorFile
Lets the user update the external actor file.class
ChangeStorageName
Renames the name of the storage item.class
ChangeVariableName
Renames the name of the variable.class
ChangeVariableValue
Changes the value of the variable.class
EditBooleanCondition
Lets the user edit the boolean condition.class
EditBooleanExpressionText
Lets the user edit a BooleanExpressionText.class
EditCombineXExpression
Lets the user edit the expression of a CombineVariables/Storage source.class
EditConversion
Lets the user edit the conversion.class
EditMathematicalExpressionText
Lets the user edit a MathematicalExpressionText.class
EditStorageValuesArrayNames
Lets the user edit the variable names of a StorageValuesArray source.class
EditStringConstantsStrings
Lets the user edit the strings of a StringConstants source.class
EditVariablesArrayVariables
Lets the user edit the variable names of a VariablesArray source.class
-