jack/Chan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replay is ok now

Browse Source
This commit is contained in:
jackyu66git
2025-06-10 18:02:48 +08:00
parent 55791afed1
commit 2295a0b1f8
2 changed files with 306 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files
web/app.py
+122
View File
@@ -353,6 +353,112 @@ def analyze_chan(df):
for bi in bi_list:
bi.cal_macd_div()
#print(bi.start_time, bi.macd_hist, bi.macd_div)
def generate_replay_data(df, client_tz):
"""生成逐步计算的回放数据"""
print(f"开始生成回放数据，K线总数: {len(df)}")
replay_data = {}
# 为每个K线索引计算分析结果
for i in range(1, len(df) + 1): # 从1开始，至少需要1根K线
try:
# 截取到当前索引的数据
current_df = df.iloc[:i].copy()
# 添加技术指标
current_df = add_indicators(current_df)
# 进行缠论分析
analysis_result = analyze_chan(current_df)
# 计算MACD
macd_data = calculate_macd(current_df)
# 构建该索引对应的分析结果
step_data = {
'kline_data': clean_dataframe_for_json(current_df).to_dict('records'),
'bi_list': [{
'start_time': bi.start_klc.end_time if isinstance(bi.start_klc.end_time, str) else bi.start_klc.end_time.astimezone(client_tz).isoformat(),
'end_time': (bi.end_klc.end_time if isinstance(bi.end_klc.end_time, str) else bi.end_klc.end_time.astimezone(client_tz).isoformat()) if bi.end_klc else None,
'sure_time': format_time_safely(bi.sure_time, client_tz) if bi.sure_time else None,
'start_price': bi.start_klc.low if convert_direction(bi.dir) == 1 else bi.start_klc.high,
'end_price': bi.end_klc.high if convert_direction(bi.dir) == 1 else bi.end_klc.low if bi.end_klc else None,
'direction': convert_direction(bi.dir),
'macd_div': float(bi.macd_div) if hasattr(bi, 'macd_div') else 0
} for bi in analysis_result['bi_list'] if bi.end_klc],
'seg_list': [{
'start_time': seg.start_bi.start_klc.end_time if isinstance(seg.start_bi.start_klc.end_time, str) else seg.start_bi.start_klc.end_time.astimezone(client_tz).isoformat(),
'end_time': (seg.end_bi.end_klc.end_time if isinstance(seg.end_bi.end_klc.end_time, str) else seg.end_bi.end_klc.end_time.astimezone(client_tz).isoformat()) if seg.end_bi else None,
'sure_time': format_time_safely(seg.sure_time, client_tz) if seg.sure_time else None,
'start_price': seg.start_bi.start_klc.low if convert_direction(seg.dir) == 1 else seg.start_bi.start_klc.high,
'end_price': seg.end_bi.end_klc.high if convert_direction(seg.dir) == 1 else seg.end_bi.end_klc.low if seg.end_bi else None,
'direction': convert_direction(seg.dir)
} for seg in analysis_result['seg_list'] if seg.end_bi],
'zs_list': [{
'start_time': zs.start_klc.end_time if isinstance(zs.start_klc.end_time, str) else zs.start_klc.end_time.astimezone(client_tz).isoformat(),
'end_time': (zs.end_klc.end_time if isinstance(zs.end_klc.end_time, str) else zs.end_klc.end_time.astimezone(client_tz).isoformat()) if zs.end_klc else None,
'zg': zs.zg,
'zd': zs.zd,
'is_sure': zs.is_sure
} for zs in analysis_result['zs_list'] if zs.end_klc],
'uncompleted_zs_list': [{
'start_time': zs.start_klc.end_time if isinstance(zs.start_klc.end_time, str) else zs.start_klc.end_time.astimezone(client_tz).isoformat(),
'end_time': None,
'zg': zs.zg,
'zd': zs.zd,
'is_sure': zs.is_sure
} for zs in analysis_result['zs_list'] if not zs.is_sure],
'trade_points': [{
'type': point['type'],
'time': format_time_safely(point['time'], client_tz),
'price': point['price'],
'desc': point['desc']
} for point in analysis_result['trade_points']],
'macd': macd_data,
'bollinger': {
'upper': current_df['bb_upper'].tolist(),
'middle': current_df['bb_middle'].tolist(),
'lower': current_df['bb_lower'].tolist()
},
'element_bollinger': {
'upper': current_df['element_bb_upper'].tolist(),
'middle': current_df['element_bb_middle'].tolist(),
'lower': current_df['element_bb_lower'].tolist()
},
'klc_fx_info': [{
'time': format_time_safely(point['time'], client_tz),
'price': float(point['price']),
'fx_type': point['fx_type'],
'is_bottom': bool(point['is_bottom']),
'fx_strength': float(point['fx_strength']),
'fx_strength_level': str(point['fx_strength_level']),
'is_strong_fx': bool(point['is_strong_fx'])
} for point in analysis_result['klc_fx_info']],
'klu_fx_info': [{
'time': format_time_safely(point['time'], client_tz),
'price': float(point['price']),
'fx_type': point['fx_type'],
'is_bottom': bool(point['is_bottom']),
'fx_strength': float(point['fx_strength']),
'fx_strength_level': str(point['fx_strength_level']),
'is_strong_fx': bool(point['is_strong_fx']),
'fx_confirmed': bool(point['fx_confirmed'])
} for point in analysis_result['klu_fx_info']]
}
replay_data[i-1] = step_data # 使用0-based索引
# 每处理100个点输出一次进度
if i % 100 == 0 or i == len(df):
print(f"生成回放数据进度: {i}/{len(df)}")
except Exception as e:
print(f"生成第{i}步回放数据时出错: {e}")
continue
print(f"回放数据生成完成，总步数: {len(replay_data)}")
return replay_data
# 获取原始K线数据用于KLU分型分析
klu_list = []
@@ -822,9 +928,13 @@ def analyze():
elements_only_param = request.args.get('elements_only')
elements_only = elements_only_param == 'true'
# 获取是否需要回放数据的参数
need_replay_data = request.args.get('need_replay_data', 'false').lower() == 'true'
print(f"API请求参数: symbol={symbol}, timeframe={timeframe}, element_timeframe={element_timeframe}")
print(f"时间范围: start_time={start_time}, end_time={end_time}")
print(f"elements_only参数: 原始值={elements_only_param}, 处理后={elements_only}")
print(f"need_replay_data参数: {need_replay_data}")
# 验证小周期是否小于主周期
if element_timeframe and not is_smaller_or_equal_timeframe(element_timeframe, timeframe):
@@ -862,6 +972,14 @@ def analyze():
# 计算MACD
macd_data = calculate_macd(df)
# 如果需要回放数据，生成逐步计算的回放数据
if need_replay_data:
print("开始生成回放数据...")
replay_data = generate_replay_data(df, client_tz)
print(f"回放数据生成完成，包含 {len(replay_data)} 个步骤")
else:
replay_data = None
# 添加主周期分析结果到返回数据
result.update({
'kline_data': clean_dataframe_for_json(df).to_dict('records'),
@@ -936,6 +1054,10 @@ def analyze():
'fx_confirmed': bool(point['fx_confirmed']) # 分型是否确认
} for point in analysis_result['klu_fx_info']]
})
# 如果生成了回放数据，添加到返回结果中
if replay_data is not None:
result['replay_data'] = replay_data
else:
print(f"只请求元素数据，跳过主周期数据处理 (elements_only={elements_only})")
web/templates/index.html
+184 -65
View File
@@ -5288,6 +5288,7 @@
// 数据回放相关变量
let replayTimer = null;
let replayData = null;
let replayStepData = null; // 存储逐步计算的回放数据
let currentReplayIndex = 0;
let totalReplaySteps = 0;
let isReplaying = false;
@@ -5373,7 +5374,7 @@
}
}
// 请求整个时间范围的数据
// 请求整个时间范围的数据，包含回放数据
$.ajax({
url: '/api/analyze',
data: {
@@ -5383,7 +5384,8 @@
element_timeframe: elementTimeframe,
start_time: replayStartTime,
end_time: replayEndTime,
elements_only: false
elements_only: false,
need_replay_data: true // 请求逐步计算的回放数据
},
success: function(data) {
// 检查是否有有效数据
@@ -5414,7 +5416,24 @@
// 初始化回放
function initReplay() {
if (!replayData || !replayData.kline_data || replayData.kline_data.length === 0) {
// 检查是否有新的回放数据结构
if (replayData && replayData.replay_data) {
console.log('使用新的逐步计算回放数据');
replayStepData = replayData.replay_data; // 存储逐步计算的数据
totalReplaySteps = Object.keys(replayStepData).length;
if (totalReplaySteps === 0) {
$('#replayStatus').text('没有可回放的数据');
$('#replayProgress').hide();
$('#startReplay').show();
$('#stopReplay').hide();
return;
}
} else if (replayData && replayData.kline_data && replayData.kline_data.length > 0) {
console.log('使用传统回放数据结构');
replayStepData = null; // 标记使用传统方式
totalReplaySteps = replayData.kline_data.length;
} else {
$('#replayStatus').text('没有可回放的数据');
$('#replayProgress').hide();
$('#startReplay').show();
@@ -5425,7 +5444,6 @@
// 设置回放变量
isReplaying = true;
currentReplayIndex = 0;
totalReplaySteps = replayData.kline_data.length;
// 更新回放状态
$('#replayStatus').text(`准备回放 (0/${totalReplaySteps})`);
@@ -5440,59 +5458,90 @@
// 准备初始回放数据
function prepareInitialReplayData() {
// 创建初始数据集，只包含第一根K线
const initialData = $.extend(true, {}, replayData);
let initialData;
// 确保第一根K线数据有效
if (!replayData.kline_data || replayData.kline_data.length === 0) {
console.error('无有效K线数据用于回放');
$('#replayStatus').text('无有效数据用于回放');
$('#replayProgress').hide();
return;
}
initialData.kline_data = [replayData.kline_data[0]];
// 确保初始K线数据的所有字段都有值
const firstKline = initialData.kline_data[0];
if (firstKline) {
// 确保K线数据的每个字段都是有效的数值
['open', 'high', 'low', 'close', 'volume'].forEach(field => {
if (firstKline[field] === null || firstKline[field] === undefined || isNaN(firstKline[field])) {
console.warn(`K线数据的${field}字段无效，设置为默认值`);
firstKline[field] = field === 'volume' ? 0 : firstKline.close || 0;
}
});
}
// 清空其他数据列表，因为还没有处理
initialData.bi_list = [];
initialData.seg_list = [];
initialData.zs_list = [];
initialData.uncompleted_zs_list = [];
initialData.element_bi_list = [];
initialData.element_seg_list = [];
initialData.element_zs_list = [];
initialData.element_uncompleted_zs_list = [];
initialData.macd_divergence = [];
initialData.klc_fx_type = [];
// 初始化MACD数据
if (initialData.macd && initialData.macd.length > 0) {
initialData.macd = [initialData.macd[0]];
// 检查是否使用新的逐步计算回放数据
if (replayStepData) {
// 使用第一步的数据作为初始数据
initialData = $.extend(true, {}, replayStepData[0]);
console.log('使用逐步计算的初始数据');
} else {
// 使用传统方式，创建初始数据集，只包含第一根K线
initialData = $.extend(true, {}, replayData);
// 确保MACD数据有效
const firstMacd = initialData.macd[0];
if (firstMacd) {
['dif', 'dea', 'macd'].forEach(field => {
if (firstMacd[field] === null || firstMacd[field] === undefined || isNaN(firstMacd[field])) {
console.warn(`MACD数据的${field}字段无效，设置为0`);
firstMacd[field] = 0;
// 确保第一根K线数据有效
if (!replayData.kline_data || replayData.kline_data.length === 0) {
console.error('无有效K线数据用于回放');
$('#replayStatus').text('无有效数据用于回放');
$('#replayProgress').hide();
return;
}
// 传统方式的数据清空逻辑
initialData.kline_data = [replayData.kline_data[0]];
// 确保初始K线数据的所有字段都有值
const firstKline = initialData.kline_data[0];
if (firstKline) {
// 确保K线数据的每个字段都是有效的数值
['open', 'high', 'low', 'close', 'volume'].forEach(field => {
if (firstKline[field] === null || firstKline[field] === undefined || isNaN(firstKline[field])) {
console.warn(`K线数据的${field}字段无效，设置为默认值`);
firstKline[field] = field === 'volume' ? 0 : firstKline.close || 0;
}
});
}
// 清空其他数据列表，因为还没有处理
initialData.bi_list = [];
initialData.seg_list = [];
initialData.zs_list = [];
initialData.uncompleted_zs_list = [];
initialData.element_bi_list = [];
initialData.element_seg_list = [];
initialData.element_zs_list = [];
initialData.element_uncompleted_zs_list = [];
initialData.trade_points = [];
initialData.element_trade_points = [];
initialData.macd_divergence = [];
initialData.klc_fx_type = [];
// 清空分型相关数据
initialData.klc_fx_info = [];
initialData.klu_fx_info = [];
initialData.element_klc_fx_info = [];
initialData.element_klu_fx_info = [];
// 初始化MACD数据
if (initialData.macd && typeof initialData.macd === 'object') {
// MACD数据是对象结构 {macd: [], signal: [], histogram: []}
if (initialData.macd.macd && initialData.macd.macd.length > 0) {
initialData.macd = {
macd: [initialData.macd.macd[0] || 0],
signal: [initialData.macd.signal[0] || 0],
histogram: [initialData.macd.histogram[0] || 0]
};
} else {
// 如果没有MACD数据，创建默认值
initialData.macd = {
macd: [0],
signal: [0],
histogram: [0]
};
}
} else {
// 如果MACD数据结构不正确，创建默认值
initialData.macd = {
macd: [0],
signal: [0],
histogram: [0]
};
}
console.log('使用传统方式生成初始数据');
}
// 更新图表，固定坐标轴范围
currentData = initialData;
@@ -5507,6 +5556,16 @@
}
}
// 输出调试信息，确认数据已正确清空
console.log('回放初始化完成，数据统计:');
console.log('K线数据:', initialData.kline_data ? initialData.kline_data.length : 0, '条');
console.log('笔数据:', initialData.bi_list ? initialData.bi_list.length : 0, '条');
console.log('线段数据:', initialData.seg_list ? initialData.seg_list.length : 0, '条');
console.log('中枢数据:', initialData.zs_list ? initialData.zs_list.length : 0, '条');
console.log('KLC分型数据:', initialData.klc_fx_info ? initialData.klc_fx_info.length : 0, '条');
console.log('KLU分型数据:', initialData.klu_fx_info ? initialData.klu_fx_info.length : 0, '条');
console.log('买卖点数据:', initialData.trade_points ? initialData.trade_points.length : 0, '条');
// 刷新图表
refreshChart(initialData);
@@ -5581,15 +5640,35 @@
currentReplayIndex++;
updateReplayStatus();
// 创建截止到当前索引的数据子集
const subsetData = createDataSubset(currentReplayIndex);
let subsetData;
// 检查是否使用新的逐步计算数据
if (replayStepData) {
// 直接使用预计算的数据
subsetData = $.extend(true, {}, replayStepData[currentReplayIndex - 1]);
console.log(`回放步骤 ${currentReplayIndex}/${totalReplaySteps} (使用预计算数据)`);
} else {
// 使用传统方式创建数据子集
subsetData = createDataSubset(currentReplayIndex);
console.log(`回放步骤 ${currentReplayIndex}/${totalReplaySteps} (传统方式)`);
}
// 输出回放进度调试信息
if (currentReplayIndex % 10 === 0 || currentReplayIndex <= 5) { // 每10步输出一次，或前5步
console.log('K线数据:', subsetData.kline_data ? subsetData.kline_data.length : 0, '条');
console.log('笔数据:', subsetData.bi_list ? subsetData.bi_list.length : 0, '条');
console.log('KLC分型:', subsetData.klc_fx_info ? subsetData.klc_fx_info.length : 0, '条');
console.log('KLU分型:', subsetData.klu_fx_info ? subsetData.klu_fx_info.length : 0, '条');
}
// 更新图表
currentData = subsetData;
refreshChart(subsetData);
// 固定Y轴范围
fixYAxisRange();
if (!replayStepData) { // 只有传统方式需要固定Y轴
fixYAxisRange();
}
// 保持最新数据可见
keepLatestDataVisible();
@@ -5699,19 +5778,32 @@
subsetData.element_uncompleted_zs_list = filterDataByTime(replayData.element_uncompleted_zs_list, currentEndTime);
}
// 过滤MACD
if (subsetData.macd && subsetData.macd.length) {
subsetData.macd = replayData.macd.slice(0, endIndex);
// 验证MACD数据
subsetData.macd.forEach((item, index) => {
['dif', 'dea', 'macd'].forEach(field => {
if (item[field] === null || item[field] === undefined || isNaN(item[field])) {
console.warn(`MACD数据[${index}]的${field}字段无效，设置为0`);
item[field] = 0;
}
// 过滤MACD数据
if (subsetData.macd && typeof subsetData.macd === 'object') {
if (replayData.macd.macd && replayData.macd.macd.length > 0) {
subsetData.macd = {
macd: replayData.macd.macd.slice(0, endIndex),
signal: replayData.macd.signal.slice(0, endIndex),
histogram: replayData.macd.histogram.slice(0, endIndex)
};
// 验证MACD数据
['macd', 'signal', 'histogram'].forEach(field => {
subsetData.macd[field].forEach((value, index) => {
if (value === null || value === undefined || isNaN(value)) {
console.warn(`MACD ${field}[${index}]数据无效，设置为0`);
subsetData.macd[field][index] = 0;
}
});
});
});
} else {
// 如果没有有效的MACD数据，创建默认数组
subsetData.macd = {
macd: new Array(endIndex).fill(0),
signal: new Array(endIndex).fill(0),
histogram: new Array(endIndex).fill(0)
};
}
}
// 过滤MACD背离
@@ -5723,6 +5815,32 @@
if (subsetData.klc_fx_type && subsetData.klc_fx_type.length) {
subsetData.klc_fx_type = filterDataByTime(replayData.klc_fx_type, currentEndTime, 'time');
}
// 过滤分型信息数据
if (subsetData.klc_fx_info && subsetData.klc_fx_info.length) {
subsetData.klc_fx_info = filterDataByTime(replayData.klc_fx_info, currentEndTime, 'time');
}
if (subsetData.klu_fx_info && subsetData.klu_fx_info.length) {
subsetData.klu_fx_info = filterDataByTime(replayData.klu_fx_info, currentEndTime, 'time');
}
if (subsetData.element_klc_fx_info && subsetData.element_klc_fx_info.length) {
subsetData.element_klc_fx_info = filterDataByTime(replayData.element_klc_fx_info, currentEndTime, 'time');
}
if (subsetData.element_klu_fx_info && subsetData.element_klu_fx_info.length) {
subsetData.element_klu_fx_info = filterDataByTime(replayData.element_klu_fx_info, currentEndTime, 'time');
}
// 过滤买卖点数据
if (subsetData.trade_points && subsetData.trade_points.length) {
subsetData.trade_points = filterDataByTime(replayData.trade_points, currentEndTime, 'time');
}
if (subsetData.element_trade_points && subsetData.element_trade_points.length) {
subsetData.element_trade_points = filterDataByTime(replayData.element_trade_points, currentEndTime, 'time');
}
} catch (e) {
console.error('过滤数据时出错:', e);
}
@@ -5777,6 +5895,7 @@
isReplaying = false;
currentReplayIndex = 0;
replayData = null;
replayStepData = null; // 清理逐步计算数据
// 更新UI
$('#replayStatus').text('');