Data manipulation
Data management nodes modifies table entities. They take one or more tables as an input and one table as an output.
Basic
Accumulate Records
Append Columns
Calculated Column
Parameters
Modify Columns
Reduce Records
This node reduces the rows of the table by calculating statistics like mean, median, min, max, stdev or any-value for each column of the table. Input and output is one table.
Parameters:
- entities: dimension or entity to be aggregated. Typically all others than the one to kept. Can be one or more.
- aggregation statistic for each column
Scale Column Data
Grouping
Aggregate Rows
Filter Groups
Group Records
Ungroup Records
Sort & Select
Current Records
Filter Records
Parameters
Pivot Table
Parameters
Select First & Last
Select Records
Select Top
Parameters
Sort Records
Table Manipulation
Append Records
Compact Columns
Copy Column ID
Duplicate Column
Join Records
Parameters
New Column ID
Shift Records
Parameters
Statistics
Aggregate Columns
Parameters
Binning
Parameters
Binning (simple)
Equidistant binning of numerical values
Parameters
Frequency Table
Generate Distribution
Parameters
Statistics
UMAP
Reduces the selected input columns to a specified number of new components using UMAP (Uniform Manifold Approximation and Projection). UMAP is a general-purpose manifold learning and dimensionality reduction algorithm that preserves local neighborhood structure and is commonly used for visualization and feature compression. For details, see the UMAP project on GitHub.

Number of components: Number of output dimensions (new component columns).
Number of neighbours: Neighborhood size used to build the graph. Smaller = more local detail; larger = more global structure.
Minimal distance: How tightly points can be packed together. Lower = tighter clusters; higher = more spread out.
Metric: Distance used in the input space (e.g., euclidean, manhattan, cosine).
Additional parameters: Advanced UMAP options passed through to the backend (key–value overrides).
Column selection: Input columns used to compute UMAP (currently only numeric columns).
Some metrics require extra settings (e.g., Minkowski needs parameter p). Specify them in Additional parameters, for example:
{"metric_kwds": {"p": 1}}
Parameters
Input
- A0 (Table)
Output
- R0 (Table)
Control
mode (Number)
code (Text)
refresh (Number)
environmentDesc (Text)
outprocType (Number)
environmentName (Text)
outprocPath (Text)
editingOutsidePath (Text)
editingOutsideEnabled (Number)
pyParDefs (Text)
devModeKey (Text)
description (Text)
P0 (Number)
P1 (Number)
P2 (Number)
P3 (Text)
P4 (Text)
P5 (Text)
Statistical tests
ANOVA One-way
F-test
Parameters
t-test 1s
One sample t-test
Parameters
t-test 2s pair
Two sample paired t-test
Parameters
t-test 2s unpair
Two sample unpaired t-test
Parameters
Z-factor
Parameters
Position
Addition
Parameters
Difference (vector)
Parameters
Distance
Parameters
Optimal path
Vector Length
Parameters
Vector Orientation
Parameters
Stage Transformation
Parameters
Processing
Find Local Extrema
Parameters
Rolling Average
Parameters
Rolling Median
Parameters
Rolling Minimum
Parameters
Rolling Maximum
Parameters
Curve Fitting
Curve Fitting
Parameters
Dose Response
Parameters
Input
- A (Table)
Output
- R (Table)
Control
DoseColName (Text)
ResponseColName (Text)
Model (Number)
Bottom (Number)
Top (Number)
Hill (Number)
Symmetry (Number)
BottomFixed (Number)
TopFixed (Number)
HillFixed (Number)
SymmetryFixed (Number)
DisplayEquation (Number)
DisplayFit (Number)
DisplayEC50 (Number)
DisplayBottom (Number)
DisplayTop (Number)
DisplayHill (Number)
DisplaySymmetry (Number)
NameIC50 (Number)
TitleFit (Text)
TitleEquation (Text)
TitleEC50 (Text)
TitleBottom (Text)
TitleTop (Text)
TitleHill (Text)
TitleSymmetry (Text)
ZeroHandling (Number)
ZeroSubstitution (Number)
Gauss Mixture
Parameters
Growth
Parameters
Input
- A (Table)
Output
- R (Table)
Control
TimeColName (Text)
ValueColName (Text)
InitValue (Number)
Plateau (Number)
TimeConstant (Number)
InitValueFixed (Number)
PlateauFixed (Number)
TimeConstantFixed (Number)
DisplayEquation (Number)
DisplayFit (Number)
DisplayInitValue (Number)
DisplayPlateau (Number)
DisplayTimeConstant (Number)
TitleEquation (Text)
TitleFit (Text)
TitleInitValue (Text)
TitlePlateau (Text)
TitleTimeConstant (Text)
Detect
DBSCAN
Parameters
Grid Points
Parameters
Parse Well Name
Object ML Classifier
The node classifies objects in a table based on their measured features.

Available classifiers:
- Nearest neighbour
- Bayes
- Neural network
Parameters
Object Rule Classifier
This node assigns a class to each object in a table by evaluating its measured features against user-defined rules.
To use it, connect the node to a table that contains an ObjectId column (required to visualize the colored binary layer) and the measured feature columns, for example a table produced by the Object Measurement node. In the node’s settings, define the classes you want to use and specify the rule conditions for each class based on the feature values. Classes are evaluated in the order they are listed, so if an object matches more than one class, it is assigned to the first matching class. If an object does not match any class rules, it is assigned to the base (default) class.
To visualize the result, connect the output table together with the corresponding binary layer to the Color by Value node, then in the Color by Value GUI choose the class column as the source column.

Parameters
TMA Dearraying
Parameters
Values Run
Detect Run of Like Values
Parameters
Sequences
Difference
Parameters
Integrate
Parameters
Position Difference
Parameters
Position Integrate
Parameters
High Pass Filter
Parameters
Low Pass Filter
Parameters
Sequence (Int)
Parameters
Sequence (Exp)
Parameters
Python
Create Column
Define new columns in the upper table by specifying their name, type, and unit.

Fill the out DataFrame with the calculated data. Use the print() function to reveal any variable.
The example shows k-means object classification using scikit-learn.
import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
# take only the float columns
df_float64 = df.select_dtypes(include=["Float64"])
# scale the input
df_float64[ [ct("A:BinMeanOfBlue"), ct("A:BinMeanOfGreen"), ct("A:BinMeanOfRed") ] ] *= 5.0
print(df_float64.head())
X = df_float64.values
# Scale after weighting
scaler = StandardScaler()
scaled_features = scaler.fit_transform(X)
# Apply K-means clustering
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
#set the output dataset
out["Pollen_Class"] = kmeans.fit_predict(X)Accessing columns in df
Input columns in pandas dataframe are accessed by their titles. Column titles may change during GA3 editing or because input channels use different names. If you access columns using plain strings, these changes can break your script and cause it to look for non-existing columns.
To make column references robust, always use the ct(...) helper instead of raw strings. For example, replace df["Area"] with df[ct("A:Area")], where A refers to table input name and Area is the column title.
def ct(title: str) -> str:
return title.split(":", 1)[1] if ":" in title else titleThe helper ct("A:Area") returns only "Area" to Python, but the full "A:Area" string is stored in the workflow and tracked by the GA3 editor. As consequence, if you rename the column in the GUI (for example Area → Object area), the editor knows which column and table A:Area referred to and automatically updates it to A:Object area. Your script keeps working without any manual changes.
To quickly insert a column reference into the code editor, click the table button
in the top toolbar and select the desired column from the list. The column title will be inserted in the form ct("Table:ColumnTitle").
Use LLMs with Python nodes
It is possible to ask large language models (LLMs) like ChatGPT, Gemini or Copilot to generate python
code that will calculate the content of the column. To simplify the interaction with the LLMs there
is a button Copy prompt for a LLM which prepares a prompt ready to be pasted into the LLMs.
The user has to replace the <USER TASK HERE>.
At the end pof the prompt:
Task (provided by the user):
ENTER YOUR QUESTION HERE
Note that it is a good practice to create a new chat for the prompt so that it doesn’t share context with unrelated conversation.
The answer should contain two parts as shown in the example:
- JSON with new columns definition - copy it and
Paste columns from LLMand - copy and paste the python code – replace it: Ctrl+A, Ctrl+V
- Example of feature reduction (movie)
- In the movie we show how to interact with the LLMs. Asking it to reduce the number of features.
Task (provided by the user):
Reduce the number of features to 2 in order to visualize the data in 2D scatterplot.
Ignore non-feature columns like Entity or Object ID.
- Example of unsupervised classification
- When the following question is added to the generated prompt:
Task (provided by the user):
Classify the objects into two classes.
The ChatGPT 4o outputs following column definition and code:
[
{"name": "ClassLabel", "type": "int", "unit": null}
]import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
# Start from an empty frame with the same index
out = pd.DataFrame(index=df.index)
# Select numeric features for clustering (excluding IDs and categorical fields)
features = [
"Area", "EqDiameter", "Perimeter", "Length", "Width", "MaxFeret", "MinFeret",
"Circularity", "Elongation", "MeanIntensityEGFP", "MeanIntensityTD",
"SumIntensityEGFP", "SumIntensityTD"
]
# Prepare data: drop rows with missing values in the selected features
valid_mask = df[features].notna().all(axis=1)
X = df.loc[valid_mask, features].astype("float64")
# Perform KMeans clustering into 2 classes
kmeans = KMeans(n_clusters=2, n_init="auto", random_state=42)
labels = pd.Series(kmeans.fit_predict(X), index=X.index).astype("Int64")
# Create the output column and fill with cluster labels, keeping <NA> where data was insufficient
out["ClassLabel"] = pd.Series(pd.NA, index=df.index, dtype="Int64")
out.loc[labels.index, "ClassLabel"] = labelsParameters
See also: Python
Create Table
Define new columns or copy them from the source tables in the upper table by specifying their name, type, and unit. Copying columns keeps their ID and Metadata.

Fill the out DataFrame with the calculated data. Use the print() function to reveal any variable.
The example shows an inner join of two object tables tables:
- Table A: all columns from results of object measurements with one row per object and
- Table B: “Value” and “Frequency” from results of object pixel histogram with 16 rows per each object
on columns ("TimeLapseIndex", "Entity", "ObjectId").
Same columns (having same name) are taken from the left table (“Table A”) with the suffixes parameter.
See Pandas documentation for the merge() function.
import pandas as pd
import numpy as np
# predefined globals:
# df: tuple[pd.DataFrame] with the input tables for "Table A", "Table B", ...
# mdf: tuple[pd.DataFrame] with the input column metadata table for "Table A", "Table B", ...
# out: pd.DataFrame with the new output table
print("Table A:", df[0].columns)
print("Table B:", df[1].columns)
out = pd.merge(*df, on=("TimeLapseIndex", "Entity", "ObjectId"), suffixes=("", None))To see how to make column access more robust for later editing, see the Create Column
For even more programmatic approach without having to define the columns in the Dialog use the Python generic node.
Use LLMs with Python nodes
It is possible to ask large language models (LLMs) like ChatGPT, Gemini or Copilot to generate python code for a
scientific question. To simplify the interaction with the LLMs there is a button Copy prompt for a LLM
which prepares a prompt ready to be pasted into the LLMs. The user has to append only the question.
Note that it is a good practice to create a new chat for the prompt so that it doesn’t share context with unrelated conversation.
The answer should contain two parts as shown in the example:
- JSON with new columns definition - copy it and
Paste columns from LLMand - copy and paste the python code – replace it: Ctrl+A, Ctrl+V
When the following question was given:
Task: I want to find out if there is one or more classes in the input table based on the coefficient of diffusion (CD). Calculate the CD from MSDs. Note that one TrackId has more than one row. Can you help me with that?
The python create table is connected to the MSD table in the Single particle tracking example as follows:

Thought for 1m 13s
ChatGPT 5 produced following answer:
[
{"name": "Entity", "type": "text", "unit": null},
{"name": "TrackId", "type": "int", "unit": null},
{"name": "PointsUsed", "type": "int", "unit": null},
{"name": "CD", "type": "number", "unit": "µm²/s"},
{"name": "CD_SE", "type": "number", "unit": "µm²/s"},
{"name": "R2_Origin", "type": "number", "unit": null},
{"name": "NumClasses", "type": "int", "unit": null},
{"name": "ClassLabel", "type": "int", "unit": null},
{"name": "ClassMeanCD", "type": "number", "unit": "µm²/s"},
{"name": "ClassCount", "type": "int", "unit": null},
{"name": "BIC_Best", "type": "number", "unit": null}
]Python code is too long (150 lines) to reproduce here.

From the CD per track it is clear that there is only one class:

Parameters
See also: Python
JavaScript
JS Create Column
NOTE: This node is deprecated in favor of the Python Create Column node.
Define one or more new columns and calculate its data using JavaScript.

In the upper table, you can define new columns by specifying their name, type, and unit.
To reference columns from the input table in your JavaScript code, simply click the button with the column name. This will insert a variable declaration with the appropriate column index. For example, clicking on the ZStackIndex column will insert:
var ZStackIndexIndex = tableA.colIndexById("_loopZStackIndex"); //ZStackIndex
This variable holds the index of the input column and can be used to access its values in your script, e.g.:
var tableA = new Table(context.tableForParameter(node.child("A")));
var a = tableA.data;
var ig = tableA.rowsToGroupRows;
var ZStackIndexIndex = tableA.colIndexById("_loopZStackIndex"); //ZStackIndex
function newItemForRow(i) {
return a[ZStackIndexIndex][i];
}Input table is already accessible as tableA variable of Table class.
The Table class wraps the input table data and metadata.
It provides methods to access columns, rows, groupings, and statistics.
Methods and properties of the Table class
Properties
tableName:stringName of the table.tableMetadata: object` Full metadata of the table.colIdList:string[]List of internal column IDs.colTitleList:string[]Visible column titles.colMetadataList:object[]Metadata for each column.data:any[][]Column-major 2D array of values.dataRowList:any[][]Transposed version for row-wise access.colCount:numberTotal number of columns.rowCount:numberTotal number of rows.
Column Lookup
colIndexById(id: string):numbercolIndexByTitle(title: string):numbercolIndexByFeature(feature: string):numbercolIndexByFullText(text: string):numberLooks up a column by ID, title, or both.matchColsFulltext(param: string | RegExp | string[]):number[]Returns indices of matching columns.
Grouping & Sorting
groupedBy:number[]Indices of columns used for grouping.orderedBy:number[]Indices of columns used for sorting.groups:number[][]List of row indices grouped by column values.rowsToGroupIds:number[]For each row, the corresponding group ID.rowsToGroupRows:number[]For each row, its index within its group.
Column Info Access
colIdAt(index: number):stringcolMetadataAt(index: number):objectcolTitleAt(index: number):stringcolUnitAt(index: number):stringcolTitleAndUnitAt(index: number, sep = " "):stringcolDecltypeAt(index: number):stringcolIsNumericAt(index: number):booleanlistColIds(filter?: (id: string) => boolean):string[]listIdentColIds():string[]
Column Data & Stats
colDataAt(index: number):any[]Returns raw values from the specified column.colDataStatsAt(index: number, stats: string[]):(number | null)[]Returns requested statistics:"total"– all values including nulls"count"– non-null values"sum","mean","min","max""stdev"– standard deviation
For each table row function newItemForRow(i) is called. It expects to return either single value or array.
If you have defined multiple columns in upper table it expects to return array only.
Creating column with indices of rows
| |
Creating column with indices of rows per group
| |
Creating column with time delta
| |
Creating column with cumulative sum
| |
Creating column with mean of column data
| |
Creating column with group mean of column data
| |
JS Create Table
NOTE: This node is deprecated in favor of the Python Create Table node.
Creates a new table by combining one or more existing tables (table inputs A, B, …). All output table columns must be defined in the node dialog column list table:

The code contains a quick reference of predefined variables:
| |
The expected output is the data of the new table (an array of arrays columns x rows). The number of columns must match the number of defined columns. And the number of rows must be equal for all columns.