Files
CPY_DevController/x_ray_data_processor.py
T

484 lines
18 KiB
Python

"""
X光数据处理模块
包含自动选择圆弧区间、拟合和数据校正等功能
"""
import numpy as np
import pandas as pd
from scipy.optimize import curve_fit
from scipy.ndimage import gaussian_filter1d
import os.path
import struct
from scipy.signal import argrelextrema, savgol_filter
class XRayDataProcessor:
def __init__(self):
"""初始化X光数据处理器"""
# 初始化数据存储
self.data = None
self.index_data = None
self.channel_data = None
self.smoothed_data = None
self.derivative_data = None
self.results = None
self.selected_spans = {'CH1': [], 'CH2': []}
self.pipe_diameter = 130
def set_pipe_diameter(self, diameter):
"""设置管道直径"""
self.pipe_diameter = diameter
def load_data(self, filepath):
"""加载CSV数据文件"""
try:
self.data = pd.read_csv(filepath)
self.channel_data = {
'CH1': self.data['CH1'].values.astype(float),
'CH2': self.data['CH2'].values.astype(float)
}
try:
self.index_data = self.data['INDEX'].values.astype(int)
except:
self.index_data = np.arange(len(self.channel_data['CH1']))
# 计算平滑数据和导数
self.calculate_smoothed_and_derivative()
return True
except Exception as e:
print(f"加载数据出错: {str(e)}")
return False
def calculate_smoothed_and_derivative(self, sigma=2.0):
"""计算高斯滤波平滑数据和一阶导数"""
try:
if self.channel_data is None:
return False
# 为每个通道计算平滑数据和导数
self.smoothed_data = {}
self.derivative_data = {}
for ch in self.channel_data.keys():
# 使用高斯滤波平滑数据
smoothed = gaussian_filter1d(self.channel_data[ch], sigma)
self.smoothed_data[ch] = smoothed
# 计算平滑数据的一阶导数
derivative = np.gradient(smoothed, self.index_data)
self.derivative_data[ch] = derivative
return True
except Exception as e:
print(f"计算平滑数据和导数出错: {str(e)}")
return False
def find_outer_peak(self, data, sigma=2.0, peak_threshold=0.15):
"""
找到一阶导数绝对值的主要极值点,作为圆弧的外侧
"""
# 1. 平滑数据,消除噪声
smoothed = gaussian_filter1d(data, sigma=sigma)
# 2. 从头开始,若第data[k] - data[k + 50] > data[k] * 0.2,说明k是外侧极值点
outer_peaks = [100, len(data) - 100]
for k in range(len(data) - 50):
if smoothed[k] - smoothed[k + 50] > smoothed[k] * peak_threshold:
outer_peaks[0] = k
break
# 3. 从尾开始,若第data[k] - data[k - 50] > data[k] * 0.2,说明k是外侧极值点
for k in range(len(data) - 50, 0, -1):
if smoothed[k] - smoothed[k - 50] > smoothed[k] * peak_threshold:
outer_peaks[1] = k
break
return outer_peaks
def find_derivative_peaks(self, deriv_data, sigma=5, peak_threshold=0.3):
"""
精准找出一阶导数绝对值的主要极值点
:param deriv_data: 一阶导数数组(CH1或CH2的一阶导数)
:param sigma: 平滑窗口大小,建议5-11,越大去噪越强
:param peak_threshold: 峰值过滤比例(0-1),越大越严格
:return: 峰值索引列表,按强度从高到低排序
"""
# 1. 平滑一阶导数,消除噪声
deriv_smooth = savgol_filter(deriv_data, window_length=sigma, polyorder=2)
# 2. 取绝对值,让正负跳变都变成正向峰值
deriv_abs = np.abs(deriv_smooth)
# 3. 找所有局部极大值点
all_peaks_idx = argrelextrema(deriv_abs, np.greater)[0]
if len(all_peaks_idx) == 0:
return []
# 4. 按峰值强度排序,过滤掉小噪声峰
peak_values = deriv_abs[all_peaks_idx]
sorted_idx = all_peaks_idx[np.argsort(peak_values)[::-1]] # 从大到小排序
# 只保留强度超过「最大峰值×阈值」的主峰值
max_peak = deriv_abs.max()
valid_peaks = [idx for idx in sorted_idx if deriv_abs[idx] >= max_peak * peak_threshold]
max4 = sorted([int(x) for x in valid_peaks[:4]])
print(max4)
return max4 # 最多返回前4个最强峰
def auto_select_arcs(self):
"""自动选择两侧的圆弧部分,对CH1和CH2通道分别处理"""
if self.index_data is None or len(self.index_data) < 10:
print("无可用数据")
return False
try:
# 清除之前的选择
self.selected_spans = {'CH1': [], 'CH2': []}
# 确保已计算平滑数据和导数
if self.derivative_data is None:
self.calculate_smoothed_and_derivative()
if self.derivative_data is None:
print("无法计算导数数据")
return False
# 为两个通道分别寻找区间
ch1_spans = self._find_spans_for_channel('CH1')
ch2_spans = self._find_spans_for_channel('CH2')
# 为每个通道存储各自的区间
success_count = 0
if ch1_spans:
self.selected_spans['CH1'] = ch1_spans
print(f"已为CH1通道选择{len(ch1_spans)}个区间")
success_count += 1
if ch2_spans:
self.selected_spans['CH2'] = ch2_spans
print(f"已为CH2通道选择{len(ch2_spans)}个区间")
success_count += 1
if success_count == 0:
# 两个通道都失败
print("两个通道均未能找到合适的区间,请尝试手动选择")
return False
return True
except Exception as e:
print(f"自动选择过程中出错: {str(e)}")
return False
def _find_spans_for_channel(self, channel):
"""为指定通道寻找合适的区间"""
data = self.channel_data[channel]
n = len(self.index_data)
potential_extremes = self.find_outer_peak(data)
# 至少有两个极值点,选择第一个和最后一个
p1 = potential_extremes[0]
p2 = potential_extremes[-1]
# 计算区间边界: [p1*0.2, p1*0.9], [(n-p2)*0.1+p2, (n-p2)*0.7+p2]
left_start_idx = max(0, int(p1 * 0.01))
left_end_idx = min(n-1, int(p1))
right_start_idx = min(n-1, p2)
right_end_idx = min(n-1, int(n - (n - p2) * 0.01))
# 转换为INDEX值
left_span = (self.index_data[left_start_idx], self.index_data[left_end_idx])
right_span = (self.index_data[right_start_idx], self.index_data[right_end_idx])
# 记录找到的极值点信息
print(f"{channel} 通道找到极值点: p1={p1}, p2={p2},区间: 左=({left_start_idx},{left_end_idx}), 右=({right_start_idx},{right_end_idx})")
spans = [left_span, right_span]
return spans
def set_manual_spans(self, spans, channel=None):
"""手动设置区间列表
参数:
spans: 区间列表或字典
channel: 指定通道,None表示设置所有通道
"""
if channel is not None and channel in ['CH1', 'CH2']:
self.selected_spans[channel] = spans
else:
# 如果是字典格式,分别设置每个通道
if isinstance(spans, dict):
for ch in ['CH1', 'CH2']:
if ch in spans:
self.selected_spans[ch] = spans[ch]
else:
# 否则设置所有通道为相同的区间
self.selected_spans = {'CH1': spans, 'CH2': spans}
return True
def fit_data(self):
"""根据选择的区间拟合数据"""
# 检查是否有任何通道选择了区间
if not any(self.selected_spans.values()):
print("请先选择至少一个数据区间")
return False
try:
self.results = {}
# 为每个通道分别进行拟合
for ch in ['CH1', 'CH2']:
if not self.selected_spans[ch]:
print(f"{ch}通道未选择区间,跳过拟合")
continue
print(f"{ch}通道选择的区间: {self.selected_spans[ch]}")
# 合并当前通道所有选中的数据点
selected_indices = []
for span in self.selected_spans[ch]:
indices_in_span = np.where((self.index_data >= span[0]) & (self.index_data <= span[1]))[0]
selected_indices.extend(indices_in_span)
# 确保索引是唯一的并且排序
selected_indices = sorted(list(set(selected_indices)))
if len(selected_indices) < 10:
print(f"{ch}通道选择的数据点太少({len(selected_indices)}个),无法进行可靠拟合")
continue
# 提取选中区间的数据
selected_index_data = self.index_data[selected_indices]
selected_channel_data = self.channel_data[ch][selected_indices]
# 分析数据
self.results[ch] = self._analyze_channel(ch, selected_channel_data, selected_index_data)
# 计算拟合曲线(对全部数据范围)
full_indices = self.index_data
params = self.results[ch]['params_opt']
self.results[ch]['Q_fit_full'] = self._model(full_indices, *params)
self.results[ch]['index_full'] = full_indices
# 检查是否有成功拟合的通道
if not self.results:
print("没有通道成功进行拟合")
return False
self._print_fit_results()
return True
except Exception as e:
print(f"拟合过程中出错: {str(e)}")
return False
def _model(self, index, Q0, mu, offset):
"""X光束衰减模型"""
R = self.pipe_diameter / 2
t = 0.8
factor = 0.04
X = factor * (index - offset)
X_clip = np.clip(X, -(R-1), R-1)
term1 = np.sqrt((R + t)**2 - X_clip**2)
term2 = np.sqrt(R**2 - X_clip**2)
L = 2 * (term1 - term2)
return Q0 * np.exp(-mu * L)
def _analyze_channel(self, channel_name, Q_data, index_data):
"""分析单个通道的数据"""
# 参数设置
initial_guess = [np.max(Q_data)*2, 0.4, np.max(index_data) * 0.5]
bounds = (
[np.max(Q_data), 0.3, np.max(index_data) * 0.2],
[3*np.max(Q_data), 0.5, np.max(index_data) * 0.8]
)
# 执行拟合
params_opt, params_cov = curve_fit(
self._model, index_data, Q_data,
p0=initial_guess,
bounds=bounds,
maxfev=10000
)
# 结果存储
return {
'params_opt': params_opt,
'params_cov': params_cov
}
def _print_fit_results(self):
"""打印拟合结果参数"""
print("双通道拟合参数对比:")
for ch in ['CH1', 'CH2']:
p = self.results[ch]['params_opt']
e = np.sqrt(np.diag(self.results[ch]['params_cov']))
print(f"\n{ch}通道:")
print(f"Q0 = {p[0]:.1f} ± {e[0]:.1f}")
print(f"μ = {p[1]:.6f} ± {e[1]:.6f} mm⁻¹")
print(f"offset = {p[2]:.1f} ± {e[2]:.1f}")
def correct_data(self):
"""根据拟合曲线校正数据"""
if self.results is None:
print("请先进行数据拟合")
return None
try:
# 根据最大拟合值计算校正系数
correction_factors = {}
corrected_data = {}
for ch in ['CH1', 'CH2']:
# 获取当前通道的拟合结果
res = self.results[ch]
# 计算全部数据范围的拟合值
full_fit_values = res['Q_fit_full'] # 已经是全部数据范围的拟合值
# 计算拟合曲线的最大值Q1
Q1 = np.max(full_fit_values)
# 为每个点计算校正系数,避免除以0
safe_fit_values = np.maximum(full_fit_values, 0.1) # 避免除以0
# 计算校正系数:拟合值/最大拟合值
factors = safe_fit_values / Q1
# 存储校正系数和校正后的数据
correction_factors[ch] = factors
corrected_data[ch] = self.channel_data[ch] / factors
return {
'index_data': self.index_data,
'original_data': self.channel_data,
'corrected_data': corrected_data
}
except Exception as e:
print(f"数据校正过程中出错: {str(e)}")
return None
def save_corrected_data(self, corrected_result, output_path, trim_edges=True, trim_amount=200):
"""保存校正后的数据
参数:
corrected_result: correct_data()方法的返回结果
output_path: 输出文件路径
trim_edges: 是否裁剪边缘数据
trim_amount: 裁剪数量,头尾各裁剪的点数
"""
try:
if corrected_result is None:
print("没有校正数据可保存")
return None,None,None
index_data = corrected_result['index_data']
original_data = corrected_result['original_data']
corrected_data = corrected_result['corrected_data']
# 检查数据长度
data_length = len(index_data)
# 如果需要裁剪但数据不足
if trim_edges and data_length <= 2 * trim_amount:
print(f"数据总长度为{data_length}点,不足以去掉头尾各{trim_amount}点。")
print("将保存全部数据。")
trim_edges = False
# 确定数据范围
if trim_edges:
start_idx = trim_amount
end_idx = data_length - trim_amount
else:
start_idx = 0
end_idx = data_length
# 创建要保存的数据
save_data = {
'INDEX': index_data[start_idx:end_idx]
}
# 添加原始数据和校正后的数据
for ch in corrected_data.keys():
save_data[f'{ch}_原始'] = original_data[ch][start_idx:end_idx]
save_data[f'{ch}'] = corrected_data[ch][start_idx:end_idx]
channel_A = []
channel_B = []
for value in save_data['CH1']:
channel_A.append(int(value))
for value in save_data['CH2']:
channel_B.append(int(value))
# print("channel_A",channel_A)
file_content = bytearray()
for i in range (len(channel_A)):
file_content.extend(struct.pack('<ff', channel_A[i], channel_B[i]))
# 创建DataFrame
df = pd.DataFrame(save_data)
# 保存DataFrame到CSV
# df.to_csv(output_path, index=False)
# print(f"数据已成功保存到: {output_path}")
return channel_A,channel_B,file_content
except Exception as e:
print(f"保存数据时出错: {str(e)}")
return None,None,None
processor = XRayDataProcessor()
def correct_data(filename):
# 加载数据
processor.load_data(filename)
filename = filename[0:-4] +"_corrected.csv"
# 自动选择圆弧区间
if processor.auto_select_arcs():
# 拟合数据
if processor.fit_data():
# 校正数据
corrected = processor.correct_data()
# 保存校正后的数据,去掉头尾各200个点
processor.save_corrected_data(
corrected,
filename,
trim_edges=True,
trim_amount=0
)
channel_A = corrected['CH1']
channel_B = corrected['CH2']
return channel_A,channel_B,corrected
return None,None,None
# 示例使用代码
if __name__ == "__main__":
# 创建处理器实例
# 加载数据
processor.load_data("example_data.csv")
# 自动选择圆弧区间
if processor.auto_select_arcs():
# 拟合数据
if processor.fit_data():
# 校正数据
corrected = processor.correct_data()
# 保存校正后的数据,去掉头尾各200个点
processor.save_corrected_data(
corrected,
"corrected_data.csv",
trim_edges=True,
trim_amount=200
)