"""

低通滤波器

:param data: 数据

:param cutoff_fre:截止频率

:param fs: 采样频率

:param order:

:return:

"""

nyq = 0.5 * fs

normal_cutoff = cutoff_fre / nyq

b, a = butter(order, normal_cutoff, analog=False)

y_output = lfilter(b, a, data)

normalization_data = []

max_data = max(data_n)

for d in data_n:

normalization_data.append(round(d / max_data, 4))

"""

.txt文件读取

:param txt_name: 完整txt文件路径，例：'E:\\Python\\Pyinstaller\\TP\\Original_DB\\01.txt'

:return:

"""

with open(txt_name, 'r') as f:

txt_list = f.readlines()

"""

分析Data_***.txt文件

:param rfd_data:

:return:

"""

data_all = []

for d in rfd_data:

wave_list = []

d = d.replace('\t', ' ').split('|')

for wave in d:

if wave != ' \n':

wave = wave.split()

wave_list.append(wave)

data_all.append(wave_list)

try:

data_all = []

if rfds_data[0][:4] == 'Time':

for d in rfds_data:

if d[:4] != 'Time':

fiber_data_list = []

d = d.replace('\t0', '').split('\t')

# date_time = datetime.fromisoformat(d[0][:-4])

fiber_data = d[1:]

for i in fiber_data:

i = i.replace('\n', '')

# i_float = round(float(i), 4) # 修改数据格式，float小数点后保留4位小数

i_float = float(i) # 修改数据格式

fiber_data_list.append(i_float)

# data_all.append([date_time, fiber_data_list])

data_all.append([fiber_data_list])

else:

for d in rfds_data:

# date_time = None

fiber_data_list = []

date_time_temp_ = []

d = d.replace('\t', ' ').split('|')

date_time_temp = d[0].split()

for da in date_time_temp:

if len(da) > 2:

date_time_temp_.append(da)

if len(date_time_temp_) == 8:

# date_time = datetime.fromisoformat(date_time_temp_[0] + ' ' + date_time_temp_[1])

# temperature = float(date_time_temp[1])

fiber_data = date_time_temp_[-6:]

for i in fiber_data:

# fiber_data_list.append(float(i))

# TODO 修改数据格式，float小数点后保留4位小数

fiber_data_list.append(float(i))

data_all.append([fiber_data_list])

return data_all

except Exception as e:

datetime_list = []

temp_list = []

wave_list = []

for d in ttw_data:

if len(d) == 1:

wave_list.append(d[0])

else:

datetime_list.append(d[0])

temp_list.append(d[1])

wave_list.append(d[2])

wave_arr = array(wave_list)

wave_arr_tran = wave_arr.transpose((1, 0))

wave_1 = []

wave_2 = []

wave_3 = []

wave_4 = []

wave_5 = []

wave_6 = []

for w in wave_list:

wave_1.append(w[0])

wave_2.append(w[1])

wave_3.append(w[2])

wave_4.append(w[3])

wave_5.append(w[4])

wave_6.append(w[5])

try:

tw_all_list = []

for wave in tw_wave:

if len(tw_time) == len(wave):

tw_list = []

for i in range(len(tw_time)):

tw_time_str = str(tw_time[i])

wave_str = str(wave[i])

if len(tw_time_str) == 19:

tw_time_str += '.000'

elif len(tw_time_str) == 26:

tw_time_str = tw_time_str[:23]

if len(wave_str) != 9:

wave_str += (9 - len(wave_str)) * '0'

# 数据格式：'2020-07-01 16:02:41.600 1534.2053\n'（二者取其一）

tw_list.append(tw_time_str.replace('.', ':') + ',' + wave_str + '\n')

# 数据格式：'2020-03-02 11:27:38:041,1,8,1,1550.2507,\n'（二者取其一）

# tw_time_str = tw_time_str.replace('.', ':')

# tw_list.append(tw_time_str + ',1,8,1,' + wave_str + ',\n')

tw_all_list.append(tw_list)

return tw_all_list

except Exception as e:

try:

wave_max_set = []

new_tw_wave_ = []

new_arr_wave_ = []

optical_order = [2, 0, 4, 1, 3, 5]

for i_oo in optical_order:

new_tw_wave_.append(tw_wave[i_oo])

new_tw_wave_ *= 2

tw_arr = array(new_tw_wave_)

for wave in tw_arr:

if len(wave) != 0:

wave_dict = c_Counter(wave)

wave_max = max(wave_dict, key=wave_dict.get)

new_arr_wave_.append(wave - wave_max)

wave_max_set.append(wave_max)

wave_display(new_tw_wave_)

new_arr_ = data_calibration(new_arr_wave_)

return new_tw_wave_, new_arr_

except Exception as e:

adjust_data = conf.adjust_data()

new_arr_ = []

if len(new_arr_wave_) != 0:

for i in range(len(new_arr_wave_)):

new_arr_.append(new_arr_wave_[i] * float(adjust_data[i % 6]))

tw_integration_ = []

if len(tw_txt) != 0:

tw_txt_arr = array(tw_txt)

for single_optical in tw_txt_arr:

single_set_ = c_Counter(single_optical)

single_max_ = max(single_set_, key=single_set_.get)

tw_integration_.append(single_optical - single_max_)

# plt.ion()

plt.figure()

plt.subplot(231)

plt.plot(new_wave[0])

plt.grid()

plt.subplot(232)

plt.plot(new_wave[2])

plt.grid()

plt.subplot(233)

plt.plot(new_wave[4])

plt.grid()

plt.subplot(234)

plt.plot(new_wave[1])

plt.grid()

plt.subplot(235)

plt.plot(new_wave[3])

plt.grid()

plt.subplot(236)

plt.plot(new_wave[5])

plt.grid()

# y_min = -0.028

# y_max = 0.08

y_max = float(pic_limits[0])

y_min = float(pic_limits[1])

plt.figure()

plt.subplot(231)

plt.plot(new_wave[0])

plt.ylim((y_min, y_max))

plt.grid()

plt.subplot(232)

plt.plot(new_wave[2])

plt.ylim((y_min, y_max))

plt.grid()

plt.subplot(233)

plt.plot(new_wave[4])

plt.ylim((y_min, y_max))

plt.grid()

plt.subplot(234)

plt.plot(new_wave[1])

plt.ylim((y_min, y_max))

plt.grid()

plt.subplot(235)

plt.plot(new_wave[3])

plt.ylim((y_min, y_max))

plt.grid()

plt.subplot(236)

plt.plot(new_wave[5])

plt.ylim((y_min, y_max))

plt.grid()

try:

wheel_count = 0 # 车轮数量计数

optical_all_data = [] # 一维的数据：所有传感器的数据；二维的数据：各个传感器所有的峰值

if len(txt_list) != 0:

x_coordinate = []

all_each_optical_normalization = []

for each_optical in txt_list:

x_wheel_set = []

max_wheel_set = []

max_wheel_single_set = []

each_optical_normalization = data_normalization(each_optical)

all_each_optical_normalization.append(each_optical_normalization)

y_after_filter = butter_lowpass_filter(each_optical_normalization, 500, 5000)

max_single = []

for i in range(0, len(y_after_filter) - 200, 200):

m = max(y_after_filter[i:i + 200])

if 0.4 < m:

max_single.append(m)

dividing_line = min(max_single) - 0.05

for i in range(len(each_optical)):

x_coordinate.append(round(i / frequency, 4))

if each_optical_normalization[i] > dividing_line:

wheel_set = [x_coordinate[i], each_optical[i]]

x_wheel_set.append(wheel_set)

max_wheel_single_set.append(x_wheel_set[0])

for i in range(1, len(x_wheel_set)): # 两数据之间间隔>=time_gap则视为两段，<time_gap视为一段

if x_wheel_set[i][0] - x_wheel_set[i - 1][0] < time_gap:

max_wheel_single_set.append(x_wheel_set[i])

elif x_wheel_set[i][0] - x_wheel_set[i - 1][0] >= time_gap:

max_wheel_set.append(max_wheel_single_set)

max_wheel_single_set = [x_wheel_set[i]]

if len(max_wheel_single_set) >= 2:

max_wheel_set.append(max_wheel_single_set)

x_data = []

if len(max_wheel_set) != 0:

for max_wheel in max_wheel_set:

if len(max_wheel) != 0:

get_no = round(len(max_wheel) / 2)

x_data.append(max_wheel[get_no][0])

wheel_dict = {}

for i in range(len(each_optical)):

wheel_dict.update({round(x_coordinate[i], 4): round(each_optical[i], 12)})

last_wheel_value = list(wheel_dict)[-1]

x_wheel_list = []

unit_interval = round(1 / frequency, 4)

for x in x_data:

if int(x / unit_interval) <= int(single_wheel_data_count / 2):

x_list = [round(unit_interval * a, 4) for a in range(single_wheel_data_count)]

x_wheel_list.append(x_list)

elif int(single_wheel_data_count / 2) <= int(x / unit_interval) <= int(

last_wheel_value / unit_interval) - int(single_wheel_data_count / 2):

x_list = [round(unit_interval * a, 4) for a in

range(int(frequency * x) - int(single_wheel_data_count / 2),

int(frequency * x) + int(single_wheel_data_count / 2))]

x_wheel_list.append(x_list)

else:

x_list = [round(unit_interval * a, 4) for a in

range(int(frequency * last_wheel_value) - single_wheel_data_count,

int(frequency * last_wheel_value))]

x_wheel_list.append(x_list)

y_wheel = []

y_single_optical = []

for x_wheel in x_wheel_list:

for x_w in x_wheel:

y_w = wheel_dict[x_w]

y_wheel.append(y_w)

y_single_optical.append(y_wheel)

y_wheel = []

if len(y_single_optical) == 32:

wheel_count += 1

# optical_all_data的输出格式:三维列表[12个传感器×32个车轮×600个数据][12×32×600]的矩阵

optical_all_data.append(y_single_optical)

# 新增optical_all_data的size不一致的处理

len_list = []

for optical_data in optical_all_data:

len_opt_data = len(optical_data)

len_list.append(len_opt_data)

zero_list = []

len_count = c_Counter(len_list)

len_ = max(len_count, key=len_count.get)

if len(len_count) != 1:

zero_ = [0.0] * single_wheel_data_count

for i in range(len_):

zero_list.append(zero_)

len_new_list = []

for i in range(len(optical_all_data)):

len_opt_all_data_ = len(optical_all_data[i])

if len_opt_all_data_ != len_:

optical_all_data[i] = zero_list

len_opt_all_data_ = len(optical_all_data[i])

len_new_list.append(len_opt_all_data_)

return optical_all_data

except Exception as e:

try:

op_left = []

op_right = []

op_arr = array(optical_all_data)

for i in range(len(op_arr)):

if i % 2 == 0:

op_left.append(op_arr[i])

else:

op_right.append(op_arr[i])

op_left_arr = array(op_left)

op_right_arr = array(op_right)

op_left_arr_tran = op_left_arr.transpose((1, 0, 2))

op_right_arr_tran = op_right_arr.transpose((1, 0, 2))

op_left_wheel_value = []

op_right_wheel_value = []

if op_left_arr_tran.shape == op_right_arr_tran.shape:

for i in range(len(op_left_arr_tran)):

op_max_left_set = []

op_max_right_set = []

for j in range(len(op_left_arr_tran[i])):

op_max_left = max(op_left_arr_tran[i][j])

op_max_right = max(op_right_arr_tran[i][j])

op_max_left_set.append(op_max_left)

op_max_right_set.append(op_max_right)

op_max_left_result = round(sum(op_max_left_set) / len(op_max_left_set), 12)

op_max_right_result = round(sum(op_max_right_set) / len(op_max_right_set), 12)

op_left_wheel_value.append(op_max_left_result)

op_right_wheel_value.append(op_max_right_result)

op_list = [op_left_wheel_value, op_right_wheel_value]

op_wheel_arr = array(op_list).transpose((1, 0))

return op_wheel_arr

except Exception as e:

try:

# axle_wheel_value = ww_wheel_value.transpose((1, 0))

# 经验值：742.585 对应 2.1t ==> 重量系数：2.1 / 742.585

# sum_left_right = 742.585

# sum_left_right = 789.85

sum_left_right = round(sum(sum(ww_wheel_value)) / len(ww_wheel_value), 12) # 使用固定值，才能确保重量，否则只能对标到2.1t

wheelset_standard_weight = standard_left_weight + standard_right_weight + standard_axle_weight

weight_coefficient = wheelset_standard_weight / sum_left_right

left_wheel_coefficient = standard_left_weight / (standard_left_weight + standard_axle_weight / 2)

right_wheel_coefficient = standard_right_weight / (standard_right_weight + standard_axle_weight / 2)

axle_coefficient = standard_axle_weight / wheelset_standard_weight

wheel_axle_weight = around(ww_wheel_value * weight_coefficient, 4)

wheel_axle_weight_tran = wheel_axle_weight.transpose((1, 0))

# 轮对的重量

wheelset_weight = around(sum(wheel_axle_weight_tran), 4)

# 轴的重量

axle_weight = around(wheelset_weight * axle_coefficient, 3)

# 车轮的重量

left_wheel_weight = around(wheel_axle_weight_tran[0] * left_wheel_coefficient, 3)

right_wheel_weight = around(wheel_axle_weight_tran[1] * right_wheel_coefficient, 3)

wheel_weight = np_append(left_wheel_weight, right_wheel_weight).reshape((2, -1)).transpose((1, 0))

return [wheel_weight, axle_weight, wheelset_weight]

except Exception as e:

"""

# 重量信息写入日志

:param save_path:

:param file_name_:

:param weight_info_:

:return:

"""

try:

loc_time = localtime()

time_format = '%Y-%m-%d %H:%M:%S'

time_ = strftime(time_format, loc_time)

weight_info_0 = str(weight_info_[0])

weight_info_1 = str(weight_info_[1]).replace('\n', '')

weight_info_2 = str(weight_info_[2]).replace('\n', '')

with open(save_path + '\\Wheel Weight.txt', 'a+') as fw:

fw.writelines('\n\n=====================================================================================\n')

fw.writelines(file_name_)

fw.writelines('\t')

fw.writelines(time_)

fw.writelines('\n\nWheel Weight:\n')

fw.writelines(weight_info_0)

fw.writelines('\n\nAxle Weight\n')

fw.writelines(weight_info_1)

fw.writelines('\n\nWheelset Weight\n')

fw.writelines(weight_info_2)

# fw.writelines('\n===========================================================================================\n')

except Exception as e:

try:

file_path = getcwd()

file_name = input('请输入需要分析重量的文件名称（不包含.txt）:')

if file_name[-4:] == '.txt':

p = file_path + '\\' + file_name

else:

p = file_path + '\\' + file_name + '.txt'

data = read_txt(p)

d_a = read_fiber_data_simple(data)

ttw_wave_list = time_temp_wave(d_a)

wave_all = wave_collection(ttw_wave_list)

new_tw_wave, new_arr_wave_ = data_integration(wave_all)

return new_tw_wave, new_arr_wave_

except Exception as e:

try:

file_path = getcwd()

file_name = input('请输入需要分析重量的文件名称（不包含.txt）:')

if file_name[-4:] == '.txt':

p = file_path + '\\' + file_name

else:

p = file_path + '\\' + file_name + '.txt'

data = read_txt(p)

d_a = read_fiber_data_simple(data)

ttw_wave_arr = time_temp_wave(d_a)

# wave_all = wave_collection(ttw_wave_list)

tw_txt, new_arr_wave_ = data_integration(ttw_wave_arr)

tw_integration_ = tw_txt_integration_display(tw_txt)

wave_display(tw_integration_)

tw_optical_all_data = optical_data_splitting_test(new_arr_wave_, o_f_frequency)

tw_wheel_arr = optical_to_wheel(tw_optical_all_data) # 整合传感器：12个传感器的数据整合成32个轴的数据

weight_info = wheel_weight_algorithm(tw_wheel_arr) # 车轮重量计算

weight_info_to_txt(file_path, file_name, weight_info) # 保存重量信息

# plt.show()

print('重量信息见 Wheel Weight.txt 文件！')

return new_arr_wave_

except Exception as e: