miniProgram/subpages/data/data.js

import * as echarts from '../../ec-canvas/echarts';


// 渐变圆环
let chartCircularProgressBar;//圈圈
let chartOutOfBed;//离床
let chartBodyMovementsLine;//体动
let chartCardiacSystemLine;//心脏系统
let chartRespiratoryLine;//平均呼吸率
let chartSnoringLine;//打鼾
let chartApneaLine;//呼吸暂停
let chartTimeWaterfall;//深浅睡眠

// 圈圈>90分极好(绿色)
// > 75分，(浅绿色)良好
// 各项睡眠监测数据统计 > 60分，较差(黄色)
// 	< 60分，很差(红色)
function setChartCircularProgressBarOption(chart, data = {}) {
	var rscore_value = data?.rscore_value || 0;
	var checkList = [{
		title: "极好",
		titleColor: "#0BC3AA",
		startColor: "#0AB1C3",
		centerColor: "#0BC3AA",
		endColor: "#36E1CA",
	}, {
		title: "良好",
		titleColor: "#9C43FF",
		startColor: "#8D25FF",
		centerColor: "#A631FF",
		endColor: "#FF8FF0",
	}, {
		title: "较差",
		titleColor: "#FF8F4E",
		startColor: "#EE8B52",
		centerColor: "#FAA472",
		endColor: "#FAA472",
	}, {
		title: "很差",
		titleColor: "#FB717B",
		startColor: "#FB717B",
		centerColor: "#FB717B",
		endColor: "#FF98A0",
	}];
	var checkData = checkList[0];
	if (rscore_value >= 90 && rscore_value <= 100) {
		checkData = checkList[0];
	} else if (rscore_value >= 75 && rscore_value < 90) {
		checkData = checkList[1];
	} else if (rscore_value >= 60 && rscore_value < 75) {
		checkData = checkList[2];
	} else {
		checkData = checkList[3];
	}

	var option = {
		series: [
			{
				type: 'gauge',
				startAngle: -270,
				endAngle: 90,
				legendHoverLink: true,
				min: 0,
				max: 100,
				itemStyle: {
					color: '#58D9F9',
					shadowColor: 'rgba(0,138,255,0.45)',
					shadowBlur: 5,
					shadowOffsetX: 1,
					shadowOffsetY: 1
				},
				progress: {
					show: true,
					roundCap: true,
					width: 10,
					itemStyle: {
						// 进度条样式
						color: {
							// 自定义渐变色
							type: 'linear',
							x: 0.75,
							y: 0.75,
							x2: 0,
							y2: 0.75,
							colorStops: [
								{
									offset: 0,
									color: checkData.startColor // 0% 处的颜色
								},

								{
									offset: 0.5,
									color: checkData.centerColor // 100% 处的颜色
								},
								{
									offset: 1,
									color: checkData.endColor // 100% 处的颜色
								}
							],
							global: false // 缺省为 false
						}
					}
				},
				pointer: {
					show: false,
				},
				axisLine: {
					roundCap: true,
					lineStyle: {
						width: 10,
					}
				},
				axisTick: {
					show: false // 是否显示分隔线
				},
				splitLine: {
					show: false // 是否显示分隔线
				},
				axisLabel: {
					show: false,
				},
				title: {
					color: checkData.titleColor,
					offsetCenter: [0, '-36%'],
					lineHeight: 15,
					fontSize: 15,
				},
				detail: {
					backgroundColor: '#fff',
					width: '60%',
					lineHeight: 40,
					height: 40,
					color: '#333333',
					offsetCenter: [0, "24%"],
					valueAnimation: true,
					formatter: function (value) {
						return '{value|' + value.toFixed(0) + '}';
					},
					rich: {
						value: {
							fontSize: 30,
							fontWeight: 'bolder',
							color: checkData.titleColor
						},
					}
				},
				data: [
					{
						name: data?.rscore_desc || checkData.title || '无',
						value: data?.rscore_value || 0
					}
				]
			}
		]
	};

	chart.setOption(option, true);
}


function initChartHumidifier(canvas, width, height, dpr) {
	// this.selectComponent('#mychart-dom-bar00').init((canvas, width, height, dpr) => {
	// 获取组件的 canvas、width、height 后的回调函数
	// 在这里初始化图表
	const chart = echarts.init(canvas, null, {
		width: width,
		height: height,
		devicePixelRatio: dpr // new
	});
	canvas.setChart(chart);
	setChartCircularProgressBarOption(chart);

	// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
	chartCircularProgressBar = chart;

	// 注意这里一定要返回 chart 实例，否则会影响事件处理等
	return chart;
	// });
};

function updateChartCircularProgressBarOption(rscore_desc, rscore_value, that) {
	if (chartCircularProgressBar) {
		setChartCircularProgressBarOption(chartCircularProgressBar, { rscore_desc, rscore_value });
		
	} else {
		that.selectComponent('#mychart-dom-CircularProgressBar').init((canvas, width, height, dpr) => {
			const chart = echarts.init(canvas, null, {
				width: width,
				height: height,
				devicePixelRatio: dpr // new
			});
			canvas.setChart(chart);
			setChartCircularProgressBarOption(chart, { rscore_desc, rscore_value });

			// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
			chartCircularProgressBar = chart;

			// 注意这里一定要返回 chart 实例，否则会影响事件处理等
			return chart;
		});
	}
}
//离床

function initChartOutOfBed(canvas, width, height, dpr) {
	// this.selectComponent('#mychart-dom-bar00').init((canvas, width, height, dpr) => {
	// 获取组件的 canvas、width、height 后的回调函数
	// 在这里初始化图表
	const chart = echarts.init(canvas, null, {
		width: width,
		height: height,
		devicePixelRatio: dpr // new
	});
	canvas.setChart(chart);
	setChartOutOfBedOption(chart);

	// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
	chartOutOfBed = chart;

	// 注意这里一定要返回 chart 实例，否则会影响事件处理等
	return chart;
	// });
};



function setChartOutOfBedOption(chart, data1 = [], data2 = [],) {
	var option = option = {
		tooltip: {
			show: true,
			trigger: 'axis',
			formatter: function (param) {
				return `${param[0] && param[0].value == 1 ? '在床' : '离床'}`
			}
		},
		dataZoom: [
			{ // 第一个 dataZoom 组件
				type: 'inside',
			},
		],
		grid: {
			top: '40rpx',
			left: 0,
			right: '20rpx',
			bottom: 0,
			containLabel: true
		},
		xAxis: {
			type: 'category',
			axisLabel: {
				color: '#6C6970',// 设置 x 轴标签颜色为白色  
				fontSize: 10
			},
			boundaryGap: false,
			splitLine: {
				show: false, // 是否显示刻度线  

			},
			axisTick: {
				// 不显示Y轴刻度线  
				show: false
			},
			data: data1,
			axisLine: {
				// 不显示X轴轴线  
				show: false
			}
		},
		yAxis: {
			// Y 轴配置
			type: 'value',
			show: false
		},
		series: [{
			type: 'line',
			name: '睡眠状态',
			smooth: true,
			lineStyle: {
				width: 2,
				color: '#54C68B'
			},
			showSymbol: false,
			areaStyle: {
				opacity: 0.8,
				color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
					{
						offset: 0,
						color: '#B8EBD0'
					},
					{
						offset: 1,
						color: 'rgba(255, 255, 255, 0)'
					}
				])
			},
			data: data2,
		}]
	};

	chart.setOption(option, true);
}


function updateOutOfBed(data1, data2, startSleepTime, endSleepTime, that) {
	if (chartOutOfBed) {
		setChartOutOfBedOption(chartOutOfBed, data1, data2);
	} else {
		that.selectComponent('#chartOutOfBed-dom').init((canvas, width, height, dpr) => {
			const chart = echarts.init(canvas, null, {
				width: width,
				height: height,
				devicePixelRatio: dpr // new
			});
			canvas.setChart(chart);
			setChartOutOfBedOption(chart, data1, data2);

			// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
			chartOutOfBed = chart;

			// 注意这里一定要返回 chart 实例，否则会影响事件处理等
			return chart;
		});
	}
}


//体动

function initChartBodyMovementsLine(canvas, width, height, dpr) {
	// 在这里初始化图表
	const chart = echarts.init(canvas, null, {
		width: width,
		height: height,
		devicePixelRatio: dpr // new
	});
	canvas.setChart(chart);
	setBodyMovementsOption(chart);

	// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
	chartBodyMovementsLine = chart;

	// 注意这里一定要返回 chart 实例，否则会影响事件处理等
	return chart;
};


function setBodyMovementsOption(chart, data1 = [], data2 = [],) {
	var option = option = {
		tooltip: {
			show: true,
			trigger: 'axis',
			formatter: function (param) {
				return `${param[0] && param[0].value == 1 ? '体动' : '否'}`
			}
		},
		dataZoom: [
			{ // 第一个 dataZoom 组件
				type: 'inside',
			},
		],
		grid: {
			top: '40rpx',
			left: 0,
			right: '20rpx',
			bottom: 0,
			containLabel: true
		},
		xAxis: {
			type: 'category',
			axisLabel: {
				color: '#6C6970',// 设置 x 轴标签颜色为白色  
				fontSize: 10
			},
			boundaryGap: false,
			splitLine: {
				show: false, // 是否显示刻度线  

			},
			axisTick: {
				// 不显示Y轴刻度线  
				show: false
			},
			data: data1,
			axisLine: {
				// 不显示X轴轴线  
				show: false
			}
		},
		yAxis: {
			// Y 轴配置
			type: 'value',
			show: false
		},
		series: [{
			name: '睡眠状态',
			type: 'line',
			smooth: true,
			lineStyle: {
				width: 2,
				color: '#5582FF'
			},
			showSymbol: false,
			areaStyle: {
				opacity: 0.8,
				color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
					{
						offset: 0,
						color: 'rgba(85, 130, 255, 0.5)'
					},
					{
						offset: 1,
						color: 'rgba(149, 177, 255, 0.3)'
					}
				])
			},
			data: data2,
		}]
	};

	chart.setOption(option, true);
}

function updateBodyMovements(data1, data2, startSleepTime, endSleepTime, that) {
	if (chartBodyMovementsLine) {
		setBodyMovementsOption(chartBodyMovementsLine, data1, data2);
	} else {
		that.selectComponent('#chartBodyMovementsLine-dom').init((canvas, width, height, dpr) => {
			const chart = echarts.init(canvas, null, {
				width: width,
				height: height,
				devicePixelRatio: dpr // new
			});
			canvas.setChart(chart);
			setBodyMovementsOption(chart, data1, data2);

			// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
			chartBodyMovementsLine = chart;

			// 注意这里一定要返回 chart 实例，否则会影响事件处理等
			return chart;
		});
	}
}


//心脏系统

function initChartCardiacSystemLine(canvas, width, height, dpr) {
	// 在这里初始化图表
	const chart = echarts.init(canvas, null, {
		width: width,
		height: height,
		devicePixelRatio: dpr // new
	});
	canvas.setChart(chart);
	setCardiacSystemOption(chart);

	// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
	chartCardiacSystemLine = chart;

	// 注意这里一定要返回 chart 实例，否则会影响事件处理等
	return chart;
};


function setCardiacSystemOption(chart, data1 = [], data2 = [],) {
	var option = option = {
		tooltip: {
			show: true,
			trigger: 'axis',
			formatter: function (param) {
				return `${(param[0].value || 0) + '次'}`
			}
		},
		dataZoom: [
			{ // 第一个 dataZoom 组件
				type: 'inside',
			},
		],
		grid: {
			top: '20rpx',
			left: '20rpx',
			right: '20rpx',
			bottom: '10rpx',
			containLabel: true
		},
		xAxis: {
			type: 'category',
			axisLabel: {
				color: '#6C6970',// 设置 x 轴标签颜色为白色  
				fontSize: 10
			},
			boundaryGap: false,
			splitLine: {
				show: false, // 是否显示刻度线  

			},
			axisTick: {
				// 不显示Y轴刻度线  
				show: false
			},
			data: data1,
			axisLine: {
				// 不显示X轴轴线  
				show: false
			}
		},
		yAxis: {
			type: 'value',
			max: 100,
			min: 0,
			show: true,
			offset: 10,
			splitLine: {
				show: false
			},
			axisLabel: {
				hideOverlap: true,
				fontSize: 10,
			}
		},
		series: [{
			type: 'line',
			smooth: true,
			lineStyle: {
				width: 2,
				color: '#F47893'
			},
			showSymbol: false,
			areaStyle: {
				opacity: 0.8,
				color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
					{
						offset: 0,
						color: 'rgba(244, 120, 147, 0.5)'
					},
					{
						offset: 1,
						color: 'rgba(250, 140, 164, 0.3)'
					}
				])
			},
			data: data2,
		}]
	};

	chart.setOption(option, true);
}

function updateCardiacSystem(data1, data2, that) {
	if (chartCardiacSystemLine) {
		setCardiacSystemOption(chartCardiacSystemLine, data1, data2);
	} else {
		that.selectComponent('#chartCardiacSystemLine-dom').init((canvas, width, height, dpr) => {
			const chart = echarts.init(canvas, null, {
				width: width,
				height: height,
				devicePixelRatio: dpr // new
			});
			canvas.setChart(chart);
			setCardiacSystemOption(chart, data1, data2);

			// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
			chartBodyMovementsLine = chart;

			// 注意这里一定要返回 chart 实例，否则会影响事件处理等
			return chart;
		});
	}
}

//平均呼吸率

function initChartRespiratoryLine(canvas, width, height, dpr) {
	// 在这里初始化图表
	const chart = echarts.init(canvas, null, {
		width: width,
		height: height,
		devicePixelRatio: dpr // new
	});
	canvas.setChart(chart);
	setRespiratoryOption(chart);

	// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
	chartRespiratoryLine = chart;

	// 注意这里一定要返回 chart 实例，否则会影响事件处理等
	return chart;
};


function setRespiratoryOption(chart, data1 = [], data2 = [],) {
	var option = option = {
		tooltip: {
			show: true,
			trigger: 'axis',
			formatter: function (param) {
				return `${(param[0].value || 0) + '次'}`
			}
		},
		dataZoom: [
			{ // 第一个 dataZoom 组件
				type: 'inside',
			},
		],
		grid: {
			top: '20rpx',
			left: '20rpx',
			right: '20rpx',
			bottom: '10rpx',
			containLabel: true
		},
		xAxis: {
			type: 'category',
			axisLabel: {
				color: '#6C6970',// 设置 x 轴标签颜色为白色  
				fontSize: 10
			},
			boundaryGap: false,
			splitLine: {
				show: false, // 是否显示刻度线  

			},
			axisTick: {
				// 不显示Y轴刻度线  
				show: false
			},
			data: data1,
			axisLine: {
				// 不显示X轴轴线  
				show: false
			}
		},
		yAxis: {
			type: 'value',
			max: 24,
			min: 0,
			show: true,
			offset: 10,
			splitLine: {
				show: false
			},
			axisLabel: {
				hideOverlap: true,
				fontSize: 10,
			}
		},
		series: [{
			type: 'line',
			smooth: true,
			lineStyle: {
				width: 2,
				color: '#06A9AD'
			},
			showSymbol: false,
			areaStyle: {
				opacity: 0.8,
				color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
					{
						offset: 0,
						color: 'rgba(186, 246, 231, 1)'
					},
					{
						offset: 1,
						color: 'rgba(255, 255, 255, 0)'
					}
				])
			},
			data: data2,
		}]
	};

	chart.setOption(option, true);
}

function updateRespiratory(data1, data2, startSleepTime, endSleepTime, that) {
	if (chartRespiratoryLine) {
		setRespiratoryOption(chartRespiratoryLine, data1, data2);
	} else {
		that.selectComponent('#chartRespiratoryLine-dom').init((canvas, width, height, dpr) => {
			const chart = echarts.init(canvas, null, {
				width: width,
				height: height,
				devicePixelRatio: dpr // new
			});
			canvas.setChart(chart);
			setRespiratoryOption(chart, data1, data2);

			// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
			chartRespiratoryLine = chart;

			// 注意这里一定要返回 chart 实例，否则会影响事件处理等
			return chart;
		});
	}
}

//打鼾

function initSnoringLine(canvas, width, height, dpr) {
	// 在这里初始化图表
	const chart = echarts.init(canvas, null, {
		width: width,
		height: height,
		devicePixelRatio: dpr // new
	});
	canvas.setChart(chart);
	setSnoringOption(chart);

	// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
	chartSnoringLine = chart;

	// 注意这里一定要返回 chart 实例，否则会影响事件处理等
	return chart;
};


function setSnoringOption(chart, data1 = [], data2 = [],) {
	var option = option = {
		tooltip: {
			show: true,
			trigger: 'axis',
			formatter: function (param) {
				return `${param[0] && param[0].value == 1 ? '打鼾' : '否'}`
			}
		},
		dataZoom: [
			{ // 第一个 dataZoom 组件
				type: 'inside',
			},
		],
		grid: {
			top: '40rpx',
			left: 0,
			right: '20rpx',
			bottom: 0,
			containLabel: true
		},
		xAxis: {
			type: 'category',
			axisLabel: {
				color: '#6C6970',// 设置 x 轴标签颜色为白色  
				fontSize: 10
			},
			boundaryGap: false,
			splitLine: {
				show: false, // 是否显示刻度线  

			},
			axisTick: {
				// 不显示Y轴刻度线  
				show: false
			},
			data: data1,
			axisLine: {
				// 不显示X轴轴线  
				show: false
			}
		},
		yAxis: {
			type: 'value',
			show: false,
		},
		series: [{
			type: 'line',
			smooth: true,
			lineStyle: {
				width: 2,
				color: '#EE8B52'
			},
			showSymbol: false,
			areaStyle: {
				opacity: 0.8,
				color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
					{
						offset: 0,
						color: 'rgba(249, 211, 189, 1)'
					},
					{
						offset: 1,
						color: 'rgba(255, 255, 255, 0)'
					}
				])
			},
			data: data2,
		}]
	};

	chart.setOption(option, true);
}

function updateSnoring(data1, data2, startSleepTime, endSleepTime, that) {
	if (chartSnoringLine) {
		setSnoringOption(chartSnoringLine, data1, data2);
	} else {
		that.selectComponent('#chartSnoringLine-dom').init((canvas, width, height, dpr) => {
			const chart = echarts.init(canvas, null, {
				width: width,
				height: height,
				devicePixelRatio: dpr // new
			});
			canvas.setChart(chart);
			setSnoringOption(chart, data1, data2);

			// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
			chartSnoringLine = chart;

			// 注意这里一定要返回 chart 实例，否则会影响事件处理等
			return chart;
		});
	}
}

//呼吸暂停

function initApneaLine(canvas, width, height, dpr) {
	// 在这里初始化图表
	const chart = echarts.init(canvas, null, {
		width: width,
		height: height,
		devicePixelRatio: dpr // new
	});
	canvas.setChart(chart);
	setApneaOption(chart);

	// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
	chartApneaLine = chart;

	// 注意这里一定要返回 chart 实例，否则会影响事件处理等
	return chart;
};


function setApneaOption(chart, data1 = [], data2 = [],) {
	var option = option = {
		tooltip: {
			show: true,
			trigger: 'axis',
			formatter: function (param) {
				return `${param[0] && param[0].value == 1 ? '停止' : '否'}`
			}
		},
		dataZoom: [
			{ // 第一个 dataZoom 组件
				type: 'inside',
			},
		],
		grid: {
			top: '40rpx',
			left: 0,
			right: '20rpx',
			bottom: 0,
			containLabel: true
		},
		xAxis: {
			type: 'category',
			axisLabel: {
				color: '#6C6970',// 设置 x 轴标签颜色为白色  
				fontSize: 10
			},
			boundaryGap: false,
			splitLine: {
				show: false, // 是否显示刻度线  

			},
			axisTick: {
				// 不显示Y轴刻度线  
				show: false
			},
			data: data1,
			axisLine: {
				// 不显示X轴轴线  
				show: false
			}
		},
		yAxis: {
			type: 'value',
			show: false,
		},
		series: [{
			type: 'line',
			smooth: true,
			lineStyle: {
				width: 2,
				color: '#6086EF'
			},
			showSymbol: false,
			areaStyle: {
				opacity: 0.8,
				color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
					{
						offset: 0,
						color: 'rgba(96, 134, 239, 1)'
					},
					{
						offset: 1,
						color: 'rgba(255, 255, 255, 0)'
					}
				])
			},
			data: data2,
		}]
	};

	chart.setOption(option, true);
}

function updateApnea(data1, data2, startSleepTime, endSleepTime, that) {
	if (chartApneaLine) {
		setApneaOption(chartApneaLine, data1, data2);
	} else {
		that.selectComponent('#chartApneaLine-dom').init((canvas, width, height, dpr) => {
			const chart = echarts.init(canvas, null, {
				width: width,
				height: height,
				devicePixelRatio: dpr // new
			});
			canvas.setChart(chart);
			setApneaOption(chart, data1, data2);

			// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
			chartApneaLine = chart;

			// 注意这里一定要返回 chart 实例，否则会影响事件处理等
			return chart;
		});
	}
}


//深浅睡眠

function timestampToHHMM(timestamp) {
	let date = new Date(timestamp); // 注意：JavaScript中的Date是以毫秒为单位的
	let hours = date.getHours().toString().padStart(2, '0'); // 获取小时数，并补零
	let minutes = date.getMinutes().toString().padStart(2, '0'); // 获取分钟数，并补零
	return hours + ':' + minutes;
}

// 自定义图形
function renderItem(params, api) {
	var categoryIndex = api.value(0);
	var startX = api.coord([api.value(1), categoryIndex])[0];
	var endX = api.coord([api.value(2), categoryIndex])[0];
	var centerY = api.coord([
		api.value(1) + (api.value(2) - api.value(1)) / 2,
		categoryIndex
	])[1]; // 取中间点的y坐标
	var height = api.size([0, 1])[1] * 1;
	var width = endX - startX;

	// 创建一个矩形
	var rect = {
		x: startX,
		y: centerY - height / 2,
		r: 2,
		width: width,
		height: height
	};

	// 返回的图形对象
	return {
		type: 'rect',
		shape: rect,
		style: api.style()
	};
}

function initChartTimeWaterfall(canvas, width, height, dpr) {
	// 在这里初始化图表
	const chart = echarts.init(canvas, null, {
		width: width,
		height: height,
		devicePixelRatio: dpr // new
	});
	canvas.setChart(chart);
	setTimeWaterfallOption(chart, null, [{ "name": "清醒", "value": [2, 0, 0, 0], "itemStyle": { "normal": { "color": { "colorStops": [{ "offset": 0, "color": "#AAD09F" }, { "offset": 1, "color": "#AAD09F" }], "x": 0, "y": 0, "x2": 0, "y2": 1, "type": "linear", "global": false } } } }]);

	// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
	chartTimeWaterfall = chart;

	// 注意这里一定要返回 chart 实例，否则会影响事件处理等
	return chart;
};


function setTimeWaterfallOption(chart, startTime = new Date().getTime(), data = [], categories = ['深睡', '中睡', '浅睡', '清醒']) {
	var option =
		option = {
			tooltip: {
				show: true,
				formatter: function (params) {
					return params.marker + params.name + ': ' + params.value[3] + ' m';
				}
			},
			dataZoom: [
				{
					type: 'inside',
					filterMode: 'weakFilter'
				}
			],
			grid: {
				top: 0,
				bottom: 0,
				height: 160,
				containLabel: false
			},
			xAxis: {
				type: 'value',
				scale: true,
				splitLine: {
					show: false // 是否显示刻度线
				},
				axisLabel: {
					color: '#6C6970',// 设置 x 轴标签颜色为白色  
					fontSize: 10,
					formatter: function (val) {
						return timestampToHHMM(val || startTime);
					}
				}
			},
			yAxis: {
				show: false,
				data: categories
			},
			series: [
				{
					type: 'custom',
					renderItem: renderItem,
					itemStyle: {
						opacity: 1
					},
					encode: {
						x: [1, 2],
						y: 0
					},
					data: data
				}
			]
		};


	chart.setOption(option, true);
}

function updateTimeWaterfall(startTime = new Date().getTime(), data, that) {
	console.log("updateTimeWaterfall========>", data);
	if (chartTimeWaterfall) {
		setTimeWaterfallOption(chartTimeWaterfall, startTime, data);
	} else {
		that.selectComponent('#chartTimeWaterfall-dom').init((canvas, width, height, dpr) => {
			const chart = echarts.init(canvas, null, {
				width: width,
				height: height,
				devicePixelRatio: dpr // new
			});
			canvas.setChart(chart);
			setTimeWaterfallOption(chart, startTime, data);

			// 将图表实例绑定到 this 上，可以在其他成员函数（如 dispose）中访问
			chartTimeWaterfall = chart;

			// 注意这里一定要返回 chart 实例，否则会影响事件处理等
			return chart;
		});
	}
}

function addZero(str) {
	if (String(str).length == 1) {
		return "0" + String(str);
	} else {
		return String(str);
	}
}



const aipushApi = "https://aipush.aidsleep.cn";
const token_push = "b74fd5754c5ef24cf600c39194abdaeb";
const token_today_push = "89835e65993fee4a6a6cbbe4c271da51e5521822934e13769e61cadabaed72c3";

Page({

	/**
	 * 页面的初始数据
	 */
	data: {
		ecCircularProgressBar: {
			// lazyLoad: true, // 懒加载
			onInit: initChartHumidifier
		},
		ecOutOfBed: {
			// lazyLoad: true, // 懒加载
			onInit: initChartOutOfBed
		},
		ecBodyMovements: {
			// lazyLoad: true, // 懒加载
			onInit: initChartBodyMovementsLine
		},
		ecCardiacSystemLine: {
			// lazyLoad: true, // 懒加载
			onInit: initChartCardiacSystemLine
		},
		ecChartRespiratoryLine: {
			// lazyLoad: true, // 懒加载
			onInit: initChartRespiratoryLine
		},
		ecSnoringLine: {
			// lazyLoad: true, // 懒加载
			onInit: initSnoringLine
		},
		ecApneaLine: {
			// lazyLoad: true, // 懒加载
			onInit: initApneaLine
		},
		ecTimeWaterfall: {
			// lazyLoad: true, // 懒加载
			onInit: initChartTimeWaterfall
		},
		showAuthorizedDialog: false,
		status: "",
		isToDay: false,

		year: addZero(new Date().getFullYear()),
		month: addZero(new Date().getMonth()),
		date: addZero(new Date().getDate()),
		hours: addZero(new Date().getHours()),

		rdt_arr: [],
		rrh_arr: [],
		rhx_arr: [],
		rsnoring_arr: [],
		routbed_arr: [],
		rmove_arr: [],
		rhxstop_arr: [],
		rsleep_arr: [],

		rdt_arrNew: [],//睡眠时间轴数据集合
		rrh_arrNew: [],//睡眠心率数据集合
		rhx_arrNew: [],//睡眠呼吸数据集合
		rmove_arrNew: [],//体动状态数据集合,0-否,1-体动状态
		rsleep_arrNew: [],//睡眠状态数据集合,0-清醒,10-浅睡,20-中睡,30-深睡
		rsleep_arr_all_New: [],//睡眠状态数据集合,0-清醒,10-浅睡,20-中睡,30-深睡
		durationData: [], //睡眠时长
		sleep_duration: [], //睡眠和清醒对比
		rdeep_durationFormatA: {},
		rdeep_duration: 0,
		rlight_duration: 0,
		rin_duration: 0,
		rawake_duration: 0,

		rrs_duration: 0,//入睡时长
		routbed_count_value: 0,//离床次数
		rsleep_eff_value: '',//睡眠效率

		rdeep_durationFormat: '',
		rlight_durationFormat: '',
		rin_durationFormat: '',
		rawake_durationFormat: '',

		ravg_hx_value: 0,
		ravg_hx_desc: '',
		ravg_rh_value: 0,
		ravg_rh_desc: '',
		rscore_value: 0,
		rscore_desc: '',
		sleep_efficiency: '',//睡眠效率
		zdPoint: [],
		rsn: '',
		rdate: '',
		total_duration: 0,
		rtotal_duration: 0,
		rinbed_duration: 0,
		rgobed_time: 0,
		routbed_time: 0,
		rgobed_routbed: 0,
		sleepHourSub: 0,
		routbed_count_value: 0,
		reportDate: '',
		currentDate: '',
		currentTime: '',
		rmove_arrFrequency: 0,//体动次数
		routbed_arrFrequency: 0,//离床次数
		rsnoring_arrFrequency: 0,//打鼾次数
		rhxstop_arrFrequency: 0,//呼吸暂停次数
		sleep_durationCountA: 0,//睡眠时间
		sns: [],
		tvEntityIds: [],
		ifOneMoreTV: false,//数据推送是否有多于一台电视

		hotelcode: '',//酒店编码
		roomcode: '',//房间编码

		rdeep_duration_efficiency: '',//深睡比例
		rlight_duration_efficiency: '',//浅睡比例
		rin_duration_efficiency: '',//中睡比例
		rawake_duration_efficiency: '',//清醒比例
		isLoading: false,
		reportId: '',
		hotelname: '',
		roomname: '',
		bedname:'',
		pushReportId: '',//推送用：reportId
	},
	toWarmReminder(e) {
		const tabName = e.currentTarget.dataset.index || 1;
		wx.navigateTo({
			url: '/subpages/warmReminder/warmReminder?id=' + tabName
		})
	},

	getRsleep_arr(list) {
		if (list) {
			console.log("getRsleep_arr_list1==" + JSON.stringify(list));
			for (let i = 0; i < list.length; i++) {
				if (list[i] == '0') {
					list[i] = '清醒';
				} else if (list[i] == '10') {
					list[i] = '浅睡';
				} else if (list[i] == '20') {
					list[i] = '中睡';
				} else if (list[i] == '30') {
					list[i] = '深睡';
				} else {
					list[i] = '其他';
				}
			}
		}
		console.log("getRsleep_arr_list2==" + JSON.stringify(list));
	},
	getFrequency(list) {//获取
		if (list) {
			console.log("getRsleep_arr_list1==" + JSON.stringify(list));
			for (let i = 0; i < list.length; i++) {
				if (list[i] == '0') {
					list[i] = '清醒';
				} else if (list[i] == '10') {
					list[i] = '浅睡';
				} else if (list[i] == '20') {
					list[i] = '中睡';
				} else if (list[i] == '30') {
					list[i] = '深睡';
				} else {
					list[i] = '其他';
				}
			}
		}
		console.log("getRsleep_arr_list2==" + JSON.stringify(list));
	},
	splitN(originalArray, n) {
		if (!originalArray) return [];
		// 计算每份的大小  
		let chunkSize = Math.ceil(originalArray.length / n);

		// 分割数组并获取每份的最后一个元素  
		let lastElements = [];
		for (let i = 0; i < originalArray.length; i += chunkSize) {
			let chunk = originalArray.slice(i, i + chunkSize);
			lastElements.push(chunk[chunk.length - 1]);
		}
		// 输出每份的最后一个元素  
		console.log('lastElements=' + lastElements);
		return lastElements;
	},
	//获取次数
	getFrequency(list, o) {
		if (!list) return 0;
		let frequency = 0;
		for (let i = 0; i < list.length; i++) {
			if (list[i] == o) frequency++;
		}
		console.log('frequency=' + frequency);
		return frequency;
	},
	getTimeDiffInHours: function (startTimeStr, endTimeStr) {
		// 假设两个时间都是同一天的，这里我们使用当前日期作为基准  
		if (!startTimeStr || !endTimeStr) return null;
		const now = new Date();
		const startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), ...startTimeStr.split(':').map(Number));
		const endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), ...endTimeStr.split(':').map(Number));

		// 处理跨天的情况  
		if (endDate < startDate) {
			endDate.setDate(endDate.getDate() + 1); // 将结束时间设置为第二天的同一时间  
		}

		// 计算时间差（毫秒）  
		const diffInMs = endDate - startDate;

		// 转换为小时  
		const diffInHours = diffInMs / (1000 * 60 * 60);

		return diffInHours;
	},
	// 时间格式化
	convertTimeToHoursAndMinutes: function (timeWithText, flag = 0) {
		if (!timeWithText) return;
		// 移除'分钟'两个字  
		var minutesStr = timeWithText.replace('分钟', '');
		var minutes = parseInt(minutesStr); // 将字符串转换为整数  

		if (isNaN(minutes)) {
			// 如果转换失败，则可能是输入的不是有效的数字  
			console.error('Invalid minutes format');
			return;
		}

		var hours = Math.floor(minutes / 60); // 整除60得到小时数  
		var remainingMinutes = minutes % 60; // 取余得到剩余的分钟数  

		// 如果小时数或分钟数小于10，前面补0  
		// var formattedHours = hours < 10 ? '0' + hours : hours;  
		var formattedHours = hours;
		// var formattedMinutes = remainingMinutes < 10 ? '0' + remainingMinutes : remainingMinutes;
		var formattedMinutes = remainingMinutes;

		// 拼接小时和分钟，形成HH:mm格式 
		var formattedTime = '';
		if (flag == 1) {
			formattedTime = formattedHours + 'H ' + formattedMinutes + 'M';
		} else if (flag == 2) {
			formattedTime = formattedHours + '{units|小时}' + formattedMinutes + '{units|分钟}';
		} else {
			formattedTime = {
				formattedHours,
				formattedMinutes
			};
		}

		// 更新数据  
		// this.setData({  
		//   formattedTime: formattedTime  
		// });  
		return formattedTime;
	},
	// 组装深度睡眠数据
	calculateTheDurationOfDeepSleep() {
		var that = this;
		// var totalDuration = this.data.total_duration;
		// var timePeriod = this.data.rdt_arrNew;
		var sleepData = this.data.rsleep_arr;//睡眠状态数据集合,0-清醒,10-浅睡,20-中睡,30-深睡

		// console.log("睡眠总时长=>", totalDuration);
		// console.log("睡眠时间片段=>", timePeriod);
		// console.log("睡眠时间片段=>", timePeriod.length);
		// console.log("睡眠数据=>", sleepData);
		// console.log("睡眠数据=>", sleepData.length);
		var awakeColor = [{ offset: 0, color: '#F7E3BA' }, { offset: 1, color: '#F7E3BA' }];;
		var lightSleepColor = [{ offset: 0, color: '#AAD09F' }, { offset: 1, color: '#AAD09F' }];
		var sleptInColor = [{ offset: 0, color: '#75BDE0' }, { offset: 1, color: '#75BDE0' }];
		var deepSleepColor = [{ offset: 0, color: '#3D7299' }, { offset: 1, color: '#3D7299' }];
		// var linearGradient = new echarts.graphic.LinearGradient(
		// 	0, 0, 0, 1, // 方向从左到右  
		// 	[
		// 		{ offset: 0, color: '#FDBE25' }, // 渐变开始的颜色  
		// 		{ offset: 1, color: '#FD7778' } // 渐变结束的颜色  
		// 	]
		// );
		// var item = {
		// 	name: { name: '清醒', color: '#7b9ce1' },
		// 	value: [index, baseTime, (baseTime += duration), duration],
		// 	itemStyle: {
		// 		normal: {
		// 			color: linearGradient,
		// 		}
		// 	}
		// };

		// var sleepData = ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "10", "10", "10", "10", "10", "10", "10", "10", "10", "10", "10", "10", "10", "10", "10", "0", "0", "0", "0", "0", "0", "0", "0", "0", "10", "10", "10", "10", "10", "10", "10", "20", "20", "20", "20", "20", "20", "20", "20", "30", "30", "30", "30", "30", "30", "30", "30", "30"];//睡眠状态数据集合,0-清醒,10-浅睡,20-中睡,30-深睡

		// 状态映射  
		const statusMap = {
			"0": "清醒",
			"10": "浅睡",
			"20": "中睡",
			"30": "深睡"
		};
		// 状态映射  
		const statusColorMap = {
			"20": awakeColor,
			"0": lightSleepColor,
			"10": sleptInColor,
			"30": deepSleepColor
		};
		// 状态映射  
		const statusIndexMap = {
			"20": 3,
			"0": 2,
			"10": 1,
			"30": 0
		};
		// 初始化变量  reportDate
		// let dateString = '2024/09/14 23:20:00';
		let dateString = `${that.data.reportDate.replaceAll("-", "/")} ${that.data.rgobed_time + ":00"}`;
		let date = new Date(dateString);
		let startTime = date.getTime(); // 基准时间，这里设为午夜开始 
		console.log("时间=》", timestampToHHMM(startTime));

		let currentTime = startTime;
		let currentState = sleepData[0];
		let timePeriods = [];

		// 遍历睡眠数据数组  
		for (let i = 0; i < sleepData.length; i++) {
			// 如果当前状态与前一个状态不同，则记录前一个时间段  
			if (i > 0 && sleepData[i] !== sleepData[i - 1]) {
				// 计算前一个时间段的结束时间（注意这里不需要减去一分钟，因为 currentTime 还未递增）  
				let endTime = currentTime;
				// 计算前一个时间段的持续时间（分钟）  
				let duration = Math.floor((endTime - startTime) / (1000 * 60));
				// 记录时间段  
				if (duration > 0) {
					var linearGradient = new echarts.graphic.LinearGradient(
						0, 0, 0, 1, // 方向从左到右  
						statusColorMap[sleepData[i - 1]]
					);
					timePeriods.push({
						name: statusMap[sleepData[i - 1]],// 使用前一个状态 
						value: [statusIndexMap[sleepData[i - 1]], startTime, endTime, duration],
						itemStyle: {
							normal: {
								color: linearGradient,
							}
						},
						// startTime: new Date(startTime), // 转换为 Date 对象以便更易于阅读  
						// endTime: new Date(endTime),
						// durationMinutes: duration
					});
				}
				// 更新当前状态和开始时间  
				currentState = sleepData[i];
				startTime = currentTime;
			}
			// 递增时间（每分钟）  
			currentTime += 1000 * 60;
			// 处理最后一个时间段（如果数组不是以状态变化结束的话）  
			if (i === sleepData.length - 1) {
				let endTime = currentTime;
				let duration = Math.floor((endTime - startTime) / (1000 * 60));
				if (duration > 0) {
					var linearGradient = new echarts.graphic.LinearGradient(
						0, 0, 0, 1, // 方向从左到右  
						statusColorMap[currentState]
					);
					timePeriods.push({
						name: statusMap[currentState],// 使用前一个状态 
						value: [statusIndexMap[currentState], startTime, endTime, duration],
						itemStyle: {
							normal: {
								color: linearGradient,
							}
						},
						// startTime: new Date(startTime), // 转换为 Date 对象以便更易于阅读  
						// endTime: new Date(endTime),
						// durationMinutes: duration
					});
				}
			}
		}

		wx.nextTick(() => {
			setTimeout(() => {
				updateTimeWaterfall(startTime, timePeriods, that)
			}, 1000);
		});
		// console.log("睡眠数据最终=>", dateString);
		// console.log("睡眠数据最终=>", startTime);
		console.log("睡眠数据最终=>", JSON.stringify(timePeriods));
	},
	// 授权成功
	authorizationSuccessful() {
		console.log("授权成功");
		this.setData({ showAuthorizedDialog: false })
		this.showData();
	},
	onReady() {
		
	},
	showData() {
		let hotelcodeTemp = wx.getStorageSync("hotelEmpower");
		let roomcodeTemp = wx.getStorageSync("roomEmpower");
		// hotelcodeTemp = wx.getStorageSync('res').result.split('|')[0];
		// roomcodeTemp = wx.getStorageSync('res').result.split('|')[1];
		// 设置canvas的宽高  
		this.setData({
			hotelcode: hotelcodeTemp,
			roomcode: roomcodeTemp,
		});
		if (this.data.isToDay) {
			this.getToDayReportData();
		} else {
			this.getReportData();
		}

	},
	/**			
	 * 生命周期函数--监听页面加载
	 */
	onShow: function () {
		if (!wx.getStorageSync('hasAuth')) {
			this.setData({ showAuthorizedDialog: true })
		} else {
			this.showData();
		}
	},
	onLoad(options) {
		var that = this;
		if (options.rpids) {
			that.setData({
				reportId: options.rpids,
				isToDay: false
			})
			wx.setNavigationBarTitle({
				title: "历史睡眠报告"
			})
		} else {
			wx.setNavigationBarTitle({
				title: "今日睡眠报告"
			})
			that.setData({
				isToDay: true
			})

		}

	},
	// 新版
	getReportData() {
		const that = this;
		wx.request({
			url: `${aipushApi}` + '/getsingle',
			data: {
				"token": token_push,
				"rpids": this.data.reportId
			},
			method: 'POST',
			success(ress) {
				try {
					if (ress && ress.data) {
						console.log('ress.data-getsingle=' + JSON.stringify(ress.data.results));

						if (!ress.data.results || ress.data.results == '') {
							wx.showModal({
								title: '提示',
								content: '无数据',
								showCancel: false
							});
							return;
						}

						wx.nextTick(() => {
							setTimeout(() => {
								//初始化数据
								that.initReportData(ress.data.results);
								that.initChartCircle(ress.data.results);
								that.initOutOfBed(ress.data.results);
								that.initBodyMovements(ress.data.results);
								that.initCardiacSystem(ress.data.results);
								that.initChartRespiratory(ress.data.results);
								that.initChartSnoring(ress.data.results);
								that.initChartApnea(ress.data.results);
								that.initTimeWaterfall(ress.data.results);
							}, 1000);
						});

					} else {
						wx.showModal({
							title: '提示',
							content: '无数据',
							showCancel: false
						});
					}
				} catch (error) {
					console.error(error);
				}
			},
			fail: function (error) {
				wx.showToast({
					title: "无数据",
					icon: "error",
					mask: true,
				});
			}
		});
	},
	// 新版
	getToDayReportData() {
		const that = this;
		wx.request({
			url: `${aipushApi}` + '/getunionsingle',
			data: {
				"token": token_today_push,
				"udi": wx.getStorageSync("unionid")
			},
			method: 'POST',
			success(ress) {
				try {
					if (ress && ress.data) {
						console.log('ress.data-getunionsingle=' + JSON.stringify(ress.data));

						if (ress.data == {} || ress.data.data == []) {
							wx.showModal({
								title: '提示',
								content: '无数据',
								showCancel: false
							});
							return;
						}
						//初始化数据
						wx.nextTick(() => {
							setTimeout(() => {
								that.initReportData(ress.data.data);
								that.initChartCircle(ress.data.data);
								that.initOutOfBed(ress.data.data);
								that.initBodyMovements(ress.data.data);
								that.initCardiacSystem(ress.data.data);
								that.initChartRespiratory(ress.data.data);
								that.initChartSnoring(ress.data.data);
								that.initChartApnea(ress.data.data);
								that.initTimeWaterfall(ress.data.data);
							}, 1000);
						});
					} else {
						wx.showModal({
							title: '提示',
							content: '无数据',
							showCancel: false
						});
					}
				} catch (error) {
					console.error(error);
				}
			},
			fail: function (error) {
				wx.showToast({
					title: "无数据",
					icon: "error",
					mask: true,
				});
			}
		});
	},
	// 初始化的数据
	initReportData(ress) {
		const that = this;

		let durationDataTemp = [];
		let obj = {};
		obj.name = '深睡';
		obj.value = ress.rdeep_duration;
		durationDataTemp.push(obj);
		obj = {};
		obj.name = '浅睡';
		obj.value = ress.rlight_duration;
		durationDataTemp.push(obj);
		obj = {};
		obj.name = '中睡';
		obj.value = ress.rin_duration;
		durationDataTemp.push(obj);
		obj = {};
		obj.name = '清醒';
		obj.value = ress.rawake_duration;
		durationDataTemp.push(obj);

		let sleep_durationCount = 0;
		if (ress.rdeep_duration) {
			sleep_durationCount += parseFloat(ress.rdeep_duration)
		}
		if (ress.rlight_duration) {
			sleep_durationCount += parseFloat(ress.rlight_duration)
		}
		if (ress.rin_duration) {
			sleep_durationCount += parseFloat(ress.rin_duration)
		}

		let sleep_efficiency_temp = ress.rtotal_duration ? (Math.ceil((sleep_durationCount / ress.rtotal_duration) * 100) + '%') : '%'

		let rdeep_duration_efficiency_temp = ress.rtotal_duration ? (Math.ceil(((ress.rdeep_duration ? parseFloat(ress.rdeep_duration) : 0) / ress.rtotal_duration) * 100) + '%') : '%'
		let rlight_duration_efficiency_temp = ress.rtotal_duration ? (Math.ceil(((ress.rlight_duration ? parseFloat(ress.rlight_duration) : 0) / ress.rtotal_duration) * 100) + '%') : '%'
		let rin_duration_efficiency_temp = ress.rtotal_duration ? (Math.ceil(((ress.rin_duration ? parseFloat(ress.rin_duration) : 0) / ress.rtotal_duration) * 100) + '%') : '%'
		let rawake_duration_efficiency_temp = ress.rtotal_duration ? (Math.ceil(((ress.rawake_duration ? parseFloat(ress.rawake_duration) : 0) / ress.rtotal_duration) * 100) + '%') : '%'


		let sleep_durationTemp = [];
		let obj1 = {};
		obj1.name = '睡眠时间';
		obj1.value = Math.ceil(sleep_durationCount / 60);
		sleep_durationTemp.push(obj1);
		obj1 = {};
		obj1.name = '清醒时间';
		obj1.value = Math.ceil(parseFloat(ress.rawake_duration) / 60);
		sleep_durationTemp.push(obj1);

		let zdPointTemp = [];
		let rdt_arrTemp = [];

		let rrh_arrTemp = [];

		let rhx_arrTemp = [];


		let rmove_arrTemp = [];

		let rsleep_arrTemp = [];

		let rsleep_arr_all_Temp = [];

		if (ress.rrh_arr) {
			rdt_arrTemp = that.splitN(ress.rdt_arr.split(","), 100);
		}

		if (ress.rrh_arr) {
			rrh_arrTemp = that.splitN(ress.rrh_arr.split(","), 100);
		}
		if (ress.rhx_arr) {
			rhx_arrTemp = that.splitN(ress.rhx_arr.split(","), 100);
		}
		if (ress.rmove_arr) {
			rmove_arrTemp = that.splitN(ress.rmove_arr.split(","), 100);
		}
		if (ress.rsleep_arr) {
			rsleep_arrTemp = that.splitN(ress.rsleep_arr.split(","), 100);
		}

		if (ress.rsleep_arr) {
			rsleep_arr_all_Temp = ress.rsleep_arr.split(",");
		}



		that.setData({

			rdt_arr: ress.rdt_arr ? ress.rdt_arr.split(',') : [],
			rrh_arr: ress.rrh_arr ? ress.rrh_arr.split(',') : [],
			rhx_arr: ress.rhx_arr ? ress.rhx_arr.split(',') : [],
			rsnoring_arr: ress.rsnoring_arr ? ress.rsnoring_arr.split(',') : [],
			routbed_arr: ress.routbed_arr ? ress.routbed_arr.split(',') : [],
			rmove_arr: ress.rmove_arr ? ress.rmove_arr.split(',') : [],
			rhxstop_arr: ress.rhxstop_arr ? ress.rhxstop_arr.split(',') : [],
			rsleep_arr: ress.rsleep_arr ? ress.rsleep_arr.split(',') : [],//睡眠状态数据集合,0-清醒,10-浅睡,20-中睡,30-深睡

			rsnoring_arrFrequency: that.getFrequency(ress.rsnoring_arr ? ress.rsnoring_arr.split(',') : [], 1),
			routbed_arrFrequency: that.getFrequency(ress.routbed_arr ? ress.routbed_arr.split(',') : [], 0),
			rmove_arrFrequency: that.getFrequency(ress.rmove_arr ? ress.rmove_arr.split(',') : [], 1),
			rhxstop_arrFrequency: that.getFrequency(ress.rhxstop_arr ? ress.rhxstop_arr.split(',') : [], 1),

			rdeep_durationFormatA: that.convertTimeToHoursAndMinutes(ress.rdeep_duration),
			rlight_duration: ress.rlight_duration,
			rin_duration: ress.rin_duration,
			rawake_duration: ress.rawake_duration,
			ravg_hx_value: ress.ravg_hx_value,
			ravg_hx_desc: ress.ravg_hx_desc,
			ravg_rh_value: ress.ravg_rh_value,
			ravg_rh_desc: ress.ravg_rh_desc,
			rscore_value: ress.rscore_value,
			rscore_desc: ress.rscore_desc,

			rsn: ress.rsn,
			rdate: ress.rdate,
			total_duration: ress.rtotal_duration,
			rtotal_duration: that.convertTimeToHoursAndMinutes(ress.rtotal_duration),//睡眠总时长,单位小时分钟
			rinbed_duration: that.convertTimeToHoursAndMinutes(ress.rinbed_duration),//在床时长,单位小时分钟
			rgobed_time: ress.rgobed_time,//上床时间
			routbed_time: ress.routbed_time,//离床时间
			rgobed_routbed: ress.rgobed_time + '~' + ress.routbed_time,
			sleepHourSub: that.getTimeDiffInHours(ress.rgobed_time, ress.routbed_time),
			routbed_count_value: ress.routbed_count_value,//离床次数
			rsn: ress.rsn,
			zdPointT: zdPointTemp,
			rdt_arrNew: rdt_arrTemp,
			rrh_arrNew: rrh_arrTemp,
			rhx_arrNew: rhx_arrTemp,
			rmove_arrNew: rmove_arrTemp,
			rsleep_arrNew: rsleep_arrTemp,
			rsleep_arr_all_New: rsleep_arr_all_Temp,
			durationData: durationDataTemp,
			sleep_duration: sleep_durationTemp,
			sleep_efficiency: sleep_efficiency_temp,
			sleep_durationCountA: that.convertTimeToHoursAndMinutes(sleep_durationCount ? sleep_durationCount.toString() : '0'),
			tvEntityIds: wx.getStorageSync('tvEntityIds'),
			ifOneMoreTV: (wx.getStorageSync('tvEntityIds') && wx.getStorageSync('tvEntityIds').length > 1),
			rdeep_duration_efficiency: rdeep_duration_efficiency_temp,
			rlight_duration_efficiency: rlight_duration_efficiency_temp,
			rin_duration_efficiency: rin_duration_efficiency_temp,
			rawake_duration_efficiency: rawake_duration_efficiency_temp,
			pushReportId: ress.rdid,

			rrs_duration: that.convertTimeToHoursAndMinutes(ress.rrs_duration ? ress.rrs_duration.toString() : '0'),
			routbed_count_value: ress.routbed_count_value,
			rsleep_eff_value: ress.rsleep_eff_value,
			hotelname: ress.hotelname,
			roomname: ress.roomname,
			bedname: ress.bedname,
		});
	},
	// 香睡指数
	initChartCircle(ress) {
		var that = this;
		try {
			let rscore_descTemp = [];
			if (ress.rscore_desc) {
				rscore_descTemp = ress.rscore_desc;
			}
			let rscore_valueTemp = [];
			if (ress.rscore_value) {
				rscore_valueTemp = ress.rscore_value;
			}
			that.setData({
				rscore_desc: rscore_descTemp,
				rscore_value: rscore_valueTemp,
			});
			updateChartCircularProgressBarOption(rscore_descTemp, rscore_valueTemp, that);
		} catch (error) {
			console.error(error);
		}

	},
	// 心脏 系统
	initCardiacSystem(ress) {
		var that = this;
		try {
			let rdt_arrTemp = [];
			if (ress.rrh_arr) {
				rdt_arrTemp = that.splitN(ress.rdt_arr.split(","), 100);
			}
			if (ress.rdate) {
				that.setData({
					reportDate: ress.rdate
				});
			}
			let rrh_arrTemp = [];
			if (ress.rrh_arr) {
				rrh_arrTemp = that.splitN(ress.rrh_arr.split(","), 100);
			}
			that.setData({
				rdt_arrNew: rdt_arrTemp,
				rrh_arrNew: rrh_arrTemp,
			});
			console.log("that.data.rdt_arrNew,that.data.rrh_arrNew=" + that.data.rdt_arrNew + "," + that.data.rrh_arrNew);
			updateCardiacSystem(that.data.rdt_arrNew, that.data.rrh_arrNew, that);
		} catch (error) {
			console.error(error);
		}
	},
	initTimeWaterfall(ress) {//深浅睡眠
		var that = this;
		try {
			let rdt_arrTemp = [];
			if (ress.rrh_arr) {
				// rdt_arrTemp = that.splitN(ress.rdt_arr.split(","), 100);
				rdt_arrTemp = ress.rdt_arr.split(",");
			}
			// console.log('深浅睡眠11111=======' + JSON.stringify(rdt_arrTemp));
			let rsleep_arr_Temp = [];
			if (ress.rsleep_arr) {
				// rsleep_arr_Temp = that.splitN(ress.rsleep_arr.split(","), 100);
				rsleep_arr_Temp = ress.rsleep_arr.split(",");
			}
			// console.log('深浅睡眠222222=======' + JSON.stringify(rsleep_arr_Temp));
			that.setData({
				rdt_arrNew: rdt_arrTemp,
				rsleep_arr: rsleep_arr_Temp,
				rdeep_duration: ress.rdeep_duration,
				rlight_duration: ress.rlight_duration,
				rin_duration: ress.rin_duration,
				rawake_duration: ress.rawake_duration,
				rdeep_durationFormat: that.convertTimeToHoursAndMinutes(ress.rdeep_duration),
				rlight_durationFormat: that.convertTimeToHoursAndMinutes(ress.rlight_duration),
				rin_durationFormat: that.convertTimeToHoursAndMinutes(ress.rin_duration),
				rawake_durationFormat: that.convertTimeToHoursAndMinutes(ress.rawake_duration),
			});

			that.calculateTheDurationOfDeepSleep();
		} catch (error) {
			console.error(error);
		}
		console.log("that.data.rsleep_arr=" + that.data.rsleep_arr);

	},
	initOutOfBed(ress) {//离床次数
		var that = this;

		try {
			var routbed_arr_Temp = [];
			if (ress.routbed_arr) {
				routbed_arr_Temp = ress.routbed_arr.split(",");
			}

			that.setData({
				rdt_arr: ress.rdt_arr ? ress.rdt_arr.split(',') : [],
				routbed_arr: routbed_arr_Temp,
				rgobed_time: ress.rgobed_time,
				routbed_time: ress.routbed_time,
				rgobed_routbed: ress.rgobed_time + '~' + ress.routbed_time,
			});
			updateOutOfBed(that.data.rdt_arr, that.data.routbed_arr, that.data.rgobed_time, that.data.routbed_time, that)
		} catch (error) {
			console.error(error);
		}
		console.log("that.data.routbed_arr=" + that.data.routbed_arr);
	},
	initBodyMovements(ress) {//体动次数
		var that = this;

		try {
			var rmove_arr_Temp = [];
			if (ress.rmove_arr) {
				rmove_arr_Temp = ress.rmove_arr.split(",");
			}

			that.setData({
				rdt_arr: that.splitN(ress.rdt_arr ? ress.rdt_arr.split(',') : [], 100),
				rmove_arr: that.splitN(rmove_arr_Temp, 100),
				rgobed_time: ress.rgobed_time,
				routbed_time: ress.routbed_time,
				rgobed_routbed: ress.rgobed_time + '~' + ress.routbed_time,
			});
			updateBodyMovements(that.data.rdt_arr, that.data.rmove_arr, that.data.rgobed_time, that.data.routbed_time, that)
		} catch (error) {
			console.error(error);
		}
		console.log("c8_that.data.rmove_arr=" + that.data.rmove_arr);
	},
	initChartRespiratory(ress) {//平均呼吸率
		var that = this;

		try {
			var rhx_arr_Temp = [];
			if (ress.rhx_arr) {
				rhx_arr_Temp = ress.rhx_arr.split(",");
			}

			that.setData({
				rdt_arr: that.splitN(ress.rdt_arr ? ress.rdt_arr.split(',') : [], 100),
				rhx_arr: that.splitN(rhx_arr_Temp, 100),
				rgobed_time: ress.rgobed_time,
				routbed_time: ress.routbed_time,
				rgobed_routbed: ress.rgobed_time + '~' + ress.routbed_time,
			});
			updateRespiratory(that.data.rdt_arr, that.data.rhx_arr, that.data.rgobed_time, that.data.routbed_time, that)
		} catch (error) {
			console.error(error);
		}
		console.log("c81_that.data.ravg_hx_value=" + that.data.ravg_hx_value);
	},
	initChartSnoring(ress) {//打鼾
		var that = this;

		try {
			var rsnoring_arr_Temp = [];
			if (ress.rsnoring_arr) {
				rsnoring_arr_Temp = ress.rsnoring_arr.split(",");
			}

			that.setData({
				rdt_arr: that.splitN(ress.rdt_arr ? ress.rdt_arr.split(',') : [], 100),
				rsnoring_arr: that.splitN(rsnoring_arr_Temp, 100),
				rgobed_time: ress.rgobed_time,
				routbed_time: ress.routbed_time,
				rgobed_routbed: ress.rgobed_time + '~' + ress.routbed_time,
			});
			updateSnoring(that.data.rdt_arr, that.data.rsnoring_arr, that.data.rgobed_time, that.data.routbed_time, that)
		} catch (error) {
			console.error(error);
		}
		console.log("c8_that.data.rmove_arr=" + that.data.rmove_arr);
	},
	initChartApnea(ress) {//呼吸暂停
		var that = this;
		try {
			var rhxstop_arr_Temp = [];
			if (ress.rhxstop_arr) {
				rhxstop_arr_Temp = ress.rhxstop_arr.split(",");
			}

			that.setData({
				rdt_arr: that.splitN(ress.rdt_arr ? ress.rdt_arr.split(',') : [], 100),
				rhxstop_arr: that.splitN(rhxstop_arr_Temp, 100),
				rgobed_time: ress.rgobed_time,
				routbed_time: ress.routbed_time,
				rgobed_routbed: ress.rgobed_time + '~' + ress.routbed_time,
			});
			updateApnea(that.data.rdt_arr, that.data.rhxstop_arr, that.data.rgobed_time, that.data.routbed_time, that)
		} catch (error) {
			console.error(error);
		}
		console.log("c8_that.data.rhxstop_arr=" + that.data.rhxstop_arr);

	},
	mounted() {

	},
	/**
	 * 生命周期函数--监听页面隐藏
	 */
	onHide: function () {
	},
	/**
	 * 生命周期函数--监听页面卸载
	 */
	onUnload: function () {
	},

	/**
	 * 页面相关事件处理函数--监听用户下拉动作
	 */
	onPullDownRefresh: function () {

	},

	/**
	 * 页面上拉触底事件的处理函数
	 */
	onReachBottom: function () {

	},

	/**
	 * 用户点击右上角分享
	 */
	onShareAppMessage: function () {

	}
})