dclab 0.67.0__cp314-cp314t-macosx_11_0_arm64.whl

dclab/definitions/feat_const.py

@@ -0,0 +1,202 @@
+#: List of scalar (one scalar value per event) features. This
+#: list does not include the `ml_score_???` features. If you
+#: need find out whether a feature name is valid, please use
+#: :func:`is_valid_feature`.
+FEATURES_SCALAR = [
+    ["area_cvx", "Convex area [px]"],
+    # area_msd is the contour moment M00
+    ["area_msd", "Measured area [px]"],
+    ["area_ratio", "Porosity (convex to measured area ratio)"],
+    # area_um is computed from the convex contour
+    ["area_um", "Area [µm²]"],
+    ["area_um_raw", "Area [µm²] of raw contour"],
+    ["aspect", "Aspect ratio of bounding box"],
+    # The background brightness of the frame (not of the mask)
+    ["bg_med", "Median frame background brightness [a.u.]"],
+    # Background image offset which should be added to "image_bg" before
+    # performing background correction. This is used in cases where the
+    # background stored in "image_bg" is not accurate enough, e.g.
+    # because the image_bg is a median image for multiple events and
+    # the imaging system exhibits flickering.
+    ["bg_off", "Background offset [a.u.]"],
+    # Brightness values are computed only for pixels inside the mask
+    ["bright_avg", "Brightness average [a.u.]"],
+    ["bright_sd", "Brightness SD [a.u.]"],
+    ["bright_bc_avg", "Brightness average (bgc) [a.u.]"],
+    ["bright_bc_sd", "Brightness SD (bgc) [a.u.]"],
+    ["bright_perc_10", "10th Percentile of brightness (bgc)"],
+    ["bright_perc_90", "90th Percentile of brightness (bgc)"],
+    ["circ", "Circularity"],
+    # deform is computed from the convex contour
+    ["deform", "Deformation"],
+    ["deform_raw", "Deformation of raw contour"],
+    ["eccentr_prnc", "Eccentricity of raw contour"],
+    ["emodulus", "Young's modulus [kPa]"],
+    # fl*_area, fl*_pos, and fl*_width values correspond to the
+    # object for which the contour was found. For high concentrations,
+    # these values could be error-prone due to the assignment from
+    # false objects.
+    ["fl1_area", "FL-1 area of peak [a.u.]"],
+    # fl1_dist is set to zero if there is only one peak
+    ["fl1_dist", "FL-1 distance between two first peaks [µs]"],
+    ["fl1_max", "FL-1 maximum [a.u.]"],
+    ["fl1_max_ctc", "FL-1 maximum, crosstalk-corrected [a.u.]"],
+    ["fl1_npeaks", "FL-1 number of peaks"],
+    ["fl1_pos", "FL-1 position of peak [µs]"],
+    ["fl1_width", "FL-1 width [µs]"],
+    ["fl2_area", "FL-2 area of peak [a.u.]"],
+    ["fl2_dist", "FL-2 distance between two first peaks [µs]"],
+    ["fl2_max", "FL-2 maximum [a.u.]"],
+    ["fl2_max_ctc", "FL-2 maximum, crosstalk-corrected [a.u.]"],
+    ["fl2_npeaks", "FL-2 number of peaks"],
+    ["fl2_pos", "FL-2 position of peak [µs]"],
+    ["fl2_width", "FL-2 width [µs]"],
+    ["fl3_area", "FL-3 area of peak [a.u.]"],
+    ["fl3_dist", "FL-3 distance between two first peaks [µs]"],
+    ["fl3_max", "FL-3 maximum [a.u.]"],
+    ["fl3_max_ctc", "FL-3 maximum, crosstalk-corrected [a.u.]"],
+    ["fl3_npeaks", "FL-3 number of peaks"],
+    ["fl3_pos", "FL-3 position of peak [µs]"],
+    ["fl3_width", "FL-3 width [µs]"],
+    # Sum of the flow rates for sample and sheath flow
+    ["flow_rate", "Flow rate [µLs⁻¹]"],
+    ["frame", "Video frame number"],
+    ["g_force", "Gravitational force in multiples of g"],
+    # index starts with 1
+    ["index", "Index (Dataset)"],
+    # index_online enumerates the events found by Shape-In and may have
+    # missing values in case of a writer-overrun with recovery (#71)
+    ["index_online", "Index (Online)"],
+    # The inertia ratios of the event contours are defined by the
+    # central second order moments of area (sqrt(m20/m02).
+    ["inert_ratio_cvx", "Inertia ratio of convex contour"],
+    ["inert_ratio_prnc", "Principal inertia ratio of raw contour"],
+    ["inert_ratio_raw", "Inertia ratio of raw contour"],
+    # This is an ancillary integer feature for visualizing the class
+    # membership of individual events based on the `ml_score_???`
+    # features.
+    ["ml_class", "Most probable ML class"],
+    ["nevents", "Number of events in the same image"],
+    ["pc1", "Principal component 1"],
+    ["pc2", "Principal component 2"],
+    # Convexity is defined by the ratio of convex contour length
+    # versus raw contour length. We use inverse convexity as it is
+    # more convenient to work with numbers >1.
+    ["per_ratio", "Inverse Convexity (raw to convex perimeter ratio)"],
+    ["per_um_raw", "Perimeter [µm] of raw contour"],
+    # pos_x and pos_y are computed from the contour moments
+    # "m10"/"m00" and "m01"/"m00" of the convex hull of "contour"
+    ["pos_x", "Position along channel axis [µm]"],
+    ["pos_y", "Position lateral in channel [µm]"],
+    # Sum of the pressures applied to sample and sheath flow
+    ["pressure", "Pressure [mPa]"],
+    # QPI features computed from holographic data
+    ["qpi_dm_avg", "Dry mass (average) [pg]"],
+    ["qpi_dm_sd", "Dry mass (SD) [pg]"],
+    ["qpi_pha_int", "Integrated phase [rad]"],
+    ["qpi_ri_avg", "Refractive index (average)"],
+    ["qpi_ri_sd", "Refractive index (SD)"],
+    # QPI features from refocused events
+    ["qpi_focus", "Computed focus distance [µm]"],
+    # Size features
+    ["size_x", "Bounding box size x [µm]"],
+    ["size_y", "Bounding box size y [µm]"],
+    # Ratio between two halves of a mask
+    ["sym_x", "Symmetry ratio left-right"],
+    ["sym_y", "Symmetry ratio top-bottom"],
+    ["temp", "Chip temperature [°C]"],
+    ["temp_amb", "Ambient temperature [°C]"],
+    # Haralick texture features can be computed using the mahotas package
+    # from the background-corrected and masked image
+    ["tex_asm_avg", "Texture angular second moment (avg)"],  # H1
+    ["tex_asm_ptp", "Texture angular second moment (ptp)"],  # H1
+    ["tex_con_avg", "Texture contrast (avg)"],  # H2
+    ["tex_con_ptp", "Texture contrast (ptp)"],  # H2
+    ["tex_cor_avg", "Texture correlation (avg)"],  # H3
+    ["tex_cor_ptp", "Texture correlation (ptp)"],  # H3
+    ["tex_den_avg", "Texture difference entropy (avg)"],  # 11
+    ["tex_den_ptp", "Texture difference entropy (ptp)"],  # 11
+    ["tex_ent_avg", "Texture entropy (avg)"],  # H9
+    ["tex_ent_ptp", "Texture entropy (ptp)"],  # H9
+    ["tex_f12_avg", "Texture First measure of correlation (avg)"],  # 12
+    ["tex_f12_ptp", "Texture First measure of correlation (ptp)"],  # 12
+    ["tex_f13_avg", "Texture Second measure of correlation (avg)"],  # 13
+    ["tex_f13_ptp", "Texture Second measure of correlation (ptp)"],  # 13
+    ["tex_idm_avg", "Texture inverse difference moment (avg)"],  # H5
+    ["tex_idm_ptp", "Texture inverse difference moment (ptp)"],  # H5
+    ["tex_sen_avg", "Texture sum entropy (avg)"],  # H8
+    ["tex_sen_ptp", "Texture sum entropy (ptp)"],  # H8
+    ["tex_sva_avg", "Texture sum variance (avg)"],  # H7
+    ["tex_sva_ptp", "Texture sum variance (ptp)"],  # H7
+    ["tex_var_avg", "Texture variance (avg)"],  # H4
+    ["tex_var_ptp", "Texture variance (ptp)"],  # H4
+    ["tilt", "Absolute tilt of raw contour"],
+    ["time", "Time [s]"],
+    # Volume is computed from the raw contour (i.e. with exclusions).
+    # Fun fact: If we had decided to compute it from the convex contour,
+    # then we would have close to none pixelation effects ¯\_(ツ)_/¯.
+    ["volume", "Volume [µm³]"],
+]
+
+#: User-defined features: They are not reserved for anything specific
+#: and can be used by the user for e.g. prototyping.
+for _i in range(10):
+    FEATURES_SCALAR.append([f"userdef{_i}", f"User-defined {_i}"])
+
+#: Basin mapping features: These are used for datasets that are derived from a
+#: subset of events of another dataset. For instance, if a dataset consists
+#: of every second event from another dataset, the feature `basinmap1` would
+#: consist of the integer array `[1, 3, 5, 7, ...]` (indexing starts at zero).
+#: The `basinmap1` feature must then be referenced in the corresponding basin
+#: definition. These features should not be presented explicitly to the
+#: normal user (e.g. in DCscope) to avoid ambiguities, and they should
+#: always be exported alongside basins that refer to them.
+for _j in range(10):
+    FEATURES_SCALAR.append([f"basinmap{_j}", f"Basin mapping {_j}"])
+
+#: list of non-scalar features
+FEATURES_NON_SCALAR = [
+    # This is a (M, 2)-shaped array with integer contour coordinates
+    ["contour", "Event contour"],
+    ["image", "Gray scale event image"],
+    ["image_bg", "Gray scale event background image"],
+    # This is the contour with holes filled
+    ["mask", "Binary mask labeling the event in the image"],
+    # See FLUOR_TRACES for valid keys
+    ["trace", "Dictionary of fluorescence traces"],
+    # QPI experimental holographic data
+    ["qpi_oah", "Off-axis hologram"],
+    # QPI holographic background data (experimental or computed)
+    ["qpi_oah_bg", "Off-axis hologram background"],
+    # QPI features computed from holographic data
+    ["qpi_pha", "Hologram phase image [rad]"],
+    ["qpi_amp", "Hologram amplitude image"],
+]
+
+#: List of fluorescence traces
+FLUOR_TRACES = [
+    "fl1_median",
+    "fl1_raw",
+    "fl2_median",
+    "fl2_raw",
+    "fl3_median",
+    "fl3_raw",
+]
+
+
+# FEATURE convenience lists and dicts
+
+#: list of feature names
+feature_names = [_cc[0] for _cc in FEATURES_SCALAR + FEATURES_NON_SCALAR]
+
+#: list of feature labels (same order as :const:`feature_names`
+feature_labels = [_cc[1] for _cc in FEATURES_SCALAR + FEATURES_NON_SCALAR]
+
+#: dict for converting feature names to labels
+feature_name2label = {}
+
+for _cc in FEATURES_SCALAR + FEATURES_NON_SCALAR:
+    feature_name2label[_cc[0]] = _cc[1]
+
+#: list of scalar feature names
+scalar_feature_names = [_cc[0] for _cc in FEATURES_SCALAR]

dclab/definitions/feat_logic.py

@@ -0,0 +1,182 @@
+import re
+
+from . import feat_const
+
+
+ML_SCORE_REGEX = re.compile(r"^ml_score_[a-z0-9]{3}$")
+
+
+def check_feature_shape(name, data):
+    """Check if (non)-scalar feature matches with its data's dimensionality
+
+    Parameters
+    ----------
+    name: str
+        name of the feature
+    data: array-like
+        data whose dimensionality will be checked
+
+    Raises
+    ------
+    ValueError
+        If the data's shape does not match its scalar description
+    """
+    if len(data.shape) == 1 and not scalar_feature_exists(name):
+        raise ValueError(
+            f"Feature '{name}' is not a scalar feature, but "
+            "a 1D array was given for `data`!"
+        )
+    elif len(data.shape) != 1 and scalar_feature_exists(name):
+        raise ValueError(
+            f"Feature '{name}' is a scalar feature, but the "
+            "`data` array is not 1D!"
+        )
+
+
+def feature_exists(name, scalar_only=False):
+    """Return True if `name` is a valid feature name
+
+    This function not only checks whether `name` is in
+    :const:`feature_names`, but also validates against
+    the machine learning scores `ml_score_???` (where
+    `?` can be a digit or a lower-case letter in the
+    English alphabet).
+
+    Parameters
+    ----------
+    name: str
+        name of a feature
+    scalar_only : bool
+        Specify whether the check should only search in scalar features
+
+    Returns
+    -------
+    valid: bool
+        True if name is a valid feature, False otherwise.
+
+    See Also
+    --------
+    scalar_feature_exists: Wraps `feature_exists` with `scalar_only=True`
+    """
+    valid = False
+    if name in feat_const.scalar_feature_names:
+        # scalar feature
+        valid = True
+    elif not scalar_only and name in feat_const.feature_names:
+        # non-scalar feature
+        valid = True
+    elif ML_SCORE_REGEX.match(name):
+        # machine-learning score feature ml_score_???
+        valid = True
+    return valid
+
+
+def feature_register(name, label=None, is_scalar=True):
+    """Register a new feature for usage in dclab
+
+    Used by temporary features and plugin features to add new feature
+    names and labels to `dclab.definitions`.
+
+    Parameters
+    ----------
+    name: str
+        name of a feature
+    label: str, optional
+        feature label corresponding to the feature name. If set to None, then
+        a label is constructed for the feature name.
+    is_scalar: bool
+        Specify whether the feature of an event is a scalar (True)
+        or not (False)
+
+    Raises
+    ------
+    ValueError
+        If the feature already exists.
+    """
+    allowed_chars = "abcdefghijklmnopqrstuvwxyz_1234567890"
+    feat = "".join([f for f in name if f in allowed_chars])
+    if feat != name:
+        raise ValueError(
+            "`feature` must only contain lower-case characters, "
+            f"digits, and underscores; got '{name}'!"
+        )
+    if label is None:
+        label = f"User-defined feature {name}"
+    if feature_exists(name):
+        raise ValueError(f"Feature '{name}' already exists!")
+
+    # Populate the new feature in all dictionaries and lists
+    # (we don't need global here)
+    feat_const.feature_names.append(name)
+    feat_const.feature_labels.append(label)
+    feat_const.feature_name2label[name] = label
+    if is_scalar:
+        feat_const.scalar_feature_names.append(name)
+
+
+def feature_deregister(name):
+    """Unregister a feature from dclab
+
+    Used by temporary features and plugin features to
+    remove the feature names and labels from `dclab.definitions`.
+
+    Parameters
+    ----------
+    name: str
+        name of a feature
+
+    Warnings
+    --------
+    This function should only be used internally, i.e., You should not use
+    this function. This function can break things.
+    """
+    label = get_feature_label(name)
+    feat_const.feature_names.remove(name)
+    feat_const.feature_labels.remove(label)
+    feat_const.feature_name2label.pop(name)
+    if name in feat_const.scalar_feature_names:
+        feat_const.scalar_feature_names.remove(name)
+
+
+def get_feature_label(name, rtdc_ds=None, with_unit=True):
+    """Return the label corresponding to a feature name
+
+    This function not only checks :const:`feature_name2label`,
+    but also supports registered `ml_score_???` features.
+
+    Parameters
+    ----------
+    name: str
+        name of a feature
+    with_unit: bool
+        set to False to remove units in square brackets
+
+    Returns
+    -------
+    label: str
+        feature label corresponding to the feature name
+
+    Notes
+    -----
+    TODO: extract feature label from ancillary information when an rtdc_ds is
+    given.
+    """
+    if name in feat_const.feature_name2label:
+        label = feat_const.feature_name2label[name]
+    elif ML_SCORE_REGEX.match(name):
+        # use a generic name for machine-learning features
+        label = f"ML score {name[-3:].upper()}"
+    else:
+        exists = feature_exists(name)
+        msg = f"Could not find label for '{name}'"
+        msg += " (feature does not exist)" if not exists else ""
+        raise ValueError(msg)
+    if not with_unit:
+        if label.endswith("]") and label.count("["):
+            label = label.rsplit("[", 1)[0].strip()
+    return label
+
+
+def scalar_feature_exists(name):
+    """Convenience method wrapping `feature_exists(..., scalar_only=True)`"""
+    return feature_exists(name, scalar_only=True)

dclab/definitions/meta_const.py

@@ -0,0 +1,252 @@
+import copy
+
+from .meta_parse import (
+    fbool, fint, fintlist, func_types, lcstr, f1dfloatduple, fboolorfloat
+)
+
+#: All configuration keywords editable by the user
+CFG_ANALYSIS = {
+    # filtering parameters
+    "filtering": [
+        ["hierarchy parent", str, "Hierarchy parent of the dataset"],
+        ["remove invalid events", fbool, "Remove events with inf/nan values"],
+        ["enable filters", fbool, "Enable filtering"],
+        ["limit events", fint, "Upper limit for number of filtered events"],
+        ["polygon filters", fintlist, "Polygon filter indices"],
+    ],
+    # Addition user-defined data
+    "calculation": [
+        ["emodulus lut", str, "Look-up table identifier"],
+        ["emodulus medium", str, "Medium used (e.g. '0.49% MC-PBS')"],
+        ["emodulus temperature", float, "Chip temperature [°C]"],
+        ["emodulus viscosity", float, "Viscosity [Pa*s] if 'medium' unknown"],
+        ["emodulus viscosity model", str, "Viscosity model for known media"],
+        ["crosstalk fl21", float, "Fluorescence crosstalk, channel 2 to 1"],
+        ["crosstalk fl31", float, "Fluorescence crosstalk, channel 3 to 1"],
+        ["crosstalk fl12", float, "Fluorescence crosstalk, channel 1 to 2"],
+        ["crosstalk fl32", float, "Fluorescence crosstalk, channel 3 to 2"],
+        ["crosstalk fl13", float, "Fluorescence crosstalk, channel 1 to 3"],
+        ["crosstalk fl23", float, "Fluorescence crosstalk, channel 2 to 3"],
+    ]
+}
+
+#: All read-only configuration keywords for a measurement
+CFG_METADATA = {
+    # All parameters related to the actual experiment
+    "experiment": [
+        ["date", str, "Date of measurement ('YYYY-MM-DD')"],
+        ["event count", fint, "Number of recorded events"],
+        ["run index", fint, "Index of measurement run"],
+        ["run identifier", str, "Unique measurement identifier"],
+        ["sample", str, "Measured sample or user-defined reference"],
+        ["time", str, "Start time of measurement ('HH:MM:SS[.S]')"],
+        ["timestamp", float, "Start of measurement in unix time [s]"],
+    ],
+    # All special keywords related to RT-FDC
+    # This section should not be present for regular RT-DC measurements.
+    "fluorescence": [
+        # The baseline offset was introduced in 0.33.0. It is added to
+        # the trace data to obtain the actual signal used for data
+        # processing (e.g. obtaining the fl1_max feature). This is more
+        # robust than adding the offset directly to the trace data, because
+        # of the possibility of integer overflows. Furthermore, DCKit can
+        # set this parameter without modifying the original trace data
+        # to correct/remove negative trace data
+        # (see https://github.com/DC-analysis/dclab/issues/101).
+        # Note that traces accessed from RTDCBase instances are never
+        # background-corrected!
+        ["baseline 1 offset", fint, "Baseline offset channel 1"],
+        ["baseline 2 offset", fint, "Baseline offset channel 2"],
+        ["baseline 3 offset", fint, "Baseline offset channel 3"],
+        ["bit depth", fint, "Trace bit depth"],
+        # If a fluorescence channel is used, a channel name *must* be
+        # present. If a channel is not used, the channel name *must not*
+        # be present. E.g. if only channels 1 and 2 are used, but there
+        # are three channels present, then `channel count` is two,
+        # `channels installed` is three, and `channel 3 name` is not set.
+        ["channel 1 name", str, "FL1 description"],
+        ["channel 2 name", str, "FL2 description"],
+        ["channel 3 name", str, "FL3 description"],
+        ["channel count", fint, "Number of active channels"],
+        ["channels installed", fint, "Number of available channels"],
+        # In contrast to `channel ? name`, the laser power *may*
+        # be present (but must be set to 0), if a laser line is not used.
+        ["laser 1 lambda", float, "Laser 1 wavelength [nm]"],
+        ["laser 1 power", float, "Laser 1 output power [%]"],
+        ["laser 2 lambda", float, "Laser 2 wavelength [nm]"],
+        ["laser 2 power", float, "Laser 2 output power [%]"],
+        ["laser 3 lambda", float, "Laser 3 wavelength [nm]"],
+        ["laser 3 power", float, "Laser 3 output power [%]"],
+        ["laser count", fint, "Number of active lasers"],
+        ["lasers installed", fint, "Number of available lasers"],
+        ["sample rate", fint, "Trace sample rate [Hz]"],
+        ["samples per event", fint, "Samples per event"],
+        ["signal max", float, "Upper voltage detection limit [V]"],
+        ["signal min", float, "Lower voltage detection limit [V]"],
+        ["trace median", fint, "Rolling median filter size for traces"],
+    ],
+    # All tdms-related parameters
+    "fmt_tdms": [
+        ["video frame offset", fint, "Missing events at beginning of video"],
+    ],
+    # All imaging-related keywords
+    "imaging": [
+        ["flash device", str, "Light source device type"],  # e.g. green LED
+        ["flash duration", float, "Light source flash duration [µs]"],
+        ["frame rate", float, "Imaging frame rate [Hz]"],
+        ["pixel size", float, "Pixel size [µm]"],
+        ["roi position x", fint, "Image x coordinate on sensor [px]"],
+        ["roi position y", fint, "Image y coordinate on sensor [px]"],
+        ["roi size x", fint, "Image width [px]"],
+        ["roi size y", fint, "Image height [px]"],
+    ],
+    # All parameters for online contour extraction from the event images
+    "online_contour": [
+        # The option "bg empty" was introduced in dclab 0.34.0 and
+        # Shape-In 2.2.2.5.
+        # Shape-In  writes to the "shapein-warning" log if there are
+        # frames with event images (non-empty frames) that had to be
+        # used for background correction.
+        ["bg empty", fbool, "Background correction from empty frames only"],
+        ["bin area min", fint, "Minium pixel area of binary image event"],
+        ["bin kernel", fint, "Disk size for binary closing of mask image"],
+        ["bin threshold", fint, "Threshold for mask from bg-corrected image"],
+        ["image blur", fint, "Odd sigma for Gaussian blur (21x21 kernel)"],
+        ["no absdiff", fbool, "Do not use OpenCV 'absdiff' for bg-correction"],
+    ],
+    # All online-filter-related keywords (box filters, soft limit, and
+    # polygons are handled in `meta_logic`).
+    # Note that "soft limit" means that the event is still included in
+    # the dataset, but is not counted for "target event count". On the
+    # other hand, "hard limit" means that only those events that are
+    # within that filter are written to the dataset.
+    "online_filter": [
+        # "target*" is only set if measurement is stopped automatically.
+        # "target*" is not necessarily reached (e.g. user aborted).
+        ["target duration", float, "Target measurement duration [min]"],
+        ["target event count", fint, "Target event count for online gating"],
+    ],
+    # Data processing pipeline
+    "pipeline": [
+        ["dcnum background", str, "Background ID"],
+        ["dcnum data", str, "Data ID"],
+        ["dcnum feature", str, "Feature extractor ID"],
+        ["dcnum gate", str, "Gating ID"],
+        ["dcnum generation", str, "Generation ID"],
+        # The hash is computed by joining the other pipeline identifiers with
+        # the "|" character in this order: generation, data, background,
+        # segmenter, feature, gate.
+        ["dcnum hash", str, "Hash"],
+        ["dcnum mapping", str, "Event mapping from original dataset"],
+        ["dcnum segmenter", str, "Segmenter ID"],
+        # The event yield the number of events the pipeline produced and
+        # helps identify files that were e.g. exported from original files.
+        ["dcnum yield", fint, "Event yield"],
+    ],
+    # All qpi-related keywords
+    "qpi": [
+        # experiment-related qpi metadata, see qpretrieve for details
+        ["wavelength", float, "Imaging wavelength [nm]"],
+        ["medium index", float, "Refractive index of medium"],
+        ["pixel size raw", float, "Hologram pixel size [µm]."],
+        # post-analysis-related qpi metadata
+        ["software version", str, "Software version(s)"],
+        # How background image was created 'experimental' or
+        # computation method e.g. 'sparsemed'
+        ["bg method", str, "Background computation method"],
+        # calculation of pha and amp from hologram
+        # FFT preprocessing
+        # padding: 0 means no padding
+        ["padding", fint, "Level of padding"],
+        ["subtract mean", fbool, "Subtract mean before processing"],
+        # pipeline_kws
+        ["filter name", str, "Fourier filter used"],
+        # qpretrieve defines the keyword argument `filter_size_interpretation`
+        # for determining the filter size in Fourier space. In DC, we
+        # need a well-defined value for the filter size. The most logical
+        # choice is to interpret the filter size as "frequency index", which
+        # is independent of the image shape and yields a good approximation
+        # of the actual resolution one can expect. The default value
+        # ("sideband distance") is a good choice for general QPI analysis,
+        # but there is no meaningful information one could extract from it
+        # by just looking at the number. Thus, the "filter size" that we
+        # see here corresponds to a filter size set in qpretrieve where
+        # `filter_size_interpretation="frequency index"`.
+        ["filter size", float, "Fourier filter size [1/pix]"],
+        ["scale to filter", fboolorfloat, "Scale QPI data to filter size"],
+        # x, y coordinates, don't set if you wish None to be the default
+        ["sideband freq", f1dfloatduple, "Sideband coordinates [1/pix]"],
+        ["invert phase", fbool, "Invert the phase data"],
+        # "pixel size proc" depends on `scale_to_filter`.
+        # If `scale_to_filter` is False, this is equal to "pixel size raw".
+        # If `scale_to_filter` is True or a float, this value will differ from
+        # "pixel size raw".
+        # RTDC "imaging:pixel size" equals "pixel size proc"
+        ["pixel size proc", float, "QPI pixel size [µm]."],
+        # postprocessing of phase and amplitude
+        ["amp fit offset", str, "Amplitude offset correction"],
+        ["amp fit profile", str, "Amplitude profile correction"],
+        ["pha fit offset", str, "Phase offset correction"],
+        ["pha fit profile", str, "Phase profile correction"],
+        # QPImage background correction mask information
+        ["amp border px", fint, "Width of border for amplitude [pix]"],
+        ["pha border px", fint, "Width of border for phase [pix]"],
+        # Forward compatible QPImage background correction for trivial
+        # masks e.g. "tblr". "tb" useful for RTDC channel.
+        ["amp border loc", str, "Border location specifier for amplitude"],
+        ["pha border loc", str, "Border location specifier for phase"],
+        # refocusing metadata
+        ["focus interval", f1dfloatduple, "Focus interval to search [µm]"],
+        ["focus metric", str, "Metric used to calculate focus"],
+        ["focus minimizer", str, "Minimizer used to calculate focus"],
+        ["focus kernel", str, "Propagation kernel"],
+        ["focus padding", fint, "Level of padding for refocus"],
+    ],
+    # All setup-related keywords, except imaging
+    "setup": [
+        ["channel width", float, "Width of microfluidic channel [µm]"],
+        ["chip identifier", lcstr, "Unique identifier of the chip used"],
+        ["chip region", lcstr, "Imaged chip region (channel or reservoir)"],
+        ["flow rate", float, "Flow rate in channel [µL/s]"],
+        ["flow rate sample", float, "Sample flow rate [µL/s]"],
+        ["flow rate sheath", float, "Sheath flow rate [µL/s]"],
+        ["identifier", str, "Unique setup identifier"],
+        # "medium" can have various values; it is used to calculate viscosity
+        ["medium", str, "Medium used"],
+        ["module composition", str, "Comma-separated list of modules used"],
+        ["software version", str, "Acquisition software with version"],
+        ["temperature", float, "Mean chip temperature [°C]"],
+    ],
+}
+
+# CFG convenience lists and dicts
+_cfg = copy.deepcopy(CFG_METADATA)
+_cfg.update(CFG_ANALYSIS)
+
+#: dict with metadata description
+config_descr = {}
+for _key in _cfg:
+    config_descr[_key] = {}
+    for _subkey, __, _descr in _cfg[_key]:
+        config_descr[_key][_subkey] = _descr
+
+#: dict of dicts containing functions to convert input data
+config_funcs = {}
+for _key in _cfg:
+    config_funcs[_key] = {}
+    for _subkey, _type, __ in _cfg[_key]:
+        config_funcs[_key][_subkey] = _type
+
+#: dict with section as keys and config parameter names as values
+config_keys = {}
+for _key in _cfg:
+    config_keys[_key] = [it[0] for it in _cfg[_key]]
+
+#: dict of dicts containing the type of section parameters
+config_types = {}
+for _key in _cfg:
+    config_types[_key] = {}
+    for _subkey, _type, __ in _cfg[_key]:
+        if _type in func_types:
+            _type = func_types[_type]
+        config_types[_key][_subkey] = _type