class PenguTrackWindow(QtWidgets.QWidget):
def __init__(self, parent=None):
super(QtWidgets.QWidget, self).__init__(parent)
self.setWindowTitle("PenguTrack - ClickPoints")
self.setWindowIcon(qta.icon("fa.coffee"))
# window layout
self.layout = QtWidgets.QVBoxLayout()
self.layout.setContentsMargins(20, 10, 20, 10)
self.setLayout(self.layout)
self.texts = {}
self.formats = {}
self.functions = {}
font = QtGui.QFont("", 11)
# add spinboxes
self.spinboxes = {}
self.spin_functions = [
self.pt_set_size, self.pt_set_area, self.pt_set_number
]
self.spin_start = [10, 100, 20]
self.spin_min_max = [[1, 100], [10, 1000], [1, 1000]]
self.spin_formats = [" %3d", " %4d", " %4d"]
for i, name in enumerate([
"Object Size (px)", "Object Area (px)",
"Object Number (approx.)"
]):
sublayout = QtWidgets.QHBoxLayout()
sublayout.setContentsMargins(0, 0, 0, 0)
spin = QtWidgets.QSpinBox(self)
# spin.format = formats[i]
spin.setValue(self.spin_start[i])
spin.setRange(self.spin_min_max[i][0], self.spin_min_max[i][1])
spin.editingFinished.connect(
lambda spin=spin, i=i: self.spin_functions[i](spin.value()))
self.spinboxes.update({name: spin})
self.functions.update({name: self.spin_functions[i]})
sublayout.addWidget(spin)
text = QtWidgets.QLabel(self)
text.setText(name + ": " + self.spin_formats[i] % spin.value())
# text.setBrush(QtGui.QBrush(QtGui.QColor("white")))
# text.setText(name + ": " + formats[i] % slider.value())
sublayout.addWidget(text)
self.formats.update({name: self.spin_formats[i]})
self.texts.update({name: text})
self.layout.addLayout(sublayout)
# Initialise PenguTrack
self.object_size = self.spin_start[0] # Object diameter (smallest)
self.object_number = self.spin_start[
1] # Number of Objects in First Track
self.object_area = self.spin_start[2]
# add even more sliders. tihihi...
self.sliders = {}
self.slider_functions = [
self.pt_set_q, self.pt_set_r, self.vb_set_n, self.vb_set_r,
self.vb_set_phi
]
self.slider_min_max = [[1, 10], [1, 10], [1, 20], [0, 100], [1, 64]]
self.slider_start = [2, 2, 10, 20, 1]
self.slider_formats = [" %3d", " %3d", " %3d", " %3d", " %3d"]
for i, name in enumerate([
"Prediciton Error", "Detection Error", "Background Complexity",
"Sensitivity", "Update Rate"
]):
sublayout = QtWidgets.QHBoxLayout()
sublayout.setContentsMargins(0, 0, 0, 0)
slider = QtWidgets.QSlider(self)
slider.setMinimum(self.slider_min_max[i][0])
slider.setMaximum(self.slider_min_max[i][1])
slider.setValue(self.slider_start[i])
slider.setOrientation(QtCore.Qt.Horizontal)
slider.sliderReleased.connect(
lambda slider=slider, i=i, name=name: self.slider_functions[i]
(slider.value(), name))
self.sliders.update({name: slider})
self.functions.update({name: self.slider_functions[i]})
sublayout.addWidget(slider)
text = QtWidgets.QLabel(self)
text.setText(name + ": " + self.slider_formats[i] % slider.value())
sublayout.addWidget(text)
self.formats.update({name: self.slider_formats[i]})
self.texts.update({name: text})
self.layout.addLayout(sublayout)
# Add start Button
self.start_button = QtWidgets.QPushButton()
self.start_button.clicked.connect(self.track)
self.start_button.setCheckable(True)
self.layout.addWidget(self.start_button)
# Initialize physical model as 2d variable speed model with 1 Hz frame-rate
self.model = VariableSpeed(1, 1, dim=2, timeconst=1)
self.q = self.slider_start[0]
self.r = self.slider_start[1]
X = np.zeros(4).T # Initial Value for Position
Q = np.diag([self.q * self.object_size,
self.q * self.object_size]) # Prediction uncertainty
R = np.diag([self.r * self.object_size,
self.r * self.object_size]) # Measurement uncertainty
self.FilterType = KalmanFilter
State_Dist = ss.multivariate_normal(
cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(
cov=R) # Initialize Distributions for Filter
# Initialize Filter
self.Tracker = MultiFilter(self.FilterType,
self.model,
np.diag(Q),
np.diag(R),
meas_dist=Meas_Dist,
state_dist=State_Dist)
# Init_Background from Image_Median
N = db.getImages().count()
init = np.array(np.median([
np.asarray(db.getImage(frame=j).data, dtype=np.int)
for j in np.random.randint(0, N, 5)
],
axis=0),
dtype=np.int)
# Init Segmentation Module with Init_Image
self.Segmentation = ViBeSegmentation(
init_image=init,
n=self.slider_start[2],
n_min=int(np.ceil(0.9 * self.slider_start[2])),
r=self.slider_start[3],
phi=self.slider_start[4])
for i in np.random.randint(0, N, 5):
self.Segmentation.detect(db.getImage(frame=i).data,
do_neighbours=False)
# Init Detection Module
self.Detector = AreaDetector(self.object_area, self.object_number)
# Define ClickPoints Marker
marker_type = db.getMarkerType(name="PT_Detection_Marker")
if not marker_type:
marker_type = db.setMarkerType(name="PT_Detection_Marker",
color="#FF0000",
style='{"scale":1.2}')
db.deleteMarkers(type=marker_type)
self.detection_marker_type = marker_type
marker_type2 = db.getMarkerType(name="PT_Track_Marker")
if not marker_type2:
marker_type2 = db.setMarkerType(name="PT_Track_Marker",
color="#00FF00",
mode=db.TYPE_Track)
db.deleteMarkers(type=marker_type2)
self.track_marker_type = marker_type2
marker_type3 = db.getMarkerType(name="PT_Prediction_Marker")
if not marker_type3:
marker_type3 = db.setMarkerType(name="PT_Prediction_Marker",
color="#0000FF")
db.deleteMarkers(type=marker_type3)
self.prediction_marker_type = marker_type3
# Delete Old Tracks
db.deleteTracks(type=self.track_marker_type)
com.ReloadTypes()
com.ReloadMarker()
print('Initialized')
# Get images and template
self.image_iterator = db.getImageIterator(start_frame=start_frame)
self.current_image = db.getImage(frame=start_frame)
self.image_data = self.current_image.data
self.markers = db.getMarkers(frame=start_frame)
self.current_marker = None
self.reload_mask()
# start to display first image
# QtCore.QTimer.singleShot(1, self.displayNext)
def vb_set_n(self, value, name):
self.texts[name].setText(name + ": " + self.formats[name] %
self.sliders[name].value())
ratio = float(self.Segmentation.N_min) / self.Segmentation.N
self.Segmentation.N = int(value)
self.Segmentation.N_min = int(np.ceil(ratio * value))
self.reload_mask()
self.reload_markers()
def vb_set_r(self, value, name):
self.texts[name].setText(name + ": " + self.formats[name] %
self.sliders[name].value())
self.Segmentation.R = int(value)
self.reload_mask()
self.reload_markers()
def vb_set_phi(self, value, name):
self.texts[name].setText(name + ": " + self.formats[name] %
self.sliders[name].value())
self.Segmentation.Phi = int(value)
self.reload_mask()
self.reload_markers()
def pt_set_area(self, value):
self.object_area = int(value)
self.Detector = AreaDetector(self.object_area, self.object_number)
self.reload_markers()
def pt_set_number(self, value):
self.object_number = int(value)
self.Detector = AreaDetector(self.object_area, self.object_number)
self.reload_markers()
def pt_set_size(self, value):
self.object_size = int(value)
X = np.zeros(4).T # Initial Value for Position
Q = np.diag([self.q * self.object_size,
self.q * self.object_size]) # Prediction uncertainty
R = np.diag([self.r * self.object_size,
self.r * self.object_size]) # Measurement uncertainty
State_Dist = ss.multivariate_normal(
cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(
cov=R) # Initialize Distributions for Filter
self.update_filter_params(np.diag(Q),
np.diag(R),
meas_dist=Meas_Dist,
state_dist=State_Dist)
def pt_set_r(self, value, name):
self.texts[name].setText(name + ": " + self.formats[name] %
self.sliders[name].value())
self.r = int(value)
X = np.zeros(4).T # Initial Value for Position
Q = np.diag([self.q * self.object_size,
self.q * self.object_size]) # Prediction uncertainty
R = np.diag([self.r * self.object_size,
self.r * self.object_size]) # Measurement uncertainty
State_Dist = ss.multivariate_normal(
cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(
cov=R) # Initialize Distributions for Filter
self.update_filter_params(np.diag(Q),
np.diag(R),
meas_dist=Meas_Dist,
state_dist=State_Dist)
def pt_set_q(self, value, name):
self.texts[name].setText(name + ": " + self.formats[name] %
self.sliders[name].value())
self.q = int(value)
X = np.zeros(4).T # Initial Value for Position
Q = np.diag([self.q * self.object_size,
self.q * self.object_size]) # Prediction uncertainty
R = np.diag([self.r * self.object_size,
self.r * self.object_size]) # Measurement uncertainty
State_Dist = ss.multivariate_normal(
cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(
cov=R) # Initialize Distributions for Filter
self.update_filter_params(np.diag(Q),
np.diag(R),
meas_dist=Meas_Dist,
state_dist=State_Dist)
def reload_markers(self):
db.deleteMarkers(image=self.current_image,
type=self.detection_marker_type)
Positions = self.Detector.detect(~db.getMask(
image=self.current_image).data.astype(bool))
print(len(Positions))
for pos in Positions:
db.setMarker(image=self.current_image,
y=pos.PositionX,
x=pos.PositionY,
type=self.detection_marker_type)
com.ReloadMarker()
def reload_mask(self):
self.setEnabled(False)
SegMap = self.Segmentation.segmentate(self.image_data,
do_neighbours=False)
db.setMask(image=self.current_image, data=(~SegMap).astype(np.uint8))
com.ReloadMask()
self.setEnabled(True)
def update_filter_params(self, *args, **kwargs):
self.Tracker.filter_args = args
self.Tracker.filter_kwargs = kwargs
for f in self.Tracker.Filters:
obj = self.Tracker.Filters.pop(f)
del obj
for f in self.Tracker.ActiveFilters:
obj = self.Tracker.Filters.pop(f)
del obj
self.Tracker.predict(u=np.zeros((self.model.Control_dim, )).T,
i=self.current_image.frame)
def track(self, value):
if value:
images = db.getImageIterator(start_frame=start_frame)
for image in images:
i = image.get_id()
# Prediction step
self.Tracker.predict(u=np.zeros((self.model.Control_dim, )).T,
i=i)
# Detection step
SegMap = self.Segmentation.detect(image.data,
do_neighbours=False)
Positions = self.Detector.detect(SegMap)
# Setting Mask in ClickPoints
if not db.getMaskType(name="PT_SegMask"):
mask_type = db.setMaskType(name="PT_SegMask",
color="#FF59E3")
m = db.setMask(image=image, data=(~SegMap).astype(np.uint8))
print("Mask save", m)
n = 1
if np.all(Positions != np.array([])):
# Update Filter with new Detections
try:
self.Tracker.update(z=Positions, i=i)
except TypeError:
print(self.Tracker.filter_args)
print(self.Tracker.filter_kwargs)
raise
# Get Tracks from Filter (a little dirty)
for k in self.Tracker.ActiveFilters.keys():
x = y = np.nan
if i in self.Tracker.ActiveFilters[
k].Measurements.keys():
meas = self.Tracker.ActiveFilters[k].Measurements[
i]
y = meas.PositionX
x = meas.PositionY
prob = self.Tracker.ActiveFilters[k].log_prob(
keys=[i], compare_bel=False)
elif i in self.Tracker.ActiveFilters[k].X.keys():
meas = None
y, x = self.Tracker.Model.measure(
self.Tracker.ActiveFilters[k].X[i])
prob = self.Tracker.ActiveFilters[k].log_prob(
keys=[i], compare_bel=False)
if i in self.Tracker.ActiveFilters[
k].Measurements.keys():
pred_y, pred_x = self.Tracker.Model.measure(
self.Tracker.ActiveFilters[k].Predicted_X[i])
prob = self.Tracker.ActiveFilters[k].log_prob(
keys=[i], compare_bel=False)
# Write assigned tracks to ClickPoints DataBase
if np.isnan(x) or np.isnan(y):
pass
else:
pred_marker = db.setMarker(
image=image,
x=pred_x,
y=pred_y,
text="Track %s" % k,
type=self.prediction_marker_type)
# try:
# db.setMarker(image=image, type=marker_type2, track=k, x=x, y=y, text='Track %s, Prob %.2f'%(k, prob))
if k not in [t.id for t in db.getTracks()]:
db.setTrack(self.track_marker_type, id=k)
print(
'Set new Track %s and Track-Marker at %s, %s'
% (k, x, y))
if k == self.Tracker.CriticalIndex:
db.setMarker(
image=image,
type=self.detection_marker_type,
x=x,
y=y,
text='Track %s, Prob %.2f, CRITICAL' %
(k, prob))
track_marker = db.setMarker(
image=image,
type=self.track_marker_type,
track=k,
x=x,
y=y,
text='Track %s, Prob %.2f' % (k, prob))
print('Set Track(%s)-Marker at %s, %s' % (k, x, y))
# except:
# db.setTrack(marker_type2, id=k)
# # db.setMarker(image=image, type=marker_type2, track=k, x=x, y=y, text='Track %s, Prob %.2f'%(k, prob))
# if k == MultiKal.CriticalIndex:
# db.setMarker(image=image, type=marker_type, x=x, y=y,
# text='Track %s, Prob %.2f, CRITICAL' % (k, prob))
# track_marker = db.setMarker(image=image, type=marker_type2, track=k, x=x, y=y,
# text='Track %s, Prob %.2f' % (k, prob))
# print('Set new Track %s and Track-Marker at %s, %s' % (k, x, y))
db.db.connect()
meas_entry = Measurement(marker=track_marker,
log=prob,
x=x,
y=y)
meas_entry.save()
com.ReloadMarker(image.sort_index)
com.JumpToFrameWait(image.sort_index)
print("Got %s Filters" %
len(self.Tracker.ActiveFilters.keys()))
if not self.start_button.isChecked():
break
def __init__(self, parent=None):
super(QtWidgets.QWidget, self).__init__(parent)
self.setWindowTitle("PenguTrack - ClickPoints")
self.setWindowIcon(qta.icon("fa.coffee"))
# window layout
self.layout = QtWidgets.QVBoxLayout()
self.layout.setContentsMargins(20, 10, 20, 10)
self.setLayout(self.layout)
self.texts = {}
self.formats = {}
self.functions = {}
font = QtGui.QFont("", 11)
# add spinboxes
self.spinboxes = {}
self.spin_functions = [
self.pt_set_size, self.pt_set_area, self.pt_set_number
]
self.spin_start = [10, 100, 20]
self.spin_min_max = [[1, 100], [10, 1000], [1, 1000]]
self.spin_formats = [" %3d", " %4d", " %4d"]
for i, name in enumerate([
"Object Size (px)", "Object Area (px)",
"Object Number (approx.)"
]):
sublayout = QtWidgets.QHBoxLayout()
sublayout.setContentsMargins(0, 0, 0, 0)
spin = QtWidgets.QSpinBox(self)
# spin.format = formats[i]
spin.setValue(self.spin_start[i])
spin.setRange(self.spin_min_max[i][0], self.spin_min_max[i][1])
spin.editingFinished.connect(
lambda spin=spin, i=i: self.spin_functions[i](spin.value()))
self.spinboxes.update({name: spin})
self.functions.update({name: self.spin_functions[i]})
sublayout.addWidget(spin)
text = QtWidgets.QLabel(self)
text.setText(name + ": " + self.spin_formats[i] % spin.value())
# text.setBrush(QtGui.QBrush(QtGui.QColor("white")))
# text.setText(name + ": " + formats[i] % slider.value())
sublayout.addWidget(text)
self.formats.update({name: self.spin_formats[i]})
self.texts.update({name: text})
self.layout.addLayout(sublayout)
# Initialise PenguTrack
self.object_size = self.spin_start[0] # Object diameter (smallest)
self.object_number = self.spin_start[
1] # Number of Objects in First Track
self.object_area = self.spin_start[2]
# add even more sliders. tihihi...
self.sliders = {}
self.slider_functions = [
self.pt_set_q, self.pt_set_r, self.vb_set_n, self.vb_set_r,
self.vb_set_phi
]
self.slider_min_max = [[1, 10], [1, 10], [1, 20], [0, 100], [1, 64]]
self.slider_start = [2, 2, 10, 20, 1]
self.slider_formats = [" %3d", " %3d", " %3d", " %3d", " %3d"]
for i, name in enumerate([
"Prediciton Error", "Detection Error", "Background Complexity",
"Sensitivity", "Update Rate"
]):
sublayout = QtWidgets.QHBoxLayout()
sublayout.setContentsMargins(0, 0, 0, 0)
slider = QtWidgets.QSlider(self)
slider.setMinimum(self.slider_min_max[i][0])
slider.setMaximum(self.slider_min_max[i][1])
slider.setValue(self.slider_start[i])
slider.setOrientation(QtCore.Qt.Horizontal)
slider.sliderReleased.connect(
lambda slider=slider, i=i, name=name: self.slider_functions[i]
(slider.value(), name))
self.sliders.update({name: slider})
self.functions.update({name: self.slider_functions[i]})
sublayout.addWidget(slider)
text = QtWidgets.QLabel(self)
text.setText(name + ": " + self.slider_formats[i] % slider.value())
sublayout.addWidget(text)
self.formats.update({name: self.slider_formats[i]})
self.texts.update({name: text})
self.layout.addLayout(sublayout)
# Add start Button
self.start_button = QtWidgets.QPushButton()
self.start_button.clicked.connect(self.track)
self.start_button.setCheckable(True)
self.layout.addWidget(self.start_button)
# Initialize physical model as 2d variable speed model with 1 Hz frame-rate
self.model = VariableSpeed(1, 1, dim=2, timeconst=1)
self.q = self.slider_start[0]
self.r = self.slider_start[1]
X = np.zeros(4).T # Initial Value for Position
Q = np.diag([self.q * self.object_size,
self.q * self.object_size]) # Prediction uncertainty
R = np.diag([self.r * self.object_size,
self.r * self.object_size]) # Measurement uncertainty
self.FilterType = KalmanFilter
State_Dist = ss.multivariate_normal(
cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(
cov=R) # Initialize Distributions for Filter
# Initialize Filter
self.Tracker = MultiFilter(self.FilterType,
self.model,
np.diag(Q),
np.diag(R),
meas_dist=Meas_Dist,
state_dist=State_Dist)
# Init_Background from Image_Median
N = db.getImages().count()
init = np.array(np.median([
np.asarray(db.getImage(frame=j).data, dtype=np.int)
for j in np.random.randint(0, N, 5)
],
axis=0),
dtype=np.int)
# Init Segmentation Module with Init_Image
self.Segmentation = ViBeSegmentation(
init_image=init,
n=self.slider_start[2],
n_min=int(np.ceil(0.9 * self.slider_start[2])),
r=self.slider_start[3],
phi=self.slider_start[4])
for i in np.random.randint(0, N, 5):
self.Segmentation.detect(db.getImage(frame=i).data,
do_neighbours=False)
# Init Detection Module
self.Detector = AreaDetector(self.object_area, self.object_number)
# Define ClickPoints Marker
marker_type = db.getMarkerType(name="PT_Detection_Marker")
if not marker_type:
marker_type = db.setMarkerType(name="PT_Detection_Marker",
color="#FF0000",
style='{"scale":1.2}')
db.deleteMarkers(type=marker_type)
self.detection_marker_type = marker_type
marker_type2 = db.getMarkerType(name="PT_Track_Marker")
if not marker_type2:
marker_type2 = db.setMarkerType(name="PT_Track_Marker",
color="#00FF00",
mode=db.TYPE_Track)
db.deleteMarkers(type=marker_type2)
self.track_marker_type = marker_type2
marker_type3 = db.getMarkerType(name="PT_Prediction_Marker")
if not marker_type3:
marker_type3 = db.setMarkerType(name="PT_Prediction_Marker",
color="#0000FF")
db.deleteMarkers(type=marker_type3)
self.prediction_marker_type = marker_type3
# Delete Old Tracks
db.deleteTracks(type=self.track_marker_type)
com.ReloadTypes()
com.ReloadMarker()
print('Initialized')
# Get images and template
self.image_iterator = db.getImageIterator(start_frame=start_frame)
self.current_image = db.getImage(frame=start_frame)
self.image_data = self.current_image.data
self.markers = db.getMarkers(frame=start_frame)
self.current_marker = None
self.reload_mask()
model = VariableSpeed(1, 1, dim=2, timeconst=0.5)
uncertainty = 8 * object_size
X = np.zeros(4).T # Initial Value for Position
Q = np.diag([uncertainty, uncertainty]) # Prediction uncertainty
R = np.diag([uncertainty * 2, uncertainty * 2]) # Measurement uncertainty
State_Dist = ss.multivariate_normal(
cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(
cov=R) # Initialize Distributions for Filter
# Initialize Filter
MultiKal = MultiFilter(KalmanFilter,
model,
np.asarray([uncertainty, uncertainty]),
np.asarray([uncertainty, uncertainty]),
meas_dist=Meas_Dist,
state_dist=State_Dist)
# Init_Background from Image_Median
N = db.getImages().count()
init = np.asarray(np.median([
np.asarray(db.getImage(frame=j).data, dtype=np.int)
for j in np.random.randint(0, N, 10)
],
axis=0),
dtype=np.int)
# Init Segmentation Module with Init_Image
# VB = ViBeSegmentation(init_image=init, n_min=18, r=20, phi=1)
def run(Log_Prob_Tresh, Detection_Error, Prediction_Error, Min_Size, Max_Size, db, res, start_frame=0, progress_bar=None):
# Checks if the marker already exist. If they don't, creates them
marker_type = db.getMarkerType(name="PT_Detection_Marker")
if not marker_type:
marker_type = db.setMarkerType(name="PT_Detection_Marker", color="#FF0000", style='{"scale":1.2}')
marker_type2 = db.getMarkerType(name="PT_Track_Marker")
if not marker_type2:
marker_type2 = db.setMarkerType(name="PT_Track_Marker", color="#00FF00", mode=db.TYPE_Track)
marker_type3 = db.getMarkerType(name="PT_Prediction_Marker")
if not marker_type3:
marker_type3 = db.setMarkerType(name="PT_Prediction_Marker", color="#0000FF")
if not db.getMaskType(name="PT_SegMask"):
mask_type = db.setMaskType(name="PT_SegMask", color="#FF59E3")
else:
mask_type = db.getMaskType(name="PT_SegMask")
images = db.getImageIterator(start_frame=start_frame)
model = RandomWalk(dim=3) # Model to predict the cell movements
# Set uncertainties
q = int(Detection_Error)
r = int(Prediction_Error)
object_area = (Min_Size + Max_Size) / 2
object_size = int(np.sqrt(object_area) / 2.)
Q = np.diag(
[q * object_size, q * object_size, q * object_size]) # Prediction uncertainty
R = np.diag([r * object_size, r * object_size,
r * object_size]) # Measurement uncertainty
State_Dist = ss.multivariate_normal(cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(cov=R) # Initialize Distributions for Filter
# Initialize Tracker
FilterType = KalmanFilter
Tracker = MultiFilter(FilterType, model, np.diag(Q),
np.diag(R), meas_dist=Meas_Dist, state_dist=State_Dist)
Tracker.AssignmentProbabilityThreshold = 0.
Tracker.MeasurementProbabilityThreshold = 0.
Tracker.LogProbabilityThreshold = Log_Prob_Tresh
q = int(Detection_Error)
r = int(Prediction_Error)
min_area = int((Min_Size / 2.) ** 2 * np.pi)
max_area = int((Max_Size / 2.) ** 2 * np.pi)
object_area = int((min_area + max_area) / 2.)
object_size = int(np.sqrt(object_area) / 2.)
Q = np.diag(
[q * object_size * res, q * object_size * res, q * object_size * res])
R = np.diag([r * object_size * res, r * object_size * res,
r * object_size * res])
State_Dist = ss.multivariate_normal(cov=Q)
Meas_Dist = ss.multivariate_normal(cov=R)
Tracker.filter_args = [np.diag(Q), np.diag(R)]
Tracker.filter_kwargs = {"meas_dist": Meas_Dist, "state_dist": State_Dist}
Tracker.Filters.clear()
Tracker.ActiveFilters.clear()
Tracker.predict(u=np.zeros((model.Control_dim,)).T, i=start_frame)
# Delete already existing tracks
db.deleteTracks(type="PT_Track_Marker")
db.deleteMarkers(type=marker_type)
db.deleteMarkers(type=marker_type2)
db.deleteMarkers(type=marker_type3)
for image in images:
if progress_bar is not None:
progress_bar.increase()
i = image.sort_index
print("Doing Frame %s" % i)
Index_Image = db.getImage(frame=i, layer=1).data
# Prediction step
Tracker.predict(u=np.zeros((model.Control_dim,)).T, i=i)
minIndices = db.getImage(frame=i, layer=1)
minProj = db.getImage(frame=i, layer=0)
Positions, mask = TCellDetector().detect(minProj, minIndices)
db.setMask(frame=i, layer=0, data=(~mask).astype(np.uint8))
for pos in Positions:
db.setMarker(frame=i, layer=0, y=pos.PositionX / res, x=pos.PositionY / res,
type=marker_type)
if len(Positions) != 0:
# Update Filter with new Detections
try:
Tracker.update(z=Positions, i=i)
except TypeError:
print(Tracker.filter_args)
print(Tracker.filter_kwargs)
raise
# Do all DB-writing as atomic transaction (at once)
with db.db.atomic() as transaction:
# Get Tracks from Filter
for k in Tracker.Filters.keys():
if i in Tracker.Filters[k].Measurements.keys():
meas = Tracker.Filters[k].Measurements[i]
x = meas.PositionX
y = meas.PositionY
z = meas.PositionZ
prob = Tracker.Filters[k].log_prob(keys=[i])
else:
x = y = z = np.nan
prob = np.nan
# Write predictions to Database
if i in Tracker.Filters[k].Predicted_X.keys():
pred_x, pred_y, pred_z = Tracker.Model.measure(Tracker.Filters[k].Predicted_X[i])
pred_x_img = pred_y / res
pred_y_img = pred_x / res
pred_marker = db.setMarker(frame=i, layer=0, x=pred_x_img, y=pred_y_img,
text="Track %s" % (1000 + k), type=marker_type3)
x_img = y / res
y_img = x / res
# Write assigned tracks to ClickPoints DataBase
if np.isnan(x) or np.isnan(y):
pass
else:
if db.getTrack(k + 1000):
track_marker = db.setMarker(frame=i, layer=0, type=marker_type2,
track=(1000 + k),
x=x_img, y=y_img,
text='Track %s, Prob %.2f, Z-Position %s' % (
(1000 + k), prob, z))
print('Set Track(%s)-Marker at %s, %s' % ((1000 + k), x_img, y_img))
else:
db.setTrack(marker_type2, id=1000 + k, hidden=False)
if k == Tracker.CriticalIndex:
db.setMarker(image=i, layer=0, type=marker_type2, x=x_img, y=y_img,
text='Track %s, Prob %.2f, CRITICAL' % ((1000 + k), prob))
track_marker = db.setMarker(image=image, type=marker_type2,
track=1000 + k,
x=x_img,
y=y_img,
text='Track %s, Prob %.2f, Z-Position %s' % (
(1000 + k), prob, z))
print('Set new Track %s and Track-Marker at %s, %s' % ((1000 + k), x_img, y_img))
meas_entry = db.setMeasurement(marker=track_marker, log=prob, x=x, y=y, z=z)
meas_entry.save()
import scipy.stats as ss
import numpy as np
# Set up Kalman filter
X = np.zeros(model.State_dim).T # Initial Value for Position
Q = np.diag([q * object_size * np.ones(model.Evolution_dim)
]) # Prediction uncertainty
R = np.diag([r * object_size * np.ones(model.Meas_dim)
]) # Measurement uncertainty
State_Dist = ss.multivariate_normal(
cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(
cov=R) # Initialize Distributions for Filter
# Initialize Filter/Tracker
MultiKal = MultiFilter(KalmanFilter,
model,
np.diag(Q),
np.diag(R),
meas_dist=Meas_Dist,
state_dist=State_Dist)
MultiKal.LogProbabilityThreshold = log_prob_threshold
# Extended Clickpoints Database for usage with pengutack
from PenguTrack.DataFileExtended import DataFileExtended
# Open ClickPoints Database
db = DataFileExtended("./ExampleData/sim_data.cdb", "w")
# Define ClickPoints Marker
detection_marker_type = db.setMarkerType(name="Detection_Marker",
color="#FF0000",
style='{"scale":1.2}')
db.deleteMarkers(type=detection_marker_type)
track_marker_type = db.setMarkerType(name="Track_Marker",
color="#00FF00",
object_size = 3 # Object diameter (smallest)
object_number = 1 # Number of Objects in First Track
object_area = 3
# Initialize physical model as 2d variable speed model with 0.5 Hz frame-rate
model = VariableSpeed(1, 1, dim=2, timeconst=1.)
X = np.zeros(4).T # Initial Value for Position
Q = np.diag([q*object_size, q*object_size]) # Prediction uncertainty
R = np.diag([r*object_size, r*object_size]) # Measurement uncertainty
State_Dist = ss.multivariate_normal(cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(cov=R) # Initialize Distributions for Filter
# Initialize Filter
MultiKal = MultiFilter(KalmanFilter, model, np.diag(Q),
np.diag(R))#, meas_dist=Meas_Dist, state_dist=State_Dist)
# MultiKal.LogProbabilityThreshold = -10000.
MultiKal.LogProbabilityThreshold = -50.
MultiKal.FilterThreshold = 2
MultiKal.MeasurementProbabilityThreshold = 0.
MultiKal.AssignmentProbabilityThreshold = 0.
# Init_Background from Image_Median
# Initialize segmentation with init_image and start updating the first 10 frames.
init_buffer = []
for i in range(2):
while True:
img, meta = cam.getNewestImage()
if img is not None:
print("Got img from cam")
init_buffer.append(img)
object_size = 1 # Object diameter (smallest)
object_number = 1 # Number of Objects in First Track
object_area = 3
# Initialize physical model as 2d variable speed model with 0.5 Hz frame-rate
model = VariableSpeed(1, 1, dim=2, timeconst=1.)
X = np.zeros(4).T # Initial Value for Position
Q = np.diag([q*object_size, q*object_size]) # Prediction uncertainty
R = np.diag([r*object_size, r*object_size]) # Measurement uncertainty
State_Dist = ss.multivariate_normal(cov=Q) # Initialize Distributions for Filter
Meas_Dist = ss.multivariate_normal(cov=R) # Initialize Distributions for Filter
# Initialize Filter
MultiKal = MultiFilter(KalmanFilter, model, np.diag(Q),
np.diag(R), meas_dist=Meas_Dist, state_dist=State_Dist)
# MultiKal.LogProbabilityThreshold = -300.
MultiKal.MeasurementProbabilityThreshold = 0.
# MultiKal = MultiFilter(Filter, model)
print("Initialized Tracker")
# Init_Background from Image_Median
# Initialize segmentation with init_image and start updating the first 10 frames.
N = db.getImages().count()
init = np.array(np.median([np.asarray(db.getImage(frame=j).data, dtype=np.int)
for j in np.arange(0,10)], axis=0), dtype=np.int)
# VB = ViBeSegmentation(n=2, init_image=init, n_min=2, r=25, phi=1)
VB = ViBeSegmentation(n=3, init_image=init, n_min=3, r=40, phi=1)
print("Debug")
for i in range(10,20):
mask = VB.detect(db.getImage(frame=i).data, do_neighbours=False)