def _analyze(self, cellanalyzer):
super(PositionPicker, self)._analyze()
n_images = 0
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):
if self.is_aborted():
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)
# initTimepoint clears channel_registry
cellanalyzer.initTimepoint(frame)
self.register_channels(cellanalyzer, channels)
image = cellanalyzer.collectObjects(self.plate_id,
self.position,
self.sample_readers,
self.learner,
byTime=True)
if image is not None:
n_images += 1
msg = 'PL %s - P %s - T %05d' %(self.plate_id, self.position,
frame)
self.set_image(image[self._qthread.renderer],
msg, region=self._qthread.renderer)
def _analyze(self, cellanalyzer):
n_images = 0
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):
if self.isAborted():
self.clear()
return 0
else:
txt = 'T %d (%d/%d)' % (frame, self._frames.index(frame) + 1,
len(self._frames))
self.statusUpdate(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.setup_classifiers()
for chname, clf in self.classifiers.iteritems():
try:
cellanalyzer.classify_objects(clf, chname)
except KeyError as e:
pass
def _analyze(self, cellanalyzer):
super(PositionPicker, self)._analyze()
n_images = 0
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):
if self.is_aborted():
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)
# initTimepoint clears channel_registry
cellanalyzer.initTimepoint(frame)
self.register_channels(cellanalyzer, channels)
image = cellanalyzer.collectObjects(self.plate_id,
self.position,
self.sample_readers,
self.learner,
byTime=True)
if image is not None:
n_images += 1
msg = 'PL %s - P %s - T %05d' %(self.plate_id, self.position,
frame)
self.set_image(image, msg)
def _analyze(self, cellanalyzer):
thread = QThread.currentThread()
imax = sum([len(n) for n in self.sample_positions.values()])
thread.statusUpdate(min=0, max=imax)
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):
thread.interruption_point()
txt = '%s, %s, T %d, (%d/%d)' \
%(self.plate_id, self.position,
frame, self._frames.index(frame)+1, len(self._frames))
thread.statusUpdate(meta="Classifier training: ",
text=txt, interval=stopwatch.interim(), increment=True)
stopwatch.reset(start=True)
# initTimepoint clears channel_registry
cellanalyzer.initTimepoint(frame)
self.register_channels(cellanalyzer, channels)
cellanalyzer.collectObjects(self.plate_id, self.position, self.sample_readers,
self.learner)
def _analyze(self, cellanalyzer):
n_images = 0
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):
if self.isAborted():
self.clear()
return 0
else:
txt = 'T %d (%d/%d)' %(frame, self._frames.index(frame)+1,
len(self._frames))
self.statusUpdate(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.setup_classifiers()
for chname, clf in self.classifiers.iteritems():
try:
cellanalyzer.classify_objects(clf, chname)
except KeyError as e:
pass
def _analyze(self, cellanalyzer):
thread = QThread.currentThread()
imax = sum([len(n) for n in self.sample_positions.values()])
thread.statusUpdate(min=0, max=imax)
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):
thread.interruption_point()
txt = '%s, %s, T %d, (%d/%d)' \
%(self.plate_id, self.position,
frame, self._frames.index(frame)+1, len(self._frames))
thread.statusUpdate(meta="Classifier training: ",
text=txt,
interval=stopwatch.interim(),
increment=True)
stopwatch.reset(start=True)
# initTimepoint clears channel_registry
cellanalyzer.initTimepoint(frame)
self.register_channels(cellanalyzer, channels)
cellanalyzer.collectObjects(self.plate_id, self.position,
self.sample_readers, self.learner)
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())))
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()
n_images += 1
images = []
if self.settings.get('Processing', 'tracking'):
region = self.settings.get('Tracking', 'tracking_regionname')
samples = self.timeholder[frame][PrimaryChannel.NAME].get_region(region)
self._tracker.track_next_frame(frame, samples)
if self.settings.get('Tracking', 'tracking_visualization'):
size = cellanalyzer.getImageSize(PrimaryChannel.NAME)
nframes = self.settings.get('Tracking', 'tracking_visualize_track_length')
radius = self.settings.get('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)]
for clf in self.classifiers.itervalues():
cellanalyzer.classify_objects(clf)
##############################################################
# FIXME - part for browser
if not self._myhack is None:
self.render_browser(cellanalyzer)
##############################################################
self.settings.set_section('General')
self.render_classification_images(cellanalyzer, images, frame)
self.render_contour_images(cellanalyzer, images, frame)
if self.settings.get('Output', 'rendering_channel_gallery'):
self.render_channel_gallery(cellanalyzer, frame)
if self.settings.get('Output', 'rendering_labels_discwrite'):
cellanalyzer.exportLabelImages(self._labels_dir)
self.logger.info(" - Frame %d, duration (ms): %3d" \
%(frame, stopwatch.interim()*1000))
cellanalyzer.purge(features=self.export_features)
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 _run(self):
c_begin, c_end, c_step = -5, 15, 2
c_info = c_begin, c_end, c_step
g_begin, g_end, g_step = -15, 3, 2
g_info = g_begin, g_end, g_step
status = {
'stage': 0,
'text': '',
'min': 0,
'max': 1,
'meta': 'Classifier training:',
'item_name': 'round',
'progress': 0
}
self.update_status(status)
i = 0
best_accuracy = -1
best_log2c = None
best_log2g = None
best_conf = None
is_abort = False
stopwatch = StopWatch(start=True)
if self._learner.has_nan_features():
self._learner.filter_nans(apply=True)
t0 = time.time()
for info in self._learner.iterGridSearchSVM(c_info=c_info,
g_info=g_info):
n, log2c, log2g, conf = info
status.update({'min': 1,
'max': n,
'progress': i+1,
'text': 'log2(C)=%d, log2(g)=%d' % \
(log2c, log2g),
'interval': stopwatch.interim(),
})
self.update_status(status, stime=50)
stopwatch.reset(start=True)
i += 1
accuracy = conf.ac_sample
if accuracy > best_accuracy:
best_accuracy = accuracy
best_log2c = log2c
best_log2g = log2g
best_conf = conf
self.conf_result.emit(log2c, log2g, conf)
if self.is_aborted():
is_abort = True
break
# overwrite only if grid-search was not aborted by the user
if not is_abort:
self._learner.train(2**best_log2c, 2**best_log2g)
self._learner.exportConfusion(best_log2c, best_log2g, best_conf)
self._learner.exportRanges()
# FIXME: in case the meta-data (colors, names, zero-insert) changed
# the ARFF file has to be written again
# -> better store meta-data outside ARFF
self._learner.exportToArff()
def _build_dimension_lookup(self):
s = StopWatch(start=True)
lookup = {}
has_xy = False
positions = []
times = []
channels = []
zslices = []
dimension_items = self._get_dimension_items()
print("Get dimensions: %s" %s.interim())
s.reset(start=True)
# if use_frame_indices is set in the ini file,
# we make a first scan of the items and determine for each position
# the list of timepoints.
# Then, we can assign to each position a dictionary that assigns to each timepoint
# its index (after ordering).
if self.use_frame_indices:
#all_times = list(set([int(item[DIMENSION_NAME_TIME]) if DIMENSION_NAME_TIME in item else 0
# for item in dimension_items]))
#all_times.sort()
first_pass = {}
for item in dimension_items:
position = item[DIMENSION_NAME_POSITION]
if not position in first_pass:
first_pass[position] = []
if DIMENSION_NAME_TIME in item:
time_val = int(item[DIMENSION_NAME_TIME])
else:
time_val = 0
first_pass[position].append(time_val)
time_index_correspondence = {}
for pos in first_pass.keys():
first_pass[position].sort()
time_index_correspondence[pos] = dict(zip(first_pass[position],
range(len(first_pass[position]))))
for item in dimension_items:
# import image info only once
if not has_xy:
has_xy = True
info = ccore.ImageImportInfo(os.path.join(self.path,
item['filename']))
self.meta_data.set_image_info(info)
self.has_multi_images = False #info.images > 1
# position
position = item[DIMENSION_NAME_POSITION]
if not position in lookup:
lookup[position] = {}
# time
if DIMENSION_NAME_TIME in item:
time_from_filename = int(item[DIMENSION_NAME_TIME])
else:
time_from_filename = 0
item[DIMENSION_NAME_TIME] = str(time_from_filename)
if self.use_frame_indices:
time = time_index_correspondence[position][time_from_filename]
else:
time = time_from_filename
if not time in lookup[position]:
lookup[position][time] = {}
# channels
if DIMENSION_NAME_CHANNEL in item:
channel = item[DIMENSION_NAME_CHANNEL]
else:
channel = '1'
item[DIMENSION_NAME_CHANNEL] = channel
if not channel in lookup[position][time]:
lookup[position][time][channel] = {}
# leave zslice optional.
# in case of multi-images it must not be defined
if DIMENSION_NAME_ZSLICE in item:
zslice = item[DIMENSION_NAME_ZSLICE]
else:
zslice = 0
item[DIMENSION_NAME_ZSLICE] = zslice
if zslice == '':
zslice = None
if not zslice is None:
zslice = int(zslice)
if not zslice in lookup[position][time][channel]:
lookup[position][time][channel][zslice] = item['filename']
# allow to read timestamps from file if not present
if META_INFO_TIMESTAMP in item:
timestamp = float(item[META_INFO_TIMESTAMP])
self.meta_data.append_absolute_time(position, time, timestamp)
elif self.timestamps_from_file in ['mtime', 'ctime']:
filename_full = os.path.join(self.path, item['filename'])
if self.timestamps_from_file == 'mtime':
timestamp = os.path.getmtime(filename_full)
else:
timestamp = os.path.getctime(filename_full)
item[META_INFO_TIMESTAMP] = timestamp
self.meta_data.append_absolute_time(position, time, timestamp)
if META_INFO_WELL in item:
well = item[META_INFO_WELL]
subwell = item.get(META_INFO_SUBWELL, None)
self.meta_data.append_well_subwell_info(position, well, subwell)
if (self.has_multi_images and
self.multi_image == self.MULTIIMAGE_USE_ZSLICE):
if not zslice is None:
raise ValueError('Multi-image assigned for zslice conflicts'
' with zslice token in filename!')
zslices.extend(range(1,info.images+1))
else:
zslices.append(zslice)
positions.append(position)
times.append(time)
channels.append(channel)
self.meta_data.positions = tuple(sorted(set(positions)))
# assure that all items of one dimension are of same length
times = set(times)
channels = set(channels)
zslices = set(zslices)
# find overall valid number of frames
for p in lookup:
times = times.intersection(lookup[p].keys())
# find overall valid channels/zslices based on overall valid frames
for p in lookup:
for t in times:
channels = channels.intersection(lookup[p][t].keys())
for c in channels:
zslices = zslices.intersection(lookup[p][t][c].keys())
self.meta_data.times = sorted(times)
self.meta_data.channels = sorted(channels)
self.meta_data.zslices = sorted(zslices)
self.meta_data.image_files = len(dimension_items)
print('Build time: %s' %s.stop())
return lookup
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 _run(self):
c_begin, c_end, c_step = -5, 15, 2
c_info = c_begin, c_end, c_step
g_begin, g_end, g_step = -15, 3, 2
g_info = g_begin, g_end, g_step
status = {'stage': 0,
'text': '',
'min': 0,
'max': 1,
'meta': 'Classifier training:',
'item_name': 'round',
'progress': 0}
self.update_status(status)
i = 0
best_accuracy = -1
best_log2c = None
best_log2g = None
best_conf = None
is_abort = False
stopwatch = StopWatch(start=True)
if self._learner.has_nan_features():
self._learner.filter_nans(apply=True)
t0 = time.time()
for info in self._learner.iterGridSearchSVM(c_info=c_info,
g_info=g_info):
n, log2c, log2g, conf = info
status.update({'min': 1,
'max': n,
'progress': i+1,
'text': 'log2(C)=%d, log2(g)=%d' % \
(log2c, log2g),
'interval': stopwatch.interim(),
})
self.update_status(status, stime=50)
stopwatch.reset(start=True)
i += 1
accuracy = conf.ac_sample
if accuracy > best_accuracy:
best_accuracy = accuracy
best_log2c = log2c
best_log2g = log2g
best_conf = conf
self.conf_result.emit(log2c, log2g, conf)
if self.is_aborted():
is_abort = True
break
# overwrite only if grid-search was not aborted by the user
if not is_abort:
self._learner.train(2**best_log2c, 2**best_log2g)
self._learner.exportConfusion(best_log2c, best_log2g, best_conf)
self._learner.exportRanges()
# FIXME: in case the meta-data (colors, names, zero-insert) changed
# the ARFF file has to be written again
# -> better store meta-data outside ARFF
self._learner.exportToArff()
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())))
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()
n_images += 1
images = []
if self.settings.get('Processing', 'tracking'):
region = self.settings.get('Tracking', 'tracking_regionname')
samples = self.timeholder[frame][
PrimaryChannel.NAME].get_region(region)
self._tracker.track_next_frame(frame, samples)
if self.settings.get('Tracking', 'tracking_visualization'):
size = cellanalyzer.getImageSize(PrimaryChannel.NAME)
nframes = self.settings.get(
'Tracking', 'tracking_visualize_track_length')
radius = self.settings.get('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)]
for clf in self.classifiers.itervalues():
cellanalyzer.classify_objects(clf)
##############################################################
# FIXME - part for browser
if not self._myhack is None:
self.render_browser(cellanalyzer)
##############################################################
self.settings.set_section('General')
self.render_classification_images(cellanalyzer, images, frame)
self.render_contour_images(cellanalyzer, images, frame)
if self.settings.get('Output', 'rendering_channel_gallery'):
self.render_channel_gallery(cellanalyzer, frame)
if self.settings.get('Output', 'rendering_labels_discwrite'):
cellanalyzer.exportLabelImages(self._labels_dir)
self.logger.info(" - Frame %d, duration (ms): %3d" \
%(frame, stopwatch.interim()*1000))
cellanalyzer.purge(features=self.export_features)
return n_images
def _build_dimension_lookup(self):
s = StopWatch(start=True)
lookup = {}
has_xy = False
positions = []
times = []
channels = []
zslices = []
dimension_items = self._get_dimension_items()
print("Get dimensions: %s" % s.interim())
s.reset(start=True)
# if use_frame_indices is set in the ini file,
# we make a first scan of the items and determine for each position
# the list of timepoints.
# Then, we can assign to each position a dictionary that assigns to each timepoint
# its index (after ordering).
if self.use_frame_indices:
#all_times = list(set([int(item[Dimensions.Time]) if Dimensions.Time in item else 0
# for item in dimension_items]))
#all_times.sort()
first_pass = {}
for item in dimension_items:
position = item[Dimensions.Position]
if not position in first_pass:
first_pass[position] = []
if Dimensions.Time in item:
time_val = int(item[Dimensions.Time])
else:
time_val = 0
first_pass[position].append(time_val)
time_index_correspondence = {}
for pos in first_pass.keys():
first_pass[position].sort()
time_index_correspondence[pos] = dict(
zip(first_pass[position],
range(len(first_pass[position]))))
for item in dimension_items:
# import image info only once
if not has_xy:
has_xy = True
info = ccore.ImageImportInfo(
os.path.join(self.path, item['filename']))
self.meta_data.set_image_info(info)
self.has_multi_images = False #info.images > 1
# position
position = item[Dimensions.Position]
if not position in lookup:
lookup[position] = {}
# time
if Dimensions.Time in item:
time_from_filename = int(item[Dimensions.Time])
else:
time_from_filename = 0
item[Dimensions.Time] = str(time_from_filename)
if self.use_frame_indices:
time = time_index_correspondence[position][time_from_filename]
else:
time = time_from_filename
if not time in lookup[position]:
lookup[position][time] = {}
# channels
if Dimensions.Channel in item:
channel = item[Dimensions.Channel]
else:
channel = '1'
item[Dimensions.Channel] = channel
if not channel in lookup[position][time]:
lookup[position][time][channel] = {}
# leave zslice optional.
# in case of multi-images it must not be defined
if Dimensions.ZSlice in item:
zslice = item[Dimensions.ZSlice]
else:
zslice = 0
item[Dimensions.ZSlice] = zslice
if zslice == '':
zslice = None
if not zslice is None:
zslice = int(zslice)
if not zslice in lookup[position][time][channel]:
lookup[position][time][channel][zslice] = item['filename']
# allow to read timestamps from file if not present
if MetaInfo.Timestamp in item:
timestamp = float(item[MetaInfo.Timestamp])
self.meta_data.append_absolute_time(position, time, timestamp)
elif self.timestamps_from_file in ['mtime', 'ctime']:
filename_full = os.path.join(self.path, item['filename'])
if self.timestamps_from_file == 'mtime':
timestamp = os.path.getmtime(filename_full)
else:
timestamp = os.path.getctime(filename_full)
item[MetaInfo.Timestamp] = timestamp
self.meta_data.append_absolute_time(position, time, timestamp)
if MetaInfo.Well in item:
well = item[MetaInfo.Well]
subwell = item.get(MetaInfo.Subwell, None)
self.meta_data.append_well_subwell_info(
position, well, subwell)
if (self.has_multi_images
and self.multi_image == self.MULTIIMAGE_USE_ZSLICE):
if not zslice is None:
raise ValueError(
'Multi-image assigned for zslice conflicts'
' with zslice token in filename!')
zslices.extend(range(1, info.images + 1))
else:
zslices.append(zslice)
positions.append(position)
times.append(time)
channels.append(channel)
self.meta_data.positions = tuple(sorted(set(positions)))
# assure that all items of one dimension are of same length
times = set(times)
channels = set(channels)
zslices = set(zslices)
# find overall valid number of frames
for p in lookup:
times = times.intersection(lookup[p].keys())
# find overall valid channels/zslices based on overall valid frames
for p in lookup:
for t in times:
channels = channels.intersection(lookup[p][t].keys())
for c in channels:
zslices = zslices.intersection(lookup[p][t][c].keys())
self.meta_data.times = sorted(times)
self.meta_data.channels = sorted(channels)
self.meta_data.zslices = sorted(zslices)
self.meta_data.image_files = len(dimension_items)
print('Build time: %s' % s.stop())
return lookup
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))
