def set_state_index(self, index):
self._grab_viewer_state()
self.state_index = index
if index is None:
self.viewer.set_state(neuroglancer.ViewerState())
else:
new_state = copy.deepcopy(self.states[index])
anno_layer = new_state.layers[self.annotation_layer_name]
if anno_layer.annotation_fill_opacity == 0:
anno_layer.annotation_fill_opacity = 0.7
anno_layer.annotation_color = 'black'
anno_layer.annotations = normalize_block_annotations(
anno_layer.annotations,
block_size=self.false_merge_block_size,
max_level=self.max_false_merge_block_levels)
self.viewer.set_state(new_state)
other_ids = self.other_state_segment_ids
other_ids.clear()
other_ids[0] = -1
for i, state in enumerate(self.states):
if i == self.state_index:
continue
for x in self.get_state_segment_ids(state):
other_ids[x] = i
self.update_message()
def load(self):
if not os.path.exists(self.filename):
return False
self.state_index = None
with open(self.filename, 'r') as f:
loaded_state = decode_json(f.read())
self.states = [neuroglancer.ViewerState(x) for x in loaded_state['states']]
self.set_state_index(loaded_state['state_index'])
return True
def render_func(viewer, start_frame, end_frame):
with lock:
saver = neuroglancer.ScreenshotSaver(viewer, args.output_directory)
states_to_capture = []
frame_number = 0
for i in range(len(keypoints) - 1):
a = keypoints[i]['state']
b = keypoints[i + 1]['state']
duration = keypoints[i]['transition_duration']
num_frames = max(1, int(duration * fps))
for frame_i in range(num_frames):
t = frame_i / num_frames
if frame_number >= end_frame:
return
if frame_number < start_frame:
frame_number += 1
continue
path = saver.get_path(frame_number)
if args.resume and os.path.exists(path):
frame_number += 1
with lock:
num_frames_written[0] += 1
else:
cur_state = neuroglancer.ViewerState.interpolate(a, b, t)
states_to_capture.append((frame_number, i + t, cur_state))
frame_number += 1
for frame_number, t, cur_state in states_to_capture:
prefetch_states = [
x[2] for x in states_to_capture[frame_number + 1:frame_number +
1 + num_prefetch_frames]
]
prev_state = viewer.state.to_json()
cur_state = cur_state.to_json()
cur_state['layers'] = prev_state['layers']
cur_state = neuroglancer.ViewerState(cur_state)
viewer.set_state(cur_state)
if num_prefetch_frames > 0:
with viewer.config_state.txn() as s:
del s.prefetch[:]
for i, state in enumerate(prefetch_states[1:]):
s.prefetch.append(
neuroglancer.PrefetchState(
state=state, priority=num_prefetch_frames - i))
frame_number, path = saver.capture(frame_number)
with lock:
num_frames_written[0] += 1
cur_num_frames_written = num_frames_written[0]
print('[%07d/%07d] keypoint %.3f/%5d: %s' %
(cur_num_frames_written, total_frames, t, len(keypoints),
path))
def load(self):
if not os.path.exists(self.filename):
return False
self.state_index = None
with open(self.filename, 'r') as f:
loaded_state = json.load(f,
object_pairs_hook=collections.OrderedDict)
self.states = [
neuroglancer.ViewerState(x) for x in loaded_state['states']
]
self.set_state_index(loaded_state['state_index'])
return True
def set_state_index(self, index):
self._grab_viewer_state()
self.state_index = index
if index is None:
self.viewer.set_state(neuroglancer.ViewerState())
else:
self.viewer.set_state(self.states[index])
other_ids = self.other_state_segment_ids
other_ids.clear()
other_ids[0] = -1
for i, state in enumerate(self.states):
if i == self.state_index:
continue
for x in self.get_state_segment_ids(state):
other_ids[x] = i
self.update_message()
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 add_segments_from_state(self, base_state):
if isinstance(base_state, basestring):
base_state = neuroglancer.parse_url(base_state)
elif isinstance(base_state, dict):
base_state = neuroglancer.ViewerState(base_state)
segment_ids = self.get_state_segment_ids(base_state)
existing_segment_ids = self.get_existing_segment_ids()
for segment_id in segment_ids:
if segment_id in existing_segment_ids:
print('Skipping redundant segment id %d' % segment_id)
continue
self.states.append(self.make_initial_state(segment_id, base_state))
if self.state_index is None:
self.next_state()
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__)
