mirror of
https://github.com/EyeTrackVR/EyeTrackVR.git
synced 2025-11-04 14:39:42 +08:00
clean up
This commit is contained in:
parent
c6413f8ee1
commit
1c3f382f40
@ -35,7 +35,6 @@ print_enable = False # I don't recommend changing to True.
|
||||
|
||||
# RANSAC
|
||||
thresh_add = 10
|
||||
# calc_print_enable = True
|
||||
skip_autoradius = False
|
||||
skip_blink_detect = False
|
||||
##############################
|
||||
@ -329,317 +328,6 @@ def fit_rotated_ellipse_old(data, P):
|
||||
return (cx, cy, w, h, theta)
|
||||
|
||||
|
||||
@lru_cache(maxsize=lru_maxsize_vs)
|
||||
def get_ransac_empty_array_lendata(len_data,iter_num, sample_num):
|
||||
# Function to reduce array allocation by providing an empty array first and recycling it with lru
|
||||
use_dtype=np.float64
|
||||
datamod = np.empty((len_data, 7), dtype=use_dtype) # np.empty((len(data), 7), dtype=ret_dtype)
|
||||
datamod[:, 5] = 1
|
||||
datamod_b=datamod[:, :5]#.T
|
||||
random_index_init_arr = np.empty((iter_num, len_data), dtype=np.uint16)
|
||||
random_index_init_arr[:, :] = np.arange(len_data, dtype=np.uint16)
|
||||
random_index = np.empty((iter_num, len_data), dtype=np.uint16)
|
||||
random_index_samplenum=random_index[:, :sample_num]
|
||||
ellipse_data_arr=np.empty((iter_num,len_data),dtype=use_dtype)
|
||||
th_abs=np.empty((iter_num,len_data),dtype=use_dtype)
|
||||
|
||||
dm_data_view=datamod[:, :2]# = data
|
||||
dm_p2_view=datamod[:, 2:4]# = data * data
|
||||
dm_mul_view=datamod[:, 4]# = data[:, 0] * data[:, 1]
|
||||
dm_neg_view=datamod[:, 6]# = -datamod[:, 2]
|
||||
|
||||
# return datamod,random_index_init_arr,random_index,ellipse_data_arr,th_abs
|
||||
return datamod,datamod_b,dm_data_view,dm_p2_view,dm_mul_view,dm_neg_view, random_index_init_arr, random_index,random_index_samplenum, ellipse_data_arr, th_abs
|
||||
|
||||
@lru_cache(maxsize=lru_maxsize_s)
|
||||
def get_ransac_empty_array_iternum_samplenum(iter_num, sample_num,len_data):
|
||||
# Function to reduce array allocation by providing an empty array first and recycling it with lru
|
||||
use_dtype=np.float64
|
||||
datamod_rng=np.empty((iter_num,sample_num,7),dtype=use_dtype)
|
||||
datamod_rng_swap = np.empty((iter_num, sample_num, 5), dtype=use_dtype)
|
||||
datamod_rng_swap_trans=datamod_rng_swap.transpose((0,2,1))
|
||||
# datamod_rng_swap_trans = np.empty((iter_num, 5,sample_num), dtype=use_dtype)
|
||||
datamod_rng_5x5= np.empty((iter_num, 5,5), dtype=use_dtype)
|
||||
datamod_rng_p5smp = np.empty((iter_num, 5,sample_num), dtype=use_dtype)
|
||||
datamod_rng_p=np.empty((iter_num,5),dtype=use_dtype)
|
||||
datamod_rng_p_npaxis=datamod_rng_p[:,:,np.newaxis]
|
||||
ellipse_y_arr=np.empty((iter_num,5),dtype=use_dtype)
|
||||
ellipse_y_arr[:, 2] = 1
|
||||
swap_index=np.array([4, 3, 0, 1, 5])
|
||||
dm_brod=np.broadcast_to(datamod_rng_p[:, 4, np.newaxis], (iter_num, len_data))
|
||||
dm_rng_six=datamod_rng[:, :, 6, np.newaxis]
|
||||
dm_rng_p_24_view= datamod_rng_p[:, 2:4]
|
||||
dm_rng_p_10_view= datamod_rng_p[:, 1::-1]
|
||||
el_y_arr_2_view=ellipse_y_arr[:, :2]
|
||||
el_y_arr_3_view=ellipse_y_arr[:, 3:]
|
||||
return datamod_rng,datamod_rng_swap,datamod_rng_swap_trans,datamod_rng_5x5,datamod_rng_p5smp,datamod_rng_p,datamod_rng_p_npaxis,ellipse_y_arr,swap_index,dm_brod,dm_rng_six,dm_rng_p_24_view,dm_rng_p_10_view,el_y_arr_2_view,el_y_arr_3_view
|
||||
|
||||
# @profile
|
||||
def fit_rotated_ellipse_ransac(data: np.ndarray, sfc: np.random.Generator, iter_num=100, sample_num=10, offset=80 # 80.0, 10, 80
|
||||
): # before changing these values, please read up on the ransac algorithm
|
||||
# However if you want to change any value just know that higher iterations will make processing frames slower
|
||||
|
||||
# The array contents do not change during the loop, so only one call is needed.
|
||||
# They say len is faster than shape.
|
||||
# Reference url: https://stackoverflow.com/questions/35547853/what-is-faster-python3s-len-or-numpys-shape
|
||||
len_data = len(data)
|
||||
|
||||
if len_data < sample_num:
|
||||
return None
|
||||
|
||||
# Type of calculation result
|
||||
# ret_dtype = np.float64
|
||||
# todo:create view
|
||||
datamod_rng, datamod_rng_swap, datamod_rng_swap_trans, datamod_rng_5x5, datamod_rng_p5smp, datamod_rng_p,datamod_rng_p_npaxis, ellipse_y_arr,swap_index,dm_brod,dm_rng_six,dm_rng_p_24_view,dm_rng_p_10_view,el_y_arr_2_view,el_y_arr_3_view=get_ransac_empty_array_iternum_samplenum(iter_num,sample_num,len_data)
|
||||
|
||||
datamod,datamod_b,dm_data_view,dm_p2_view,dm_mul_view,dm_neg_view,random_index_init_arr,random_index,random_index_samplenum,ellipse_data_arr,th_abs=get_ransac_empty_array_lendata(len_data,iter_num,sample_num)
|
||||
|
||||
# Sorts a random number array of size (iter,len_data). After sorting, returns the index of sample_num random numbers before sorting.
|
||||
# If the array size is less than about 100, this is faster than rng.choice.
|
||||
# rng_sample = rng.random((iter_num, len_data),dtype=np.float32).argsort()[:, :sample_num]#out=
|
||||
# or
|
||||
# I don't see any advantage to doing this.
|
||||
# rng_sample = np.asarray(rng.random((iter, len_data)).argsort()[:, :sample_num], dtype=np.int32)
|
||||
|
||||
# I don't think it looks beautiful.
|
||||
# x,y,x**2,y**2,x*y,1,-1*x**2
|
||||
# datamod = np.concatenate(
|
||||
# [data, data ** 2, (data[:, 0] * data[:, 1])[:, np.newaxis], np.ones((len_data, 1), dtype=ret_dtype),
|
||||
# (-1 * data[:, 0] ** 2)[:, np.newaxis]], axis=1,
|
||||
# dtype=ret_dtype)
|
||||
|
||||
# I don't think it looks beautiful.
|
||||
# x,y,x**2,y**2,x*y,1,-1*x**2
|
||||
# data_squared = np.square(data)
|
||||
# datamod = np.empty((len(data), 7), dtype=ret_dtype) # np.empty((len(data), 7), dtype=ret_dtype)
|
||||
# datamod[:, :2] = data#[:]
|
||||
# # datamod[:, 2:4] = np.square(data) # or data**2
|
||||
# # np.square(data,out=datamod[:, 2:4])#casting,dtype
|
||||
# datamod[:, 2:4] = data * data
|
||||
# datamod[:, 4] = data[:, 0] * data[:, 1]
|
||||
# # datamod[:, 4]=data.prod(axis=1,dtype=np.float64)
|
||||
# # datamod[:, 5] = 1
|
||||
# datamod[:, 6] = -datamod[:, 2] # -1 * data[:, 0] ** 2#
|
||||
|
||||
dm_data_view[:, :] = data#[:]
|
||||
dm_p2_view[:,:] = data * data
|
||||
dm_mul_view[:] = data[:, 0] * data[:, 1]
|
||||
dm_neg_view[:] = -dm_p2_view[:,0] # -1 * data[:, 0] ** 2#
|
||||
|
||||
|
||||
|
||||
# datamod_slim = np.array(datamod[:, :5], dtype=ret_dtype)
|
||||
#
|
||||
# datamod_rng = datamod[rng_sample]
|
||||
# datamod_rng = rng.choice(datamod, (iter, sample_num), replace=True, shuffle=False)
|
||||
# datamod_rng = datamod[rng.choice(len_data, (iter,len_data),shuffle=False)[:,:sample_num]]
|
||||
|
||||
# random_index = np.empty((iter_num, len_data), dtype=np.uint16)
|
||||
# random_index[:, :] = np.arange(len_data, dtype=np.uint16)
|
||||
# random_index_bro = np.broadcast_to(np.arange(len_data, dtype=np.uint16), (iter_num, len_data))
|
||||
# or
|
||||
# random_index = np.zeros(100,dtype=np.uint16).reshape((-1,1))+ np.arange(len_data, dtype=np.uint16).reshape((1, len_data))
|
||||
# sfc.permuted(random_index, axis=1, out=random_index)
|
||||
sfc.permuted(random_index_init_arr, axis=1, out=random_index)
|
||||
# random_index = sfc.permuted(np.broadcast_to(np.arange(len_data, dtype=np.uint16), (iter_num, len_data)),axis=1)
|
||||
|
||||
# datamod_rng = datamod[random_index[:,:sample_num]]#take
|
||||
# np.take replaces a[ind,:] and is 3-4 times faster, https://gist.github.com/rossant/4645217
|
||||
# datamod_rng = np.take(datamod,random_index[:,:sample_num],axis=0)
|
||||
# datamod_rng = datamod.take(random_index[:, :sample_num], axis=0, mode="clip")# iter_num,sample_num,7
|
||||
# datamod.take(random_index[:, :sample_num], axis=0, mode="clip",out=datamod_rng) # iter_num,sample_num,7
|
||||
datamod.take(random_index_samplenum, axis=0, mode="clip", out=datamod_rng)
|
||||
|
||||
# datamod_rng = datamod[rng_sample]#out=
|
||||
|
||||
# datamod_rng_swap = datamod_rng[:, :, [4, 3, 0, 1, 5]] # out= # iter_num,sample_num,5
|
||||
# datamod_rng_swap[:,:,:] = datamod_rng[:, :, [4, 3, 0, 1, 5]] # out= # iter_num,sample_num,
|
||||
|
||||
datamod_rng.take(swap_index, axis=2,mode="clip",out=datamod_rng_swap)
|
||||
# or
|
||||
# datamod_rng_swap = np.take(datamod_rng,[4, 3, 0, 1, 5],axis=2)
|
||||
|
||||
# datamod_rng_swap_trans = datamod_rng_swap.transpose((0, 2, 1)) # out=
|
||||
# datamod_rng_swap_trans[:,:,:] = datamod_rng_swap.transpose((0, 2, 1))#.copy() # out=
|
||||
#
|
||||
# # These two lines are one of the bottlenecks
|
||||
# datamod_rng_5x5 = np.matmul(datamod_rng_swap_trans, datamod_rng_swap)
|
||||
# datamod_rng_p5smp = np.matmul(np.linalg.inv(datamod_rng_5x5), datamod_rng_swap_trans)
|
||||
# datamod_rng_p5smp = np.matmul(np.linalg.inv(np.matmul(datamod_rng_swap_trans, datamod_rng_swap)), datamod_rng_swap_trans)
|
||||
np.matmul(datamod_rng_swap_trans, datamod_rng_swap,out=datamod_rng_5x5)
|
||||
# I want to use cv2.mulTransposed, but for some reason the results are different and it can only use 1-channel arrays.
|
||||
# np.linalg.inv(datamod_rng_5x5)
|
||||
# datamod_rng_5x5[:,:,:]=np.linalg.inv(datamod_rng_5x5)
|
||||
# _umath_linalg.inv(datamod_rng_5x5,out=datamod_rng_5x5)# check error
|
||||
# https://github.com/bogovicj/JaneliaMLCourse/issues/1
|
||||
# solve is slow
|
||||
# np.linalg.solve(np.matmul(datamod_rng_swap_trans, datamod_rng_swap), datamod_rng_swap_trans)
|
||||
_umath_linalg.inv(datamod_rng_5x5, signature='d->d', extobj=np.linalg.linalg.get_linalg_error_extobj(np.linalg.linalg._raise_linalgerror_singular),out=datamod_rng_5x5)
|
||||
|
||||
np.matmul(datamod_rng_5x5, datamod_rng_swap_trans,out=datamod_rng_p5smp)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# global ein_path
|
||||
# if ein_path is None:
|
||||
# ein_path = np.einsum_path("ijk,ijl->ikl", datamod_rng_swap, datamod_rng_swap, optimize='optimal')[0]#'optimal','greedy'
|
||||
# datamod_rng_p5smp = np.matmul(np.linalg.inv(np.einsum("ijk,ijl->ikl", datamod_rng_swap, datamod_rng_swap,casting="no",optimize=ein_path)), datamod_rng_swap_trans)
|
||||
# # np.einsum('ijk,ilk->ijl', dataswap_trans, dataswap)
|
||||
#
|
||||
# datamod_rng_p = np.matmul(datamod_rng_p5smp, datamod_rng[:, :, 6, np.newaxis]).reshape((-1, 5)) # out= # iter_num,5
|
||||
# datamod_rng_p[:,:]=np.matmul(datamod_rng_p5smp, datamod_rng[:, :, 6, np.newaxis]).reshape((-1, 5)) # out= # iter_num,5
|
||||
np.matmul(datamod_rng_p5smp, dm_rng_six,out=datamod_rng_p_npaxis)
|
||||
|
||||
|
||||
|
||||
#
|
||||
# # I don't think it looks beautiful.
|
||||
# ellipse_y_arr = np.asarray(
|
||||
# [datamod_rng_p[:, 2], datamod_rng_p[:, 3], np.ones(iter_num,dtype=ret_dtype), datamod_rng_p[:, 1], datamod_rng_p[:, 0]], dtype=ret_dtype)
|
||||
|
||||
# ellipse_y_arr = np.empty((iter_num, 5), dtype=ret_dtype)
|
||||
# ellipse_y_arr[0,:]=datamod_rng_p[:, 2]
|
||||
# ellipse_y_arr[1, :]=datamod_rng_p[:, 3]
|
||||
# ellipse_y_arr[:, :2] = datamod_rng_p[:, 2:4]
|
||||
# # ellipse_y_arr[:, 2] = 1
|
||||
# ellipse_y_arr[:, 3:] = datamod_rng_p[:, 1::-1]
|
||||
|
||||
el_y_arr_2_view[:,:]= dm_rng_p_24_view#datamod_rng_p[:, 2:4]
|
||||
el_y_arr_3_view[:,:] = dm_rng_p_10_view#datamod_rng_p[:, 1::-1]
|
||||
|
||||
# ellipse_y_arr[:,3:]=datamod_rng_p[:,1]
|
||||
# ellipse_y_arr[4,:]=datamod_rng_p[:,0]
|
||||
# ellipse_data_arr = np.asarray(ellipse_model(datamod[:, :5], ellipse_y_arr.T, np.asarray(datamod_rng_p[:, 4])).transpose((1, 0)))
|
||||
# ellipse_data_arr = datamod[:, :5].dot(ellipse_y_arr.T)+np.asarray(datamod_rng_p[:, 4])
|
||||
# ellipse_data_arr = np.matmul(ellipse_y_arr, datamod[:, :5].T) + np.asarray(datamod_rng_p[:, 4, np.newaxis])# iter_num,len_data
|
||||
# np.matmul(ellipse_y_arr, datamod_t,out=ellipse_data_arr)
|
||||
# ellipse_y_arr.dot(datamod[:, :5].T, out=ellipse_data_arr)
|
||||
# ellipse_data_arr+=datamod_rng_p[:, 4, np.newaxis]#np.asarray(datamod_rng_p[:, 4, np.newaxis])
|
||||
# cv2.gemm is slower and for some reason the src3 argument for addition is not available
|
||||
cv2.gemm(ellipse_y_arr,datamod_b,1.0,dm_brod,1.0,dst=ellipse_data_arr,flags=cv2.GEMM_2_T)
|
||||
# ellipse_data_arr[:,:]=scipy.linalg.blas.dgemm(alpha=1.0, a=ellipse_y_arr, b=datamod_b, beta=1.0, c=np.broadcast_to(datamod_rng_p[:, 4, np.newaxis], (iter_num, len_data)),trans_b=True, overwrite_c=False)
|
||||
|
||||
# ellipse_data_arr=ellipse_y_arr.dot(datamod[:, :5].T) + np.asarray(datamod_rng_p[:, 4, np.newaxis])
|
||||
# ellipse_data_arr =ellipse_data_arr.transpose((1, 0))
|
||||
# ellipse_data_arr = np.einsum("ij,kj->ki",np.asarray(datamod[:, :5]),ellipse_y_arr)+np.asarray(datamod_rng_p[:, 4,np.newaxis])
|
||||
|
||||
# Q, R = np.linalg.qr(datamod_rng_swap_trans)
|
||||
# # datarng_T = datamod_rng.transpose((0, 2, 1))
|
||||
# Qtb = Q @ datamod_rng[:, :, 6].reshape((iter_num,5,5))
|
||||
# p = np.linalg.solve(R, Qtb)
|
||||
# Q, R = np.linalg.qr(datamod_rng_swap)#, mode='raw')
|
||||
# Qtb = Q.transpose((0, 2, 1)) @ datamod_rng[:, :, 6, np.newaxis]
|
||||
# p = np.linalg.solve(R, Qtb.reshape((-1, 5)))
|
||||
# hoge=datamod_rng_swap.transpose((0, 2, 1))@datamod_rng_swap
|
||||
# inv_h=np.linalg.inv(hoge)
|
||||
# D, U = np.linalg.eigh(hoge)
|
||||
# Ap = (U * np.sqrt(D)).T
|
||||
|
||||
# smp=np.linalg.solve(R, Q.transpose((0, 2, 1)))
|
||||
# smp= np.matmul(np.linalg.inv(R), Q.transpose((0, 2, 1)))
|
||||
# datamod_rng_p=np.matmul(smp, datamod_rng[:, :,6, np.newaxis]).reshape((-1, 5))
|
||||
# ellipse_y_arr = np.asarray([datamod_rng_p[:,2], datamod_rng_p[:,3], np.ones(iter_num), datamod_rng_p[:,1], datamod_rng_p[:,0]], dtype=ret_dtype)
|
||||
# ellipse_data_arr = datamod[:, :5].dot(ellipse_y_arr) + datamod_rng_p[:,4]
|
||||
# ellipse_data_arr = ellipse_data_arr.transpose((1, 0))
|
||||
|
||||
# ellipse_data_abs = np.abs(ellipse_data_arr)
|
||||
# ellipse_data_abs = cv2.absdiff(ellipse_data_arr, 0)
|
||||
# ellipse_data_index = np.argmax(np.sum(ellipse_data_abs < offset, axis=1), axis=0)
|
||||
# ellipse_data_index = np.argmax(cv2.reduce(cv2.threshold(ellipse_data_abs, offset, 1, cv2.THRESH_BINARY_INV)[1], 1, cv2.REDUCE_SUM).reshape(-1), axis=0)
|
||||
# ellipse_data_index = cv2.reduceArgMax(cv2.reduce((ellipse_data_abs < offset)*1.0, 1, cv2.REDUCE_SUM),axis=0)[0,0]
|
||||
# ellipse_data_index = cv2.reduceArgMax(cv2.reduce(cv2.threshold(ellipse_data_abs, offset, 1, cv2.THRESH_BINARY_INV)[1], 1, cv2.REDUCE_SUM),axis=0)[0,0]
|
||||
# ellipse_data_index = np.einsum("ij->i", cv2.threshold(ellipse_data_abs, offset, 1, cv2.THRESH_BINARY_INV)[1]).argmax()
|
||||
# ellipse_data_index = \
|
||||
# cv2.minMaxLoc(cv2.reduce(cv2.threshold(np.abs(ellipse_data_arr), offset, 1, cv2.THRESH_BINARY_INV)[1], 1, cv2.REDUCE_SUM))[3][1]
|
||||
np.abs(ellipse_data_arr,out=th_abs)
|
||||
cv2.threshold(th_abs, offset, 1.0, cv2.THRESH_BINARY_INV,dst=th_abs)#[1]
|
||||
ellipse_data_index = \
|
||||
cv2.minMaxLoc(cv2.reduce(th_abs, 1, cv2.REDUCE_SUM))[3][1]
|
||||
# ellipse_data_index = np.linalg.norm(cv2.threshold(ellipse_data_abs, offset, 1, cv2.THRESH_BINARY_INV)[1],ord=0,axis=1).argmax()
|
||||
# if ellipse_data_index!=a:
|
||||
# print()
|
||||
# effective_data_arr = ellipse_data_arr[ellipse_data_index]
|
||||
# error_num = ellipse_data_arr[ellipse_data_index].sum()
|
||||
error_num = cv2.sumElems(ellipse_data_arr[ellipse_data_index])[0]
|
||||
effective_sample_p_arr = datamod_rng_p[ellipse_data_index].tolist()
|
||||
|
||||
# if fit_rotated_ellipse(effective_data_arr.sum(), effective_sample_p_arr)!= fit_rotated_ellipse_base(effective_data_arr, effective_sample_p_arr):
|
||||
# print()
|
||||
return fit_rotated_ellipse(error_num, effective_sample_p_arr)
|
||||
|
||||
|
||||
# @profile
|
||||
def fit_rotated_ellipse(data, P):
|
||||
# a = 1.0
|
||||
# # b, c, d, e, f = P
|
||||
# b, c, d, e, f = P[0], P[1], P[2], P[3], P[4]
|
||||
# # b = P[0]
|
||||
# # c = P[1]
|
||||
# # d = P[2]
|
||||
# # e = P[3]
|
||||
# # f = P[4]
|
||||
# # The cost of trigonometric functions is high.
|
||||
# theta = 0.5 * math.atan2(b, a-c)# math.atan(b / (a - c))# #np.arctan(b / (a - c), dtype=np.float64)
|
||||
# # theta_sin = np.sin(theta, dtype=np.float64)
|
||||
# # theta_cos = np.cos(theta, dtype=np.float64)
|
||||
# theta_sin, theta_cos = math.sin(theta), math.cos(theta)
|
||||
# tc2 = theta_cos ** 2
|
||||
# ts2 = theta_sin ** 2
|
||||
# b_tcs = b * theta_cos * theta_sin
|
||||
#
|
||||
# # Do the calculation only once
|
||||
# cxy = b ** 2 - 4 * a * c
|
||||
# cx = (2 * c * d - b * e) / cxy
|
||||
# cy = (2 * a * e - b * d) / cxy
|
||||
#
|
||||
# # I just want to clear things up around here.
|
||||
# cu = a * cx ** 2 + b * cx * cy + c * cy ** 2 - f
|
||||
# # cu_r = np.array([(a * tc2 + b_tcs + c * ts2), (a * ts2 - b_tcs + c * tc2)])
|
||||
# # wh = np.sqrt(cu / cu_r)
|
||||
#
|
||||
# w = math.sqrt(cu/(a * tc2 + b_tcs + c * ts2))
|
||||
# h = math.sqrt(cu/(a * ts2 - b_tcs + c * tc2))
|
||||
|
||||
a = 1.0
|
||||
# b, c, d, e, f = P[0], P[1], P[2], P[3], P[4]
|
||||
b, c, d, e = P[0], P[1], P[2], P[3]
|
||||
theta = 0.5 * math.atan(b / (a - c)) # math.atan2(b, a - c)
|
||||
theta_sin, theta_cos = math.sin(theta), math.cos(theta)
|
||||
tc2 = theta_cos * theta_cos
|
||||
ts2 = theta_sin * theta_sin
|
||||
b_tcs = b * theta_cos * theta_sin
|
||||
cxy = b * b - 4 * a * c
|
||||
cx = (2 * c * d - b * e) / cxy
|
||||
cy = (2 * a * e - b * d) / cxy
|
||||
# cu = a * cx * cx + b * cx * cy + c * cy * cy - P[4]#f
|
||||
cu = c * cy * cy + cx * (a * cx + b * cy) - P[4]
|
||||
# here: https://stackoverflow.com/questions/327002/which-is-faster-in-python-x-5-or-math-sqrtx
|
||||
# and : https://gist.github.com/zed/783011
|
||||
w = math.sqrt(cu / (a * tc2 + b_tcs + c * ts2))
|
||||
h = math.sqrt(cu / (a * ts2 - b_tcs + c * tc2))
|
||||
|
||||
# error_sum = data.sum()#sum(data)#np.sum(data)
|
||||
# error_sum = data[0] + data[1] + data[2] + data[3] + data[4] + data[5] + data[6] + data[7] + data[8] + data[9] + data[10]
|
||||
error_sum = data # sum(data)
|
||||
# print("fitting error = %.3f" % (error_sum))
|
||||
|
||||
# cxy2 = P[0] * P[0] - 4 * a * P[1]
|
||||
# theta2 = 0.5 * math.atan(P[0] / (a - P[1]))
|
||||
# theta_sin2, theta_cos2 = math.sin(theta2), math.cos(theta2)
|
||||
# tc22 = theta_cos2 * theta_cos2
|
||||
# ts22 = theta_sin2 * theta_sin2
|
||||
# b_tcs2 = P[0] * theta_cos2 * theta_sin2
|
||||
# cx2 = (2 * P[1] * P[2] - P[0] * P[3]) / cxy2
|
||||
# cy2 = (2 * a * P[3] - P[0] * P[2]) / cxy2
|
||||
# cu2 = P[1] * cy2 * cy2 + cx2 * (a * cx2 + P[0] * cy2) - P[4]
|
||||
# w2 = math.sqrt(cu2 / (a * tc22 + b_tcs2 + P[1] * ts22))
|
||||
# h2 = math.sqrt(cu2 / (a * ts22 - b_tcs2 + P[1] * tc22))
|
||||
|
||||
return cx, cy, w, h, theta
|
||||
|
||||
|
||||
class CvParameters_old:
|
||||
# It may be a little slower because a dict named "self" is read for each function call.
|
||||
def __init__(self, radius, step):
|
||||
@ -719,6 +407,7 @@ class HaarSurroundFeature_old:
|
||||
|
||||
return kernel
|
||||
|
||||
|
||||
@lru_cache(maxsize=lru_maxsize_vvs)
|
||||
def get_hsf_empty_array_old(len_syx, frameint_x, frame_int_dtype, fcshape):
|
||||
# Function to reduce array allocation by providing an empty array first and recycling it with lru
|
||||
@ -786,7 +475,7 @@ def conv_int_old(frame_int, kernel, xy_step, padding, xy_steps_list):
|
||||
|
||||
len_sx, len_sy = len(xy_steps_list[0]), len(xy_steps_list[1])
|
||||
inout_sum, p_temp, p_list, response_list, frameconvlist = get_hsf_empty_array_old((len_sy, len_sx), col + 1,
|
||||
frame_int.dtype, (f_shape, y_step, x_step))
|
||||
frame_int.dtype, (f_shape, y_step, x_step))
|
||||
inner_sum, outer_sum = inout_sum
|
||||
p00, p11, p01, p10 = p_list
|
||||
frame_conv, frame_conv_stride = frameconvlist
|
||||
@ -850,6 +539,151 @@ def conv_int_old(frame_int, kernel, xy_step, padding, xy_steps_list):
|
||||
return frame_conv, min_response, center
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@lru_cache(maxsize=lru_maxsize_vs)
|
||||
def get_ransac_empty_array_lendata_new(len_data,iter_num, sample_num):
|
||||
# Function to reduce array allocation by providing an empty array first and recycling it with lru
|
||||
use_dtype=np.float64
|
||||
datamod = np.empty((len_data, 7), dtype=use_dtype) # np.empty((len(data), 7), dtype=ret_dtype)
|
||||
datamod[:, 5] = 1
|
||||
datamod_b=datamod[:, :5]#.T
|
||||
random_index_init_arr = np.empty((iter_num, len_data), dtype=np.uint16)
|
||||
random_index_init_arr[:, :] = np.arange(len_data, dtype=np.uint16)
|
||||
random_index = np.empty((iter_num, len_data), dtype=np.uint16)
|
||||
random_index_samplenum=random_index[:, :sample_num]
|
||||
ellipse_data_arr=np.empty((iter_num,len_data),dtype=use_dtype)
|
||||
th_abs=np.empty((iter_num,len_data),dtype=use_dtype)
|
||||
|
||||
dm_data_view=datamod[:, :2]# = data
|
||||
dm_p2_view=datamod[:, 2:4]# = data * data
|
||||
dm_mul_view=datamod[:, 4]# = data[:, 0] * data[:, 1]
|
||||
dm_neg_view=datamod[:, 6]# = -datamod[:, 2]
|
||||
|
||||
# return datamod,random_index_init_arr,random_index,ellipse_data_arr,th_abs
|
||||
return datamod,datamod_b,dm_data_view,dm_p2_view,dm_mul_view,dm_neg_view, random_index_init_arr, random_index,random_index_samplenum, ellipse_data_arr, th_abs
|
||||
|
||||
@lru_cache(maxsize=lru_maxsize_s)
|
||||
def get_ransac_empty_array_iternum_samplenum_new(iter_num, sample_num,len_data):
|
||||
# Function to reduce array allocation by providing an empty array first and recycling it with lru
|
||||
use_dtype=np.float64
|
||||
datamod_rng=np.empty((iter_num,sample_num,7),dtype=use_dtype)
|
||||
datamod_rng_swap = np.empty((iter_num, sample_num, 5), dtype=use_dtype)
|
||||
datamod_rng_swap_trans=datamod_rng_swap.transpose((0,2,1))
|
||||
# datamod_rng_swap_trans = np.empty((iter_num, 5,sample_num), dtype=use_dtype)
|
||||
datamod_rng_5x5= np.empty((iter_num, 5,5), dtype=use_dtype)
|
||||
datamod_rng_p5smp = np.empty((iter_num, 5,sample_num), dtype=use_dtype)
|
||||
datamod_rng_p=np.empty((iter_num,5),dtype=use_dtype)
|
||||
datamod_rng_p_npaxis=datamod_rng_p[:,:,np.newaxis]
|
||||
ellipse_y_arr=np.empty((iter_num,5),dtype=use_dtype)
|
||||
ellipse_y_arr[:, 2] = 1
|
||||
swap_index=np.array([4, 3, 0, 1, 5])
|
||||
dm_brod=np.broadcast_to(datamod_rng_p[:, 4, np.newaxis], (iter_num, len_data))
|
||||
dm_rng_six=datamod_rng[:, :, 6, np.newaxis]
|
||||
dm_rng_p_24_view= datamod_rng_p[:, 2:4]
|
||||
dm_rng_p_10_view= datamod_rng_p[:, 1::-1]
|
||||
el_y_arr_2_view=ellipse_y_arr[:, :2]
|
||||
el_y_arr_3_view=ellipse_y_arr[:, 3:]
|
||||
return datamod_rng,datamod_rng_swap,datamod_rng_swap_trans,datamod_rng_5x5,datamod_rng_p5smp,datamod_rng_p,datamod_rng_p_npaxis,ellipse_y_arr,swap_index,dm_brod,dm_rng_six,dm_rng_p_24_view,dm_rng_p_10_view,el_y_arr_2_view,el_y_arr_3_view
|
||||
|
||||
# @profile
|
||||
def fit_rotated_ellipse_ransac_new(data: np.ndarray, sfc: np.random.Generator, iter_num=100, sample_num=10, offset=80 # 80.0, 10, 80
|
||||
): # before changing these values, please read up on the ransac algorithm
|
||||
# However if you want to change any value just know that higher iterations will make processing frames slower
|
||||
|
||||
# The array contents do not change during the loop, so only one call is needed.
|
||||
# They say len is faster than shape.
|
||||
# Reference url: https://stackoverflow.com/questions/35547853/what-is-faster-python3s-len-or-numpys-shape
|
||||
len_data = len(data)
|
||||
|
||||
if len_data < sample_num:
|
||||
return None
|
||||
|
||||
# Type of calculation result
|
||||
# ret_dtype = np.float64
|
||||
# todo:create view
|
||||
datamod_rng, datamod_rng_swap, datamod_rng_swap_trans, datamod_rng_5x5, datamod_rng_p5smp, datamod_rng_p,datamod_rng_p_npaxis, ellipse_y_arr,swap_index,dm_brod,dm_rng_six,dm_rng_p_24_view,dm_rng_p_10_view,el_y_arr_2_view,el_y_arr_3_view=get_ransac_empty_array_iternum_samplenum_new(iter_num,sample_num,len_data)
|
||||
|
||||
datamod,datamod_b,dm_data_view,dm_p2_view,dm_mul_view,dm_neg_view,random_index_init_arr,random_index,random_index_samplenum,ellipse_data_arr,th_abs=get_ransac_empty_array_lendata_new(len_data,iter_num,sample_num)
|
||||
|
||||
|
||||
# I don't think it looks beautiful.
|
||||
# x,y,x**2,y**2,x*y,1,-1*x**2
|
||||
# datamod = np.concatenate(
|
||||
# [data, data ** 2, (data[:, 0] * data[:, 1])[:, np.newaxis], np.ones((len_data, 1), dtype=ret_dtype),
|
||||
# (-1 * data[:, 0] ** 2)[:, np.newaxis]], axis=1,
|
||||
# dtype=ret_dtype)
|
||||
|
||||
dm_data_view[:, :] = data#[:]
|
||||
dm_p2_view[:,:] = data * data
|
||||
dm_mul_view[:] = data[:, 0] * data[:, 1]
|
||||
dm_neg_view[:] = -dm_p2_view[:,0] # -1 * data[:, 0] ** 2#
|
||||
|
||||
# Sorts a random number array of size (iter,len_data). After sorting, returns the index of sample_num random numbers before sorting.
|
||||
sfc.permuted(random_index_init_arr, axis=1, out=random_index)
|
||||
|
||||
# np.take replaces a[ind,:] and is 3-4 times faster, https://gist.github.com/rossant/4645217
|
||||
# a.take() is faster than np.take(a)
|
||||
datamod.take(random_index_samplenum, axis=0, mode="clip", out=datamod_rng)
|
||||
|
||||
datamod_rng.take(swap_index, axis=2, mode="clip", out=datamod_rng_swap)
|
||||
# or
|
||||
# datamod_rng_swap = np.take(datamod_rng,[4, 3, 0, 1, 5],axis=2)
|
||||
|
||||
np.matmul(datamod_rng_swap_trans, datamod_rng_swap, out=datamod_rng_5x5)
|
||||
# I want to use cv2.mulTransposed, but for some reason the results are different and it can only use 1-channel arrays.
|
||||
# np.linalg.solve(np.matmul(datamod_rng_swap_trans, datamod_rng_swap), datamod_rng_swap_trans) # solve is slow https://github.com/bogovicj/JaneliaMLCourse/issues/1
|
||||
_umath_linalg.inv(datamod_rng_5x5, signature='d->d', extobj=np.linalg.linalg.get_linalg_error_extobj(np.linalg.linalg._raise_linalgerror_singular), out=datamod_rng_5x5)
|
||||
np.matmul(datamod_rng_5x5, datamod_rng_swap_trans, out=datamod_rng_p5smp)
|
||||
|
||||
np.matmul(datamod_rng_p5smp, dm_rng_six, out=datamod_rng_p_npaxis)
|
||||
|
||||
el_y_arr_2_view[:,:] = dm_rng_p_24_view
|
||||
el_y_arr_3_view[:,:] = dm_rng_p_10_view
|
||||
|
||||
cv2.gemm(ellipse_y_arr,datamod_b,1.0,dm_brod,1.0,dst=ellipse_data_arr,flags=cv2.GEMM_2_T)
|
||||
|
||||
np.abs(ellipse_data_arr,out=th_abs)
|
||||
cv2.threshold(th_abs, offset, 1.0, cv2.THRESH_BINARY_INV,dst=th_abs)#[1]
|
||||
ellipse_data_index = \
|
||||
cv2.minMaxLoc(cv2.reduce(th_abs, 1, cv2.REDUCE_SUM))[3][1]
|
||||
|
||||
# error_num = ellipse_data_arr[ellipse_data_index].sum()
|
||||
error_num = cv2.sumElems(ellipse_data_arr[ellipse_data_index])[0]
|
||||
effective_sample_p_arr = datamod_rng_p[ellipse_data_index].tolist()
|
||||
|
||||
# if fit_rotated_ellipse(effective_data_arr.sum(), effective_sample_p_arr)!= fit_rotated_ellipse_base(effective_data_arr, effective_sample_p_arr):
|
||||
# print()
|
||||
return fit_rotated_ellipse_new(error_num, effective_sample_p_arr)
|
||||
|
||||
|
||||
# @profile
|
||||
def fit_rotated_ellipse_new(data, P):
|
||||
a = 1.0
|
||||
# b, c, d, e, f = P[0], P[1], P[2], P[3], P[4]
|
||||
b, c, d, e = P[0], P[1], P[2], P[3]
|
||||
theta = 0.5 * math.atan(b / (a - c)) # math.atan2(b, a - c)
|
||||
theta_sin, theta_cos = math.sin(theta), math.cos(theta)
|
||||
tc2 = theta_cos * theta_cos
|
||||
ts2 = theta_sin * theta_sin
|
||||
b_tcs = b * theta_cos * theta_sin
|
||||
cxy = b * b - 4 * a * c
|
||||
cx = (2 * c * d - b * e) / cxy
|
||||
cy = (2 * a * e - b * d) / cxy
|
||||
# cu = a * cx * cx + b * cx * cy + c * cy * cy - P[4]
|
||||
cu = c * cy * cy + cx * (a * cx + b * cy) - P[4]
|
||||
# here: https://stackoverflow.com/questions/327002/which-is-faster-in-python-x-5-or-math-sqrtx
|
||||
# and : https://gist.github.com/zed/783011
|
||||
w = math.sqrt(cu / (a * tc2 + b_tcs + c * ts2))
|
||||
h = math.sqrt(cu / (a * ts2 - b_tcs + c * tc2))
|
||||
error_sum = data # sum(data)
|
||||
# print("fitting error = %.3f" % (error_sum))
|
||||
|
||||
return cx, cy, w, h, theta
|
||||
|
||||
|
||||
class CvParameters_new:
|
||||
# It may be a little slower because a dict named "self" is read for each function call.
|
||||
def __init__(self, radius, step):
|
||||
@ -930,7 +764,7 @@ class HaarSurroundFeature_new:
|
||||
return kernel
|
||||
|
||||
@lru_cache(maxsize=lru_maxsize_vvs)
|
||||
def get_hsf_empty_array(len_sx,len_sy, frameint_x, frame_int_dtype, fcshape):
|
||||
def get_hsf_empty_array_new(len_sx,len_sy, frameint_x, frame_int_dtype, fcshape):
|
||||
# def get_hsf_empty_array(len_syx, frameint_x, frame_int_dtype, fcshape):
|
||||
# Function to reduce array allocation by providing an empty array first and recycling it with lru
|
||||
len_syx=(len_sy,len_sx)
|
||||
@ -964,51 +798,6 @@ def get_hsf_inout_index(padding, x_step, y_step, col, row, r_in, r_out):#,val_in
|
||||
x_steps_arr = np.arange(padding, col - padding, x_step,dtype=np.int16)
|
||||
len_sx, len_sy = len(x_steps_arr), len(y_steps_arr)
|
||||
|
||||
# y_steps_arr = np.arange(padding, row - padding, y_step)
|
||||
# x_steps_arr = np.arange(padding, col - padding, x_step)
|
||||
# len_sx, len_sy = len(x_steps_arr), len(y_steps_arr)
|
||||
|
||||
# inarr_m = frame_int[y_steps[0]-r_in:y_steps[-1]-r_in+1:y_step]
|
||||
# inarr_p = frame_int[y_steps[0]+r_in:y_steps[-1]+r_in+1:y_step]
|
||||
# inarr_mm = inarr_m[:, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
# inarr_mp = inarr_m[:, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
# inarr_pm = inarr_p[:, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
# inarr_pp = inarr_p[:, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
|
||||
# inarr_ym = np.arange(y_steps_arr[0]-r_in,y_steps_arr[-1]-r_in+1,y_step).reshape(-1,1)#np.ogrid[padding-r_in:y_steps[-1]-r_in+1:y_step],frame_int[y_steps[0]-r_in:y_steps[-1]-r_in+1:y_step]
|
||||
# inarr_yp = np.arange(y_steps_arr[0]+r_in,y_steps_arr[-1]+r_in+1,y_step).reshape(-1,1)#np.ogrid[padding+r_in:y_steps[-1]+r_in+1:y_step],frame_int[y_steps[0]+r_in:y_steps[-1]+r_in+1:y_step]
|
||||
# inarr_mm_index = (inarr_ym,np.arange(x_steps_arr[0]-r_in,x_steps_arr[-1]-r_in+1,x_step).reshape(1,-1))#inarr_m[:, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
# inarr_mp_index = (inarr_ym,np.arange(x_steps_arr[0]+r_in,x_steps_arr[-1]+r_in+1,x_step).reshape(1,-1))#inarr_m[:, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
# inarr_pm_index = (inarr_yp,inarr_mm_index[1].copy())#inarr_p[:, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
# inarr_pp_index = (inarr_yp,inarr_mp_index[1].copy())#inarr_p[:, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
#
|
||||
# y_ro_m = y_steps_arr - r_out
|
||||
# x_ro_m = x_steps_arr - r_out
|
||||
# y_ro_p = y_steps_arr + r_out
|
||||
# x_ro_p = x_steps_arr + r_out
|
||||
#
|
||||
# return x_steps_arr,y_steps_arr,len_sx,len_sy,inarr_mm_index,inarr_mp_index,inarr_pm_index,inarr_pp_index,y_ro_m,x_ro_m,y_ro_p,x_ro_p
|
||||
|
||||
# y_rin_m_f = y_steps_arr[0] - r_in
|
||||
# y_rin_m_e = y_steps_arr[-1] - r_in + 1
|
||||
# y_rin_p_f = y_steps_arr[0] + r_in
|
||||
# y_rin_p_e = y_steps_arr[-1] + r_in + 1
|
||||
#
|
||||
# x_rin_m_f = x_steps_arr[0] - r_in
|
||||
# x_rin_m_e = x_steps_arr[-1] - r_in + 1
|
||||
# x_rin_p_f = x_steps_arr[0] + r_in
|
||||
# x_rin_p_e = x_steps_arr[-1] + r_in + 1
|
||||
|
||||
# y_rin_m_f = padding - r_in
|
||||
# y_rin_m_e = y_steps_arr[-1] - r_in + 1
|
||||
# y_rin_p_f = padding + r_in
|
||||
# y_rin_p_e = y_steps_arr[-1] + r_in + 1
|
||||
#
|
||||
# x_rin_m_f = padding - r_in
|
||||
# x_rin_m_e = x_steps_arr[-1] - r_in + 1
|
||||
# x_rin_p_f = padding + r_in
|
||||
# x_rin_p_e = x_steps_arr[-1] + r_in + 1
|
||||
|
||||
y_end=padding+(y_step*(len_sy-1))
|
||||
x_end=padding+(x_step*(len_sx-1))
|
||||
y_rin_m_f = padding - r_in
|
||||
@ -1108,163 +897,17 @@ def conv_int(frame_int, kernel, x_step,y_step, padding,in_p00_view, in_p11_view,
|
||||
:param padding: int
|
||||
:return:
|
||||
"""
|
||||
# row, col = frame_int.shape
|
||||
# row -= 1
|
||||
# col -= 1
|
||||
# x_step, y_step = xy_step
|
||||
# padding2 = 2 * padding
|
||||
# f_shape = row - 2 * padding, col - 2 * padding
|
||||
# r_in = kernel.r_in
|
||||
# len_sx, len_sy = len(x_steps), len(y_steps)
|
||||
# inout_sum, p_temp, p_list, response_list, frameconvlist = get_hsf_empty_array((len_sy, len_sx), col + 1,
|
||||
# frame_int.dtype, (f_shape, y_step, x_step))
|
||||
# inner_sum, outer_sum = inout_sum
|
||||
# p00, p11, p01, p10 = p_list
|
||||
# frame_conv, frame_conv_stride = frameconvlist
|
||||
# len_sx, len_sy, y_rin_m, y_rin_p, x_rin_m, x_rin_p, y_ro_m, x_ro_m, y_ro_p, x_ro_p,val_in,val_out,f_shape = get_hsf_inout_index(
|
||||
# padding, x_step, y_step, col, row, kernel.r_in, kernel.r_out,kernel.val_in,kernel.val_out)
|
||||
# len_sx, len_sy, y_rin_m, y_rin_p, x_rin_m, x_rin_p, y_ro_m, x_ro_m, y_ro_p, x_ro_p, f_shape = get_hsf_inout_index(
|
||||
# padding, x_step, y_step, col, row, kernel.r_in, kernel.r_out)
|
||||
|
||||
inner_sum, outer_sum,p_temp, p00, p11, p01, p10, response_list, frame_conv, frame_conv_stride = get_hsf_empty_array(len_sx,len_sy,#(len_sy, len_sx),
|
||||
inner_sum, outer_sum,p_temp, p00, p11, p01, p10, response_list, frame_conv, frame_conv_stride = get_hsf_empty_array_new(len_sx,len_sy,#(len_sy, len_sx),
|
||||
frame_int.shape[1],#col + 1,
|
||||
frame_int.dtype, (
|
||||
f_shape, y_step,
|
||||
x_step))
|
||||
#
|
||||
# inner_sum, in_p_temp, in_p00, in_p11, in_p01, in_p10, outer_sum, p_temp, p00, p11, p01, p10, response_list, frame_conv, frame_conv_stride= get_hsf_empty_array((len_sy, len_sx),
|
||||
# col + 1,
|
||||
# frame_int.dtype, (
|
||||
# f_shape, y_step,
|
||||
# x_step))
|
||||
# inout_sum, p_temp, p_list, response_list, frameconvlist = hsf_empty_array
|
||||
# inner_sum, outer_sum = inout_sum
|
||||
# p00, p11, p01, p10 = p_list
|
||||
# frame_conv, frame_conv_stride = frameconvlist
|
||||
|
||||
# x_steps_st_end=np.asarray([x_steps[0],x_steps[len_sx-1]+1])
|
||||
# # x_steps_st_end[1]+=1
|
||||
# y_steps_st_end=np.asarray([y_steps[0],y_steps[len_sy-1]+1])
|
||||
# y_steps_st_end[1] += 1
|
||||
|
||||
# x_steps_st_end=np.asarray([x_steps[0],x_steps[len_sx-1]+1])
|
||||
# y_steps_st_end=np.asarray([y_steps[0],y_steps[len_sy-1]+1])
|
||||
# xy_steps_st_end=np.asarray([[x_steps[0],x_steps[-1]],[y_steps[0],y_steps[-1]]])
|
||||
# xy_steps_st_end[:,1]+=1
|
||||
|
||||
# xy_rin_m = xy_steps_st_end-r_in
|
||||
# xy_rin_p = xy_steps_st_end + r_in
|
||||
|
||||
# xx==(y,x),m==MINUS,p==PLUS, ex: mm==(y-,x-)
|
||||
# inarr_m = frame_int[y_steps[0]-r_in:y_steps[-1]-r_in+1:y_step]
|
||||
# inarr_p = frame_int[y_steps[0]+r_in:y_steps[-1]+r_in+1:y_step]
|
||||
# inarr_mm = inarr_m[:, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
# inarr_mp = inarr_m[:, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
# inarr_pm = inarr_p[:, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
# inarr_pp = inarr_p[:, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
|
||||
# y_rin_m = y_steps_st_end - r_in
|
||||
# x_rin_m = x_steps_st_end - r_in
|
||||
# y_rin_p = y_steps_st_end + r_in
|
||||
# x_rin_p = x_steps_st_end + r_in
|
||||
# # xx==(y,x),m==MINUS,p==PLUS, ex: mm==(y-,x-)
|
||||
# inarr_mm = frame_int[y_rin_m[0]:y_rin_m[1]:y_step, x_rin_m[0]:x_rin_m[1]:x_step]
|
||||
# inarr_mp = frame_int[y_rin_m[0]:y_rin_m[1]:y_step, x_rin_p[0]:x_rin_p[1]:x_step]
|
||||
# inarr_pm = frame_int[y_rin_p[0]:y_rin_p[1]:y_step, x_rin_m[0]:x_rin_m[1]:x_step]
|
||||
# inarr_pp = frame_int[y_rin_p[0]:y_rin_p[1]:y_step, x_rin_p[0]:x_rin_p[1]:x_step]
|
||||
|
||||
# == inarr_mm + inarr_pp - inarr_mp - inarr_pm
|
||||
# inner_sum[:, :] = inarr_mm
|
||||
# inner_sum += inarr_pp
|
||||
# inner_sum -= inarr_mp
|
||||
# inner_sum -= inarr_pm
|
||||
|
||||
# cv2.subtract(cv2.subtract(cv2.add(inarr_mm,inarr_pp),inarr_mp),inarr_pm,dst=inner_sum[:,:])
|
||||
# inner_sum[:, :]=inarr_mm.__add__(inarr_pp).__sub__(inarr_mp).__sub__(inarr_pm)
|
||||
# inner_sum[:,:]=inarr_m[:, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
# inner_sum += inarr_p[:, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
# inner_sum -= inarr_m[:, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
# inner_sum -= inarr_p[:, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
# y_m_f=y_steps[0] - r_in
|
||||
# y_m_e=y_steps[-1] - r_in + 1
|
||||
# y_p_f=y_steps[0] + r_in
|
||||
# y_p_e=y_steps[-1] + r_in + 1
|
||||
#
|
||||
# x_m_f=x_steps[0] - r_in
|
||||
# x_m_e=x_steps[-1] - r_in + 1
|
||||
# x_p_f=x_steps[0] + r_in
|
||||
# x_p_e=x_steps[-1] + r_in + 1
|
||||
|
||||
# inner_sum[:,:]=frame_int[y_steps[0]-r_in:y_steps[-1]-r_in+1:y_step, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
# inner_sum += frame_int[y_steps[0]+r_in:y_steps[-1]+r_in+1:y_step, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
# inner_sum -= frame_int[y_steps[0]-r_in:y_steps[-1]-r_in+1:y_step, x_steps[0]+r_in:x_steps[-1]+r_in+1:x_step]
|
||||
# inner_sum -= frame_int[y_steps[0]+r_in:y_steps[-1]+r_in+1:y_step, x_steps[0]-r_in:x_steps[-1]-r_in+1:x_step]
|
||||
|
||||
|
||||
# inner_sum[:, :] = frame_int[y_rin_m_f:y_rin_m_e:y_step, x_rin_m_f:x_rin_m_e:x_step]
|
||||
# inner_sum += frame_int[y_rin_p_f:y_rin_p_e:y_step, x_rin_p_f:x_rin_p_e:x_step]
|
||||
# inner_sum -= frame_int[y_rin_m_f:y_rin_m_e:y_step, x_rin_p_f:x_rin_p_e:x_step]
|
||||
# inner_sum -= frame_int[y_rin_p_f:y_rin_p_e:y_step, x_rin_m_f:x_rin_m_e:x_step]
|
||||
|
||||
# inner_sum_temp[:, :,0] = frame_int[y_rin_m, x_rin_m].copy()
|
||||
# inner_sum_temp[:, :,1] = frame_int[y_rin_p, x_rin_p].copy()
|
||||
# inner_sum_temp[:, :,2] = -frame_int[y_rin_m, x_rin_p].copy()
|
||||
# inner_sum_temp[:, :,3] = -frame_int[y_rin_p, x_rin_m].copy()
|
||||
# cv2.transform(inner_sum_temp, np.ones((1, 4)),
|
||||
# dst=inner_sum)
|
||||
|
||||
#
|
||||
# inner_sum[:, :] = frame_int[y_rin_m, x_rin_m]
|
||||
# inner_sum += frame_int[y_rin_p, x_rin_p]
|
||||
# inner_sum -= frame_int[y_rin_m, x_rin_p]
|
||||
# inner_sum -= frame_int[y_rin_p, x_rin_m]
|
||||
|
||||
# inner_sum[:, :] = frame_int[y_rin_m, x_rin_m]+ frame_int[y_rin_p, x_rin_p]-frame_int[y_rin_m, x_rin_p]- frame_int[y_rin_p, x_rin_m]
|
||||
|
||||
# inner_sum[:, :] = frame_int[y_rin_m, x_rin_m] + frame_int[y_rin_p, x_rin_p] - frame_int[y_rin_m, x_rin_p] - frame_int[y_rin_p, x_rin_m]
|
||||
|
||||
inner_sum[:, :] = in_p00_view + in_p11_view - in_p01_view - in_p10_view
|
||||
|
||||
# inarr_m = frame_int[inarr_ym]
|
||||
# inarr_p = frame_int[inarr_yp]
|
||||
# inner_sum[:, :] = inarr_m[:,inarr_xm]#inarr_mm
|
||||
# inner_sum += inarr_p[:,inarr_xp]#inarr_pp
|
||||
# inner_sum -= inarr_m[:,inarr_xp]#inarr_mp
|
||||
# inner_sum -= inarr_p[:,inarr_xm]#inarr_pm
|
||||
|
||||
# Bottleneck here, I want to make it smarter. Someone do it.
|
||||
# (y,x)
|
||||
# p00=max(y_ro_m,0),max(x_ro_m,0)
|
||||
# p11=min(y_ro_p,ylim),min(x_ro_p,xlim)
|
||||
# p01=max(y_ro_m,0),min(x_ro_p,xlim)
|
||||
# p10=min(y_ro_p,ylim),max(x_ro_m,0)
|
||||
# y_ro_m = y_steps - kernel.r_out
|
||||
# x_ro_m = x_steps - kernel.r_out
|
||||
# y_ro_p = y_steps + kernel.r_out
|
||||
# x_ro_p = x_steps + kernel.r_out
|
||||
# p00 calc
|
||||
# np.take(frame_int, y_steps - kernel.r_out, axis=0, mode="clip", out=p_temp)
|
||||
|
||||
# np.take(frame_int, y_ro_m, axis=0, mode="clip", out=p_temp)
|
||||
# np.take(p_temp, x_ro_m, axis=1, mode="clip", out=p00)
|
||||
# # p01 calc
|
||||
# np.take(p_temp, x_ro_p, axis=1, mode="clip", out=p01)
|
||||
# # p11 calc
|
||||
# np.take(frame_int, y_ro_p, axis=0, mode="clip", out=p_temp)
|
||||
# np.take(p_temp, x_ro_p, axis=1, mode="clip", out=p11)
|
||||
# # p10 calc
|
||||
# np.take(p_temp, x_ro_m, axis=1, mode="clip", out=p10)
|
||||
|
||||
# np.take(frame_int, y_ro_m, axis=0, mode="clip", out=p_temp)
|
||||
# np.take(p_temp, x_ro_m, axis=1, mode="clip", out=p00)
|
||||
# # p01 calc
|
||||
# np.take(p_temp, x_ro_p, axis=1, mode="clip", out=p01)
|
||||
# # p11 calc
|
||||
# np.take(frame_int, y_ro_p, axis=0, mode="clip", out=p_temp)
|
||||
# np.take(p_temp, x_ro_p, axis=1, mode="clip", out=p11)
|
||||
# # p10 calc
|
||||
# np.take(p_temp, x_ro_m, axis=1, mode="clip", out=p10)
|
||||
|
||||
frame_int.take( y_ro_m, axis=0, mode="clip", out=p_temp)
|
||||
p_temp.take(x_ro_m, axis=1, mode="clip", out=p00)
|
||||
# p01 calc
|
||||
@ -1275,50 +918,10 @@ def conv_int(frame_int, kernel, x_step,y_step, padding,in_p00_view, in_p11_view,
|
||||
# p10 calc
|
||||
p_temp.take( x_ro_m, axis=1, mode="clip", out=p10)
|
||||
|
||||
# p_temp[:,:]=frame_int[y_ro_m.reshape(-1),:]#.copy()
|
||||
# p00[:,:]=np.asarray(p_temp[:,x_ro_m.reshape(-1)])#.copy()
|
||||
# # p01 calc
|
||||
# p01[:,:]=-p_temp[:,x_ro_p.reshape(-1)]#.copy()
|
||||
# # p11 calc
|
||||
# p_temp[:,:]=frame_int[y_ro_p.reshape(-1),:]
|
||||
# p11[:,:]=np.asarray(p_temp[:,x_ro_p.reshape(-1)])#.copy()
|
||||
# # p10 calc
|
||||
# p10[:,:]=-p_temp[:,x_ro_m.reshape(-1)]#.copy()
|
||||
|
||||
# the point is this
|
||||
# p00=np.take(np.take(frame_int, y_ro_m, axis=0, mode="clip"), x_ro_m, axis=1, mode="clip")
|
||||
# p11=np.take(np.take(frame_int, y_ro_p, axis=0, mode="clip"), x_ro_p, axis=1, mode="clip")
|
||||
# p01=np.take(np.take(frame_int, y_ro_m, axis=0, mode="clip"), x_ro_p, axis=1, mode="clip")
|
||||
# p10=np.take(np.take(frame_int, y_ro_p, axis=0, mode="clip"), x_ro_m, axis=1, mode="clip")
|
||||
|
||||
outer_sum[:, :] = p00 + p11 - p01 - p10 - inner_sum
|
||||
# cv2.transform(np.asarray([p00, p11, -p01, -p10, -inner_sum]).transpose((1, 2, 0)), np.ones((1, 5)),
|
||||
# dst=outer_sum) # https://answers.opencv.org/question/3120/how-to-sum-a-3-channel-matrix-to-a-one-channel-matrix/
|
||||
# cv2.transform(np.asarray([frame_int[y_ro_m,x_ro_m], frame_int[y_ro_m,x_ro_p], -frame_int[y_ro_p,x_ro_p], -frame_int[y_ro_p,x_ro_m], -inner_sum]).transpose((1, 2, 0)), np.ones((1, 5)),
|
||||
# dst=outer_sum) # https://answers.opencv.org/question/3120/how-to-sum-a-3-channel-matrix-to-a-one-channel-matrix/
|
||||
# cv2.transform(np.asarray([
|
||||
# frame_int[y_ro_m,x_ro_m],
|
||||
# frame_int[y_ro_p,x_ro_p],
|
||||
# -frame_int[y_ro_m,x_ro_p],
|
||||
# -frame_int[y_ro_p,x_ro_m],
|
||||
# -inner_sum]).transpose((1, 2, 0)), np.ones((1, 5)),
|
||||
# dst=outer_sum) # https://answers.opencv.org/question/3120/how-to-sum-a-3-channel-matrix-to-a-one-channel-matrix/
|
||||
|
||||
# outer_sum_temp[:,:,0]=p00#frame_int[y_ro_m, x_ro_m]
|
||||
# outer_sum_temp[:, :, 1] = p11#frame_int[y_ro_p, x_ro_p]
|
||||
# outer_sum_temp[:, :, 2] = p01#frame_int[y_ro_m, x_ro_p]
|
||||
# outer_sum_temp[:, :, 3] = p10#frame_int[y_ro_p, x_ro_m]
|
||||
|
||||
# p_temp[:,:]=frame_int[y_ro_m.reshape(-1),:]#.copy()
|
||||
# outer_sum_temp[:,:,0]=np.asarray(p_temp[:,x_ro_m.reshape(-1)])#frame_int[y_ro_m, x_ro_m]
|
||||
# outer_sum_temp[:, :, 2] = -p_temp[:,x_ro_p.reshape(-1)]#frame_int[y_ro_m, x_ro_p]
|
||||
# p_temp[:,:]=frame_int[y_ro_p.reshape(-1),:]
|
||||
# outer_sum_temp[:, :, 1] = np.asarray(p_temp[:,x_ro_p.reshape(-1)])#frame_int[y_ro_p, x_ro_p]
|
||||
# outer_sum_temp[:, :, 3] = -p_temp[:,x_ro_m.reshape(-1)]#frame_int[y_ro_p, x_ro_m]
|
||||
# outer_sum_temp[:, :, 4] = -inner_sum
|
||||
# cv2.transform(outer_sum_temp, np.ones((1, 5)),
|
||||
# dst=outer_sum) # https://answers.opencv.org/question/3120/how-to-sum-a-3-channel-matrix-to-a-one-channel-matrix/
|
||||
|
||||
|
||||
# np.multiply(kernel.val_in, inner_sum, dtype=np.float64, out=response_list)
|
||||
# response_list += kernel.val_out * outer_sum
|
||||
@ -1333,8 +936,7 @@ def conv_int(frame_int, kernel, x_step,y_step, padding,in_p00_view, in_p11_view,
|
||||
# min_response, max_val, min_loc, max_loc = cv2.minMaxLoc(response_list)
|
||||
min_response, _, min_loc, _ = cv2.minMaxLoc(response_list)
|
||||
|
||||
# center = ((x_steps_arr[min_loc[0]] - padding), (y_steps_arr[min_loc[1]] - padding))
|
||||
# center = get_hsf_center(padding,x_step,y_step,min_loc)#[0],min_loc[1])
|
||||
# center = get_hsf_center(padding,x_step,y_step,min_loc)
|
||||
|
||||
frame_conv_stride[:, :] = response_list
|
||||
# or
|
||||
@ -1420,7 +1022,8 @@ class HSRAC_cls(object):
|
||||
ret, frame = self.cap.read()
|
||||
if ret:
|
||||
# I have set it to grayscale (1ch) just in case, but if the frame is 1ch, this line can be commented out.
|
||||
self.current_image = frame # debug code
|
||||
if imshow_enable or save_video:
|
||||
self.current_image = frame # debug code
|
||||
self.current_image_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
|
||||
return True
|
||||
return False
|
||||
@ -1484,12 +1087,14 @@ class HSRAC_cls(object):
|
||||
|
||||
crop_start_time = timeit.default_timer()
|
||||
# Define the center point and radius
|
||||
# center_x, center_y = center_xy
|
||||
# upper_x = center_x + radius
|
||||
# lower_x = center_x - radius
|
||||
# upper_y = center_y + radius
|
||||
# lower_y = center_y - radius
|
||||
center_x, center_y, upper_x, lower_x, upper_y, lower_y=get_center_noclamp(center_xy,radius)
|
||||
if old_mode:
|
||||
center_x, center_y = center_xy
|
||||
upper_x = center_x + radius
|
||||
lower_x = center_x - radius
|
||||
upper_y = center_y + radius
|
||||
lower_y = center_y - radius
|
||||
else:
|
||||
center_x, center_y, upper_x, lower_x, upper_y, lower_y=get_center_noclamp(center_xy,radius)
|
||||
|
||||
# Crop the image using the calculated bounds
|
||||
cropped_image = safe_crop(gray_frame, lower_x, lower_y, upper_x, upper_y)
|
||||
@ -1570,43 +1175,43 @@ class HSRAC_cls(object):
|
||||
|
||||
# For measuring processing time of image processing
|
||||
ransac_start_time = timeit.default_timer()
|
||||
# Crop first to reduce the amount of data to process.
|
||||
# frame = cropped_image[0:len(cropped_image) - 10, :]
|
||||
# To reduce the processing data, first convert to 1-channel and then blur.
|
||||
# The processing results were the same when I swapped the order of blurring and 1-channelization.
|
||||
# frame_gray = cv2.GaussianBlur(frame, (5, 5), 0)
|
||||
# cv2.GaussianBlur is slow (use 10%)
|
||||
# use cv2.blur() or cv2.boxFilter()?
|
||||
# or
|
||||
# frame_gray =cv2.boxFilter(frame, -1,(5, 5))# https://github.com/bfraboni/FastGaussianBlur
|
||||
# cv2.boxFilter(frame_gray, -1,(5, 5),dst=frame_gray)
|
||||
# cv2.boxFilter(frame_gray, -1,(5, 5),dst=frame_gray)
|
||||
|
||||
|
||||
if old_mode:
|
||||
frame_gray = cv2.GaussianBlur(frame, (5, 5), 0)
|
||||
else:
|
||||
# frame_gray = cv2.GaussianBlur(frame, (5, 5), 0)
|
||||
# cv2.GaussianBlur is slow (uses 10% of the time of all this script)
|
||||
# use cv2.blur()
|
||||
# or
|
||||
# frame_gray =cv2.boxFilter(frame, -1,(5, 5))# https://github.com/bfraboni/FastGaussianBlur
|
||||
# cv2.boxFilter(frame_gray, -1,(5, 5),dst=frame_gray)
|
||||
# cv2.boxFilter(frame_gray, -1,(5, 5),dst=frame_gray)
|
||||
# or
|
||||
frame_gray = cv2.sepFilter2D(frame, -1, self.gauss_k, self.gauss_k)
|
||||
|
||||
|
||||
#todo:no numpy and use lru
|
||||
|
||||
# hsf_center_x, hsf_center_y = center_x.copy(), center_y.copy()
|
||||
# # ransac_xy_offset = (hsf_center_x-20, hsf_center_y-20)
|
||||
# upper_x = hsf_center_x + max(20, radius)
|
||||
# lower_x = hsf_center_x - max(20, radius)
|
||||
# upper_y = hsf_center_y + max(20, radius)
|
||||
# lower_y = hsf_center_y - max(20, radius)
|
||||
# ransac_xy_offset = (lower_x, lower_y)
|
||||
upper_x, lower_x, upper_y, lower_y, ransac_xy_offset = get_hsf_center_uplow(center_x,center_y,radius)
|
||||
if old_mode:
|
||||
hsf_center_x, hsf_center_y = center_x, center_y#center_x.copy(), center_y.copy()
|
||||
# ransac_xy_offset = (hsf_center_x-20, hsf_center_y-20)
|
||||
upper_x = hsf_center_x + max(20, radius)
|
||||
lower_x = hsf_center_x - max(20, radius)
|
||||
upper_y = hsf_center_y + max(20, radius)
|
||||
lower_y = hsf_center_y - max(20, radius)
|
||||
ransac_xy_offset = (lower_x, lower_y)
|
||||
else:
|
||||
upper_x, lower_x, upper_y, lower_y, ransac_xy_offset = get_hsf_center_uplow(center_x,center_y,radius)
|
||||
|
||||
# Crop the image using the calculated bounds
|
||||
#todo:safecrop tune
|
||||
frame_gray_crop = safe_crop(frame_gray, lower_x, lower_y, upper_x, upper_y)
|
||||
th_frame,fic_frame=get_ransac_frame(frame_gray_crop.shape)
|
||||
if not old_mode:
|
||||
th_frame,fic_frame=get_ransac_frame(frame_gray_crop.shape)
|
||||
frame = frame_gray_crop # todo: It can cause bugs.
|
||||
|
||||
# this will need to be adjusted everytime hardware is changed (brightness of IR, Camera postion, etc)m
|
||||
# min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(frame_gray_crop)
|
||||
min_val = cv2.minMaxLoc(frame_gray_crop)[0]
|
||||
# min_val=cv2.reduce(frame_gray_crop,1,cv2.REDUCE_MIN).min()
|
||||
# threshold_value = min_val + thresh_add
|
||||
if old_mode:
|
||||
_, thresh = cv2.threshold(frame_gray_crop, min_val + thresh_add, 255, cv2.THRESH_BINARY)
|
||||
@ -1626,17 +1231,13 @@ class HSRAC_cls(object):
|
||||
except Exception as e:
|
||||
raise e
|
||||
# I want to eliminate try here because try tends to be slow in execution.
|
||||
fic_frame = 255 - frame_gray_crop
|
||||
# fic_frame = 255 - frame_gray_crop
|
||||
if old_mode:
|
||||
contours, _ = cv2.findContours(th_frame, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
|
||||
else:
|
||||
contours = cv2.findContours(fic_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[0]
|
||||
# contours, _ = cv2.findContours(fic_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
|
||||
# or
|
||||
# contours, _=cv2.findContours(th_frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
|
||||
# cv2.findContours(th_frame, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
|
||||
# cv2.findContours(th_frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
|
||||
# cv2.findContours(th_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
|
||||
# or
|
||||
# contours = cv2.findContours(fic_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)[0]
|
||||
|
||||
if not blink_bd and self.blink_detector.enable_detect_flg:
|
||||
threshold_value = self.center_q1.quartile_1
|
||||
@ -1664,22 +1265,15 @@ class HSRAC_cls(object):
|
||||
except Exception as e:
|
||||
raise e
|
||||
# I want to eliminate try here because try tends to be slow in execution.
|
||||
fic_frame = 255 - frame_gray_crop
|
||||
# fic_frame = 255 - frame_gray_crop
|
||||
if old_mode:
|
||||
contours2, _ = cv2.findContours(th_frame, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
|
||||
contours = (*contours, *contours2)
|
||||
else:
|
||||
# contours2, _ = cv2.findContours(fic_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)#cv2.CHAIN_APPROX_NONE)
|
||||
# contours2 = cv2.findContours(fic_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[0]
|
||||
contours = (*contours, *cv2.findContours(fic_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[0])
|
||||
# contours = (*contours, *contours2)
|
||||
# or
|
||||
# contours = (*contours, *cv2.findContours(fic_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)[0])
|
||||
|
||||
# hull = []
|
||||
# # This way is faster than contours[i]
|
||||
# # But maybe this one is faster. hull = [cv2.convexHull(cnt, False) for cnt in contours]
|
||||
# for cnt in contours:
|
||||
# # pass
|
||||
# hull.append(cv2.convexHull(cnt, False))
|
||||
if not contours:
|
||||
# If empty, go to next loop
|
||||
return int(center_x), int(center_y), th_frame, frame, gray_frame
|
||||
@ -1707,7 +1301,7 @@ class HSRAC_cls(object):
|
||||
if old_mode:
|
||||
ransac_data = fit_rotated_ellipse_ransac_old(maxcnt.reshape(-1, 2), self.rng)
|
||||
else:
|
||||
ransac_data = fit_rotated_ellipse_ransac(maxcnt.reshape(-1, 2).astype(np.float64), self.sfc)
|
||||
ransac_data = fit_rotated_ellipse_ransac_new(maxcnt.reshape(-1, 2).astype(np.float64), self.sfc)
|
||||
if ransac_data is None:
|
||||
# ransac_data is None==maxcnt.shape[0]<sample_num
|
||||
# go to next loop
|
||||
@ -1758,20 +1352,6 @@ class HSRAC_cls(object):
|
||||
if cv2.waitKey(1) & 0xFF == ord("q"):
|
||||
pass
|
||||
|
||||
# except Exception as e:
|
||||
# print(e)
|
||||
# pass
|
||||
|
||||
# debug code
|
||||
# try:
|
||||
# if any([isinstance(val, float) for val in [cx, cy]]):
|
||||
# print()
|
||||
# return int(cx), int(cy),cropbox, ori_frame,thresh, frame, gray_frame
|
||||
# except:
|
||||
# if any([isinstance(val, float) for val in [center_x, center_y]]):
|
||||
# print()
|
||||
# return center_x, center_y,cropbox, ori_frame,thresh, frame, gray_frame
|
||||
# print(frame_gray.shape, thresh.shape)
|
||||
|
||||
cv_end_time = timeit.default_timer()
|
||||
self.timedict["ransac"].append(cv_end_time - ransac_start_time)
|
||||
@ -1791,6 +1371,8 @@ if __name__ == "__main__":
|
||||
logger.info("alg ver: {}".format(alg_ver))
|
||||
logger.info("alg mode: {}".format("old" if old_mode else "new"))
|
||||
logger.info("loops: {}".format(loop_num))
|
||||
if not os.path.exists(input_video_path) or not os.path.isfile(input_video_path):
|
||||
raise FileNotFoundError(input_video_path)
|
||||
logger.info("video name: {}".format(os.path.basename(input_video_path)))
|
||||
cap = cv2.VideoCapture(input_video_path)
|
||||
logger.info("video info: size:{}x{} fps:{} frames:{} total:{:.3f} sec".format(int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
|
||||
|
||||
Loading…
Reference in New Issue
Block a user