添加对python算法的支持

This commit is contained in:
2026-07-30 18:46:32 +08:00
parent 7eb3b89714
commit 86af7f30be
25 changed files with 13525 additions and 2 deletions
+383
View File
@@ -0,0 +1,383 @@
import numpy as np
try:
from .validation_utils import limit
except ImportError:
from validation_utils import limit
def _lfilter(b, a, x, zi=None):
b = np.asarray(b, dtype=np.float64)
a = np.asarray(a, dtype=np.float64)
x = np.asarray(x, dtype=np.float64)
if a[0] != 1.0:
b = b / a[0]
a = a / a[0]
nb = len(b)
na = len(a)
n = max(nb, na)
if nb < n:
b = np.pad(b, (0, n - nb))
if na < n:
a = np.pad(a, (0, n - na))
y = np.zeros_like(x)
if zi is None:
zi = np.zeros(n - 1)
else:
zi = np.asarray(zi, dtype=np.float64).copy()
for i in range(len(x)):
xi = x[i]
yi = b[0] * xi + zi[0]
for j in range(n - 2):
zi[j] = b[j + 1] * xi + zi[j + 1] - a[j + 1] * yi
zi[n - 2] = b[n - 1] * xi - a[n - 1] * yi
y[i] = yi
if zi is not None and len(zi) > 0:
return y, zi
return y
def filter2k3(filtpara, x, mode=0):
filtpara = np.asarray(filtpara, dtype=np.float64)
x = np.asarray(x, dtype=np.float64)
N2 = int(np.round(0.5 * (len(filtpara) - 1)))
Nx = len(x)
if len(filtpara) > len(x):
return x.copy(), 0
if mode > 0:
filtpara = filtpara[::-1]
y = np.convolve(x, filtpara, mode='full')
y = np.concatenate([y[N2:Nx], y[:N2]])
if mode == 2:
y[:N2] = y[N2]
y[-N2:] = y[-N2 - 1]
else:
y[:N2] = x[:N2]
y[Nx - N2:Nx] = x[Nx - N2:Nx]
return y, N2
def fifi(b, a, x):
b = np.asarray(b, dtype=np.float64).ravel()
a = np.asarray(a, dtype=np.float64).ravel()
x = np.asarray(x, dtype=np.float64)
if len(b) == 0 or len(a) == 0 or len(x) == 0:
return np.array([])
orig_shape = x.shape
if x.ndim > 1 and min(x.shape) > 1:
raise ValueError('Only works for vector input.')
x_flat = x.ravel()
len_x = len(x_flat)
nb = len(b)
na = len(a)
nfilt = max(nb, na)
if nb < nfilt:
b = np.pad(b, (0, nfilt - nb))
if na < nfilt:
a = np.pad(a, (0, nfilt - na))
nfact = 3 * (nfilt - 1)
if len_x <= nfact:
raise ValueError('Data must have length more than 3 times filter order.')
zi = np.linalg.solve(
np.eye(nfilt - 1) - np.column_stack([
-a[1:nfilt],
np.row_stack([np.eye(nfilt - 2), np.zeros(nfilt - 2)])
]),
b[1:nfilt] - a[1:nfilt] * b[0]
)
y_padded = np.concatenate([
2 * x_flat[0] - x_flat[nfact:0:-1],
x_flat,
2 * x_flat[-1] - x_flat[-2:-nfact - 2:-1]
])
y_padded, _ = _lfilter(b, a, y_padded, zi=zi * y_padded[0])
y_padded = y_padded[::-1]
y_padded, _ = _lfilter(b, a, y_padded, zi=zi * y_padded[0])
y_padded = y_padded[::-1]
y_out = y_padded[nfact:len_x + nfact]
if orig_shape[0] == 1 and x.ndim > 1:
y_out = y_out.reshape(1, -1)
return y_out
def dilate1(x, N):
x = np.asarray(x, dtype=np.float64)
y = x.copy()
N = int(np.round(N))
if N >= 3:
filtvek = np.array([1, 0, 0, 0, 1], dtype=np.float64)
y2, _ = filter2k3(filtvek, y.astype(float))
y2 = (y2 >= 2)
y = np.logical_or(y.astype(bool), y2).astype(float)
N = 2
if N == 2:
filtvek = np.array([1, 0, 0, 1, 0], dtype=np.float64)
y2, _ = filter2k3(filtvek, y.astype(float))
y2 = (y2 >= 2)
y = np.logical_or(y.astype(bool), y2).astype(float)
filtvek = np.array([0, 1, 0, 0, 1], dtype=np.float64)
y2, _ = filter2k3(filtvek, y.astype(float))
y2 = (y2 >= 2)
y = np.logical_or(y.astype(bool), y2).astype(float)
N = 1
if N == 1:
filtvek = np.array([1, 0, 1], dtype=np.float64)
y2, _ = filter2k3(filtvek, y.astype(float))
y2 = (y2 >= 2)
y = np.logical_or(y.astype(bool), y2).astype(float)
return y
def videochk(video, errnorm, rawxycount, maxrawxycount, memerror,
minlevel1, maxlevel1, minlevel2, maxlevel2,
errmssmin_start, errmssmax_start, errmssmin_end, errmssmax_end):
errfac = 0.80
errnorm = np.atleast_2d(np.asarray(errnorm, dtype=np.float64))
if errnorm.shape[0] < 2:
errnorm = np.vstack([errnorm, np.zeros((1, errnorm.shape[1]))])
video = np.atleast_2d(np.asarray(video, dtype=np.float64))
if not errnorm[0, 0] and rawxycount < (maxrawxycount - 2):
sorted_vid = np.sort(video, axis=1)[:, ::-1]
if sorted_vid.shape[1] >= 25:
meanmax = np.mean(sorted_vid[:, 5:25])
elif sorted_vid.shape[1] > 5:
meanmax = np.mean(sorted_vid[:, 5:])
else:
meanmax = np.mean(sorted_vid)
if minlevel1 is not None and len(np.atleast_1d(minlevel1)) > 0 and meanmax < minlevel1:
errnorm[0, 0] = errmssmin_start
if maxlevel1 is not None and len(np.atleast_1d(maxlevel1)) > 0 and meanmax > maxlevel1:
errnorm[0, 0] = errmssmax_start
elif rawxycount == maxrawxycount - 2 or rawxycount == maxrawxycount - 1 or memerror:
sorted_vid = np.sort(video, axis=1)[:, ::-1]
if sorted_vid.shape[1] >= 25:
meanmax = np.mean(sorted_vid[:, 5:25])
elif sorted_vid.shape[1] > 5:
meanmax = np.mean(sorted_vid[:, 5:])
else:
meanmax = np.mean(sorted_vid)
if minlevel2 is not None and len(np.atleast_1d(minlevel2)) > 0:
if meanmax < minlevel2 * errfac:
if not errnorm[0, 0]:
errnorm[0, 0] = errmssmin_end
memerror = errmssmin_end
elif meanmax < minlevel2:
if not errnorm[1, 0]:
errnorm[1, 0] = errmssmin_end
memerror = errmssmin_end
if maxlevel2 is not None and len(np.atleast_1d(maxlevel2)) > 0 and meanmax > maxlevel2:
if not errnorm[0, 0]:
errnorm[0, 0] = errmssmax_end
memerror = errmssmax_end
return errnorm, memerror
def scan_norm(in_sig, in0bright, in0darkStatic, in0darkDynamic, dxZeile, gap, videoOffs,
errsettings, mem, init, video_req_time):
mmPixel = 0
maxrawxycount = 210
inbright_minlevel1 = 5000
inbright_maxlevel1 = 12000
inbright_minlevel2 = 4000
inbright_maxlevel2 = 12000
inbright_too_low = 196
inbright_too_high = 197
raw_minlevel1 = []
raw_maxlevel1 = 12000
raw_minlevel2 = []
raw_maxlevel2 = 12000
raw_too_low = 194
raw_too_high = 195
raw_Contr = 193
dark_maxwarnlevel = 5000
dark_maxerrlevel = 6000
dark_minerrlevel = 1
darkdyn_too_low = 198
darkdyn_too_high = 199
darkdyntimeout = 600
maxdarkdyncount = 2 * darkdyntimeout / video_req_time
rad_minlevel1 = 5000
rad_maxlevel1 = []
rad_minlevel2 = 4000
rad_maxlevel2 = []
rad_too_low = 200
rad_too_high = 195
in_sig = np.asarray(in_sig, dtype=np.float64).ravel()
in0bright = np.asarray(in0bright, dtype=np.float64).ravel()
in0darkStatic = np.asarray(in0darkStatic, dtype=np.float64).ravel()
in0darkDynamic = np.asarray(in0darkDynamic, dtype=np.float64).ravel()
start = int(videoOffs)
stop = len(in_sig) - int(videoOffs) - 1
if mem is None or not mem or init:
mem = {}
mem['rawxycount'] = 0
mem['darkdyncount'] = 0
mem['ref_error'] = 0
mem['raw_error'] = 0
mem['rad_error'] = 0
if mem['rawxycount'] < maxrawxycount:
mem['rawxycount'] += 1
if mem['darkdyncount'] < maxdarkdyncount:
mem['darkdyncount'] += 1
errnorm = np.atleast_2d(np.asarray(errsettings, dtype=np.float64)).copy()
if errnorm.shape[0] < 2:
errnorm = np.vstack([errnorm, np.zeros((1, max(1, errnorm.shape[1])))])
if not errnorm[0, 0]:
if (len(in_sig) != len(in0darkDynamic) or len(in_sig) != len(in0bright) or
len(in_sig) != len(in0darkStatic)):
errnorm[0, 0] = 186
elif len(in_sig) < 200:
errnorm[0, 0] = 186
bright_seg = in0bright[start:stop + 1]
errref, mem['ref_error'] = videochk(
bright_seg, np.array([[0], [0]]), mem['rawxycount'], maxrawxycount,
mem['ref_error'],
inbright_minlevel1, inbright_maxlevel1,
inbright_minlevel2, inbright_maxlevel2,
inbright_too_low, inbright_too_high, inbright_too_low, inbright_too_high
)
if not errnorm[1, 0]:
if errref[0, 0]:
errnorm[1, 0] = errref[0, 0]
elif errref[1, 0]:
errnorm[1, 0] = errref[1, 0]
raw_seg = in_sig[start:stop + 1]
errnorm, mem['raw_error'] = videochk(
raw_seg, errnorm, mem['rawxycount'], maxrawxycount,
mem['raw_error'],
raw_minlevel1, raw_maxlevel1,
raw_minlevel2, raw_maxlevel2,
raw_Contr, raw_Contr, raw_too_low, raw_too_high
)
if mem['darkdyncount'] >= maxdarkdyncount:
dark_dyn_seg = in0darkDynamic[start:stop + 1]
if not errnorm[0, 0]:
if np.mean(dark_dyn_seg) > dark_maxerrlevel:
errnorm[0, 0] = darkdyn_too_high
elif np.mean(dark_dyn_seg) < dark_minerrlevel:
errnorm[0, 0] = darkdyn_too_low
if np.all(errnorm[:, 0] == 0):
if np.mean(dark_dyn_seg) > dark_maxwarnlevel:
errnorm[1, 0] = darkdyn_too_high
rad_seg = in_sig[start:stop + 1] - in0darkDynamic[start:stop + 1]
errnorm, mem['rad_error'] = videochk(
rad_seg, errnorm, mem['rawxycount'], maxrawxycount,
mem['rad_error'],
rad_minlevel1, rad_maxlevel1,
rad_minlevel2, rad_maxlevel2,
raw_Contr, raw_Contr, rad_too_low, rad_too_high
)
normvideo = np.zeros(stop - start + 1)
if not errnorm[0, 0]:
intsOffset = 100.0
intsFactor = 40000
in_norm = intsFactor * ((in_sig[start:stop + 1] - in0darkDynamic[start:stop + 1]) /
(in0bright[start:stop + 1] - in0darkStatic[start:stop + 1]))
in_norm, _, _ = limit(in_norm, np.array([]), 1)
in_norm = in_norm + intsOffset
if gap is not None and len(np.atleast_1d(gap)) > 0:
gap_arr = np.asarray(gap, dtype=np.float64)
if gap_arr.ndim == 1:
gap_arr = gap_arr.reshape(-1, 1)
sort_idx = np.argsort(gap_arr[0, :])
gap_arr[0, :] = gap_arr[0, sort_idx]
gap_arr[0, :] = np.round(gap_arr[0, :])
gap_arr[1, :] = gap_arr[1, sort_idx]
if gap_arr.shape[0] >= 3:
gap_arr[2, :] = np.round(gap_arr[2, sort_idx])
if gap_arr.shape[0] >= 4:
gap_arr[3, :] = np.round(gap_arr[3, sort_idx])
gap_arr[0, :] = np.round(gap_arr[0, :] - videoOffs)
valid_idx = np.where((gap_arr[0, :] > 1) & (gap_arr[0, :] < len(in_norm)))[0]
gap_arr = gap_arr[:, valid_idx]
else:
gap_arr = np.array([])
if gap_arr.size == 0:
normvideo = in_norm
else:
normvideo_list = []
startind = 0
mmstart1 = 0.0
mmstart2 = 0.0
for ii in range(gap_arr.shape[1]):
stopind = int(gap_arr[0, ii] - gap_arr[2, ii]) - 1
x1 = mmstart1 + np.arange(0, stopind - startind + 1) * dxZeile
x2 = np.arange(mmstart2, x1[-1] + dxZeile, dxZeile)
if stopind > startind:
if startind == 0:
secvideo = in_norm[startind:stopind + 1]
else:
secvideo = np.interp(x2, x1, in_norm[startind:stopind + 1])
normvideo_list.append(secvideo)
mmstart1 = x1[-1]
if len(x2) > 0:
mmstart2 = x2[-1] + dxZeile
numdisablepix = int(gap_arr[2, ii] + gap_arr[3, ii])
startind = stopind + 1
stopind = startind + numdisablepix
if stopind < len(in_norm):
x1 = mmstart1 + np.array([0, gap_arr[1, ii] + numdisablepix * dxZeile])
x2 = np.arange(mmstart2, x1[-1] + dxZeile, dxZeile)
secvideo = np.interp(x2, x1, in_norm[[startind, min(stopind, len(in_norm) - 1)]])
normvideo_list.append(secvideo)
mmstart1 = x1[-1]
if len(x2) > 0:
mmstart2 = x2[-1] + dxZeile
startind = stopind + 1
stopind = len(in_norm) - 1
if startind <= stopind:
x1 = mmstart1 + np.arange(0, stopind - startind + 1) * dxZeile
x2 = np.arange(mmstart2, x1[-1] + dxZeile, dxZeile)
secvideo = np.interp(x2, x1, in_norm[startind:stopind + 1])
normvideo_list.append(secvideo)
if normvideo_list:
normvideo = np.concatenate(normvideo_list)
else:
normvideo = in_norm
mmPixel = -0.5 * dxZeile * (len(normvideo) - 1)
return normvideo, mmPixel, errnorm, mem