def _analyze(self, cellanalyzer):
super(PositionAnalyzer, self)._analyze()
n_images = 0
stopwatch = StopWatch(start=True)
crd = Coordinate(self.plate_id, self.position,
self._frames, list(set(self.ch_mapping.values())))
minimal_effort = self.settings.get('Output', 'minimal_effort') and self.settings.get('Output', 'hdf5_reuse')
for frame, channels in self._imagecontainer( \
crd, interrupt_channel=True, interrupt_zslice=True):
if self.is_aborted():
self.clear()
return 0
else:
txt = 'T %d (%d/%d)' %(frame, self._frames.index(frame)+1,
len(self._frames))
self.update_status({'progress': self._frames.index(frame)+1,
'text': txt,
'interval': stopwatch.interim()})
stopwatch.reset(start=True)
cellanalyzer.initTimepoint(frame)
self.register_channels(cellanalyzer, channels)
cellanalyzer.process()
self.logger.info(" - Frame %d, cellanalyzer.process (ms): %3d" \
%(frame, stopwatch.interval()*1000))
n_images += 1
images = []
if self.settings('Processing', 'tracking'):
region = self.settings('Tracking', 'region')
samples = self.timeholder[frame][PrimaryChannel.NAME].get_region(region)
self._tracker.track_next_frame(frame, samples)
if self.settings('Tracking', 'tracking_visualization'):
size = cellanalyzer.getImageSize(PrimaryChannel.NAME)
nframes = self.settings('Tracking', 'tracking_visualize_track_length')
radius = self.settings('Tracking', 'tracking_centroid_radius')
img_conn, img_split = self._tracker.render_tracks(
frame, size, nframes, radius)
images += [(img_conn, '#FFFF00', 1.0),
(img_split, '#00FFFF', 1.0)]
self.logger.info(" - Frame %d, Tracking (ms): %3d" \
%(frame, stopwatch.interval()*1000))
# can't cluster on a per frame basis
if self.settings("EventSelection", "supervised_event_selection"):
for clf in self.classifiers.itervalues():
cellanalyzer.classify_objects(clf)
self.logger.info(" - Frame %d, Classification (ms): %3d" \
% (frame, stopwatch.interval()*1000))
self.settings.set_section('General')
# want emit all images at once
if not minimal_effort:
imgs = {}
imgs.update(self.render_classification_images(cellanalyzer, images, frame))
imgs.update(self.render_contour_images(cellanalyzer, images, frame))
msg = 'PL %s - P %s - T %05d' %(self.plate_id, self.position, frame)
self.set_image(imgs, msg, 50)
if self.settings('Output', 'rendering_channel_gallery'):
self.render_channel_gallery(cellanalyzer, frame)
if self.settings('Output', 'rendering_labels_discwrite'):
cellanalyzer.exportLabelImages(self._labels_dir)
cellanalyzer.purge(features=self.export_features)
self.logger.info(" - Frame %d, rest (ms): %3d" \
%(frame, stopwatch.interval()*1000))
self.logger.info(" - Frame %d, duration (ms): %3d" \
%(frame, stopwatch.interim()*1000))
return n_images
def _analyze(self, cellanalyzer):
super(PositionAnalyzer, self)._analyze()
n_images = 0
stopwatch = StopWatch(start=True)
crd = Coordinate(self.plate_id, self.position,
self._frames, list(set(self.ch_mapping.values())))
minimal_effort = self.settings.get('Output', 'minimal_effort') and self.settings.get('Output', 'hdf5_reuse')
for frame, channels in self._imagecontainer( \
crd, interrupt_channel=True, interrupt_zslice=True):
if self.is_aborted():
self.clear()
return 0
else:
txt = 'T %d (%d/%d)' %(frame, self._frames.index(frame)+1,
len(self._frames))
self.update_status({'progress': self._frames.index(frame)+1,
'text': txt,
'interval': stopwatch.interim()})
stopwatch.reset(start=True)
cellanalyzer.initTimepoint(frame)
self.register_channels(cellanalyzer, channels)
cellanalyzer.process()
self.logger.info(" - Frame %d, cellanalyzer.process (ms): %3d" \
%(frame, stopwatch.interval()*1000))
n_images += 1
images = []
if self.settings('Processing', 'tracking'):
region = self.settings('Tracking', 'region')
samples = self.timeholder[frame][PrimaryChannel.NAME].get_region(region)
self._tracker.track_next_frame(frame, samples)
if self.settings('Tracking', 'tracking_visualization'):
size = cellanalyzer.getImageSize(PrimaryChannel.NAME)
nframes = self.settings('Tracking', 'tracking_visualize_track_length')
radius = self.settings('Tracking', 'tracking_centroid_radius')
img_conn, img_split = self._tracker.render_tracks(
frame, size, nframes, radius)
images += [(img_conn, '#FFFF00', 1.0),
(img_split, '#00FFFF', 1.0)]
self.logger.info(" - Frame %d, Tracking (ms): %3d" \
%(frame, stopwatch.interval()*1000))
# can't cluster on a per frame basis
if self.settings("EventSelection", "supervised_event_selection"):
for clf in self.classifiers.itervalues():
cellanalyzer.classify_objects(clf)
self.logger.info(" - Frame %d, Classification (ms): %3d" \
% (frame, stopwatch.interval()*1000))
self.settings.set_section('General')
# want emit all images at once
if not minimal_effort:
imgs = {}
imgs.update(self.render_classification_images(cellanalyzer, images, frame))
imgs.update(self.render_contour_images(cellanalyzer, images, frame))
msg = 'PL %s - P %s - T %05d' %(self.plate_id, self.position, frame)
self.set_image(imgs, msg, 50)
if self.settings('Output', 'rendering_channel_gallery'):
self.render_channel_gallery(cellanalyzer, frame)
if self.settings('Output', 'rendering_labels_discwrite'):
cellanalyzer.exportLabelImages(self._labels_dir)
cellanalyzer.purge(features=self.export_features)
self.logger.info(" - Frame %d, rest (ms): %3d" \
%(frame, stopwatch.interval()*1000))
self.logger.info(" - Frame %d, duration (ms): %3d" \
%(frame, stopwatch.interim()*1000))
return n_images
def _analyze(self, cellanalyzer):
thread = QThread.currentThread()
stopwatch = StopWatch(start=True)
crd = Coordinate(self.plate_id, self.position, self._frames,
list(set(self.ch_mapping.values())))
for frame, channels in self._imagecontainer( \
crd, interrupt_channel=True, interrupt_zslice=True):
self.interruptionPoint()
txt = '%s, %s, T %d (%d/%d)' \
%(self.plate_id, self.position, frame,
self._frames.index(frame)+1, len(self._frames))
self.statusUpdate(text=txt,
interval=stopwatch.interim(),
increment=True)
stopwatch.reset(start=True)
cellanalyzer.initTimepoint(frame)
self.register_channels(cellanalyzer, channels)
cellanalyzer.process()
self.logger.debug(" - Frame %d, cellanalyzer.process (ms): %3d" \
%(frame, stopwatch.interval()*1000))
images = []
if self.settings('Processing', 'tracking'):
apc = AppPreferences()
region = self.settings('Tracking', 'region')
samples = self.timeholder[frame][
PrimaryChannel.NAME].get_region(region)
self._tracker.track_next_frame(frame, samples)
if apc.display_tracks:
size = cellanalyzer.getImageSize(PrimaryChannel.NAME)
img_conn, img_split = self._tracker.render_tracks(
frame, size, apc.track_length, apc.cradius)
images += [(img_conn, '#FFFF00', 1.0),
(img_split, '#00FFFF', 1.0)]
self.logger.debug(" - Frame %d, Tracking (ms): %3d" \
%(frame, stopwatch.interval()*1000))
# can't cluster on a per frame basis
if self.settings("EventSelection", "supervised_event_selection"):
for channel, clf in self.classifiers.iteritems():
cellanalyzer.classify_objects(clf, channel)
self.logger.debug(" - Frame %d, Classification (ms): %3d" \
% (frame, stopwatch.interval()*1000))
self.settings.set_section('General')
# want emit all images at once
imgs = {}
imgs.update(
self.render_classification_images(cellanalyzer, images, frame))
imgs.update(self.render_contour_images(cellanalyzer, images,
frame))
msg = 'PL %s - P %s - T %05d' % (self.plate_id, self.position,
frame)
self.setImage(imgs, msg, 50)
cellanalyzer.purge(features=self.export_features)
self.logger.debug(" - Frame %d, duration (ms): %3d" \
%(frame, stopwatch.interim()*1000))
