flimkit 0.12.0__py3-none-any.whl

flimkit/formats/PTU/tools.py

@@ -0,0 +1,94 @@
+import numpy as np
+from .reader import PTUFile
+
+def signal_from_PTUFile(
+    filename,
+    /,
+    *,
+    dtype=None,
+    frame=None,
+    channel=0,
+    dtime=0,
+    binning=1,
+    keepdims=False,
+):
+    from xarray import DataArray
+
+    ptu = PTUFile(str(filename), verbose=False)
+    is_image = ptu.n_x > 0 and ptu.n_y > 0
+    _active_channels = np.asarray(ptu._active)
+
+    if is_image:
+        cubes = [ptu.raw_pixel_stack(channel=int(c), binning=binning)
+                 for c in _active_channels]
+        stack = np.stack(cubes, axis=0)
+        data = np.transpose(stack, (1, 2, 0, 3))[np.newaxis, ...]
+    else:
+        hists = [ptu.summed_decay(channel=int(c)) for c in _active_channels]
+        data = np.stack(hists, axis=0)[np.newaxis, np.newaxis, np.newaxis, :, :]
+
+    if dtype is None:
+        dtype = np.uint16
+    data = data.astype(dtype)
+
+    n_bins_full = data.shape[-1]
+
+    if dtime is not None:
+        if dtime < 0:
+            data = data.sum(axis=-1, keepdims=keepdims)
+        elif dtime > 0:
+            data = data[..., :dtime]
+
+    if channel is not None:
+        if channel < 0:
+            data = data.sum(axis=3, keepdims=keepdims)
+        else:
+            ch_positions = np.where(_active_channels == channel)[0]
+            if len(ch_positions) == 0:
+                raise ValueError(
+                    f"Channel {channel} not found in PTU file. "
+                    f"Available hardware channels: {_active_channels.tolist()}"
+                )
+            channel_idx = int(ch_positions[0])
+            if keepdims:
+                data = data[:, :, :, channel_idx : channel_idx + 1]
+            else:
+                data = data[:, :, :, channel_idx]
+
+    if frame is not None:
+        if frame < 0:
+            data = data.sum(axis=0, keepdims=keepdims)
+        else:
+            if keepdims:
+                data = data[frame : frame + 1]
+            else:
+                data = data[frame]
+
+    all_dims = ['T', 'Y', 'X', 'C', 'H']
+    removed = []
+    if dtime is not None and dtime < 0 and not keepdims:
+        removed.append('H')
+    if channel is not None and channel >= 0 and not keepdims:
+        removed.append('C')
+    if frame is not None and not keepdims:
+        removed.append('T')
+    dims = [d for d in all_dims if d not in removed]
+
+    coords = {}
+    h_bins = dtime if (dtime is not None and dtime > 0) else n_bins_full
+    time_ns = ptu.time_ns[:h_bins]
+    if 'H' in dims:
+        coords['H'] = ('H', time_ns)
+
+    frequency_mhz = ptu.sync_rate * 1e-6
+
+    da = DataArray(
+        data,
+        dims=dims,
+        coords=coords,
+        attrs={
+            'frequency': frequency_mhz,
+            'ptu_tags': ptu.tags,
+        },
+    )
+    return da

flimkit/formats/__init__.py

@@ -0,0 +1,2 @@
+from .flim_file import (FLIMFile, detect_format, file_modality,
+                        supported_formats, supported_extensions, file_dialog_filetypes)

flimkit/formats/flim_file.py

@@ -0,0 +1,232 @@
+from pathlib import Path
+import importlib
+
+_FORMATS = [
+    {'id': 'ptu', 'label': 'PicoQuant PTU', 'exts': ('.ptu',),
+     'modality': 'time', 'reader': 'flimkit.formats.PTU.reader:PTUFile'},
+    {'id': 'bh_sdt', 'label': 'Becker & Hickl SDT', 'exts': ('.sdt',),
+     'modality': 'time', 'reader': 'flimkit.formats.BH.reader:BHFile'},
+    {'id': 'iss_tdflim', 'label': 'ISS time-tag',
+     'exts': ('.tagtime', '.tagchannel', '.tagdecay'),
+     'modality': 'time', 'reader': 'flimkit.formats.ISS.reader:ISSFile'},
+    {'id': 'iss_image', 'label': 'ISS image', 'exts': ('.ifi',),
+     'modality': 'intensity', 'reader': 'flimkit.formats.ISS.image:ISSImage'},
+    {'id': 'iss_fdflim', 'label': 'ISS FD-FLIM (phasor)', 'exts': ('.ifli',),
+     'modality': 'frequency', 'reader': 'flimkit.formats.ISS.fdflim:ISSFdFlim'},
+    {'id': 'ps', 'label': 'Photonscore .photons', 'exts': ('.photons',),
+     'modality': 'time', 'reader': 'flimkit.formats.PS.reader:PSFile'},
+    {'id': 'pq_phu', 'label': 'PicoQuant PHU (histogram)', 'exts': ('.phu',),
+     'modality': 'time', 'reader': 'flimkit.formats.PTU.phu:PHUFile'},
+    {'id': 'pq_bin', 'label': 'PicoQuant BIN', 'exts': ('.bin',),
+     'modality': 'time', 'reader': 'flimkit.formats.signal:PQBinFile'},
+    {'id': 'simfcs_bh', 'label': 'SimFCS B&H', 'exts': ('.b&h',),
+     'modality': 'time', 'reader': 'flimkit.formats.signal:SimfcsBHFile'},
+    {'id': 'simfcs_bhz', 'label': 'SimFCS BHZ', 'exts': ('.bhz',),
+     'modality': 'time', 'reader': 'flimkit.formats.signal:SimfcsBHZFile'},
+    {'id': 'imspector_tiff', 'label': 'ImSpector FLIM TIFF', 'exts': ('.tif', '.tiff'),
+     'modality': 'time', 'reader': 'flimkit.formats.signal:ImspectorTIFFFile'},
+    {'id': 'iss_vista_tdflim', 'label': 'ISS Vista TDFLIM', 'exts': ('.iss-tdflim', '.tdflim'),
+     'modality': 'time', 'reader': 'flimkit.formats.signal:VistaTdflimFile'},
+    {'id': 'simfcs_referenced', 'label': 'SimFCS referenced (phasor)', 'exts': ('.ref', '.r64'),
+     'modality': 'frequency', 'reader': 'flimkit.formats.phasor:SimfcsReferencedFile'},
+    {'id': 'ometiff_phasor', 'label': 'PhasorPy OME-TIFF (phasor)', 'exts': ('.ome.tif',),
+     'modality': 'frequency', 'reader': 'flimkit.formats.phasor:OmeTiffPhasorFile'},
+    {'id': 'flimlabs_phasor', 'label': 'FLIM LABS phasor (JSON)', 'exts': ('.json',),
+     'modality': 'frequency', 'reader': 'flimkit.formats.phasor:FlimLabsPhasorFile'},
+    {'id': 'flimlabs_signal', 'label': 'FLIM LABS imaging (JSON)', 'exts': (),
+     'modality': 'time', 'reader': 'flimkit.formats.signal:FlimLabsSignalFile'},
+]
+
+_cache = {'version': None, 'formats': None, 'ext_to_id': None, 'modality_by_id': None}
+
+def _registry():
+    from flimkit import plugins
+    plugins.ensure_loaded()
+    return plugins.registry
+
+def _all_formats():
+    reg = _registry()
+    if _cache['version'] != reg.version():
+        merged = [dict(f) for f in _FORMATS]
+        known = {f['id'] for f in merged}
+        for f in reg.formats():
+            if f.id in known:
+                continue
+            merged.append({'id': f.id, 'label': f.label, 'exts': f.exts,
+                           'modality': f.modality, 'reader': f})
+        ext_to_id = {}
+        for f in merged:
+            for ext in f['exts']:
+                ext_to_id.setdefault(ext, f['id'])
+        _cache['formats'] = merged
+        _cache['ext_to_id'] = ext_to_id
+        _cache['modality_by_id'] = {f['id']: f['modality'] for f in merged}
+        _cache['version'] = reg.version()
+    return _cache['formats']
+
+def _ext_to_id():
+    _all_formats()
+    return _cache['ext_to_id']
+
+def _modality_by_id():
+    _all_formats()
+    return _cache['modality_by_id']
+
+def _find_sibling(stem, ext_lower):
+    direct = Path(str(stem) + ext_lower)
+    if direct.exists():
+        return direct
+    parent = stem.parent if str(stem.parent) else Path('.')
+    target = stem.name.lower() + ext_lower
+    if parent.exists():
+        for f in parent.iterdir():
+            if f.name.lower() == target:
+                return f
+    return None
+
+def _has_iss_triplet(p):
+    stem = p.with_suffix('') if p.suffix else p
+    return _find_sibling(stem, '.tagtime') is not None
+
+def _sniff_tiff(p):
+    try:
+        with open(p, 'rb') as fh:
+            head = fh.read(4)
+    except OSError:
+        return 'unknown'
+    if head not in (b'II*\x00', b'MM\x00*'):
+        return 'unknown'
+    try:
+        import tifffile
+        with tifffile.TiffFile(str(p)) as tif:
+            make = tif.pages.first.tags.valueof(271, '')
+            if make == 'ImSpector':
+                return 'imspector_tiff'
+            names = [s.name for s in tif.series[:3]]
+            if tif.is_ome and names == ['Phasor mean', 'Phasor real', 'Phasor imag']:
+                return 'ometiff_phasor'
+    except Exception:
+        pass
+    return 'unknown'
+
+def _scan_bytes(p, needle, chunk=1 << 20):
+    try:
+        with open(p, 'rb') as fh:
+            tail = b''
+            while True:
+                buf = fh.read(chunk)
+                if not buf:
+                    return False
+                if needle in tail + buf:
+                    return True
+                tail = buf[-len(needle):]
+    except OSError:
+        return False
+
+def _sniff_json(p):
+    try:
+        with open(p, 'rb') as fh:
+            head = fh.read(8192)
+    except OSError:
+        return 'unknown'
+    if b'"file_id"' not in head or b'"laser_period_ns"' not in head:
+        return 'unknown'
+    if _scan_bytes(p, b'"phasors_data"'):
+        return 'flimlabs_phasor'
+    if _scan_bytes(p, b'"intensities_data"') or _scan_bytes(p, b'"data"'):
+        return 'flimlabs_signal'
+    return 'unknown'
+
+def _sniff_magic(p):
+    try:
+        with open(p, 'rb') as fh:
+            head = fh.read(64)
+    except OSError:
+        return 'unknown'
+    if b'PQHISTO' in head:
+        return 'pq_phu'
+    if b'PQTTTR' in head or b'PTU' in head:
+        return 'ptu'
+    if head[:12] == b'VistaFLImage':
+        return 'iss_fdflim'
+    if head[:10] == b'VISTAIMAGE':
+        return 'iss_image'
+    if b'D7 Photons Data' in head:
+        return 'ps'
+    return 'unknown'
+
+def _clean_path(path):
+    s = str(path).strip()
+    if len(s) >= 2 and s[0] == s[-1] and s[0] in ('"', "'"):
+        s = s[1:-1].strip()
+    return s
+
+def _run_sniffers(tier, p):
+    for sniffer in _registry().sniffers(tier):
+        try:
+            found = sniffer(p)
+        except Exception as exc:
+            print(f'[Plugins] sniffer from {sniffer.source} raised {exc}')
+            continue
+        if found and found != 'unknown':
+            return found
+    return None
+
+def detect_format(path):
+    p = Path(_clean_path(path))
+    ext = p.suffix.lower()
+    if ext in ('.tif', '.tiff'):
+        return _sniff_tiff(p)
+    if ext == '.json':
+        return _sniff_json(p)
+    found = _run_sniffers('extension', p)
+    if found is not None:
+        return found
+    ext_to_id = _ext_to_id()
+    if ext in ext_to_id:
+        return ext_to_id[ext]
+    if _has_iss_triplet(p):
+        return 'iss_tdflim'
+    found = _sniff_magic(p)
+    if found != 'unknown':
+        return found
+    found = _run_sniffers('magic', p)
+    if found is not None:
+        return found
+    return 'unknown'
+
+def file_modality(path):
+    return _modality_by_id().get(detect_format(path), 'unknown')
+
+def supported_formats():
+    return [dict(f) for f in _all_formats()]
+
+def supported_extensions():
+    return [ext for f in _all_formats() for ext in f['exts']]
+
+def file_dialog_filetypes():
+    all_globs = ' '.join('*' + ext for ext in supported_extensions())
+    types = [('FLIM files', all_globs)]
+    for f in _all_formats():
+        globs = ' '.join('*' + ext for ext in f['exts'])
+        types.append((f['label'], globs))
+    return types
+
+def _load_reader(fmt):
+    for f in _all_formats():
+        if f['id'] == fmt:
+            spec = f['reader']
+            if isinstance(spec, str):
+                mod_name, cls_name = spec.split(':')
+                return getattr(importlib.import_module(mod_name), cls_name)
+            return spec.reader()
+    return None
+
+class FLIMFile:
+    def __new__(cls, path, **kwargs):
+        path = _clean_path(path)
+        fmt = detect_format(path)
+        reader = _load_reader(fmt)
+        if reader is None:
+            raise ValueError(f'Unrecognised FLIM file format: {path}')
+        return reader(str(path), **kwargs)

flimkit/formats/phasor.py

@@ -0,0 +1,132 @@
+import numpy as np
+from pathlib import Path
+
+def _import_io():
+    try:
+        import phasorpy.io as pio
+    except ImportError:
+        raise ImportError('phasorpy is required to read this format '
+                          '(pip install phasorpy)')
+    return pio
+
+class PhasorReader:
+    modality = 'frequency'
+
+    def __init__(self, path, mean, real, imag, attrs, label='phasor',
+                 verbose=True, channel=None, frequency_mhz=None):
+        self.path = str(path)
+        self.verbose = verbose
+        self.label = label
+        self.channel = channel
+        self._mean = np.asarray(mean)
+        self._real = np.asarray(real)
+        self._imag = np.asarray(imag)
+        attrs = dict(attrs or {})
+        self._dims = tuple(attrs.get('dims') or ())
+        self._harmonics = attrs.get('harmonic')
+        freq = frequency_mhz if frequency_mhz is not None else attrs.get('frequency')
+        self.frequency_mhz = float(freq) if freq else 0.0
+        self.tags = {f'phasorpy_{k}': v for k, v in attrs.items()}
+        dims = self._dims
+        self.n_channels = int(self._mean.shape[dims.index('C')]) if 'C' in dims else 1
+        self.n_y = int(self._mean.shape[dims.index('Y')]) if 'Y' in dims else 0
+        self.n_x = int(self._mean.shape[dims.index('X')]) if 'X' in dims else 0
+        self.is_image = self.n_x > 0 and self.n_y > 0
+        self.n_harmonics = len(self._harmonics) if isinstance(self._harmonics, (list, tuple)) else 1
+        if self.verbose:
+            print(f'  {label} : {Path(self.path).name}')
+            if self.is_image:
+                print(f'  Size     : {self.n_x} x {self.n_y} px, {self.n_channels} ch, '
+                      f'{self.n_harmonics} harmonic(s)  dims={"".join(dims)}')
+            else:
+                print(f'  Point    : no image (no Y/X axes), {self.n_channels} ch, '
+                      f'{self.n_harmonics} harmonic(s)  dims={"".join(dims)}')
+            if self.frequency_mhz:
+                print(f'  Frequency: {self.frequency_mhz:.3f} MHz')
+            else:
+                print('  WARNING  : file carries no frequency; pass frequency_mhz=<MHz> '
+                      'for the universal circle / lifetime overlay')
+            print('  Frequency-domain data: loads into phasor analysis, no lifetime fitting')
+            print(' ')
+
+    def _ch_index(self, channel):
+        if channel is None:
+            return None
+        c = int(channel)
+        idx = c - 1 if c >= 1 else c
+        return idx if 0 <= idx < self.n_channels else 0
+
+    def _auto_channel(self):
+        dims = list(self._dims)
+        if 'C' not in dims:
+            return 0
+        ci = dims.index('C')
+        sums = self._mean.sum(axis=tuple(i for i in range(self._mean.ndim) if i != ci))
+        return int(np.argmax(sums))
+
+    def _reduce(self, arr, dims, ch_idx):
+        dims = list(dims)
+        if arr.ndim != len(dims):
+            dims = dims[-arr.ndim:]
+        if 'C' in dims:
+            ci = dims.index('C')
+            arr = np.take(arr, ch_idx, axis=ci)
+            dims = [d for i, d in enumerate(dims) if i != ci]
+        while len(dims) > 2:
+            extra = next(i for i, d in enumerate(dims) if d not in ('Y', 'X'))
+            arr = np.take(arr, 0, axis=extra)
+            dims = [d for i, d in enumerate(dims) if i != extra]
+        order = [dims.index(d) for d in ('Y', 'X') if d in dims]
+        return np.transpose(arr, order) if len(order) == 2 else arr
+
+    def phasor(self, channel=None, harmonic=0, calibrate=True, **kwargs):
+        ch = self.channel if channel is None else channel
+        ch_idx = self._ch_index(ch)
+        if ch_idx is None:
+            ch_idx = self._auto_channel()
+        real, imag = self._real, self._imag
+        if isinstance(self._harmonics, (list, tuple)):
+            hi = int(harmonic) if 0 <= int(harmonic) < len(self._harmonics) else 0
+            real, imag = real[hi], imag[hi]
+        mean2 = self._reduce(self._mean, self._dims, ch_idx)
+        real2 = self._reduce(real, self._dims, ch_idx)
+        imag2 = self._reduce(imag, self._dims, ch_idx)
+        return (mean2.astype(float), real2.astype(float), imag2.astype(float),
+                self.frequency_mhz)
+
+    def pixel_stack(self, *args, **kwargs):
+        raise ValueError(f'{self.label} is frequency-domain phasor data: there is no '
+                         'time-domain decay to fit. Load it into phasor analysis instead.')
+
+    def summed_decay(self, *args, **kwargs):
+        return self.pixel_stack()
+
+    def raw_pixel_stack(self, *args, **kwargs):
+        return self.pixel_stack()
+
+class _GohlkePhasorFile(PhasorReader):
+    _reader_name = None
+    _label = None
+    _reader_kwargs = {}
+
+    def __init__(self, path, verbose=True, channel=None, **kwargs):
+        pio = _import_io()
+        fn = getattr(pio, self._reader_name, None)
+        if fn is None:
+            raise ImportError(f'{self._reader_name} is not available in this '
+                              f'phasorpy version; upgrade phasorpy')
+        mean, real, imag, attrs = fn(str(path), **self._reader_kwargs)
+        super().__init__(path, mean, real, imag, attrs, label=self._label,
+                         verbose=verbose, channel=channel, **kwargs)
+
+class SimfcsReferencedFile(_GohlkePhasorFile):
+    _reader_name = 'phasor_from_simfcs_referenced'
+    _label = 'SimFCS referenced'
+
+class OmeTiffPhasorFile(_GohlkePhasorFile):
+    _reader_name = 'phasor_from_ometiff'
+    _label = 'PhasorPy OME-TIFF'
+
+class FlimLabsPhasorFile(_GohlkePhasorFile):
+    _reader_name = 'phasor_from_flimlabs_json'
+    _label = 'FLIM LABS phasor'

flimkit/formats/signal.py

@@ -0,0 +1,170 @@
+import numpy as np
+from pathlib import Path
+
+def _import_io():
+    try:
+        import phasorpy.io as pio
+    except ImportError:
+        raise ImportError('phasorpy is required to read this format '
+                          '(pip install phasorpy)')
+    return pio
+
+def _bin_cube(cube, binning):
+    if binning <= 1:
+        return cube
+    ny, nx, nh = cube.shape
+    ny2, nx2 = (ny // binning) * binning, (nx // binning) * binning
+    cube = cube[:ny2, :nx2, :]
+    return cube.reshape(ny2 // binning, binning, nx2 // binning, binning, nh).sum(axis=(1, 3))
+
+class SignalReader:
+    modality = 'time'
+
+    def __init__(self, path, signal, label='signal', verbose=True, channel=None,
+                 bin_width_ns=None, frequency_mhz=None):
+        self.path = str(path)
+        self.verbose = verbose
+        self.label = label
+        self.channel = channel
+        dims = list(signal.dims)
+        vals = np.asarray(signal.values)
+        attrs = dict(getattr(signal, 'attrs', {}) or {})
+        coords = getattr(signal, 'coords', {})
+        self._dims = dims
+        self._vals = vals
+        self.tags = {f'phasorpy_{k}': v for k, v in attrs.items()}
+        c_ax = dims.index('C') if 'C' in dims else None
+        self.n_channels = int(vals.shape[c_ax]) if c_ax is not None else 1
+        self._c_ax = c_ax
+        h_ax = dims.index('H') if 'H' in dims else None
+        if h_ax is None:
+            raise ValueError(f'{label}: no TCSPC histogram (H) axis in {dims}')
+        self.n_bins = int(vals.shape[h_ax])
+        self.n_y = int(vals.shape[dims.index('Y')]) if 'Y' in dims else 0
+        self.n_x = int(vals.shape[dims.index('X')]) if 'X' in dims else 0
+        self.is_image = self.n_x > 0 and self.n_y > 0
+        h_ns = None
+        if 'H' in coords:
+            h_ns = np.asarray(coords['H'].values, dtype=float)
+        elif bin_width_ns is not None:
+            h_ns = np.arange(self.n_bins) * float(bin_width_ns)
+        if h_ns is not None and h_ns.size > 1:
+            self.tcspc_res = float(np.median(np.diff(h_ns))) * 1e-9
+            self.time_ns = h_ns
+        else:
+            self.tcspc_res = float(bin_width_ns) * 1e-9 if bin_width_ns else 0.0
+            self.time_ns = np.arange(self.n_bins) * (self.tcspc_res * 1e9)
+        freq_mhz = frequency_mhz if frequency_mhz is not None else attrs.get('frequency')
+        self.sync_rate = float(freq_mhz) * 1e6 if freq_mhz else 0.0
+        self.period_ns = (1e9 / self.sync_rate) if self.sync_rate else 0.0
+        self.photon_channel = None
+        self._total_photons = None
+        self._cube_cache = {}
+        if self.verbose:
+            print(f'  {label} : {Path(self.path).name}')
+            print(f'  TCSPC    : {self.n_bins} bins x {self.tcspc_res*1e12:.2f} ps')
+            if self.sync_rate:
+                print(f'  Laser    : {self.sync_rate/1e6:.3f} MHz  ({self.period_ns:.3f} ns)')
+            if self.is_image:
+                print(f'  Image    : {self.n_x} x {self.n_y} px, {self.n_channels} channel(s)')
+            else:
+                print(f'  Point    : no image (no Y/X axes), {self.n_channels} channel(s)')
+            if self.tcspc_res <= 0:
+                print(f'  WARNING  : {label} carries no time axis; pass bin_width_ns='
+                      f'<ns> (and frequency_mhz=<MHz>) or fits will be meaningless')
+            print(' ')
+
+    def _ch_index(self, channel):
+        if channel is None:
+            return None
+        c = int(channel)
+        idx = c - 1 if c >= 1 else c
+        return idx if 0 <= idx < self.n_channels else 0
+
+    def _cube_for(self, channel):
+        key = channel
+        if key in self._cube_cache:
+            return self._cube_cache[key]
+        arr = self._vals
+        dims = list(self._dims)
+        if self._c_ax is not None:
+            idx = self._ch_index(channel)
+            if idx is None:
+                sums = arr.sum(axis=tuple(i for i in range(arr.ndim) if i != self._c_ax))
+                idx = int(np.argmax(sums))
+                self.photon_channel = idx + 1
+            arr = np.take(arr, idx, axis=self._c_ax)
+            dims = [d for i, d in enumerate(dims) if i != self._c_ax]
+        drop = tuple(i for i, d in enumerate(dims) if d not in ('Y', 'X', 'H'))
+        if drop:
+            arr = arr.sum(axis=drop)
+            dims = [d for d in dims if d in ('Y', 'X', 'H')]
+        order = [dims.index(d) for d in ('Y', 'X', 'H') if d in dims]
+        cube = np.transpose(arr, order)
+        self._cube_cache[key] = cube
+        return cube
+
+    def summed_decay(self, channel=None):
+        cube = self._cube_for(self.channel if channel is None else channel)
+        decay = cube.reshape(-1, self.n_bins).sum(axis=0).astype(float)
+        self._total_photons = int(decay.sum())
+        return decay
+
+    def raw_pixel_stack(self, channel=None, binning=1):
+        cube = self._cube_for(self.channel if channel is None else channel)
+        if cube.ndim != 3:
+            raise RuntimeError(f'{self.label} has no scan image; use summed_decay')
+        if binning > 1:
+            cube = _bin_cube(cube, binning)
+        self._total_photons = int(cube.sum())
+        return np.ascontiguousarray(cube).astype(np.uint32)
+
+    def pixel_stack(self, channel=None, binning=1):
+        return self.raw_pixel_stack(channel=channel, binning=binning).astype(float)
+
+    def intensity_image(self, channel=None, binning=1):
+        return self.raw_pixel_stack(channel=channel, binning=binning).sum(axis=2)
+
+    @property
+    def photons_per_pulse(self):
+        return None
+
+class _GohlkeSignalFile(SignalReader):
+    _reader_name = None
+    _label = None
+    _reader_kwargs = {}
+
+    def __init__(self, path, verbose=True, channel=None, **kwargs):
+        pio = _import_io()
+        fn = getattr(pio, self._reader_name, None)
+        if fn is None:
+            raise ImportError(f'{self._reader_name} is not available in this '
+                              f'phasorpy version; upgrade phasorpy')
+        signal = fn(str(path), **self._reader_kwargs)
+        super().__init__(path, signal, label=self._label, verbose=verbose,
+                         channel=channel, **kwargs)
+
+class PQBinFile(_GohlkeSignalFile):
+    _reader_name = 'signal_from_pqbin'
+    _label = 'PicoQuant BIN'
+
+class SimfcsBHFile(_GohlkeSignalFile):
+    _reader_name = 'signal_from_bh'
+    _label = 'SimFCS B&H'
+
+class SimfcsBHZFile(_GohlkeSignalFile):
+    _reader_name = 'signal_from_bhz'
+    _label = 'SimFCS BHZ'
+
+class ImspectorTIFFFile(_GohlkeSignalFile):
+    _reader_name = 'signal_from_imspector_tiff'
+    _label = 'ImSpector FLIM TIFF'
+
+class VistaTdflimFile(_GohlkeSignalFile):
+    _reader_name = 'signal_from_tdflim'
+    _label = 'ISS Vista TDFLIM'
+    _reader_kwargs = {'channel': None}
+
+class FlimLabsSignalFile(_GohlkeSignalFile):
+    _reader_name = 'signal_from_flimlabs_json'
+    _label = 'FLIM LABS imaging'