def fit_sigmoid(time: np.array, flux: np.array) -> list:
""" Find best-fit parameters using scipy.least_squares.
Parameters
----------
time : array_like
exploratory variable (time of observation)
flux : array_like
response variable (measured flux)
Returns
-------
result : list of float
best fit parameter values
"""
flux = np.asarray(flux)
t0 = time[flux.argmax()] - time[0]
if t0 > 0:
dt = time[flux.argmax()] - time[flux.argmin()]
slope = (flux.argmax() - flux.argmin()) / dt
else:
slope = 1.
f0 = flux[0]
aguess = slope
cguess = np.max(flux)
if f0 != 0 and cguess / f0 != 1.:
bguess = np.log(cguess / f0 - 1.) / aguess
else:
bguess = 1.0
guess = [aguess, bguess, cguess]
result = least_squares(errfunc_sigmoid, guess, args=(time, flux))
return result.x
def match_dets_and_objs(self, distance_matrix: np.array):
"""Matches detections with tracked_objects from a distance matrix
I used to match by minimizing the global distances, but found several
cases in which this was not optimal. So now I just match by starting
with the global minimum distance and matching the det-obj corresponding
to that distance, then taking the second minimum, and so on until we
reach the distance_threshold.
This avoids the the algorithm getting cute with us and matching things
that shouldn't be matching just for the sake of minimizing the global
distance, which is what used to happen
"""
# NOTE: This implementation is terribly inefficient, but it doesn't
# seem to affect the fps at all.
distance_matrix = distance_matrix.copy()
if distance_matrix.size > 0:
det_idxs = []
obj_idxs = []
current_min = distance_matrix.min()
while current_min < self.distance_threshold:
flattened_arg_min = distance_matrix.argmin()
det_idx = flattened_arg_min // distance_matrix.shape[1]
obj_idx = flattened_arg_min % distance_matrix.shape[1]
det_idxs.append(det_idx)
obj_idxs.append(obj_idx)
distance_matrix[det_idx, :] = self.distance_threshold + 1
distance_matrix[:, obj_idx] = self.distance_threshold + 1
current_min = distance_matrix.min()
return det_idxs, obj_idxs
else:
return [], []
def convertRGBToHSVColor(colours : np.array):
col_arr = np.float32(colours)
min_col = colours.argmin()
max_col = colours.argmax()
chroma = col_arr[max_col] - col_arr[min_col]
hue = getHueFromChroma(col_arr, chroma, max_col, min_col)
value = np.mean(col_arr)
saturation = getSatuationFromChroma(col_arr, chroma, value)
return np.array([hue, saturation, value], dtype = np.uint8)
def assign_obs_to_clusters(eucl_dists: np.array):
new_clusters = eucl_dists.argmin(axis=1).reshape(-1, 1) + 1
self.clustered_data = np.hstack((self.data, new_clusters))
