def show_grad(file_path, name, vec_lec=1, downsample_fac=1): global viewer global res h5file = h5py.File(file_path, 'r') for key in h5file.keys(): line_id = 0 data = h5file[key] with viewer.txn() as s: s.layers.append(name=name + '_' + key + '_end', layer=neuroglancer.AnnotationLayer(voxelSize=res)) s.layers.append(name=name + '_' + key + '_start', layer=neuroglancer.AnnotationLayer(voxelSize=res)) line = s.layers[-2].annotations point = s.layers[-1].annotations for i in range(data.shape[0]): line.append( neuroglancer.LineAnnotation( id=line_id, point_a=downsample_fac * data[i, 0:3], point_b=downsample_fac * data[i, 0:3] + vec_lec * data[i, 3:6])) point.append( neuroglancer.PointAnnotation(id=line_id + 500000, point=downsample_fac * data[i, 0:3])) line_id += 1
def show_matches_gt_npy(filepath, name): global viewer global res with viewer.txn() as s: npf = np.load(filepath) keys = npf.item().keys() for key in keys: l = np.asarray(npf.item().get(key)) s.layers.append(name='start_' + name, layer=neuroglancer.AnnotationLayer(voxelSize=res)) start = s.layers[-1].annotations s.layers.append(name='end_' + name, layer=neuroglancer.AnnotationLayer(voxelSize=res)) end = s.layers[-1].annotations id = -1 for data in l: id += 1 start.append( neuroglancer.LineAnnotation(id=id, point_a=data[2][::-1], point_b=data[3][::-1])) end.append( neuroglancer.PointAnnotation(id=id, point=data[2][::-1]))
def show_grad_field(file_path, name, seg_file=None, seg_id=None, vec_lec=1, upsample_fac=1, sparsity=15, bloat=0): global viewer global res h5file = h5py.File(file_path, 'r') if seg_file is not None: h5file_seg = h5py.File(seg_file, 'r') segs = np.asarray(h5file_seg['main']) h5file_seg.close() mask = (segs == seg_id) else: mask = None for key in h5file.keys(): line_id = 0 data = h5file[key] if mask is None: locations = np.transpose( np.nonzero((data[0] != 0) | (data[1] != 0) | (data[2] != 0))) else: if bloat > 0: mask = ndimage.binary_dilation(mask, structure=np.ones((3, 3, 3)), iterations=int(bloat)) locations = np.transpose(np.nonzero((mask))) locations = locations[::sparsity] with viewer.txn() as s: s.layers.append(name=name + '_' + key + '_end', layer=neuroglancer.AnnotationLayer(voxelSize=res)) s.layers.append(name=name + '_' + key + '_start', layer=neuroglancer.AnnotationLayer(voxelSize=res)) line = s.layers[-2].annotations point = s.layers[-1].annotations for i in range(locations.shape[0]): loc = tuple(locations[i]) line.append( neuroglancer.LineAnnotation( id=line_id, point_a=upsample_fac * locations[i, ::-1], point_b=upsample_fac * locations[i, ::-1] + vec_lec * np.array([ data[(2, ) + loc], data[(1, ) + loc], data[ (0, ) + loc] ]))) point.append( neuroglancer.PointAnnotation(id=line_id + 500000, point=upsample_fac * locations[i, ::-1])) line_id += 1
def add_neuron(s, df, neuron_ids=[], show_ellipsoid_annotation=False): if len(neuron_ids) == 0: neuron_ids = list(np.unique(df.neuron_id)) for ii, neuron_id in enumerate(neuron_ids): color = "#%06x" % random.randint(0, 0xFFFFFF) pos_dic = {} df_neuron = df[df.neuron_id == neuron_id] edges = [] for index, row in df_neuron.iterrows(): node_id = row.id pos = np.array(row.position) pos_dic[node_id] = np.flip(pos) if row.parent_id: edges.append((node_id, row.parent_id)) v_nodes, u_nodes, connectors = [], [], [] print(f'Loaded {len(pos_dic)} nodes for neuron id {neuron_id}') for u, v in edges: if u in pos_dic and v in pos_dic: u_site = pos_dic[u] v_site = pos_dic[v] u_nodes.append( neuroglancer.EllipsoidAnnotation(center=u_site, radii=(30, 30, 30), id=next(ngid))) v_nodes.append( neuroglancer.EllipsoidAnnotation(center=v_site, radii=(30, 30, 30), id=next(ngid))) connectors.append( neuroglancer.LineAnnotation(point_a=u_site, point_b=v_site, id=next(ngid))) s.layers['neuronskeleton_{}'.format( neuron_id)] = neuroglancer.AnnotationLayer( voxel_size=(1, 1, 1), filter_by_segmentation=False, annotation_color=color, annotations=connectors, ) if show_ellipsoid_annotation: s.layers['node_u_{}'.format( neuron_id)] = neuroglancer.AnnotationLayer( voxel_size=(1, 1, 1), filter_by_segmentation=False, annotation_color=color, annotations=u_nodes, ) s.layers['node_v_{}'.format( neuron_id)] = neuroglancer.AnnotationLayer( voxel_size=(1, 1, 1), filter_by_segmentation=False, annotation_color=color, annotations=v_nodes, )
def add_trees(s, trees, node_id, name, visible=False): if trees is None: return None # print(f"Drawing {name} with {len(trees.nodes)} nodes") for i, cc_nodes in enumerate(nx.weakly_connected_components(trees)): # print(f"drawing cc {i} with {len(cc_nodes)} nodes") cc = trees.subgraph(cc_nodes) mst = [] for u, v in cc.edges(): pos_u = np.array(cc.nodes[u]["pos"]) + 0.5 pos_v = np.array(cc.nodes[v]["pos"]) + 0.5 mst.append( neuroglancer.LineAnnotation(point_a=pos_u[::-1], point_b=pos_v[::-1], id=next(node_id))) # print(f"adding {len(mst)} edge annotations") s.layers.append( name="{}_{}".format(name, i), layer=neuroglancer.AnnotationLayer(annotations=mst), annotationColor="#{:02X}{:02X}{:02X}".format( random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)), visible=visible, )
def _start_flood_fill(self, pos): self._stop_flood_fill() inf_results = zarr.zeros( self.gt_vol.bounds.to_list()[3:][::-1], chunks=(64, 64, 64), dtype=np.uint8) inf_volume = neuroglancer.LocalVolume( data=inf_results, voxel_size=list(self.gt_vol.resolution)) with self.viewer.txn() as s: s.layers['points'] = neuroglancer.AnnotationLayer() s.layers['inference'] = neuroglancer.ImageLayer( source=inf_volume, shader=''' void main() { float v = toNormalized(getDataValue(0)); vec4 rgba = vec4(0,0,0,0); if (v != 0.0) { rgba = vec4(colormapJet(v), 1.0); } emitRGBA(rgba); } ''', ) self.flood_fill_event = threading.Event() t = threading.Thread( target=self._do_flood_fill, kwargs=dict( initial_pos=pos, inf_results=inf_results, inf_volume=inf_volume, event=self.flood_fill_event, )) t.daemon = True t.start()
def display_bounding_box(self, txn): box = neuroglancer.AxisAlignedBoundingBoxAnnotation() box.point_a = self.box_coords[0] box.point_b = self.box_coords[1] box.id = "selection" txn.layers["selection"] = neuroglancer.AnnotationLayer( annotations=[box])
def add_trees(s, trees, node_id, name, visible=False): if trees is None: return None trees = nx.to_directed(trees) ccs = list(nx.weakly_connected_components(trees)) if len(ccs) < 10: for i, cc_nodes in enumerate(nx.weakly_connected_components(trees)): cc = trees.subgraph(cc_nodes) mst = [] for u, v in cc.edges(): pos_u = np.array(cc.nodes[u]["location"]) + 0.5 pos_v = np.array(cc.nodes[v]["location"]) + 0.5 mst.append( neuroglancer.LineAnnotation(point_a=pos_u[::-1], point_b=pos_v[::-1], id=next(node_id))) s.layers.append( name="{}_{}".format(name, i), layer=neuroglancer.AnnotationLayer(annotations=mst), annotationColor="#{:02X}{:02X}{:02X}".format( random.randint(0, 255), random.randint(0, 255), random.randint(0, 255), ), visible=visible, ) else: mst = [] for u, v in trees.edges(): pos_u = np.array(trees.nodes[u]["location"]) + 0.5 pos_v = np.array(trees.nodes[v]["location"]) + 0.5 mst.append( neuroglancer.LineAnnotation(point_a=pos_u[::-1], point_b=pos_v[::-1], id=next(node_id))) s.layers.append( name="{}".format(name), layer=neuroglancer.AnnotationLayer(annotations=mst), annotationColor="#{:02X}{:02X}{:02X}".format( random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)), visible=visible, )
def handle_synapses(ngviewer, path): """Add pre/post-synapses hosted via http as a neuroglancer layer.""" # This function adds synapses in the precomputed format hosted remotely via http to a neuroglancer instance. presynapsepath = 'precomputed://' + path + '/precomputed/presynapses' postsynapsepath = 'precomputed://' + path + '/precomputed/postsynapses' with ngviewer.txn() as s: s.layers['presynapses'] = neuroglancer.AnnotationLayer( source=presynapsepath, annotationColor='#ff0000', linked_segmentation_layer={'presynapses_cell': 'skeleton'}, filter_by_segmentation=['presynapses_cell']) s.layers['postsynapses'] = neuroglancer.AnnotationLayer( source=postsynapsepath, annotationColor='#0000ff', linked_segmentation_layer={'postsynapses_cell': 'skeleton'}, filter_by_segmentation=['postsynapses_cell']) return ngviewer
def handle_points(ngviewer, path, layer_name, annotationColor): """Add points hosted via http as a neuroglancer layer.""" # This function adds points in the precomputed format hosted locally via http to a neuroglancer instance. pointpath = 'precomputed://' + path + '/precomputed/' + layer_name with ngviewer.txn() as s: s.layers[layer_name] = neuroglancer.AnnotationLayer( source=pointpath, annotationColor=annotationColor) return ngviewer
def make_initial_state(self, segment_id, base_state): state = copy.deepcopy(base_state) segments = self.get_state_segment_ids(state) segments.clear() segments.add(segment_id) state.layers[ self.annotation_layer_name] = neuroglancer.AnnotationLayer() return state
def show_bbox(pointa, pointb, name): global viewer global res pointa = np.asarray(pointa) pointb = np.asarray(pointb) with viewer.txn() as s: s.layers.append(name='bb_' + name, layer=neuroglancer.AnnotationLayer(voxelSize=res)) s.layers[-1].annotations.append( neuroglancer.AxisAlignedBoundingBoxAnnotation( id=0, point_a=(pointa)[::-1], point_b=(pointb)[::-1]))
def display(self): if self.img_path.startswith("precomputed:"): img = self.img_path else: img = load_image(self.img_path, self.x0, self.x1, self.y0, self.y1, self.z0, self.z1) if self.alt_img_path is not None: if self.alt_img_path.startswith("precomputed:"): alt_img = self.alt_img_path else: alt_img = load_image(self.alt_img_path, self.x0, self.x1, self.y0, self.y1, self.z0, self.z1) if self.seg_path is not None: seg = load_image(self.seg_path, self.x0, self.x1, self.y0, self.y1, self.z0, self.z1) with self.viewer.txn() as txn: layer(txn, "image", img, gray_shader, self.multiplier, self.x0, self.y0, self.z0) if self.alt_img_path is not None: layer(txn, "alt-image", alt_img, green_shader, self.alt_multiplier, self.x0, self.y0, self.z0) if self.seg_path is not None: seglayer(txn, "segmentation", seg, self.x0, self.y0, self.z0) self.display_points(txn, self.points, "annotation", COLOR_POINTS) if self.detected_points is not None: self.display_points(txn, self.detected_points, "detected", COLOR_DETECTED_POINTS) elif has_layer(txn, "detected"): del txn.layers["detected"] if self.deleting_points is not None: self.display_points(txn, self.deleting_points, "deleting", COLOR_DELETING_POINTS) elif has_layer(txn, "deleting"): del txn.layers["deleting"] if self.box_coords is not None: self.display_bounding_box(txn) if self.bounding_box is not None: box = neuroglancer.AxisAlignedBoundingBoxAnnotation() box.point_a = self.bounding_box[0] box.point_b = self.bounding_box[1] box.id = "bounding-box" txn.layers["bounding-box"] = neuroglancer.AnnotationLayer( annotations=[box]) txn.position.voxel_coordinates = \ [(a + b) / 2 for a, b in zip(*self.bounding_box)] elif has_layer(txn, "selection"): del txn.layers["selection"] if self.bounding_box is None: self.center()
def show_ends_junctions(points_file, name): global viewer global res with h5py.File(points_file, 'r') as h5file: with viewer.txn() as s: s.layers.append(name='ends-' + name, layer=neuroglancer.AnnotationLayer(voxelSize=res)) ends = s.layers[-1].annotations s.layers.append(name='junc-' + name, layer=neuroglancer.AnnotationLayer(voxelSize=res)) junctions = s.layers[-1].annotations id = -1 for key in h5file.keys(): data = np.asarray(h5file[key]) if key[0] == 'e': point = ends else: point = junctions for j in range(data.shape[0]): id += 1 point.append( neuroglancer.PointAnnotation(point=data[j, ::-1], id=id))
def show_lines(filepath, name): global viewer global res h5file = h5py.File(filepath, 'r') with viewer.txn() as s: s.layers.append(name='start_' + name, layer=neuroglancer.AnnotationLayer(voxelSize=res)) start = s.layers[-1].annotations s.layers.append(name='end_' + name, layer=neuroglancer.AnnotationLayer(voxelSize=res)) end = s.layers[-1].annotations line_id = 0 for key in h5file.keys(): data = np.asarray(h5file[key]) start.append( neuroglancer.LineAnnotation(id=line_id, point_a=data[2::-1], point_b=data[5:2:-1])) end.append( neuroglancer.PointAnnotation(id=line_id, point=data[0:3])) line_id += 1
def add_annotation_layer(viewer, layer_name, verbose=True): if (layer_name in [l.name for l in viewer.state.layers]) & (verbose): print('{} is already a layer!'.format(layer_name)) else: with viewer.txn() as s: s.layers.append(name=layer_name, layer=neuroglancer.AnnotationLayer()) # Neuroglancer seems to take a short delay before layers are ready for objects to be added to them. # This sleep adds enough delay to python-bound viewers if isinstance(viewer, neuroglancer.viewer.Viewer): sleep(2.5) return viewer
def _set_viewer_seeds(s, seeds): for inclusive in [False, True]: layer_name = 'inclusive-seeds' if inclusive else 'exclusive-seeds' s.layers[layer_name] = neuroglancer.AnnotationLayer( annotation_color='green' if inclusive else 'red', annotations=[ dict( type='point', id=x['id'], point=x['position'], description=str(x['supervoxel_id']), ) for x in seeds[inclusive] ], )
def __init__(self, synapse_path, top_method='min', num_top_partners=10): with open(synapse_path, 'r') as f: synapse_data = json.load(f)['data'] self.synapses_by_id, self.synapse_partner_counts = get_synapses_by_id( synapse_data) self.top_method = top_method self.num_top_partners = num_top_partners viewer = self.viewer = neuroglancer.Viewer() viewer.actions.add('select-custom', self._handle_select) with viewer.config_state.txn() as s: s.input_event_bindings.data_view['dblclick0'] = 'select-custom' with viewer.txn() as s: s.perspective_zoom = 1024 s.perspective_orientation = [ 0.63240087, 0.01582051, 0.05692779, 0.77238464 ] s.navigation.zoom_factor = 32 s.layers['image'] = neuroglancer.ImageLayer( source= 'precomputed://gs://neuroglancer-public-data/flyem_fib-25/image', ) s.layers['ground_truth'] = neuroglancer.SegmentationLayer( source= 'precomputed://gs://neuroglancer-public-data/flyem_fib-25/ground_truth', ) s.layers['partners'] = neuroglancer.SegmentationLayer( source= 'precomputed://gs://neuroglancer-public-data/flyem_fib-25/ground_truth', ) s.layers['synapses'] = neuroglancer.AnnotationLayer( linked_segmentation_layer='ground_truth') s.layout = neuroglancer.row_layout([ neuroglancer.LayerGroupViewer( layout='xy', layers=['image', 'ground_truth', 'partners', 'synapses'], ), neuroglancer.LayerGroupViewer( layout='3d', layers=['ground_truth', 'synapses'], ), neuroglancer.LayerGroupViewer( layout='3d', layers=['partners', 'synapses'], ), ]) self.selected_segments = frozenset() self.viewer.shared_state.add_changed_callback( lambda: self.viewer.defer_callback(self.on_state_changed))
def show_matches_pred_npy(filepath, name, weight_th=0.80): global viewer global res with viewer.txn() as s: results = np.load(filepath) s.layers.append(name='start_' + name, layer=neuroglancer.AnnotationLayer(voxelSize=res)) start = s.layers[-1].annotations s.layers.append(name='end_' + name, layer=neuroglancer.AnnotationLayer(voxelSize=res)) end = s.layers[-1].annotations id = -1 for data in results: if float(data[5]) > weight_th: id += 1 start.append( neuroglancer.LineAnnotation(id=id, point_a=data[2][::-1], point_b=data[3][::-1])) end.append( neuroglancer.PointAnnotation(id=id, point=data[2][::-1]))
def bboxlayer(txn, name, x0, x1, y0, y1, z0, z1): """Add a bounding box layer :param txn: the neuroglancer viewer transaction context :param name: the name of the layer :param x0: the leftmost edge of the box :param x1: the rightmost edge of the box :param y0: the topmost edge of the box :param y1: the bottommoste edge of the box :param z0: the most shallow depth of the box :param z1: the deepest edge of the box """ box = neuroglancer.AxisAlignedBoundingBoxAnnotation() box.point_a = [x0, y0, z0] box.point_b = [x1, y1, z1] box.id = name txn.layers[name] = neuroglancer.AnnotationLayer(annotations=[box])
def show_points(points_file, name, resolution=None): global viewer global res r = resolution if resolution else res h5file = h5py.File(points_file, 'r') with viewer.txn() as s: for key in h5file.keys(): s.layers.append(name=name, layer=neuroglancer.AnnotationLayer(voxelSize=r)) points_layer = s.layers[-1].annotations points_ar = np.array(h5file[key]) points = [ neuroglancer.PointAnnotation(point=points_ar[i, ::-1], id=i) for i in range(points_ar.shape[0]) ] points_layer.extend(points)
def dataset_view(datasetname): dataset = DataSet.query.filter(DataSet.name == datasetname).first_or_404() state = neuroglancer.ViewerState() state.layers['img'] = neuroglancer.ImageLayer(source='precomputed://' + dataset.image_source) if dataset.pychunkedgraph_viewer_source is not None: state.layers['seg'] = neuroglancer.SegmentationLayer( source='graphene://' + dataset.pychunkedgraph_viewer_source) else: state.layers['seg'] = neuroglancer.SegmentationLayer( source='precomputed://' + dataset.flat_segmentation_source) state.layers['ann'] = neuroglancer.AnnotationLayer() state.layout = "xy-3d" ng_url = neuroglancer.to_url(state, prefix=current_app.config['NEUROGLANCER_URL']) return render_template('dataset.html', dataset=dataset, ng_url=ng_url, version=__version__)
def add_trees_no_skeletonization( s, trees, node_id, name, dimensions, visible=False, color=None ): mst = [] for u, v in trees.edges(): pos_u = np.array(trees.nodes[u]["location"]) + 0.5 pos_v = np.array(trees.nodes[v]["location"]) + 0.5 mst.append( neuroglancer.LineAnnotation( point_a=pos_u[::-1], point_b=pos_v[::-1], id=next(node_id) ) ) s.layers.append( name="{}".format(name), layer=neuroglancer.AnnotationLayer(annotations=mst), annotationColor="#{:02X}{:02X}{:02X}".format(255, 125, 125), visible=visible, )
def display_points(self): with self.viewer.txn() as txn: pointlayer(txn, "points", self.points[:, 0], self.points[:, 1], self.points[:, 2], self.color) if self.deleting_points is not None: pointlayer(txn, "delete-points", self.deleting_points[:, 0], self.deleting_points[:, 1], self.deleting_points[:, 2], "red") if self.box_coords is not None: box = neuroglancer.AxisAlignedBoundingBoxAnnotation() box.point_a = self.box_coords[0] box.point_b = self.box_coords[1] box.id = "selection" txn.layers["selection"] = neuroglancer.AnnotationLayer( annotations=[box]) elif "selection" in txn.layers: del txn.layers["selection"]
def display_points_txn(self, txn): pointlayer(txn, self.name, self.points[:, 2], self.points[:, 1], self.points[:, 0], self.color, voxel_size=self.voxel_size) if self.deleting_points is not None: pointlayer(txn, "delete-%s" % self.name, self.deleting_points[:, 2], self.deleting_points[:, 1], self.deleting_points[:, 0], "red", voxel_size=self.voxel_size) if self.box_coords is not None: box = neuroglancer.AxisAlignedBoundingBoxAnnotation() box.point_a = self.box_coords[0] box.point_b = self.box_coords[1] box.id = "selection" txn.layers["selection"] = neuroglancer.AnnotationLayer( annotations=[box]) elif "selection" in txn.layers: del txn.layers["selection"]
def show_vec_2(direction_vecs_path, vec_lec, name): global viewer global res h5file = h5py.File(direction_vecs_path, 'r') for key in h5file.keys(): line_id = 0 data = h5file[key] with viewer.txn() as s: s.layers.append(name='dir_' + key, layer=neuroglancer.AnnotationLayer(voxelSize=res)) annotations = s.layers[-1].annotations for i in range(data.shape[0]): annotations.append( neuroglancer.LineAnnotation(id=line_id, point_a=data[i][2::-1], point_b=data[i][2::-1] + vec_lec * data[i][5:2:-1])) annotations.append( neuroglancer.PointAnnotation(id=line_id + 500000, point=data[i][2::-1] + vec_lec * data[i][5:2:-1])) line_id += 1
def add_synapses(s, df, pre_neuron_id=None, post_neuron_id=None, color=None, name='', radius=30): if pre_neuron_id is not None: df = df[df.id_skel_pre == pre_neuron_id] if post_neuron_id is not None: df = df[df.id_skel_post == post_neuron_id] pre_sites, post_sites, connectors = [], [], [] print('Displaying {} of synapses'.format(len(df))) for index, syn in df.iterrows(): pre_site = np.flip(syn.location_pre) post_site = np.flip(syn.location_post) pre_sites.append( neuroglancer.EllipsoidAnnotation(center=pre_site, radii=(radius, radius, radius), id=next(ngid))) post_sites.append( neuroglancer.EllipsoidAnnotation(center=post_site, radii=(radius, radius, radius), id=next(ngid))) connectors.append( neuroglancer.LineAnnotation(point_a=pre_site, point_b=post_site, id=next(ngid))) s.layers['synlinks_{}'.format(name)] = neuroglancer.AnnotationLayer( voxel_size=(1, 1, 1), filter_by_segmentation=False, annotation_color=color, annotations=connectors, )
def handle_synapticdata(ngviewer, layer_kws): """Add the synapse predictions for the em datasets as a neuroglancer layer.""" # This function adds synapse predictions to a neuroglancer instance. ngspace = _get_ngspace(layer_kws) for layername in ngspace['layers']: if ngspace['layers'][layername]['type'] == 'synapsepred': with ngviewer.txn() as s: s.layers[layername] = neuroglancer.AnnotationLayer( source=ngspace['layers'][layername]['source'], linked_segmentation_layer={ 'pre_segment': ngspace['layers'][layername]['linkedseg'], 'post_segment': ngspace['layers'][layername]['linkedseg'] }, filter_by_segmentation=['post_segment', 'pre_segment'], shader='''#uicontrol vec3 preColor color(default=\"blue\") # uicontrol vec3 postColor color(default=\"red\") # uicontrol float scorethr slider(min=0, max=1000) # uicontrol int showautapse slider(min=0, max=1) void main() { setColor(defaultColor()); setEndpointMarkerColor( vec4(preColor, 0.5), vec4(postColor, 0.5)); setEndpointMarkerSize(5.0, 5.0); setLineWidth(2.0); if (int(prop_autapse()) > showautapse) discard; if (prop_score()<scorethr) discard; }''', shaderControls={"scorethr": 80}, ) return ngviewer
def visualize_synapses_in_neuroglancer(s, synapses, score_thr=-1, radius=30, show_ellipsoid_annotation=False, name='', color='#00ff00'): pre_sites = [] post_sites = [] connectors = [] below_score = 0 neuro_id = 0 for syn in synapses: if syn.score is None: add_synapse = True else: add_synapse = syn.score > score_thr if not add_synapse: below_score += 1 else: pre_site = np.flip(syn.location_pre) post_site = np.flip(syn.location_post) description = f"id: {syn.id}, pre_seg: {syn.id_segm_pre}, post_seg: {syn.id_segm_post}, score: {syn.score}" pre_sites.append( neuroglancer.EllipsoidAnnotation(center=pre_site, radii=(radius, radius, radius), id=neuro_id + 1)) post_sites.append( neuroglancer.EllipsoidAnnotation(center=post_site, radii=(radius, radius, radius), id=neuro_id + 2)) connectors.append( neuroglancer.LineAnnotation(point_a=pre_site, point_b=post_site, id=neuro_id + 3, description=description)) neuro_id += 3 s.layers['connectors_{}'.format(name)] = neuroglancer.AnnotationLayer( voxel_size=(1, 1, 1), filter_by_segmentation=False, annotation_color=color, annotations=connectors, ) if show_ellipsoid_annotation: s.layers['pre_sites'] = neuroglancer.AnnotationLayer( voxel_size=(1, 1, 1), filter_by_segmentation=False, annotation_color='#00ff00', annotations=pre_sites, ) s.layers['post_sites'] = neuroglancer.AnnotationLayer( voxel_size=(1, 1, 1), filter_by_segmentation=False, annotation_color='#ff00ff', annotations=post_sites, ) print('filtered out {}/{} of synapses'.format(below_score, len(synapses))) print('displaying {} synapses'.format(len(post_sites))) return synapses
neuroglancer.EllipsoidAnnotation(center=(x, y, z), radii=(tuple([10] * 3)), id=node_id, segments=None)) data_k["maxima"] = maxima prediction_views.append(data_k) with viewer.txn() as s: for k, view in enumerate(prediction_views): for dset, dset_data in view["view_dsets"].items(): add_layer(s, dset_data, str(k) + "_" + dset) s.layers['{}_maxima'.format(k)] = neuroglancer.AnnotationLayer( voxel_size=(1, 1, 1), filter_by_segmentation=False, annotation_color='#add8e6', annotations=view["maxima"]) try: s.layers['{}_connectors'.format(k)] = neuroglancer.AnnotationLayer( voxel_size=(1, 1, 1), filter_by_segmentation=False, annotation_color='#00ff00', annotations=view["edge_connectors"]) except KeyError: print("No edges in prediction") add_layer(s, prediction_views[0]["raw"], 'raw') print(viewer)