def add_stack(self):
if self.stack == 'MD585':
with self.viewer.txn() as s:
s.layers[self.stack + '_image'] = neuroglancer.ImageLayer( \
source='precomputed://https://mousebrainatlas-datajoint-jp2k.s3.amazonaws.com/precomputed/MD585_fullres')
elif self.stack == 'MD589':
with self.viewer.txn() as s:
s.layers[self.stack + '_image'] = neuroglancer.ImageLayer( \
source='precomputed://https://mousebrainatlas-datajoint-jp2k.s3.amazonaws.com/precomputed/MD589_fullres')
elif self.stack == 'MD594':
with self.viewer.txn() as s:
s.layers[self.stack + '_image'] = neuroglancer.ImageLayer( \
source='precomputed://https://mousebrainatlas-datajoint-jp2k.s3.amazonaws.com/precomputed/MD594_fullres')
def __init__(self):
viewer = self.viewer = neuroglancer.Viewer()
self.gt_vol = cloudvolume.CloudVolume(
'https://storage.googleapis.com/neuroglancer-public-data/flyem_fib-25/ground_truth',
mip=0,
bounded=True,
progress=False,
provenance={})
viewer.actions.add('start-fill', self._start_fill_action)
viewer.actions.add('stop-fill', self._stop_fill_action)
self.dimensions = neuroglancer.CoordinateSpace(
names=['x', 'y', 'z'],
units='nm',
scales=[8, 8, 8],
)
with viewer.config_state.txn() as s:
s.input_event_bindings.data_view['shift+mousedown0'] = 'start-fill'
s.input_event_bindings.data_view['keyt'] = 'stop-fill'
with viewer.txn() as s:
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['ground_truth'].visible = False
self.flood_fill_event = None
def test_title(webdriver):
if webdriver.browser == 'firefox':
pytest.skip('test can hang under firefox')
a = np.array([[[255]]], dtype=np.uint8)
with webdriver.viewer.txn() as s:
s.dimensions = neuroglancer.CoordinateSpace(names=["x", "y", "z"],
units="nm",
scales=[1, 1, 1])
s.layers.append(
name="a",
layer=neuroglancer.ImageLayer(source=neuroglancer.LocalVolume(data=a,
dimensions=s.dimensions),
),
)
webdriver.sync()
assert webdriver.driver.title == 'neuroglancer'
with webdriver.viewer.txn() as s:
s.title = 'the title'
webdriver.sync()
assert webdriver.driver.title == 'the title - neuroglancer'
with webdriver.viewer.txn() as s:
s.title = None
webdriver.sync()
assert webdriver.driver.title == 'neuroglancer'
def layer(txn,
name,
img,
shader,
multiplier,
offx=0,
offy=0,
offz=0,
voxel_size=default_voxel_size):
"""Add an image layer to Neuroglancer
:param txn: The transaction context of the viewer
:param name: The name of the layer as displayed in Neuroglancer
:param img: The image to display
:param shader: the shader to use when displaying, e.g. gray_shader
:param multiplier: the multiplier to apply to the normalized data value.
This can be used to brighten or dim the image.
"""
if isinstance(img, str):
frac = multiplier
source = img
else:
frac = multiplier / np.percentile(img, 99.9)
if img.dtype.kind in ("i", "u"):
frac = frac * np.iinfo(img.dtype).max
source = neuroglancer.LocalVolume(img,
voxel_offset=(offx, offy, offz),
voxel_size=voxel_size)
txn.layers[name] = neuroglancer.ImageLayer(source=source,
shader=shader % frac)
def refresh(self):
with self.viewer.txn() as s:
s.voxel_size = self.voxel_size * 1000
s.layers["image"] = neuroglancer.ImageLayer(
source=self.url, shader=cubehelix_shader % self.brightness)
s.layers["points"] = neuroglancer.PointAnnotationLayer(
points=self.points)
def glance_precomputed(viewer,
image=None,
host='localhost',
labels=None,
port=41000):
'''supply cloud paths'''
if image:
image_path = 'precomputed://http://localhost:{}/'.format(
port) + os.path.relpath(image)
#image_path = 'precomputed://'+image
#image_path = 'precomputed://ftp://localhost/cloud_test'
#image_path = 'precomputed://http://localhost:41000'
print('Image Source:', image_path)
else:
return None
if labels:
labels_path = 'precomputed://http://localhost:{}/'.format(
port) + os.path.relpath(labels)
print('Labels Source:', labels_path)
with viewer.txn() as s:
if image is not None:
s.layers['image'] = neuroglancer.ImageLayer(source=image_path)
if labels is not None:
s.layers['ground_truth'] = neuroglancer.SegmentationLayer(
source=labels_path)
return viewer.get_viewer_url()
def show_grad_as_color(path, name, bounds=None, resolution=None):
global viewer
global res
if resolution is None:
r = res
else:
r = resolution
print('Loading: ' + path)
print('as: ' + name)
with h5py.File(path, 'r') as hf:
hf_keys = hf.keys()
print(list(hf_keys))
for key in list(hf_keys):
if bounds is not None:
data = np.array(hf[key][bounds[0][0]:bounds[0][1],
bounds[1][0]:bounds[1][1],
bounds[2][0]:bounds[2][1]])
else:
data = np.array(hf[key])
data = grad_to_RGB(data)
with viewer.txn() as s:
s.layers[name] = neuroglancer.ImageLayer(
source=neuroglancer.LocalVolume(data, voxel_size=res),
shader="""void main()
{
emitRGB(vec3(toNormalized(getDataValue(0)),
toNormalized(getDataValue(1)),
toNormalized(getDataValue(2))));
}""",
)
def _start_flood_fill(self, pos):
self._stop_flood_fill()
inf_results = zarr.zeros(self.gt_vol.bounds.to_list()[3:],
chunks=(64, 64, 64),
dtype=np.uint8)
inf_volume = neuroglancer.LocalVolume(data=inf_results,
dimensions=self.dimensions)
with self.viewer.txn() as s:
s.layers['points'] = neuroglancer.LocalAnnotationLayer(
self.dimensions)
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 add_volume(self, volume, layer_name=None, clear_layer=False):
if self.viewer is None:
self.viewer = neuroglancer.Viewer()
if layer_name is None:
layer_name = f'{self.layer_type}_{self.scales}'
source = neuroglancer.LocalVolume(
data=volume,
dimensions=neuroglancer.CoordinateSpace(names=['x', 'y', 'z'],
units='nm',
scales=self.scales),
voxel_offset=self.offset)
if self.layer_type == 'segmentation':
layer = neuroglancer.SegmentationLayer(source=source)
else:
layer = neuroglancer.ImageLayer(source=source)
with self.viewer.txn() as s:
if clear_layer:
s.layers.clear()
s.layers[layer_name] = layer
print(f'A new layer named {layer_name} is added to:')
print(self.viewer)
def __init__(self):
viewer = self.viewer = neuroglancer.Viewer()
viewer.actions.add('inference', self._do_inference)
self.gt_vol = cloudvolume.CloudVolume(
'https://storage.googleapis.com/neuroglancer-public-data/flyem_fib-25/ground_truth',
mip=0,
bounded=True,
progress=False,
provenance={})
self.dimensions = neuroglancer.CoordinateSpace(
names=['x', 'y', 'z'],
units='nm',
scales=self.gt_vol.resolution,
)
self.inf_results = zarr.zeros(self.gt_vol.bounds.to_list()[3:],
chunks=(64, 64, 64),
dtype=np.uint8)
self.inf_volume = neuroglancer.LocalVolume(data=self.inf_results,
dimensions=self.dimensions)
with viewer.config_state.txn() as s:
s.input_event_bindings.data_view['shift+mousedown0'] = 'inference'
with viewer.txn() as s:
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['ground_truth'].visible = False
s.layers['inference'] = neuroglancer.ImageLayer(
source=self.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);
}
''',
)
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
dimensions = neuroglancer.CoordinateSpace(
names=['x', 'y', 'z'],
units='nm',
scales=[8, 8, 8],
)
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.projection_orientation = [
0.63240087, 0.01582051, 0.05692779, 0.77238464
]
s.dimensions = dimensions
s.position = [3000, 3000, 3000]
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.LocalAnnotationLayer(
dimensions=dimensions,
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 _neuroglancer_layer(
self) -> Tuple[neuroglancer.ImageLayer, Dict[str, Any]]:
# Generates an Image layer. May not be correct if this crop contains a segmentation
layer = neuroglancer.ImageLayer(source=self._neuroglancer_source())
kwargs = {
"visible": False,
"blend": "additive",
}
return layer, kwargs
def handle_emdata(ngviewer, layer_kws):
"""Add the electron microscopy layer as a neuroglancer layer."""
# This function adds EM layer to a neuroglancer instance.
# The EM layers are usually corresponding to spaces like 'FAFB', etc
ngspace = _get_ngspace(layer_kws)
for layername in ngspace['layers']:
if ngspace['layers'][layername]['type'] == 'image':
with ngviewer.txn() as s:
s.layers[layername] = neuroglancer.ImageLayer(
source=ngspace['layers'][layername]['source'], )
return ngviewer
def visualize_trees(graphs: Dict[str, nx.DiGraph]):
viewer = neuroglancer.Viewer()
with viewer.txn() as s:
s.layers["blegh"] = neuroglancer.ImageLayer(
source=neuroglancer.LocalVolume(data=np.zeros([1, 1, 1]).transpose(
[2, 1, 0]),
voxel_size=[1, 1, 1]))
node_id = itertools.count(start=1)
for name, graph in graphs.items():
add_trees(s, graph, node_id, name=name, visible=True)
print(viewer)
input("Hit ENTER to quit!")
def __init__(self, state_path, bodies, labels, segmentation_url, image_url,
num_to_prefetch):
self.state = State(state_path)
self.num_to_prefetch = num_to_prefetch
self.viewer = neuroglancer.Viewer()
self.bodies = bodies
self.state.load()
self.total_voxels = sum(x.num_voxels for x in bodies)
self.cumulative_voxels = np.cumsum([x.num_voxels for x in bodies])
with self.viewer.txn() as s:
s.layers['image'] = neuroglancer.ImageLayer(source=image_url)
s.layers['segmentation'] = neuroglancer.SegmentationLayer(
source=segmentation_url)
s.navigation.zoom_factor = 66
s.perspective_zoom = 1280
s.show_slices = False
s.concurrent_downloads = 256
s.gpu_memory_limit = 2 * 1024 * 1024 * 1024
s.layout = '3d'
key_bindings = [
['bracketleft', 'prev-index'],
['bracketright', 'next-index'],
['home', 'first-index'],
['end', 'last-index'],
['control+keys', 'save'],
]
label_keys = ['keyd', 'keyf', 'keyg', 'keyh']
for label, label_key in zip(labels, label_keys):
key_bindings.append([label_key, 'label-%s' % label])
def label_func(s, label=label):
self.set_label(s, label)
self.viewer.actions.add('label-%s' % label, label_func)
self.viewer.actions.add('prev-index', self._prev_index)
self.viewer.actions.add('next-index', self._next_index)
self.viewer.actions.add('first-index', self._first_index)
self.viewer.actions.add('last-index', self._last_index)
self.viewer.actions.add('save', self.save)
with self.viewer.config_state.txn() as s:
for key, command in key_bindings:
s.input_event_bindings.viewer[key] = command
s.status_messages['help'] = (
'KEYS: ' + ' | '.join('%s=%s' % (key, command)
for key, command in key_bindings))
self.index = -1
self.set_index(self._find_one_after_last_labeled_index())
def handle_synapticclefts(ngviewer, layer_kws):
"""Add the synapse cleft predictions for the em dataset as a neuroglancer layer."""
# This function adds synapse cleft predictions to a neuroglancer instance.
ngspace = _get_ngspace(layer_kws)
for layername in ngspace['layers']:
if ngspace['layers'][layername]['type'] == 'synapticcleft':
with ngviewer.txn() as s:
s.layers[layername] = neuroglancer.ImageLayer(
source=ngspace['layers'][layername]['source'],
shader=
'void main() {emitRGBA(vec4(0.0,0.0,1.0,toNormalized(getDataValue())));}',
opacity=0.73)
return ngviewer
def display_split_result(graph, agglo_id, cur_eqs, supervoxel_map, split_seeds,
image_url, segmentation_url):
agglo_members = set(graph.get_agglo_members(agglo_id))
state = neuroglancer.ViewerState()
state.layers.append(name='image',
layer=neuroglancer.ImageLayer(source=image_url))
state.layers.append(
name='original',
layer=neuroglancer.SegmentationLayer(
source=segmentation_url,
segments=agglo_members,
),
visible=False,
)
state.layers.append(
name='isolated-supervoxels',
layer=neuroglancer.SegmentationLayer(
source=segmentation_url,
segments=set(x for x, seeds in six.viewitems(supervoxel_map)
if len(seeds) > 1),
),
visible=False,
)
state.layers.append(name='split',
layer=neuroglancer.SegmentationLayer(
source=segmentation_url,
equivalences=cur_eqs,
segments=set(cur_eqs[x] for x in agglo_members),
))
for label, component in six.viewitems(split_seeds):
state.layers.append(
name='seed%d' % label,
layer=neuroglancer.PointAnnotationLayer(
points=[seed['position'] for seed in component], ),
)
state.show_slices = False
state.layout = '3d'
all_seed_points = [
seed['position'] for component in six.viewvalues(split_seeds)
for seed in component
]
state.voxel_coordinates = np.mean(all_seed_points, axis=0)
state.perspective_zoom = 140
return state
def test_slider(webdriver):
with webdriver.viewer.txn() as s:
s.dimensions = neuroglancer.CoordinateSpace(names=["x", "y"], units="nm", scales=[1, 1])
s.position = [0.5, 0.5]
s.layers.append(
name='image',
layer=neuroglancer.ImageLayer(source=neuroglancer.LocalVolume(
dimensions=s.dimensions,
data=np.full(shape=(1, 1), dtype=np.uint32, fill_value=42),
),
),
visible=True,
shader='''
#uicontrol float color slider(min=0, max=10)
void main() {
emitGrayscale(color);
}
''',
shader_controls={
'color': 1,
},
)
s.layout = 'xy'
s.cross_section_scale = 1e-6
s.show_axis_lines = False
control = webdriver.viewer.state.layers['image'].shader_controls['color']
assert control == 1
def expect_color(color):
webdriver.sync()
screenshot = webdriver.viewer.screenshot(size=[10, 10]).screenshot
np.testing.assert_array_equal(screenshot.image_pixels,
np.tile(np.array(color, dtype=np.uint8), (10, 10, 1)))
expect_color([255, 255, 255, 255])
with webdriver.viewer.txn() as s:
s.layers['image'].shader_controls = {
'color': 0,
}
expect_color([0, 0, 0, 255])
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 test_screenshot_basic(webdriver):
a = np.array([[[255]]], dtype=np.uint8)
with webdriver.viewer.txn() as s:
s.dimensions = neuroglancer.CoordinateSpace(names=["x", "y", "z"],
units="nm",
scales=[1, 1, 1])
s.layers.append(
name="a",
layer=neuroglancer.ImageLayer(
source=neuroglancer.LocalVolume(data=a, dimensions=s.dimensions),
shader='void main () { emitRGB(vec3(1.0, 0.0, 0.0)); }',
),
)
s.layout = 'xy'
s.cross_section_scale = 1e-6
s.show_axis_lines = False
screenshot = webdriver.viewer.screenshot(size=[10, 10]).screenshot
np.testing.assert_array_equal(screenshot.image_pixels,
np.tile(np.array([255, 0, 0, 255], dtype=np.uint8), (10, 10, 1)))
def add_dask_layer(state):
"""Adds a lazily-computed data source backed by dask."""
# https://docs.dask.org/en/latest/array-creation.html#using-dask-delayed
import dask
import dask.array
def make_array(k):
print('Computing k=%d' % (k, ))
return np.full(shape=(256, 256), fill_value=k, dtype=np.uint8)
lazy_make_array = dask.delayed(make_array, pure=True)
lazy_chunks = [lazy_make_array(k) for k in range(255)]
sample = lazy_chunks[0].compute() # load the first chunk (assume rest are same shape/dtype)
arrays = [
dask.array.from_delayed(lazy_chunk, dtype=sample.dtype, shape=sample.shape)
for lazy_chunk in lazy_chunks
]
x = dask.array.concatenate(arrays)
state.layers['dask'] = neuroglancer.ImageLayer(source=neuroglancer.LocalVolume(x))
def test_display_dimensions(webdriver, display_dimensions, layout, key,
expected_position):
a = np.zeros((10, 10, 10), dtype=np.uint8)
with webdriver.viewer.txn() as s:
s.dimensions = neuroglancer.CoordinateSpace(names=["z", "y", "x"],
units="nm",
scales=[1, 1, 1])
s.layers.append(
name="a",
layer=neuroglancer.ImageLayer(source=neuroglancer.LocalVolume(
data=a, dimensions=s.dimensions), ),
)
s.display_dimensions = display_dimensions
s.layout = layout
webdriver.sync()
webdriver.action_chain().move_to_element_with_offset(
webdriver.root_element, 100, 100).click().send_keys(key).perform()
webdriver.sync()
assert np.floor(
webdriver.viewer.state.position).tolist() == expected_position
def layer(txn,
name,
img,
shader=None,
multiplier=1.0,
dimensions=None,
offx=0,
offy=0,
offz=0,
voxel_size=default_voxel_size):
"""Add an image layer to Neuroglancer
:param txn: The transaction context of the viewer.
:param name: The name of the layer as displayed in Neuroglancer.
:param img: The image to display in TCZYX order.
:param shader: the shader to use when displaying, e.g. gray_shader
:param multiplier: the multiplier to apply to the normalized data value.
This can be used to brighten or dim the image.
"""
if isinstance(img, str):
source = img
else:
if dimensions is None:
dim_names = ["xyzct"[d] for d in range(img.ndim)]
dim_units = ["µm"] * img.ndim
dim_scales = [1.0] * img.ndim
dimensions = neuroglancer.CoordinateSpace(names=dim_names,
units=dim_units,
scales=dim_scales)
source = neuroglancer.LocalVolume(data=reverse_dimensions(img),
dimensions=dimensions,
voxel_offset=(offx, offy, offz))
shader = shader or gray_shader
txn.layers[name] = neuroglancer.ImageLayer(source=source,
shader=shader % multiplier)
def add_cdf_test_layer(state, dtype, min_value=None, max_value=None):
dimensions = neuroglancer.CoordinateSpace(names=['x'],
units='',
scales=[1])
state.dimensions = dimensions
if min_value is None or max_value is None:
info = np.iinfo(dtype)
if min_value is None:
min_value = info.min
if max_value is None:
max_value = info.max
data = np.linspace(start=min_value,
stop=max_value,
endpoint=True,
dtype=dtype,
num=256)
state.layers[np.dtype(dtype).name] = neuroglancer.ImageLayer(
source=neuroglancer.LocalVolume(
data=data,
dimensions=dimensions,
))
def main():
global output_file_name
global synapses
global viewer
args = parse_args()
neuroglancer.set_static_content_source(url=args.static_content_source)
neuroglancer.set_server_bind_address(bind_port=int(args.port))
image_url = args.image_url
segmentation_url = args.segmentation_url
output_file_name = args.output
synapse_dict = json.load(open(args.synapses))
for n1, n2, x, y, z in zip(synapse_dict["neuron_1"],
synapse_dict["neuron_2"],
synapse_dict["synapse_center"]["x"],
synapse_dict["synapse_center"]["y"],
synapse_dict["synapse_center"]["z"]):
synapses.append(Synapse(n1, n2, x, y, z))
viewer = neuroglancer.Viewer()
with viewer.txn() as s:
s.layers['image'] = neuroglancer.ImageLayer(source=image_url)
s.layers['segmentation'] = neuroglancer.SegmentationLayer(
source=segmentation_url)
viewer.actions.add("yes", lambda _: yes())
viewer.actions.add("no", lambda _: no())
viewer.actions.add("skip", lambda _: skip())
viewer.actions.add("back", lambda _: back())
viewer.actions.add("revert", lambda _: set_viewer_state())
with viewer.config_state.txn() as s:
s.input_event_bindings.viewer['shift+keyy'] = 'yes'
s.input_event_bindings.viewer["shift+keyn"] = "no"
s.input_event_bindings.viewer["shift+keys"] = "skip"
s.input_event_bindings.viewer["shift+keyr"] = "revert"
s.input_event_bindings.viewer["shift+keyb"] = "back"
set_viewer_state()
webbrowser.open_new(viewer.get_viewer_url())
while True:
time.sleep(1)
def test_invlerp(webdriver):
with webdriver.viewer.txn() as s:
s.dimensions = neuroglancer.CoordinateSpace(names=["x", "y"], units="nm", scales=[1, 1])
s.position = [0.5, 0.5]
s.layers.append(
name='image',
layer=neuroglancer.ImageLayer(source=neuroglancer.LocalVolume(
dimensions=s.dimensions,
data=np.full(shape=(1, 1), dtype=np.uint32, fill_value=42),
),
),
visible=True,
shader_controls={
'normalized': {
'range': [0, 42],
},
},
)
s.layout = 'xy'
s.cross_section_scale = 1e-6
s.show_axis_lines = False
control = webdriver.viewer.state.layers['image'].shader_controls['normalized']
assert isinstance(control, neuroglancer.InvlerpParameters)
np.testing.assert_equal(control.range, [0, 42])
def expect_color(color):
webdriver.sync()
screenshot = webdriver.viewer.screenshot(size=[10, 10]).screenshot
np.testing.assert_array_equal(screenshot.image_pixels,
np.tile(np.array(color, dtype=np.uint8), (10, 10, 1)))
expect_color([255, 255, 255, 255])
with webdriver.viewer.txn() as s:
s.layers['image'].shader_controls = {
'normalized': neuroglancer.InvlerpParameters(range=[42, 100]),
}
expect_color([0, 0, 0, 255])
def test_context_lost(webdriver):
a = np.array([[[255]]], dtype=np.uint8)
with webdriver.viewer.txn() as s:
s.dimensions = neuroglancer.CoordinateSpace(names=["x", "y", "z"],
units="nm",
scales=[1, 1, 1])
s.layers.append(
name="a",
layer=neuroglancer.ImageLayer(
source=neuroglancer.LocalVolume(data=a,
dimensions=s.dimensions),
shader='void main () { emitRGB(vec3(1.0, 0.0, 0.0)); }',
),
)
s.layout = 'xy'
s.cross_section_scale = 1e-6
s.show_axis_lines = False
screenshot = webdriver.viewer.screenshot(size=[10, 10]).screenshot
np.testing.assert_array_equal(
screenshot.image_pixels,
np.tile(np.array([255, 0, 0, 255], dtype=np.uint8), (10, 10, 1)))
webdriver.driver.execute_script('''
window.webglLoseContext = viewer.gl.getExtension('WEBGL_lose_context');
window.webglLoseContext.loseContext();
''')
time.sleep(3) # Wait a few seconds for log messages to be written
browser_log = webdriver.get_log_messages()
assert 'Lost WebGL context' in browser_log
webdriver.driver.execute_script('''
window.webglLoseContext.restoreContext();
''')
time.sleep(3) # Wait a few seconds for log messages to be written
browser_log = webdriver.get_log_messages()
assert 'WebGL context restored' in browser_log
screenshot = webdriver.viewer.screenshot(size=[10, 10]).screenshot
np.testing.assert_array_equal(
screenshot.image_pixels,
np.tile(np.array([255, 0, 0, 255], dtype=np.uint8), (10, 10, 1)))
import neuroglancer
import numpy as np
import argparse
from pathlib import Path
viewer = neuroglancer.Viewer()
print(viewer)
parser = argparse.ArgumentParser()
parser.add_argument("nifti_path", type=Path)
p = parser.parse_args()
with viewer.txn() as s:
s.layers['image'] = neuroglancer.ImageLayer(
#source='nifti://http://127.0.0.1:9000/B51315_T1_masked.nii.gz',
source='nifti://http://127.0.0.1:9000/B51325_invivoAPOE1_labels.nii.gz'
)
webbrowser.open_new(viewer.get_viewer_url())
print(neuroglancer.to_url(viewer.state))
print(viewer.state)
print(viewer)
neuroglancer.stop()
def __init__(self, graph, agglo_id, image_url, segmentation_url, state_path):
self.graph = graph
self.agglo_id = agglo_id
self.image_url = image_url
self.segmentation_url = segmentation_url
self.state = InteractiveState(state_path)
self.cached_split_result = CachedSplitResult(
state=self.state, graph=self.graph, agglo_id=self.agglo_id)
self.agglo_members = set(self.graph.get_agglo_members(agglo_id))
if state_path is not None and os.path.exists(state_path):
self.state.load()
else:
self.state.initialize(self.agglo_members)
viewer = self.viewer = neuroglancer.Viewer()
viewer.actions.add('inclusive-seed', self._add_inclusive_seed)
viewer.actions.add('exclusive-seed', self._add_exclusive_seed)
viewer.actions.add('next-component', self._next_component)
viewer.actions.add('prev-component', self._prev_component)
viewer.actions.add('new-component', self._make_new_component)
viewer.actions.add('exclude-component', self._exclude_component)
viewer.actions.add('exclude-all-but-component', self._exclude_all_but_component)
key_bindings = [
['bracketleft', 'prev-component'],
['bracketright', 'next-component'],
['at:dblclick0', 'exclude-component'],
['at:shift+mousedown2', 'exclude-all-but-component'],
['at:control+mousedown0', 'inclusive-seed'],
['at:shift+mousedown0', 'exclusive-seed'],
['enter', 'new-component'],
]
with viewer.txn() as s:
s.layers.append(
name='image',
layer=neuroglancer.ImageLayer(source=self.image_url),
)
s.layers.append(
name='original',
layer=neuroglancer.SegmentationLayer(
source=self.segmentation_url,
segments=self.agglo_members,
),
)
s.layers.append(
name='unused',
layer=neuroglancer.SegmentationLayer(source=self.segmentation_url,
),
visible=False,
)
s.layers.append(
name='split-result',
layer=neuroglancer.SegmentationLayer(
source=self.segmentation_url,
segments=self.agglo_members,
),
)
s.concurrent_downloads = 256
self._update_state(s)
with viewer.config_state.txn() as s:
s.status_messages['help'] = ('KEYS: ' + ' | '.join('%s=%s' % (key, command)
for key, command in key_bindings))
for key, command in key_bindings:
s.input_event_bindings.viewer[key] = command
s.input_event_bindings.slice_view[key] = command
s.input_event_bindings.perspective_view[key] = command
self._update_config_state(s)
viewer.shared_state.add_changed_callback(
lambda: viewer.defer_callback(self._handle_state_changed))
neuroglancer.cli.add_server_arguments(ap)
args = ap.parse_args()
neuroglancer.cli.handle_server_arguments(args)
viewer = neuroglancer.Viewer()
with viewer.txn() as s:
s.layers['image'] = neuroglancer.ImageLayer(
source=
'precomputed://gs://neuroglancer-public-data/flyem_fib-25/image',
panels=[
neuroglancer.LayerSidePanelState(
side='left',
col=0,
row=0,
tab='render',
tabs=['source', 'rendering'],
),
neuroglancer.LayerSidePanelState(
side='left',
col=0,
row=1,
tab='render',
tabs=['annotations'],
),
],
)
s.layers['ground_truth'] = neuroglancer.SegmentationLayer(
source=
'precomputed://gs://neuroglancer-public-data/flyem_fib-25/ground_truth',
)
print(viewer.state)
print(viewer)
