def _add_prefetch(s):
with viewer.config_state.txn() as s:
prefetch_state = copy.deepcopy(initial_state)
prefetch_state.partial_viewport = [0.5, 0, 0.5, 1]
s.prefetch = [
neuroglancer.PrefetchState(state=prefetch_state, priority=0)
]
def set_state(self, viewer, frame_i, prefetch_frames):
states = self.get_frames(frame_i, frame_i + prefetch_frames)
viewer.set_state(states[0])
with viewer.config_state.txn() as s:
del s.prefetch[:]
for i, state in enumerate(states[1:]):
s.prefetch.append(
neuroglancer.PrefetchState(state=state, priority=prefetch_frames - i))
def capture_screenshots(viewer, request_iter, refresh_browser_callback, refresh_browser_timeout, num_to_prefetch=1):
prefetch_buffer = list(itertools.islice(request_iter, num_to_prefetch + 1))
while prefetch_buffer:
with viewer.config_state.txn() as s:
s.show_ui_controls = False
s.show_panel_borders = False
del s.prefetch[:]
for i, request in enumerate(prefetch_buffer[1:]):
s.prefetch.append(neuroglancer.PrefetchState(state=request.state, priority=num_to_prefetch - i))
request = prefetch_buffer[0]
request.config_callback(s)
viewer.set_state(request.state)
print('%s [%s] Requesting screenshot' % (
datetime.datetime.now().strftime('%Y-%m-%dT%H:%M%S.%f'),
request.description,
))
last_statistics_time = time.time()
def statistics_callback(statistics):
nonlocal last_statistics_time
last_statistics_time = time.time()
total = statistics.total
print(
'%s [%s] Screenshot in progress: %6d/%6d chunks loaded (%10d bytes), %3d downloading'
% (
datetime.datetime.now().strftime('%Y-%m-%dT%H:%M%S.%f'),
request.description,
total.visible_chunks_gpu_memory,
total.visible_chunks_total,
total.visible_gpu_memory,
total.visible_chunks_downloading,
))
event = threading.Event()
screenshot = None
def result_callback(s):
nonlocal screenshot
screenshot = s.screenshot
event.set()
viewer.async_screenshot(
result_callback,
include_depth=request.include_depth,
statistics_callback=statistics_callback,
)
def get_timeout():
return max(0, last_statistics_time + refresh_browser_timeout - time.time())
while True:
if event.wait(get_timeout()):
break
if get_timeout() > 0:
continue
last_statistics_time = time.time()
refresh_browser_callback()
request.response_callback(screenshot)
del prefetch_buffer[0]
next_request = next(request_iter, None)
if next_request is not None:
prefetch_buffer.append(next_request)
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 prefetch(self):
prefetch_states = []
for i in range(self.num_to_prefetch):
idx = self.index + (i + 1) * self.batch
if idx >= len(self.todo):
break
prefetch_state = copy.deepcopy(self.viewer.state)
prefetch_state.layers['seg'].segments = self.list_segments(idx)
prefetch_state.layout = '3d'
prefetch_states.append(prefetch_state)
with self.viewer.config_state.txn() as s:
s.prefetch = [
neuroglancer.PrefetchState(state=prefetch_state, priority=-i)
for i, prefetch_state in enumerate(prefetch_states)
]
def set_index(self, index):
if index == self.index:
return
body = self.bodies[index]
self.index = index
def modify_state_for_body(s, body):
s.layers['segmentation'].segments = frozenset([body.segment_id])
s.voxel_coordinates = body.bbox_start + body.bbox_size // 2
with self.viewer.txn() as s:
modify_state_for_body(s, body)
prefetch_states = []
for i in range(self.num_to_prefetch):
prefetch_index = self.index + i + 1
if prefetch_index >= len(self.bodies):
break
prefetch_state = copy.deepcopy(self.viewer.state)
prefetch_state.layout = '3d'
modify_state_for_body(prefetch_state, self.bodies[prefetch_index])
prefetch_states.append(prefetch_state)
with self.viewer.config_state.txn() as s:
s.prefetch = [
neuroglancer.PrefetchState(state=prefetch_state, priority=-i)
for i, prefetch_state in enumerate(prefetch_states)
]
label = self.state.body_labels.get(body.segment_id, '')
with self.viewer.config_state.txn() as s:
s.status_messages['status'] = (
'[Segment %d/%d : %d/%d voxels labeled = %.3f fraction] label=%s'
% (index, len(self.bodies), self.cumulative_voxels[index],
self.total_voxels,
self.cumulative_voxels[index] / self.total_voxels, label))
