tic = time.time()
with sitr.ScanImageTiffReader(os.path.join(dir_imgs, files_ca[0])) as reader:
I_si = reader.data()
print("SI time = {}".format(time.time() - tic))
#%%
ch_camTrig = 'patch1'
ch_stim = 'patch3'
frameRate = 50
path_bas = os.path.join(os.path.split(dir_imgs)[0], 't01_bas.16ch')
import apCode.ephys as ephys
bas = ephys.importCh(path_bas, nCh=16)
print(bas.keys())
inds_stim = spt.levelCrossings(bas[ch_stim], thr=2)[0]
dInds = np.diff(bas['t'][inds_stim])
inds_del = np.where(dInds < 15)[0] + 1
inds_stim = np.delete(inds_stim, inds_del)
inds_camTrig = spt.levelCrossings(bas[ch_camTrig], thr=2)[0]
dInds = np.diff(bas['t'][inds_camTrig])
inds_del = np.where(dInds <= (0.5 / frameRate))[0] + 1
inds_camTrig = np.delete(inds_camTrig, inds_del)
# plt.plot(bas[ch_camTrig])
# plt.plot(inds_camTrig,bas[ch_camTrig][inds_camTrig],'o')
print('# stims = {}, # of camera triggers = {}'.format(len(inds_stim),
len(inds_camTrig)))
#%%
#%%
maxAllowedTimeBetweenStimAndCamTrig = 0.5 # In sec
def readPeriStimulusTifImages(tifPaths, basPaths, nBasCh = 16, ch_camTrig = 'patch4', ch_stim = 'patch3',\
tifNameStr = '', time_preStim = 1, time_postStim = 10, thr_stim = 1.5,\
thr_camTrig = 1, maxAllowedTimeBetweenStimAndCamTrig = 0.5, n_jobs = 1):
"""
Given the directory to .tif files stored by ScanImage (Bessel beam image settings) and the full
path to the accompanying bas files returns a dictionary with values holding peri-stimulus
image data (Ca activity) in trialized format along with some other pertinent info.
Parameters
----------
tifDir: string
Path to directory holding .tif files written by ScanImage. In the current setting, each .tif
file holds nCh*3000 images, where nCh = number of channels.
basPath: string
Full path to the bas (BehavAndScan) file accompanying the imaging session.
nBasCh: scalar
Number of signal channels in the bas file.
ch_camTrig: string
Name of the channel in bas corresponding to the camera trigger signal
ch_stim: string
Name of the stimulus signal channel in bas.
tifNameStr: string
Only .tif files containing this will be read.
time_preStim: scalar
The length of the pre-stimulus time to include when reading images
time_postStim: scalar
The length of the post-stimulus time.
thr_stim: scalar
Threshold to use for detection of stimuli in the stimulus channel of bas.
thr_camTrig: scalar
Threshold to use for detection of camera trigger onsets in the camera trigger channel of bas.
maxAllowedTimeBetweenStimAndCamTrig: scalar
If a camera trigger is separated in time by the nearest stimulus by longer than this time
interval, then ignore this stimulus trial.
Returns
-------
D: dict
Dictionary contaning the following keys:
'I': array, (nTrials, nTime, nImageChannels, imageWidth, imageHeight)
Image hyperstack arranged in conveniently-accessible trialized format.
'tifInfo': dict
Dictionary holding useful image metadata. Has following keys:
'filePaths': list of strings
Paths to .tif files
'nImagesInfile': scalar int
Number of images in each .tif file after accounting of number of
image channels
'nChannelsInFile': scalar int
Number of image channels
'inds_stim': array of integers, (nStim,)
Indices in bas coordinates where stimuli occurred.
'inds_stim_img': array of integers, (nStim,)
Indices in image coordinates where stimuli occurred
'inds_camTrig': array of integers, (nCameraTriggers,)
Indices in bas coordinates corresponding to the onsets of camera triggers.
'bas': dict
BehavAndScan data
"""
import tifffile as tff
import numpy as np
import apCode.FileTools as ft
import apCode.ephys as ephys
import apCode.SignalProcessingTools as spt
import apCode.util as util
# import os
def getImgIndsInTifs(tifInfo):
nImgsInFile_cum = np.cumsum(tifInfo['nImagesInFile'] *
tifInfo['nChannelsInFile'])
imgIndsInTifs = []
for i in range(len(nImgsInFile_cum)):
if i == 0:
inds_ = np.arange(0, nImgsInFile_cum[i])
else:
inds_ = np.arange(nImgsInFile_cum[i - 1], nImgsInFile_cum[i])
imgIndsInTifs.append(inds_)
return imgIndsInTifs
### Read relevant metadata from tif files in directory
print('Reading ScanImage metadata from tif files...')
tifInfo = ft.scanImageTifInfo(tifPaths)
nCaImgs = np.sum(tifInfo['nImagesInFile'])
### Check for consistency in the number of image channels in all files.
if len(np.unique(tifInfo['nChannelsInFile'])) > 1:
print('Different number of image channels across files, check files!')
return None
nImgCh = tifInfo['nChannelsInFile'][0]
print(f'{nCaImgs} {nImgCh}-channel images from all tif files')
### Get a list of indices corresponding to images in each of the tif files
inds_imgsInTifs = getImgIndsInTifs(tifInfo)
### Read bas file to get stimulus and camera trigger indices required to align images and behavior
print(
'Reading and joining bas files, detecting stimuli and camera triggers...'
)
basList = [ephys.importCh(bp, nCh=nBasCh) for bp in basPaths]
bas = concatenateBas(basList)
inds_stim = spt.levelCrossings(bas[ch_stim], thr=thr_stim)[0]
if len(inds_stim) == 0:
print(
f'Only {len(inds_stim)} stims detected, check channel specification or threshold'
)
return dict(bas=bas)
inds_camTrig = spt.levelCrossings(bas[ch_camTrig], thr=thr_camTrig)[0]
if len(inds_camTrig) == 0:
print(
f'Only {len(inds_camTrig)} cam trigs detected, check channel specification or threshold'
)
return dict(bas=bas)
dt_vec = np.diff(bas['t'][inds_camTrig])
dt_ca = np.round(np.mean(dt_vec) * 100) / 100
print('Ca sampling rate = {}'.format(1 / dt_ca))
inds_del = np.where(dt_vec <= (0.5 * dt_ca))[0] + 1
inds_camTrig = np.delete(inds_camTrig, inds_del)
### Deal with possible mismatch in number of camera trigger indices and number of images in tif files
if nCaImgs < len(inds_camTrig):
inds_camTrig = inds_camTrig[:nCaImgs]
nCaImgs_extra = 0
elif nCaImgs > len(inds_camTrig):
nCaImgs_extra = nCaImgs - len(inds_camTrig)
else:
nCaImgs_extra = 0
print('{} extra Ca2+ images'.format(nCaImgs_extra))
print('{} stimuli and {} camera triggers'.format(len(inds_stim),
len(inds_camTrig)))
### Indices of ca images closest to stimulus
inds_stim_img = spt.nearestMatchingInds(inds_stim, inds_camTrig)
### Find trials where the nearest cam trigger is farther than the stimulus by a certain amount
inds_camTrigNearStim = inds_camTrig[inds_stim_img]
t_stim = bas['t'][inds_stim]
t_camTrigNearStim = bas['t'][inds_camTrigNearStim]
inds_tooFar = np.where(
np.abs(t_stim -
t_camTrigNearStim) > maxAllowedTimeBetweenStimAndCamTrig)[0]
inds_ca_all = np.arange(nCaImgs)
nPreStim = int(time_preStim / dt_ca)
nPostStim = int(time_postStim / dt_ca)
print("{} pre-stim points, and {} post-stim points".format(
nPreStim, nPostStim))
inds_ca_trl = np.array(
spt.segmentByEvents(inds_ca_all, inds_stim_img + nCaImgs_extra,
nPreStim, nPostStim))
### Find trials that are too short to include the pre- or post-stimulus period
trlLens = np.array([len(trl_) for trl_ in inds_ca_trl])
inds_tooShort = np.where(trlLens < np.max(trlLens))[0]
inds_trl_del = np.union1d(inds_tooFar, inds_tooShort)
inds_trl_keep = np.setdiff1d(np.arange(len(inds_ca_trl)), inds_trl_del)
### Exclude the above 2 types of trials from consideration
if len(inds_trl_del) > 0:
print('Excluding the trials {}'.format(inds_trl_del))
inds_ca_trl = inds_ca_trl[inds_trl_keep]
I = []
print('Reading trial-related images from tif files...')
nTrls = len(inds_ca_trl)
def trlImages(inds_ca_trl, inds_imgsInTifs, nImgCh, tifInfo, trl):
trl_ = np.arange(trl.min() * nImgCh, (trl.max() + 1) * nImgCh)
loc = util.locateItemsInSetsOfItems(trl_, inds_imgsInTifs)
I_ = []
for subInds, supInd in zip(loc['subInds'], loc['supInds']):
with tff.TiffFile(tifInfo['filePaths'][supInd]) as tif:
img = tif.asarray(key=subInds)
I_.extend(img.reshape(-1, nImgCh, *img.shape[1:]))
I_ = np.array(I_)
return I_
if n_jobs < 2:
chunkSize = int(nTrls / 5)
for iTrl, trl in enumerate(inds_ca_trl):
if np.mod(iTrl, chunkSize) == 0:
print('Trl # {}/{}'.format(iTrl + 1, nTrls))
I_ = trlImages(inds_ca_trl, inds_imgsInTifs, nImgCh, tifInfo, trl)
I.append(I_)
else:
print('Processing with dask')
import dask
from dask.diagnostics import ProgressBar
for trl in inds_ca_trl:
I_ = dask.delayed(trlImages)(inds_ca_trl, inds_imgsInTifs, nImgCh,
tifInfo, trl)
I.append(I_)
with ProgressBar():
I = dask.compute(*I)
D = dict(I = np.squeeze(np.array(I)), tifInfo = tifInfo, inds_stim = inds_stim, inds_stim_img = inds_stim_img,\
inds_camTrig = inds_camTrig,bas = bas, inds_trl_excluded = inds_trl_del)
return D
