def setUpContainer(self):
self.plane_segmentation = TestPlaneSegmentation.buildPlaneSegmentation(self)
self.rt_region = self.plane_segmentation.create_roi_table_region('the first of two ROIs', region=[0])
data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
timestamps = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
return RoiResponseSeries('test_roi_response_series', data, 'lumens', self.rt_region, timestamps=timestamps)
def test_init(self):
ip = CreatePlaneSegmentation()
rt_region = ip.create_roi_table_region('the second ROI', region=[0])
ts = RoiResponseSeries('test_ts', list(), rt_region, unit='unit', timestamps=list())
self.assertEqual(ts.name, 'test_ts')
self.assertEqual(ts.unit, 'unit')
self.assertEqual(ts.rois, rt_region)
def test_init(self):
ip = CreatePlaneSegmentation()
rt_region = ip.create_roi_table_region('the second ROI', region=[1])
rrs = RoiResponseSeries('test_ts', list(), rt_region, unit='unit', timestamps=list())
dof = DfOverF(rrs)
self.assertEqual(dof.roi_response_series['test_ts'], rrs)
def test_init(self):
ip = CreatePlaneSegmentation()
rt_region = ip.create_roi_table_region('the second ROI', region=[1])
ts = RoiResponseSeries('test_ts', list(), rt_region, unit='unit', timestamps=list())
ff = Fluorescence(ts)
self.assertEqual(ff.roi_response_series['test_ts'], ts)
self.assertEqual(ff.roi_response_series['test_ts'], ts)
def test_init(self):
ps = create_plane_segmentation()
rt_region = ps.create_roi_table_region(description='the second ROI',
region=[1])
rrs = RoiResponseSeries(name='test_ts',
data=list(),
rois=rt_region,
unit='unit',
timestamps=list())
dof = DfOverF(rrs)
self.assertEqual(dof.roi_response_series['test_ts'], rrs)
def test_init(self):
ps = create_plane_segmentation()
rt_region = ps.create_roi_table_region(description='the second ROI',
region=[0])
ts = RoiResponseSeries(name='test_ts',
data=[1, 2, 3],
rois=rt_region,
unit='unit',
timestamps=[0.1, 0.2, 0.3])
self.assertEqual(ts.name, 'test_ts')
self.assertEqual(ts.unit, 'unit')
self.assertEqual(ts.rois, rt_region)
def test_init(self):
ps = create_plane_segmentation()
rt_region = ps.create_roi_table_region(description='the second ROI',
region=[1])
ts = RoiResponseSeries(name='test_ts',
data=[1, 2, 3],
rois=rt_region,
unit='unit',
timestamps=[0.1, 0.2, 0.3])
ff = Fluorescence(ts)
self.assertEqual(ff.roi_response_series['test_ts'], ts)
def setUpContainer(self):
self.plane_segmentation = TestPlaneSegmentation.buildPlaneSegmentation(
self)
self.rt_region = self.plane_segmentation.create_roi_table_region(
'the first of two ROIs', region=[0])
data = [0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]
timestamps = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
return RoiResponseSeries('test_roi_response_series',
data,
self.rt_region,
unit='lumens',
timestamps=timestamps)
def test_init(self):
ip = CreatePlaneSegmentation()
iS = ImageSegmentation('test source', ip, name='test_iS')
rrs = RoiResponseSeries('test_ts',
'a hypothetical source',
list(),
'unit', ['name1'],
iS,
timestamps=list())
dof = DfOverF('test_dof', rrs)
self.assertEqual(dof.source, 'test_dof')
self.assertEqual(dof.roi_response_series, rrs)
def test_init(self):
ip = CreatePlaneSegmentation()
iS = ImageSegmentation('test source', ip, name='test_iS')
ts = RoiResponseSeries('test_ts',
'a hypothetical source',
list(),
'unit', ['name1'],
iS,
timestamps=list())
ff = Fluorescence('test_ff', ts)
self.assertEqual(ff.source, 'test_ff')
self.assertEqual(ff.roi_response_series, ts)
def cicada_add_roi_response_series(self,
module,
traces_data=None,
rois=None):
""" class pynwb.ophys.RoiResponseSeries(name, data, unit, rois,
resolution=0.0, conversion=1.0, timestamps=None, starting_time=None, rate=None, comments='no comments',
description='no description', control=None, control_description=None, parent=None)
"""
required_metadata = [
"roi_response_series_name", "roi_response_series_unit"
]
metadata_to_add = list(
set(required_metadata) -
set(list(self.data['ophys_metadata'].keys())))
for i in metadata_to_add:
self.data["ophys_metadata"] = self.add_required_metadata(
self.data["ophys_metadata"], i, "ophys")
# Nom du module où récupérer les infos de métadonnée
name_module = "roi_response_series_"
roi_response_series = RoiResponseSeries(
name=self.data['ophys_metadata'].get(name_module + "name"),
data=traces_data,
unit=self.data['ophys_metadata'].get(name_module + "unit"),
rois=self.table_region,
resolution=0.0,
conversion=1.0,
timestamps=self.data['ophys_metadata'].get(name_module +
"timestamp"),
starting_time=self.data['ophys_metadata'].get(name_module +
"starting_time"),
rate=1.0,
comments="no comments",
description="no description",
control=self.data['ophys_metadata'].get(name_module + "control"),
control_description=self.data['ophys_metadata'].get(
name_module + "control_description"),
parent=self.data['ophys_metadata'].get(name_module + "parent"))
if module == "DfOverF":
self.DfOverF.add_roi_response_series(roi_response_series)
elif module == "fluorescence":
self.fluorescence.add_roi_response_series(roi_response_series)
else:
print(
f"erreur : le nom du module doit être 'DfOverF' ou 'fluorescence', et non {module} !"
)
def test_init(self):
ip = CreatePlaneSegmentation()
rt_region = ip.create_roi_table_region([1], 'the second ROI')
rrs = RoiResponseSeries('test_ts',
'a hypothetical source',
list(),
'unit',
rt_region,
timestamps=list())
dof = DfOverF('test_dof', rrs)
self.assertEqual(dof.source, 'test_dof')
self.assertEqual(dof.roi_response_series['test_ts'], rrs)
def test_init(self):
ip = CreatePlaneSegmentation()
iS = ImageSegmentation('test source', ip, name='test_iS')
ts = RoiResponseSeries('test_ts',
'a hypothetical source',
list(),
'unit', ['name1'],
iS,
timestamps=list())
self.assertEqual(ts.name, 'test_ts')
self.assertEqual(ts.source, 'a hypothetical source')
self.assertEqual(ts.unit, 'unit')
self.assertEqual(ts.roi_names, ['name1'])
self.assertEqual(ts.segmentation_interface, iS)
def test_init(self):
ip = CreatePlaneSegmentation()
rt_region = ip.create_roi_table_region([1], 'the second ROI')
ts = RoiResponseSeries('test_ts',
'a hypothetical source',
list(),
'unit',
rt_region,
timestamps=list())
self.assertEqual(ts.name, 'test_ts')
self.assertEqual(ts.source, 'a hypothetical source')
self.assertEqual(ts.unit, 'unit')
self.assertEqual(ts.rois, rt_region)
def test_init(self):
ip = CreatePlaneSegmentation()
rt_region = ip.create_roi_table_region([1], 'the second ROI')
ts = RoiResponseSeries('test_ts',
'a hypothetical source',
list(),
'unit',
rt_region,
timestamps=list())
ff = Fluorescence('test_ff', ts)
self.assertEqual(ff.source, 'test_ff')
self.assertEqual(ff.roi_response_series['test_ts'], ts)
self.assertEqual(ff.roi_response_series['test_ts'], ts)
def add_ophys_processing_from_suite2p(save_folder, nwbfile, xml,
device=None,
optical_channel=None,
imaging_plane=None,
image_series=None):
"""
adapted from suite2p/suite2p/io/nwb.py "save_nwb" function
"""
plane_folders = natsorted([ f.path for f in os.scandir(save_folder) if f.is_dir() and f.name[:5]=='plane'])
OPS = [np.load(os.path.join(f, 'ops.npy'), allow_pickle=True).item() for f in plane_folders]
if len(OPS)>1:
multiplane, nplanes = True, len(plane_folders)
pData_folder = os.path.join(save_folder, 'combined') # processed data folder -> using the "combined output from suite2p"
else:
multiplane, nplanes = False, 1
pData_folder = os.path.join(save_folder, 'plane0') # processed data folder
# find time sampling per plane
functional_chan = ('Ch1' if len(xml['Ch1']['relativeTime'])>1 else 'Ch2') # functional channel is one of the two !!
CaImaging_timestamps = xml[functional_chan]['relativeTime']+float(xml['settings']['framePeriod'])/2.
ops = np.load(os.path.join(pData_folder, 'ops.npy'), allow_pickle=True).item()
if device is None:
device = nwbfile.create_device(
name='Microscope',
description='My two-photon microscope',
manufacturer='The best microscope manufacturer')
if optical_channel is None:
optical_channel = OpticalChannel(
name='OpticalChannel',
description='an optical channel',
emission_lambda=500.)
if imaging_plane is None:
imaging_plane = nwbfile.create_imaging_plane(
name='ImagingPlane',
optical_channel=optical_channel,
imaging_rate=ops['fs'],
description='standard',
device=device,
excitation_lambda=600.,
indicator='GCaMP',
location='V1',
grid_spacing=([2,2,30] if multiplane else [2,2]),
grid_spacing_unit='microns')
if image_series is None:
# link to external data
image_series = TwoPhotonSeries(
name='TwoPhotonSeries',
dimension=[ops['Ly'], ops['Lx']],
external_file=(ops['filelist'] if 'filelist' in ops else ['']),
imaging_plane=imaging_plane,
starting_frame=[0],
format='external',
starting_time=0.0,
rate=ops['fs'] * ops['nplanes']
)
nwbfile.add_acquisition(image_series) # otherwise, were added
# processing
img_seg = ImageSegmentation()
ps = img_seg.create_plane_segmentation(
name='PlaneSegmentation',
description='suite2p output',
imaging_plane=imaging_plane,
reference_images=image_series
)
ophys_module = nwbfile.create_processing_module(
name='ophys',
description='optical physiology processed data\n TSeries-folder=%s' % save_folder)
ophys_module.add(img_seg)
file_strs = ['F.npy', 'Fneu.npy', 'spks.npy']
traces = []
iscell = np.load(os.path.join(pData_folder, 'iscell.npy')).astype(bool)
if ops['nchannels']>1:
if os.path.isfile(os.path.join(pData_folder, 'redcell_manual.npy')):
redcell = np.load(os.path.join(pData_folder, 'redcell_manual.npy'))[iscell[:,0], :]
else:
print('\n'+30*'--')
print(' /!\ no file found for the manual labelling of red cells (generate it with the red-cell labelling GUI) /!\ ')
print(' /!\ taking the raw suit2p output with the classifier settings /!\ ')
print('\n'+30*'--')
redcell = np.load(os.path.join(pData_folder, 'redcell.npy'))[iscell[:,0], :]
for fstr in file_strs:
traces.append(np.load(os.path.join(pData_folder, fstr))[iscell[:,0], :])
stat = np.load(os.path.join(pData_folder, 'stat.npy'), allow_pickle=True)
ncells = np.sum(iscell[:,0])
plane_ID = np.zeros(ncells)
for n in np.arange(ncells):
pixel_mask = np.array([stat[iscell[:,0]][n]['ypix'], stat[iscell[:,0]][n]['xpix'],
stat[iscell[:,0]][n]['lam']])
ps.add_roi(pixel_mask=pixel_mask.T)
if 'iplane' in stat[0]:
plane_ID[n] = stat[iscell[:,0]][n]['iplane']
if ops['nchannels']>1:
ps.add_column('redcell', 'two columns - redcell & probcell', redcell)
ps.add_column('plane', 'one column - plane ID', plane_ID)
rt_region = ps.create_roi_table_region(
region=list(np.arange(0, ncells)),
description='all ROIs')
# FLUORESCENCE (all are required)
file_strs = ['F.npy', 'Fneu.npy', 'spks.npy']
name_strs = ['Fluorescence', 'Neuropil', 'Deconvolved']
for i, (fstr,nstr) in enumerate(zip(file_strs, name_strs)):
roi_resp_series = RoiResponseSeries(
name=nstr,
data=traces[i],
rois=rt_region,
unit='lumens',
timestamps=CaImaging_timestamps[::nplanes]) # ideally should be shifted for each ROI depending on the plane...
fl = Fluorescence(roi_response_series=roi_resp_series, name=nstr)
ophys_module.add(fl)
# BACKGROUNDS
# (meanImg, Vcorr and max_proj are REQUIRED)
bg_strs = ['meanImg', 'meanImgE', 'Vcorr', 'max_proj', 'meanImg_chan2']
nplanes = ops['nplanes']
for iplane in range(nplanes):
images = Images('Backgrounds_%d'%iplane)
for bstr in bg_strs:
if bstr in ops:
if bstr=='Vcorr' or bstr=='max_proj':
img = np.zeros((ops['Ly'], ops['Lx']), np.float32)
img[ops['yrange'][0]:ops['yrange'][-1],
ops['xrange'][0]:ops['xrange'][-1]] = ops[bstr]
else:
img = ops[bstr]
images.add_image(GrayscaleImage(name=bstr, data=img))
ophys_module.add(images)
def test_roundtrip(self):
multi_commanded_voltage = MultiCommandedVoltage()
commandedvoltage_series = (
multi_commanded_voltage.create_commanded_voltage_series(
name="commanded_voltage",
data=[1.0, 2.0, 3.0],
frequency=30.0,
power=500.0,
rate=30.0,
unit='volts'))
cmmandedvoltage_series2 = (
multi_commanded_voltage.create_commanded_voltage_series(
name="commanded_voltage2",
data=[1.0, 2.0, 3.0],
frequency=30.0,
power=500.0,
rate=30.0,
))
excitationsources_table = ExcitationSourcesTable(
description="excitation sources table")
excitationsources_table.add_row(
peak_wavelength=700.0,
source_type="laser",
commanded_voltage=commandedvoltage_series,
)
photodetectors_table = PhotodetectorsTable(
description="photodetectors table")
photodetectors_table.add_row(peak_wavelength=500.0,
type="PMT",
gain=100.0)
fluorophores_table = FluorophoresTable(description='fluorophores')
fluorophores_table.add_row(label='dlight',
location='VTA',
coordinates=(3.0, 2.0, 1.0))
fibers_table = FibersTable(description="fibers table")
fibers_ref = DynamicTableRegion(name="rois",
data=[0],
description="source fibers",
table=fibers_table)
roi_response_series = RoiResponseSeries(
name="roi_response_series",
description="my roi response series",
data=np.random.randn(100, 1),
unit='F',
rate=30.0,
rois=fibers_ref,
)
deconv_roi_response_series = DeconvolvedRoiResponseSeries(
name="DeconvolvedRoiResponseSeries",
description="my roi response series",
data=np.random.randn(100, 1),
unit='F',
rate=30.0,
rois=fibers_ref,
raw=roi_response_series,
)
ophys_module = self.nwbfile.create_processing_module(
name="ophys", description="fiber photometry")
self.nwbfile.add_lab_meta_data(
FiberPhotometry(fibers=fibers_table,
excitation_sources=excitationsources_table,
photodetectors=photodetectors_table,
fluorophores=fluorophores_table,
commanded_voltages=multi_commanded_voltage))
fibers_table.add_fiber(excitation_source=0,
photodetector=0,
fluorophores=[0],
location='my location',
notes='notes')
self.nwbfile.add_acquisition(roi_response_series)
ophys_module.add(deconv_roi_response_series)
with NWBHDF5IO(self.path, mode="w") as io:
io.write(self.nwbfile)
with NWBHDF5IO(self.path, mode="r", load_namespaces=True) as io:
read_nwbfile = io.read()
self.assertContainerEqual(ophys_module,
read_nwbfile.processing["ophys"])
self.assertContainerEqual(
self.nwbfile.lab_meta_data['fiber_photometry'],
read_nwbfile.lab_meta_data['fiber_photometry'])
self.assertContainerEqual(
roi_response_series,
read_nwbfile.acquisition["roi_response_series"])
def add_ophys_processing_from_suite2p(save_folder,
nwbfile,
CaImaging_timestamps,
device=None,
optical_channel=None,
imaging_plane=None,
image_series=None):
"""
adapted from suite2p/suite2p/io/nwb.py "save_nwb" function
"""
plane_folders = natsorted([
f.path for f in os.scandir(save_folder)
if f.is_dir() and f.name[:5] == 'plane'
])
ops1 = [
np.load(os.path.join(f, 'ops.npy'), allow_pickle=True).item()
for f in plane_folders
]
if len(ops1) > 1:
multiplane = True
else:
multiplane = False
ops = ops1[0]
if device is None:
device = nwbfile.create_device(
name='Microscope',
description='My two-photon microscope',
manufacturer='The best microscope manufacturer')
if optical_channel is None:
optical_channel = OpticalChannel(name='OpticalChannel',
description='an optical channel',
emission_lambda=500.)
if imaging_plane is None:
imaging_plane = nwbfile.create_imaging_plane(
name='ImagingPlane',
optical_channel=optical_channel,
imaging_rate=ops['fs'],
description='standard',
device=device,
excitation_lambda=600.,
indicator='GCaMP',
location='V1',
grid_spacing=([2, 2, 30] if multiplane else [2, 2]),
grid_spacing_unit='microns')
if image_series is None:
# link to external data
image_series = TwoPhotonSeries(
name='TwoPhotonSeries',
dimension=[ops['Ly'], ops['Lx']],
external_file=(ops['filelist'] if 'filelist' in ops else ['']),
imaging_plane=imaging_plane,
starting_frame=[0],
format='external',
starting_time=0.0,
rate=ops['fs'] * ops['nplanes'])
nwbfile.add_acquisition(image_series) # otherwise, were added
# processing
img_seg = ImageSegmentation()
ps = img_seg.create_plane_segmentation(name='PlaneSegmentation',
description='suite2p output',
imaging_plane=imaging_plane,
reference_images=image_series)
ophys_module = nwbfile.create_processing_module(
name='ophys', description='optical physiology processed data')
ophys_module.add(img_seg)
file_strs = ['F.npy', 'Fneu.npy', 'spks.npy']
traces = []
ncells_all = 0
for iplane, ops in enumerate(ops1):
if iplane == 0:
iscell = np.load(
os.path.join(save_folder, 'plane%i' % iplane, 'iscell.npy'))
for fstr in file_strs:
traces.append(
np.load(os.path.join(save_folder, 'plane%i' % iplane,
fstr)))
else:
iscell = np.append(iscell,
np.load(
os.path.join(save_folder,
'plane%i' % iplane,
'iscell.npy')),
axis=0)
for i, fstr in enumerate(file_strs):
traces[i] = np.append(
traces[i],
np.load(os.path.join(save_folder, 'plane%i' % iplane,
fstr)),
axis=0)
stat = np.load(os.path.join(save_folder, 'plane%i' % iplane,
'stat.npy'),
allow_pickle=True)
ncells = len(stat)
for n in range(ncells):
if multiplane:
pixel_mask = np.array([
stat[n]['ypix'], stat[n]['xpix'],
iplane * np.ones(stat[n]['npix']), stat[n]['lam']
])
ps.add_roi(voxel_mask=pixel_mask.T)
else:
pixel_mask = np.array(
[stat[n]['ypix'], stat[n]['xpix'], stat[n]['lam']])
ps.add_roi(pixel_mask=pixel_mask.T)
ncells_all += ncells
ps.add_column('iscell', 'two columns - iscell & probcell', iscell)
rt_region = ps.create_roi_table_region(region=list(np.arange(
0, ncells_all)),
description='all ROIs')
# FLUORESCENCE (all are required)
file_strs = ['F.npy', 'Fneu.npy', 'spks.npy']
name_strs = ['Fluorescence', 'Neuropil', 'Deconvolved']
for i, (fstr, nstr) in enumerate(zip(file_strs, name_strs)):
roi_resp_series = RoiResponseSeries(
name=nstr,
data=traces[i],
rois=rt_region,
unit='lumens',
timestamps=CaImaging_timestamps
) # CRITICAL TO HAVE IT HERE FOR RE-ALIGNEMENT
fl = Fluorescence(roi_response_series=roi_resp_series, name=nstr)
ophys_module.add(fl)
# BACKGROUNDS
# (meanImg, Vcorr and max_proj are REQUIRED)
bg_strs = ['meanImg', 'meanImgE', 'Vcorr', 'max_proj', 'meanImg_chan2']
nplanes = ops['nplanes']
for iplane in range(nplanes):
images = Images('Backgrounds_%d' % iplane)
for bstr in bg_strs:
if bstr in ops:
if bstr == 'Vcorr' or bstr == 'max_proj':
img = np.zeros((ops['Ly'], ops['Lx']), np.float32)
img[ops['yrange'][0]:ops['yrange'][-1],
ops['xrange'][0]:ops['xrange'][-1]] = ops[bstr]
else:
img = ops[bstr]
images.add_image(GrayscaleImage(name=bstr, data=img))
ophys_module.add(images)
mod = nwbfile.create_processing_module('rois', 'example data module')
img_seg = ImageSegmentation()
ps = img_seg.create_plane_segmentation('Ca2+ imaging example', imaging_plane,
'my_planeseg', image_series)
mod.add_data_interface(img_seg)
for i, img_mask in enumerate(zip(mat_data['cellImages'])):
pixel_mask = np.array(np.where(img_mask)).T
ps.add_roi(str(i), pixel_mask, img_mask)
region = ps.create_roi_table_region('all',
region=list(
range(len(mat_data['cellImages']))))
roi_response = RoiResponseSeries('RoiResponseSeries',
mat_data['cellTraces'],
'lumens?',
region,
rate=5.0,
starting_time=0.0)
fl = Fluorescence(roi_response_series=roi_response)
mod.add_data_interface(fl)
fname_out = 'm655_D11_S1.nwb'
with NWBHDF5IO(fname_out, 'w') as io:
io.write(nwbfile)
with NWBHDF5IO(fname_out, 'r') as io:
io.read()
notes='notes'
)
# Here we set up a list of fibers that our recording came from
fibers_ref = DynamicTableRegion(
name="rois",
data=[0], # potentially multiple fibers
description="source fibers",
table=fibers_table
)
# Create a raw roiresponseseries, this is your main acquisition
roi_response_series = RoiResponseSeries(
name="raw_fluorescence_trace",
description="my roi response series",
data=np.random.randn(100, 1),
unit='F',
rate=30.0,
rois=fibers_ref,
)
# This is your processed data
deconv_roi_response_series = DeconvolvedRoiResponseSeries(
name="deconvolved_fluorescence_trace",
description="my roi response series",
data=np.random.randn(100, 1),
unit='F',
rate=30.0,
rois=fibers_ref,
raw=roi_response_series,
)
# such as a :py:class:`~pynwb.ophys.PlaneSegmentation` table by row indices.
#
#
# First, we create a :py:class:`~pynwb.core.DynamicTableRegion` that references
# the first two ROIs of the :py:class:`~pynwb.ophys.PlaneSegmentation` table.
rt_region = ps.create_roi_table_region(region=[0, 1],
description='the first of two ROIs')
####################
# Then we create a :py:class:`~pynwb.ophys.RoiResponseSeries` object to store fluorescence
# data for those two ROIs.
roi_resp_series = RoiResponseSeries(
name='RoiResponseSeries',
data=np.ones((50, 2)), # 50 samples, 2 ROIs
rois=rt_region,
unit='lumens',
rate=30.)
####################
# To help data analysis and visualization tools know that this
# :py:class:`~pynwb.ophys.RoiResponseSeries` object represents fluorescence data,
# we will store the :py:class:`~pynwb.ophys.RoiResponseSeries` object inside
# of a :py:class:`~pynwb.ophys.Fluorescence` object.
# Then add the :py:class:`~pynwb.ophys.Fluorescence` object into the
# same :py:class:`~pynwb.base.ProcessingModule` named ``"ophys"`` that we created earlier.
#
# .. only:: html
#
# .. image:: ../../_static/Fluorescence.svg
# :width: 600
def save_nwb(ops1):
if NWB and not ops1[0]['mesoscan']:
if len(ops1) > 1:
multiplane = True
else:
multiplane = False
ops = ops1[0]
### INITIALIZE NWB FILE
nwbfile = NWBFile(
session_description='suite2p_proc',
identifier=ops['data_path'][0],
session_start_time=(ops['date_proc'] if 'date_proc' in ops else
datetime.datetime.now()))
print(nwbfile)
device = nwbfile.create_device(
name='Microscope',
description='My two-photon microscope',
manufacturer='The best microscope manufacturer')
optical_channel = OpticalChannel(name='OpticalChannel',
description='an optical channel',
emission_lambda=500.)
imaging_plane = nwbfile.create_imaging_plane(
name='ImagingPlane',
optical_channel=optical_channel,
imaging_rate=ops['fs'],
description='standard',
device=device,
excitation_lambda=600.,
indicator='GCaMP',
location='V1',
grid_spacing=([2, 2, 30] if multiplane else [2, 2]),
grid_spacing_unit='microns')
# link to external data
image_series = TwoPhotonSeries(
name='TwoPhotonSeries',
dimension=[ops['Ly'], ops['Lx']],
external_file=(ops['filelist'] if 'filelist' in ops else ['']),
imaging_plane=imaging_plane,
starting_frame=[0],
format='external',
starting_time=0.0,
rate=ops['fs'] * ops['nplanes'])
nwbfile.add_acquisition(image_series)
# processing
img_seg = ImageSegmentation()
ps = img_seg.create_plane_segmentation(name='PlaneSegmentation',
description='suite2p output',
imaging_plane=imaging_plane,
reference_images=image_series)
ophys_module = nwbfile.create_processing_module(
name='ophys', description='optical physiology processed data')
ophys_module.add(img_seg)
file_strs = ['F.npy', 'Fneu.npy', 'spks.npy']
traces = []
ncells_all = 0
for iplane, ops in enumerate(ops1):
if iplane == 0:
iscell = np.load(os.path.join(ops['save_path'], 'iscell.npy'))
for fstr in file_strs:
traces.append(np.load(os.path.join(ops['save_path'],
fstr)))
else:
iscell = np.append(iscell,
np.load(
os.path.join(ops['save_path'],
'iscell.npy')),
axis=0)
for i, fstr in enumerate(file_strs):
traces[i] = np.append(
traces[i],
np.load(os.path.join(ops['save_path'], fstr)),
axis=0)
stat = np.load(os.path.join(ops['save_path'], 'stat.npy'),
allow_pickle=True)
ncells = len(stat)
for n in range(ncells):
if multiplane:
pixel_mask = np.array([
stat[n]['ypix'], stat[n]['xpix'],
iplane * np.ones(stat[n]['npix']), stat[n]['lam']
])
ps.add_roi(voxel_mask=pixel_mask.T)
else:
pixel_mask = np.array(
[stat[n]['ypix'], stat[n]['xpix'], stat[n]['lam']])
ps.add_roi(pixel_mask=pixel_mask.T)
ncells_all += ncells
ps.add_column('iscell', 'two columns - iscell & probcell', iscell)
rt_region = ps.create_roi_table_region(region=list(
np.arange(0, ncells_all)),
description='all ROIs')
# FLUORESCENCE (all are required)
file_strs = ['F.npy', 'Fneu.npy', 'spks.npy']
name_strs = ['Fluorescence', 'Neuropil', 'Deconvolved']
for i, (fstr, nstr) in enumerate(zip(file_strs, name_strs)):
roi_resp_series = RoiResponseSeries(name=nstr,
data=traces[i],
rois=rt_region,
unit='lumens',
rate=ops['fs'])
fl = Fluorescence(roi_response_series=roi_resp_series, name=nstr)
ophys_module.add(fl)
# BACKGROUNDS
# (meanImg, Vcorr and max_proj are REQUIRED)
bg_strs = ['meanImg', 'Vcorr', 'max_proj', 'meanImg_chan2']
nplanes = ops['nplanes']
for iplane in range(nplanes):
images = Images('Backgrounds_%d' % iplane)
for bstr in bg_strs:
if bstr in ops:
if bstr == 'Vcorr' or bstr == 'max_proj':
img = np.zeros((ops['Ly'], ops['Lx']), np.float32)
img[ops['yrange'][0]:ops['yrange'][-1],
ops['xrange'][0]:ops['xrange'][-1]] = ops[bstr]
else:
img = ops[bstr]
images.add_image(GrayscaleImage(name=bstr, data=img))
ophys_module.add(images)
with NWBHDF5IO(os.path.join(ops['save_path0'], 'suite2p', 'ophys.nwb'),
'w') as fio:
fio.write(nwbfile)
else:
print('pip install pynwb OR don"t use mesoscope recording')
rt_region = ps.create_roi_table_region(region=list(range(len(rois))),
description='rois')
## Store the data of each the ROIs in their RoiResponseSeries
## first get the roi data signal
rois_data = rois_signal(data=data, rois_masks=rois)
rois_data_mean = [rois_data[i].mean(axis=1) for i in range(len(rois_data))]
[rois_data_mean[i].shape for i in range(len(rois_data_mean))]
rois_data_mean = np.stack(rois_data_mean)
## Then create RoiResponseSeries to hold the data of those ROIs
roi_resp_series = RoiResponseSeries(name='RoiResponseSeries',
data=rois_data_mean,
rois=rt_region,
unit='intensity',
rate=400.)
fl = Fluorescence(roi_response_series=roi_resp_series)
ophys_module.add(fl)
# df_over_f = DfOverF(roi_response_series=roi_resp_series)
# ophys_module.add(df_over_f)
with NWBHDF5IO('sample_data.nwb', 'w') as io:
io.write(nwbfile)
#
# io = NWBHDF5IO('sample_data.nwb', 'r')
# nwbfile = io.read()
