This workflows showcases a simple working example of using NumPy library for segmentation (see numpy.org).

Figure 773. 

Code 
GA3 Python Editor

# IMPORTANT: 'limnode' must be imported like this (not from nor as)
import limnode
import numpy as np

# defines output parameter properties
def output(inp: limnode.InDefTuple, out: limnode.OutDefTuple, par: limnode.UserParTuple) -> None:
    out[0].makeNew("Binary", "#00ff00")

# return Program for dimension reduction or two-pass processing
def build(par: limnode.UserParTuple, loops: limnode.LoopDefs) -> limnode.Program|None:
    return None

# called for each frame/volume
def run(inp: limnode.InDataTuple, out: limnode.OutDataTuple, par: limnode.UserParTuple, ctx: limnode.RunContext) -> None:
    img = inp[0].data
    bin = np.where((img >= 300) & (img <= 400), 1, 0)
    out[0].data[:] = bin.astype(np.uint8)

# child process initialization (when outproc is set)
if __name__ == '__main__':
    from limnode import print
    limnode.child_main(run, output, build)

Figure 774. Results.

Scikit-image is “a collection of algorithms for image processing” (see scikit-image.org).

Figure 775. 

Code 

# IMPORTANT: 'limnode' must be imported like this (not from nor as)
import limnode, numpy
from skimage import filters

# defines output parameter properties
def output(inp: limnode.InDefTuple, out: limnode.OutDefTuple, par: limnode.UserParTuple) -> None:
    out[0].makeNew("otsu", (0, 255, 255))

# return Program for dimension reduction or two-pass processing
def build(par: limnode.UserParTuple, loops: limnode.LoopDefs) -> limnode.Program|None:
    return None

# called for each frame/volume
def run(inp: limnode.InDataTuple, out: limnode.OutDataTuple, par: limnode.UserParTuple, ctx: limnode.RunContext) -> None:
    image = inp[0].data[0, :, :, 0]
    threshold = filters.threshold_otsu(image)
    binary = image > threshold
    out[0].data[0, :, :, 0] = binary.astype(numpy.uint8)

# child process initialization (when outproc is set)
if __name__ == '__main__':
    from limnode import print
    limnode.child_main(run, output, build)

Figure 776. Results.

BaSiCPy is a library “for background and shading correction of optical microscopy images” (see BaSiCPy).

Figure 777. 

Environment 

channels:
    - conda-forge
dependencies:
    - python=3.10
    - pip
    - pip:
        - "scipy<1.13"
        - "jax[cpu]==0.4.13"
        - "hyperactive<5"
        - "ml-dtypes==0.2.0"
        - basicpy
variables:
  PIP_FIND_LINKS: "https://whls.blob.core.windows.net/unstable/index.html"
  PIP_USE_DEPRECATED: "legacy-resolver"

The environment was created and tested in the November, 2025.

Figure 778. 

Code 

# IMPORTANT: 'limnode' must be imported like this (not from nor as)
import limnode, numpy
from basicpy import BaSiC

basic = BaSiC(get_darkfield=True)
fitted: bool = False
imgcache: list[numpy.ndarray] = []

# defines output parameter properties
def output(inp: limnode.InDefTuple, out: limnode.OutDefTuple, par: limnode.UserParTuple) -> None:
   pass

# return Program for dimension reduction or two-pass processing
def build(par: limnode.UserParTuple, loops: limnode.LoopDefs) -> limnode.Program|None:
   return limnode.TwoPassProgram(loops).overMultiPoint()

# called for each frame/volume
def run(inp: limnode.InDataTuple, out: limnode.OutDataTuple, par: limnode.UserParTuple, ctx: limnode.RunContext) -> None:
   global imgcache, fitted, basic
   if ctx.finalCall:
       if not fitted:
           stk = numpy.stack(imgcache, axis=0)
           basic.fit(stk)
           imgcache = []
           fitted = True
       out[0].data[0, :, :, 0] = basic.transform(inp[0].data[0, :, :, 0])[0]
   else:
       imgcache.append(numpy.copy(inp[0].data[0, :, :, 0]))
       fitted = False

# child process initialization (when outproc is set)
if __name__ == '__main__':
    from limnode import print
    limnode.child_main(run, output, build)

Figure 779. Results.

Replace both graph nodes with a Python node. Both having Table as single input and single output.

Figure 780. Python nodes replacing the standard GA3 graphs.

# IMPORTANT: 'limnode' must be imported like this (not from nor as)
import limnode

import numpy as np
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.ticker import FuncFormatter
import datetime, io, json

savefig_kwargs: dict = {
    'format': 'png',
    'bbox_inches': 'tight',
    'pad_inches': 0.25
}

def seconds_to_hms(x, _):
    return str(datetime.timedelta(seconds=int(x)))

def draw_graph(x, y, bgcolor, fgcolor):
    fig = Figure(figsize=(12, 4), facecolor=bgcolor)
    ax = fig.add_subplot(1, 1, 1, facecolor=bgcolor)
    ax.plot(x, y, marker='o', color='#77aadd', linewidth=2)
    ax.set_title("Object Count vs Time", fontsize=14, color=fgcolor)
    ax.set_xlabel("Time (hh:mm:ss)", fontsize=12, color=fgcolor)
    ax.set_ylabel("Count", fontsize=12, color=fgcolor)
    ax.grid(True, alpha=0.6, color='gray')
    ax.tick_params(axis='both', colors=fgcolor)
    for label in ax.get_xticklabels() + ax.get_yticklabels():
        label.set_color(fgcolor)
    for spine in ax.spines.values():
        spine.set_color(fgcolor)
    ax.xaxis.set_major_formatter(FuncFormatter(seconds_to_hms))
    return fig

# defines output parameter properties
def output(inp: limnode.InDefTuple, out: limnode.OutDefTuple, par: limnode.UserParTuple) -> None:
    out[0].makeResult("LineChart", inp[0])

# return Program for dimension reduction or two-pass processing
def build(par: limnode.UserParTuple, loops: limnode.LoopDefs) -> limnode.Program|None:
    return None

# called for each frame/volume
def run(inp: limnode.InDataTuple, out: limnode.OutDataTuple, par: limnode.UserParTuple, ctx: limnode.RunContext) -> None:
    Time = inp[0].colArray("Time")
    ObjectCount = inp[0].colArray("ObjectCount")

    canvasLight = draw_graph(Time, ObjectCount, '#fcfcfc', '#000000')
    canvasDark = draw_graph(Time, ObjectCount, '#444444', '#f0f0f0')


    out[0].withMplImage(ctx.inpParameterCoordinates[0], (canvasLight, canvasDark), savefig_kwargs=savefig_kwargs, iconres="line_common")

# child process initialization (when outproc is set)
if __name__ == '__main__':
    from limnode import print
    limnode.child_main(run, output, build)

The above python code produces following line chart.

Figure 781. 

Figure 782. Line chart by matplotlib in the light scheme.

Histogram of object sizes per frame 
Similarly with histogram:

GA3 Python editor

# IMPORTANT: 'limnode' must be imported like this (not from nor as)
import limnode

import numpy as np
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.ticker import FuncFormatter
import io, json

savefig_kwargs: dict = {
    'format': 'png',
    'bbox_inches': 'tight',
    'pad_inches': 0.25
}

def draw_graph(data, bgcolor, fgcolor):
    fig = Figure(figsize=(12, 4), facecolor=bgcolor)
    ax = fig.add_subplot(1, 1, 1, facecolor=bgcolor)
    ax.hist(data, bins=30, color='#77aadd', edgecolor='#77aadd22')
    ax.set_title("Histogram of Object Sizes", fontsize=14, color=fgcolor)
    ax.set_xlabel("Size (equivalent diameter)", fontsize=12, color=fgcolor)
    ax.set_ylabel("Frequency", fontsize=12, color=fgcolor)
    #ax.grid(True, alpha=0.6, color='gray')
    ax.tick_params(axis='y', colors=fgcolor)
    for label in ax.get_xticklabels() + ax.get_yticklabels():
        label.set_color(fgcolor)
    for spine in ax.spines.values():
        spine.set_color(fgcolor)
    return fig

# defines output parameter properties
def output(inp: limnode.InDefTuple, out: limnode.OutDefTuple, par: limnode.UserParTuple) -> None:
    out[0].makeResult("Histogram", inp[0])

# return Program for dimension reduction or two-pass processing
def build(par: limnode.UserParTuple, loops: limnode.LoopDefs) -> limnode.Program|None:
    return None

# called for each frame/volume
def run(inp: limnode.InDataTuple, out: limnode.OutDataTuple, par: limnode.UserParTuple, ctx: limnode.RunContext) -> None:
    ObjectSizes = inp[0].colArray("EqDiameter")

    canvasLight = draw_graph(ObjectSizes, '#fcfcfc', '#000000')
    canvasDark = draw_graph(ObjectSizes, '#444444', '#f0f0f0')

    out[0].withMplImage(ctx.inpParameterCoordinates[0], (canvasLight, canvasDark), savefig_kwargs=savefig_kwargs, iconres="histo_common")

# child process initialization (when outproc is set)
if __name__ == '__main__':
    from limnode import print
    limnode.child_main(run, output, build)

The above python code produces following histogram.

Figure 783. Histogram by matplotlib.

Conclusion 
These two examples are not the fanciest plots. The lack interactivity as the native GA3 plots because they are rendered into a static image (or two: light and dark). However based on the aggregation of the inputs and loop coordinates the histogram will change as the current frame changes and linechart of counts vs. time will not as there is only one plot of aggregated counts.

Stardist is a popular AI segmentation package.

As it needs tensorflow to be installed in oreder for Stardist to run it is suggested to install it in a separate environment. Follow the tensorflow guide for Windows installation.

Edit the environment and insert following definition:

CPU:

channels:
    - conda-forge
dependencies:
    - python=3.10           # minimum for NIS-Elements
    - pip
    - pip:
        - tensorflow
        - stardist
        - numpy==1.26

GPU:

channels:
    - conda-forge
dependencies:
    - python=3.10           # minimum for NIS-Elements
    - cudatoolkit=11.2
    - cudnn=8.1.0
    - pip
    - pip:
        - tensorflow<2.11
        - stardist
        - numpy==1.26

Then install it by clicking the “Install managed environment” icon. Be patient it takes time.

Figure 784. Stardist: Managed environment.

[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

Insert the code as follows:

# IMPORTANT: 'limnode' must be imported like this (not from nor as)
import limnode

# Lazy load on first run
model = None

# defines output parameter properties
def output(inp: limnode.InDefTuple, out: limnode.OutDefTuple, par: limnode.UserParTuple) -> None:
    out[0].makeNew("nuclei", (0, 255, 255)).makeInt32()

# return Program for dimension reduction or two-pass processing
def build(par: limnode.UserParTuple, loops: limnode.LoopDefs) -> limnode.Program|None:
    return None

# called for each frame/volume
def run(inp: limnode.InDataTuple, out: limnode.OutDataTuple, par: limnode.UserParTuple, ctx: limnode.RunContext) -> None:
    global model

    import numpy
    from csbdeep.utils import normalize
    from stardist.models import StarDist2D

    # Check GPU
    # import tensorflow as tf
    # print(tf.config.list_physical_devices('GPU'))

    if model is None:
        model = StarDist2D.from_pretrained('2D_versatile_fluo')

    img = inp[0].data[0, :, :, 0]
    labels,_= model.predict_instances(normalize(img, 1, 99.8, axis=(0, 1)))

    separated = limnode.separateLabeledImage(labels)
    out[0].data[:, :, :, 0] = separated.astype(numpy.int32)

# child process initialization (when outproc is set)
if __name__ == '__main__':
    from limnode import print
    limnode.child_main(run, output, build)

OSError: [WinError 1314] A required privilege is not held ... 
If this error happens the user has no right to create symbolic links.

Th easiest solution on Windows 11 is to Enable Windows Developer Mode:

Settings > System > For Developers > Developer Mode.

Figure 785. Stardist: Segmentation result.

Omnipose is a pupular general image segmentation package that builds on Cellpose.

Figure 786. 

Environment 
Edit the environment and insert following definition:

CPU:

channels:
    - conda-forge
dependencies:
    - python=3.10.12
    - pip
    - pip:
        - omnipose==1.1.4

GPU:

channels:
    - conda-forge
dependencies:
    - python=3.10.12
    - pip
    - pip:
        - --index-url https://pypi.org/simple
        - --extra-index-url https://download.pytorch.org/whl/cu126
        - omnipose==1.1.4
        - torch==2.9.1
        - torchvision==0.24.1
        - torchaudio==2.9.1

Then install it by clicking the “Install managed environment” icon. Be patient it takes time.

The environment was created and tested in the January, 2026.

Figure 787. Omnipose: Managed environment.

Code 
Insert the code as follows:

# IMPORTANT: 'limnode' must be imported like this (not from nor as)
import limnode

model = None
model_name = None

# defines output parameter properties
def output(inp: limnode.InDefTuple, out: limnode.OutDefTuple, par: limnode.UserParTuple) -> None:
    out[0].makeNew("Mask", (0, 255, 0)).makeUInt8()
    out[1].makeNewRgb("Flow").makeUInt8()

# return Program for dimension reduction or two-pass processing
def build(par: limnode.UserParTuple, loops: limnode.LoopDefs) -> limnode.Program|None:
    return None

# called for each frame/volume
def run(inp: limnode.InDataTuple, out: limnode.OutDataTuple, par: limnode.UserParTuple, ctx: limnode.RunContext) -> None:
    import numpy as np 
    from omnipose.gpu import use_gpu
    from omnipose.utils import normalize99
    from cellpose_omni import models

    img = inp[0].data[0, :, :, 0]
    img = normalize99(img)

    global model, model_name
    new_model_name = 'bact_fluor_omni'
    if model is None or model_name != new_model_name:
        model_name = new_model_name
        gpu_device, is_gpu = use_gpu()
        if is_gpu:
            model = models.CellposeModel(gpu=(gpu_device, is_gpu), model_type=model_name)
        else:
            model = models.CellposeModel(model_type=model_name)

    params = {
        'channels':None,
        'rescale': None, 
        'mask_threshold': -2,
        'flow_threshold': 0,
        'transparency': False,
        'omni': True, 
        'cluster': True,
        'resample': True, 
        'verbose': False,
        'tile': False, 
        'niter': None,
        'augment': False,
        'affinity_seg': True
    }

    mask, flow, style = model.eval(img,**params)
    mask = limnode.separateLabeledImage(mask)
    out[0].data[0,:,:,0] = mask
    out[1].data[0,:,:,:] = np.where(mask[..., None], flow[0][:, :, 0:3], 0)[...,[2,1,0]]

# child process initialization (when outproc is set)
if __name__ == '__main__':
    from limnode import print
    limnode.child_main(run, output, build)

Figure 788. Omnipose: Binary Mask & RGB Flow.