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", mode=db.TYPE_Track) db.deleteMarkers(type=track_marker_type) prediction_marker_type = db.setMarkerType(name="Prediction_Marker",
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()
# 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) print(init_buffer[-1].shape) print(init_buffer[-1].dtype)