pyimagej-fiji-bridge

PyImageJ — ImageJ/Fiji 的 Python 桥接工具

概述

PyImageJ 通过 PyJNIus 和 scyjava 为 ImageJ2 和 Fiji 提供 Python 接口，并在 Python 进程中嵌入完整的 Java 虚拟机。它支持 NumPy 数组与 ImageJ 的 ImagePlus/ImgLib2 数据结构之间的双向数据交换，因此你可以在 Python 中预处理图像，将其传入 Fiji 插件（Bio-Formats、TrackMate、Analyze Particles、Weka segmentation），再将结果返回到 pandas DataFrame。该库支持用于脚本编写和批处理的无头模式，也支持用于交互式 Fiji 会话的 GUI 模式。

适用场景

• 从 Python 调用 Fiji 专用插件：Bio-Formats 多格式 I/O、TrackMate 粒子跟踪、CLIJ2 GPU 处理或社区 Fiji 更新站点插件
• 在不打开 Fiji GUI 的情况下无头运行 ImageJ 宏工作流，例如，批量处理一整场实验并运行一夜
• 使用完整的 ImageJ 类型系统，应用 ImageJ Ops 框架（150 多种图像处理操作）
• 在 NumPy 数组（SciPy 生态系统）与 ImageJ 超级堆栈（TZCYX 通道顺序）之间转换，以进行往返处理
• 将 ImageJ Results 表和 ROI Manager 测量结果解析为 pandas DataFrame，供后续统计分析使用
• 在 Python 工作流中执行现有的 .ijm 宏文件，无需重写
• 如果你需要不使用 Fiji 插件的纯 Python 处理，请改用 scikit-image——它安装更快，也无需承担 JVM 开销
• 对于交互式多维图像可视化和标注，请改用 napari；PyImageJ 不能替代查看器

先决条件

• Python 包：pyimagej、scyjava、numpy、pandas
• Java：Java 8 或 Java 11（不支持 Java 17）；建议使用 conda 可靠地管理 Java
• Fiji/ImageJ2：首次初始化时自动下载，也可指定本地 Fiji 安装路径
• 环境：强烈建议使用 conda 环境；仅通过 pip 安装通常会遇到 JVM 路径问题

# Recommended: conda installation
conda create -n pyimagej -c conda-forge pyimagej openjdk=11
conda activate pyimagej

# Install additional dependencies
pip install pandas tifffile

# Verify
python -c "import imagej; ij = imagej.init('sc.fiji:fiji', mode='headless'); print(ij.getVersion())"

快速入门

import imagej
import numpy as np

# Initialize Fiji in headless mode (downloads on first run, ~500 MB)
ij = imagej.init("sc.fiji:fiji", mode="headless")
print(f"ImageJ version: {ij.getVersion()}")

# Create a test image, process with Gaussian blur via Ops, convert back
arr = np.random.randint(0, 1000, (256, 256), dtype=np.uint16)
imp = ij.py.to_imageplus(arr)
blurred = ij.op().filter().gauss(imp.getProcessor(), 2.0)
result = ij.py.from_imageplus(imp)
print(f"Processed array shape: {result.shape}, dtype: {result.dtype}")

核心 API

模块 1：初始化

每个 Python 会话中都必须初始化一次 PyImageJ。mode 和 endpoint 决定要使用的 ImageJ 发行版及 GUI 行为。

import imagej

# Headless Fiji — most common for scripts and batch jobs
ij = imagej.init("sc.fiji:fiji", mode="headless")

# GUI mode — opens the Fiji window (requires a display)
ij = imagej.init("sc.fiji:fiji", mode="gui")

# Local Fiji installation — faster startup, no download
ij = imagej.init("/path/to/Fiji.app", mode="headless")

# Specific Fiji version
ij = imagej.init("sc.fiji:fiji:2.14.0", mode="headless")

# Bare ImageJ2 without Fiji plugins
ij = imagej.init("net.imagej:imagej", mode="headless")

print(f"ImageJ version: {ij.getVersion()}")
print(f"Headless: {ij.ui().isHeadless()}")

模块 2：图像 I/O

使用 ImageJ 的 I/O 层（其中包含用于专有格式的 Bio-Formats）打开和保存图像，并在 ImageJ 与 NumPy 表示形式之间转换。

import imagej
import numpy as np

ij = imagej.init("sc.fiji:fiji", mode="headless")

# Open any format Bio-Formats supports: CZI, LIF, ND2, ICS, TIFF, etc.
imp = ij.io().open("/data/experiment.czi")
print(f"Dimensions: {imp.getDimensions()}")   # [W, H, C, Z, T]
print(f"nSlices: {imp.getNSlices()}, nFrames: {imp.getNFrames()}")

# Save image
ij.io().save(imp, "/data/output.tif")
print("Saved output.tif")

# NumPy ↔ ImageJ conversion
arr = np.zeros((100, 100), dtype=np.uint16)
arr[30:70, 30:70] = 1000   # bright square

# NumPy → ImagePlus
imp = ij.py.to_imageplus(arr)
print(f"ImagePlus: {imp.getWidth()}×{imp.getHeight()}, type={imp.getType()}")

# ImagePlus → NumPy (returns a view where possible)
arr_back = ij.py.from_imageplus(imp)
print(f"NumPy array: shape={arr_back.shape}, dtype={arr_back.dtype}")

# Multi-channel array: shape (C, H, W)
rgb = np.random.randint(0, 255, (3, 256, 256), dtype=np.uint8)
imp_rgb = ij.py.to_imageplus(rgb)
print(f"Channels: {imp_rgb.getNChannels()}")

模块 3：宏执行

运行 ImageJ 宏语言（IJM）代码片段或宏文件。宏在 ImageJ 环境中执行，可以调用任何内置 ImageJ 命令。

import imagej

ij = imagej.init("sc.fiji:fiji", mode="headless")

# Run an inline macro string
ij.macro.run("print('Hello from ImageJ macro');")

# Run a macro with options string (key=value pairs)
# Options string mirrors the dialog parameters of ImageJ commands
macro_code = """
run("Gaussian Blur...", "sigma=2");
run("Auto Threshold", "method=Otsu white");
"""
ij.macro.run(macro_code)

# Run a macro file from disk
ij.macro.runMacroFile("/scripts/my_analysis.ijm")

# Run macro that returns a value via getResult or output string
result = ij.macro.run("""
x = 42 * 2;
return x;
""")
print(f"Macro returned: {result}")

# Macro with current image: open → process → measure
ij.io().open("/data/cells.tif")   # sets current active image

measure_macro = """
run("Set Measurements...", "area mean min integrated redirect=None decimal=3");
run("Analyze Particles...", "size=50-Infinity display clear summarize");
"""
ij.macro.run(measure_macro)
print("Analyze Particles complete; results in Results table")

模块 4：ImageJ Ops

ImageJ Ops 是一个包含 150 多种图像处理操作并支持类型安全分发的框架。Ops 适用于 ImgLib2 Img 对象，是以编程方式调用图像处理算法的首选方式。

import imagej
import numpy as np

ij = imagej.init("sc.fiji:fiji", mode="headless")

arr = np.random.randint(100, 900, (512, 512), dtype=np.uint16)
img = ij.py.to_java(arr)   # converts to ImgLib2 RandomAccessibleInterval

# Gaussian blur
blurred = ij.op().filter().gauss(img, 2.0)
blurred_np = ij.py.from_java(blurred)
print(f"Blurred: {blurred_np.shape}")

# Otsu threshold → binary image
binary = ij.op().threshold().otsu(img)
binary_np = ij.py.from_java(binary)
print(f"Binary unique values: {np.unique(binary_np)}")

# Morphological operations
from jnius import autoclass
BitType = autoclass("net.imglib2.type.logic.BitType")
opened = ij.op().morphology().open(binary, [3, 3])
opened_np = ij.py.from_java(opened)
print(f"After opening: {opened_np.shape}")

# Statistics ops
mean_val = ij.op().stats().mean(img)
std_val  = ij.op().stats().stdDev(img)
print(f"Mean intensity: {mean_val:.1f}, StdDev: {std_val:.1f}")

# Math ops: multiply image by scalar
scaled = ij.op().math().multiply(img, ij.py.to_java(2.0))
print(f"Scaled max: {ij.py.from_java(scaled).max()}")

模块 5：插件和命令调用

SciJava 命令是以编程方式调用 Fiji 插件的主要途径。命令接受一个字典，其中的命名参数与插件对话框中的参数相对应。

import imagej

ij = imagej.init("sc.fiji:fiji", mode="headless")

# Open a file using Bio-Formats opener command
future = ij.command().run(
    "loci.plugins.LociImporter",
    True,
    {"id": "/data/image.lif", "open_files": True, "autoscale": True}
)
module = future.get()
imp = module.getOutput("imp")
print(f"Opened via Bio-Formats: {imp.getDimensions()}")

# Run Analyze Particles as a SciJava command
ij.io().open("/data/binary_mask.tif")

future = ij.command().run(
    "ij.plugin.filter.ParticleAnalyzer",
    True,
    {
        "minSize": 50.0,
        "maxSize": float("inf"),
        "options": 0,      # SHOW_NONE
        "measurements": 1,  # AREA
    }
)
future.get()
print("Analyze Particles command complete")

# Alternatively, run via macro string for simpler plugin invocation
ij.macro.run("""
run("Analyze Particles...", "size=50-Infinity display clear summarize");
""")

模块 6：结果表和 ROI 分析

运行 Analyze Particles 或其他测量命令后，从 ImageJ 的 Results 表和 ROI Manager 中获取测量结果。

import imagej
import pandas as pd

ij = imagej.init("sc.fiji:fiji", mode="headless")

# After running Analyze Particles, read the Results table
def results_to_dataframe(ij) -> pd.DataFrame:
    """Convert ImageJ Results table to pandas DataFrame."""
    rt = ij.ResultsTable.getResultsTable()
    if rt is None or rt.size() == 0:
        return pd.DataFrame()
    headings = list(rt.getHeadings())
    data = {col: [rt.getValue(col, i) for i in range(rt.size())]
            for col in headings}
    return pd.DataFrame(data)

# Run segmentation + measurement macro
ij.io().open("/data/cells.tif")
ij.macro.run("""
run("Gaussian Blur...", "sigma=1.5");
setAutoThreshold("Otsu dark");
run("Convert to Mask");
run("Analyze Particles...", "size=20-Infinity display clear");
""")

df = results_to_dataframe(ij)
print(f"Found {len(df)} objects")
print(df[["Area", "Mean", "IntDen"]].describe())
df.to_csv("particle_measurements.csv", index=False)
print("Saved particle_measurements.csv")

# Access the ROI Manager
def get_roi_manager(ij):
    """Return the ImageJ ROI Manager instance, creating if needed."""
    RoiManager = ij.py.jclass("ij.plugin.frame.RoiManager")
    rm = RoiManager.getInstance()
    if rm is None:
        rm = RoiManager(False)   # headless=False means no GUI window
    return rm

rm = get_roi_manager(ij)
roi_count = rm.getCount()
print(f"ROIs in manager: {roi_count}")

# Extract bounding boxes for all ROIs
rois = []
for i in range(roi_count):
    roi = rm.getRoi(i)
    bounds = roi.getBounds()
    rois.append({"index": i, "x": bounds.x, "y": bounds.y,
                 "width": bounds.width, "height": bounds.height})
roi_df = pd.DataFrame(rois)
print(roi_df.head())

常见工作流

工作流 1：自动荧光定量

目标：打开多通道 TIFF 堆栈，应用高斯模糊，对细胞核通道进行阈值处理，运行 Analyze Particles，并将每个细胞的测量结果导出为 CSV。

import imagej
import pandas as pd
import numpy as np
from pathlib import Path

ij = imagej.init("sc.fiji:fiji", mode="headless")

def quantify_nuclei(tiff_path: str, output_csv: str,
                    channel: int = 1, sigma: float = 1.5,
                    min_size: int = 50) -> pd.DataFrame:
    """
    Segment and measure nuclei in a fluorescence TIFF.

    Parameters
    ----------
    tiff_path  : path to single- or multi-channel TIFF
    output_csv : where to save results
    channel    : 1-based channel index for nuclear stain (e.g., DAPI)
    sigma      : Gaussian blur radius in pixels
    min_size   : minimum nucleus area in pixels
    """
    # Step 1: Open image
    imp = ij.io().open(tiff_path)
    print(f"Loaded: {Path(tiff_path).name}  dims={imp.getDimensions()}")

    # Step 2: Extract channel if multi-channel
    if imp.getNChannels() > 1:
        imp.setC(channel)

    # Step 3: Apply Gaussian blur and threshold via macro
    ij.macro.run(f"""
selectWindow("{imp.getTitle()}");
run("Gaussian Blur...", "sigma={sigma}");
setAutoThreshold("Otsu dark");
run("Convert to Mask");
run("Fill Holes");
run("Watershed");
""")

    # Step 4: Measure
    ij.macro.run(f"""
run("Set Measurements...", "area mean min centroid integrated shape redirect=None decimal=3");
run("Analyze Particles...", "size={min_size}-Infinity display clear include summarize");
""")

    # Step 5: Collect results
    rt = ij.ResultsTable.getResultsTable()
    if rt is None or rt.size() == 0:
        print("No objects detected")
        return pd.DataFrame()

    headings = list(rt.getHeadings())
    df = pd.DataFrame(
        {col: [rt.getValue(col, i) for i in range(rt.size())]
         for col in headings}
    )
    df["source_file"] = Path(tiff_path).stem
    df.to_csv(output_csv, index=False)
    print(f"Saved {len(df)} measurements → {output_csv}")
    return df


df = quantify_nuclei(
    tiff_path="/data/experiment_dapi.tif",
    output_csv="nuclei_measurements.csv",
    channel=1,
    sigma=1.5,
    min_size=50
)
print(df[["Area", "Mean", "Circ."]].describe())

工作流 2：批量 Fiji 宏处理

目标：使用现有的 Fiji .ijm 宏文件处理一个图像文件夹，并将每张图像的 Results 表收集到一个 DataFrame 中。

import imagej
import pandas as pd
from pathlib import Path

ij = imagej.init("sc.fiji:fiji", mode="headless")

def run_macro_on_image(ij, image_path: str, macro_file: str) -> pd.DataFrame:
    """Open one image, run a macro file, return its Results table."""
    ij.io().open(image_path)

    # Clear any previous results before running
    ij.macro.run("run(\"Clear Results\");")

    # Run macro file (macro must operate on the active image)
    ij.macro.runMacroFile(macro_file)

    rt = ij.ResultsTable.getResultsTable()
    if rt is None or rt.size() == 0:
        return pd.DataFrame()
    headings = list(rt.getHeadings())
    return pd.DataFrame(
        {col: [rt.getValue(col, i) for i in range(rt.size())]
         for col in headings}
    )


input_dir  = Path("/data/images")
macro_file = "/scripts/measure_cells.ijm"
output_csv = "batch_results.csv"

all_results = []
image_files = sorted(input_dir.glob("*.tif"))

for img_path in image_files:
    print(f"Processing: {img_path.name}")
    df = run_macro_on_image(ij, str(img_path), macro_file)
    if not df.empty:
        df["filename"] = img_path.name
        all_results.append(df)

    # Close all windows to free memory between images
    ij.macro.run("close('*');")

if all_results:
    combined = pd.concat(all_results, ignore_index=True)
    combined.to_csv(output_csv, index=False)
    print(f"Batch complete: {len(image_files)} images, "
          f"{len(combined)} total measurements → {output_csv}")
else:
    print("No results collected from any image")

关键参数

参数	模块	默认值	范围 / 选项	作用
mode	初始化	"headless"	"headless"、"gui"、"interactive"	控制是否打开 Fiji GUI 窗口；运行脚本时使用 "headless"
endpoint	初始化	"sc.fiji:fiji"	Maven 坐标或 /path/to/Fiji.app	选择 ImageJ2 发行版；sc.fiji:fiji 包含所有 Fiji 插件
sigma（高斯模糊）	宏 / Ops	2.0	0.5–10.0	以像素为单位的空间平滑半径；值越大，降噪效果越好，但边缘也会越模糊
minSize（分析粒子）	插件 / 宏	0	像素² 或 0–Infinity	要纳入的最小对象面积；用于消除噪点
method（自动阈值）	宏 / Ops	"Otsu"	"Otsu"、"Triangle"、"MaxEntropy"、"Huang"、"Li"	阈值算法；对于双峰直方图，Otsu 效果较好
measurements 位掩码	结果 / 宏	不固定	AREA=1、MEAN=2、CENTROID=4 等值的 OR 组合	选择结果表中显示的列
Java 堆大小	初始化（环境变量）	JVM 默认值（约为 RAM 的 25%）	通过 JAVA_TOOL_OPTIONS 设置	限制处理大型堆栈时使用的内存；处理大图像时设置 -Xmx8g

最佳实践

1. 每个会话只初始化一次，并重复使用 ij：启动新的 JVM 开销很大（5–15 秒）。在模块级别创建 ij，或将其作为参数传递，不要在循环内调用 imagej.init()。

   # At module top level — initialized once
   import imagej
   ij = imagej.init("sc.fiji:fiji", mode="headless")
   
   def process(path):
       imp = ij.io().open(path)   # reuse ij
       ...
   

2. 使用 conda 管理 Java：仅使用 pip 安装时，经常会因未设置 JAVA_HOME 或 PATH 中的 JDK 版本不正确而失败。使用包含 openjdk=11 的 conda 环境，可避免 90% 的 JVM 未找到错误。

3. 在批处理循环中处理不同图像时，清除 Results 和 ROI Manager：ImageJ 会在同一会话的多次调用中累积结果。每处理一张图像前，务必调用 run("Clear Results") 和 rm.reset()，以免不同行的数据混在一起。

   ij.macro.run("run('Clear Results');")
   rm = get_roi_manager(ij)
   rm.reset()
   

4. 简单命令优先使用 ij.macro.run()，而非 ij.command().run()：宏字符串更短、更易读，并且与 Fiji Macro Recorder 使用相同的语法。只有在需要以编程方式访问命令输出（模块返回值）时，才使用 ij.command().run()。

5. 尽可能延后转换为 NumPy：ij.py.from_imageplus() 会将数据从 JVM 复制到 Python。在 ImageJ 中进行多步处理时，尽量将数据保留为 ImagePlus 或 ImgLib2 格式，仅在最后转换，以最大限度地减少内存复制开销。

6. 将 ImgLib2 Ops 与 ij.py.to_java() / ij.py.from_java() 搭配使用：to_imageplus() / from_imageplus() 适用于经典的 ImageProcessor；to_java() / from_java() 则面向现代 ImgLib2 类型系统，这是 ij.op() 所要求的。

7. 初始化时设置 Fiji 更新站点插件列表，确保结果可复现：指定固定的 Fiji 版本（sc.fiji:fiji:2.14.0），而不要使用 sc.fiji:fiji（最新版本），以免 Fiji 发布新的插件更新后改变流水线的行为。

常用方案

方案：无界面运行 TrackMate 点检测

适用场景：以编程方式运行 TrackMate 粒子跟踪，并将检测到的点作为 DataFrame 获取，而不打开 TrackMate GUI。

import imagej
import pandas as pd

ij = imagej.init("sc.fiji:fiji", mode="headless")

# TrackMate headless via macro (scripting interface)
trackmate_macro = """
run("TrackMate", "");
// For fully scripted TrackMate, use the Scripting Interface
// documented at https://imagej.net/plugins/trackmate/scripting
"""

# Scripted TrackMate via Jython-style Java interop
def run_trackmate_headless(ij, imp, radius=3.0, threshold=100.0):
    """Detect spots with LoG detector; return DataFrame of spot coordinates."""
    from jnius import autoclass

    # Import TrackMate classes
    Model          = autoclass("fiji.plugin.trackmate.Model")
    Settings       = autoclass("fiji.plugin.trackmate.Settings")
    TrackMate      = autoclass("fiji.plugin.trackmate.TrackMate")
    LogDetectorFactory = autoclass(
        "fiji.plugin.trackmate.detection.LogDetectorFactory")

    model    = Model()
    settings = Settings(imp)

    # Configure LoG spot detector
    settings.detectorFactory = LogDetectorFactory()
    settings.detectorSettings = {
        "DO_SUBPIXEL_LOCALIZATION": True,
        "RADIUS": radius,
        "TARGET_CHANNEL": 1,
        "THRESHOLD": threshold,
        "DO_MEDIAN_FILTERING": False,
    }

    tm = TrackMate(model, settings)
    tm.process()

    # Extract spot table
    spots = model.getSpots()
    spots.setVisible(True)
    records = []
    for spot in spots.iterable(True):
        records.append({
            "id":       spot.ID(),
            "x":        spot.getDoublePosition(0),
            "y":        spot.getDoublePosition(1),
            "z":        spot.getDoublePosition(2),
            "frame":    spot.getFeature("FRAME"),
            "quality":  spot.getFeature("QUALITY"),
        })
    return pd.DataFrame(records)


imp = ij.io().open("/data/timelapse.tif")
df  = run_trackmate_headless(ij, imp, radius=3.0, threshold=50.0)
print(f"Detected {len(df)} spots across {df['frame'].nunique()} frames")
df.to_csv("spots.csv", index=False)
print(df.head())

方案：将 ImageJ Hyperstack 转换为 NumPy 5D 数组（TZCYX）

适用场景：将多维 Fiji hyperstack 导入 Python，转换为 5D NumPy 数组，并采用大多数科学图像分析库使用的标准 TZCYX 轴顺序。

import imagej
import numpy as np

ij = imagej.init("sc.fiji:fiji", mode="headless")

def hyperstack_to_numpy(ij, imp) -> np.ndarray:
    """
    Convert an ImageJ hyperstack to a NumPy array with shape (T, Z, C, Y, X).

    ImageJ internal order is C-Z-T (slowest to fastest in stack index).
    This function reorders to the TZCYX convention used by tifffile, OME, etc.
    """
    nC = imp.getNChannels()
    nZ = imp.getNSlices()
    nT = imp.getNFrames()
    H  = imp.getHeight()
    W  = imp.getWidth()

    arr = np.zeros((nT, nZ, nC, H, W), dtype=np.uint16)

    for t in range(1, nT + 1):
        for z in range(1, nZ + 1):
            for c in range(1, nC + 1):
                idx = imp.getStackIndex(c, z, t)
                imp.setSlice(idx)
                arr[t-1, z-1, c-1] = ij.py.from_imageplus(imp)

    return arr


imp = ij.io().open("/data/4d_experiment.tif")
print(f"ImageJ dims (W,H,C,Z,T): {imp.getDimensions()}")

stack = hyperstack_to_numpy(ij, imp)
print(f"NumPy TZCYX shape: {stack.shape}")  # e.g., (10, 15, 2, 512, 512)
print(f"dtype: {stack.dtype}, max: {stack.max()}")

# Save as OME-TIFF with correct axis metadata
import tifffile
tifffile.imwrite(
    "output_TZCYX.ome.tif",
    stack,
    imagej=True,
    metadata={"axes": "TZCYX"},
    photometric="minisblack"
)
print("Saved output_TZCYX.ome.tif")

故障排查

问题	原因	解决方案
初始化时出现 JVMNotFoundException	未设置 JAVA_HOME，或 JDK 版本不正确	通过 conda 安装：conda install -c conda-forge openjdk=11；避免使用 Java 17
RuntimeError: Fiji download failed	无法连接互联网，或存在公司代理	从 fiji.sc 手动下载 Fiji，然后使用 imagej.init("/path/to/Fiji.app")
处理大型图像堆栈时出现 java.lang.OutOfMemoryError	JVM 默认堆内存太小	在导入 imagej 前设置 export JAVA_TOOL_OPTIONS="-Xmx8g"
宏 run(...) 静默无效	宏需要活动图像，但当前没有	运行处理宏前调用 ij.io().open(path)；检查 ij.WindowManager.getImageCount()
Analyze Particles 后结果表为空	未应用阈值，或掩膜不是二值图像	确认掩膜是 8 位二值图像（0/255），且 imp.getType() == 0；在 Analyze Particles 前运行 Convert to Mask
调用 ij.ResultsTable.getResultsTable() 时出现 AttributeError: 'NoneType' object	当前会话中尚未运行测量	确认 Analyze Particles 宏已完成；运行 ij.macro.run("print(nResults);") 检查计数
找不到插件类（ClassNotFoundException）	此 Fiji 安装中没有该插件	添加 Fiji 更新站点（例如 TrackMate），或使用包含所有默认插件的 sc.fiji:fiji endpoint
gui 模式因 HeadlessException 崩溃	没有可用显示器（SSH/集群）	在远程环境中使用 mode="headless"；GUI 模式需要 DISPLAY 或 X11 转发

相关技能

• scikit-image-processing — 无需 JVM 的纯 Python 图像处理；适用于不需要 Fiji 插件的情况
• napari-image-viewer — 用于 Python 的交互式多维图像查看器；可与 PyImageJ 配合进行可视化
• trackpy-particle-tracking — Python 原生 Crocker-Grier SPT；适用于简单 2D 跟踪，可替代 TrackMate
• cellpose-cell-segmentation — 基于深度学习的细胞分割；可独立运行，也可作为 Fiji 插件运行
• omero-integration — OMERO 服务图像管理；PyImageJ 可处理通过 omero-py 获取的图像

参考资料

• PyImageJ 文档 — 官方 API 参考、初始化指南和数据转换
• PyImageJ GitHub 仓库 — 源代码、问题跟踪器、笔记本和示例
• ImageJ Ops 框架 — Ops 命名空间参考和算法目录
• TrackMate 脚本指南 — 无头 TrackMate Java API 模式
• Bio-Formats 支持的格式 — 可通过 ij.io().open() 打开的专有显微镜格式列表
• ImageJ 宏语言参考 — ij.macro.run() 字符串可用的内置函数