def CreatePlaneSegmentation(): w, h = 5, 5 img_mask = [[[1.0 for x in range(w)] for y in range(h)], [[2.0 for x in range(w)] for y in range(h)]] pix_mask = [[1, 2, 1.0], [3, 4, 1.0], [5, 6, 1.0], [7, 8, 2.0], [9, 10, 2.0]] iSS = ImageSeries(name='test_iS', source='a hypothetical source', data=list(), unit='unit', external_file=['external_file'], starting_frame=[1, 2, 3], format='tiff', timestamps=list()) oc = OpticalChannel('test_optical_channel', 'test_source', 'description', 'emission_lambda') ip = ImagingPlane('test_imaging_plane', 'test_source', oc, 'description', 'device', 'excitation_lambda', 'imaging_rate', 'indicator', 'location', (1, 2, 1, 2, 3), 4.0, 'unit', 'reference_frame') pS = PlaneSegmentation('test source', 'description', ip, 'test_name', iSS) pS.add_roi(pix_mask[0:3], img_mask[0]) pS.add_roi(pix_mask[3:5], img_mask[1]) return pS
def buildPlaneSegmentation(self): w, h = 5, 5 img_mask = [[[1.0 for x in range(w)] for y in range(h)], [[2.0 for x in range(w)] for y in range(h)]] pix_mask = [(1, 2, 1.0), (3, 4, 1.0), (5, 6, 1.0), (7, 8, 2.0), (9, 10, 2.)] ts = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] self.image_series = ImageSeries(name='test_iS', source='a hypothetical source', dimension=[2], external_file=['images.tiff'], starting_frame=[1, 2, 3], format='tiff', timestamps=ts) self.optical_channel = OpticalChannel('test_optical_channel', 'optical channel source', 'optical channel description', 500.) self.imaging_plane = ImagingPlane( 'test_imaging_plane', 'ophys integration tests', self.optical_channel, 'imaging plane description', 'imaging_device_1', 600., '2.718', 'GFP', 'somewhere in the brain', (1, 2, 1, 2, 3), 4.0, 'manifold unit', 'A frame to refer to') self.img_mask = deepcopy(img_mask) self.pix_mask = deepcopy(pix_mask) pS = PlaneSegmentation('integration test PlaneSegmentation', 'plane segmentation description', self.imaging_plane, 'test_plane_seg_name', self.image_series) pS.add_roi('1234', pix_mask[0:3], img_mask[0]) pS.add_roi('5678', pix_mask[3:5], img_mask[1]) return pS
def cicada_add_plane_segmentation(self): """ class pynwb.ophys.PlaneSegmentation(description, imaging_plane, name=None, reference_images=None, id=None, columns=None, colnames=None) """ required_metadata = ["plane_segmentation_description"] 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 = "plane_segmentation_" self.plane_segmentation = PlaneSegmentation( description=self.data['ophys_metadata'].get(name_module + "description"), imaging_plane=self.imaging_plane, name=self.data['ophys_metadata'].get(name_module + "name"), reference_images=self.data['ophys_metadata'].get( name_module + "reference_image"), id=self.data['ophys_metadata'].get(name_module + "id"), columns=self.data['ophys_metadata'].get(name_module + "columns"), colnames=self.data['ophys_metadata'].get(name_module + "colnames")) self.image_segmentation.add_plane_segmentation(self.plane_segmentation)
def CreatePlaneSegmentation(): w, h = 5, 5 img_mask = [[[1.0 for x in range(w)] for y in range(h)], [[2.0 for x in range(w)] for y in range(h)]] pix_mask = [[1, 2, 1.0], [3, 4, 1.0], [5, 6, 1.0], [7, 8, 2.0], [9, 10, 2.0]] iSS = ImageSeries(name='test_iS', data=np.ones((2, 2, 2)), unit='unit', external_file=['external_file'], starting_frame=[1, 2, 3], format='tiff', timestamps=[1., 2.]) oc = OpticalChannel('test_optical_channel', 'description', 500.) device = Device(name='device_name') ip = ImagingPlane('test_imaging_plane', oc, 'description', device, 600., 300., 'indicator', 'location', (1, 2, 1, 2, 3), 4.0, 'unit', 'reference_frame') pS = PlaneSegmentation('description', ip, 'test_name', iSS) pS.add_roi(pixel_mask=pix_mask[0:3], image_mask=img_mask[0]) pS.add_roi(pixel_mask=pix_mask[3:5], image_mask=img_mask[1]) return pS
def test_init(self): w, h = 5, 5 img_mask = [[[1.0 for x in range(w)] for y in range(h)], [[2.0 for x in range(w)] for y in range(h)]] pix_mask = [[1, 2, 1.0], [3, 4, 1.0], [5, 6, 1.0], [7, 8, 2.0], [9, 10, 2.0]] iSS = ImageSeries(name='test_iS', source='a hypothetical source', data=list(), unit='unit', external_file=['external_file'], starting_frame=[1, 2, 3], format='tiff', timestamps=list()) oc = OpticalChannel('test_optical_channel', 'test_source', 'description', 500.) ip = ImagingPlane('test_imaging_plane', 'test_source', oc, 'description', 'device', 600., 'imaging_rate', 'indicator', 'location', (1, 2, 1, 2, 3), 4.0, 'unit', 'reference_frame') pS = PlaneSegmentation('test source', 'description', ip, 'test_name', iSS) pS.add_roi("1234", pix_mask[0:3], img_mask[0]) pS.add_roi("5678", pix_mask[3:5], img_mask[1]) self.assertEqual(pS.description, 'description') self.assertEqual(pS.source, 'test source') self.assertEqual(pS.imaging_plane, ip) self.assertEqual(pS.reference_images, iSS) self.assertEqual(pS.pixel_masks.data, pix_mask) self.assertEqual(pS.image_masks.data, img_mask)
def test_init_3d_image_mask(self): img_masks = np.random.randn(2, 20, 30, 4) iSS, ip = self.getBoilerPlateObjects() pS = PlaneSegmentation('description', ip, 'test_name', iSS) pS.add_roi(image_mask=img_masks[0]) pS.add_roi(image_mask=img_masks[1]) self.assertTrue(np.allclose(pS['image_mask'][0], img_masks[0])) self.assertTrue(np.allclose(pS['image_mask'][1], img_masks[1]))
def test_init_3d_pixel_mask(self): pix_masks = np.random.randn(2, 20, 30, 4) iSS, ip = self.getBoilerPlateObjects() pS = PlaneSegmentation('description', ip, 'test_name', iSS) pS.add_roi(pixel_mask=pix_masks[0].tolist()) pS.add_roi(pixel_mask=pix_masks[1].tolist()) self.assertTrue(np.allclose(pS['pixel_mask'][0], pix_masks[0])) self.assertTrue(np.allclose(pS['pixel_mask'][1], pix_masks[1]))
def CreatePlaneSegmentation(): w, h = 5, 5 img_mask = [[0 for x in range(w)] for y in range(h)] w, h = 5, 2 pix_mask = [[0 for x in range(w)] for y in range(h)] pix_mask_weight = [0 for x in range(w)] iSS = ImageSeries(name='test_iS', source='a hypothetical source', data=list(), unit='unit', external_file=['external_file'], starting_frame=[1, 2, 3], format='tiff', timestamps=list()) roi1 = ROI('roi1', 'test source', 'roi description1', pix_mask, pix_mask_weight, img_mask, iSS) roi2 = ROI('roi2', 'test source', 'roi description2', pix_mask, pix_mask_weight, img_mask, iSS) roi_list = (roi1, roi2) oc = OpticalChannel('test_optical_channel', 'test_source', 'description', 'emission_lambda') ip = ImagingPlane('test_imaging_plane', 'test_source', oc, 'description', 'device', 'excitation_lambda', 'imaging_rate', 'indicator', 'location', (1, 2, 1, 2, 3), 4.0, 'unit', 'reference_frame') ps = PlaneSegmentation('name', 'test source', 'description', roi_list, ip, iSS) return ps
def buildPlaneSegmentationNoRois(self): """ Return an PlaneSegmentation and set related objects """ ts = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] self.image_series = ImageSeries(name='test_iS', dimension=[2], external_file=['images.tiff'], starting_frame=[1, 2, 3], format='tiff', timestamps=ts) self.device = Device(name='dev1') self.optical_channel = OpticalChannel( name='test_optical_channel', description='optical channel description', emission_lambda=500.) self.imaging_plane = ImagingPlane( name='test_imaging_plane', optical_channel=self.optical_channel, description='imaging plane description', device=self.device, excitation_lambda=600., imaging_rate=300., indicator='GFP', location='somewhere in the brain', reference_frame='a frame to refer to') return PlaneSegmentation(description='description', imaging_plane=self.imaging_plane, name='test_plane_seg_name', reference_images=self.image_series)
def test_init_image_mask(self): w, h = 5, 5 img_mask = [[[1.0 for x in range(w)] for y in range(h)], [[2.0 for x in range(w)] for y in range(h)]] iSS, ip = self.getBoilerPlateObjects() pS = PlaneSegmentation('description', ip, 'test_name', iSS) pS.add_roi(image_mask=img_mask[0]) pS.add_roi(image_mask=img_mask[1]) self.assertEqual(pS.description, 'description') self.assertEqual(pS.imaging_plane, ip) self.assertEqual(pS.reference_images, (iSS,)) self.assertEqual(pS['image_mask'].data, img_mask)
def create_basic_plane_segmentation(self): """Creates a basic plane segmentation used for testing""" iSS, ip = self.set_up_dependencies() pS = PlaneSegmentation(description='description', imaging_plane=ip, name='test_name', reference_images=iSS) return iSS, ip, pS
def test_init_voxel_mask(self): vox_mask = [[1, 2, 3, 1.0], [3, 4, 1, 1.0], [5, 6, 3, 1.0], [7, 8, 3, 2.0], [9, 10, 2, 2.0]] iSS, ip = self.getBoilerPlateObjects() pS = PlaneSegmentation('description', ip, 'test_name', iSS) pS.add_roi(voxel_mask=vox_mask[0:3]) pS.add_roi(voxel_mask=vox_mask[3:5]) self.assertEqual(pS.description, 'description') self.assertEqual(pS.imaging_plane, ip) self.assertEqual(pS.reference_images, (iSS, )) self.assertEqual(pS['voxel_mask'].target.data, vox_mask) self.assertEqual(pS['voxel_mask'][0], vox_mask[0:3]) self.assertEqual(pS['voxel_mask'][1], vox_mask[3:5])
def buildPlaneSegmentation(self): """ Return an PlaneSegmentation and set related objects """ w, h = 5, 5 img_mask = [[[1.0 for x in range(w)] for y in range(h)], [[2.0 for x in range(w)] for y in range(h)]] pix_mask = [(1, 2, 1.0), (3, 4, 1.0), (5, 6, 1.0), (7, 8, 2.0), (9, 10, 2.)] ts = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] self.image_series = ImageSeries(name='test_iS', dimension=[2], external_file=['images.tiff'], starting_frame=[1, 2, 3], format='tiff', timestamps=ts) self.device = Device(name='dev1') self.optical_channel = OpticalChannel('test_optical_channel', 'optical channel description', 500.) self.imaging_plane = ImagingPlane('imgpln1', self.optical_channel, 'a fake ImagingPlane', self.device, 600., 200., 'GFP', 'somewhere in the brain', (((1., 2., 3.), (4., 5., 6.)), ), 2., 'a unit', reference_frame='unknown') self.img_mask = deepcopy(img_mask) self.pix_mask = deepcopy(pix_mask) self.pxmsk_index = [3, 5] pS = PlaneSegmentation('plane segmentation description', self.imaging_plane, 'test_plane_seg_name', self.image_series) pS.add_roi(pixel_mask=pix_mask[0:3], image_mask=img_mask[0]) pS.add_roi(pixel_mask=pix_mask[3:5], image_mask=img_mask[1]) return pS
def test_init(self): w, h = 5, 5 img_mask = [[[1.0 for x in range(w)] for y in range(h)], [[2.0 for x in range(w)] for y in range(h)]] pix_mask = [[1, 2, 1.0], [3, 4, 1.0], [5, 6, 1.0], [7, 8, 2.0], [9, 10, 2.0]] iSS, ip = self.getBoilerPlateObjects() pS = PlaneSegmentation('description', ip, 'test_name', iSS) pS.add_roi(pixel_mask=pix_mask[0:3], image_mask=img_mask[0]) pS.add_roi(pixel_mask=pix_mask[3:5], image_mask=img_mask[1]) self.assertEqual(pS.description, 'description') self.assertEqual(pS.imaging_plane, ip) self.assertEqual(pS.reference_images, (iSS,)) self.assertEqual(pS['pixel_mask'].target.data, pix_mask) self.assertEqual(pS['pixel_mask'][0], pix_mask[0:3]) self.assertEqual(pS['pixel_mask'][1], pix_mask[3:5]) self.assertEqual(pS['image_mask'].data, img_mask)
def create_plane_segmentation(): w, h = 5, 5 img_mask = [[[1.0 for x in range(w)] for y in range(h)], [[2.0 for x in range(w)] for y in range(h)]] pix_mask = [[1, 2, 1.0], [3, 4, 1.0], [5, 6, 1.0], [7, 8, 2.0], [9, 10, 2.0]] iSS = ImageSeries(name='test_iS', data=np.ones((2, 2, 2)), unit='unit', external_file=['external_file'], starting_frame=[1, 2, 3], format='tiff', timestamps=[1., 2.]) ip = create_imaging_plane() pS = PlaneSegmentation(description='description', imaging_plane=ip, name='test_name', reference_images=iSS) pS.add_roi(pixel_mask=pix_mask[0:3], image_mask=img_mask[0]) pS.add_roi(pixel_mask=pix_mask[3:5], image_mask=img_mask[1]) return pS
def setBoilerPlateObjects(self): ts = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] self.image_series = ImageSeries(name='test_iS', dimension=[2], external_file=['images.tiff'], starting_frame=[1, 2, 3], format='tiff', timestamps=ts) self.device = Device(name='dev1') self.optical_channel = OpticalChannel('test_optical_channel', 'optical channel description', 500.) self.imaging_plane = ImagingPlane('test_imaging_plane', self.optical_channel, 'imaging plane description', self.device, 600., 300., 'GFP', 'somewhere in the brain', (1, 2, 1, 2, 3), 4.0, 'manifold unit', 'A frame to refer to') return PlaneSegmentation('description', self.imaging_plane, 'test_plane_seg_name', self.image_series)
def test_show_plane_segmentation_3d_voxel(self): ps3v = PlaneSegmentation( "output from segmenting my favorite imaging plane", self.imaging_plane, "3d_voxel", self.image_series, ) voxel_mask = [(i, i, i, 1.0) for i in range(3)] ps3v.add_roi(voxel_mask=voxel_mask) voxel_mask = [(1, 1, i, 1.2) for i in range(3)] ps3v.add_roi(voxel_mask=voxel_mask) wid = show_plane_segmentation_3d_voxel(ps3v) assert isinstance(wid, widgets.Widget)
def test_show_plane_segmentation_3d_mask(self): ps3 = PlaneSegmentation( "output from segmenting my favorite imaging plane", self.imaging_plane, "3d_plane_seg", self.image_series, ) w, h, d = 3, 3, 3 img_mask1 = np.zeros((w, h, d)) for i in range(3): img_mask1[i, i, i] = 1.0 ps3.add_roi(image_mask=img_mask1) img_mask2 = np.zeros((w, h, d)) for i in range(3): img_mask2[i, i, i] = 1.2 ps3.add_roi(image_mask=img_mask2) wid = show_plane_segmentation_3d_mask(ps3) assert isinstance(wid, widgets.Widget)
def create_basic_plane_segmentation(self): """Creates a basic plane segmentation used for testing""" iSS, ip = self.getBoilerPlateObjects() return PlaneSegmentation('description', ip, 'test_name', iSS)
def show_plane_segmentation_2d(plane_seg: PlaneSegmentation, color_wheel: list = color_wheel, color_by: str = None, threshold: float = .01, fig: go.Figure = None, width: int = 600, ref_image=None): """ Parameters ---------- plane_seg: PlaneSegmentation color_wheel: list, optional color_by: str, optional threshold: float, optional fig: plotly.graph_objects.Figure, optional width: int, optional width of image in pixels. Height is automatically determined to be proportional ref_image: image, optional Returns ------- """ layout_kwargs = dict() if color_by: if color_by not in plane_seg: raise ValueError( 'specified color_by parameter, {}, not in plane_seg object'. format(color_by)) cats = np.unique(plane_seg[color_by][:]) layout_kwargs.update(title=color_by) data = plane_seg['image_mask'].data nUnits = data.shape[0] if fig is None: fig = go.FigureWidget() if ref_image is not None: fig.add_trace( go.Heatmap(z=ref_image, hoverinfo='skip', showscale=False, colorscale='gray')) aux_leg = [] all_hover = df_to_hover_text(plane_seg.to_dataframe()) for i in range(nUnits): kwargs = dict(showlegend=False) if color_by is not None: if plane_seg[color_by][i] not in aux_leg: kwargs.update(showlegend=True) aux_leg.append(plane_seg[color_by][i]) c = color_wheel[np.where(cats == plane_seg[color_by][i])[0][0]] kwargs.update( line_color=c, name=str(plane_seg[color_by][i]), legendgroup=str(plane_seg[color_by][i]), ) # form cell borders x, y = compute_outline(plane_seg['image_mask'][i], threshold) fig.add_trace( go.Scatter(x=x, y=y, fill='toself', mode='lines', text=all_hover[i], hovertext='text', line=dict(width=.5), **kwargs)) fig.update_layout(width=width, yaxis=dict(mirror=True, scaleanchor="x", scaleratio=1, range=[0, plane_seg['image_mask'].shape[2]], constrain='domain'), xaxis=dict(mirror=True, range=[0, plane_seg['image_mask'].shape[1]], constrain='domain'), margin=dict(t=30, b=10), **layout_kwargs) return fig
def show_plane_segmentation_2d(plane_seg: PlaneSegmentation, color_wheel=color_wheel, color_by=None, threshold=.01, fig=None): """ Parameters ---------- plane_seg: PlaneSegmentation color_wheel: list color_by: str, optional threshold: float fig: plotly.graph_objects.Figure, optional Returns ------- """ layout_kwargs = dict() if color_by: if color_by not in plane_seg: raise ValueError( 'specified color_by parameter, {}, not in plane_seg object'. format(color_by)) cats = np.unique(plane_seg[color_by][:]) else: layout_kwargs.update(title=color_by) data = plane_seg['image_mask'].data nUnits = data.shape[0] if fig is None: fig = go.FigureWidget() aux_leg = [] all_hover = df_to_hover_text(plane_seg.to_dataframe()) for i in range(nUnits): if plane_seg[color_by][i] not in aux_leg: show_leg = True aux_leg.append(plane_seg[color_by][i]) else: show_leg = False kwargs = dict() if color_by: c = color_wheel[np.where(cats == plane_seg[color_by][i])[0][0]] kwargs.update( line_color=c, name=str(plane_seg[color_by][i]), legendgroup=str(plane_seg[color_by][i]), showlegend=show_leg, ) # form cell borders x, y = compute_outline(plane_seg['image_mask'][i], threshold) fig.add_trace( go.Scatter(x=x, y=y, fill='toself', mode='lines', text=all_hover[i], hovertext='text', line=dict(width=.5), **kwargs)) width = 600 fig.update_layout(width=width, yaxis=dict(mirror=True, scaleanchor="x", scaleratio=1, range=[0, plane_seg['image_mask'].shape[2]], constrain='domain'), xaxis=dict(mirror=True, range=[0, plane_seg['image_mask'].shape[1]], constrain='domain'), margin=dict(t=10, b=10), **layout_kwargs) return fig
class Preprocessing: def load_yaml(self): # Open YAML file with metadata if existing then dump all data in a dict if os.path.isfile("data.yaml"): with open("data.yaml", 'r') as stream: self.data = yaml.safe_load(stream) # Same but with .yml extension elif os.path.isfile("data.yml"): with open("data.yml", 'r') as stream: self.data = yaml.safe_load(stream) else: self.data = dict() if self.data is None: self.data = dict() # Dump the dict in the YAML file to save what the user inputted for future use with open('data.yaml', 'w') as outfile: yaml.dump(self.data, outfile, default_flow_style=False, allow_unicode=True) def add_required_metadata(self, data, key, metadata_type): # Prompt user to give required metadata # Need to be wary of the type (put " " for string and datetime.datetime(%Y, %m, %d) for datetime) print("Missing required " + metadata_type + " metadata : " + key + "\n") metadata_value = input("Type the value (with respect of the type) : ") data[key] = eval(metadata_value) # Dump the dict in the YAML file to save what the user inputted for future use with open('data.yaml', 'w') as outfile: yaml.dump(self.data, outfile, default_flow_style=False, allow_unicode=True) return data def add_optional_metadata(self, data): # Allow user to add as much metadata as he wants with the key he wants # Need to refer to documentation if he wants to fill existing attributes but he can create new ones and use # them in his own code keyboard_input = False while not keyboard_input: # Prompt user to give optional metadata # Need to be wary of the type (put " " for string and datetime.datetime(%Y, %m, %d) for datetime) metadata_key = input( "Type the name of the metadata you want to add ? ") metadata_key.replace(" ", "").lower().replace("", "_") metadata_value = input( "Type the value (with respect of the type) : ") data[metadata_key] = eval(metadata_value) go = input("Continue ? (yes/no)") # Prevent errors if other input than yes/np while go.replace(" ", "").lower() != "no" and go.replace( " ", "").lower() != "yes": go = input("Continue ? (yes/no)") if go.replace(" ", "").lower() == "no": keyboard_input = True # Dump the dict in the YAML file to save what the user inputted for future use with open('data.yaml', 'w') as outfile: yaml.dump(self.data, outfile, default_flow_style=False, allow_unicode=True) return data def ophys_metadata_acquisition(self): # TODO: Peut être faire un dictionnaire de sous-dictionnaires correspondant à chaque classe à remplir # Points positifs : Plus grand lisibilité dans le YAML, gestion simple des ambiguités de nom # tout en gardant la notation de NWB. # Points négatifs : Plus dur à rentrer en input pour l'utilisateur (il faut lui demander à quelle classe # correspond sa valeur). # List of the required metadata # TODO : maybe better implementation is possible ? required_metadata = [ "session_description", "identifier", "session_start_time" ] if self.data.get('ophys_metadata') is None: self.data['ophys_metadata'] = dict() for i in required_metadata: self.data["ophys_metadata"] = self.add_required_metadata( self.data["ophys_metadata"], i, "ophys") else: # Check if YAML file doesn't have all the required attributes and ask them the missing ones 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") print("Found ophys metadata : " + str(list(self.data['ophys_metadata'].keys()))) add_metadata = input( "Do you want to add more ophys metadata ? (yes/no) ") # Prevent errors if other input than yes/np while add_metadata.replace( " ", "").lower() != "no" and add_metadata.replace( " ", "").lower() != "yes": add_metadata = input( "Do you want to add more ophys metadata ? (yes/no) ") if add_metadata.replace(" ", "").lower() == "yes": self.data["ophys_metadata"] = self.add_optional_metadata( self.data["ophys_metadata"]) # Create new NWB file with all known attributes self.nwbfile = NWBFile( session_description=self.data['ophys_metadata'].get( "session_description"), identifier=self.data['ophys_metadata'].get("identifier"), session_start_time=self.data['ophys_metadata'].get( "session_start_time"), file_create_date=self.data['ophys_metadata'].get( "file_create_date"), timestamps_reference_time=self.data['ophys_metadata'].get( "timestamps_reference_time"), experimenter=self.data['ophys_metadata'].get("experimenter"), experiment_description=self.data['ophys_metadata'].get( "experiment_description"), session_id=self.data['ophys_metadata'].get("session_id"), institution=self.data['ophys_metadata'].get("institution"), keywords=self.data['ophys_metadata'].get("keywords"), notes=self.data['ophys_metadata'].get("notes"), pharmacology=self.data['ophys_metadata'].get("pharmacology"), protocol=self.data['ophys_metadata'].get("protocol"), related_publications=self.data['ophys_metadata'].get( "related_publications"), slices=self.data['ophys_metadata'].get("slices"), source_script=self.data['ophys_metadata'].get("source_script"), source_script_file_name=self.data['ophys_metadata'].get( "source_script_file_name"), data_collection=self.data['ophys_metadata'].get( "self.data['ophys_metadata']_collection"), surgery=self.data['ophys_metadata'].get("surgery"), virus=self.data['ophys_metadata'].get("virus"), stimulus_notes=self.data['ophys_metadata'].get("stimulus_notes"), lab=self.data['ophys_metadata'].get("lab"), subject=self.subject) def subject_metadata_acquisition(self): # Check if metadata about the subject exists and prompt the user if he wants to add some if self.data.get('subject_metadata') is None: print("No subject metadata found \n ") self.data['subject_metadata'] = dict() elif len(self.data['subject_metadata']) == 0: print("No subject metadata found \n ") else: print("Found subject metadata : " + str(list(self.data['subject_metadata'].keys()))) add_metadata = input( "Do you want to add more subject metadata ? (yes/no) ") # Prevent errors if other input than yes/np while add_metadata.replace( " ", "").lower() != "no" and add_metadata.replace( " ", "").lower() != "yes": add_metadata = input( "Do you want to add more subject metadata ? (yes/no) ") if add_metadata.replace(" ", "").lower() == "yes": self.data['subject_metadata'] = self.add_optional_metadata( self.data['subject_metadata']) self.subject = Subject( age=self.data['subject_metadata'].get("age"), description=self.data['subject_metadata'].get("description"), genotype=self.data['subject_metadata'].get("genotype"), sex=self.data['subject_metadata'].get("sex"), species=self.data['subject_metadata'].get("species"), subject_id=self.data['subject_metadata'].get("subject_id"), weight=self.data['subject_metadata'].get("weight"), date_of_birth=self.data['subject_metadata'].get("date_of_birth")) def cicada_create_device(self): """ class pynwb.device.Device(name, parent=None) """ required_metadata = ["device_name"] 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") self.device = Device( name=self.data['ophys_metadata'].get("device_name")) self.nwbfile.add_device(self.device) def cicada_create_optical_channel(self): required_metadata = [ "optical_channel_name", "optical_channel_description", "optical_channel_emission_lambda" ] 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") self.optical_channel = OpticalChannel( name=self.data['ophys_metadata'].get("optical_channel_name"), description=self.data['ophys_metadata'].get( "optical_channel_description"), emission_lambda=self.data['ophys_metadata'].get( "optical_channel_emission_lambda")) def cicada_create_module(self): required_metadata = [ "processing_module_name", "processing_module_description" ] 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") self.mod = self.nwbfile.create_processing_module( name=self.data['ophys_metadata'].get("processing_module_name"), description=self.data['ophys_metadata'].get( "processing_module_description")) def cicada_create_imaging_plane(self): """ class pynwb.ophys.ImagingPlane(name, optical_channel, description, device, excitation_lambda, imaging_rate, indicator, location, manifold=None, conversion=None, unit=None, reference_frame=None, parent=None) """ required_metadata = [ "imaging_plane_name", "imaging_plane_description", "imaging_plane_excitation_lambda", "imaging_plane_imaging_rate", "imaging_plane_indicator", "imaging_plane_location" ] 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 = "imaging_plane_" self.imaging_plane = self.nwbfile.create_imaging_plane( name=self.data['ophys_metadata'].get(name_module + "name"), optical_channel=self.optical_channel, description=self.data['ophys_metadata'].get(name_module + "description"), device=self.device, excitation_lambda=self.data['ophys_metadata'].get( name_module + "excitation_lambda"), imaging_rate=self.data['ophys_metadata'].get(name_module + "imaging_rate"), indicator=self.data['ophys_metadata'].get(name_module + "indicator"), location=self.data['ophys_metadata'].get(name_module + "location"), manifold=self.data['ophys_metadata'].get(name_module + "manifold"), conversion=self.data['ophys_metadata'].get(name_module + "conversion"), unit=self.data['ophys_metadata'].get(name_module + "unit"), reference_frame=self.data['ophys_metadata'].get(name_module + "reference_frame")) def cicada_create_two_photon_series(self, data_to_store=None, external_file=None): """ class pynwb.ophys.TwoPhotonSeries(name, imaging_plane, data=None, unit=None, format=None, field_of_view=None, pmt_gain=None, scan_line_rate=None, external_file=None, starting_frame=None, bits_per_pixel=None, dimension=[nan], 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 = ["two_photon_name"] 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 = "two_photon_" self.movie_two_photon = TwoPhotonSeries( name=self.data['ophys_metadata'].get(name_module + "name"), imaging_plane=self.imaging_plane, data=data_to_store, unit=self.data['ophys_metadata'].get(name_module + "unit"), format=self.data['ophys_metadata'].get(name_module + "format"), field_of_view=self.data['ophys_metadata'].get(name_module + "field_of_view"), pmt_gain=self.data['ophys_metadata'].get(name_module + "pmt_gain"), scan_line_rate=self.data['ophys_metadata'].get(name_module + "scan_line_rate"), external_file=external_file, starting_frame=self.data['ophys_metadata'].get(name_module + "starting_frame"), bits_per_pixel=self.data['ophys_metadata'].get(name_module + "bits_per_pixel"), dimension=data_to_store.shape[1:], resolution=0.0, conversion=1.0, timestamps=self.data['ophys_metadata'].get(name_module + "timestamps"), 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")) self.nwbfile.add_acquisition(self.movie_two_photon) def cicada_create_motion_correction(self): """ class pynwb.ophys.MotionCorrection(corrected_images_stacks={}, name='MotionCorrection') """ # Nom du module où récupérer les infos de métadonnée name_module = "motion_correction_" corrected_images_stacks = {} self.motion_correction = MotionCorrection( corrected_images_stacks=corrected_images_stacks, name="MotionCorrection") self.mod.add_data_interface(self.motion_correction) def cicada_add_corrected_image_stack(self, corrected=None, original=None, xy_translation=None): """ class pynwb.ophys.CorrectedImageStack(corrected, original, xy_translation, name='CorrectedImageStack') """ # Nom du module où récupérer les infos de métadonnée name_module = "corrected_image_stack_" self.corrected_image_stack = CorrectedImageStack( corrected=corrected, original=original, xy_translation=xy_translation, name="CorrectedImageStack") self.motion_correction.add_corrected_image_stack( self.corrected_image_stack) def cicada_add_plane_segmentation(self): """ class pynwb.ophys.PlaneSegmentation(description, imaging_plane, name=None, reference_images=None, id=None, columns=None, colnames=None) """ required_metadata = ["plane_segmentation_description"] 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 = "plane_segmentation_" self.plane_segmentation = PlaneSegmentation( description=self.data['ophys_metadata'].get(name_module + "description"), imaging_plane=self.imaging_plane, name=self.data['ophys_metadata'].get(name_module + "name"), reference_images=self.data['ophys_metadata'].get( name_module + "reference_image"), id=self.data['ophys_metadata'].get(name_module + "id"), columns=self.data['ophys_metadata'].get(name_module + "columns"), colnames=self.data['ophys_metadata'].get(name_module + "colnames")) self.image_segmentation.add_plane_segmentation(self.plane_segmentation) def cicada_add_roi_in_plane_segmentation(self, pixel_mask=None, voxel_mask=None, image_mask=None, id_roi=None): """add_roi(pixel_mask=None, voxel_mask=None, image_mask=None, id=None) """ self.plane_segmentation.add_roi(pixel_mask=pixel_mask, voxel_mask=voxel_mask, image_mask=image_mask, id=id_roi) def cicada_create_roi_table_region_in_plane_segmentation( self, region=slice(None, None, None)): """create_roi_table_region(description, region=slice(None, None, None), name='rois')""" required_metadata = ["roi_table_region_description"] 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_table_region_" self.table_region = self.plane_segmentation.create_roi_table_region( description=self.data['ophys_metadata'].get(name_module + "description"), region=region, name="rois") def cicada_create_image_segmentation(self): """ class pynwb.ophys.ImageSegmentation(plane_segmentations={}, name='ImageSegmentation') """ # Nom du module où récupérer les infos de métadonnée name_module = "image_segmentation_" plane_segmentations = {} self.image_segmentation = ImageSegmentation( plane_segmentations=plane_segmentations, name="ImageSegmentation") self.mod.add_data_interface(self.image_segmentation) def cicada_create_fluorescence(self): """ class pynwb.ophys.Fluorescence(roi_response_series={}, name='Fluorescence') """ # Nom du module où récupérer les infos de métadonnée name_module = "fluorescence_" roi_response_series = {} self.fluorescence = Fluorescence( roi_response_series=roi_response_series, name="Fluorescence") self.mod.add_data_interface(self.fluorescence) def cicada_create_DfOverF(self): """ class pynwb.ophys.DfOverF(roi_response_series={}, name='DfOverF') """ # Nom du module où récupérer les infos de métadonnée name_module = "DfOverF_" roi_response_series = {} self.DfOverF = DfOverF(roi_response_series=roi_response_series, name="DfOverF") self.mod.add_data_interface(self.DfOverF) 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 find_roi(self): # Chemin du dossier suite2p data_path = "C:/Users/François/Documents/dossier François/Stage INMED/" \ "Programmes/Godly Ultimate Interface/NWB/exp2nwb-master/src/suite2p" self.suite2p_data = dict() # Ouverture des fichiers stat et is_cell f = np.load(data_path + "/F.npy", allow_pickle=True) self.suite2p_data["F"] = f f_neu = np.load(data_path + "/Fneu.npy", allow_pickle=True) self.suite2p_data["Fneu"] = f_neu spks = np.load(data_path + "/spks.npy", allow_pickle=True) self.suite2p_data["spks"] = spks stat = np.load(data_path + "/stat.npy", allow_pickle=True) self.suite2p_data["stat"] = stat is_cell = np.load(data_path + "/iscell.npy", allow_pickle=True) self.suite2p_data["is_cell"] = is_cell # Trouve les coordonnées de chaque ROI (cellule ici) coord = [] for cell in np.arange(len(stat)): if is_cell[cell][0] == 0: continue print(is_cell[cell][0]) list_points_coord = [ (x, y, 1) for x, y in zip(stat[cell]["xpix"], stat[cell]["ypix"]) ] # coord.append(np.array(list_points_coord).transpose()) # La suite permet d'avoir uniquement les contours (sans les pixels intérieurs) """ # ATTENTION ! Il faut : from shapely.geometry import MultiPoint, LineString convex_hull = MultiPoint(list_points_coord).convex_hull if isinstance(convex_hull, LineString): coord_shapely = MultiPoint(list_points_coord).convex_hull.coords else: coord_shapely = MultiPoint(list_points_coord).convex_hull.exterior.coords coord.append(np.array(coord_shapely).transpose()) """ self.suite2p_data[ "coord"] = coord # Contient la liste des pixels inclus dans chaque ROI