def add_example_layers(state):
a = np.zeros((3, 100, 100, 100), dtype=np.uint8)
ix, iy, iz = np.meshgrid(*[np.linspace(0, 1, n) for n in a.shape[1:]], indexing='ij')
a[0, :, :, :] = np.abs(np.sin(4 * (ix + iy))) * 255
a[1, :, :, :] = np.abs(np.sin(4 * (iy + iz))) * 255
a[2, :, :, :] = np.abs(np.sin(4 * (ix + iz))) * 255
b = np.cast[np.uint32](np.floor(np.sqrt((ix - 0.5)**2 + (iy - 0.5)**2 + (iz - 0.5)**2) * 10))
b = np.pad(b, 1, 'constant')
dimensions = neuroglancer.CoordinateSpace(names=['x', 'y', 'z'],
units='nm',
scales=[10, 10, 10])
state.dimensions = dimensions
state.layers.append(
name='a',
layer=neuroglancer.LocalVolume(
data=a,
dimensions=neuroglancer.CoordinateSpace(
names=['c', 'x', 'y', 'z'],
units=['', 'nm', 'nm', 'nm'],
scales=[1, 10, 10, 10],
coordinate_arrays=[
neuroglancer.CoordinateArray(labels=['red', 'green', 'blue']), None, None, None
]),
voxel_offset=(0, 20, 30, 15),
))
state.layers.append(
name='b',
layer=neuroglancer.LocalVolume(
data=b,
dimensions=dimensions,
),
)
return a, b
def refresh(self):
"""Refresh both views"""
with self.moving_viewer.txn() as s:
s.dimensions = neuroglancer.CoordinateSpace(
names=["x", "y", "z"],
units=["µm"],
scales=self.moving_voxel_size)
layer(s,
self.IMAGE,
self.moving_image,
gray_shader,
self.moving_brightness,
voxel_size=self.moving_voxel_size)
with self.reference_viewer.txn() as s:
s.dimensions = neuroglancer.CoordinateSpace(
names=["x", "y", "z"],
units=["µm"],
scales=self.reference_voxel_size)
layer(s,
self.REFERENCE,
self.reference_image,
red_shader,
self.reference_brightness,
voxel_size=self.reference_voxel_size)
layer(s,
self.ALIGNMENT,
self.alignment_image,
green_shader,
self.moving_brightness,
voxel_size=self.moving_voxel_size)
if self.segmentation is not None:
seglayer(s, self.SEGMENTATION, self.segmentation)
def __init__(self, raw, embedding, mst, classifier):
self.raw = raw
self.embedding = embedding
self.classifier = classifier
self.mst = mst
self.points = []
self.mst_graph = nx.Graph()
self.mst_graph.add_weighted_edges_from(mst)
self.threshold = 0.5
self.raw_dimensions = neuroglancer.CoordinateSpace(
names=['z', 'y', 'x'],
units='nm',
scales=raw.voxel_size)
self.dimensions = neuroglancer.CoordinateSpace(
names=['c^', 'z', 'y', 'x'],
units=[''] + 3*['nm'],
scales=raw.voxel_size)
# if len(raw.shape) > 3:
# volume_shape = raw.shape[1:]
# else:
volume_shape = raw.shape
print(f"Creating segmentation layer with shape {volume_shape}")
#self.segmentation = np.arange(np.product(volume_shape),dtype=np.uint32)
#self.segmentation = self.segmentation.reshape(volume_shape)
self.segmentation = np.zeros(volume_shape, dtype=np.uint32)
self.segmentation_volume = neuroglancer.LocalVolume(
data=self.segmentation,
dimensions=self.raw_dimensions)
self.viewer = neuroglancer.Viewer()
self.viewer.actions.add('label_fg', self._label_fg)
self.viewer.actions.add('label_bg', self._label_bg)
self.viewer.actions.add('update_seg', self._update_segmentation)
with self.viewer.config_state.txn() as s:
s.input_event_bindings.data_view['shift+mousedown0'] = 'label_fg'
s.input_event_bindings.data_view['shift+mousedown1'] = 'label_bg'
s.input_event_bindings.data_view['keyu'] = 'update_seg'
with self.viewer.txn() as s:
add_layer(s, self.raw, 'raw')
add_layer(s, self.embedding, 'embedding')
s.layers['embedding'].visible = False
s.layers['points'] = neuroglancer.LocalAnnotationLayer(
self.dimensions)
s.layers['segmentation'] = neuroglancer.SegmentationLayer(
source=self.segmentation_volume)
def useLayer(self, numLayers):
# Store as ProjectionArray
self.img2 = ProjectionArray(self.img, numLayers)
dimensions = neuroglancer.CoordinateSpace(
names=['z', 'y', 'x'],
units='nm',
scales=[10, 10, 10])
with self.viewer.txn() as s:
s.dimensions = dimensions
s.layers.clear()
s.layers.append(
name='Original Image',
layer=neuroglancer.LocalVolume(
data=self.img,
dimensions=neuroglancer.CoordinateSpace(
names=['c^', 'x', 'y', 'z'],
units=['', 'nm', 'nm', 'nm'],
scales=[1, 10, 10, 10]),
voxel_offset=(0, 0, 0, 0),
),
shader='''
void main() {
emitRGB(vec3(toNormalized(getDataValue(0)),
toNormalized(getDataValue(1)),
toNormalized(getDataValue(2))));
}
''')
s.layers.append(
name='Z-Projection Image',
layer=neuroglancer.LocalVolume(
data=self.img2,
dimensions=neuroglancer.CoordinateSpace(
names=['c^', 'x', 'y', 'z'],
units=['', 'nm', 'nm', 'nm'],
scales=[1, 10, 10, 10]),
voxel_offset=(0, 0, 0, 0),
),
shader='''
void main() {
emitRGB(vec3(toNormalized(getDataValue(0)),
toNormalized(getDataValue(1)),
toNormalized(getDataValue(2))));
}
''')
s.layers['Original Image'] = s.layers[0]
s.layers['Z-Projection Image'] = s.layers[1]
s.layout = neuroglancer.row_layout([
neuroglancer.LayerGroupViewer(layers=['Original Image']),
neuroglancer.LayerGroupViewer(layers=['Z-Projection Image']),
])
def test_segment_colors(webdriver):
a = np.array([[[42]]], 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.SegmentationLayer(
source=neuroglancer.LocalVolume(data=a,
dimensions=s.dimensions),
segment_colors={42: '#f00'},
),
)
s.layout = 'xy'
s.cross_section_scale = 1e-6
s.show_axis_lines = False
assert list(s.layers[0].segment_colors.keys()) == [42]
assert s.layers[0].segment_colors[42] == '#f00'
screenshot_response = webdriver.viewer.screenshot(size=[10, 10])
assert screenshot_response.viewer_state.layers[0].segment_colors[
42] == '#ff0000'
screenshot = screenshot_response.screenshot
np.testing.assert_array_equal(
screenshot.image_pixels,
np.tile(np.array([255, 0, 0, 255], dtype=np.uint8), (10, 10, 1)))
with webdriver.viewer.txn() as s:
s.layers[0].segment_colors[42] = '#0f0'
screenshot_response = webdriver.viewer.screenshot(size=[10, 10])
assert screenshot_response.viewer_state.layers[0].segment_colors[
42] == '#00ff00'
screenshot = screenshot_response.screenshot
np.testing.assert_array_equal(
screenshot.image_pixels,
np.tile(np.array([0, 255, 0, 255], dtype=np.uint8), (10, 10, 1)))
def test_create_nghandledimensionslayer(self):
"""Check if the dimensions are handled."""
dimensions = ng.CoordinateSpace(names=['x', 'y', 'z'], units='um', scales=[1, 1, 1])
dimensions2 = _handle_ngdimensions(layer_kws={'dimensions': dimensions})
assert dimensions2 == dimensions
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 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 _handle_ngdimensions(layer_kws):
"""Return the dimensions of different neuroglancer spaces."""
# return dimensions either based on already set ngspace or a string 'ngspace'.
dimensions = None
if 'ngspace' in sys.modules:
layer_kws['ngspace'] = sys.modules['ngspace']
if 'dimensions' in layer_kws:
dimensions = layer_kws['dimensions']
if 'ngspace' in layer_kws:
ngspace = _get_ngspace(layer_kws)
print('Dimensions are in :', ngspace['ngspace'])
dimensions = neuroglancer.CoordinateSpace(
names=['x', 'y', 'z'],
units=ngspace['dimension']['units'],
scales=[
ngspace['dimension']['x'], ngspace['dimension']['y'],
ngspace['dimension']['z']
])
if dimensions is None:
raise ValueError(
"dimensions is not set already: either use 'ngspace' or 'dimensions'"
)
return dimensions
def seglayer(txn,
name,
seg,
dimensions=None,
offx=0,
offy=0,
offz=0,
voxel_size=default_voxel_size):
"""Add a segmentation layer
:param txn: the neuroglancer transaction
:param name: the display name of the segmentation
:param seg: the segmentation to display
"""
if isinstance(seg, str):
source = seg
else:
if dimensions is None:
dim_names = ["xyzct"[d] for d in range(seg.ndim)]
dim_units = ["µm"] * seg.ndim
dim_scales = [1.0] * seg.ndim
dimensions = neuroglancer.CoordinateSpace(names=dim_names,
units=dim_units,
scales=dim_scales)
source = neuroglancer.LocalVolume(data=reverse_dimensions(
seg.astype(np.uint16)),
dimensions=dimensions,
voxel_offset=(offx, offy, offz))
txn.layers[name] = neuroglancer.SegmentationLayer(source=source)
def add_volume(self, colored=True):
volume_filepath = os.path.join(self.local_volume_fp_root, self.stack,
'human_annotation/solid_volume_5um')
if colored:
volume_fn = 'volume_colored.npy'
color_segments = []
for i in range(1, 50):
color_segments.append(i)
else:
volume_fn = 'volume.npy'
xy_ng_resolution_um = 5
volume_data = np.load(os.path.join(volume_filepath, volume_fn))
# deprecated voxel_size = [xy_ng_resolution_um * 1000, xy_ng_resolution_um * 1000, 20000], # X Y Z
dims = neuroglancer.CoordinateSpace(names=['x', 'y', 'z'],
units=['nm', 'nm', 'nm'],
scales=[10, 10, 10])
with self.viewer.txn() as s:
s.layers[self.stack +
"_Annotations"] = neuroglancer.SegmentationLayer(
source=neuroglancer.LocalVolume(
data=volume_data, # Z,Y,X
dimensions=dims,
voxel_offset=[0, 0, 0] # X Y Z
),
segments=color_segments)
def add_layer(context, array, name, visible=True, **kwargs):
array_dims = len(array.shape)
voxel_size = array.voxel_size[-3:]
attrs = {
2: {
"names": ["y", "x"],
"units": "nm",
"scales": voxel_size
},
3: {
"names": ["z", "y", "x"],
"units": "nm",
"scales": voxel_size
},
4: {
"names": ["c^", "z", "y", "x"],
"units": ["", "nm", "nm", "nm"],
"scales": [1, *voxel_size],
},
}
dimensions = neuroglancer.CoordinateSpace(**attrs[array_dims])
print(array_dims, array.roi.get_offset())
offset = np.array((0, ) * (array_dims - 3) + array.roi.get_offset()[-3:])
offset = offset // attrs[array_dims]["scales"]
# if len(offset) == 2:
# offset = (0,) + tuple(offset)
d = np.asarray(array.data)
if array.data.dtype == np.dtype(bool):
array.data = np.array(d, dtype=np.float32)
channels = ",".join([
f"toNormalized(getDataValue({i}))" if i < array.shape[0] else "0"
for i in range(3)
])
shader_4d = ("""
void main() {
emitRGB(vec3(%s));
}
""" % channels)
shader_3d = """
void main () {
emitGrayscale(toNormalized(getDataValue()));
}"""
print(offset)
layer = neuroglancer.LocalVolume(data=array.data,
dimensions=dimensions,
voxel_offset=tuple(offset))
if array.data.dtype == np.dtype(np.uint64):
context.layers.append(name=name, layer=layer, visible=visible)
else:
context.layers.append(
name=name,
layer=layer,
visible=visible,
shader=shader_4d if array_dims == 4 else shader_3d,
**kwargs,
)
def dimensions_from_volume(array):
voxel_size = array.voxel_size
spatial_dims = 3
attrs = {"names": ["z", "y", "x"], "units": "nm", "scales": voxel_size}
dimensions = neuroglancer.CoordinateSpace(**attrs)
offset = np.array(array.roi.get_offset())
offset = offset // attrs["scales"]
return dimensions, offset, array.shape[-spatial_dims:]
def __init__(self, source, units='nm', scales=[1, 1, 1], **kwargs):
self.dimensions = neuroglancer.CoordinateSpace(names=['x', 'y', 'z'],
units=units,
scales=scales)
props = copy.deepcopy(self.DEFAULTS)
props['source'] = LocalMeshSource(source, self.dimensions, **kwargs)
props.update(**kwargs)
super().__init__(**props)
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 add_stack(vol, viewer, name):
volume_layer = neuroglancer.LocalVolume(
data=vol,
dimensions=neuroglancer.CoordinateSpace(names=['x', 'y', 'z'],
units='um',
scales=[10.4, 10.4, 20]),
voxel_offset=(0, 0, 0))
with viewer.txn() as s:
s.layers.append(name=name, layer=volume_layer)
def add_layer(context, array, name, visible=True, **kwargs):
array_dims = len(array.shape)
voxel_size = array.voxel_size
attrs = {
3: {"names": ["z", "y", "x"], "units": "nm", "scales": voxel_size},
4: {
"names": ["c^", "z", "y", "x"],
"units": ["", "nm", "nm", "nm"],
"scales": [1, *voxel_size],
},
}
dimensions = neuroglancer.CoordinateSpace(**attrs[array_dims])
offset = np.array((0,) * (array_dims - 3) + array.roi.get_offset())
offset = offset // attrs[array_dims]["scales"]
if len(array.shape) > 3 and array.shape[0] > 3:
pca = PCA(n_components=3)
flattened = array.to_ndarray().reshape(array.shape[0], -1).T
fitted = pca.fit_transform(flattened).T
array.data = fitted.reshape((3,) + array.shape[1:])
# d = np.asarray(array.data)
# if array.data.dtype == np.dtype(bool):
# array.data = np.array(d, dtype=np.float32)
channels = ",".join(
[
f"toNormalized(getDataValue({i}))" if i < array.shape[0] else "0"
for i in range(3)
]
)
shader_4d = (
"""
void main() {
emitRGB(vec3(%s));
}
"""
% channels
)
shader_3d = None
layer = neuroglancer.LocalVolume(
data=array.data, dimensions=dimensions, voxel_offset=tuple(offset)
)
if array.data.dtype == np.dtype(np.uint64):
context.layers.append(name=name, layer=layer, visible=visible)
else:
context.layers.append(
name=name,
layer=layer,
visible=visible,
shader=shader_4d if array_dims == 4 else shader_3d,
**kwargs,
)
def add_example_layers(state):
a = np.zeros((3, 100, 100, 100), dtype=np.uint8)
ix, iy, iz = np.meshgrid(*[np.linspace(0, 1, n) for n in a.shape[1:]],
indexing='ij')
a[0, :, :, :] = np.abs(np.sin(4 * (ix + iy))) * 255
a[1, :, :, :] = np.abs(np.sin(4 * (iy + iz))) * 255
a[2, :, :, :] = np.abs(np.sin(4 * (ix + iz))) * 255
b = np.cast[np.uint32](np.floor(
np.sqrt((ix - 0.5)**2 + (iy - 0.5)**2 + (iz - 0.5)**2) * 10))
b = np.pad(b, 1, 'constant')
dimensions = neuroglancer.CoordinateSpace(names=['x', 'y', 'z'],
units='nm',
scales=[10, 10, 10])
state.dimensions = dimensions
state.layers.append(
name='a',
layer=neuroglancer.LocalVolume(
data=a,
dimensions=neuroglancer.CoordinateSpace(
names=['c^', 'x', 'y', 'z'],
units=['', 'nm', 'nm', 'nm'],
scales=[1, 10, 10, 10]),
voxel_offset=(0, 20, 30, 15),
),
shader="""
void main() {
emitRGB(vec3(toNormalized(getDataValue(0)),
toNormalized(getDataValue(1)),
toNormalized(getDataValue(2))));
}
""",
)
state.layers.append(
name='b',
layer=neuroglancer.LocalVolume(
data=b,
dimensions=dimensions,
),
)
return a, b
def setup_viewer(viewer, dtype, value, layer_type):
a = np.array([[[value]]], dtype=dtype)
with viewer.txn() as s:
s.dimensions = neuroglancer.CoordinateSpace(names=["x", "y", "z"],
units="nm",
scales=[1, 1, 1])
s.layers.append(
name="a",
layer=layer_type(source=neuroglancer.LocalVolume(
data=a, dimensions=s.dimensions), ),
)
s.layout = 'xy'
s.cross_section_scale = 1e-6
s.show_axis_lines = False
def _append_synapse_annotation_layer(
self, viewer_state: ng.viewer_state.ViewerState, name: str,
synapses: Synapses):
annotations = []
pre_synapses = synapses.pre_with_physical_coordinate
self._append_point_annotation_layer(viewer_state, name + '_pre',
pre_synapses)
post_synapses = synapses.post_with_physical_coordinate
if post_synapses is not None:
for post_idx in range(post_synapses.shape[0]):
pre_idx = post_synapses[post_idx, 0]
pre_coordinate = pre_synapses[pre_idx, :]
post_coordinate = post_synapses[post_idx, 1:]
post_annotation = ng.LineAnnotation(
id=str(post_idx),
# note that the synapse coordinate is already in xyz order
# so we do not need to reverse it!
pointA=pre_coordinate,
pointB=post_coordinate,
props=['#0ff', 5])
annotations.append(post_annotation)
viewer_state.layers.append(
name=name,
layer=ng.LocalAnnotationLayer(
dimensions=ng.CoordinateSpace(names=['z', 'y', 'x'],
units="nm",
scales=(1, 1, 1)),
annotation_properties=[
ng.AnnotationPropertySpec(
id='color',
type='rgb',
default='red',
),
ng.AnnotationPropertySpec(id='size',
type='float32',
default=5)
],
annotations=annotations,
shader='''
void main() {
setColor(prop_color());
setPointMarkerSize(prop_size());
}
''',
),
)
def dimensions_from_guess(dataset, graph):
locations = dataset[f"{graph}-locations"][()]
lower = locations.min(axis=0)
upper = locations.max(axis=0)
voxel_size = [1000, 300, 300]
lower -= lower % voxel_size
upper += voxel_size - upper % voxel_size
shape = ((upper - lower) / voxel_size).astype(int)
attrs = {"names": ["z", "y", "x"], "units": "nm", "scales": voxel_size}
dimensions = neuroglancer.CoordinateSpace(**attrs)
offset = np.array(lower)
offset = offset // voxel_size
return dimensions, offset, shape
def test_mesh_silhouette(webdriver):
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.SegmentationLayer(
source=neuroglancer.LocalVolume(data=np.zeros((10, 10, 10),
dtype=np.uint8),
dimensions=s.dimensions),
mesh_silhouette_rendering=2),
)
state = webdriver.sync()
assert state.layers['a'].mesh_silhouette_rendering == 2
def pointlayer(txn,
name,
x,
y,
z,
color="yellow",
size=5,
shader=pointlayer_shader,
voxel_size=default_voxel_size):
"""Add a point layer.
:param txn: the neuroglancer viewer transaction context
:param name: the displayable name of the point layer
:param x: the x coordinate per point
:param y: the y coordinate per point
:param z: the z coordinate per point
:param color: the color of the points in the layer, e.g. "red", "yellow"
:param size: the size of the points
:param voxel_size: the size of a voxel (x, y, z)
"""
dimensions = neuroglancer.CoordinateSpace(names=["x", "y", "z"],
units=["µm", "µm", "µm"],
scales=voxel_size)
layer = neuroglancer.LocalAnnotationLayer(
dimensions=dimensions,
annotation_properties=[
neuroglancer.AnnotationPropertySpec(
id='color',
type='rgb',
default=color,
),
neuroglancer.AnnotationPropertySpec(
id='size',
type='float32',
default=float(size),
)
],
annotations=[
neuroglancer.PointAnnotation(
id=i + 1, point=[zz, yy,
xx]) # input points should be in zyx order
for i, (xx, yy, zz) in enumerate(zip(x, y, z))
],
shader=shader)
txn.layers[name] = layer
def add_example_layer(state):
ix, iy, iz = np.meshgrid(*[np.linspace(0, 1, n) for n in [100, 100, 100]], indexing='ij')
b = np.cast[np.int32](np.floor(np.sqrt((ix - 0.5)**2 + (iy - 0.5)**2 + (iz - 0.5)**2) * 10)) - 2
b = np.pad(b, 1, 'constant')
dimensions = neuroglancer.CoordinateSpace(names=['x', 'y', 'z'],
units='nm',
scales=[10, 10, 10])
state.dimensions = dimensions
state.layers.append(
name='b',
layer=neuroglancer.SegmentationLayer(source=neuroglancer.LocalVolume(
data=b,
dimensions=dimensions,
)),
)
return b
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 dims_from_guess(graph):
locations = np.array([attrs["location"] for attrs in graph.nodes.values()])
try:
lower = locations.min(axis=0)
upper = locations.max(axis=0)
except:
lower = np.array([0, 0, 0])
upper = np.array([0, 0, 0])
voxel_size = [1000, 300, 300]
lower -= lower % voxel_size
upper += voxel_size - upper % voxel_size
shape = ((upper - lower) / voxel_size).astype(int)
attrs = {"names": ["z", "y", "x"], "units": "nm", "scales": voxel_size}
dimensions = neuroglancer.CoordinateSpace(**attrs)
offset = np.array(lower)
offset = offset // voxel_size
return dimensions, offset, shape
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 test_linked_segmentation_group(webdriver):
a = np.array([[[42]]], dtype=np.uint8)
b = np.array([[[43]]], 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.SegmentationLayer(
source=neuroglancer.LocalVolume(data=a,
dimensions=s.dimensions),
segment_default_color='#f00',
segments=[43],
),
visible=False,
)
s.layers.append(
name="b",
layer=neuroglancer.SegmentationLayer(
source=neuroglancer.LocalVolume(data=b,
dimensions=s.dimensions),
linked_segmentation_group='a',
),
)
s.layout = 'xy'
s.cross_section_scale = 1e-6
s.show_axis_lines = False
screenshot_response = webdriver.viewer.screenshot(size=[10, 10])
assert screenshot_response.viewer_state.layers[
0].segment_default_color == '#ff0000'
screenshot = screenshot_response.screenshot
np.testing.assert_array_equal(
screenshot.image_pixels,
np.tile(np.array([255, 0, 0, 255], dtype=np.uint8), (10, 10, 1)))
with webdriver.viewer.txn() as s:
s.layers[1].linked_segmentation_color_group = False
s.layers[1].segment_default_color = '#0f0'
screenshot_response = webdriver.viewer.screenshot(size=[10, 10])
screenshot = screenshot_response.screenshot
np.testing.assert_array_equal(
screenshot.image_pixels,
np.tile(np.array([0, 255, 0, 255], dtype=np.uint8), (10, 10, 1)))
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])
