PTB-XL处理程序

ECG处理程序

#data_process = (X_train[5,:,11] - np.roll(data_process,10))/10 #差分
#print(data_process)
import matplotlib.pyplot as plt
from scipy.signal import medfilt
def Slope_condition(data_process, location, Scope, Threshold):
    for i in range(Scope,0,-1):# 逐渐缩小范围找斜率满足要求的点
        if location-i>=0 and location+i<=999 :
            Slope_left = (data_process[location]-data_process[location-i])*100 # 100Hz, 计算左斜率
            Slope_right = (data_process[location+i]-data_process[location])*100  # 100Hz, 计算右斜率
            if Slope_left*Slope_right<(Threshold/(Scope-i+1)):
                return 1
            else :
                continue
    return 0 #这样都找不到，那就没有
    
def R_location(data_process, P_N, threshold, baseline):
    Xlim = []
    Ylim = []
    # print(data_process.shape)
    if P_N == "+":
        candidate = np.where((data_process-baseline)>=threshold)
    if P_N == "-":
        candidate = np.where((data_process-baseline)<=threshold)
    candidate = candidate[0]
    # print(candidate)
    # print(len(candidate))
    if len(candidate)==0:
        return Xlim, Ylim
    Data_max = data_process[candidate[0]]
    #print(Data_max)
    max_index = candidate[0]
    #print(max_index)
    for i in candidate:
        # print(i)
        if max_index != i-1 and max_index != i :  # 有间断再输出，并且进行下一段比较
            S_C = Slope_condition(data_process, max_index, 5, -500) #斜率状态
            if len(Xlim)==0:
                if S_C :
                    Xlim.append(max_index)
                    Ylim.append(Data_max)
            else :
                if S_C and max_index-Xlim[-1]>40: # 一般心率不会超过250/min
                    Xlim.append(max_index)
                    Ylim.append(Data_max)
            # print(Data_max, max_index)
            max_index = i
            Data_max = data_process[i]
        else :
            if Data_max < data_process[i] and P_N == "+" :  # 比较
                Data_max = data_process[i]
                max_index = i
            if Data_max > data_process[i] and P_N == "-" :  # 比较
                Data_max = data_process[i]
                max_index = i
        #print(data_process[i])
        #print(i)
    if len(Xlim)==0:
        return Xlim, Ylim
    if max_index != 999 and max_index-Xlim[-1]>40 and Slope_condition(data_process, max_index, 5, -500):
        Xlim.append(max_index)
        Ylim.append(Data_max)
    return Xlim, Ylim

def R_location_supplement(data_process,  P_N, Xlim_S, Scope):
    Xlim = []
    Ylim = []
    for i in Xlim_S:
        Data_max = data_process[i-Scope]
        max_index = i-Scope
        for j in range(i-Scope+1, i+Scope):
            if j>=1000 :
                break
            if j<=0 :
                continue
            if Data_max < data_process[j] and P_N == "+" : # 在一个范围内找最大值 
                Data_max = data_process[j]
                max_index = j
            if Data_max > data_process[j] and P_N == "-" :
                Data_max = data_process[j]
                max_index = j
        Xlim.append(max_index)
        Ylim.append(Data_max)
        #Xlim.append(i)
        #Ylim.append(data_process[i])
    return Xlim, Ylim

def R_location_Sup(data_person, threshold, high):
    for i in [11,10,9,5,2,1,0]:
        data_process = data_person[:, i]
        Baseline = medfilt(data_person[:, i],51)
        Xlim, Ylim = R_location(data_process, P_N="+", threshold = high, baseline = Baseline)
        if len(Xlim) >= threshold : #默认心跳频率高于48次/min
            break
    if len(Xlim) < threshold :
        Xlim, Ylim = R_location_Sup(data_person=data_person, threshold=threshold, high = high/2)
    return Xlim, Ylim

def Q_location(data_process,location, Scope):
    Q_min = data_process[location]
    Q_l = location
    for i in range(location, location-Scope, -1):
        if i>=0 :
            if data_process[i] < Q_min :  #向左在一定范围内找最小（判定条件）
                Q_min = data_process[i]
                Q_l = i
        else :
            break
    return Q_l, Q_min

def S_location(data_process,location, Scope):
    S_min = data_process[location]
    S_l = location
    for i in range(location, location+Scope, 1):
        if i<=999 :
            if data_process[i] < S_min :  #向右在一定范围内找最小（判定条件）
                S_min = data_process[i]
                S_l = i
        else :
            break
    return S_l, S_min

def Q_S_location(data_process, Xlim_S, Scope):
    Q_Xlim = []
    Q_Ylim = []
    S_Xlim = []
    S_Ylim = []
    for i in Xlim_S:
        Q_X,Q_Y = Q_location(data_process, i, Scope)
        S_X,S_Y = S_location(data_process, i, Scope)
        Q_Xlim.append(Q_X)
        Q_Ylim.append(Q_Y)
        S_Xlim.append(S_X)
        S_Ylim.append(S_Y)
    return Q_Xlim, Q_Ylim, S_Xlim, S_Ylim

def base_leave(data_process, location, Scope, PT, baseline):
    T_max = abs(data_process[location]-baseline[location])
    T_l = location
    if PT == 'P':
        range_start = location
        range_end = location+Scope
    if PT == 'T':
        range_start = location-Scope
        range_end = location
    # print(distance)
    for i in range(range_start, range_end):
        if i>=1000 :
            break
        if i<0 :
            continue
        if abs(data_process[i]-baseline[i]) > T_max :  #  找到离基线最远的点
            T_max = abs(data_process[i]-baseline[i])
            T_l = i
    #if Slope_condition(data_process, T_l, 1, -0) == 0 and (range_end-range_start) > 4:
        #T_l, data_process[T_l] = base_leave(data_process=data_process, location=location, Scope = Scope, PT=PT, baseline=baseline, distance = distance+1)
        
    return T_l, data_process[T_l]

def mm_where(data_process, range_start, range_end, P_N = 'max'):
    T_MM = data_process[range_start]
    T_l = range_start
    if P_N == 'max':
        for i in range(range_start, range_end):
            if i>=1000 :
                break
            if i<0 :
                continue
            if data_process[i] > T_MM :
                T_MM = data_process[i]
                T_l = i
    if P_N == 'min':
        for i in range(range_start, range_end):
            if i>=1000 :
                break
            if i<0 :
                continue
            if data_process[i] < T_MM :
                T_MM = data_process[i]
                T_l = i
    return T_l, T_MM

def PT_location_supplement(data_process, T_Xlim, Scope, PT, baseline):
    Xlim = []
    Ylim = []
    count = 0
    for i in T_Xlim:
        count = count+1
        T_l, T_MM = base_leave(data_process, i, int(Scope[count-1]), PT = PT, baseline = baseline)  # 以在一定范围内离基线最远为判定条件
        Xlim.append(T_l)
        Ylim.append(T_MM)
    return Xlim, Ylim

def Space(Xlim):
    # 循环左移
    Xlim_start = np.delete(Xlim, len(Xlim)-1)
    Xlim_end = np.roll(Xlim, -1)
    Xlim_end = np.delete(Xlim_end, len(Xlim_end)-1)
    space = Xlim_end-Xlim_start
    space = np.r_[Xlim[0], space, 1000-Xlim[-1]]
    space.astype(int)
    return space

def Space_P(Q_Xlim, TFR_Xlim):
    Xlim_start = np.r_[0, TFR_Xlim]
    Xlim_end = np.r_[Q_Xlim, 999]
    space = Xlim_start - Xlim_end
    space.astype(int)
    return space

def foot_find(data_process, location, Scope, direction, Baseline):
    if direction == 'right':
        S = location
        E = location+Scope
        D = 1
    if direction == 'left':
        S = location
        E = location-Scope
        D = -1
    for i in range(S,E,D):
        if (i+1)>=999:
            break
        if i<0 :
            continue
        high_R = data_process[i+1]-Baseline[i+1]
        high = data_process[i]-Baseline[i]
        if (high*high_R)<0:
            if(abs(high)<abs(high_R)):
                return i, data_process[i]
            if(abs(high)>abs(high_R)):
                return i+1, data_process[i+1]
    return i, data_process[i]

def TF_location(data_process, Xlim, Scope, direction, Baseline):
    TFXlim = []
    TFYlim = []
    for i in Xlim:
        TFX, TFY = foot_find(data_process=data_process, location=i, Scope=Scope, direction=direction, Baseline=Baseline)
        TFXlim.append(TFX)
        TFYlim.append(TFY)
    return TFXlim, TFYlim

def PT_location(data_process, Xlim_S, Scope, PT, baseline):
    space = Space(Xlim_S)
    #print(space)
    space.astype(int)
    if PT == 'P':
        space = np.delete(space, len(space)-1) #需要左边的间距
        middle = Xlim_S - space//2  # 获得左边中间位置
    if PT == 'T':
        space = np.delete(space, 0)  #需要右边的间距
        middle = Xlim_S + space//2  # 获得右边中间位置
    middle[middle > 999] = 999  # 去掉索引超出范围的点
    middle[middle < 0] = 0
    middle = middle.astype(int)
    #print(middle,"middle")
    #print(Scope)
    PT_Xlim, PT_Ylim = PT_location_supplement(data_process, middle, Scope=space//2-Scope, PT = PT, baseline = baseline)
    return PT_Xlim, PT_Ylim

def P_location(data_process, Q_Xlim, TFR_Xlim, Scope, Baseline):
    P_Xlim = []
    P_Ylim = []
    space = Space_P(Q_Xlim, TFR_Xlim)-Scope
    for i in range(len(TFR_Xlim)):
        P_X, P_Y = base_leave(data_process=data_process, location=TFR_Xlim[i], Scope=space[i], PT='P', baseline=Baseline)
        P_Xlim.append(P_X)
        P_Ylim.append(P_Y)
    return P_Xlim, P_Ylim
count = 0
for k in range(0,1):
    count = count+1
    if y_train.values[k] ==['NORM']:
        print(y_train.values[k],k)


    """
    data_person = X_train[k, :, :]
    # data_process = data_person[:, 0]
    Xlim, Ylim = R_location_Sup(data_person, threshold=8, high=0.05)
    # print(Xlim)
    #T_Xlim, T_Ylim = T_location(data_person[:, index], Xlim, 3)
    for i in range(1, 12):
        if i in [9, 10, 11]:
            Xlim_S, Ylim_S = R_location_supplement(data_person[:, i], P_N="+", Xlim_S=Xlim, Scope=10)
        else:
            Xlim_S, Ylim_S = R_location_supplement(data_person[:, i], P_N="+", Xlim_S=Xlim, Scope=5)
        # print(Xlim_S)
        Q_Xlim, Q_Ylim, S_Xlim, S_Ylim = Q_S_location(data_person[:, i], Xlim_S, Scope=10)
        Baseline = medfilt(data_person[:, i], 11)
        T_Xlim, T_Ylim = PT_location(data_person[:, i], S_Xlim, 5, 'T', Baseline)
        TFR_Xlim, TFR_Ylim = TF_location(data_person[:, i], T_Xlim, 50, 'right', Baseline)
        TFL_Xlim, TFL_Ylim = TF_location(data_person[:, i], T_Xlim, 50, 'left', Baseline)
        P_Xlim, P_Ylim = PT_location(data_person[:, i], Q_Xlim, 5, 'P', Baseline)
        # print(type(y_train))
        # print(y_train.index)
        
        plt.figure(figsize=(15, 24))
        plt.subplot(12, 1, i+1)
        plt.plot(P_Xlim, P_Ylim, 'ko')
        plt.plot(T_Xlim, T_Ylim, 'bo')
        plt.plot(Q_Xlim, Q_Ylim, 'go')
        plt.plot(S_Xlim, S_Ylim, 'yo')
        plt.plot(Xlim_S, Ylim_S, 'ro')
        plt.plot(data_person[:, i])
        plt.plot(Baseline)
        plt.grid()
        plt.show()
    """
print(count)
# plt.savefig("1.jpg")