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()
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)
print(init_buffer[-1].shape)
print(init_buffer[-1].dtype)
break
# init = np.array(np.median([init_buffer], axis=0))