553 lines
21 KiB
Python
553 lines
21 KiB
Python
import os
|
|
import json
|
|
import logging
|
|
from unittest import result
|
|
import pandas as pd
|
|
import numpy as np
|
|
from scipy.io import savemat, loadmat
|
|
from typing import Dict, Any, Optional, Tuple
|
|
from datetime import datetime
|
|
|
|
from werkzeug.wrappers import response
|
|
|
|
from udp_handler import UdpHandler
|
|
|
|
from config import config_manager
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class CustomFloatEncoder(json.JSONEncoder):
|
|
"""自定义浮点数编码器"""
|
|
|
|
def encode(self, o):
|
|
if isinstance(o, float):
|
|
return format(o, '.3f')
|
|
if isinstance(o, dict):
|
|
return "{" + ", ".join(f"{json.dumps(k)}: {self.encode(v)}" for k, v in o.items()) + "}"
|
|
if isinstance(o, list):
|
|
return "[" + ", ".join(self.encode(v) for v in o) + "]"
|
|
return super().encode(o)
|
|
|
|
class ComputeService:
|
|
"""计算服务"""
|
|
|
|
def __init__(self, dev_id: str):
|
|
"""初始化计算服务
|
|
|
|
Args:
|
|
udp_handler: UDP处理器实例
|
|
template_path: MAT模板文件路径
|
|
"""
|
|
|
|
self.template_path = config_manager.get('template_path',
|
|
r'D:\Python\CPY_Server\InStructTemplate.mat')
|
|
|
|
port = config_manager.get('udp_map', {}).get(dev_id, None)
|
|
if port is None:
|
|
logger.error(f"UDP port not found for dev_id: {dev_id}")
|
|
port = 15000
|
|
|
|
self.udp_handler = UdpHandler(port,
|
|
config_manager.get('udp.host', '127.0.0.1'))
|
|
|
|
if not self.udp_handler.search_for_available_udp_port():
|
|
logger.error("ComputeService is not available")
|
|
self.available = False
|
|
raise Exception("ComputeService is not available")
|
|
|
|
self.available = True
|
|
|
|
self.dev_id = dev_id
|
|
|
|
# 数据缓冲区
|
|
self.dm_buffer = {
|
|
'X': [],
|
|
'Y': [],
|
|
'X_std': 0,
|
|
'Y_std': 0,
|
|
'dev1': [],
|
|
'dev2': [],
|
|
'dev1_std': 0,
|
|
'dev2_std': 0,
|
|
'all_std': 0
|
|
}
|
|
|
|
# 服务状态
|
|
self.available = False
|
|
|
|
# 统计信息
|
|
self.cal_count = 0
|
|
self.last_result = None
|
|
|
|
logger.info(f"ComputeService initialized with template: {self.template_path}")
|
|
|
|
|
|
|
|
def reset_buffer(self):
|
|
"""重置数据缓冲区"""
|
|
self.dm_buffer = {
|
|
'X': [],
|
|
'Y': [],
|
|
'X_std': 0,
|
|
'Y_std': 0,
|
|
'dev1': [],
|
|
'dev2': [],
|
|
'dev1_std': 0,
|
|
'dev2_std': 0,
|
|
'all_std': 0
|
|
}
|
|
logger.info("Data buffer reset")
|
|
|
|
def csv_to_mat(self, csv_path: str, init: int = 0, metadata: Optional[Dict[str, Any]] = None) -> Optional[str]:
|
|
"""将CSV文件转换为MAT文件
|
|
|
|
Args:
|
|
csv_path: CSV文件路径
|
|
init: 是否初始化(1表示初始化)
|
|
|
|
Returns:
|
|
str: MAT文件路径,失败返回None
|
|
"""
|
|
try:
|
|
# 读取CSV文件
|
|
df = pd.read_csv(csv_path, nrows=8000)
|
|
|
|
# 取CH1和CH2两列的数据
|
|
df = df[['CH1', 'CH2']]
|
|
|
|
# 交换CH1和CH2
|
|
df = df[['CH2', 'CH1']]
|
|
|
|
# 检查df['CH1']每一行,如果有小于0的,就置为0
|
|
df['CH1'] = df['CH1'].apply(lambda x: x if x > 0 else 0)
|
|
|
|
# 检查df['CH2']每一行,如果有小于0的,就置为0
|
|
df['CH2'] = df['CH2'].apply(lambda x: x if x > 0 else 0)
|
|
|
|
# 判断最大值,如果最大值大于100000,则除以5,小于10000,则乘以5
|
|
max_val = df['CH1'].max()
|
|
if max_val > 100000:
|
|
df['CH1'] = df['CH1'].divide(5)
|
|
df['CH2'] = df['CH2'].divide(5)
|
|
elif max_val > 60000:
|
|
df['CH1'] = df['CH1'].divide(3)
|
|
df['CH2'] = df['CH2'].divide(3)
|
|
elif max_val < 10000:
|
|
df['CH1'] = df['CH1'].multiply(3)
|
|
df['CH2'] = df['CH2'].multiply(3)
|
|
|
|
# 舍弃小数位,只保留整数
|
|
df = df.astype(int)
|
|
|
|
# 如果是direction_1,逆序
|
|
if 'direction_1' in csv_path or 'UP' in csv_path:
|
|
df = df.iloc[::-1]
|
|
|
|
# 读取模板MAT文件
|
|
mat_data = loadmat(self.template_path)
|
|
|
|
# 替换InStruct.iIntensX和InStruct.iIntensY的值
|
|
mat_data['InStruct']['iIntensX'][0, 0] = df['CH1'].values.astype(np.uint16)
|
|
mat_data['InStruct']['iIntensY'][0, 0] = df['CH2'].values.astype(np.uint16)
|
|
|
|
# 设置设备类型
|
|
if 'device1' in csv_path or 'Scanner1' in csv_path :
|
|
mat_data['InStruct']['Settings'][0, 0][0, 0] = 5
|
|
elif 'device2' in csv_path or 'Scanner2' in csv_path:
|
|
mat_data['InStruct']['Settings'][0, 0][0, 0] = 4
|
|
|
|
# 设置其他参数
|
|
mat_data['InStruct']['Settings'][0, 0][0, 2] = 1.0 #内屏
|
|
mat_data['InStruct']['Settings'][0, 0][0, 3] = 10.5 #绝缘
|
|
mat_data['InStruct']['Settings'][0, 0][0, 4] = 1.0 #外屏
|
|
mat_data['InStruct']['Settings'][0, 0][0, 5] = 46 #总直径
|
|
mat_data['InStruct']['Settings'][0, 0][0, 6] = 20.5 #导体直径
|
|
|
|
if metadata and 'product_info' in metadata:
|
|
try:
|
|
mat_data['InStruct']['Settings'][0, 0][0, 2] = metadata.get('product_info', {}).get('ISC', 1.0) #内屏
|
|
mat_data['InStruct']['Settings'][0, 0][0, 3] = metadata.get('product_info', {}).get('INS', 10.5) #绝缘
|
|
mat_data['InStruct']['Settings'][0, 0][0, 4] = metadata.get('product_info', {}).get('OSC', 1.0) #外屏
|
|
except:
|
|
pass
|
|
|
|
# 设置初始化标志
|
|
if init:
|
|
mat_data['InStruct']['Settings'][0, 0][0, 9] = 1
|
|
else:
|
|
mat_data['InStruct']['Settings'][0, 0][0, 9] = 0
|
|
|
|
# 删除不需要的字段
|
|
try:
|
|
del mat_data['OutStruct']
|
|
del mat_data['MatlabGateway_TimeStamp']
|
|
del mat_data['mem']
|
|
del mat_data['__globals__']
|
|
except:
|
|
pass
|
|
|
|
# 生成输出文件名
|
|
mat_path = csv_path.replace('.csv', '_in.mat')
|
|
|
|
# 保存MAT文件
|
|
savemat(mat_path, mat_data, appendmat=False)
|
|
logger.info(f"Converted CSV to MAT: {csv_path} -> {mat_path}")
|
|
|
|
return mat_path
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to convert CSV to MAT: {e}")
|
|
return None
|
|
|
|
def _update_buffer(self, result_data: Dict[str, Any], out_path: str):
|
|
"""更新数据缓冲区
|
|
|
|
Args:
|
|
result_data: 结果数据
|
|
out_path: 输出文件路径
|
|
"""
|
|
try:
|
|
XEdgeLeft = result_data['XEdgeLeft']
|
|
XEdgeRight = result_data['XEdgeRight']
|
|
YEdgeLeft = result_data['YEdgeLeft']
|
|
YEdgeRight = result_data['YEdgeRight']
|
|
|
|
# 更新X缓冲区
|
|
if XEdgeRight[0] > 0.1 and XEdgeLeft[0] > 0.1:
|
|
XEdgeDist = XEdgeRight[0] - XEdgeLeft[0]
|
|
self.dm_buffer['X'].append(XEdgeDist)
|
|
if len(self.dm_buffer['X']) > 10:
|
|
self.dm_buffer['X'].pop(0)
|
|
self.dm_buffer['X_std'] = np.std(self.dm_buffer['X'])
|
|
|
|
# 更新Y缓冲区
|
|
if YEdgeRight[0] > 0.1 and YEdgeLeft[0] > 0.1:
|
|
YEdgeDist = YEdgeRight[0] - YEdgeLeft[0]
|
|
self.dm_buffer['Y'].append(YEdgeDist)
|
|
if len(self.dm_buffer['Y']) > 10:
|
|
self.dm_buffer['Y'].pop(0)
|
|
self.dm_buffer['Y_std'] = np.std(self.dm_buffer['Y'])
|
|
|
|
# 更新设备1缓冲区
|
|
if 'device1' in out_path or 'Scanner1' in out_path:
|
|
if XEdgeRight[0] > 0.1 and XEdgeLeft[0] > 0.1:
|
|
XEdgeDist = XEdgeRight[0] - XEdgeLeft[0]
|
|
self.dm_buffer['dev1'].append(XEdgeDist)
|
|
if len(self.dm_buffer['dev1']) > 10:
|
|
self.dm_buffer['dev1'].pop(0)
|
|
self.dm_buffer['dev1_std'] = np.std(self.dm_buffer['dev1'])
|
|
if YEdgeRight[0] > 0.1 and YEdgeLeft[0] > 0.1:
|
|
YEdgeDist = YEdgeRight[0] - YEdgeLeft[0]
|
|
self.dm_buffer['dev1'].append(YEdgeDist)
|
|
if len(self.dm_buffer['dev1']) > 10:
|
|
self.dm_buffer['dev1'].pop(0)
|
|
self.dm_buffer['dev1_std'] = np.std(self.dm_buffer['dev1'])
|
|
|
|
# 更新设备2缓冲区
|
|
elif 'device2' in out_path or 'Scanner2' in out_path:
|
|
if XEdgeRight[0] > 0.1 and XEdgeLeft[0] > 0.1:
|
|
XEdgeDist = XEdgeRight[0] - XEdgeLeft[0]
|
|
self.dm_buffer['dev2'].append(XEdgeDist)
|
|
if len(self.dm_buffer['dev2']) > 10:
|
|
self.dm_buffer['dev2'].pop(0)
|
|
self.dm_buffer['dev2_std'] = np.std(self.dm_buffer['dev2'])
|
|
if YEdgeRight[0] > 0.1 and YEdgeLeft[0] > 0.1:
|
|
YEdgeDist = YEdgeRight[0] - YEdgeLeft[0]
|
|
self.dm_buffer['dev2'].append(YEdgeDist)
|
|
if len(self.dm_buffer['dev2']) > 10:
|
|
self.dm_buffer['dev2'].pop(0)
|
|
self.dm_buffer['dev2_std'] = np.std(self.dm_buffer['dev2'])
|
|
|
|
# 更新总体标准差
|
|
if len(self.dm_buffer['dev1']) >= 10 or len(self.dm_buffer['dev2']) >= 10:
|
|
self.dm_buffer['all_std'] = np.std(self.dm_buffer['dev1'] + self.dm_buffer['dev2'])
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to update buffer: {e}")
|
|
|
|
def _process_result(self, mat_data: Dict[str, Any], out_path: str) -> Dict[str, Any]:
|
|
"""处理计算结果
|
|
|
|
Args:
|
|
mat_data: MAT文件数据
|
|
out_path: 输出文件路径
|
|
|
|
Returns:
|
|
dict: 处理后的结果
|
|
"""
|
|
try:
|
|
ret = {}
|
|
|
|
# 提取边缘数据
|
|
XEdgeLeft = mat_data['OutStruct']['EdgesLeftX'][0, 0].flatten().tolist()
|
|
XEdgeRight = mat_data['OutStruct']['EdgesRightX'][0, 0].flatten().tolist()
|
|
YEdgeLeft = mat_data['OutStruct']['EdgesLeftY'][0, 0].flatten().tolist()
|
|
YEdgeRight = mat_data['OutStruct']['EdgesRightY'][0, 0].flatten().tolist()
|
|
|
|
# 更新缓冲区
|
|
self._update_buffer({
|
|
'XEdgeLeft': XEdgeLeft,
|
|
'XEdgeRight': XEdgeRight,
|
|
'YEdgeLeft': YEdgeLeft,
|
|
'YEdgeRight': YEdgeRight
|
|
}, out_path)
|
|
|
|
# 提取重量数据
|
|
WtISC = mat_data['OutStruct']['WtISC'][0, 0].flatten().tolist()
|
|
WtOSC = mat_data['OutStruct']['WtOSC'][0, 0].flatten().tolist()
|
|
WtINS = mat_data['OutStruct']['WtINS'][0, 0].flatten().tolist()
|
|
WtALL = mat_data['OutStruct']['WtALL'][0, 0].flatten().tolist()
|
|
|
|
vals = mat_data['OutStruct']['WtBis'][0, 0].flatten().tolist()
|
|
|
|
# 外屏层
|
|
ret['WtOSC'] = [0 for _ in range(8)]
|
|
ret['WtOSC'][0] = vals[2]
|
|
ret['WtOSC'][1] = WtOSC[0]
|
|
ret['WtOSC'][2] = vals[3]
|
|
ret['WtOSC'][3] = WtOSC[2]
|
|
ret['WtOSC'][4] = vals[0]
|
|
ret['WtOSC'][5] = WtOSC[1]
|
|
ret['WtOSC'][6] = vals[1]
|
|
ret['WtOSC'][7] = WtOSC[3]
|
|
|
|
# 绝缘层
|
|
ret['WtINS'] = [0 for _ in range(8)]
|
|
ret['WtINS'][0] = vals[6]
|
|
ret['WtINS'][1] = WtINS[0]
|
|
ret['WtINS'][2] = vals[7]
|
|
ret['WtINS'][3] = WtINS[2]
|
|
ret['WtINS'][4] = vals[4]
|
|
ret['WtINS'][5] = WtINS[1]
|
|
ret['WtINS'][6] = vals[5]
|
|
ret['WtINS'][7] = WtINS[3]
|
|
|
|
# 内屏层
|
|
ret['WtISC'] = [0 for _ in range(8)]
|
|
ret['WtISC'][0] = vals[10]
|
|
ret['WtISC'][1] = WtISC[0]
|
|
ret['WtISC'][2] = vals[11]
|
|
ret['WtISC'][3] = WtISC[2]
|
|
ret['WtISC'][4] = vals[8]
|
|
ret['WtISC'][5] = WtISC[1]
|
|
ret['WtISC'][6] = vals[9]
|
|
ret['WtISC'][7] = WtISC[3]
|
|
|
|
# 总壁厚
|
|
ret['WtALL'] = [0 for _ in range(8)]
|
|
ret['WtALL'][0] = vals[14]
|
|
ret['WtALL'][1] = WtALL[0]
|
|
ret['WtALL'][2] = vals[15]
|
|
ret['WtALL'][3] = WtALL[2]
|
|
ret['WtALL'][4] = vals[12]
|
|
ret['WtALL'][5] = WtALL[1]
|
|
ret['WtALL'][6] = vals[13]
|
|
ret['WtALL'][7] = WtALL[3]
|
|
|
|
# 提取角度数据
|
|
mmang = mat_data['OutStruct']['MMAng'][0, 0].flatten().tolist()
|
|
|
|
ret['AngOSC'] = [90 + val for val in mmang[0:2]]
|
|
ret['AngOSC'].append(90 + WtOSC[10])
|
|
for i in range(len(ret['AngOSC'])):
|
|
if ret['AngOSC'][i] >= 360:
|
|
ret['AngOSC'][i] = ret['AngOSC'][i] - 360
|
|
|
|
ret['AngINS'] = [90 + val for val in mmang[2:4]]
|
|
ret['AngINS'].append(90 + WtINS[10])
|
|
for i in range(len(ret['AngINS'])):
|
|
if ret['AngINS'][i] >= 360:
|
|
ret['AngINS'][i] = ret['AngINS'][i] - 360
|
|
|
|
ret['AngISC'] = [90 + val for val in mmang[4:6]]
|
|
ret['AngISC'].append(90 + WtISC[10])
|
|
for i in range(len(ret['AngISC'])):
|
|
if ret['AngISC'][i] >= 360:
|
|
ret['AngISC'][i] = ret['AngISC'][i] - 360
|
|
|
|
ret['AngALL'] = [90 + val for val in mmang[6:8]]
|
|
ret['AngALL'].append(90 + WtALL[10])
|
|
for i in range(len(ret['AngALL'])):
|
|
if ret['AngALL'][i] >= 360:
|
|
ret['AngALL'][i] = ret['AngALL'][i] - 360
|
|
|
|
# 提取直径数据
|
|
ret['DmCORE'] = mat_data['OutStruct']['DmCORE'][0, 0].flatten().tolist()[0:3]
|
|
ret['DmCORE'] = [val - 0.2 for val in ret['DmCORE']]
|
|
ret['DmALL'] = mat_data['OutStruct']['DmALL'][0, 0].flatten().tolist()[0:3]
|
|
ret['DmALL'] = [val - 0.2 for val in ret['DmALL']]
|
|
|
|
# 计算偏心率
|
|
err = max(ret['WtINS']) - min(ret['WtINS'])
|
|
if max(ret['WtINS']) < 0.1:
|
|
ret['EccentricityINS'] = 0
|
|
else:
|
|
ret['EccentricityINS'] = err * 100.0 / max(ret['WtINS'])
|
|
|
|
err = max(ret['WtOSC']) - min(ret['WtOSC'])
|
|
if max(ret['WtOSC']) < 0.1:
|
|
ret['EccentricityOSC'] = 0
|
|
else:
|
|
ret['EccentricityOSC'] = err * 100.0 / max(ret['WtOSC'])
|
|
|
|
err = max(ret['WtISC']) - min(ret['WtISC'])
|
|
if max(ret['WtISC']) < 0.1:
|
|
ret['EccentricityISC'] = 0
|
|
else:
|
|
ret['EccentricityISC'] = err * 100.0 / max(ret['WtISC'])
|
|
|
|
# 波动性
|
|
ret['Volatility'] = [self.dm_buffer['dev1_std'], self.dm_buffer['dev2_std'], self.dm_buffer['all_std']]
|
|
|
|
# 边缘数据
|
|
ret['EdgesB'] = XEdgeLeft[0:4] + XEdgeRight[0:4][::-1]
|
|
ret['EdgesA'] = YEdgeLeft[0:4] + YEdgeRight[0:4][::-1]
|
|
ret['EdgesA'].sort()
|
|
ret['EdgesB'].sort()
|
|
|
|
# 如果是direction_1,需要反转边缘数据
|
|
if 'direction_1' in out_path or 'UP' in out_path:
|
|
rawDataLen = len(mat_data['OutStruct']['NormVideoX'][0, 0].flatten().tolist())
|
|
width = rawDataLen * 0.04
|
|
for i in range(len(ret['EdgesB'])):
|
|
if ret['EdgesB'][i] > 0.1:
|
|
ret['EdgesB'][i] = width - ret['EdgesB'][i]
|
|
if ret['EdgesA'][i] > 0.1:
|
|
ret['EdgesA'][i] = width - ret['EdgesA'][i]
|
|
|
|
return ret
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to process result: {e}")
|
|
return {}
|
|
|
|
def compute(self, mat_path: str, timeout: float = 2.0) -> Tuple[Optional[str], Optional[Dict[str, Any]]]:
|
|
"""执行计算
|
|
|
|
Args:
|
|
mat_path: MAT文件路径
|
|
timeout: 超时时间(秒)
|
|
|
|
Returns:
|
|
tuple: (输出文件路径, 结果字典)
|
|
"""
|
|
try:
|
|
# 通过UDP发送计算命令
|
|
start_time = datetime.now()
|
|
out_path = self.udp_handler.compute(mat_path, timeout)
|
|
end_time = datetime.now()
|
|
logger.info(f"---------------Computing used time: {end_time - start_time}---------------")
|
|
|
|
if not out_path:
|
|
logger.error("Compute failed: no output path returned")
|
|
self.available = False
|
|
return None, None
|
|
|
|
# 检查输出文件是否存在
|
|
if not os.path.exists(out_path):
|
|
logger.error(f"Output file not found: {out_path}")
|
|
return None, None
|
|
|
|
# 读取结果文件
|
|
mat_data = loadmat(out_path)
|
|
|
|
# 处理结果
|
|
result = self._process_result(mat_data, out_path)
|
|
|
|
logger.info(f"Compute completed: {out_path}")
|
|
|
|
return out_path, result
|
|
|
|
except Exception as e:
|
|
logger.error(f"Compute failed: {e}")
|
|
return None, None
|
|
|
|
def compute_file(self, csv_path: str, init: int = 0, metadata: Optional[Dict[str, Any]] = None) -> Optional[str]:
|
|
"""计算CSV文件
|
|
|
|
Args:
|
|
csv_path: CSV文件路径
|
|
init: 是否初始化
|
|
|
|
Returns:
|
|
str: JSON格式的结果,失败返回None
|
|
"""
|
|
try:
|
|
start_time = datetime.now()
|
|
|
|
# 如果是初始化,重置缓冲区
|
|
if init:
|
|
self.reset_buffer()
|
|
|
|
# 转换CSV到MAT
|
|
mat_path = self.csv_to_mat(csv_path, init, metadata)
|
|
|
|
if not mat_path:
|
|
return json.dumps({'error': 'Failed to convert CSV to MAT'})
|
|
|
|
# 执行计算
|
|
out_path, result = self.compute(mat_path)
|
|
|
|
if not out_path or not result:
|
|
return json.dumps({'error': 'Compute failed'})
|
|
|
|
# 转换为JSON
|
|
result_json = json.dumps(result, cls=CustomFloatEncoder)
|
|
|
|
# 更新统计
|
|
self.cal_count += 1
|
|
self.last_result = result_json
|
|
|
|
end_time = datetime.now()
|
|
logger.info(f"Compute completed in {end_time - start_time}")
|
|
|
|
return result_json
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to compute file: {e}")
|
|
return json.dumps({'error': str(e)})
|
|
finally:
|
|
if not config_manager.get('data_file_save', True):
|
|
if csv_path and os.path.exists(csv_path):
|
|
os.remove(csv_path)
|
|
if mat_path and os.path.exists(mat_path):
|
|
os.remove(mat_path)
|
|
if out_path and os.path.exists(out_path):
|
|
os.remove(out_path)
|
|
|
|
def get_status(self) -> Dict[str, Any]:
|
|
"""获取服务状态
|
|
|
|
Returns:
|
|
dict: 状态信息
|
|
"""
|
|
return {
|
|
'available': self.available,
|
|
'cal_count': self.cal_count,
|
|
'buffer_size': {
|
|
'X': len(self.dm_buffer['X']),
|
|
'Y': len(self.dm_buffer['Y']),
|
|
'dev1': len(self.dm_buffer['dev1']),
|
|
'dev2': len(self.dm_buffer['dev2'])
|
|
},
|
|
'buffer_std': {
|
|
'X_std': self.dm_buffer['X_std'],
|
|
'Y_std': self.dm_buffer['Y_std'],
|
|
'dev1_std': self.dm_buffer['dev1_std'],
|
|
'dev2_std': self.dm_buffer['dev2_std'],
|
|
'all_std': self.dm_buffer['all_std']
|
|
}
|
|
}
|
|
|
|
def is_available(self) -> bool:
|
|
"""检查服务是否可用
|
|
|
|
Returns:
|
|
bool: 是否可用
|
|
"""
|
|
return self.udp_handler.is_available()
|
|
|
|
def close(self):
|
|
"""关闭服务"""
|
|
self.udp_handler.close()
|