484 lines
18 KiB
Python
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
|
|
)
|