Uses of Interface
adams.core.QuickInfoSupporter

Packages that use QuickInfoSupporter

Package	Description
adams.core
adams.core.command
adams.core.io
adams.core.io.filechanged
adams.core.net.hostnameverifier
adams.data.areaoverlap
adams.data.barcode.encode
adams.data.binning.algorithm
adams.data.binning.postprocessing
adams.data.boofcv.transformer
adams.data.compare
adams.data.conversion
adams.data.featureconverter
adams.data.groupextraction
adams.data.groupupdate
adams.data.idextraction
adams.data.idupdate
adams.data.image
adams.data.image.transformer
adams.data.image.transformer.subimages
adams.data.imagesegmentation.operation
adams.data.io.input
adams.data.jai.transformer
adams.data.matlab.multimatrixoperation
adams.data.objectfilter
adams.data.objectfinder
adams.data.objectoverlap
adams.data.opencv.transformer
adams.data.outlier
adams.data.spreadsheet.cellfinder
adams.data.spreadsheet.columnfinder
adams.data.spreadsheet.filter
adams.data.spreadsheet.rowfinder
adams.data.timeseries
adams.doc.listing
adams.flow.condition.bool
adams.flow.control
adams.flow.control.flowrestart.notification
adams.flow.control.flowrestart.operation
adams.flow.control.flowrestart.trigger
adams.flow.control.plotprocessor
adams.flow.control.removeoutliers
adams.flow.core
adams.flow.sink
adams.flow.sink.pyrosink
adams.flow.sink.sendnotification
adams.flow.sink.simplelogging.format
adams.flow.sink.simplelogging.output
adams.flow.source
adams.flow.source.filesystemsearch
adams.flow.source.inputstreamsource
adams.flow.source.newlist
adams.flow.source.pyrosource
adams.flow.source.readersource
adams.flow.source.wekaforecastersetup
adams.flow.source.wekapackagemanageraction
adams.flow.standalone
adams.flow.standalone.pyrostandalone
adams.flow.standalone.wekapackagemanageraction
adams.flow.template
adams.flow.transformer
adams.flow.transformer.arraysubsetgeneration
adams.flow.transformer.draw
adams.flow.transformer.exiftagoperation
adams.flow.transformer.generatefilebaseddataset
adams.flow.transformer.indexedsplitsrunsevaluation
adams.flow.transformer.indexedsplitsrunsgenerator
adams.flow.transformer.indexedsplitsrunspredictions
adams.flow.transformer.locateobjects
adams.flow.transformer.metadata
adams.flow.transformer.multimapoperation
adams.flow.transformer.multispreadsheetoperation
adams.flow.transformer.negativeregions
adams.flow.transformer.pdfgenerate
adams.flow.transformer.plotgenerator
adams.flow.transformer.preparefilebaseddataset
adams.flow.transformer.pyrotransformer
adams.flow.transformer.spreadsheetmethodmerge
adams.flow.transformer.timeseriessplit
adams.flow.transformer.wekadatasetsmerge
adams.flow.transformer.wekaevaluationpostprocessor
adams.flow.transformer.wekapackagemanageraction
adams.flow.transformer.wekarepeatedcrossvalidationoutput
adams.flow.websocket.client
adams.flow.websocket.server
adams.gui.flow.tree
adams.gui.tools.spreadsheetviewer.chart
adams.gui.visualization.jfreechart.chart
adams.gui.visualization.jfreechart.dataset
adams.gui.visualization.object.objectannotations.check
adams.gui.visualization.object.objectannotations.cleaning
adams.gui.visualization.object.objectannotations.colors
adams.gui.visualization.object.objectannotations.label
adams.gui.visualization.object.objectannotations.outline
adams.gui.visualization.object.objectannotations.shape
adams.multiprocess
adams.scripting.connection

Uses of QuickInfoSupporter in adams.core

Classes in adams.core that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	NumericStringCompare	Compares the numeric portion of two String objects by extracting it using the supplied regexp.

Uses of QuickInfoSupporter in adams.core.command

Subinterfaces of QuickInfoSupporter 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 QuickInfoSupporter

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 QuickInfoSupporter in adams.core.io

Classes in adams.core.io that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractFilenameGenerator	Ancestor for filename generators.
class	AbstractFilenameGeneratorWithDirectory	Ancestor for filename generators that use a directory.
class	AbstractFilenameGeneratorWithExtension	Ancestor for filename generators that require a provided extension.
class	DefaultFilenameGenerator	The default generator for database ID and ID handlers.
class	FixedFilenameGenerator	Simple concatenates directory, provided name and extension.
class	NullFilenameGenerator	Dummy filename generator, always outputs null.
class	ReportFieldFilenameGenerator	Obtains the filename from a field in the attached report.
class	SimpleFilenameGenerator	Simple generator that assembles filename based on output dir, prefix, current object (string representation), suffix and extension.
class	SimpleFixedFilenameGenerator	Simply returns the supplied file name.
class	SimpleObjectToStringFilenameGenerator	Simple generator that just turns the incoming object into a string using the 'toString()' method.
class	TimestampFilenameGenerator	Generator that assembles a filename based on output dir, prefix, current timestamp (according to format string), suffix and extension.

Uses of QuickInfoSupporter in adams.core.io.filechanged

Classes in adams.core.io.filechanged that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractFileChangeMonitor	Ancestor for file change monitors.
class	AbstractMessageDigestBasedMonitor	Ancestor for message digest based monitors.
class	FlowFileDigest	Generates a message digest for a flow file and uses that for comparison.
class	LastModified	Uses the lastmodified timestamp.
class	MessageDigest	Generates a message digest and uses that for comparison.
class	MultiMonitor	Combines the results of the specified monitors according to the combination type.
class	NoChange	Dummy, never reports a change.
class	Size	Uses the file size.

Uses of QuickInfoSupporter in adams.core.net.hostnameverifier

Classes in adams.core.net.hostnameverifier that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractHostnameVerifier	Ancestor for hostname verifiers.
class	All	Verifies all hosts.
class	RegExp	Hostnames must match regular expression.

Uses of QuickInfoSupporter in adams.data.areaoverlap

Subinterfaces of QuickInfoSupporter in adams.data.areaoverlap

Modifier and Type	Interface	Description
interface	AreaOverlap	Interface for classes that compute the overlapping areas between annotations and predictions.

Classes in adams.data.areaoverlap that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractAreaOverlap	Ancestor for area overlap computation schemes.
class	BoundingBoxBased	Uses bounding boxes for the calculation.
class	PolygonBased	Uses polygons for the calculation.

Uses of QuickInfoSupporter in adams.data.barcode.encode

Classes in adams.data.barcode.encode that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractBarcodeEncoder	Ancestor for barcode encoders, i.e., classes that generated barcode images.
class	EAN13	Draws an EAN13 barcode at a specified location and size.Digits must be 13 characters long.
class	PassThrough	* Dummy barcode type, draws nothing.
class	QRCode	Draws a QR code at a specified location and size.
class	UPCA	Draws a UPCA barcode at a specified location and size.Digits must be 11 (checksum gets calculated) or 12 (incl.

Uses of QuickInfoSupporter in adams.data.binning.algorithm

Subinterfaces of QuickInfoSupporter in adams.data.binning.algorithm

Modifier and Type	Interface	Description
interface	BinningAlgorithm	Interface for binning algorithms.
interface	FixedBinWidthBinningAlgorithm	Interface for binning algorithms that require a fixed bin width.
interface	FixedNumBinsBinningAlgorithm	Interface for binning algorithms that require to specify the number of bins.

Classes in adams.data.binning.algorithm that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractBinningAlgorithm	Ancestor for binning algorithms.
class	AbstractEqualWidthBinningAlgorithm	Ancestor for algorithms that use bins with the same width.
class	DensityBinning	Performs density-based binning.
class	FreedmanDiaconisChoiceBinning	The Freedman-Diaconis' choice is based on the interquartile range.
class	FrequencyBinning	Performs frequency binning.
class	ManualBinning	Generates a predefined number of equal sized bins.
class	NoBinning	Performs no real binning, just places all items in one bin.
class	RiceRuleBinning	The Rice Rule is presented as a simple alternative to Sturges's rule.
class	ScottsNormalReferenceRuleBinning	Scott's normal reference rule is optimal for random samples of normally distributed data, in the sense that it minimizes the integrated mean squared error of the density estimate.
class	SquareRootChoiceBinning	Takes the square root of the number of data points in the sample used by Excel histograms and many others) and rounds to the next integer.
class	SturgesFormulaBinning	Sturges' formula is derived from a binomial distribution and implicitly assumes an approximately normal distribution.

Uses of QuickInfoSupporter in adams.data.binning.postprocessing

Subinterfaces of QuickInfoSupporter in adams.data.binning.postprocessing

Modifier and Type	Interface	Description
interface	BinPostProcessing	Interface for schemes for post-processing bins.

Classes in adams.data.binning.postprocessing that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractBinPostProcessing	Ancestor for schemes for post-processing bins.
class	MinBinSize	Ensures that bins have the specified minimum number of objects stored.
class	PassThrough	Performs no post-processing.

Uses of QuickInfoSupporter in adams.data.boofcv.transformer

Classes in adams.data.boofcv.transformer that implement QuickInfoSupporter

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 QuickInfoSupporter in adams.data.compare

Classes in adams.data.compare that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractObjectCompare<T,R>	Ancestor for classes that compare objects and return a result.
class	DataContainer	Compares adams.data.container.DataContainer objects (header, data or both) and returns the result of that comparison.
class	JavaComparable	Compares objects that implement the Java java.lang.Comparable interface and returns the result of that comparison.

Uses of QuickInfoSupporter in adams.data.conversion

Subinterfaces of QuickInfoSupporter in adams.data.conversion

Modifier and Type	Interface	Description
interface	BufferedImageToOtherFormatConversion	Indicator interface for conversion that convert a BufferedImageContainer 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 a BufferedImageContainer.

Classes in adams.data.conversion that implement QuickInfoSupporter

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 '&lt;' 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 QuickInfoSupporter in adams.data.featureconverter

Classes in adams.data.featureconverter that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractFeatureConverter<D,R>	Ancestor for generic feature converter schemes.
class	AbstractMetaFeatureConverter	Ancestor for converters that use a base converter.
class	CountValues	Meta-feature-converter that counts numeric values that satisfy the specified min/max range.
class	Dataset	Turns the features into ADAMS dataset format.
class	FeatureContainer	Simply returns the header definition/row in a adams.flow.container.FeatureConverterContainer container.
class	FixedColumnText	Simple feature converter that generates textual output with fixed column width.
class	FixedNumFeatures	Meta-feature-converter 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	SpreadSheet	Generates features in spreadsheet format.
class	Text	Simple feature converter that generates a CSV-like textual output.
class	Weka	Generates features in spreadsheet format.

Uses of QuickInfoSupporter in adams.data.groupextraction

Subinterfaces of QuickInfoSupporter in adams.data.groupextraction

Modifier and Type	Interface	Description
interface	GroupExtractor	Ancestor for schemes that extract the group from objects.
interface	SpreadSheetRowGroupExtractor	Indicator interface for extractors that work on spreadsheet rows.
interface	SpreadSheetRowGroupExtractorWithColumn	Extractors that work on spreadsheet rows.

Classes in adams.data.groupextraction that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractGroupExtractor	Ancestor for schemes that extract the group from objects.
class	Manual	Just returns the supplied group.
class	Null	Dummy, extracts nothing.
class	ReportField	Returns the value of the specified field.
class	ReportFieldRegExp	Returns the value of the regexp group applied to the specified report field.
class	SpreadSheetCell	Returns the cell value of the spreadsheet row.
class	SpreadSheetCellRegExp	Applies regular expression to the cell value of the spreadsheet row and returns the specified expression group.
class	SpreadSheetCellWithLookUp	Returns the cell value of the spreadsheet row.

Uses of QuickInfoSupporter in adams.data.groupupdate

Subinterfaces of QuickInfoSupporter in adams.data.groupupdate

Modifier and Type	Interface	Description
interface	GroupUpdater	Ancestor for schemes that update the group of objects.

Classes in adams.data.groupupdate that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractGroupUpdater	Ancestor for schemes that update the group of objects.
class	PassThrough	Performs no update.
class	ReportField	Sets the group under the specified field in the report (either report or report handler).

Uses of QuickInfoSupporter in adams.data.idextraction

Subinterfaces of QuickInfoSupporter in adams.data.idextraction

Modifier and Type	Interface	Description
interface	IDExtractor	Ancestor for schemes that extract the ID from objects.

Classes in adams.data.idextraction that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractIDExtractor	Ancestor for schemes that extract the ID from objects.
class	Manual	Just returns the supplied ID.
class	Null	Does nothing.
class	ReportField	Returns the value of the specified field.
class	ReportFieldRegExp	Returns the value of the specified field after passing it through the find/replace pair.
class	SpreadSheetCell	Returns the cell value of the spreadsheet row.

Uses of QuickInfoSupporter in adams.data.idupdate

Subinterfaces of QuickInfoSupporter in adams.data.idupdate

Modifier and Type	Interface	Description
interface	IDUpdater	Ancestor for schemes that update the ID of objects.

Classes in adams.data.idupdate that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractIDUpdater	Ancestor for schemes that update the ID of objects.
class	IDHandler	Updates the ID of (mutable) ID handlers.
class	PassThrough	Performs no update.
class	ReportField	Sets the ID under the specified field in the report (either report or report handler).

Uses of QuickInfoSupporter in adams.data.image

Subinterfaces of QuickInfoSupporter 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 QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractImageTransformer<T extends AbstractImageContainer>	Abstract base class for AbstractImage transformations.

Uses of QuickInfoSupporter in adams.data.image.transformer

Subinterfaces of QuickInfoSupporter 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 QuickInfoSupporter

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 QuickInfoSupporter in adams.data.image.transformer.subimages

Classes in adams.data.image.transformer.subimages that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractSubImagesGenerator	Ancestor for classes that generate subimages from a single image.
class	Grid	Splits the image using a grid of specified number of columns and rows. Additional report values: - Row for the row - Column for the column - Coordinates for the 1-based coordinates (x,y,w,h) It is possible to generate overlapping images (all but last row and last column) by defining overlaps.
class	LabeledRegions	Extracts the sub-images according to the region definitions. Additional report values: - Region: for the region - Coordinates: for the 1-based coordinates (x,y,w,h)
class	Objects	Extracts sub-images defined by the objects that the object finder locates.
class	PassThrough	Dummy generator, simply passes the original image through.
class	Regions	Extracts the sub-images according to the region definitions. Additional report values: - Region for the region

Uses of QuickInfoSupporter in adams.data.imagesegmentation.operation

Classes in adams.data.imagesegmentation.operation that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractImageSegmentationContainerOperation	Abstract base class for operations that require multiple images.
class	CompareAnnotationWithPrediction	Compares a prediction (first container) with the annotation (second container) and outputs a color image per label that shows the correct overlaps, the missed annotations and additionally predicted pixels.
class	ConfusionMatrix	Evaluates a prediction (first container) against the annotation (second container) and outputs a spreadsheet with the confusion matrix.
class	CountPixels	Counts the pixels and generates a spreadsheet with count per layer.
class	EvaluatePrediction	Evaluates a prediction (first container) against the annotation (second container) and outputs a spreadsheet with the results.
class	PassThrough	Dummy, just passes through the containers.
class	SimpleOverlay	Combines base image (or just background color) and layers into a single image.

Uses of QuickInfoSupporter in adams.data.io.input

Classes in adams.data.io.input that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractCompressedTextReader	Ancestor for text readers of compressed files.
class	AbstractTextReader<T>	Ancestor for readers for text streams.
class	AbstractTextReaderWithEncoding<T>	Ancestor for text readers that support file encodings.
class	Bzip2TextFileReader	Reads content from bzip2 compressed text files.
class	GzippedTextFileReader	Reads content from gzipped text files.
class	LineArrayTextReader	Reads the text in as array of strings (each line is an array element). For large files, the data can be 'chunked' (ie outputting it in blocks).
class	LineByLineTextReader	Reads the text data, line by line.
class	LzfTextFileReader	Reads content from LZF compressed text files.
class	LzmaTextFileReader	Reads content from LZMA compressed text files.
class	SingleStringTextReader	Reads all text data into a single string and returns that
class	XzTextFileReader	Reads content from XZ compressed text files.
class	ZstdTextFileReader	Reads content from ZStd compressed text files.

Uses of QuickInfoSupporter in adams.data.jai.transformer

Classes in adams.data.jai.transformer that implement QuickInfoSupporter

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 QuickInfoSupporter in adams.data.matlab.multimatrixoperation

Classes in adams.data.matlab.multimatrixoperation that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractMultiMatrixOperation	Abstract base class for operations that require multiple matrices.
class	Add	Performs element-wise addition and outputs the result as single matrix.
class	ApplyMask	Performs element-wise subtraction and outputs the result as single matrix.
class	Combine	Combines the matrices into single one with additional dimension.
class	Subtract	Performs element-wise subtraction and outputs the result as single matrix.

Uses of QuickInfoSupporter in adams.data.objectfilter

Subinterfaces of QuickInfoSupporter in adams.data.objectfilter

Modifier and Type	Interface	Description
interface	ObjectFilter	Interface for image object filters.

Classes in adams.data.objectfilter that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractObjectFilter	Ancestor for image object filters.
class	AddDefaultLabel	For inserting a default label if missing.
class	AttachMetaData	Attaches the specified meta-data value.
class	AttachOverlappingMetaData	Attaches meta-data from the stored report
class	ClipBoundingBoxes	Ensures that bounding boxes fall within the image boundaries.
class	KeepEnclosed	Uses the outlines of annotations with the specified label to filter out any objects that aren't enclosed by these.
class	MakeSquare	Generates a square bounding box around the current center of the bounding box. Discards any polygon data.
class	MergeOverlaps	Merges overlapping objects into single object.
class	OffsetIndex	Offsets the object index.
class	PassThrough	Dummy, just returns the incoming object list.
class	RemoveDuplicatePolygonPoints	Removes duplicate points from polygons, e.g., introduced during scaling.
class	RemovePolygons	Removes polygon information.
class	RenameLabels	For renaming labels in the meta-data, stored under a specific key. The rules for renaming are specified: old=new.
class	Rotate	Rotates the objects using the specified degrees. Requires the original image width before the image got rotated in order to rotate the objects correctly.
class	Scale	Scales the objects.
class	TransformMetaData	Transforms the specified meta-data using the referenced callable actor.
class	Translate	Translates the objects by the specified X and Y.
class	UpdateBoundsFromPolygon	If polygon available, updates x//width/height with bounds of polygon.

Uses of QuickInfoSupporter in adams.data.objectfinder

Subinterfaces of QuickInfoSupporter in adams.data.objectfinder

Modifier and Type	Interface	Description
interface	ObjectFinder	Interface for finders that locate objects in the report of an image.

Classes in adams.data.objectfinder that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractMetaObjectFinder	Ancestor for object finders that use a base finder.
class	AbstractObjectFinder	Ancestor for finders that locate objects in the report of an image.
class	AllFinder	Returns all indices.
class	ByMetaDataNumericValue	Returns indices of objects which numeric meta-data value match the min/max.
class	ByMetaDataStringValue	Outputs the indices of objects where the specified regular expression matches the value associated with the given meta-data key.
class	HasMetaDataValue	Outputs the indices of objects where the specified meta-data key is present.
class	Invert	Inverts the indices of the base object finder.
class	MultiObjectFinder	Applies multiple object finding algorithms to the data. The indices can be either joined or intersected.
class	NullFinder	Finds no indices.
class	ObjectsInPolygon	Locates the objects that fall into the defined polygon. Partial hits can be considered as well.
class	ObjectsInRegion	Locates the objects that fall into the defined region. Partial hits can be considered as well.
class	PolygonPoints	Returns the indices of objects which polygons satisfy specified min/max for number of points.
class	Size	Applies the minimum/maximum constraints to width/height (according to the chosen type).

Uses of QuickInfoSupporter in adams.data.objectoverlap

Subinterfaces of QuickInfoSupporter in adams.data.objectoverlap

Modifier and Type	Interface	Description
interface	LabelAwareObjectOverlap	Interface for ObjectOverlap classes that can distinguish between correct/incorrect labels.
interface	ObjectOverlap	Interface for schemes that calculate image overlaps.

Classes in adams.data.objectoverlap that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractObjectOverlap	Ancestor for schemes that calculate image overlaps.
class	AreaRatio	Uses the area ratio between the annotated and predicted objects.
class	IntersectOverUnionRatio	Computes the Intersect Over Union (IOU) between annotations and predictions.
class	Null	Dummy, does not calculate any overlaps.

Uses of QuickInfoSupporter in adams.data.opencv.transformer

Classes in adams.data.opencv.transformer that implement QuickInfoSupporter

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 QuickInfoSupporter in adams.data.outlier

Classes in adams.data.outlier that implement QuickInfoSupporter

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.
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 QuickInfoSupporter in adams.data.spreadsheet.cellfinder

Subinterfaces of QuickInfoSupporter in adams.data.spreadsheet.cellfinder

Modifier and Type	Interface	Description
interface	CellFinder	Interface for classes that locate cells of interest in a spreadsheet.
interface	RowCellFinder	Finds cells in a spreadsheet row.

Classes in adams.data.spreadsheet.cellfinder that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractCellFinder	Ancestor for schemes that locate cells of interest in a spreadsheet.
class	AbstractRowCellFinder	Ancestor for cell finders that operate on sheets or rows.
class	CellRange	Locator that locates cells using a rectangular range.
class	CellTypeRange	Locator that locates cells of a certain type using a rectangular range.
class	ColumnFinderRange	Uses a column finder to locate the interesting columns.
class	CorrespondingColumn	Rather than return a cell that was located using the given cell finder, you can return a corresponding cell (within the same row). This allows you to locate cells with certain value but then update a different column in the same row.
class	RowFinderRange	Uses a row finder to locate the interesting rows.
class	SingleCell	Simple locator that just locates a single cell.

Uses of QuickInfoSupporter in adams.data.spreadsheet.columnfinder

Subinterfaces of QuickInfoSupporter in adams.data.spreadsheet.columnfinder

Modifier and Type	Interface	Description
interface	ColumnFinder	Interface for classes that "find" columns of interest in spreadsheets.
interface	TrainableColumnFinder	Interface for ColumnFinder algorithms that can be trained.

Classes in adams.data.spreadsheet.columnfinder that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractColumnFinder	Ancestor for classes that find columns of interest in spreadsheets.
class	AbstractFilteredColumnFinder	Ancestor for column finders that pre-filter the columns.
class	AbstractTrainableColumnFinder	Ancestor for ColumnFinder algorithms that can be trained.
class	AllFinder	Dummy finder, finds all columns.
class	ByContentType	Returns indices of columns that satisfy the specified content types.
class	ByExactName	Returns indices of columns which names match the exact name.
class	ByIndex	Returns indices of columns that fall in the defined range.
class	ByName	Returns indices of columns which names match the regular expression.
class	DownSample	Returns the indices of every n-th column.
class	FilteredColumnFinder	Filters the data first before applying the actual finder to locate the columns.
class	Invert	Inverts the selected columns of the provided sub-column-filter.
class	MultiColumnFinder	Applies multiple column finding algorithms to the data. The indices can be either joined or intersected.
class	NullFinder	Dummy finder, does not find any columns.
class	RowFilteredColumnFinder	This column finder first filters the rows before finding any columns on the subset of rows.
class	SubSample	Returns the indices of a subsample of columns.

Uses of QuickInfoSupporter in adams.data.spreadsheet.filter

Classes in adams.data.spreadsheet.filter that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractSpreadSheetFilter	Ancestor for spreadsheet filters.
class	AbstractTrainableSpreadSheetFilter	Ancestor for trainable spreadsheet filters.
class	Normalize	Normalizes numeric columns to the specified lower and upper bound.
class	PassThrough	Dummy filter.
class	Standardize	Standardizes numeric columns to mean 0.0 and standard deviation 1.0.
class	WekaFilter	Applies a Weka filter to the data.

Uses of QuickInfoSupporter in adams.data.spreadsheet.rowfinder

Subinterfaces of QuickInfoSupporter in adams.data.spreadsheet.rowfinder

Modifier and Type	Interface	Description
interface	RowFinder	Interface for classes that "find" rows of interest in spreadsheets.
interface	TrainableRowFinder	Interface for RowFinder algorithms that can be trained.

Classes in adams.data.spreadsheet.rowfinder that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractFilteredRowFinder	Ancestor for row finders that pre-filter the rows.
class	AbstractRowFinder	Ancestor for classes that find rows of interest in datasets.
class	AbstractTrainableRowFinder	Ancestor for RowFinder algorithms that can be trained.
class	AllFinder	Dummy finder, returns all rows.
class	ByContentType	Returns indices of rows which match the specified content type.
class	ByDateValue	Returns indices of rows which date/time type falls between the min/max.
class	ByIndex	Returns indices of rows that fall in the defined range.
class	ByNumericRange	Returns indices of rows which numeric value fall into the specified intervals.
class	ByNumericValue	Returns indices of rows which numeric value match the min/max.
class	ByStringComparison	Returns indices of rows which string value match the min/max.
class	ByValue	Returns indices of rows which label match the regular expression.
class	ClosestNumericValue	Returns the index of the row that comes closest to the provided numeric value.
class	DownSample	Returns the indices of every n-th row.
class	Invert	Inverts the selected rows of the provided sub-row-filter.
class	IsNumeric	Returns indices of rows that have numeric values in the specified column.
class	MissingValue	Returns indices of rows which label match the regular expression.
class	MultiRowFinder	Applies multiple row finding algorithms to the data. The indices can be either joined or intersected.
class	NullFinder	Dummy finder, does not find any rows.
class	SubSample	Returns the indices of a subsample of rows.

Uses of QuickInfoSupporter in adams.data.timeseries

Classes in adams.data.timeseries that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractMetaTimeseriesFeatureGenerator	Ancestor for generators that use a base generator.
class	AbstractTimeseriesFeatureGenerator<T extends Timeseries>	Abstract base class for Timeseries 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 QuickInfoSupporter in adams.doc.listing

Classes in adams.doc.listing that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractFileBasedListingOutput	Ancestor for schemes that output the listings to a file.
class	AbstractFileBasedListingOutputWithEncoding	Ancestor for output schemes that support file encodings.
class	AbstractListingOutput	Ancestor for classes that output the generated lists.
class	ConsoleOutput	Outputs the listings in simple plain text in the console.
class	HtmlOutput	Outputs the listing in HTML to the specified file.
class	MarkdownOutput	Outputs the listing in Markdown to the specified file.
class	OptionOutput	Creates a sub-directory for each module and stores the generated output in there, one file per class.

Uses of QuickInfoSupporter in adams.flow.condition.bool

Subinterfaces of QuickInfoSupporter in adams.flow.condition.bool

Modifier and Type	Interface	Description
interface	BooleanCondition	Ancestor for conditions that get evaluated in, e.g., the IfThenElse control actor, deciding which branch to take.
interface	IndexedBooleanCondition	Boolean conditions that return also an index, as they do encapsulate multiple boolean conditions at the same time.

Classes in adams.flow.condition.bool that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractAttributeCapabilities	Ancestor for capabilities-based conditions.
class	AbstractBooleanCondition	Ancestor for conditions that get evaluated in, e.g., the IfThenElse control actor, deciding which branch to take.
class	AbstractBooleanDatabaseCondition	Ancestor for conditions that operate on a database.
class	AbstractExpression	Ancestor for conditions that use a boolean expression.
class	AbstractMultiCondition	Ancestor for conditions that use multiple sub-conditions.
class	AbstractScript	Ancestor for boolean script conditions.
class	AbstractScriptedCondition	Abstract ancestor for actors that execute scripts.
class	AdamsInstanceCapabilities	Filters adams.data.instance.Instance based on defined capabilities.
class	And	Performs a logical AND over all its sub-conditions, i.e., it only evaluates to 'true' if all of the sub-conditions evaluate to 'true' as well.
class	BinaryFile	Evaluates to 'true' if the file exists and is a binary file. A heuristic is used to determine whether a file is binary, based on the first 1024 bytes.
class	BooleanReportValue	Returns 'true' if the boolean field in the report is present and is 'true'.
class	BytesComplete	Evaluates to 'true' if the bytes from the token are considered a 'complete' file.
class	Counting	Counts the tokens passing through and returns 'true' if min/max/interval are met.
class	DirectoriesMatch	Evaluates to 'true' if at least one sub-directory matches the regular expression in the specified directory.
class	DirectoryExists	Evaluates to 'true' if the directory exists.
class	Expression	Evaluates to 'true' if the expression evaluates to 'true'. In case of java.lang.Number tokens that arrive at the input, these can be accessed in the expression via 'X'; string tokens can be accessed via expression '"X"' (surrounding double quotes are required). If the incoming token is either a Report or a ReportHandler, the contents of the report get added as values as well (boolean, numeric or string) and you can access them via their name instead of 'X'. The following grammar is used for evaluating the boolean 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	False	Always evaluates to 'false'.
class	FileComplete	Evaluates to 'true' if the file (from option or token) is considered complete.
class	FileExists	Evaluates to 'true' if the file exists. If a filename generator other than adams.core.io.NullFilenameGenerator is specified, then this takes precedence over the supplied filename (uses the token passing through).
class	FileInUse	Evaluates to 'true' if the file is currently being used by another process. If a filename generator other than adams.core.io.NullFilenameGenerator is specified, then this takes precedence over the supplied filename (uses the token passing through).
class	FilesMatch	Evaluates to 'true' if at least one file matches the regular expression in the specified directory.
class	Groovy	A boolean condition that uses the condition defined in a Groovy script.
class	HasClass	Evaluates to 'true' if the specified class is available on the classpath.
class	HasColumn	Checks whether the spreadsheet passing through has a certain column.
class	HasElements	Checks whether the array passing through has a at least the specified number of elements.
class	HasExifTag	Checks whether the specified EXIF tag is present.
class	HashSet	Evaluates to true if the payload of the current token or the specified string (if non-empty) is present in the specified hashset. The value gets transformed using the specified conversion. See also: adams.flow.standalone.HashSetInit adams.flow.transformer.HashSetInit
class	HasInterface	Evaluates to 'true' if the objects implement the specified interface.
class	HasLength	Checks whether the array passing through has the required number of elements.
class	HasMapValue	Evaluates to true if the specified java.util.Map object is available in storage and a value is associated with the supplied key.
class	HasProperty	Evaluates to 'true' if the objects have the specified property path.
class	HasQueue	Evaluates to true if the specified queue is available in storage.
class	HasRows	Checks whether the spreadsheet passing through has the required number of rows.
class	HasSize	Checks whether the collection passing through has the required number of elements.
class	HasStorageValue	Evaluates to true if the specified storage value is present.
class	HasVariable	Evaluates to true if the specified variable is set.
class	HasVariableValue	Evaluates to true if the specified variable is present and its value is the same as the specified one.
class	InList	Checks whether the incoming string is among the specified items.
class	IsAndroid	Evaluates to 'true' if the operating system is Android.
class	IsArm64	Evaluates to 'true' if the system architecture is Arm64.
class	IsArray	Evaluates to 'true' if the object passing through represents an array.
class	IsBoolean	Evaluates to 'true' if the payload of the token is a boolean string (true|false).
class	IsByte	Evaluates to 'true' if the payload of the token is a byte number/string.
class	IsBzip2Compressed	Checks whether the file or byte array is Bzip2 compressed.
class	IsDouble	Evaluates to 'true' if the payload of the token is a double number/string.
class	IsFloat	Evaluates to 'true' if the payload of the token is a float number/string.
class	IsGzipCompressed	Checks whether the file or byte array is Gzip compressed.
class	IsInteger	Evaluates to 'true' if the payload of the token is an integer number/string.
class	IsLinux	Evaluates to 'true' if the operating system is Linux.
class	IsLong	Evaluates to 'true' if the payload of the token is a long number/string.
class	IsMac	Evaluates to 'true' if the operating system is a Mac.
class	IsMat5Array	Checks whether the object represents a Matlab array.
class	IsMat5Matrix	Checks whether the object represents a Matlab matrix.
class	IsMat5Struct	Checks whether the object represents a Matlab struct data structure.
class	IsNull	Evaluates to 'true' if the payload of the token passing through is null.
class	IsNumeric	Evaluates to 'true' if the payload of the token is a number or a numeric string.
class	IsRarCompressed	Checks whether the file or byte array is Rar compressed.
class	IsShort	Evaluates to 'true' if the payload of the token is a short number/string.
class	IsSubClass	Evaluates to 'true' if the objects are derived from the specified superclass.
class	IsWindows	Evaluates to 'true' if the operating system is a Windows variant.
class	IsXzCompressed	Checks whether the file or byte array is Xz compressed.
class	IsZipCompressed	Checks whether the file or byte array is Zip compressed.
class	IsZstdCompressed	Checks whether the file or byte array is Zstd compressed.
class	Not	Negates the output of the specified condition.
class	NotesErrors	Evaluates to true if the notes handler passing through has any errors recorded.
class	Or	Performs a logical OR over all its sub-conditions, i.e., it evaluates to 'true' if any of the sub-conditions evaluates to 'true' as well.
class	PromptUser	Prompts the user to click on 'positive' or 'negative' button (negative button can be omitted). The actor's name can be used in the message using the following placeholders: {SHORT} - the short name {FULL} - the full name (incl path) Variables get expanded as well. Can be used in a headless environment as well.
class	RegExp	Returns the result of the regular expression matching the incoming string.
class	ReportValueExists	Returns 'true' if the field in the report is present.
class	Scripted	A boolean condition that uses the condition defined in an external script.
class	StorageFlagSet	Evaluates to true if the specified storage value is present, a boolean and true.
class	TableExists	Checks whether table(s) exist that match the given regular expression.
class	True	Always evaluates to 'true'.
class	VariableFlagSet	Evaluates to true if the specified variable is present, a boolean and true.
class	WekaCapabilities	Filters weka.core.Instance and weka.core.Instances objects based on defined capabilities.
class	WekaClassification	Uses the index of the classification, i.e., the predicted label, as index of the switch

Uses of QuickInfoSupporter in adams.flow.control

Subinterfaces of QuickInfoSupporter 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 the Flow or LocalScopeTrigger actor.
interface	StorageHandler	Interface for actors that allow the storing of temporary data.

Classes in adams.flow.control that implement QuickInfoSupporter

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	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.
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.
class	IfThenElse	Emulates an If-Then-Else construct.
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	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.
class	Switch	Emulates a Switch control statement.
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 QuickInfoSupporter in adams.flow.control.flowrestart.notification

Classes in adams.flow.control.flowrestart.notification that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractNotification	Ancestor for notification schemes.
class	Null	Dummy, does nothing.
class	TimestampFile	Updates the timestamp in the specified file.

Uses of QuickInfoSupporter in adams.flow.control.flowrestart.operation

Classes in adams.flow.control.flowrestart.operation that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractRestartOperation	Ancestor for restart operations.
class	ExternalCommand	Executes an external command, eg systemd or Windows service.
class	FlowFile	Starts the specified flow.
class	MultiOperation	Executes multiple restart operations, one after the other.
class	Null	Dummy, does nothing.
class	RestartItself	Restarts the flow as defined in variable ActorUtils.FLOW_FILENAME_LONG.

Uses of QuickInfoSupporter in adams.flow.control.flowrestart.trigger

Classes in adams.flow.control.flowrestart.trigger that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractTrigger	Ancestor for restart triggers.
class	Cron	Triggers the restart according to the specified schedule.
class	FileMonitor	Monitors a file using the specified file change monitor.
class	MetaCron	Executes the base trigger according to the specified schedule.
class	MonitorItself	Monitors its own flow file with the specified file change monitor.
class	MultiTrigger	Manages multiple triggers.
class	Null	Dummy, does nothing.

Uses of QuickInfoSupporter in adams.flow.control.plotprocessor

Classes in adams.flow.control.plotprocessor that implement QuickInfoSupporter

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 QuickInfoSupporter in adams.flow.control.removeoutliers

Classes in adams.flow.control.removeoutliers that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractNumericOutlierDetector	Ancestor for numeric outlier detection.
class	AbstractOutlierDetector	Ancestor for outlier detectors of actual vs predicted.
class	IQR	Interquartile range based detector. If difference between actual/predicted is more than the factor of standard deviations away from the quartial 0.25/0.75, then the point gets flagged as outlier.
class	MeanAbsoluteError	Mean absolute error (MAE) based detector. If difference between actual/predicted is more than MAE * FACTOR, then the point gets flagged as outlier.
class	MultiOutlierDetector	Applies the specified outlier detectors sequentially and combines the detected outliers either via union or intersect.
class	Null	Dummy outlier detector, detects no outliers at all.
class	StdDev	Standard deviation based detector. If difference between actual/predicted is more than the factor of standard deviations away from the mean, then the point gets flagged as outlier.

Uses of QuickInfoSupporter in adams.flow.core

Subinterfaces of QuickInfoSupporter 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 implements BooleanConditionSupporter.
interface	ActorWithTimedEquivalent	Actors that have a timed equivalent, i.e., one that implements TimedActor.
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 a KeyManagerFactory.
interface	LazySetupSupporter	Interface for actors that optionally perform a Actor.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	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 of SSLContext.
interface	StopModeSupporter	Interface for actors that support a specific stop mode.
interface	StopRestrictor	Interface for actors that can limit the scope of the Stop 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 support TokenEvents and handle TokenListeners.
interface	TriggerableEvent	Indicator interface for events that can be triggered with the TriggerEvent actor.
interface	TrustManagerFactoryProvider	Interface for actors that provide an instance to a TrustManagerFactory.
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 QuickInfoSupporter

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.

Uses of QuickInfoSupporter in adams.flow.sink

Subinterfaces of QuickInfoSupporter in adams.flow.sink

Modifier and Type	Interface	Description
interface	DisplayPanelProvider	Interface for graphical sinks that can also generate a panel from scratch for a new token.

Classes in adams.flow.sink that implement QuickInfoSupporter

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	AbstractDbSink	Ancestor for sinks that use the database.
class	AbstractDisplay	Ancestor for actors that display stuff.
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	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.
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.
class	ImageViewer	Actor for displaying an image.
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.
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.
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.
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 QuickInfoSupporter in adams.flow.sink.pyrosink

Classes in adams.flow.sink.pyrosink that implement QuickInfoSupporter

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 QuickInfoSupporter in adams.flow.sink.sendnotification

Classes in adams.flow.sink.sendnotification that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractNotification	Ancestor for notification schemes.
class	Console	Outputs the message in the console (with optional prefix).
class	Email	Uses the incoming message as body in the email being sent.
class	LogFile	Outputs the message to a log file.
class	MessageBox	Simply pops up a message box with the notification.
class	MultiNotification	Executes the notifications sequentially.
class	Null	For suppressing notifications.

Uses of QuickInfoSupporter in adams.flow.sink.simplelogging.format

Subinterfaces of QuickInfoSupporter in adams.flow.sink.simplelogging.format

Modifier and Type	Interface	Description
interface	SimpleFormat	Interface for schemes that format logging messages.

Classes in adams.flow.sink.simplelogging.format that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractSimpleFormat	Ancestor for simple formatting schemes.
class	NoFormat	Applies no formatting, just forwards the message as is.
class	TimestampedFormat	Outputs the message using the specified format.

Uses of QuickInfoSupporter in adams.flow.sink.simplelogging.output

Subinterfaces of QuickInfoSupporter in adams.flow.sink.simplelogging.output

Modifier and Type	Interface	Description
interface	SimpleOutput	Interface for schemes that output logging messages.

Classes in adams.flow.sink.simplelogging.output that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractSimpleOutput	Ancestor for output schemes.
class	ConsoleOutput	Just outputs the message via stdout.
class	FileOutput	Appends the log messages to the specified file.
class	MultiOutput	Outputs the log message with all the specified sub-outputs.
class	RotatingFileOutput	Appends the log messages to the specified file, but also allows for rotating them.

Uses of QuickInfoSupporter in adams.flow.source

Subinterfaces of QuickInfoSupporter 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 QuickInfoSupporter

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.
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 QuickInfoSupporter in adams.flow.source.filesystemsearch

Classes in adams.flow.source.filesystemsearch that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractFileSystemSearchlet	Ancestor for file-system search algorithms.
class	AbstractFtpDirectoryListerBasedSearchlet	Ancestor for search algorithms that use FtpDirectoryLister under the hood.
class	AbstractLocalDirectoryListerBasedSearchlet	Ancestor for search algorithms that use LocalDirectoryLister under the hood.
class	AbstractSftpDirectoryListerBasedSearchlet	Ancestor for search algorithms that use SftpDirectoryLister under the hood.
class	AbstractSmbDirectoryListerBasedSearchlet	Ancestor for search algorithms that use SmbDirectoryLister under the hood.
class	BlockingSearch	Executes the base search till there is a non-empty list returned or, if specified, the timeout reached.
class	FtpDirectorySearch	Searches only for directories (FTP).
class	FtpDirectorySearchWithComparator	Searches only for directories, but uses the comparator for sorting the directories (FTP).
class	FtpDirectorySearchWithCustomSort	Searches only for directories, but uses a regular expression to reassemble the name and perform the sorting (FTP).
class	FtpFileSearch	Searches only for files (FTP).
class	FtpFileSearchWithComparator	Searches only for files, but uses the comparator for sorting the files (FTP).
class	FtpFileSearchWithCustomSort	Searches only for files, but uses a regular expression to reassemble the name and perform the sorting (FTP).
class	LocalDirectorySearch	Searches only for directories.
class	LocalDirectorySearchWithComparator	Searches only for directories, but uses the comparator for sorting the directories.
class	LocalDirectorySearchWithCustomSort	Searches only for directories, but uses a regular expression to reassemble the name and perform the sorting.
class	LocalDirectorySearchWithTimestampConstraints	Searches only for directories. Allows to further restrict the search using a timestamp window ('last modified') that the directories must satisfy.
class	LocalFileSearch	Searches only for files.
class	LocalFileSearchWithComparator	Searches only for files, but uses the comparator for sorting the files.
class	LocalFileSearchWithCustomSort	Searches only for files, but uses a regular expression to reassemble the name and perform the sorting.
class	LocalFileSearchWithTimestampConstraints	Searches only for files. Allows to further restrict the search using a timestamp window ('last modified') that the files must satisfy.
class	MultiSearch	Combines the search results of multiple search algorithms.
class	SftpDirectorySearch	Searches only for directories (SFTP).
class	SftpDirectorySearchWithComparator	Searches only for directories, but uses the comparator for sorting the directories (SFTP).
class	SftpDirectorySearchWithCustomSort	Searches only for directories, but uses a regular expression to reassemble the name and perform the sorting (SFTP).
class	SftpFileSearch	Searches only for files (SFTP).
class	SftpFileSearchWithComparator	Searches only for files, but uses the comparator for sorting the files (SFTP).
class	SftpFileSearchWithCustomSort	Searches only for files, but uses a regular expression to reassemble the name and perform the sorting (SFTP).
class	SmbDirectorySearch	Searches only for directories (SMB, Windows shares).
class	SmbDirectorySearchWithComparator	Searches only for directories, but uses the comparator for sorting the directories (SMB, Windows shares).
class	SmbDirectorySearchWithCustomSort	Searches only for directories, but uses a regular expression to reassemble the name and perform the sorting (SMB, Windows shares).
class	SmbFileSearch	Searches only for files (SMB, Windows shares).
class	SmbFileSearchWithComparator	Searches only for files, but uses the comparator for sorting the files (SMB, Windows shares).
class	SmbFileSearchWithCustomSort	Searches only for files, but uses a regular expression to reassemble the name and perform the sorting (SMB, Windows shares).

Uses of QuickInfoSupporter in adams.flow.source.inputstreamsource

Classes in adams.flow.source.inputstreamsource that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractInputStreamGenerator	Ancestor for classes that construct input streams.
class	FromFile	Generates an input stream from the specified file.
class	FromResource	Generates an input stream from the specified resource (eg from jar).

Uses of QuickInfoSupporter in adams.flow.source.newlist

Classes in adams.flow.source.newlist that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractListGenerator	Ancestor for list generators.
class	FixedList	Simply outputs the supplied list elements.
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)
class	Wrapper	Wraps the list items produced by the specified generator with user-supplied prefix and suffix.

Uses of QuickInfoSupporter in adams.flow.source.pyrosource

Classes in adams.flow.source.pyrosource that implement QuickInfoSupporter

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 QuickInfoSupporter in adams.flow.source.readersource

Classes in adams.flow.source.readersource that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractReaderGenerator	Ancestor for classes that construct readers.
class	FromFile	Generates a reader from the specified file.
class	FromResource	Generates a reader from the specified resource (eg from jar).

Uses of QuickInfoSupporter in adams.flow.source.wekaforecastersetup

Classes in adams.flow.source.wekaforecastersetup that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractForecasterGenerator	Ancestor for classes that generate AbstractForecaster instances.
class	BaselineAdjustedForecasterGenerator	Outputs a configured instance of a baseline-adjusted Forecaster.
class	WekaForecasterGenerator	Outputs a configured instance of a Weka Forecaster.

Uses of QuickInfoSupporter in adams.flow.source.wekapackagemanageraction

Classes in adams.flow.source.wekapackagemanageraction that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractWekaPackageManagerAction	Ancestor for package manager actions.
class	ListPackages	Lists the packages.

Uses of QuickInfoSupporter in adams.flow.standalone

Subinterfaces of QuickInfoSupporter 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 QuickInfoSupporter

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.
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 QuickInfoSupporter in adams.flow.standalone.pyrostandalone

Classes in adams.flow.standalone.pyrostandalone that implement QuickInfoSupporter

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 QuickInfoSupporter in adams.flow.standalone.wekapackagemanageraction

Classes in adams.flow.standalone.wekapackagemanageraction that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractWekaPackageManagerAction	Ancestor for package manager actions.
class	RefreshCache	Refreshes the package cache.

Uses of QuickInfoSupporter in adams.flow.template

Subinterfaces of QuickInfoSupporter in adams.flow.template

Modifier and Type	Interface	Description
interface	ActorTemplateUser	Interface for actors that make use for actor templates.

Uses of QuickInfoSupporter in adams.flow.transformer

Subinterfaces of QuickInfoSupporter 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 QuickInfoSupporter

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 update Report objects or reports that are part of a MutableReportHandler 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.
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.
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.
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.
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.
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)..
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.
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.
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.
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 QuickInfoSupporter in adams.flow.transformer.arraysubsetgeneration

Classes in adams.flow.transformer.arraysubsetgeneration that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractArraySubsetGenerator	Ancestor for schemes that generate array subsets.
class	EveryNth	Picks every nth element to be used in the new array.
class	Percentage	Uses the specified percentage to determine which nth elements to be used in the new array.
class	RangeSubset	Generates a subset of the array, using the specified array elements.
class	SimplePercentage	Uses the specified percentage to determine which first n elements are to be used in the new array.

Uses of QuickInfoSupporter in adams.flow.transformer.draw

Classes in adams.flow.transformer.draw that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractColorDrawOperation	Ancestor for operations that use a color.
class	AbstractColorStrokeDrawOperation	Ancestor for operations that use a colored, variable stroke.
class	AbstractDrawObjectsFromReport	Ancestor for overlays that use object locations from a report.
class	AbstractDrawOperation	Ancestor to all draw operations.
class	AnnotationsAndPredictions	Overlays the image with annotations and predictions from storage with their respective draw operations.
class	Barcode	* Draws a barcode with the specified color and dimensions at the given location.
class	FloodFill	Performs a flood-fill starting at the given position.
class	Image	Draws the image obtained from a callable actor at the specified location.
class	Line	Draws a line between the given start and end coordinates.
class	ObjectAnnotationsFromReport	Overlays object annotations from the report.
class	ObjectCentersFromReport	Displays the centers of objects in the image, using data from the attached report. Suffixes: .x .y .width .height Optionally, if type information is available per object, the locations can be displayed in distinct colors per type.
class	ObjectLocationsFromReport	Displays the locations of objects in the image, using data from the attached report. Suffixes: .x .y .width .height Optionally, if type information is available per object, the locations can be displayed in distinct colors per type.
class	Oval	Draws an oval with the specified color and dimensions at the given location.
class	Pixel	Draws a pixel with the specified color at the specified location.
class	Rectangle	Draws a rectangle with the specified color and dimensions at the given location.
class	Text	Draws text with a specified font at the given location.

Uses of QuickInfoSupporter in adams.flow.transformer.exiftagoperation

Subinterfaces of QuickInfoSupporter in adams.flow.transformer.exiftagoperation

Modifier and Type	Interface	Description
interface	ExifTagExistsOperation<I>	Interface for EXIF tag exists operations.
interface	ExifTagOperation<I,O>	Interface for EXIF tag operations.
interface	ExifTagReadOperation<I,O>	Interface for EXIF tag read operations.
interface	ExifTagRemoveOperation<I,O>	Interface for EXIF tag removal operations.
interface	ExifTagWriteOperation<I,O>	Interface for EXIF tag write operations.

Classes in adams.flow.transformer.exiftagoperation that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractApacheCommonsExifTagOperation<I,O>	Ancestor for EXIF tag operations using the Apache Commons Imaging library.
class	AbstractExifTagOperation<I,O>	Ancestor for operations on EXIF data.
class	ApacheCommonsExifTagExists	Checks whether the specified tag is present in the the file.
class	ApacheCommonsExifTagRead	Reads the specified tag from the file and forwards the information.
class	ApacheCommonsExifTagRemove	Removes the specified tag from the file.
class	ApacheCommonsExifTagWrite	Sets the specified tag value in the file.

Uses of QuickInfoSupporter in adams.flow.transformer.generatefilebaseddataset

Classes in adams.flow.transformer.generatefilebaseddataset that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractFileBasedDatasetGeneration<T>	Ancestor for schemes that generate datasets.
class	SimpleFileList	Simply outputs the specified list of files in the container as a text file.

Uses of QuickInfoSupporter in adams.flow.transformer.indexedsplitsrunsevaluation

Subinterfaces of QuickInfoSupporter in adams.flow.transformer.indexedsplitsrunsevaluation

Modifier and Type	Interface	Description
interface	IndexedSplitsRunsEvaluation<I,O>	Interface for performing evaluations on indexed splits runs.

Classes in adams.flow.transformer.indexedsplitsrunsevaluation that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractIndexedSplitsRunsEvaluation<I,O>	Ancestor for performing evaluations on indexed splits runs.
class	InstancesIndexedSplitsRunsEvaluation	Evaluates the specified classifier on the indexed splits runs applied to the incoming data.
class	NullEvaluation	Dummy, does nothing.

Uses of QuickInfoSupporter in adams.flow.transformer.indexedsplitsrunsgenerator

Subinterfaces of QuickInfoSupporter in adams.flow.transformer.indexedsplitsrunsgenerator

Modifier and Type	Interface	Description
interface	IndexedSplitsRunsGenerator	Interface for schemes that generate indexed splits runs.
interface	InstancesIndexedSplitsRunsGenerator	Indicator interface for generators that process Instances objects.
interface	SpreadSheetIndexedSplitsRunsGenerator	Indicator interface for generators that process Instances objects.

Classes in adams.flow.transformer.indexedsplitsrunsgenerator that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractIndexedSplitsRunsGenerator	Ancestor for schemes that generate indexed splits runs.
class	AbstractInstancesIndexedSplitsRunsGenerator	Ancestor for generators that process Instances objects.
class	AbstractSpreadSheetIndexedSplitsRunsGenerator	Ancestor for generators that process SpreadSheet objects.
class	InstancesCrossValidationFoldGenerator	Split generator that generates folds for cross-validation for Instances objects.
class	InstancesGroupedCrossValidationFoldGenerator	Split generator that generates folds for cross-validation for Instances objects.
class	InstancesGroupedRandomSplitGenerator	Random split generator that works on Instances objects (groups instances).
class	InstancesRandomSplitGenerator	Random split generator that works on Instances objects.
class	ManualSplitGenerator	Uses the manually defined split ranges to generate the splits.
class	MultiRunGenerator	Generates the specified number of runs using the configured base generator.
class	SpreadSheetRandomSplitGenerator	Random split generator that works on spreadsheets.

Uses of QuickInfoSupporter in adams.flow.transformer.indexedsplitsrunspredictions

Subinterfaces of QuickInfoSupporter in adams.flow.transformer.indexedsplitsrunspredictions

Modifier and Type	Interface	Description
interface	IndexedSplitsRunsPredictions<T>	Interface for generating predictions on indexed splits runs.

Classes in adams.flow.transformer.indexedsplitsrunspredictions that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractIndexedSplitsRunsPredictions<T>	Ancestor for generates predictions on indexed splits runs.
class	InstancesIndexedSplitsRunsPredictions	Trains the referenced classifier on the training splits and generates predictions for the test splits.
class	NullPredictions	Dummy, does nothing.

Uses of QuickInfoSupporter in adams.flow.transformer.locateobjects

Classes in adams.flow.transformer.locateobjects that implement QuickInfoSupporter

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 QuickInfoSupporter in adams.flow.transformer.metadata

Classes in adams.flow.transformer.metadata that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractMetaDataExtractor	Ancestor for algorithms that extract meta-data from image files.
class	ApacheCommons	Uses the Apache Commons Imaging library to extract the meta-data. For more information see: https://commons.apache.org/proper/commons-imaging/
class	MetaDataExtractor	Uses the MetaDataExtractor library to extract the meta-data. For more information see: http://code.google.com/p/metadata-extractor/

Uses of QuickInfoSupporter in adams.flow.transformer.multimapoperation

Classes in adams.flow.transformer.multimapoperation that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractMultiMapOperation<O>	Abstract base class for operations that require multiple maps.
class	CommonKeys	Outputs the common keys among the maps.
class	Merge	Merges the maps.
class	PassThrough	Dummy, just passes through the data.

Uses of QuickInfoSupporter in adams.flow.transformer.multispreadsheetoperation

Classes in adams.flow.transformer.multispreadsheetoperation that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractIndentifiableRowOperation	Identifies rows and then applies the actual operation to them.
class	AbstractMultiSpreadSheetOperation<O>	Abstract base class for operations that require multiple spreadsheets.
class	CommonIDs	Extracts the common IDs from two or more spreadsheets. Matching sense can be inverted, i.e., the IDs not in common are output.
class	Difference	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	Merge	Merges 2 or more spreadsheets into a single spreadsheet, using a selectable merge method.
class	Overlay	Combines non-empty cells from the spreadsheets into one by overlaying them.
class	PassThrough	Dummy, just passes through the data.
class	Sum	Computes the sum of the numeric cells between two spreadsheets. The values of the second spreadsheet are added to the first one. If no 'key' columns are defined, the current order of rows is used for comparison.

Uses of QuickInfoSupporter in adams.flow.transformer.negativeregions

Classes in adams.flow.transformer.negativeregions that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractMetaNegativeRegionsGenerator	Ancestor for meta-algorithms.
class	AbstractNegativeRegionsGenerator	Ancestor for algorithms for generating negative regions.
class	LargestRegions	Returns only the top X largest regions from the base generator.
class	MaxDimensions	Enforces the specified maximum dimensions.
class	MinDimensions	Enforces the specified minimum dimensions.
class	Null	Dummy, generates no regions.
class	RandomRegions	Generates specified number of random regions and then prunes ones that overlap with other regions or annotations.
class	SimpleBlockFill	Finds largest blocks from starting points on grid.

Uses of QuickInfoSupporter in adams.flow.transformer.pdfgenerate

Classes in adams.flow.transformer.pdfgenerate that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractPDFGenerator	Ancestor for schemes to generate PDFs.
class	AbstractScript	Ancestor for PDF generator scripts.
class	AbstractScriptedPDFGenerator	Abstract ancestor for PDF generators that execute external scripts.
class	Proclets	Processes an array of files using the specified PDF proclets.
class	Scripted	A PDF generator that uses any scripting handler for processing the objects with a script located in the specified file.

Uses of QuickInfoSupporter in adams.flow.transformer.plotgenerator

Classes in adams.flow.transformer.plotgenerator that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractPlotGenerator	Ancestor for generators that use data from a spreadsheet to create plot containers for the SequencePlotter sink.
class	AndrewsCurvesGenerator	Generates plot containers from row-based data for Andrews Curves. César Ignacio García Osorio, Colin Fyfe (2003).
class	NamedPlotGenerator	Plots the numeric data of two columns, X and Y with the plot name from a separate column.
class	RowWisePlotGenerator	Generates a separate plot per row in the spreadsheet, using the specified columns as data points.
class	SimplePlotGenerator	Plots the numeric data from one or more columns.
class	XYPlotGenerator	Uses one column for the X value and one or more other columns as Y to plot against.
class	XYWithErrorsPlotGenerator	Generator for X/Y plots (with X optional) that attaches error information for Y and optionally X as well.

Uses of QuickInfoSupporter in adams.flow.transformer.preparefilebaseddataset

Classes in adams.flow.transformer.preparefilebaseddataset that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractFileBasedDatasetPreparation<T>	Ancestor for schemes that prepare file-based datasets.
class	AbstractRandomizableFileBasedDatasetPreparation<T>	Ancestor for schemes that randomize the files.
class	CrossValidation	Generates cross-validation folds.
class	GroupedCrossValidation	Generates grouped cross-validation folds.
class	GroupedTrainTestSplit	Generates a train/test split using the specified grouping.
class	GroupedTrainValidateTestSplit	Generates a train/validate/test split using the specified grouping.
class	Selected	Generates a container from the selected elements of the array.
class	TrainTestSplit	Generates a train/test split.
class	TrainValidateTestSplit	Generates a train/validate/test split.

Uses of QuickInfoSupporter in adams.flow.transformer.pyrotransformer

Classes in adams.flow.transformer.pyrotransformer that implement QuickInfoSupporter

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-server
class	Generic	Generic call, just forwards any data to the remote object.
class	Null	Dummy, does nothing.

Uses of QuickInfoSupporter in adams.flow.transformer.spreadsheetmethodmerge

Classes in adams.flow.transformer.spreadsheetmethodmerge that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractMerge	Base class for all spreadsheet merge methods.
class	JoinOnID	Joins the spreadsheets by concatenating rows that share a unique ID.
class	Simple	Just merges the spreadsheets side by side.

Uses of QuickInfoSupporter in adams.flow.transformer.timeseriessplit

Classes in adams.flow.transformer.timeseriessplit that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractSplitOnDate	Ancestor for splitters that split on a date.
class	AbstractTimeseriesSplitter	Ancestor for timeseries splitters.
class	FixedDate	Splits the timeseries using the specified date.
class	FixedLengthSegments	Splits the timeseries into segements of a fixed length, i.e., number of data points.
class	FixedNumSegments	Splits the timeseries into a fixed number of same-sized segements.
class	PassThrough	Performs no splitting, just passes through the original timeseries.
class	ReportDate	Splits the timeseries using a field from its report. Accepted date formats: yyyy-MM-dd HH:mm:ss yyyy-MM-dd HH:mm:ss.S yyyy-MM-dd

Uses of QuickInfoSupporter in adams.flow.transformer.wekadatasetsmerge

Classes in adams.flow.transformer.wekadatasetsmerge that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractMerge
class	JoinOnID	Joins the datasets by concatenating rows that share a unique ID.
class	Simple	Just merges the datasets side by side.

Uses of QuickInfoSupporter in adams.flow.transformer.wekaevaluationpostprocessor

Classes in adams.flow.transformer.wekaevaluationpostprocessor that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractNumericClassPostProcessor	Ancestor for numeric class post-processors.
class	AbstractWekaEvaluationPostProcessor	Ancestor for classes that post-process Evaluation objects.
class	MultiPostProcessor	Applies the specified post-processors sequentially to the input data and combines their output.
class	PassThrough	Does nothing, just passes through the input data.
class	RemoveWorst	Removes the worst predictions, which are considered outliers that detract from the actual model performance.
class	RemoveWorstStdDev	Removes the worst predictions, which are considered outliers that detract from the actual model performance.
class	SimpleSubRange	Generates an Evaluation object based on the actual class values that fall within the specified interval ranges.
class	SubRange	Generates an Evaluation object based on the actual class values that fall within the specified interval ranges.

Uses of QuickInfoSupporter in adams.flow.transformer.wekapackagemanageraction

Classes in adams.flow.transformer.wekapackagemanageraction that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractWekaPackageManagerAction	Ancestor for package manager actions.
class	InstallFromFile	Action that installs packages from files.
class	InstallFromURL	Action that installs packages from URLs.
class	InstallOfficial	Action that installs official packages via their name and (optional) version.
class	InstallPackage	Action that installs the incoming package.
class	Uninstall	Action that removes installed packages.

Uses of QuickInfoSupporter in adams.flow.transformer.wekarepeatedcrossvalidationoutput

Classes in adams.flow.transformer.wekarepeatedcrossvalidationoutput that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractWekaRepeatedCrossValidationOutput<T>	Ancestor for classes that generate output from repeated cross-validations.
class	Predictions	Generates statistics for predictions from repeated cross-validation runs.
class	SamplePlot	Generates plot containers with statistics derived for each sample across the cross-validation runs.
class	Statistics	Generates mean/stddev for the specified statistics.

Uses of QuickInfoSupporter in adams.flow.websocket.client

Classes in adams.flow.websocket.client that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractWebSocketClientGenerator	Ancestor for client generators.
class	SimpleSendGenerator	Generates the SimpleSend client.
class	SimpleSendWithQueueGenerator	Generates the SimpleSendWithQueue client.

Uses of QuickInfoSupporter in adams.flow.websocket.server

Classes in adams.flow.websocket.server that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractWebSocketServerGenerator	Ancestor for server generators.
class	EchoServerGenerator	Generates a simple echo server.

Uses of QuickInfoSupporter in adams.gui.flow.tree

Classes in adams.gui.flow.tree that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	ClipboardActorContainer	A simple container for multiple actors, for easy copying to and retrieving from the clipboard.

Uses of QuickInfoSupporter in adams.gui.tools.spreadsheetviewer.chart

Classes in adams.gui.tools.spreadsheetviewer.chart that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractChartGenerator	Ancestor for classes that generate/display charts using a flow as backend.
class	AbstractRowBasedChartGenerator	Ancestor for row-based plot generators.
class	AbstractXYChartGenerator	Ancestor for X/Y (or just Y) plot generators.
class	BarPlot	Generates a bar plot by plotting the X column against the Y column.
class	ControlChart	Generates the specified control chart from the data.
class	GenericPlot	Flexible chart generator.
class	Histogram	Generates histograms by plotting the X column against the Y column.
class	JFreeChart	Uses JFreeChart to display the data.
class	LinePlot	Generates a line plot by plotting the X column against one or more Y columns.
class	ScatterPlot	Generates a scatter plot by plotting the X column against one or more Y columns.

Uses of QuickInfoSupporter in adams.gui.visualization.jfreechart.chart

Classes in adams.gui.visualization.jfreechart.chart that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractChartGenerator<T extends org.jfree.data.general.Dataset>	Ancestor for chart generators.
class	AbstractChartGeneratorWithAxisLabels<T extends org.jfree.data.general.Dataset>	Ancestor for chart generators that support axis labels.
class	BarChart	Generates bar chart from category data.
class	BubbleChart	Generates bubble chart from XYZ data (Z is size of bubble).
class	ScatterPlot	Generates a scatter plot from XY data.
class	XYLineChart	Generates line chart from XY data.

Uses of QuickInfoSupporter in adams.gui.visualization.jfreechart.dataset

Classes in adams.gui.visualization.jfreechart.dataset that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractDatasetGenerator<T extends org.jfree.data.general.Dataset>	Ancestor for dataset generators.
class	DefaultCategory	For each of the Y columns, a separate series is generated.
class	DefaultXY	Generates DefaultXYDataset datasets.
class	DefaultXYZ	Generates DefaultXYZDataset datasets.

Uses of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.check

Subinterfaces of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.check

Modifier and Type	Interface	Description
interface	AnnotationCheck	Interface for annotation checks.

Classes in adams.gui.visualization.object.objectannotations.check that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractAnnotationCheck	Ancestor for annotation checks.
class	MultiCheck	Applies the specified checks sequentially.
class	PassThrough	Dummy, performs no checks.
class	RequireMetaData	Requires the specified meta-data key to be present in all objects.

Uses of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.cleaning

Subinterfaces of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.cleaning

Modifier and Type	Interface	Description
interface	AnnotationCleaner	Interface for annotation cleaners.

Classes in adams.gui.visualization.object.objectannotations.cleaning that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractAnnotationCleaner	Ancestor for annotation cleaners.
class	Filter	Applies the object finder to clean the annotations.
class	OverlapRemoval	Applies the overlapping object removal algorithm to clean the annotations.
class	PassThrough	Performs no cleaning, just passes through the annotations.

Uses of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.colors

Subinterfaces of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.colors

Modifier and Type	Interface	Description
interface	AnnotationColors	Interface for classes that generate colors for annotations.

Classes in adams.gui.visualization.object.objectannotations.colors that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractAnnotationColors	Ancestor for annotation colorizers.
class	FixedColor	Uses a single, fixed color.
class	PerType	Uses a color per object type.
class	TypeColorMapping	Uses the colors defined for each type.
class	VaryByObject	Varies the color per object, useful when just a single type of object is annotated.

Uses of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.label

Subinterfaces of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.label

Modifier and Type	Interface	Description
interface	LabelPlotter	Interface for classes that plot labels.

Classes in adams.gui.visualization.object.objectannotations.label that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractLabelPlotter	Ancestor for label plotters.
class	Anchored	Plots the label relative to the anchor.
class	MultiLabelPlotter	Applies the specified plotters subsequently.
class	NoLabel	Does not plot a label.

Uses of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.outline

Subinterfaces of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.outline

Modifier and Type	Interface	Description
interface	OutlinePlotter	Interface for classes that plot the outlines of shapes.
interface	SubsetPlotSupporter	Interface for plotters that allow limiting the objects to be plotted.

Classes in adams.gui.visualization.object.objectannotations.outline that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractOutlinePlotter	Ancestor for outline plotters.
class	AbstractStrokeOutlinePlotter	Ancestor for plotters that define a stroke width.
class	MultiOutlinePlotter	Applies the specified plotters subsequently.
class	NoOutline	Omits plotting an outline.
class	PolygonOutline	Plots the polygon.
class	PolygonVertices	Plots the polygon vertices.
class	RectangleOutline	Plots the bounding box.
class	RectangleVertices	Plots the vertices of the bounding box.

Uses of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.shape

Subinterfaces of QuickInfoSupporter in adams.gui.visualization.object.objectannotations.shape

Modifier and Type	Interface	Description
interface	ShapePlotter	Interface for classes that plot shapes.

Classes in adams.gui.visualization.object.objectannotations.shape that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractShapePlotter	Ancestor for outline plotters.
class	Center	Plots a circle in the center of the object.
class	FilledPolygon	Plots a filled polygon.
class	FilledRectangle	Plots a filled rectangle.
class	MultiShapePlotter	Applies the specified plotters subsequently.
class	NoShape	Omits plotting the shape.

Uses of QuickInfoSupporter in adams.multiprocess

Subinterfaces of QuickInfoSupporter in adams.multiprocess

Modifier and Type	Interface	Description
interface	JobRunner<T extends Job>	Interface for runners that execute jobs.

Classes in adams.multiprocess that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractJobRunner<T extends Job>	Ancestor for jobrunner classes.
class	AbstractMetaJobRunner	Ancestor for meta-jobrunners, that wrap around a base jobrunner.
class	LocalJobRunner<T extends Job>	Executes the jobs on the local machine.
class	RemoteCommandJobRunner	Utilizes the remote command framework for sending jobs to a remote machine.
class	ScpJobRunner	Wraps another jobrunner and serializes it, scp's it to the specified remote file and then waits for the specified import file (containing the serialized, executed jobs) to appear. Requires a adams.flow.standalone.SSHConnection standalone for defining the SSH connection.
protected static class	ScpJobRunner.RemoteJobRunner
class	SerializingJobRunner	Wraps another jobrunner and serializes it to the specified export file and then waits for the specified import file (containing the serialized, executed jobs) to appear.

Uses of QuickInfoSupporter in adams.scripting.connection

Subinterfaces of QuickInfoSupporter in adams.scripting.connection

Modifier and Type	Interface	Description
interface	Connection	Interface for class that handle connections for remote commands.

Classes in adams.scripting.connection that implement QuickInfoSupporter

Modifier and Type	Class	Description
class	AbstractConnection	Ancestor for connections.
class	AbstractConnectionEnhancer	Ancestor connections that enhance a base connection.
class	AbstractMultiConnection	Ancestor for connection classes that manage multiple base connections.
class	AbstractSSHConnection	Ancestor of connection schemes that use an SSH tunnel to connect to the remote scripting engine.
class	AbstractSSHConnectionWithPortForwarding	Ancestor of connection schemes that use an SSH tunnel to connect to the remote scripting engine.
class	DefaultConnection	Sends the command to the specified host:port.
class	FTPConnection	Uses FTP to send commands.
class	LoadBalancer	Balances the handling of commands among several connections.
class	Multicast	Sends the same command to all connections.
class	ScpConnection	Copies the command as file to the remote host into the specified directory.
class	SSHConnection	Uses an SSH tunnel to connect to the remote scripting engine.