Uses of Class
adams.flow.transformer.AbstractTransformer

Packages that use AbstractTransformer

Package	Description
adams.flow.control
adams.flow.transformer

Uses of AbstractTransformer in adams.flow.control

Subclasses of AbstractTransformer in adams.flow.control

Modifier and Type	Class	Description
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	Breakpoint	Allows to pause the execution of the flow when this actor is reached and the condition evaluates to 'true'.
class	Cast	Casts the incoming data to the specified classname.
class	FileProcessor
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	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	Injector	Injects a string token into the token sequence. The string can be inject before or after the current token.
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	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	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	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	Sleep	Waits for a fixed amount of milliseconds.
class	TriggerEvent	Triggers the specified event.

Uses of AbstractTransformer in adams.flow.transformer

Subclasses of AbstractTransformer in adams.flow.transformer

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	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	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	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	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	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	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	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	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	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	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	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.