import svgObject from './svgOjbect';
import ConstParas from '@/utils/constParas.js';
import UnitHelper from '@/utils/unit.js';
import PointToleranceConfig from './PointToleranceConfig.js';
import coordinateHelper from '@/utils/coordinateHelper.js';

var LxpChartDiagram = function () {
	var m_svg;

	var m_unit = { Q: 1, H: 0, P: 1, NPSH: 0 }; //功率、流量、扬程单位集合
	var m_divChartName; //容器DIV名称
	var m_chartSize; //图表尺寸
	var m_localizationType; //语言类型
	var m_toolTipContent; //内容提示DIV容器
	var m_equipZeroH = 0;

	var m_chartType; //类型
	var m_pumpInfo; //基本信息
	var m_chartPointPara;
	var m_chartObject;
	var m_coordinatePara; //坐标

	var m_secondFlowCoord; //第二坐标参数(流量)

	var m_chartSetting; //设置
	var m_displayStyle; //显示设置

	var m_changeWrkCurveCb; //修改工作曲线的回调函数

	var m_chartDiagramPanelStyle = ConstParas.ChartDiagramPanelStyle.Two;

	var m_isDispCurveQE = true; //是否显示效率
	var m_isDispNpsh; //是否显示汽蚀
	var m_d2IsMeter = true; //公制

	var m_wrkCurveGrp; //工作曲线
	var m_designPointTolerance = [0.91, 1.09, 0.95, 1.05]; //设计点公差

	//设置颜色
	var setObjectColor = function (isMonorColor) {
		m_displayStyle.IsMonoColor = isMonorColor;
		if (m_displayStyle.IsMonoColor) {
			m_displayStyle.ColorH = '#000000';
			m_displayStyle.ColorE = '#000000';
			m_displayStyle.ColorP = '#000000';
			m_displayStyle.ColorNPSH = '#000000';
			m_displayStyle.ColorEquipment = '#000000';
			m_displayStyle.ColorEqualParaCurvesE = '#000000';
			m_displayStyle.ColorSpectrumFill = '#f2eada';
			m_displayStyle.ColorGridLine = '#cccccc';
		} else {
			m_displayStyle.ColorH = 'RoyalBlue';
			m_displayStyle.ColorE = 'DarkGreen';
			m_displayStyle.ColorP = 'MediumVioletRed';
			m_displayStyle.ColorNPSH = 'Salmon';
			m_displayStyle.ColorEquipment = '#013317';
			m_displayStyle.ColorEqualParaCurvesE = '#402db7';
			m_displayStyle.ColorSpectrumFill = 'Aquamarine';
			m_displayStyle.ColorGridLine = '#cccccc';
		}
	};

	//初始化显示设置
	var initialDispStyle = function (displayStyle, chartSetting) {
		if (displayStyle != null) {
			m_displayStyle = displayStyle;
		} else {
			m_displayStyle = {};
			m_displayStyle.IsMonoColor = false;
			m_displayStyle.IsDispSpectrum = false; //默认不显示型谱
			m_displayStyle.DesignPointDispType = 0; //设计点显示方式(eDesignPointDispType) Cross 0  LeftDownTriangle 2
			m_displayStyle.BlodRegionCurveWidth = 4;
		}
		//
		if (chartSetting != null) {
			m_displayStyle.AllowRegionDispStyle = chartSetting.AllowRegionDispStyle;
			m_displayStyle.PerferRegionDispStyle = chartSetting.PerferRegionDispStyle;
		}
		if (m_displayStyle.AxisTitlePosiAxisUpY == null) m_displayStyle.AxisTitlePosiAxisUpY = false;

		m_isDispNpsh = true;
		if (m_chartObject != null && m_chartObject.MaxWaterCurveNPSH == null) m_isDispNpsh = false;
		if (m_displayStyle.BlodRegionCurveWidth == null) m_displayStyle.BlodRegionCurveWidth = 4;

		m_displayStyle.FeatCurveSize = 10;
		m_displayStyle.EqualCurveSize = 9;
		if (m_displayStyle.IsDispCurveLabel == null) m_displayStyle.IsDispCurveLabel = true;

		m_displayStyle.isDrawWaterMark = true;
		m_displayStyle.isDispEquipmentCurve = false;
		//是否显示子刻度
		m_displayStyle.isDispMiniTick = true;
		m_displayStyle.isRotateLabelX = false;
		m_displayStyle.isAxisIntervalX = false;
		m_displayStyle.MiniTickNumber = 3;

		setObjectColor(m_displayStyle.IsMonoColor);
	};
	var initialSvg = function () {
		if (m_divChartName == null) {
			return false;
		}
		//
		var m_svgID = 'FeatCurveSvg'; //暂时不知道做啥用
		m_svg = new svgObject().init(m_divChartName, m_chartSize.TotalWidth, m_chartSize.TotalHeight, svgClick, svgMove, m_svgID);

		return true;
	};
	//初始化面板尺寸
	var initialPanelSize = function () {
		if (!initialSvg()) return;

		if (m_coordinatePara == null) return;

		if (m_chartSize == null) {
			m_chartSize = {};
			m_chartSize.TotalWidth = document.getElementById(m_divChartName).clientWidth;
			m_chartSize.TotalHeight = document.getElementById(m_divChartName).clientHeight;
		}

		if (m_chartSize.TotalHeight < 500) m_chartSize.TotalHeight = 500;

		var space_left = 70;
		var space_right = 60;
		var space_top = 30; //有第二刻度 就高一点, 没有的话 10就够了
		var space_bottom = 52;
		if (m_coordinatePara.SpaceP > 99) {
			space_left = 80;
		}
		if (m_coordinatePara.SpaceP <= 0.1) {
			space_left = 80;
		}
		if (m_localizationType >= 2) {
			space_left = 75;
			space_right = 75;
		}

		m_chartSize.SpaceTop = space_top;
		m_chartSize.SpaceRight = space_right;
		m_chartSize.SpaceBottom = space_bottom;
		m_chartSize.SpaceLeft = space_left;

		m_chartSize.DiagramTop = space_top;
		m_chartSize.DiagramLeft = space_left;
		m_chartSize.DiagramRight = m_chartSize.TotalWidth - space_right;
		m_chartSize.DiagramBottom = m_chartSize.TotalHeight - space_bottom;

		m_chartSize.DiagramWidth = m_chartSize.TotalWidth - space_left - space_right;
		m_chartSize.DiagramHeight = m_chartSize.TotalHeight - space_top - space_bottom;

		m_chartSize.SpaceGridX = m_chartSize.DiagramWidth / m_coordinatePara.GridNumberX;

		if (m_chartDiagramPanelStyle == ConstParas.ChartDiagramPanelStyle.Whole) {
			m_chartSize.UpDiagram = {};
			m_chartSize.UpDiagram.Up = space_top;
			m_chartSize.UpDiagram.Bottom = m_chartSize.TotalHeight - space_bottom;
			m_chartSize.UpDiagram.SpaceGridY = m_chartSize.DiagramHeight / m_coordinatePara.GridNumberY;
			m_chartSize.UpDiagram.GridNumberY = m_coordinatePara.GridNumberY;

			m_chartSize.DownDiagram = {}; //一样
			m_chartSize.DownDiagram.Up = space_top;
			m_chartSize.DownDiagram.Bottom = m_chartSize.TotalHeight - space_bottom;
			m_chartSize.DownDiagram.SpaceGridY = m_chartSize.DiagramHeight / m_coordinatePara.GridNumberY;
			m_chartSize.DownDiagram.GridNumberY = m_coordinatePara.GridNumberY;

			m_chartSize.PanelH = {};
			m_chartSize.PanelH.Bottom = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * m_coordinatePara.StartLineNoH;
			m_chartSize.PanelH.Up = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * m_coordinatePara.EndLineNoH;

			m_chartSize.PanelE = {};
			m_chartSize.PanelE.Bottom = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * m_coordinatePara.StartLineNoE;
			m_chartSize.PanelE.Up = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * m_coordinatePara.EndLineNoE;

			m_chartSize.PanelP = {};
			m_chartSize.PanelP.Bottom = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * m_coordinatePara.StartLineNoP;
			m_chartSize.PanelP.Up = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * m_coordinatePara.EndLineNoP;

			m_chartSize.PanelNPSH = {};
			m_chartSize.PanelNPSH.Bottom =
				m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * m_coordinatePara.StartLineNoNPSH;
			m_chartSize.PanelNPSH.Up = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * m_coordinatePara.EndLineNoNPSH;

			//console.log(m_chartSize)
			//把间隙弄小点
			var areaAttr = {
				x: space_left,
				y: space_top,
				width: m_chartSize.DiagramWidth,
				height: m_chartSize.DiagramHeight,
			};

			var areaStyle = {
				'stroke-width': '1px',
				stroke: '#cccccc',
				fill: '#ffffff',
				'fill-opacity': '0.5',
				'zIndex:': 5,
			};

			//
			m_svg.createArea(areaAttr, areaStyle);
		} else {
			var panel_space = 35;
			m_chartSize.PanelSpace = panel_space;

			var grid_num_h = m_coordinatePara.EndLineNoH - m_coordinatePara.StartLineNoH;
			var grid_num_e = m_coordinatePara.EndLineNoE - m_coordinatePara.StartLineNoE;

			var grid_num_up = Math.max(grid_num_h, grid_num_e);
			grid_num_up = grid_num_up + 2; //多两条
			if (!m_isDispCurveQE) {
				grid_num_up = m_coordinatePara.EndLineNoH - m_coordinatePara.StartLineNoH;
			}
			//console.log(grid_num_up, grid_num_h, grid_num_e) ;
			var grid_num_NPSH = m_coordinatePara.EndLineNoNPSH - m_coordinatePara.StartLineNoNPSH;
			var grid_num_p = m_coordinatePara.EndLineNoP - m_coordinatePara.StartLineNoP;
			var grid_num_down = Math.max(grid_num_NPSH, grid_num_p) + 1;

			m_chartSize.UpDiagram = {};
			m_chartSize.UpDiagram.Up = space_top;
			m_chartSize.UpDiagram.SpaceGridY = (m_chartSize.DiagramHeight - panel_space) / (grid_num_up + grid_num_down);
			m_chartSize.UpDiagram.Bottom = space_top + grid_num_up * m_chartSize.UpDiagram.SpaceGridY;
			m_chartSize.UpDiagram.GridNumberY = grid_num_up;

			m_chartSize.DownDiagram = {};
			m_chartSize.DownDiagram.Up = m_chartSize.UpDiagram.Bottom + panel_space;
			m_chartSize.DownDiagram.SpaceGridY = (m_chartSize.DiagramHeight - panel_space) / (grid_num_up + grid_num_down);
			m_chartSize.DownDiagram.Bottom = m_chartSize.TotalHeight - space_bottom;
			m_chartSize.DownDiagram.GridNumberY = grid_num_down;

			m_chartSize.PanelH = {};
			m_chartSize.PanelH.Bottom = m_chartSize.UpDiagram.Up + m_chartSize.UpDiagram.SpaceGridY * grid_num_h;
			m_chartSize.PanelH.Up = m_chartSize.UpDiagram.Up;

			m_chartSize.PanelE = {};
			m_chartSize.PanelE.Bottom = m_chartSize.UpDiagram.Bottom;
			m_chartSize.PanelE.Up = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * grid_num_e;

			m_chartSize.PanelP = {};
			m_chartSize.PanelP.Up = m_chartSize.DownDiagram.Up;
			m_chartSize.PanelP.Bottom = m_chartSize.DownDiagram.Up + m_chartSize.DownDiagram.SpaceGridY * grid_num_p;

			m_chartSize.PanelNPSH = {};
			m_chartSize.PanelNPSH.Bottom = m_chartSize.DownDiagram.Bottom;
			m_chartSize.PanelNPSH.Up = m_chartSize.DownDiagram.Bottom - m_chartSize.DownDiagram.SpaceGridY * grid_num_NPSH;

			//console.log(m_chartSize)
		}
	};
	//第二坐标
	var calcSecondFlowCoordParas = function () {
		m_secondFlowCoord = {};
		if (m_coordinatePara.SecondUnitQ != null) {
			//index页面会设置
			m_secondFlowCoord.Unit = m_coordinatePara.SecondUnitQ;
		} else {
			if (m_unit.Q == 0) m_secondFlowCoord.Unit = 1;
			else m_secondFlowCoord.Unit = 0;
		}

		m_secondFlowCoord.Labels = [];
		// console.log(m_coordinatePara)

		var spaceQ2 = coordinateHelper.GetOptimalSpace(UnitHelper.ConvertQ_fromM3H(m_secondFlowCoord.Unit, m_coordinatePara.SpaceQ * 1.1));
		var min_q = UnitHelper.ConvertQ_fromM3H(m_secondFlowCoord.Unit, m_coordinatePara.DispMinQ);
		var dispMinQ2 = Math.floor(min_q / spaceQ2) * spaceQ2;

		for (var i = 0; i < m_coordinatePara.GridNumberX; i++) {
			var q = dispMinQ2 + spaceQ2 * i;
			var disQ = UnitHelper.valueFormat(UnitHelper.getDispValueQ(q));
			var m3h = UnitHelper.ConvertQ_toM3H(m_secondFlowCoord.Unit, q);

			if (m3h < m_coordinatePara.DispMaxQ * 0.95) {
				//console.log(i, disQ, m3h)
				m_secondFlowCoord.Labels.push({ DispValue: disQ, M3H: m3h });
			} else {
				break;
			}
		}
		//console.log(m_secondFlowCoord)
	};
	//
	var getSvgObjByName = function (objName) {
		return m_svg.getPathByName(objName);
	};
	//代码临时注释
	var svgClick = function (e) {};
	//
	var svgMove = function (e) {
		//alert("svgMove");
	};

	//翻译
	var getTranslateString = function (cn) {
		if (m_localizationType == 0) return cn;
		if (m_localizationType == 6) {
			//ko
			if (cn == '流量') return '유량';
			else if (cn == '压力') return '압력받다';
			else if (cn == '扬程') return '양정';
			else if (cn == '效率') return '효율성';
			else if (cn == '功率') return '파워';
		}
		if (m_localizationType == 8) {
			//es
			if (cn == '流量') return 'Caudal';
			else if (cn == '压力') return 'Presión';
			else if (cn == '扬程') return 'Cabezal';
			else if (cn == '效率') return 'Eficiencia';
			else if (cn == '功率') return 'Potencia';
		}
		if (m_localizationType == 5) {
			//ru
			if (cn == '流量') return 'поток';
			else if (cn == '压力') return 'давление';
			else if (cn == '扬程') return 'напор';
			else if (cn == '效率') return 'эффективность';
			else if (cn == '功率') return 'мощность ';
		}
		if (cn == '流量') return 'Flow';
		else if (cn == '压力') return 'Press';
		else if (cn == '扬程') return 'Head';
		else if (cn == '效率') return 'Eta';
		else if (cn == '功率') return 'Power';
		else if (cn == '汽蚀') return 'NPSHr';
		else return cn;
	};
	//绘制x坐标(含标题):底部
	var createFlowAxisBottom = function () {
		var title_space = 44;
		var bottom_posi = m_chartSize.DownDiagram.Bottom;

		if (m_coordinatePara == null) {
			return;
		}

		//刻度线
		var attrAxisTickX = {
			stroke: 'black',
			'stroke-width': '1',
			fill: 'none',
			zIndex: 10,
		};

		//刻度长度
		var minTickLength = 4;
		var tickLength = 6;

		//刻度文字
		var styleAxisLabelX = 'font-size:11px;fill-opacity:1;fill:black;'; //font-weight:bold

		//标题文字
		var styleAxisTitleX = 'font-size:14px;fill-opacity:1;fill:black;font-weight:bold;';

		//
		for (var i = 0; i <= m_coordinatePara.GridNumberX; i++) {
			let q = m_coordinatePara.MinQ + i * m_coordinatePara.SpaceQ;
			//console.log(q)
			var content = UnitHelper.valueFormat(UnitHelper.getDispValueQ(UnitHelper.ConvertQ_fromM3H(m_unit.Q, q)));
			if (i == m_coordinatePara.GridNumberX) {
				let unit_name = UnitHelper.GetUnitNameQ(m_unit.Q);
				content = 'Q [' + unit_name + ']';
			}
			var posiX_grid = m_chartSize.DiagramLeft + m_chartSize.SpaceGridX * i;
			//刻度线
			var valueMain = [];
			valueMain.push('M ', posiX_grid, ' ', bottom_posi, ' L ', posiX_grid, ' ', bottom_posi + tickLength);
			m_svg.createPath(null, valueMain.join(''), attrAxisTickX, null); //"TickLineX" + i

			//文字 m_displayStyle.isAxisIntervalX
			var label_y = bottom_posi + tickLength + 15;
			if (m_displayStyle.isRotateLabelX) label_y = label_y + 1;
			var attrAxisLabelX = {
				opacity: 1,
				x: posiX_grid,
				y: label_y,
				'text-anchor': 'middle',
			};
			var transform = null;
			if (m_displayStyle.isRotateLabelX) transform = 'rotate(45 ' + posiX_grid + ',' + label_y + ')';
			if (m_displayStyle.isAxisIntervalX) {
				if (i % 2 == 0) m_svg.createText(attrAxisLabelX, styleAxisLabelX, content, 10, null, transform);
			} else {
				m_svg.createText(attrAxisLabelX, styleAxisLabelX, content, 10, null, transform);
			}

			//子刻度线
			if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.GridNumberX) {
				for (var j = 0; j <= m_displayStyle.MiniTickNumber; j++) {
					var pois_minTick = posiX_grid + (m_chartSize.SpaceGridX * j) / (m_displayStyle.MiniTickNumber + 1);
					var valueMini = [];
					valueMini.push('M ', pois_minTick, ' ', bottom_posi, ' L ', pois_minTick, ' ', bottom_posi + minTickLength);
					m_svg.createPath(null, valueMini.join(''), attrAxisTickX, null);
				}
			}
		}

		var attrAxisTitleX = {
			opacity: 1,
			x: (m_chartSize.DiagramLeft + m_chartSize.DiagramRight) / 2,
			y: bottom_posi + title_space,
			'text-anchor': 'middle',
		};
		if (m_displayStyle.isRotateLabelX) attrAxisTitleX.y = attrAxisTitleX.y + 12;

		let unit_name = UnitHelper.GetUnitNameQ(m_unit.Q);
		m_svg.createText(attrAxisTitleX, styleAxisTitleX, getTranslateString('流量') + ' (' + unit_name + ')');
	};
	//绘制x坐标(含标题):上面第二坐标
	var createFlowAxisSecondUp = function () {
		if (m_secondFlowCoord == null || m_secondFlowCoord.Labels == null) {
			return;
		}

		//刻度线
		var attrAxisTickX = {
			stroke: 'black',
			'stroke-width': '1',
			fill: 'none',
			zIndex: 10,
		};

		//刻度长度
		var minTickLength = 4;
		var tickLength = 6;

		//刻度文字
		var styleAxisLabelX = 'font-size:11px;fill-opacity:1;fill:black;'; //font-weight:bold
		var bottom_posi = m_chartSize.SpaceTop;

		//
		var posiX_start = getPixelValueQ(m_secondFlowCoord.Labels[0].M3H);
		var spaix_space = getPixelValueQ(m_secondFlowCoord.Labels[1].M3H) - getPixelValueQ(m_secondFlowCoord.Labels[0].M3H);
		var iLabelCount = m_secondFlowCoord.Labels.length;

		//
		for (var i = 0; i <= 2; i++) {
			var last_posi = posiX_start + iLabelCount * spaix_space;
			if (last_posi < m_chartSize.DiagramRight - spaix_space * 1.1) {
				var last = m_secondFlowCoord.Labels[iLabelCount - 1];
				var lastlast = m_secondFlowCoord.Labels[iLabelCount - 2];
				m_secondFlowCoord.Labels.push({
					DispValue: last.DispValue + (last.DispValue - lastlast.DispValue),
					M3H: last.M3H + (last.M3H - lastlast.M3H),
				});

				iLabelCount++;
			}
		}

		for (let i = 0; i <= iLabelCount; i++) {
			var content = '';
			var posiX_grid = 0;
			if (i == iLabelCount) {
				let unit_name = UnitHelper.GetUnitNameQ(m_secondFlowCoord.Unit);
				content = 'Q [' + unit_name + ']';
				posiX_grid = m_chartSize.DiagramRight;
			} else {
				let q_disp = m_secondFlowCoord.Labels[i].DispValue;
				//let q_m3h = m_secondFlowCoord.Labels[i].M3H;

				content = UnitHelper.valueFormat(UnitHelper.getDispValueQ(q_disp));
				posiX_grid = posiX_start + i * spaix_space;
				if (posiX_grid < m_chartSize.DiagramLeft) {
					continue;
				}

				//刻度线
				var valueMain = [];
				valueMain.push('M ', posiX_grid, ' ', bottom_posi, ' L ', posiX_grid, ' ', bottom_posi - tickLength);
				m_svg.createPath(null, valueMain.join(''), attrAxisTickX, null); //"TickLineX" + i
			}

			//文字 m_displayStyle.isAxisIntervalX
			var label_y = bottom_posi - tickLength - 7;

			var attrAxisLabelX = {
				opacity: 1,
				x: posiX_grid,
				y: label_y,
				'text-anchor': 'middle',
			};
			var transform = null;

			m_svg.createText(attrAxisLabelX, styleAxisLabelX, content, 10, null, transform);

			//子刻度线
			var sub_spaix_space = spaix_space / m_displayStyle.MiniTickNumber;
			if (i < iLabelCount - 1) {
				for (var j = 1; j < m_displayStyle.MiniTickNumber; j++) {
					var pois_minTick = posiX_grid + sub_spaix_space * j;
					if (pois_minTick < m_chartSize.DiagramLeft) {
						continue;
					}

					var valueMini = [];
					valueMini.push('M ', pois_minTick, ' ', bottom_posi, ' L ', pois_minTick, ' ', bottom_posi - minTickLength);
					m_svg.createPath(null, valueMini.join(''), attrAxisTickX, null);
				}
			} else {
				for (let j = 1; j < 10; j++) {
					let pois_minTick = posiX_grid + sub_spaix_space * j;
					if (pois_minTick > m_chartSize.DiagramRight - sub_spaix_space) {
						break;
					}

					let valueMini = [];
					valueMini.push('M ', pois_minTick, ' ', bottom_posi, ' L ', pois_minTick, ' ', bottom_posi - minTickLength);
					m_svg.createPath(null, valueMini.join(''), attrAxisTickX, null);
				}
			}
		}
	};

	//绘制x坐标(含标题):中间
	var createFlowAxisMiddle = function () {
		var bottom_posi = m_chartSize.UpDiagram.Bottom;
		if (m_coordinatePara == null) {
			return;
		}

		//刻度线
		var attrAxisTickX = {
			stroke: 'black',
			'stroke-width': '1',
			fill: 'none',
			zIndex: 10,
		};

		//刻度长度
		var minTickLength = 4;
		var tickLength = 6;

		//刻度文字
		var styleAxisLabelX = 'font-size:11px;fill-opacity:1;fill:black;'; //font-weight:bold

		//
		for (var i = 0; i <= m_coordinatePara.GridNumberX; i++) {
			//少一个刻度

			let q = m_coordinatePara.MinQ + i * m_coordinatePara.SpaceQ;
			//console.log(q)
			var content = UnitHelper.valueFormat(UnitHelper.getDispValueQ(UnitHelper.ConvertQ_fromM3H(m_unit.Q, q)));
			if (i == m_coordinatePara.GridNumberX) {
				let unit_name = UnitHelper.GetUnitNameQ(m_unit.Q);
				content = 'Q [' + unit_name + ']';
			}
			var posiX_grid = m_chartSize.DiagramLeft + m_chartSize.SpaceGridX * i;
			//刻度线
			var valueMain = [];
			valueMain.push('M ', posiX_grid, ' ', bottom_posi, ' L ', posiX_grid, ' ', bottom_posi + tickLength);
			m_svg.createPath(null, valueMain.join(''), attrAxisTickX, null); //"TickLineX" + i

			//文字 m_displayStyle.isAxisIntervalX
			var label_y = bottom_posi + tickLength + 15;
			if (m_displayStyle.isRotateLabelX) label_y = label_y + 1;
			var attrAxisLabelX = {
				opacity: 1,
				x: posiX_grid,
				y: label_y,
				'text-anchor': 'middle',
			};
			var transform = null;
			if (m_displayStyle.isRotateLabelX) transform = 'rotate(45 ' + posiX_grid + ',' + label_y + ')';
			if (m_displayStyle.isAxisIntervalX) {
				if (i % 2 == 0) m_svg.createText(attrAxisLabelX, styleAxisLabelX, content, 10, null, transform);
			} else {
				m_svg.createText(attrAxisLabelX, styleAxisLabelX, content, 10, null, transform);
			}

			//子刻度线
			if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.GridNumberX) {
				for (var j = 0; j <= m_displayStyle.MiniTickNumber; j++) {
					var pois_minTick = posiX_grid + (m_chartSize.SpaceGridX * j) / (m_displayStyle.MiniTickNumber + 1);
					var valueMini = [];
					valueMini.push('M ', pois_minTick, ' ', bottom_posi, ' L ', pois_minTick, ' ', bottom_posi + minTickLength);
					m_svg.createPath(null, valueMini.join(''), attrAxisTickX, null);
				}
			}
		}

		/*  
                //标题文字
        var styleAxisTitleX = "font-size:14px;fill-opacity:1;fill:black;font-weight:bold;";
        不绘制标题
          var attrAxisTitleX = {
                "opacity": 1,
                "x": (m_chartSize.DiagramLeft + m_chartSize.DiagramRight) / 2,
                "y": bottom_posi + title_space,
                "text-anchor": "middle"
            };
            if (m_displayStyle.isRotateLabelX)
                attrAxisTitleX.y = attrAxisTitleX.y + 12;

            let unit_name = UnitHelper.GetUnitNameQ(m_unit.Q);
            m_svg.createText(attrAxisTitleX, styleAxisTitleX, getTranslateString("流量") + " (" + unit_name + ")");
        */
	};
	//绘制Y坐标(含标题)
	var createYAxis_Whole = function () {
		if (m_coordinatePara == null) {
			return;
		}

		//刻度长度
		var minTickLength = 3;
		var tickLength = 6;

		//扬程
		if (m_coordinatePara.EndLineNoH > m_coordinatePara.StartLineNoH) {
			//刻度线
			var attrAxisTickH = {
				stroke: m_displayStyle.ColorH,
				'stroke-width': '1',
				fill: 'none',
			};

			//刻度文字
			var styleAxisLabelH = 'font-size:11px; fill-opacity:1; fill:' + m_displayStyle.ColorH + ';';
			//标签
			var styleAxisTitleH = 'font-size:14px; ;fill-opacity:1; font-weight:bold; fill:' + m_displayStyle.ColorH + ';';

			let unit_h_name = UnitHelper.GetUnitNameH(m_unit.H);

			//标签
			var attrAxisTitleH = {
				opacity: 1,
				x: m_chartSize.DiagramLeft - 52,
				y:
					m_chartSize.UpDiagram.Bottom -
					m_chartSize.UpDiagram.SpaceGridY *
						((m_coordinatePara.EndLineNoH - m_coordinatePara.StartLineNoH) / 2 + m_coordinatePara.StartLineNoH) -
					10,
				'text-anchor': 'middle',
			};
			if (m_localizationType == 0) {
				//中文
				if (m_unit.H == UnitHelper.H.MPa || m_unit.H == UnitHelper.H.KPa) {
					attrAxisTitleH.y = attrAxisTitleH.y - 5;
					m_svg.createText(attrAxisTitleH, styleAxisTitleH, '压');
					attrAxisTitleH.y = attrAxisTitleH.y + 15;
					m_svg.createText(attrAxisTitleH, styleAxisTitleH, '力');

					attrAxisTitleH.x = attrAxisTitleH.x + 3;
					attrAxisTitleH.y = attrAxisTitleH.y + 21;
					var transform = 'rotate(-90 ' + attrAxisTitleH.x + ',' + attrAxisTitleH.y + ')';
					if (m_unit.H == UnitHelper.H.MPa) m_svg.createText(attrAxisTitleH, styleAxisTitleH, '(MPa)', 10, null, transform);
					else if (m_unit.H == UnitHelper.H.MPa) m_svg.createText(attrAxisTitleH, styleAxisTitleH, '(kPa)', 10, null, transform);
				} else {
					attrAxisTitleH.y = attrAxisTitleH.y - 5;
					m_svg.createText(attrAxisTitleH, styleAxisTitleH, '扬');
					attrAxisTitleH.y = attrAxisTitleH.y + 15;
					m_svg.createText(attrAxisTitleH, styleAxisTitleH, '程');

					if (m_unit.H == 0) {
						attrAxisTitleH.x = attrAxisTitleH.x + 3;
						attrAxisTitleH.y = attrAxisTitleH.y + 21;
						let transform = 'rotate(-90 ' + attrAxisTitleH.x + ',' + attrAxisTitleH.y + ')'; //不用多出空格否则全屏会有问题expandChartFullScreen
						m_svg.createText(attrAxisTitleH, styleAxisTitleH, '(' + unit_h_name + ')', 10, null, transform);
					}
				}
			} else {
				var content = 'Head (' + unit_h_name + ')';
				if (m_unit.H == UnitHelper.H.MPa) {
					content = 'Press (MPa)';
				}
				if (m_unit.H == UnitHelper.H.KPa) {
					content = 'Press (KPa)';
				}
				let transform = 'rotate(-90 ' + attrAxisTitleH.x + ',' + attrAxisTitleH.y + ')'; //不用多出空格否则全屏会有问题expandChartFullScreen
				m_svg.createText(attrAxisTitleH, styleAxisTitleH, content, 10, null, transform);
			}

			//
			for (var i = m_coordinatePara.StartLineNoH; i <= m_coordinatePara.EndLineNoH; i++) {
				var posiY_grid = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * i;

				//主刻度
				var valueMain = [];
				valueMain.push('M ', m_chartSize.DiagramLeft, ' ', posiY_grid, ' L ', m_chartSize.DiagramLeft - tickLength, ' ', posiY_grid);
				m_svg.createPath(null, valueMain.join(''), attrAxisTickH, null);

				//文字
				var attrAxisLabelH = {
					opacity: 1,
					x: m_chartSize.DiagramLeft - 10,
					y: posiY_grid + 5,
					'text-anchor': 'end',
				};
				let content = UnitHelper.valueFormat(m_coordinatePara.MinH + i * m_coordinatePara.SpaceH);
				m_svg.createText(attrAxisLabelH, styleAxisLabelH, content);

				//子刻度线
				if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.EndLineNoH) {
					for (var j = 1; j <= m_displayStyle.MiniTickNumber; j++) {
						var pois_minTick = posiY_grid - (m_chartSize.UpDiagram.SpaceGridY * j) / (m_displayStyle.MiniTickNumber + 1);
						var valueMini = [];
						valueMini.push(
							'M ',
							m_chartSize.DiagramLeft,
							' ',
							pois_minTick,
							' L ',
							m_chartSize.DiagramLeft - minTickLength,
							' ',
							pois_minTick
						);
						m_svg.createPath(null, valueMini.join(''), attrAxisTickH, null);
					}
				}
			}
		}

		//效率
		if (m_coordinatePara.EndLineNoE > m_coordinatePara.StartLineNoE && m_isDispCurveQE) {
			//刻度线
			var attrAxisTickE = {
				stroke: m_displayStyle.ColorE,
				'stroke-width': '1',
				fill: 'none',
			};

			//刻度文字
			var styleAxisLabelE = 'font-size:11px; fill-opacity:1; fill:' + m_displayStyle.ColorE + ';';
			//标签
			var styleAxisTitleE = 'font-size:14px; ;fill-opacity:1; font-weight:bold; fill:' + m_displayStyle.ColorE + ';';
			//
			var attrAxisTitleE = {
				opacity: 1,
				x: m_chartSize.DiagramRight + 44,
				y:
					m_chartSize.UpDiagram.Bottom -
					m_chartSize.UpDiagram.SpaceGridY *
						((m_coordinatePara.EndLineNoE - m_coordinatePara.StartLineNoE) / 2 + m_coordinatePara.StartLineNoE) -
					10,
				'text-anchor': 'middle',
			};

			//标签
			if (m_localizationType == 0) {
				//中文
				attrAxisTitleE.y = attrAxisTitleE.y - 5;
				m_svg.createText(attrAxisTitleE, styleAxisTitleE, '效');
				attrAxisTitleE.y = attrAxisTitleE.y + 15;
				m_svg.createText(attrAxisTitleE, styleAxisTitleE, '率');

				attrAxisTitleE.x = attrAxisTitleE.x + 6;
				attrAxisTitleE.y = attrAxisTitleE.y + 24;
				let transform = 'rotate(-90 ' + attrAxisTitleE.x + ',' + attrAxisTitleE.y + ')';
				m_svg.createText(attrAxisTitleE, styleAxisTitleE, '(%)', 10, null, transform);
			} else {
				attrAxisTitleE.x = attrAxisTitleE.x + 6;
				attrAxisTitleE.y = attrAxisTitleE.y + 24;
				let transform = 'rotate(-90 ' + attrAxisTitleE.x + ',' + attrAxisTitleE.y + ')';
				m_svg.createText(attrAxisTitleE, styleAxisTitleE, 'Eta (%)', 10, null, transform);
			}

			//
			for (let i = m_coordinatePara.StartLineNoE; i <= m_coordinatePara.EndLineNoE; i++) {
				let content = m_coordinatePara.MinE + i * m_coordinatePara.SpaceE;
				let posiY_grid = m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * i;
				//主刻度
				let valueMain = [];
				valueMain.push('M ', m_chartSize.DiagramRight, ' ', posiY_grid, ' L ', m_chartSize.DiagramRight + tickLength, ' ', posiY_grid);
				m_svg.createPath(null, valueMain.join(''), attrAxisTickE, null);

				//文字
				var attrAxisLabelE = {
					opacity: 1,
					x: m_chartSize.DiagramRight + 10,
					y: posiY_grid + 5,
				};
				m_svg.createText(attrAxisLabelE, styleAxisLabelE, content);

				//子刻度线
				if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.EndLineNoE) {
					for (let j = 0; j < m_displayStyle.MiniTickNumber; j++) {
						let pois_minTick = posiY_grid - (m_chartSize.UpDiagram.SpaceGridY * j) / m_displayStyle.MiniTickNumber;
						let valueMini = [];
						valueMini.push(
							'M ',
							m_chartSize.DiagramRight,
							' ',
							pois_minTick,
							' L ',
							m_chartSize.DiagramRight + minTickLength,
							' ',
							pois_minTick
						);
						m_svg.createPath(null, valueMini.join(''), attrAxisTickE, null);
					}
				}
			}
		}

		//功率
		if (m_coordinatePara.EndLineNoP > m_coordinatePara.StartLineNoP) {
			//刻度线
			var attrAxisTickP = {
				stroke: m_displayStyle.ColorP,
				'stroke-width': '1',
				fill: 'none',
			};

			let unit_p_name = UnitHelper.GetUnitNameP(m_unit.P);

			//刻度文字
			var styleAxisLabelP = 'font-size:11px; fill-opacity:1; fill:' + m_displayStyle.ColorP + ';';
			//标签
			var styleAxisTitleP = 'font-size:14px; ;fill-opacity:1; font-weight:bold; fill:' + m_displayStyle.ColorP + ';';

			//标签
			if (m_localizationType == 0) {
				//中文
				var attrAxisTitleP = {
					opacity: 1,
					x: m_chartSize.DiagramLeft - 52,
					y:
						m_chartSize.DownDiagram.Bottom -
						m_chartSize.DownDiagram.SpaceGridY *
							((m_coordinatePara.EndLineNoP - m_coordinatePara.StartLineNoP) / 2 + m_coordinatePara.StartLineNoP),
					'text-anchor': 'middle',
				};
				if (m_coordinatePara.SpaceP <= 0.1) {
					attrAxisTitleP.x = attrAxisTitleP.x - 5;
				}
				attrAxisTitleP.y = attrAxisTitleP.y - 5;
				m_svg.createText(attrAxisTitleP, styleAxisTitleP, '功');
				attrAxisTitleP.y = attrAxisTitleP.y + 15;
				m_svg.createText(attrAxisTitleP, styleAxisTitleP, '率');

				attrAxisTitleP.x = attrAxisTitleP.x + 2;
				attrAxisTitleP.y = attrAxisTitleP.y + 25;
				let transform = 'rotate(-90 ' + attrAxisTitleP.x + ',' + attrAxisTitleP.y + ')';
				m_svg.createText(attrAxisTitleP, styleAxisTitleP, '(' + unit_p_name + ')', 10, null, transform);
			} else {
				let attrAxisTitleP = {
					opacity: 1,
					x: m_chartSize.DiagramLeft - 60,
					y:
						m_chartSize.DownDiagram.Bottom -
						m_chartSize.DownDiagram.SpaceGridY *
							((m_coordinatePara.EndLineNoP - m_coordinatePara.StartLineNoP) / 2 + m_coordinatePara.StartLineNoP) -
						10,
					'text-anchor': 'middle',
				};
				if (m_coordinatePara.SpaceP <= 0.1) {
					attrAxisTitleP.x = attrAxisTitleP.x - 5;
				}
				attrAxisTitleP.x = attrAxisTitleP.x + 13;
				attrAxisTitleP.y = attrAxisTitleP.y + 25;
				let transform = 'rotate(-90 ' + attrAxisTitleP.x + ',' + attrAxisTitleP.y + ')';
				m_svg.createText(attrAxisTitleP, styleAxisTitleP, 'Power (' + unit_p_name + ')', 10, null, transform);
			}

			//
			for (var i = m_coordinatePara.StartLineNoP; i <= m_coordinatePara.EndLineNoP; i++) {
				let content = UnitHelper.valueFormat(m_coordinatePara.MinP + i * m_coordinatePara.SpaceP);

				content = UnitHelper.formatToFixed(parseFloat(UnitHelper.ConvertP(UnitHelper.P.KW, m_unit.P, content)), 1);

				let posiY_grid = m_chartSize.DownDiagram.Bottom - m_chartSize.DownDiagram.SpaceGridY * i;
				//主刻度
				let valueMain = [];
				valueMain.push('M ', m_chartSize.DiagramLeft, ' ', posiY_grid, ' L ', m_chartSize.DiagramLeft - tickLength, ' ', posiY_grid);
				m_svg.createPath(null, valueMain.join(''), attrAxisTickP, null);

				//文字
				var attrAxisLabelP = {
					opacity: 1,
					x: m_chartSize.DiagramLeft - 10,
					y: posiY_grid + 5,
					'text-anchor': 'end',
				};

				m_svg.createText(attrAxisLabelP, styleAxisLabelP, content);

				//子刻度线
				if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.EndLineNoP && i != m_coordinatePara.EndLineNoE) {
					for (let j = 1; j < m_displayStyle.MiniTickNumber; j++) {
						let pois_minTick = posiY_grid - (m_chartSize.DownDiagram.SpaceGridY * j) / m_displayStyle.MiniTickNumber;
						let valueMini = [];
						valueMini.push(
							'M ',
							m_chartSize.DiagramLeft,
							' ',
							pois_minTick,
							' L ',
							m_chartSize.DiagramLeft - minTickLength,
							' ',
							pois_minTick
						);
						m_svg.createPath(null, valueMini.join(''), attrAxisTickP, null);
					}
				}
			}
		}

		//汽蚀
		if (m_isDispNpsh && m_coordinatePara.EndLineNoNPSH > m_coordinatePara.StartLineNoNPSH) {
			//刻度线
			var attrAxisTickNPSH = {
				stroke: m_displayStyle.ColorNPSH,
				'stroke-width': '1',
				fill: 'none',
			};

			//刻度文字
			var styleAxisLabelNPSH = 'font-size:11px; fill-opacity:1; fill:' + m_displayStyle.ColorNPSH + ';';
			//标签
			var styleAxisTitleNPSH = 'font-size:14px; ;fill-opacity:1; font-weight:bold; fill:' + m_displayStyle.ColorNPSH + ';';

			//标签
			var attrAxisTitleNPSH = {
				opacity: 1,
				x: m_chartSize.DiagramRight + 44,
				y:
					m_chartSize.DownDiagram.Bottom -
					m_chartSize.DownDiagram.SpaceGridY *
						((m_coordinatePara.EndLineNoNPSH - m_coordinatePara.StartLineNoNPSH) / 2 + m_coordinatePara.StartLineNoNPSH) -
					10,
				'text-anchor': 'middle',
			};
			if (m_localizationType == 0) {
				//中文
				attrAxisTitleNPSH.y = attrAxisTitleNPSH.y - 5;
				m_svg.createText(attrAxisTitleNPSH, styleAxisTitleNPSH, '汽');
				attrAxisTitleNPSH.y = attrAxisTitleNPSH.y + 15;
				m_svg.createText(attrAxisTitleNPSH, styleAxisTitleNPSH, '蚀');
				attrAxisTitleNPSH.x = attrAxisTitleNPSH.x + 6;
				attrAxisTitleNPSH.y = attrAxisTitleNPSH.y + 24;
				let transform = 'rotate(-90 ' + attrAxisTitleNPSH.x + ',' + attrAxisTitleNPSH.y + ')';
				m_svg.createText(attrAxisTitleNPSH, styleAxisTitleNPSH, '(m)', 10, null, transform);
			} else {
				attrAxisTitleNPSH.x = attrAxisTitleNPSH.x + 6;
				attrAxisTitleNPSH.y = attrAxisTitleNPSH.y + 24;
				let transform = 'rotate(-90 ' + attrAxisTitleNPSH.x + ',' + attrAxisTitleNPSH.y + ')';
				m_svg.createText(attrAxisTitleNPSH, styleAxisTitleNPSH, 'NPSHr (m)', 10, null, transform);
			}

			//
			for (let i = m_coordinatePara.StartLineNoNPSH; i <= m_coordinatePara.EndLineNoNPSH; i++) {
				let content = UnitHelper.valueFormat(m_coordinatePara.MinNPSH + i * m_coordinatePara.SpaceNPSH);
				let posiY_grid = m_chartSize.DownDiagram.Bottom - m_chartSize.DownDiagram.SpaceGridY * i;
				//主刻度
				let valueMain = [];
				valueMain.push('M ', m_chartSize.DiagramRight, ' ', posiY_grid, ' L ', m_chartSize.DiagramRight + tickLength, ' ', posiY_grid);
				m_svg.createPath(null, valueMain.join(''), attrAxisTickNPSH, null);

				//文字
				var attrAxisLabelNPSH = {
					opacity: 1,
					x: m_chartSize.DiagramRight + 10,
					y: posiY_grid + 5,
				};
				m_svg.createText(attrAxisLabelNPSH, styleAxisLabelNPSH, content);

				//子刻度线
				if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.EndLineNoNPSH) {
					for (let j = 0; j < m_displayStyle.MiniTickNumber; j++) {
						let pois_minTick = posiY_grid - (m_chartSize.DownDiagram.SpaceGridY * j) / m_displayStyle.MiniTickNumber;
						let valueMini = [];
						valueMini.push(
							'M ',
							m_chartSize.DiagramRight,
							' ',
							pois_minTick,
							' L ',
							m_chartSize.DiagramRight + minTickLength,
							' ',
							pois_minTick
						);
						m_svg.createPath(null, valueMini.join(''), attrAxisTickNPSH, null);
					}
				}
			}
		}
	};
	//绘制Y坐标(含标题)
	var createYAxis_TwoPanel = function () {
		if (m_coordinatePara == null) {
			return;
		}

		//刻度长度
		var minTickLength = 3;
		var tickLength = 6;

		//扬程
		if (m_coordinatePara.EndLineNoH > m_coordinatePara.StartLineNoH) {
			if (m_displayStyle.AxisTitlePosiAxisUpY == false) {
				//标题放在刻度上
				creatAxisTitleH();
			}

			//刻度线
			var attrAxisTickH = {
				stroke: m_displayStyle.ColorH,
				'stroke-width': '1',
				fill: 'none',
			};

			//刻度文字
			var styleAxisLabelH = 'font-size:11px; fill-opacity:1; fill:' + m_displayStyle.ColorH + ';';
			//
			for (var i = 0; i <= m_coordinatePara.EndLineNoH - m_coordinatePara.StartLineNoH; i++) {
				var posiY_grid = m_chartSize.PanelH.Bottom - m_chartSize.UpDiagram.SpaceGridY * i;

				//主刻度
				var valueMain = [];
				valueMain.push('M ', m_chartSize.DiagramLeft, ' ', posiY_grid, ' L ', m_chartSize.DiagramLeft - tickLength, ' ', posiY_grid);
				m_svg.createPath(null, valueMain.join(''), attrAxisTickH, null);

				//文字
				var attrAxisLabelH = {
					opacity: 1,
					x: m_chartSize.DiagramLeft - 10,
					y: posiY_grid + 5,
					'text-anchor': 'end',
				};
				var axis_h = UnitHelper.ConvertH_fromM(
					m_unit.H,
					m_coordinatePara.MinH + (i + m_coordinatePara.StartLineNoH) * m_coordinatePara.SpaceH
				);
				if (axis_h < 0) continue;
				var content = UnitHelper.valueFormat(axis_h);
				if (i == m_coordinatePara.EndLineNoH - m_coordinatePara.StartLineNoH) {
					if (m_displayStyle.AxisTitlePosiAxisUpY == true) {
						styleAxisLabelH = 'font-size:12px; fill-opacity:1; fill:' + m_displayStyle.ColorH + ';';
						let unit_h_name = UnitHelper.GetUnitNameH(m_unit.H);
						content = 'H [' + unit_h_name + ']';
					}
				}

				m_svg.createText(attrAxisLabelH, styleAxisLabelH, content);

				//子刻度线
				if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.EndLineNoH - m_coordinatePara.StartLineNoH) {
					for (var j = 1; j <= m_displayStyle.MiniTickNumber; j++) {
						var pois_minTick = posiY_grid - (m_chartSize.UpDiagram.SpaceGridY * j) / (m_displayStyle.MiniTickNumber + 1);
						var valueMini = [];
						valueMini.push(
							'M ',
							m_chartSize.DiagramLeft,
							' ',
							pois_minTick,
							' L ',
							m_chartSize.DiagramLeft - minTickLength,
							' ',
							pois_minTick
						);
						m_svg.createPath(null, valueMini.join(''), attrAxisTickH, null);
					}
				}
			}
		}

		//效率
		if (m_coordinatePara.EndLineNoE > m_coordinatePara.StartLineNoE && m_isDispCurveQE) {
			createAxisTitleE();

			//刻度文字
			var styleAxisLabelE = 'font-size:11px; fill-opacity:1; fill:' + m_displayStyle.ColorE + ';';
			//刻度线
			var attrAxisTickE = {
				stroke: m_displayStyle.ColorE,
				'stroke-width': '1',
				fill: 'none',
			};
			//
			for (let i = 0; i <= m_coordinatePara.EndLineNoE - m_coordinatePara.StartLineNoE; i++) {
				let posiY_grid = m_chartSize.PanelE.Bottom - m_chartSize.UpDiagram.SpaceGridY * i;
				//主刻度
				let valueMain = [];
				valueMain.push('M ', m_chartSize.DiagramRight, ' ', posiY_grid, ' L ', m_chartSize.DiagramRight + tickLength, ' ', posiY_grid);
				m_svg.createPath(null, valueMain.join(''), attrAxisTickE, null);

				//文字
				var attrAxisLabelE = {
					opacity: 1,
					x: m_chartSize.DiagramRight + 10,
					y: posiY_grid + 5,
				};
				let content = UnitHelper.valueFormat(m_coordinatePara.MinE + (i + m_coordinatePara.StartLineNoE) * m_coordinatePara.SpaceE);
				m_svg.createText(attrAxisLabelE, styleAxisLabelE, content);

				//子刻度线
				if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.EndLineNoE - m_coordinatePara.StartLineNoE) {
					for (let j = 0; j < m_displayStyle.MiniTickNumber; j++) {
						let pois_minTick = posiY_grid - (m_chartSize.UpDiagram.SpaceGridY * j) / m_displayStyle.MiniTickNumber;
						let valueMini = [];
						valueMini.push(
							'M ',
							m_chartSize.DiagramRight,
							' ',
							pois_minTick,
							' L ',
							m_chartSize.DiagramRight + minTickLength,
							' ',
							pois_minTick
						);
						m_svg.createPath(null, valueMini.join(''), attrAxisTickE, null);
					}
				}
			}
		}

		//功率
		if (m_coordinatePara.EndLineNoP > m_coordinatePara.StartLineNoP) {
			if (m_displayStyle.AxisTitlePosiAxisUpY == false) {
				//标题放在刻度上
				createAxisTitleP();
			}

			//刻度线
			var attrAxisTickP = {
				stroke: m_displayStyle.ColorP,
				'stroke-width': '1',
				fill: 'none',
			};
			var styleAxisLabelP = 'font-size:11px; fill-opacity:1; fill:' + m_displayStyle.ColorP + ';';
			//console.log(m_coordinatePara);
			for (let i = 0; i <= m_coordinatePara.EndLineNoP - m_coordinatePara.StartLineNoP; i++) {
				let posiY_grid = m_chartSize.PanelP.Bottom - m_chartSize.DownDiagram.SpaceGridY * i;
				//主刻度
				let valueMain = [];
				valueMain.push('M ', m_chartSize.DiagramLeft, ' ', posiY_grid, ' L ', m_chartSize.DiagramLeft - tickLength, ' ', posiY_grid);
				m_svg.createPath(null, valueMain.join(''), attrAxisTickP, null);

				//文字
				var attrAxisLabelP = {
					opacity: 1,
					x: m_chartSize.DiagramLeft - 10,
					y: posiY_grid + 5,
					'text-anchor': 'end',
				};

				var aixs_p = m_coordinatePara.MinP + (i + m_coordinatePara.StartLineNoP) * m_coordinatePara.SpaceP;
				aixs_p = UnitHelper.getDispValueP(UnitHelper.ConvertP_fromKW(m_unit.P, aixs_p));
				if (aixs_p < -0.01) continue;
				let content = aixs_p.toString();

				if (i == m_coordinatePara.EndLineNoP - m_coordinatePara.StartLineNoP) {
					if (m_displayStyle.AxisTitlePosiAxisUpY == true) {
						styleAxisLabelP = 'font-size:12px; fill-opacity:1; fill:' + m_displayStyle.ColorP + ';';
						let unit_p_name = UnitHelper.GetUnitNameP(m_unit.P);
						content = 'P [' + unit_p_name + ']';
					}
				}

				m_svg.createText(attrAxisLabelP, styleAxisLabelP, content);

				//子刻度线
				if (
					m_displayStyle.isDispMiniTick &&
					i != m_coordinatePara.EndLineNoP &&
					i != m_coordinatePara.EndLineNoP - m_coordinatePara.StartLineNoP
				) {
					for (var j = 1; j < m_displayStyle.MiniTickNumber; j++) {
						let pois_minTick = posiY_grid - (m_chartSize.DownDiagram.SpaceGridY * j) / m_displayStyle.MiniTickNumber;
						let valueMini = [];
						valueMini.push(
							'M ',
							m_chartSize.DiagramLeft,
							' ',
							pois_minTick,
							' L ',
							m_chartSize.DiagramLeft - minTickLength,
							' ',
							pois_minTick
						);
						m_svg.createPath(null, valueMini.join(''), attrAxisTickP, null);
					}
				}
			}
		}

		//汽蚀
		if (m_isDispNpsh && m_coordinatePara.EndLineNoNPSH > m_coordinatePara.StartLineNoNPSH) {
			createAxisTitleNPSH();

			//刻度线
			var attrAxisTickNPSH = {
				stroke: m_displayStyle.ColorNPSH,
				'stroke-width': '1',
				fill: 'none',
			};

			//刻度文字
			var styleAxisLabelNPSH = 'font-size:11px; fill-opacity:1; fill:' + m_displayStyle.ColorNPSH + ';';

			//
			for (let i = 0; i <= m_coordinatePara.EndLineNoNPSH - m_coordinatePara.StartLineNoNPSH; i++) {
				let posiY_grid = m_chartSize.PanelNPSH.Bottom - m_chartSize.DownDiagram.SpaceGridY * i;
				//主刻度
				let valueMain = [];
				valueMain.push('M ', m_chartSize.DiagramRight, ' ', posiY_grid, ' L ', m_chartSize.DiagramRight + tickLength, ' ', posiY_grid);
				m_svg.createPath(null, valueMain.join(''), attrAxisTickNPSH, null);

				//文字
				var attrAxisLabelNPSH = {
					opacity: 1,
					x: m_chartSize.DiagramRight + 10,
					y: posiY_grid + 5,
				};
				var axis_npsh = UnitHelper.valueFormat(
					m_coordinatePara.MinNPSH + (i + m_coordinatePara.StartLineNoNPSH) * m_coordinatePara.SpaceNPSH
				);
				axis_npsh = UnitHelper.ConvertNPSH_fromM(m_unit.NPSH, axis_npsh);
				let content = UnitHelper.getDispValueNPSH(axis_npsh);

				m_svg.createText(attrAxisLabelNPSH, styleAxisLabelNPSH, content);

				//子刻度线
				if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.EndLineNoNPSH - m_coordinatePara.StartLineNoNPSH) {
					for (var j = 0; j < m_displayStyle.MiniTickNumber; j++) {
						let pois_minTick = posiY_grid - (m_chartSize.DownDiagram.SpaceGridY * j) / m_displayStyle.MiniTickNumber;
						let valueMini = [];
						valueMini.push(
							'M ',
							m_chartSize.DiagramRight,
							' ',
							pois_minTick,
							' L ',
							m_chartSize.DiagramRight + minTickLength,
							' ',
							pois_minTick
						);
						m_svg.createPath(null, valueMini.join(''), attrAxisTickNPSH, null);
					}
				}
			}
		}
	};
	//绘制Y坐标标题(扬程)
	var creatAxisTitleH = function () {
		var styleAxisTitleH = 'font-size:14px; ;fill-opacity:1; font-weight:bold; fill:' + m_displayStyle.ColorH + ';';

		let unit_h_name = UnitHelper.GetUnitNameH(m_unit.H);

		//标签
		var attrAxisTitleH = {
			opacity: 1,
			x: m_chartSize.DiagramLeft - 52,
			y: (m_chartSize.PanelH.Bottom + m_chartSize.PanelH.Up) / 2 - 10,
			'text-anchor': 'middle',
		};
		if (m_localizationType == 0) {
			//中文
			if (m_unit.H == UnitHelper.H.MPa || m_unit.H == UnitHelper.H.KPa) {
				attrAxisTitleH.y = attrAxisTitleH.y - 5;
				m_svg.createText(attrAxisTitleH, styleAxisTitleH, '压');
				attrAxisTitleH.y = attrAxisTitleH.y + 15;
				m_svg.createText(attrAxisTitleH, styleAxisTitleH, '力');

				attrAxisTitleH.x = attrAxisTitleH.x + 3;
				attrAxisTitleH.y = attrAxisTitleH.y + 21;
				var transform = 'rotate(-90 ' + attrAxisTitleH.x + ',' + attrAxisTitleH.y + ')';
				m_svg.createText(attrAxisTitleH, styleAxisTitleH, '(MPa)', 10, null, transform);
			} else {
				attrAxisTitleH.y = attrAxisTitleH.y - 5;
				m_svg.createText(attrAxisTitleH, styleAxisTitleH, '扬');
				attrAxisTitleH.y = attrAxisTitleH.y + 15;
				m_svg.createText(attrAxisTitleH, styleAxisTitleH, '程');

				if (m_unit.H == 0) {
					attrAxisTitleH.x = attrAxisTitleH.x + 3;
					attrAxisTitleH.y = attrAxisTitleH.y + 21;
					let transform = 'rotate(-90 ' + attrAxisTitleH.x + ',' + attrAxisTitleH.y + ')'; //不用多出空格否则全屏会有问题expandChartFullScreen
					m_svg.createText(attrAxisTitleH, styleAxisTitleH, '(' + unit_h_name + ')', 10, null, transform);
				}
			}
		} else {
			var content = 'Head (' + unit_h_name + ')';
			if (m_unit.H == UnitHelper.H.MPa) {
				content = 'Press (MPa)';
			}
			if (m_unit.H == UnitHelper.H.KPa) {
				content = 'Press (MPa)';
			}
			let transform = 'rotate(-90 ' + attrAxisTitleH.x + ',' + attrAxisTitleH.y + ')'; //不用多出空格否则全屏会有问题expandChartFullScreen
			m_svg.createText(attrAxisTitleH, styleAxisTitleH, content, 10, null, transform);
		}
	};
	//绘制Y坐标标题(效率)
	var createAxisTitleE = function () {
		if (m_displayStyle.AxisTitlePosiAxisUpY == true) {
			//标题放在刻度上
			var styleAxisTitleE = 'font-size:12px; fill-opacity:1; fill:' + m_displayStyle.ColorE + ';';
			//刻度线
			var attrAxisTitleE = {
				stroke: m_displayStyle.ColorE,
				'stroke-width': '1',
				fill: 'none',
			};

			var posiY_grid =
				m_chartSize.PanelE.Bottom -
				m_chartSize.UpDiagram.SpaceGridY * (m_coordinatePara.EndLineNoE - m_coordinatePara.StartLineNoE + 1);
			//主刻度
			var valueMain = [];
			valueMain.push('M ', m_chartSize.DiagramRight, ' ', posiY_grid, ' L ', m_chartSize.DiagramRight + 2, ' ', posiY_grid);
			m_svg.createPath(null, valueMain.join(''), attrAxisTitleE, null);

			//文字
			var attrAxisLabelE = {
				opacity: 1,
				x: m_chartSize.DiagramRight + 10,
				y: posiY_grid + 5,
			};
			var content = 'E [%]';
			m_svg.createText(attrAxisLabelE, styleAxisTitleE, content);
		} else {
			let styleAxisTitleE = 'font-size:14px; ;fill-opacity:1; font-weight:bold; fill:' + m_displayStyle.ColorE + ';';
			//
			let attrAxisTitleE = {
				opacity: 1,
				x: m_chartSize.DiagramRight + 44,
				y: (m_chartSize.UpDiagram.Bottom + m_chartSize.UpDiagram.Up) / 2 - 10,
				'text-anchor': 'middle',
			};

			//标签
			if (m_localizationType == 0) {
				//中文
				attrAxisTitleE.y = attrAxisTitleE.y - 5;
				m_svg.createText(attrAxisTitleE, styleAxisTitleE, '效');
				attrAxisTitleE.y = attrAxisTitleE.y + 15;
				m_svg.createText(attrAxisTitleE, styleAxisTitleE, '率');

				attrAxisTitleE.x = attrAxisTitleE.x + 6;
				attrAxisTitleE.y = attrAxisTitleE.y + 24;
				var transform = 'rotate(-90 ' + attrAxisTitleE.x + ',' + attrAxisTitleE.y + ')';
				m_svg.createText(attrAxisTitleE, styleAxisTitleE, '(%)', 10, null, transform);
			} else {
				attrAxisTitleE.x = attrAxisTitleE.x + 6;
				attrAxisTitleE.y = attrAxisTitleE.y + 24;
				let transform = 'rotate(-90 ' + attrAxisTitleE.x + ',' + attrAxisTitleE.y + ')';
				m_svg.createText(attrAxisTitleE, styleAxisTitleE, 'Eta (%)', 10, null, transform);
			}
		}
	};
	//绘制Y坐标标题(功率)
	var createAxisTitleP = function () {
		let unit_p_name = UnitHelper.GetUnitNameP(m_unit.P);

		//标签
		var styleAxisTitleP = 'font-size:14px; ;fill-opacity:1; font-weight:bold; fill:' + m_displayStyle.ColorP + ';';

		//标签
		if (m_localizationType == 0) {
			//中文
			var attrAxisTitleP = {
				opacity: 1,
				x: m_chartSize.DiagramLeft - 52,
				y: (m_chartSize.PanelP.Bottom + m_chartSize.PanelP.Up) / 2 - 10,
				'text-anchor': 'middle',
			};
			if (m_coordinatePara.SpaceP <= 0.1) {
				attrAxisTitleP.x = attrAxisTitleP.x - 5;
			}
			attrAxisTitleP.y = attrAxisTitleP.y - 5;
			m_svg.createText(attrAxisTitleP, styleAxisTitleP, '功');
			attrAxisTitleP.y = attrAxisTitleP.y + 15;
			m_svg.createText(attrAxisTitleP, styleAxisTitleP, '率');

			attrAxisTitleP.x = attrAxisTitleP.x + 2;
			attrAxisTitleP.y = attrAxisTitleP.y + 25;
			var transform = 'rotate(-90 ' + attrAxisTitleP.x + ',' + attrAxisTitleP.y + ')';
			m_svg.createText(attrAxisTitleP, styleAxisTitleP, '(' + unit_p_name + ')', 10, null, transform);
		} else {
			let attrAxisTitleP = {
				opacity: 1,
				x: m_chartSize.DiagramLeft - 60,
				y: (m_chartSize.PanelP.Bottom + m_chartSize.PanelP.Up) / 2 - 10,
				'text-anchor': 'middle',
			};
			if (m_coordinatePara.SpaceP <= 0.1) {
				attrAxisTitleP.x = attrAxisTitleP.x - 5;
			}
			attrAxisTitleP.x = attrAxisTitleP.x + 13;
			attrAxisTitleP.y = attrAxisTitleP.y + 25;
			let transform = 'rotate(-90 ' + attrAxisTitleP.x + ',' + attrAxisTitleP.y + ')';
			m_svg.createText(attrAxisTitleP, styleAxisTitleP, 'Power (' + unit_p_name + ')', 10, null, transform);
		}
	};
	//绘制Y坐标标题(汽蚀)
	var createAxisTitleNPSH = function () {
		if (m_displayStyle.AxisTitlePosiAxisUpY == true) {
			//标题放在刻度上
			//刻度线
			var attrAxisTickNPSH = {
				stroke: m_displayStyle.ColorNPSH,
				'stroke-width': '1',
				fill: 'none',
			};

			//刻度文字
			var styleAxisLabelNPSH = 'font-size:12px; fill-opacity:1; fill:' + m_displayStyle.ColorNPSH + ';';

			var posiY_grid =
				m_chartSize.PanelNPSH.Bottom -
				m_chartSize.DownDiagram.SpaceGridY * (m_coordinatePara.EndLineNoNPSH - m_coordinatePara.StartLineNoNPSH + 1);
			//主刻度
			var valueMain = [];
			valueMain.push('M ', m_chartSize.DiagramRight, ' ', posiY_grid, ' L ', m_chartSize.DiagramRight + 2, ' ', posiY_grid);
			m_svg.createPath(null, valueMain.join(''), attrAxisTickNPSH, null);

			//文字
			var attrAxisLabelNPSH = {
				opacity: 1,
				x: m_chartSize.DiagramRight + 10,
				y: posiY_grid - 4,
			};
			m_svg.createText(attrAxisLabelNPSH, styleAxisLabelNPSH, 'NPSH');

			var attrAxisLabelNPSH_unit = {
				opacity: 1,
				x: m_chartSize.DiagramRight + 10,
				y: posiY_grid + 9,
			};
			m_svg.createText(attrAxisLabelNPSH_unit, styleAxisLabelNPSH, '[' + UnitHelper.GetUnitNameNPSH(m_unit.NPSH) + ']');
		} else {
			var styleAxisTitleNPSH = 'font-size:14px; ;fill-opacity:1; font-weight:bold; fill:' + m_displayStyle.ColorNPSH + ';';
			var attrAxisTitleNPSH = {
				opacity: 1,
				x: m_chartSize.DiagramRight + 44,
				y: (m_chartSize.PanelNPSH.Bottom + m_chartSize.PanelNPSH.Up) / 2 - 10,
				'text-anchor': 'middle',
			};
			if (m_localizationType == 0) {
				//中文
				attrAxisTitleNPSH.y = attrAxisTitleNPSH.y - 5;
				m_svg.createText(attrAxisTitleNPSH, styleAxisTitleNPSH, '汽');
				attrAxisTitleNPSH.y = attrAxisTitleNPSH.y + 15;
				m_svg.createText(attrAxisTitleNPSH, styleAxisTitleNPSH, '蚀');
				attrAxisTitleNPSH.x = attrAxisTitleNPSH.x - 4;
				attrAxisTitleNPSH.y = attrAxisTitleNPSH.y + 24;
				var transform = 'rotate(90 ' + attrAxisTitleNPSH.x + ',' + attrAxisTitleNPSH.y + ')';
				m_svg.createText(attrAxisTitleNPSH, styleAxisTitleNPSH, '(m)', 10, null, transform);
			} else {
				attrAxisTitleNPSH.x = attrAxisTitleNPSH.x + 6;
				attrAxisTitleNPSH.y = attrAxisTitleNPSH.y + 24;
				let transform = 'rotate(90 ' + attrAxisTitleNPSH.x + ',' + attrAxisTitleNPSH.y + ')';
				m_svg.createText(attrAxisTitleNPSH, styleAxisTitleNPSH, 'NPSHr (m)', 10, null, transform);
			}
		}
	};
	//绘制面板
	var drawDiagramPanel = function () {
		if (m_chartDiagramPanelStyle == ConstParas.ChartDiagramPanelStyle.Whole) {
			//绘制网格线
			createGridLineDiagram_Whole();

			//绘制X坐标(上面 第二坐标)
			createFlowAxisSecondUp();

			//绘制X坐标
			createFlowAxisBottom();

			//绘制Y坐标
			createYAxis_Whole();
		} else {
			//绘制网格线
			createGridLineDiagram_TwoPanel();

			//绘制X坐标(上面 第二坐标)
			createFlowAxisSecondUp();

			//绘制X坐标
			createFlowAxisMiddle();
			createFlowAxisBottom();

			//绘制Y坐标
			createYAxis_TwoPanel();
		}
	};
	//产生装置曲线
	var drawEquipmentCurve = function () {
		var equipmentCurveElement = document.getElementById('EquipmentCurve');
		if (equipmentCurveElement) {
			equipmentCurveElement.parentNode.removeChild(equipmentCurveElement);
		}

		if (m_chartObject.EquipmentSectPt == null) return;
		var pointNumber = 20;
		var EquipmentCurve = [];
		var space = m_chartObject.EquipmentSectPt.X / (pointNumber - 1);
		var k = (m_chartObject.EquipmentSectPt.Y - m_equipZeroH) / (m_chartObject.EquipmentSectPt.X * m_chartObject.EquipmentSectPt.X);
		for (var i = 0; i < pointNumber; i++) {
			var pt = {};
			pt.X = space * i;
			pt.Y = m_equipZeroH + k * pt.X * pt.X;
			EquipmentCurve.push(pt);
		}
		createCurveQH('EquipmentCurve', EquipmentCurve, 1, m_displayStyle.ColorEquipment, m_displayStyle.isDispEquipmentCurve);
	};

	//产生型谱
	var drawSpectrumShape = function () {
		var spectrumShape = m_chartObject.SpectrumShape;
		//console.log(m_displayStyle.IsDispSpectrum,spectrumShape)

		if (spectrumShape == null) return;
		var spectrumShapeElement = document.getElementById('SpectrumShape');
		if (spectrumShapeElement) {
			spectrumShapeElement.parentNode.removeChild(spectrumShapeElement);
		}

		if (!m_displayStyle.IsDispSpectrum) {
			return;
		}

		var pathValue = [];

		var pixelPoints_Left = [];
		var points_left = spectrumShape['LeftParabolaPoints'];
		for (var v = 0; v < points_left.length; v++) {
			var pt = points_left[v];
			var x = getPixelValueQ(pt.X);
			var y = getPixelValueH(pt.Y);
			pixelPoints_Left.push({ X: x, Y: y });
		}
		var bezierCurve_points_Left = transBezierCurveModel(pixelPoints_Left);
		for (var h = 0; h < bezierCurve_points_Left.length; h++) {
			var b_pt = bezierCurve_points_Left[h];
			if (h == 0) {
				pathValue.push('M ', b_pt.Point0.X, ' ', b_pt.Point0.Y);
				pathValue.push(
					' C ',
					b_pt.Point1.X,
					' ',
					b_pt.Point1.Y,
					' ',
					b_pt.Point2.X,
					' ',
					b_pt.Point2.Y,
					' ',
					b_pt.Point3.X,
					' ',
					b_pt.Point3.Y
				);
			} else {
				pathValue.push(' L ', b_pt.Point0.X, ' ', b_pt.Point0.Y);
				pathValue.push(
					' C ',
					b_pt.Point1.X,
					' ',
					b_pt.Point1.Y,
					' ',
					b_pt.Point2.X,
					' ',
					b_pt.Point2.Y,
					' ',
					b_pt.Point3.X,
					' ',
					b_pt.Point3.Y
				);
			}
		}

		var pixelPoints_Top = [];
		var points_top = spectrumShape['BasePoints'];
		for (let v = 0; v < points_top.length; v++) {
			let pt = points_top[v];
			let x = getPixelValueQ(pt.X);
			let y = getPixelValueH(pt.Y);
			pixelPoints_Top.push({ X: x, Y: y });
		}
		var bezierCurve_points_top = transBezierCurveModel(pixelPoints_Top);
		for (let h = 0; h < bezierCurve_points_top.length; h++) {
			let b_pt = bezierCurve_points_top[h];
			pathValue.push(' L ', b_pt.Point0.X, ' ', b_pt.Point0.Y);
			pathValue.push(
				' C ',
				b_pt.Point1.X,
				' ',
				b_pt.Point1.Y,
				' ',
				b_pt.Point2.X,
				' ',
				b_pt.Point2.Y,
				' ',
				b_pt.Point3.X,
				' ',
				b_pt.Point3.Y
			);
		}

		var pixelPoints_bottom = [];
		var points_bottom = spectrumShape['SimularPoints'];
		for (let v = 0; v < points_bottom.length; v++) {
			let pt = points_bottom[v];
			let x = getPixelValueQ(pt.X);
			let y = getPixelValueH(pt.Y);
			pixelPoints_bottom.push({ X: x, Y: y });
		}
		var bezierCurve_points_bottom = transBezierCurveModel(pixelPoints_bottom);
		for (let h = 0; h < bezierCurve_points_bottom.length; h++) {
			let b_pt = bezierCurve_points_bottom[h];
			pathValue.push(' L ', b_pt.Point0.X, ' ', b_pt.Point0.Y);
			pathValue.push(
				' C ',
				b_pt.Point1.X,
				' ',
				b_pt.Point1.Y,
				' ',
				b_pt.Point2.X,
				' ',
				b_pt.Point2.Y,
				' ',
				b_pt.Point3.X,
				' ',
				b_pt.Point3.Y
			);
		}

		var pixelPoints_right = [];
		var points_right = spectrumShape['RightParabolaPoints'];
		for (let v = 0; v < points_right.length; v++) {
			let pt = points_right[v];
			let x = getPixelValueQ(pt.X);
			let y = getPixelValueH(pt.Y);
			pixelPoints_right.push({ X: x, Y: y });
		}
		var bezierCurve_points_right = transBezierCurveModel(pixelPoints_right);
		for (let h = 0; h < bezierCurve_points_right.length; h++) {
			let b_pt = bezierCurve_points_right[h];
			pathValue.push(' L ', b_pt.Point0.X, ' ', b_pt.Point0.Y);
			pathValue.push(
				' C ',
				b_pt.Point1.X,
				' ',
				b_pt.Point1.Y,
				' ',
				b_pt.Point2.X,
				' ',
				b_pt.Point2.Y,
				' ',
				b_pt.Point3.X,
				' ',
				b_pt.Point3.Y
			);
			if (h == bezierCurve_points_right.length - 1) {
				pathValue.push(' L ', b_pt.Point3.X, ' ', b_pt.Point3.Y);
			}
		}

		//有时会报错，加上这个就没事 tangxu 20151122
		if (pathValue.toString().indexOf('M ,NaN, ,NaN') == 0) {
			return;
		}

		var style = {
			'stroke-width': '1',
			stroke: 'none',
			fill: m_displayStyle.ColorSpectrumFill,
			'stroke-opacity': '0.1',
			'fill-opacity': '0.3',
			'shape-rendering': 'geometricPrecision',
			'zIndex:': -1,
		};
		m_svg.createPath('SpectrumShape', pathValue.join(''), null, style);
	};

	//绘制曲线(流量扬程)
	var createCurveQH = function (curveElementName, curvePoints, curveWidth, curveColor, curveIsDisp, curveDashType) {
		if (curvePoints == null) {
			return;
		}
		if (curveElementName == null) {
			return;
		}

		var pixelPoints = [];
		for (var v = 0; v < curvePoints.length; v++) {
			var pt = curvePoints[v];
			var x = getPixelValueQ(pt.X);
			var y = getPixelValueH(pt.Y);
			pixelPoints.push({ X: x, Y: y });
		}

		return createCurveQH_pixel(curveElementName, pixelPoints, curveWidth, curveColor, curveIsDisp, curveDashType);
	};
	//绘制曲线(流量扬程) : 像素点
	var createCurveQH_pixel = function (curveElementName, pixelPoints, curveWidth, curveColor, isDisp, curveDashType) {
		if (pixelPoints == null || pixelPoints.length < 3) {
			return;
		}
		if (curveElementName == null) {
			return;
		}
		var pathValue = transBezierCurveToPath(pixelPoints);
		if (pathValue == null || pathValue == undefined) return;
		//有时会报错，加上这个就没事 tangxu 20151122
		if (pathValue.toString().indexOf('M ,NaN, ,NaN') == 0) {
			return;
		}

		var style = {
			'stroke-width': '2px',
			stroke: m_displayStyle.ColorH,
			fill: 'none',
			'fill-opacity': '0.5',
			//"stroke-dasharray":"5 3",
			'shape-rendering': 'geometricPrecision',
			'zIndex:': 7,
		};
		if (curveWidth != null) {
			style['stroke-width'] = curveWidth;
		}
		if (curveColor != null) {
			style['stroke'] = curveColor;
		}
		if (curveDashType != null) {
			style['stroke-dasharray'] = curveDashType; //'10, 10';//'10, 10, 5, 5'
		}
		//console.log(curveElementName,pathValue)
		//绘制
		m_svg.createPath(
			curveElementName,
			pathValue.join(''),
			{
				id: curveElementName,
			},
			style
		);
		//是否显示
		if (isDisp != null && !isDisp) {
			document.getElementById(curveElementName).style.display = 'none';
		}

		//绘制定义点
		/*pixelPoints.forEach(pixel_pt => {
           // console.log(pixel_pt)
           var attr_pt = {
                "cx": pixel_pt.X,
                "cy": pixel_pt.Y,
                "r": 2
            }
            var style_pt = {
                "stroke-width": "2px",
                "stroke": curveColor,
                "fill": "none",
                "fill-opacity": "0.5", 
                "shape-rendering": "geometricPrecision",
                "zIndex:": 7
            };
 
    
            m_svg.createCircle(null, attr_pt, style_pt); 
        });*/

		return pixelPoints;
	};
	//绘制直线
	var createLineQH = function (curveElementName, point1, point2, curveWidth, curveColor, objTag) {
		if (point1 == null || point2 == null) {
			return;
		}
		if (curveElementName == null) {
			return;
		}
		var x1 = getPixelValueQ(point1.X);
		var y1 = getPixelValueH(point1.Y);

		var x2 = getPixelValueQ(point2.X);
		var y2 = getPixelValueH(point2.Y);

		var style = {
			'stroke-width': '2px',
			stroke: m_displayStyle.ColorH,
			fill: 'none',
			'fill-opacity': '0.5',
			//"stroke-dasharray":"5 3",
			'shape-rendering': 'geometricPrecision',
			'zIndex:': 7,
		};
		if (curveWidth != null) {
			style['stroke-width'] = curveWidth;
		}
		if (curveColor != null) {
			style['stroke'] = curveColor;
		}
		var temp = 'M x1 y1 L x2 y2';
		var pathValue = temp.replace('x1', x1).replace('y1', y1).replace('x2', x2).replace('y2', y2);
		if (objTag == null) m_svg.createPath(curveElementName, pathValue, null, style);
		else m_svg.createPath(curveElementName, pathValue, { tag: objTag }, style);
	};
	//绘制点
	var createPointQH = function (curveElementName, point, circleSize, circleColor) {
		if (point == null) {
			return;
		}
		if (curveElementName == null) {
			return;
		}

		var xPixel = getPixelValueQ(point.X);
		var yPixel = getPixelValueH(point.Y);

		var attr = {
			cx: xPixel,
			cy: yPixel,
			r: 2,
		};
		var style = {
			'stroke-width': '2px',
			stroke: m_displayStyle.ColorH,
			fill: 'none',
			'fill-opacity': '0.5',
			//"stroke-dasharray":"5 3",
			'shape-rendering': 'geometricPrecision',
			'zIndex:': 7,
		};
		if (circleSize != null) {
			attr.r = circleSize;
		}
		if (circleColor != null) {
			style['stroke'] = circleColor;
		}

		m_svg.createCircle(curveElementName, attr, style);
	};
	//绘制文字 textAnchor 文字对齐 start | middle | end
	var drawTextByQH = function (curveElementName, text, point, textSize, textColor, offsetPixelX, offsetPixelY, textAnchor) {
		if (!text) {
			return;
		}
		if (!point) {
			return;
		}

		var xPixel = getPixelValueQ(point.X);
		var yPixel = getPixelValueH(point.Y);
		if (offsetPixelX != null) {
			xPixel += offsetPixelX;
		}
		if (offsetPixelY != null) {
			yPixel -= offsetPixelY;
		}

		var textStyle = 'stroke-width:1px; '; //font-weight:bold; fill-opacity:0.9;
		if (textColor != null) {
			textStyle += ' fill:' + textColor + ';';
		} else {
			textStyle += ' fill:#000000;';
		}
		if (textSize != null) {
			textStyle += ' font-size:' + textSize + 'px;';
		} else {
			textStyle += ' font-size:12px;';
		}
		if (textAnchor != null) {
			textStyle += ' text-anchor:' + textAnchor + ';';
		}
		if (curveElementName == null) {
			return m_svg.createText(
				{
					opacity: 0.5,
					y: yPixel,
					x: xPixel,
				},
				textStyle,
				text
			);
		} else {
			return m_svg.createText(
				{
					id: curveElementName,
					opacity: 0.5,
					y: yPixel,
					x: xPixel,
				},
				textStyle,
				text
			);
		}
	};
	//绘制设计点
	var drawDesignPoint = function () {
		if (m_chartObject.DesignPoint4StdUnit == null) return;
		var defaultDp = m_chartObject.DesignPoint4StdUnit;

		var DispStyleType = m_displayStyle.DesignPointDispType;
		if (DispStyleType == 2) {
			//倒三角

			var xPixel = getPixelValueQ(defaultDp.X);
			var yPixel = getPixelValueH(defaultDp.Y);

			var xTri = m_chartSize.DiagramWidth / 20;
			var yTri = xTri / 2;
			var style = {
				'stroke-width': '2px',
				stroke: 'red',
				fill: 'none',
				'fill-opacity': '0.5',
				//"stroke-dasharray":"5 3",
				'shape-rendering': 'geometricPrecision',
				'zIndex:': 18,
			};
			//if (curveWidth != null) {
			//    style["stroke-width"] = curveWidth;
			//}
			//if (curveColor != null) {
			//    style["stroke"] = curveColor;
			//}

			var temp = 'M x1 y1 L x2 y2';
			var pathValue = temp
				.replace('x1', xPixel)
				.replace('y1', yPixel)
				.replace('x2', xPixel - xTri)
				.replace('y2', yPixel);
			m_svg.createPath(
				'DesignPointWater1',
				pathValue,
				{
					//"class": "DesignPoint1",
					tag: 'DesignPoint1',
				},
				style
			);
			pathValue = temp
				.replace('x1', xPixel)
				.replace('y1', yPixel)
				.replace('x2', xPixel)
				.replace('y2', yPixel + yTri);
			m_svg.createPath(
				'DesignPointWater2',
				pathValue,
				{
					//"class": "DesignPoint1",
					tag: 'DesignPoint1',
				},
				style
			);
			pathValue = temp
				.replace('x1', xPixel - xTri)
				.replace('y1', yPixel)
				.replace('x2', xPixel)
				.replace('y2', yPixel + yTri);
			m_svg.createPath(
				'DesignPointWater3',
				pathValue,
				{
					//"class": "DesignPoint1",
					tag: 'DesignPoint1',
				},
				style
			);

			//m_svg.createPath(objName, pathValue.join(''), {
			//    "id": objName
			//}, style);

			pathValue = temp
				.replace('x1', xPixel - xTri / 3)
				.replace('y1', yPixel)
				.replace('x2', xPixel)
				.replace('y2', yPixel + yTri / 3);
			m_svg.createPath(
				'DesignPointWater4',
				pathValue,
				{
					//"class": "DesignPoint1",
					tag: 'DesignPoint1',
				},
				style
			);

			pathValue = temp
				.replace('x1', xPixel - (xTri * 2) / 3)
				.replace('y1', yPixel)
				.replace('x2', xPixel)
				.replace('y2', yPixel + (yTri * 2) / 3);
			m_svg.createPath(
				'DesignPointWater5',
				pathValue,
				{
					//"class": "DesignPoint1",
					tag: 'DesignPoint1',
				},
				style
			);
		} else {
			//十字线
			var x = defaultDp.X;
			var y = defaultDp.Y;
			var point1 = { X: x, Y: y * m_designPointTolerance[2] };
			var point2 = { X: x, Y: y * m_designPointTolerance[3] };
			createLineQH('DesignPointWater1', point1, point2, 3, 'red', 'DesignPoint1');

			point1 = { X: x * m_designPointTolerance[0], Y: y };
			point2 = { X: x * m_designPointTolerance[1], Y: y };
			createLineQH('DesignPointWater2', point1, point2, 3, 'red', 'DesignPoint1');
		}
	};
	//刷新区域点位置
	var refreshRegionPtPosi = function (grp_pt, tag) {
		// console.log(m_chartObject, grp_pt, tag);
		if (tag == null) return;

		if (tag == 'AllowMaxPointQ' && m_chartPointPara != null) {
			m_chartPointPara.AllowMaxPoint = grp_pt;
			calcAllowRegionCurve();
		}
		if (tag == 'AllowMinPointQ' && m_chartPointPara != null) {
			m_chartPointPara.AllowMinPoint = grp_pt;
			calcAllowRegionCurve();
		}
		if (tag == 'PerferMinPointQ' && m_chartPointPara != null) {
			m_chartPointPara.PerferMinPoint = grp_pt;
			calcPerferRegionCurve();
		}
		if (tag == 'PerferMaxPointQ' && m_chartPointPara != null) {
			m_chartPointPara.PerferMaxPoint = grp_pt;
			calcPerferRegionCurve();
		}
	};
	//绘制 允许区域
	var calcAllowRegionCurve = function () {
		var regionBlodCurveQHAllow = document.getElementById('RegionBlodCurveQH_Allow');
		if (regionBlodCurveQHAllow) {
			regionBlodCurveQHAllow.parentNode.removeChild(regionBlodCurveQHAllow);
		}
		var regionBlodCurveQPAllow = document.getElementById('RegionBlodCurveQP_Allow');
		if (regionBlodCurveQPAllow) {
			regionBlodCurveQPAllow.parentNode.removeChild(regionBlodCurveQPAllow);
		}
		var regionBlodCurveQEAllow = document.getElementById('RegionBlodCurveQE_Allow');
		if (regionBlodCurveQEAllow) {
			regionBlodCurveQEAllow.parentNode.removeChild(regionBlodCurveQEAllow);
		}
		var regionBlodCurveNPSHAllow = document.getElementById('RegionBlodCurveNPSH_Allow');
		if (regionBlodCurveNPSHAllow) {
			regionBlodCurveNPSHAllow.parentNode.removeChild(regionBlodCurveNPSHAllow);
		}

		if (m_chartPointPara == null) return;

		if (m_wrkCurveGrp == null) return;
		if (m_wrkCurveGrp.PixelQH == null) return;

		if (m_chartPointPara.AllowMaxPoint == null) return;
		if (m_chartPointPara.AllowMinPoint == null) return;
		// console.log("AllowRegionPoint",m_chartPointPara.AllowMaxPoint,m_chartPointPara.AllowMinPoint);
		if (!m_chartPointPara.AllowRegionInChartVisible) {
			return;
		}
		if (m_chartPointPara.AllowRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod) {
			//加粗显示

			var pt_num = 11;
			var space = (m_chartPointPara.AllowMaxPoint.Q - m_chartPointPara.AllowMinPoint.Q) / (pt_num - 1);

			var pixelPoints_QH = [];
			var pixelPoints_QE = [];
			var pixelPoints_QP = [];

			for (var i = 0; i < pt_num; i++) {
				var q = m_chartPointPara.AllowMinPoint.Q + i * space;
				var xPixel = getPixelValueQ(q);

				var head_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQH, xPixel);
				if (head_pixel_pt != null) pixelPoints_QH.push(head_pixel_pt);
				if (m_isDispCurveQE) {
					var eta_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQE, xPixel);
					if (eta_pixel_pt != null) pixelPoints_QE.push(eta_pixel_pt);
				}

				var power_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQP, xPixel);
				if (power_pixel_pt != null) pixelPoints_QP.push(power_pixel_pt);

				//var npsh_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelNPSH, xPixel);
				//if (npsh_pixel_pt != null)
				//     pixelPoints_NPSH.push(npsh_pixel_pt);
			}

			let pixelPoints_NPSH = [];
			if (m_isDispNpsh && m_wrkCurveGrp.PixelNPSH && m_wrkCurveGrp.PixelNPSH.length > 3) {
				var min_q = Math.max(getPixelValueQ(m_chartPointPara.AllowMinPoint.Q), m_wrkCurveGrp.PixelNPSH[0].Point0.X);
				var max_q = Math.min(
					getPixelValueQ(m_chartPointPara.AllowMaxPoint.Q),
					m_wrkCurveGrp.PixelNPSH[m_wrkCurveGrp.PixelNPSH.length - 1].Point3.X
				);

				//console.log("PixelNPSH", m_wrkCurveGrp.PixelNPSH[m_wrkCurveGrp.PixelNPSH.length - 1]  , getPixelValueQ(m_chartPointPara.AllowMaxPoint.Q), max_q);

				space = (max_q - min_q) / (pt_num - 1);
				for (let i = 0; i < pt_num; i++) {
					let xPixel = min_q + i * space;

					var npsh_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelNPSH, xPixel);
					//console.log(i, xPixel,npsh_pixel_pt);
					if (npsh_pixel_pt != null) {
						pixelPoints_NPSH.push(npsh_pixel_pt);
					} else {
						if (i == 0) pixelPoints_NPSH.push(m_wrkCurveGrp.PixelNPSH[0].Point0);
					}
				}
			}

			//console.log(m_wrkCurveGrp,m_chartPointPara);
			createCurveQH_pixel('RegionBlodCurveQH_Allow', pixelPoints_QH, m_displayStyle.BlodRegionCurveWidth);
			createCurveQE_pixel('RegionBlodCurveQE_Allow', pixelPoints_QE, m_displayStyle.BlodRegionCurveWidth);
			createCurveQP_pixel('RegionBlodCurveQP_Allow', pixelPoints_QP, m_displayStyle.BlodRegionCurveWidth);
			createCurveNPSH_pixel('RegionBlodCurveNPSH_Allow', pixelPoints_NPSH, m_displayStyle.BlodRegionCurveWidth);
		} else if (m_chartPointPara.AllowRegionDispStyle == ConstParas.ChartRegionDispStyle.Strip) {
			// 条带
			var chartRegionAllowRegionStrip = document.getElementById('ChartRegionAllowRegionStrip');
			if (chartRegionAllowRegionStrip) {
				chartRegionAllowRegionStrip.parentNode.removeChild(chartRegionAllowRegionStrip);
			}
			var xPixel_min_q = getPixelValueQ(m_chartPointPara.AllowMinPoint.Q);
			var xPixel_max_q = getPixelValueQ(m_chartPointPara.AllowMaxPoint.Q);

			var attr = {
				x: xPixel_min_q,
				y: m_chartSize.DiagramTop,
				width: xPixel_max_q - xPixel_min_q,
				height: m_chartSize.DiagramHeight,
			};
			var style = {
				'stroke-width': '1',
				stroke: 'none',
				fill: 'ForestGreen',
				'stroke-opacity': '0.1',
				'fill-opacity': '0.3',
				'shape-rendering': 'geometricPrecision',
				'zIndex:': -1,
			};
			m_svg.createRect(attr, style, 'ChartRegionAllowRegionStrip');
		}
	};
	//绘制 最优区域
	var calcPerferRegionCurve = function () {
		if (m_chartPointPara == null) return;
		if (m_wrkCurveGrp == null) return;
		if (m_wrkCurveGrp.PixelQH == null) return;
		if (m_chartPointPara.PerferMaxPoint == null) return;
		if (m_chartPointPara.PerferMinPoint == null) return;

		if (!m_chartPointPara.PerferRegionInChartVisible) {
			return;
		}
		if (m_chartPointPara.PerferRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod) {
			//加粗显示

			var pt_num = 11;
			var space = (m_chartPointPara.PerferMaxPoint.Q - m_chartPointPara.PerferMinPoint.Q) / (pt_num - 1);

			var pixelPoints_QH = [];
			var pixelPoints_QE = [];
			var pixelPoints_QP = [];
			let pixelPoints_NPSH = [];

			for (var i = 0; i < pt_num; i++) {
				var q = m_chartPointPara.PerferMinPoint.Q + i * space;
				var xPixel = getPixelValueQ(q);

				var head_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQH, xPixel);
				if (head_pixel_pt != null) pixelPoints_QH.push(head_pixel_pt);
				if (m_isDispCurveQE) {
					var eta_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQE, xPixel);
					if (eta_pixel_pt != null) pixelPoints_QE.push(eta_pixel_pt);
				}

				var power_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQP, xPixel);
				if (power_pixel_pt != null) pixelPoints_QP.push(power_pixel_pt);
			}


			if (m_isDispNpsh && m_wrkCurveGrp.PixelNPSH && m_wrkCurveGrp.PixelNPSH.length > 3) {
				var min_q = Math.max(getPixelValueQ(m_chartPointPara.PerferMinPoint.Q), m_wrkCurveGrp.PixelNPSH[0].Point0.X);
				var max_q = Math.min(
					getPixelValueQ(m_chartPointPara.PerferMaxPoint.Q),
					m_wrkCurveGrp.PixelNPSH[m_wrkCurveGrp.PixelNPSH.length - 1].Point3.X
				);
				//console.log("PixelNPSH", m_wrkCurveGrp.PixelNPSH[0] , getPixelValueQ(m_chartPointPara.AllowMinPoint.Q), min_q);
				space = (max_q - min_q) / (pt_num - 1);
				for (let i = 0; i < pt_num; i++) {
					let xPixel = min_q + i * space;

					var npsh_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelNPSH, xPixel);
					if (npsh_pixel_pt != null) pixelPoints_NPSH.push(npsh_pixel_pt);
					else {
						if (i == 0) pixelPoints_NPSH.push(m_wrkCurveGrp.PixelNPSH[0].Point0);
						else console.log(xPixel);
					}
				}
			}

			var regionBlodCurveQHPerfer = document.getElementById('RegionBlodCurveQH_Perfer');
			if (regionBlodCurveQHPerfer) {
				regionBlodCurveQHPerfer.parentNode.removeChild(regionBlodCurveQHPerfer);
			}
			var regionBlodCurveQPPerfer = document.getElementById('RegionBlodCurveQP_Perfer');
			if (regionBlodCurveQPPerfer) {
				regionBlodCurveQPPerfer.parentNode.removeChild(regionBlodCurveQPPerfer);
			}
			var regionBlodCurveQEPerfer = document.getElementById('RegionBlodCurveQE_Perfer');
			if (regionBlodCurveQEPerfer) {
				regionBlodCurveQEPerfer.parentNode.removeChild(regionBlodCurveQEPerfer);
			}
			var regionBlodCurveNPSHPerfer = document.getElementById('RegionBlodCurveNPSH_Perfer');
			if (regionBlodCurveNPSHPerfer) {
				regionBlodCurveNPSHPerfer.parentNode.removeChild(regionBlodCurveNPSHPerfer);
			}

			createCurveQH_pixel('RegionBlodCurveQH_Perfer', pixelPoints_QH, m_displayStyle.BlodRegionCurveWidth);
			createCurveQE_pixel('RegionBlodCurveQE_Perfer', pixelPoints_QE, m_displayStyle.BlodRegionCurveWidth);
			createCurveQP_pixel('RegionBlodCurveQP_Perfer', pixelPoints_QP, m_displayStyle.BlodRegionCurveWidth);
			createCurveNPSH_pixel('RegionBlodCurveNPSH_Perfer', pixelPoints_NPSH, m_displayStyle.BlodRegionCurveWidth);
		} else if (m_chartPointPara.PerferRegionDispStyle == ConstParas.ChartRegionDispStyle.Strip) {
			// 条带
			var chartRegionPerferRegionStrip = document.getElementById('ChartRegionPerferRegionStrip');
			if (chartRegionPerferRegionStrip) {
				chartRegionPerferRegionStrip.parentNode.removeChild(chartRegionPerferRegionStrip);
			}
			var xPixel_min_q = getPixelValueQ(m_chartPointPara.PerferMinPoint.Q);
			var xPixel_max_q = getPixelValueQ(m_chartPointPara.PerferMaxPoint.Q);

			var attr = {
				x: xPixel_min_q,
				y: m_chartSize.DiagramTop,
				width: xPixel_max_q - xPixel_min_q,
				height: m_chartSize.DiagramHeight,
			};
			var style = {
				'stroke-width': '1',
				stroke: 'none',
				fill: 'ForestGreen',
				'stroke-opacity': '0.1',
				'fill-opacity': '0.3',
				'shape-rendering': 'geometricPrecision',
				'zIndex:': -1,
			};
			m_svg.createRect(attr, style, 'ChartRegionPerferRegionStrip');
		}
	};
	//绘制曲线(流量效率)
	var createCurveQE = function (curveElementName, points, curveWidth, curveColor, curveIsDisp, curveDashType) {
		if (points == null) {
			return null;
		}

		if (curveElementName == null) {
			return null;
		}
		var point_num = points.length;
		if (point_num < 3) return;
		if (curveElementName == 'RegionBlodCurveQE_Allow') {
      console.log('')
		} else if (curveElementName == 'PerferBlodCurveQE_Allow') {
      console.log('')
		} else {
			if (points[0].X < points[point_num - 1].X * 0.01 && points[0].Y < 10) {
				//强制归零
				points[0].X = 0;
				points[0].Y = 0;
			}
		}
		var pixelPoints = [];
		//console.log(points[0]);
		for (var v = 0; v < point_num; v++) {
			var pt = points[v];
			var x = getPixelValueQ(pt.X);
			var y = getPixelValueE(pt.Y);
			pixelPoints.push({ X: x, Y: y });
		}

		return createCurveQE_pixel(curveElementName, pixelPoints, curveWidth, curveColor, curveIsDisp, curveDashType);
	};
	//绘制曲线(流量效率) : 像素点
	var createCurveQE_pixel = function (curveElementName, pixelPoints, curveWidth, curveColor, isDisp, curveDashType) {
		if (pixelPoints == null || pixelPoints.length < 3) {
			return null;
		}
		if (curveElementName == null) {
			return null;
		}
		var pathValue = transBezierCurveToPath(pixelPoints);
		if (pathValue == null || pathValue == undefined) return null;
		//有时会报错，加上这个就没事 tangxu 20151122
		if (pathValue.toString().indexOf('M ,NaN, ,NaN') == 0) {
			return null;
		}
		var style = {
			'stroke-width': '2px',
			stroke: m_displayStyle.ColorE,
			fill: 'none',
			'fill-opacity': '0.5',
			//"stroke-dasharray":"5 3",
			'shape-rendering': 'geometricPrecision',
			'zIndex:': 7,
		};
		if (curveWidth != null) {
			style['stroke-width'] = curveWidth;
		}
		if (curveColor != null) {
			style['stroke'] = curveColor;
		}

		if (curveDashType != null) {
			style['stroke-dasharray'] = curveDashType; //'10, 10';//'10, 10, 5, 5'
		}

		m_svg.createPath(
			curveElementName,
			pathValue.join(''),
			{
				id: curveElementName,
			},
			style
		);
		if (isDisp != null && !isDisp) {
			document.getElementById(curveElementName).style.display = 'none';
		}
		return pixelPoints;
	};
	//绘制曲线(流量功率)
	var createCurveQP = function (curveElementName, points, curveWidth, curveColor, curveIsDisp, curveDashType) {
		if (points == null) {
			return null;
		}
		if (curveElementName == null) {
			return null;
		}

		var pixelPoints = [];
		for (var v = 0; v < points.length; v++) {
			var pt = points[v];
			var x = getPixelValueQ(pt.X);
			var y = getPixelValueP(pt.Y);
			pixelPoints.push({ X: x, Y: y });
		}
		return createCurveQP_pixel(curveElementName, pixelPoints, curveWidth, curveColor, curveIsDisp, curveDashType);
	};
	//绘制曲线(流量功率) : 像素点
	var createCurveQP_pixel = function (curveElementName, pixelPoints, curveWidth, curveColor, curveIsDisp, curveDashType) {
		if (pixelPoints == null || pixelPoints.length < 3) {
			return null;
		}
		if (curveElementName == null) {
			return null;
		}
		var pathValue = transBezierCurveToPath(pixelPoints);
		if (pathValue == null || pathValue == undefined) return null;
		//有时会报错，加上这个就没事 tangxu 20151122
		if (pathValue.toString().indexOf('M ,NaN, ,NaN') == 0) {
			return null;
		}
		var style = {
			'stroke-width': '2px',
			stroke: m_displayStyle.ColorP,
			fill: 'none',
			'fill-opacity': '0.5',
			//"stroke-dasharray":"5 3",
			'shape-rendering': 'geometricPrecision',
			'zIndex:': 7,
		};
		if (curveWidth != null) {
			style['stroke-width'] = curveWidth;
		}
		if (curveColor != null) {
			style['stroke'] = curveColor;
		}
		//m_svg.createPath(curveElementName, pathValue.join(''), {
		//    "id": curveElementName
		//}, style);
		if (curveDashType != null) {
			style['stroke-dasharray'] = curveDashType; //'10, 10';//'10, 10, 5, 5'
		}

		m_svg.createPath(
			curveElementName,
			pathValue.join(''),
			{
				id: curveElementName,
			},
			style
		);
		if (curveIsDisp != null && !curveIsDisp) {
			document.getElementById(curveElementName).style.display = 'none';
		}

		return pixelPoints;
	};
	//绘制曲线(流量汽蚀)
	var createCurveNPSH = function (curveElementName, points, curveWidth, curveColor, curveIsDisp, curveDashType) {
		if (points == null || m_coordinatePara.SpaceNPSH < 0.02) {
			return null;
		}
		if (curveElementName == null) {
			return null;
		}

		var pixelPoints = [];
		for (var v = 0; v < points.length; v++) {
			var pt = points[v];
			var x = getPixelValueQ(pt.X);
			var y = getPixelValueNPSH(pt.Y);
			pixelPoints.push({ X: x, Y: y });
		}

		return createCurveNPSH_pixel(curveElementName, pixelPoints, curveWidth, curveColor, curveIsDisp, curveDashType);
	};
	//绘制曲线(流量功率) : 像素点
	var createCurveNPSH_pixel = function (curveElementName, pixelPoints, curveWidth, curveColor, curveIsDisp, curveDashType) {
		if (pixelPoints == null || pixelPoints.length < 3) {
			return null;
		}
		if (curveElementName == null) {
			return null;
		}
		var pathValue = transBezierCurveToPath(pixelPoints);
		if (pathValue == null || pathValue == undefined) return;
		//有时会报错，加上这个就没事 tangxu 20151122
		if (pathValue.toString().indexOf('M ,NaN, ,NaN') == 0) {
			return;
		}
		var style = {
			'stroke-width': '2px',
			stroke: m_displayStyle.ColorNPSH,
			fill: 'none',
			'fill-opacity': '0.5',
			//"stroke-dasharray":"5 3",
			'shape-rendering': 'geometricPrecision',
			'zIndex:': 7,
		};
		if (curveWidth != null) {
			style['stroke-width'] = curveWidth;
		}
		if (curveColor != null) {
			style['stroke'] = curveColor;
		}
		if (curveDashType != null) {
			style['stroke-dasharray'] = curveDashType; //'10, 10';//'10, 10, 5, 5'
		}
		m_svg.createPath(
			curveElementName,
			pathValue.join(''),
			{
				id: curveElementName,
			},
			style
		);
		if (curveIsDisp != null && !curveIsDisp) {
			document.getElementById(curveElementName).style.display = 'none';
		}
	};
	//清理
	var ClearCurveElement = function () {
		var elements = [
			'SimJieZhiCurveQH',
			'SimJieZhiCurveQE',
			'SimJieZhiCurveQP',
			'SimJieZhiCurveNPSH',
			'SimWaterCurveQH',
			'SimWaterCurveQE',
			'SimWaterCurveQP',
			'SimWaterCurveNPSH',
			'MaxWaterCurveQH',
			'MaxWaterCurveQE',
			'MaxWaterCurveQP',
			'MaxWaterCurveNPSH',
			'MaxD2Text',
			'WrkD2Text',
			'RegionBlodCurveQH_Allow',
			'RegionBlodCurveQP_Allow',
			'RegionBlodCurveQE_Allow',
			'RegionBlodCurveNPSH_Allow',
			'PerferBlodCurveQH_Allow',
			'PerferBlodCurveQP_Allow',
			'PerferBlodCurveQE_Allow',
			'PerferBlodCurveNPSH_Allow',
			'DesignPointWater1',
			'DesignPointWater2',
		];

		elements.forEach(function (id) {
			var element = document.getElementById(id);
			if (element) {
				element.parentNode.removeChild(element);
			}
		});
	};

	//初始化工作曲线
	var intitalWrkCurveInfo = function () {
		m_wrkCurveGrp = {};
		//console.log(m_chartObject)
		if (m_chartObject.SimJieZhiCurveQH != null) {
			m_wrkCurveGrp = {
				RealQH: m_chartObject.SimJieZhiCurveQH,
				RealQE: m_chartObject.SimJieZhiCurveQE,
				RealQP: m_chartObject.SimJieZhiCurveQP,
				RealNPSH: m_chartObject.SimJieZhiCurveNPSH,
			};
		} else if (m_chartObject.SimWaterCurveQH != null) {
			m_wrkCurveGrp = {
				RealQH: m_chartObject.SimWaterCurveQH,
				RealQE: m_chartObject.SimWaterCurveQE,
				RealQP: m_chartObject.SimWaterCurveQP,
				RealNPSH: m_chartObject.SimWaterCurveNPSH,
			};
		} else if (m_chartObject.MaxWaterCurveQH != null) {
			m_wrkCurveGrp = {
				RealQH: m_chartObject.MaxWaterCurveQH,
				RealQE: m_chartObject.MaxWaterCurveQE,
				RealQP: m_chartObject.MaxWaterCurveQP,
				RealNPSH: m_chartObject.MaxWaterCurveNPSH,
			};
		} else {
			return null;
		}

		//通知外部
		if (m_changeWrkCurveCb != null) {
			m_changeWrkCurveCb(m_wrkCurveGrp);
		}
		//console.log(m_wrkCurveGrp,m_changeWrkCurveCb)
		//
		var pixelPoints = [];
		if (m_wrkCurveGrp.RealQH != null) {
			for (var v = 0; v < m_wrkCurveGrp.RealQH.length; v++) {
				var pt = m_wrkCurveGrp.RealQH[v];
				var x = getPixelValueQ(pt.X);
				var y = getPixelValueH(pt.Y);
				pixelPoints.push({ X: x, Y: y });
			}
		}

		m_wrkCurveGrp.PixelQH = transBezierCurveModel(pixelPoints);

		pixelPoints = [];
		if (m_wrkCurveGrp.RealQE != null) {
			for (var v = 0; v < m_wrkCurveGrp.RealQE.length; v++) {
				var pt = m_wrkCurveGrp.RealQE[v];
				var x = getPixelValueQ(pt.X);
				var y = getPixelValueE(pt.Y);
				pixelPoints.push({ X: x, Y: y });
			}
		}

		m_wrkCurveGrp.PixelQE = transBezierCurveModel(pixelPoints);

		pixelPoints = [];
		if (m_wrkCurveGrp.RealQP != null) {
			for (var v = 0; v < m_wrkCurveGrp.RealQP.length; v++) {
				var pt = m_wrkCurveGrp.RealQP[v];
				var x = getPixelValueQ(pt.X);
				var y = getPixelValueP(pt.Y);
				pixelPoints.push({ X: x, Y: y });
			}
		}
		m_wrkCurveGrp.PixelQP = transBezierCurveModel(pixelPoints);

		if (m_wrkCurveGrp.RealNPSH != null && m_wrkCurveGrp.RealNPSH.length > 3) {
			pixelPoints = [];
			for (var v = 0; v < m_wrkCurveGrp.RealNPSH.length; v++) {
				var pt = m_wrkCurveGrp.RealNPSH[v];
				var x = getPixelValueQ(pt.X);
				var y = getPixelValueNPSH(pt.Y);
				pixelPoints.push({ X: x, Y: y });
			}
			m_wrkCurveGrp.PixelNPSH = transBezierCurveModel(pixelPoints);
		}
	};

	//绘制 子切割线
	var drawSubSimuCurveList = function () {
		//
		if (m_chartObject.SpectrumList != null) {
			for (var i = 0; i < m_chartObject.SpectrumList.length; i++) {
				var subSpectrumCurve = m_chartObject.SpectrumList[i];

				createCurveQH('SpectrumList' + i, subSpectrumCurve.QH, 1);
				if (m_displayStyle.IsDispCurveLabel) {
					if (subSpectrumCurve.CurveName == null || subSpectrumCurve.CurveName == '') {
						//if (m_d2IsMeter) {
						//    drawTextByQH("SpectrumListText" + i, subSpectrumCurve.CurvePara + "mm", subSpectrumCurve.QH[0], m_displayStyle.FeatCurveSize,m_displayStyle.ColorH, 6, 5, "start");
						//}
						//else {
						//    drawTextByQH("SpectrumListText" + i, (subSpectrumCurve.CurvePara / 25.4).toFixed(2) + "\"", subSpectrumCurve.QH[0], m_displayStyle.FeatCurveSize,m_displayStyle.ColorH, 6, 5, "start");
						//}
						drawTextByQH(
							'SpectrumListText' + i,
							UnitHelper.getDispValueLength(subSpectrumCurve.CurvePara, m_d2IsMeter, true),
							subSpectrumCurve.QH[0],
							m_displayStyle.FeatCurveSize,
							m_displayStyle.ColorH,
							6,
							5,
							'start'
						);
					} else {
						drawTextByQH(
							'SpectrumListText' + i,
							subSpectrumCurve.CurveName,
							subSpectrumCurve.QH[0],
							m_displayStyle.FeatCurveSize,
							m_displayStyle.ColorH,
							6,
							5,
							'start'
						);
					}
				}
			}
		}
	};
	//绘制等效线
	var drawEquepEtaCurveList = function () {
		//
		if (m_chartObject.EqualParaCurvesE != null) {
			for (var i = 0; i < m_chartObject.EqualParaCurvesE.length; i++) {
				var points = m_chartObject.EqualParaCurvesE[i].PointInfo;
				if (points.length >= 4) {
					//曲线
					createCurveQH('EqualParaCurvesE' + i, points, 1, m_displayStyle.ColorEqualParaCurvesE);
					drawTextByQH(
						'EqualParaCurvesEText' + i,
						m_chartObject.EqualParaCurvesE[i].CurvePara + '%',
						points[0],
						m_displayStyle.EqualCurveSize,
						m_displayStyle.ColorEqualParaCurvesE,
						2,
						6,
						'middle'
					);
				} else if (points.length == 2 || points.length == 3) {
					//直线
					createLineQH('EqualParaCurvesE' + i, points[0], points[1], 1, m_displayStyle.ColorEqualParaCurvesE);
					drawTextByQH(
						'EqualParaCurvesEText' + i,
						m_chartObject.EqualParaCurvesE[i].CurvePara + '%',
						points[0],
						m_displayStyle.EqualCurveSize,
						m_displayStyle.ColorEqualParaCurvesE,
						2,
						6,
						'middle'
					);
				} else if (points.length == 1) {
					createPointQH('EqualParaCurvesE' + i, points[0], 3, m_displayStyle.ColorEqualParaCurvesE);
					drawTextByQH(
						'EqualParaCurvesEText' + i,
						m_chartObject.EqualParaCurvesE[i].CurvePara + '%',
						points[0],
						m_displayStyle.EqualCurveSize,
						m_displayStyle.ColorEqualParaCurvesE,
						2,
						6,
						'middle'
					);
				}
			}
		}
	};
	//切割,全部
	var drawAllCurve_Cut_Full = function () {
		var maxCurveWidth = 2;
		if (m_chartObject.SimWaterCurveQH != null) {
			maxCurveWidth = 1;
		}
		var simuWaterCurveWidth = 2;
		if (m_chartObject.SimJieZhiCurveQH != null) {
			simuWaterCurveWidth = 1;
		}
		//
		var curveMaxPathQH = createCurveQH('MaxWaterCurveQH', m_chartObject.MaxWaterCurveQH, maxCurveWidth);
		if (m_pumpInfo.MaxD2 != null && m_pumpInfo.MaxD2 > 1 && m_displayStyle.IsDispCurveLabel) {
			//叶轮直径(最大)
			drawTextByQH(
				'MaxD2Text',
				UnitHelper.getDispValueLength(m_pumpInfo.MaxD2, m_d2IsMeter, true),
				m_chartObject.MaxWaterCurveQH[0],
				m_displayStyle.FeatCurveSize,
				m_displayStyle.ColorH,
				6,
				5
			);
		}
		//
		createCurveQH('MinWaterCurveQH', m_chartObject.MinWaterCurveQH, 1);
		if (m_chartObject.MinWaterCurveQH != null && m_displayStyle.IsDispCurveLabel && m_pumpInfo.MinD2) {
			//叶轮直径(最小)
			drawTextByQH(
				'MinD2Text',
				UnitHelper.getDispValueLength(m_pumpInfo.MinD2, m_d2IsMeter, true),
				m_chartObject.MinWaterCurveQH[0],
				m_displayStyle.FeatCurveSize,
				m_displayStyle.ColorH,
				6,
				5
			);
		}
		//
		var curveSimuPathQH = createCurveQH('SimWaterCurveQH', m_chartObject.SimWaterCurveQH, simuWaterCurveWidth);
		if (m_chartObject.SimWaterCurveQH != null) {
			//叶轮直径
			if (Math.abs(m_pumpInfo.WrkD2 - m_pumpInfo.MaxD2) > 5) {
				drawTextByQH(
					'WrkD2Text',
					UnitHelper.getDispValueLength(m_pumpInfo.WrkD2, m_d2IsMeter, true),
					m_chartObject.SimWaterCurveQH[0],
					12,
					m_displayStyle.ColorH,
					10,
					5
				);
			}
		}

		//效率
		if (m_isDispCurveQE) {
			if (m_chartObject.SimWaterCurveQE) createCurveQE('SimWaterCurveQE', m_chartObject.SimWaterCurveQE, simuWaterCurveWidth);
			else if (m_chartObject.MaxWaterCurveQE) createCurveQE('MaxWaterCurveQE', m_chartObject.MaxWaterCurveQE, maxCurveWidth);
			//暂时不显示
			//createCurveQE("MinWaterCurveQE", m_chartObject.MinWaterCurveQE, 1);
		}

		//功率
		if (m_chartObject.SimWaterCurveQP) createCurveQP('SimWaterCurveQP', m_chartObject.SimWaterCurveQP, simuWaterCurveWidth);
		else if (m_chartObject.MaxWaterCurveQP) createCurveQP('MaxWaterCurveQP', m_chartObject.MaxWaterCurveQP, maxCurveWidth);
		//createCurveQP("MinWaterCurveQP", m_chartObject.MinWaterCurveQP, 1);

		if (m_chartObject.SimWaterCurveNPSH) createCurveNPSH('SimWaterCurveNPSH', m_chartObject.SimWaterCurveNPSH, simuWaterCurveWidth);
		else if (m_chartObject.MaxWaterCurveNPSH) createCurveNPSH('MaxWaterCurveNPSH', m_chartObject.MaxWaterCurveNPSH, maxCurveWidth);
		//createCurveNPSH("MinWaterCurveNPSH", m_chartObject.MinWaterCurveNPSH, 1);

		if (m_chartObject.SimJieZhiCurveQH != null) {
			createCurveQH('SimJieZhiCurveQH', m_chartObject.SimJieZhiCurveQH, 1, null, true, '10, 10');
			if (m_isDispCurveQE) createCurveQE('SimJieZhiCurveQE', m_chartObject.SimJieZhiCurveQE, 1, null, true, '10, 10');
			createCurveQP('SimJieZhiCurveQP', m_chartObject.SimJieZhiCurveQP, 1, null, true, '10, 10');
		}

		//初始化工作曲线
		intitalWrkCurveInfo();

		//绘制区域
		calcAllowRegionCurve();
		calcPerferRegionCurve();
	};
	//切割,工作曲线
	var drawAllCurve_Cut_Wrk = function () {
		// console.log(m_chartObject,m_chartPointPara)
		var fullCurveWidth = 2;
		if (
			m_chartPointPara.AllowRegionInChartVisible == true ||
			m_chartPointPara.AllowRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod
		) {
			fullCurveWidth = 1;
		}
		if (
			m_chartPointPara.PerferRegionInChartVisible == true ||
			m_chartPointPara.PerferRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod
		) {
			fullCurveWidth = 1;
		}

		if (m_chartObject.SimWaterCurveQH != null) {
			var curveSimuPathQH = createCurveQH('SimWaterCurveQH', m_chartObject.SimWaterCurveQH, fullCurveWidth);

			//叶轮直径
			if (m_pumpInfo.WrkD2 != null && m_pumpInfo.WrkD2 > 1 && m_displayStyle.IsDispCurveLabel) {
				drawTextByQH(
					'WrkD2Text',
					UnitHelper.getDispValueLength(m_pumpInfo.WrkD2, m_d2IsMeter, true),
					m_chartObject.SimWaterCurveQH[0],
					12,
					m_displayStyle.ColorH,
					10,
					5
				);
			}

			if (m_isDispCurveQE) createCurveQE('SimWaterCurveQE', m_chartObject.SimWaterCurveQE, fullCurveWidth);

			createCurveQP('SimWaterCurveQP', m_chartObject.SimWaterCurveQP, fullCurveWidth);

			createCurveNPSH('SimWaterCurveNPSH', m_chartObject.SimWaterCurveNPSH, fullCurveWidth);

			if (m_chartObject.SimJieZhiCurveQH != null) {
				createCurveQH('SimJieZhiCurveQH', m_chartObject.SimJieZhiCurveQH, 1, null, true, '10, 10');
				if (m_isDispCurveQE) createCurveQE('SimJieZhiCurveQE', m_chartObject.SimJieZhiCurveQE, 1, null, true, '10, 10');
				createCurveQP('SimJieZhiCurveQP', m_chartObject.SimJieZhiCurveQP, 1, null, true, '10, 10');
			}
		} else {
			//
			var curveMaxPathQH = createCurveQH('MaxWaterCurveQH', m_chartObject.MaxWaterCurveQH, fullCurveWidth);
			//
			if (m_pumpInfo.WrkD2 != null && m_pumpInfo.WrkD2 > 1 && m_displayStyle.IsDispCurveLabel) {
				//叶轮直径
				drawTextByQH(
					'MaxD2Text',
					UnitHelper.getDispValueLength(m_pumpInfo.WrkD2, m_d2IsMeter, true),
					m_chartObject.MaxWaterCurveQH[0],
					m_displayStyle.FeatCurveSize,
					m_displayStyle.ColorH,
					6,
					5
				);
			}

			if (m_isDispCurveQE) {
				createCurveQE('MaxWaterCurveQE', m_chartObject.MaxWaterCurveQE, fullCurveWidth);
			}

			createCurveQP('MaxWaterCurveQP', m_chartObject.MaxWaterCurveQP, fullCurveWidth);

			createCurveNPSH('MaxWaterCurveNPSH', m_chartObject.MaxWaterCurveNPSH, fullCurveWidth);
		}
		//初始化工作曲线
		intitalWrkCurveInfo();

		calcAllowRegionCurve();
		calcPerferRegionCurve();
	};
	//变频,全部曲线
	var drawAllCurve_Speed_Full = function () {
		var fullCurveWidth = 2;
		if (
			m_chartPointPara.AllowRegionInChartVisible == true ||
			m_chartPointPara.AllowRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod
		) {
			fullCurveWidth = 1;
		}
		if (
			m_chartPointPara.PerferRegionInChartVisible == true ||
			m_chartPointPara.PerferRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod
		) {
			fullCurveWidth = 1;
		}
		var curveMaxPathQH = createCurveQH('MaxWaterCurveQH', m_chartObject.MaxWaterCurveQH, fullCurveWidth);
		if (m_pumpInfo.Ratedn != null && m_pumpInfo.Ratedn > 1 && m_displayStyle.IsDispCurveLabel) {
			//转速
			drawTextByQH('MaxSpeedText', m_pumpInfo.Ratedn + ' rpm', m_chartObject.MaxWaterCurveQH[0], 12, '#28004D', 10, 5);
		}

		if (m_isDispCurveQE) createCurveQE('MaxWaterCurveQE', m_chartObject.MaxWaterCurveQE, fullCurveWidth);

		createCurveQP('MaxWaterCurveQP', m_chartObject.MaxWaterCurveQP, fullCurveWidth);
		createCurveNPSH('MaxWaterCurveNPSH', m_chartObject.MaxWaterCurveNPSH, fullCurveWidth);

		//
		createCurveQH('MinWaterCurveQH', m_chartObject.MinWaterCurveQH, 1);
		if (m_chartType == 0 && m_chartObject.MinWaterCurveQH != null && m_displayStyle.IsDispCurveLabel) {
			//转速
			drawTextByQH('MinSpeedText', m_pumpInfo.MinSpeed + ' rpm', m_chartObject.MinWaterCurveQH[0], 12, '#28004D', 10, 5);
		}

		//暂时不显示
		//m_isDispCurveQE
		//createCurveQE("MinWaterCurveQE", m_chartObject.MinWaterCurveQE, 1);
		//createCurveQP("MinWaterCurveQP", m_chartObject.MinWaterCurveQP, 1);
		//createCurveNPSH("MinWaterCurveNPSH", m_chartObject.MinWaterCurveNPSH, 1);

		var curveMaxPathQH = createCurveQH('SimWaterCurveQH', m_chartObject.SimWaterCurveQH, fullCurveWidth);

		if (m_isDispCurveQE) createCurveQE('SimWaterCurveQE', m_chartObject.SimWaterCurveQE, fullCurveWidth);
		createCurveQP('SimWaterCurveQP', m_chartObject.SimWaterCurveQP, fullCurveWidth);
		createCurveNPSH('SimWaterCurveNPSH', m_chartObject.SimWaterCurveNPSH, fullCurveWidth);

		if (m_chartObject.SimJieZhiCurveQH != null) {
			createCurveQH('SimJieZhiCurveQH', m_chartObject.SimJieZhiCurveQH, 1, null, true, '10, 10');
			if (m_isDispCurveQE) createCurveQE('SimJieZhiCurveQE', m_chartObject.SimJieZhiCurveQE, 1, null, true, '10, 10');
			createCurveQP('SimJieZhiCurveQP', m_chartObject.SimJieZhiCurveQP, 1, null, true, '10, 10');
		}
		//初始化工作曲线
		intitalWrkCurveInfo();

		calcAllowRegionCurve();
		calcPerferRegionCurve();
	};
	//变频,工作曲线
	var drawAllCurve_Speed_Wrk = function () {
		var fullCurveWidth = 2;
		if (
			m_chartPointPara.AllowRegionInChartVisible == true ||
			m_chartPointPara.AllowRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod
		) {
			fullCurveWidth = 1;
		}
		if (
			m_chartPointPara.PerferRegionInChartVisible == true ||
			m_chartPointPara.PerferRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod
		) {
			fullCurveWidth = 1;
		}
		// console.log(m_pumpInfo)
		if (m_chartObject.SimWaterCurveQH != null) {
			var curveSimuPathQH = createCurveQH('SimWaterCurveQH', m_chartObject.SimWaterCurveQH, fullCurveWidth);

			if (m_pumpInfo.WrkSpeed != null && m_pumpInfo.WrkSpeed > 1 && m_displayStyle.IsDispCurveLabel) {
				drawTextByQH('WrkD2Text', m_pumpInfo.WrkSpeed + ' rpm', m_chartObject.SimWaterCurveQH[0], 12, m_displayStyle.ColorH, 10, 5);
			}

			if (m_isDispCurveQE) createCurveQE('SimWaterCurveQE', m_chartObject.SimWaterCurveQE, fullCurveWidth);

			createCurveQP('SimWaterCurveQP', m_chartObject.SimWaterCurveQP, fullCurveWidth);

			createCurveNPSH('SimWaterCurveNPSH', m_chartObject.SimWaterCurveNPSH, fullCurveWidth);

			if (m_chartObject.SimJieZhiCurveQH != null) {
				createCurveQH('SimJieZhiCurveQH', m_chartObject.SimJieZhiCurveQH, 1, null, true, '10, 10');
				if (m_isDispCurveQE) createCurveQE('SimJieZhiCurveQE', m_chartObject.SimJieZhiCurveQE, 1, null, true, '10, 10');
				createCurveQP('SimJieZhiCurveQP', m_chartObject.SimJieZhiCurveQP, 1, null, true, '10, 10');
			}
		} else {
			//
			var curveMaxPathQH = createCurveQH('MaxWaterCurveQH', m_chartObject.MaxWaterCurveQH, fullCurveWidth);
			//  console.log(m_displayStyle,m_pumpInfo.Ratedn)
			if (m_pumpInfo.Ratedn != null && m_pumpInfo.Ratedn > 1 && m_displayStyle.IsDispCurveLabel) {
				drawTextByQH(
					'MaxD2Text',
					m_pumpInfo.Ratedn + ' rpm',
					m_chartObject.MaxWaterCurveQH[0],
					m_displayStyle.FeatCurveSize,
					m_displayStyle.ColorH,
					6,
					5
				);
			}

			if (m_isDispCurveQE) {
				createCurveQE('MaxWaterCurveQE', m_chartObject.MaxWaterCurveQE, fullCurveWidth);
			}

			createCurveQP('MaxWaterCurveQP', m_chartObject.MaxWaterCurveQP, fullCurveWidth);

			createCurveNPSH('MaxWaterCurveNPSH', m_chartObject.MaxWaterCurveNPSH, fullCurveWidth);
		}
		//初始化工作曲线
		intitalWrkCurveInfo();

		calcAllowRegionCurve();
		calcPerferRegionCurve();
	};
	//
	var drawAllCurve_BaoLuo = function () {
		var maxCurveWidth = 2;
		if (
			m_chartPointPara.AllowRegionInChartVisible == true ||
			m_chartPointPara.AllowRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod
		) {
			maxCurveWidth = 1;
		}
		if (
			m_chartPointPara.PerferRegionInChartVisible == true ||
			m_chartPointPara.PerferRegionDispStyle == ConstParas.ChartRegionDispStyle.Blod
		) {
			maxCurveWidth = 1;
		}
		var curveMaxPathQH = createCurveQH('MaxWaterCurveQH', m_chartObject.MaxWaterCurveQH, maxCurveWidth);

		//console.log( m_chartObject.MaxWaterCurveQE)
		if (m_isDispCurveQE) createCurveQE('MaxWaterCurveQE', m_chartObject.MaxWaterCurveQE, maxCurveWidth);

		createCurveQP('MaxWaterCurveQP', m_chartObject.MaxWaterCurveQP, maxCurveWidth);
		createCurveNPSH('MaxWaterCurveNPSH', m_chartObject.MaxWaterCurveNPSH, maxCurveWidth);

		var simuWaterCurveWidth = 2;
		if (m_chartObject.SimJieZhiCurveQH != null) {
			simuWaterCurveWidth = 1;
		}

		if (m_chartObject.SimJieZhiCurveQH != null) {
			createCurveQH('SimJieZhiCurveQH', m_chartObject.SimJieZhiCurveQH, 1, null, true, '10, 10');
			if (m_isDispCurveQE) createCurveQE('SimJieZhiCurveQE', m_chartObject.SimJieZhiCurveQE, 1, null, true, '10, 10');
			createCurveQP('SimJieZhiCurveQP', m_chartObject.SimJieZhiCurveQP, 1, null, true, '10, 10');
		}
		//初始化工作曲线
		intitalWrkCurveInfo();

		calcAllowRegionCurve();
		calcPerferRegionCurve();
	};
	//绘制水印(文字)
	var drawTextWaterMark = function (text) {
		if (!text) {
			return;
		}

		var logoStyle =
			'-webkit-transform: rotate(5deg);-moz-transform: rotate(5deg);transform: rotate(15deg);fill:#000000;fill-opacity:0.6;font-weight:bold;stroke-width:1px;font-size:16px;z-index:0';

		var w = 30;
		var h = 80;
		var isDrawSecond = true;
		var left = (m_chartSize.DiagramRight - m_chartSize.DiagramLeft - text.length * w) / 2;

		for (var i = 0; i < text.length; i++) {
			m_svg.createText(
				{
					opacity: 0.5,
					y: m_chartSize.SpaceTop + h + i * 10,
					x: m_chartSize.DiagramLeft + left + i * w,
				},
				logoStyle,
				text[i],
				0,
				'WaterMarkText1'
			);

			if (isDrawSecond) {
				var endHeight = h + text.length * 10; //: h + text.length * 10 - 80;
				m_svg.createText(
					{
						opacity: 0.5,
						y: m_chartSize.UpDiagram.Bottom - endHeight + i * 10,
						x: m_chartSize.DiagramLeft + left + i * w,
					},
					logoStyle,
					text[i],
					0,
					'WaterMarkText1'
				);
			}
		}
	};

	//绘制水印(图片)
	var drawLogoWaterMark = function () {
		var watermark_img_url = '/static/img/watermark/default.png';

		var img_watermark = new Image();
		img_watermark.src = watermark_img_url;
		img_watermark.onload = function () {
			var watermark_image_width_real = img_watermark.width;
			var watermark_image_height_real = img_watermark.height;

			var ratio_byHeight = (m_chartSize.TotalHeight * 0.2) / watermark_image_height_real;
			var ratio_byWidth = (m_chartSize.TotalWidth * 0.2) / watermark_image_width_real;

			var ratio_waterMark = Math.min(ratio_byHeight, ratio_byWidth);

			var watermark_image_width = watermark_image_width_real * ratio_waterMark;
			var watermark_image_height = watermark_image_height_real * ratio_waterMark;

			var logoStyle =
				'-webkit-transform: rotate(5deg);-moz-transform: rotate(5deg);transform: rotate(15deg);fill:#000000;fill-opacity:0.6;font-weight:bold;stroke-width:1px;font-size:16px;z-index:0';
			var logoPosi1 = {
				opacity: 0.9,
				y: (m_chartSize.TotalHeight * 1) / 4 - watermark_image_height / 2,
				x: (m_chartSize.TotalWidth * 1) / 4 - watermark_image_width / 2,
				width: watermark_image_width,
				height: watermark_image_height,
			};
			m_svg.createImage(logoPosi1, logoStyle, 'WaterMarkImage2', watermark_img_url);

			var logoPosi2 = {
				opacity: 0.9,
				y: (m_chartSize.TotalHeight * 3) / 4 - watermark_image_height / 2,
				x: (m_chartSize.TotalWidth * 1) / 4 - watermark_image_width / 2,
				width: watermark_image_width,
				height: watermark_image_height,
			};
			m_svg.createImage(logoPosi2, logoStyle, 'WaterMarkImage2', watermark_img_url);

			var logoPosi3 = {
				opacity: 0.9,
				y: (m_chartSize.TotalHeight * 1) / 4 - watermark_image_height / 2,
				x: (m_chartSize.TotalWidth * 3) / 4 - watermark_image_width / 2,
				width: watermark_image_width,
				height: watermark_image_height,
			};
			m_svg.createImage(logoPosi3, logoStyle, 'WaterMarkImage3', watermark_img_url);

			var logoPosi4 = {
				opacity: 0.9,
				y: (m_chartSize.TotalHeight * 3) / 4 - watermark_image_height / 2,
				x: (m_chartSize.TotalWidth * 3) / 4 - watermark_image_width / 2,
				width: watermark_image_width,
				height: watermark_image_height,
			};
			m_svg.createImage(logoPosi4, logoStyle, 'WaterMarkImage4', watermark_img_url);
		};
	};
	//产生装置曲线
	var drawEquipmentCurve = function () {
		var equipmentCurveElement = document.getElementById('EquipmentCurve');
		if (equipmentCurveElement) {
			equipmentCurveElement.parentNode.removeChild(equipmentCurveElement);
		}
		if (m_chartObject.EquipmentSectPt == null) return;
		var pointNumber = 20;
		var EquipmentCurve = [];
		var space = m_chartObject.EquipmentSectPt.X / (pointNumber - 1);
		var k = (m_chartObject.EquipmentSectPt.Y - m_equipZeroH) / (m_chartObject.EquipmentSectPt.X * m_chartObject.EquipmentSectPt.X);
		for (var i = 0; i < pointNumber; i++) {
			var pt = {};
			pt.X = space * i;
			pt.Y = m_equipZeroH + k * pt.X * pt.X;
			EquipmentCurve.push(pt);
		}
		createCurveQH('EquipmentCurve', EquipmentCurve, 1, m_displayStyle.ColorEquipment, m_displayStyle.isDispEquipmentCurve);
	};
	//绘制查询竖直指导线
	var drawQueryIndicatVertLine = function () {
		if (document.getElementById('infoDv4VerticalLine') !== null) {
			var infoDiv = document.getElementById('infoDv4VerticalLine');
			if (infoDiv) {
				infoDiv.parentNode.removeChild(infoDiv);
			}
		}

		//先创建用于放置查询信息的Div
		var htmlDiv = "<lable style='font-size:7px'>" + getTranslateString('流量') + '</label>';
		var info_Div = document.createElement('div');
		info_Div.id = 'infoDv4VerticalLine';
		info_Div.style.position = 'relative';
		info_Div.style.color = 'gray';
		info_Div.style.fontSize = '9px';
		info_Div.style.textAlign = 'left';
		info_Div.style.width = '120px';
		info_Div.style.left = (m_chartSize.DiagramRight - 90).toString() + 'px';
		info_Div.style.top = (32 - m_chartSize.TotalHeight).toString() + 'px';
		info_Div.innerHTML = htmlDiv;
		info_Div.style.display = 'none';
		document.getElementById(m_divChartName).appendChild(info_Div);

		m_infoDv4VerticalLine = document.getElementById('infoDv4VerticalLine');

		var attr4verticalLine = {
			stroke: 'rgb(136 136 221)',
			'stroke-width': '5',
			fill: 'none',
			zIndex: 100,
			'stroke-dasharray': '10 3',
			cursor: 'pointer',
			'stroke-opacity': '1',
			'shape-rendering': 'geometricPrecision',
		};

		var xStartValuePixel = (m_chartSize.DiagramLeft + m_chartSize.DiagramRight) / 2; // 开始位置

		//创建竖直线
		var pathValue1 = [];
		var vertialLinePathName1 = 'verticalLine1';
		pathValue1.push(
			'M ',
			xStartValuePixel,
			' ',
			m_chartSize.UpDiagram.Up,
			' L ',
			xStartValuePixel,
			' ',
			m_chartSize.DownDiagram.Bottom
		);
		m_svg.createPath(
			vertialLinePathName1,
			pathValue1.join(''),
			{
				id: vertialLinePathName1,
			},
			attr4verticalLine,
			null
		);

		m_queryInfoIndicatorLineV = document.getElementById(vertialLinePathName1);

		drawQueryDataInfo(xStartValuePixel);

		var isMoveVerticalLine = false;
		//m_svg.getPathByName("verticalLine")

		m_queryInfoIndicatorLineV.addEventListener('mousedown', function (e) {
			isMoveVerticalLine = true;
			e.preventDefault();
		});

		document.addEventListener('mousemove', function (e) {
			if (isMoveVerticalLine) {
				var svg_root = m_svg.getRootNode();
				var svg = document.querySelector(svg_root);

				let e = window.event || e;
				if (
					e.clientX - svg.offset().left > m_chartSize.DiagramLeft &&
					m_chartSize.DiagramRight + svg.offset().left - e.clientX > 0 &&
					e.clientY - svg.offset().top > m_chartSize.DiagramTop &&
					m_chartSize.DiagramBottom + svg.offset().top - e.clientY > 0
				) {
					//当前鼠标位置 x的像素
					var xPixel = parseFloat(e.clientX - svg.offset().left);
					//
					drawQueryDataInfo(xPixel);
					//修改位置
					if (m_queryInfoIndicatorLineV) {
						var pathValue1 = [];
						pathValue1.push('M ', xPixel, ' ', m_chartSize.UpDiagram.Up, ' L ', xPixel, ' ', m_chartSize.DownDiagram.Bottom);
						m_queryInfoIndicatorLineV.attr('d', pathValue1.join(''));
					}
				}
			}
		});
		document.addEventListener('mouseup', function (e) {
			if (isMoveVerticalLine) {
				isMoveVerticalLine = false;
			}
		});

		//设置显示
		setQueryIndicatVertLineVisible(m_dispVerticalLine);
	};
	//获取x在curve的(X Y)点值 (像素点)
	var getBezierPointY = function (curve, x) {
		if (curve == null) return null;
		var iPtCount = curve.length;

		if (x < curve[0].Point0.X - 1) {
			return null;
		}
		if (x > curve[iPtCount - 1].Point3.X + 1) {
			return null;
		}

		for (var i = 0; i < iPtCount; i++) {
			if (x == curve[i].Point0.X) {
				return {
					X: curve[i].Point0.X,
					Y: curve[i].Point0.Y,
				};
			}
			if (x == curve[i].Point3.X) {
				return {
					X: curve[i].Point3.X,
					Y: curve[i].Point3.Y,
				};
			}
			if (x > curve[i].Point0.X && x < curve[i].Point3.X) {
				var ptBizer = curve[i];
				//
				try {
					var minDis = Math.abs(ptBizer.Point3.X - ptBizer.Point0.X);
					var sectY = null;
					var sectX = null;
					for (var uu = 0; uu <= 1; uu = uu + 0.05) {
						var x0 = ptBizer.Point0.X * uu * uu * uu;
						var x1 = 3 * ptBizer.Point1.X * uu * uu * (1 - uu);
						var x2 = 3 * ptBizer.Point2.X * uu * (1 - uu) * (1 - uu);
						var x3 = ptBizer.Point3.X * (1 - uu) * (1 - uu) * (1 - uu);

						var curveX = x0 + x1 + x2 + x3;
						if (Math.abs(curveX - x) < minDis) {
							var y0 = ptBizer.Point0.Y * uu * uu * uu;
							var y1 = 3 * ptBizer.Point1.Y * uu * uu * (1 - uu);
							var y2 = 3 * ptBizer.Point2.Y * uu * (1 - uu) * (1 - uu);
							var y3 = ptBizer.Point3.Y * (1 - uu) * (1 - uu) * (1 - uu);
							minDis = Math.abs(curveX - x);
							sectY = y0 + y1 + y2 + y3;
							sectX = curveX;
						}
					}
					//
					if (sectY != null && sectX != null) {
						return {
							X: sectX,
							Y: sectY,
						};
					}
				} catch (ex) {
					//alert(ex.message);
					console.log('getBezierPointY error', curve, x);
					return null;
				}
			}
		}

		if (x > curve[iPtCount - 1].Point3.X - 1 && x < curve[iPtCount - 1].Point3.X + 5) {
			return {
				X: curve[iPtCount - 1].Point3.X,
				Y: curve[iPtCount - 1].Point3.Y,
			};
		}

		return null;
	};
	//获取x在curve的(X Y)点值 (像素点)
	var getBezierPointX = function (curve, y) {
		if (curve == null) return null;
		var iPtCount = curve.length;

		if (y < curve[0].Point0.Y && y < curve[iPtCount - 1].Point3.Y) {
			return null;
		}
		if (y > curve[0].Point0.Y && y > curve[iPtCount - 1].Point3.Y) {
			return null;
		}

		for (var i = 0; i < iPtCount; i++) {
			var ptBizer = curve[i];

			if (y < ptBizer.Point0.Y && y < ptBizer.Point3.Y) {
				continue;
			}
			if (y > ptBizer.Point0.Y && y > ptBizer.Point3.Y) {
				continue;
			}

			//
			try {
				var minDis = Math.abs(ptBizer.Point3.Y - ptBizer.Point0.Y);

				var sectY = null;
				var sectX = null;
				for (var uu = 0; uu <= 1; uu = uu + 0.05) {
					var x0 = ptBizer.Point0.X * uu * uu * uu;
					var x1 = 3 * ptBizer.Point1.X * uu * uu * (1 - uu);
					var x2 = 3 * ptBizer.Point2.X * uu * (1 - uu) * (1 - uu);
					var x3 = ptBizer.Point3.X * (1 - uu) * (1 - uu) * (1 - uu);

					var y0 = ptBizer.Point0.Y * uu * uu * uu;
					var y1 = 3 * ptBizer.Point1.Y * uu * uu * (1 - uu);
					var y2 = 3 * ptBizer.Point2.Y * uu * (1 - uu) * (1 - uu);
					var y3 = ptBizer.Point3.Y * (1 - uu) * (1 - uu) * (1 - uu);

					var curveX = x0 + x1 + x2 + x3;
					var curveY = y0 + y1 + y2 + y3;

					if (Math.abs(curveY - y) < minDis) {
						minDis = Math.abs(curveY - y);
						sectY = curveY;
						sectX = curveX;
					}
				}
				//
				if (sectY != null && sectX != null) {
					return {
						X: sectX,
						Y: sectY,
					};
				}
			} catch (ex) {
				//alert(ex.message);
				return null;
			}
		}

		return null;
	};
	//绘制/显示 参数查询信息
	var drawQueryDataInfo = function (xPixel) {
		//x的像素
		if (xPixel == null) return;
		if (m_wrkCurveGrp == null) return;
		if (m_wrkCurveGrp.PixelQH == null) return;
		//流量
		//console.log(m_coordinatePara,m_chartSize, xPixel);
		let flow_stdUnit = getActualValueQ(xPixel);
		if (flow_stdUnit == null) return;
		//console.log(flow_stdUnit);
		if (flow_stdUnit < 0.1) return;

		var flow_info = {};
		flow_info.text = getTranslateString('流量');
		flow_info.value = UnitHelper.getDispValueQ(UnitHelper.ConvertQ_fromM3H(m_unit.Q, flow_stdUnit));
		flow_info.unit = UnitHelper.GetUnitNameQ(m_unit.Q);
		if (flow_info.value == null || flow_info.value == '') return;
		// console.log(flow_info);

		//扬程
		var head_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQH, xPixel);
		if (head_pixel_pt == null) return;
		var head_stdUnit = getActualValueH(head_pixel_pt.Y);
		var head_info = {};
		head_info.text = getTranslateString('扬程');
		head_info.unit = UnitHelper.GetUnitNameH(m_unit.H);
		head_info.value = UnitHelper.getDispValueH(UnitHelper.ConvertH_fromM(m_unit.H, head_stdUnit));

		//效率
		var eff_info = {};
		eff_info.value = '';
		if (m_isDispCurveQE) {
			var eta_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQE, xPixel);
			//console.log(" 1875 eta_pixel_pt",m_wrkCurveGrp.PixelQE,xPixel,eta_pixel_pt)
			if (eta_pixel_pt != null) {
				var eta_stdUnit = getActualValueE(eta_pixel_pt.Y);

				eff_info.text = getTranslateString('效率');
				eff_info.value = parseFloat(eta_stdUnit.toFixed(1));
				eff_info.unit = '%';
			}
		}

		//功率
		var power_info = {};
		power_info.value = '';
		var power_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQP, xPixel);
		if (power_pixel_pt != null) {
			var power_stdUnit = getActualValueP(power_pixel_pt.Y);
			power_info.text = getTranslateString('功率');
			power_info.value = UnitHelper.getDispValueP(UnitHelper.ConvertP_fromKW(m_unit.P, power_stdUnit));
			power_info.unit = UnitHelper.GetUnitNameP(m_unit.P);
		}

		var npsh_info = {}; //汽蚀
		npsh_info.text = getTranslateString('汽蚀');
		npsh_info.value = '';
		npsh_info.unit = 'm';

		if (m_wrkCurveGrp.PixelNPSH != null && m_isDispNpsh) {
			var npsh_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelNPSH, xPixel);
			//console.log(npsh_pixel_pt)
			if (npsh_pixel_pt != null) {
				npsh_info.unit = UnitHelper.GetUnitNameNPSH(m_unit.NPSH);
				var npsh_stdUnit = getActualValueNPSH(npsh_pixel_pt.Y);
				npsh_info.value = UnitHelper.getDispValueNPSH(UnitHelper.ConvertNPSH_fromM(npsh_stdUnit));
			}
		}

		var tip_html = '';
		var flow_html = flow_info.text + ': &nbsp;&nbsp;' + flow_info.value + '&nbsp;&nbsp;' + flow_info.unit;
		tip_html = flow_html;
		//console.log("flow_info",flow_info);

		var head_html = head_info.text + ': &nbsp;&nbsp;' + head_info.value + '&nbsp;&nbsp;' + head_info.unit;
		tip_html += '</br>' + head_html;
		//console.log("head_info",head_info);

		if (eff_info.value != '') {
			var eff_html = eff_info.text + ': &nbsp;&nbsp;' + eff_info.value + '&nbsp;&nbsp;' + eff_info.unit;
			tip_html += '</br>' + eff_html;
		}

		if (power_info.value != '') {
			var power_html = power_info.text + ': &nbsp;&nbsp;' + power_info.value + '&nbsp;&nbsp;' + power_info.unit;
			tip_html += '</br>' + power_html;
		}

		if (npsh_info.value != '') {
			var npsh_html = npsh_info.text + ': &nbsp;&nbsp;' + npsh_info.value + '&nbsp;&nbsp;' + npsh_info.unit;
			tip_html += '</br>' + npsh_html;
		}

		m_infoDv4VerticalLine.style.display = 'block';
		m_infoDv4VerticalLine.innerHTML = tip_html;

		//获取查询曲线查询得到的数据 给参数查询使用
		if (onChangeQueryDataCb != null) {
			onChangeQueryDataCb({
				Q: flow_info,
				H: head_info,
				E: eff_info,
				P: power_info,
				NPSH: npsh_info,
			});
		}
	};
	//根据流量获取点
	var getGrpPointInWrkCurveByFlow = function (flow_stdUnit) {
		if (flow_stdUnit == null) return null;
		if (flow_stdUnit < 0.1) return null;

		//var UnitHelper.ConvertQ_fromM3H(m_unit.Q, flow_stdUnit)
		var xPixel = getPixelValueQ(flow_stdUnit);

		//扬程
		var head_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQH, xPixel);
		if (head_pixel_pt == null) return;
		var head_stdUnit = getActualValueH(head_pixel_pt.Y);

		//效率
		var eta_stdUnit = 0;
		if (m_isDispCurveQE) {
			var eta_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQE, xPixel);
			if (eta_pixel_pt != null) {
				eta_stdUnit = getActualValueE(eta_pixel_pt.Y);
				eta_stdUnit = parseFloat(eta_stdUnit.toFixed(1));
			}
		}

		//功率
		var power_stdUnit = 0;
		var power_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQP, xPixel);
		if (power_pixel_pt != null) {
			power_stdUnit = getActualValueP(power_pixel_pt.Y);
		}

		var npsh_stdUnit = 0;
		if (m_wrkCurveGrp.PixelNPSH != null) {
			var npsh_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelNPSH, xPixel);
			if (npsh_pixel_pt != null) {
				npsh_stdUnit = getActualValueNPSH(npsh_pixel_pt.Y);
			}
		}

		var grp_pt = {};
		grp_pt.Q = flow_stdUnit;
		grp_pt.H = head_stdUnit;
		grp_pt.E = eta_stdUnit;
		grp_pt.P = power_stdUnit;
		grp_pt.NPSH = npsh_stdUnit;

		return grp_pt;
	};
	//查询线
	var m_infoDv4VerticalLine;
	var m_queryInfoIndicatorLineV;
	var m_dispVerticalLine = false;
	var onChangeQueryDataCb = null; //查询外部回调
	//设置是否显示
	var setQueryIndicatVertLineVisible = function (disp) {
		m_dispVerticalLine = disp;
		if (disp) {
      m_infoDv4VerticalLine.style.display = 'block';
      m_queryInfoIndicatorLineV.style.display = 'block';
		} else {
      m_infoDv4VerticalLine.style.display = 'none';
      m_queryInfoIndicatorLineV.style.display = 'none';
		}
	};
	//绘制图表(核心代码)
	var drawChart = function () {
		//面板(含坐标)
		drawDiagramPanel();

		//绘制线
		if (m_chartType == ConstParas.ChartType.Cut) {
			if (m_displayStyle.IsOnlyDispWrkCurve) {
				drawAllCurve_Cut_Wrk();
			} else {
				//绘制型谱
				drawSpectrumShape();
				drawAllCurve_Cut_Full();
			}
		} else if (m_chartType == ConstParas.ChartType.Speed) {
			if (m_displayStyle.IsOnlyDispWrkCurve) {
				drawAllCurve_Speed_Wrk();
			} else {
				//绘制型谱
				drawSpectrumShape();
				drawAllCurve_Speed_Full();
			}
		} else if (m_chartType == ConstParas.ChartType.BaoLuo) {
			drawAllCurve_BaoLuo();
		} else return;

		//设计点
		drawDesignPoint();

		//绘制水印
		drawLogoWaterMark();

		//装置曲线
		drawEquipmentCurve();

		//查询指示线
		drawQueryIndicatVertLine();

		//
		// createMouseTipInfo();
	};
	//
	var createGridLineDiagram_Whole = function () {
		if (m_coordinatePara == null) {
			return;
		}

		var attr = {
			stroke: m_displayStyle.ColorGridLine,
			'stroke-width': '1',
			fill: 'none',
			zIndex: 10,
		};

		//产生网格线竖直方向
		for (var i = 0; i <= m_coordinatePara.GridNumberX; i++) {
			var distance = m_chartSize.SpaceGridX * i;
			var valueTemp = [];
			valueTemp.push(
				'M ',
				m_chartSize.DiagramLeft + distance,
				' ',
				m_chartSize.SpaceTop,
				' L ',
				m_chartSize.DiagramLeft + distance,
				' ',
				m_chartSize.UpDiagram.Bottom
			);
			m_svg.createPath(null, valueTemp.join(''), attr, null);
		}

		//产生网格线水平方向
		for (let i = 0; i <= m_coordinatePara.GridNumberY; i++) {
			let distance = m_chartSize.UpDiagram.SpaceGridY * i;
			let valueTemp = [];
			valueTemp.push(
				'M ',
				m_chartSize.DiagramLeft,
				' ',
				m_chartSize.SpaceTop + distance,
				' L ',
				m_chartSize.DiagramRight,
				' ',
				m_chartSize.SpaceTop + distance
			);
			m_svg.createPath(null, valueTemp.join(''), attr, null);
		}
	};
	//绘制面板(分离)
	var createGridLineDiagram_TwoPanel = function () {
		if (m_coordinatePara == null) {
			return;
		}

		var attr = {
			stroke: m_displayStyle.ColorGridLine,
			'stroke-width': '1',
			fill: 'none',
			zIndex: 10,
		};

		//产生网格线竖直方向
		for (var i = 0; i <= m_coordinatePara.GridNumberX; i++) {
			var distance = m_chartSize.SpaceGridX * i;
			var valueTemp = [];
			valueTemp.push(
				'M ',
				m_chartSize.DiagramLeft + distance,
				' ',
				m_chartSize.UpDiagram.Up,
				' L ',
				m_chartSize.DiagramLeft + distance,
				' ',
				m_chartSize.UpDiagram.Bottom
			);
			m_svg.createPath(null, valueTemp.join(''), attr, null);

			//console.log(m_chartSize.DiagramLeft + distance , m_chartSize.UpDiagram.Up,   m_chartSize.DiagramLeft + distance,   m_chartSize.UpDiagram.Bottom)
		}

		for (let i = 0; i <= m_coordinatePara.GridNumberX; i++) {
			let distance = m_chartSize.SpaceGridX * i;
			let valueTemp = [];
			valueTemp.push(
				'M ',
				m_chartSize.DiagramLeft + distance,
				' ',
				m_chartSize.DownDiagram.Up,
				' L ',
				m_chartSize.DiagramLeft + distance,
				' ',
				m_chartSize.DownDiagram.Bottom
			);
			m_svg.createPath(null, valueTemp.join(''), attr, null);
		}

		//产生网格线水平方向
		for (let i = 0; i <= m_chartSize.UpDiagram.GridNumberY; i++) {
			let distance = m_chartSize.UpDiagram.SpaceGridY * i;
			let valueTemp = [];
			valueTemp.push(
				'M ',
				m_chartSize.DiagramLeft,
				' ',
				m_chartSize.UpDiagram.Up + distance,
				' L ',
				m_chartSize.DiagramRight,
				' ',
				m_chartSize.UpDiagram.Up + distance
			);
			m_svg.createPath(null, valueTemp.join(''), attr, null);
		}

		for (let i = 0; i <= m_chartSize.DownDiagram.GridNumberY; i++) {
			let distance = m_chartSize.DownDiagram.SpaceGridY * i;
			let valueTemp = [];
			valueTemp.push(
				'M ',
				m_chartSize.DiagramLeft,
				' ',
				m_chartSize.DownDiagram.Up + distance,
				' L ',
				m_chartSize.DiagramRight,
				' ',
				m_chartSize.DownDiagram.Up + distance
			);
			m_svg.createPath(null, valueTemp.join(''), attr, null);
		}
	};
	//转成Bezier曲线模型
	var transBezierCurveModel = function (pixelPoints) {
		if (pixelPoints == null || pixelPoints.length < 4) return null;

		var iPointCout = pixelPoints.length;
		var a = 0.09;
		var b = 0.09;
		var controlPoint = [];

		for (var i = 0; i < iPointCout - 1; i++) {
			var bezier = {};
			bezier.Point0 = pixelPoints[i];
			if (i == 0) {
				let x1 = pixelPoints[i].X + a * (pixelPoints[i + 1].X - pixelPoints[i].X);
				let y1 = pixelPoints[i].Y + a * (pixelPoints[i + 1].Y - pixelPoints[i].Y);
				bezier.Point1 = {
					X: x1,
					Y: y1,
				};
			} else {
				let x1 = pixelPoints[i].X + a * (pixelPoints[i + 1].X - pixelPoints[i - 1].X);
				let y1 = pixelPoints[i].Y + a * (pixelPoints[i + 1].Y - pixelPoints[i - 1].Y);
				bezier.Point1 = {
					X: x1,
					Y: y1,
				};
			}

			if (i == iPointCout - 2) {
				let x2 = pixelPoints[i + 1].X - b * (pixelPoints[i + 1].X - pixelPoints[i].X);
				let y2 = pixelPoints[i + 1].Y - b * (pixelPoints[i + 1].Y - pixelPoints[i].Y);
				bezier.Point2 = {
					X: x2,
					Y: y2,
				};
			} else {
				let x2 = pixelPoints[i + 1].X - b * (pixelPoints[i + 2].X - pixelPoints[i].X);
				let y2 = pixelPoints[i + 1].Y - b * (pixelPoints[i + 2].Y - pixelPoints[i].Y);
				bezier.Point2 = {
					X: x2,
					Y: y2,
				};
			}

			bezier.Point3 = pixelPoints[i + 1];
			controlPoint.push(bezier);
		}
		return controlPoint;
	};

	//转成曲线路径
	var transBezierCurveToPath = function (pixelPoints) {
		var bezierCurveValue = transBezierCurveModel(pixelPoints);
		if (bezierCurveValue == null) {
			return;
		}
		var pathValue = [];
		for (var i = 0; i < bezierCurveValue.length; i++) {
			var b_pt = bezierCurveValue[i];
			if (i == 0) {
				pathValue.push('M ', b_pt.Point0.X, ' ', b_pt.Point0.Y);
				pathValue.push(
					' C ',
					b_pt.Point1.X,
					' ',
					b_pt.Point1.Y,
					' ',
					b_pt.Point2.X,
					' ',
					b_pt.Point2.Y,
					' ',
					b_pt.Point3.X,
					' ',
					b_pt.Point3.Y
				);
			} else {
				pathValue.push(' L ', b_pt.Point0.X, ' ', b_pt.Point0.Y);
				pathValue.push(
					' C ',
					b_pt.Point1.X,
					' ',
					b_pt.Point1.Y,
					' ',
					b_pt.Point2.X,
					' ',
					b_pt.Point2.Y,
					' ',
					b_pt.Point3.X,
					' ',
					b_pt.Point3.Y
				);
			}
			if (i == bezierCurveValue.length - 1) {
				pathValue.push(' L ', b_pt.Point3.X, ' ', b_pt.Point3.Y);
			}
		}
		return pathValue;
	};

	//返回标准单位下的值
	var getActualValueQ = function (pixelValue) {
		var actualMinValue = m_coordinatePara.DispMinQ;
		var actualMaxValue = m_coordinatePara.DispMaxQ;
		var pixelMinValue = m_chartSize.DiagramLeft;
		var pixelMaxValue = m_chartSize.DiagramRight;
		return ((pixelValue - pixelMinValue) / (pixelMaxValue - pixelMinValue)) * (actualMaxValue - actualMinValue) + actualMinValue;
	};
	var getActualValueH = function (pixelValue) {
		var actualMinValue = m_coordinatePara.DispMinH;
		var actualMaxValue = m_coordinatePara.DispMaxH;
		var pixelMinValue = m_chartSize.PanelH.Bottom;
		var pixelMaxValue = m_chartSize.PanelH.Up;

		var actualValue =
			((pixelValue - pixelMinValue) / (pixelMaxValue - pixelMinValue)) * (actualMaxValue - actualMinValue) + actualMinValue;
		//console.log("getActualValueH", actualValue, actualMinValue,actualMaxValue,pixelMinValue,pixelMaxValue);

		return actualValue;
	};
	var getActualValueE = function (pixelValue) {
		var actualMinValue = m_coordinatePara.DispMinE;
		var actualMaxValue = m_coordinatePara.DispMaxE;
		var pixelMinValue = m_chartSize.PanelE.Bottom;
		var pixelMaxValue = m_chartSize.PanelE.Up;

		var actualValue =
			((pixelValue - pixelMinValue) / (pixelMaxValue - pixelMinValue)) * (actualMaxValue - actualMinValue) + actualMinValue;
		//console.log("getActualValueE",actualValue, actualMinValue,actualMaxValue,pixelMinValue,pixelMaxValue);

		return actualValue;
	};
	var getActualValueP = function (pixelValue) {
		var actualMinValue = m_coordinatePara.DispMinP;
		var actualMaxValue = m_coordinatePara.DispMaxP;
		var pixelMinValue = m_chartSize.PanelP.Bottom;
		var pixelMaxValue = m_chartSize.PanelP.Up;
		return ((pixelValue - pixelMinValue) / (pixelMaxValue - pixelMinValue)) * (actualMaxValue - actualMinValue) + actualMinValue;
	};
	var getActualValueNPSH = function (pixelValue) {
		var actualMinValue = m_coordinatePara.DispMinNPSH;
		var actualMaxValue = m_coordinatePara.DispMaxNPSH;
		var pixelMinValue = m_chartSize.PanelNPSH.Bottom;
		var pixelMaxValue = m_chartSize.PanelNPSH.Up;
		var actualValue =
			((pixelValue - pixelMinValue) / (pixelMaxValue - pixelMinValue)) * (actualMaxValue - actualMinValue) + actualMinValue;
		// console.log("getActualValueNPSH",actualValue, actualMinValue,actualMaxValue,pixelMinValue,pixelMaxValue);
		return actualValue;
	};

	//  actualValue 是标准单位下的值
	var getPixelValueQ = function (actualValue) {
		var actualMinValue = m_coordinatePara.DispMinQ;
		var actualMaxValue = m_coordinatePara.DispMaxQ;
		var pixelMinValue = m_chartSize.DiagramLeft;
		var pixelMaxValue = m_chartSize.DiagramRight;

		return ((actualValue - actualMinValue) / (actualMaxValue - actualMinValue)) * (pixelMaxValue - pixelMinValue) + pixelMinValue;
	};
	var getPixelValueH = function (actualValue) {
		var actualMinValue = m_coordinatePara.DispMinH;
		var actualMaxValue = m_coordinatePara.DispMaxH;
		var pixelMinValue = m_chartSize.PanelH.Bottom;
		var pixelMaxValue = m_chartSize.PanelH.Up;

		if (actualMaxValue == actualMinValue) return actualMinValue;

		var v = ((actualValue - actualMinValue) / (actualMaxValue - actualMinValue)) * (pixelMaxValue - pixelMinValue) + pixelMinValue;
		//console.log("getPixelValueH",actualValue,v,  actualMinValue,actualMaxValue,pixelMinValue,pixelMaxValue);
		return v;
	};
	var getPixelValueE = function (actualValue) {
		var actualMinValue = m_coordinatePara.DispMinE;
		var actualMaxValue = m_coordinatePara.DispMaxE;
		var pixelMinValue = m_chartSize.PanelE.Bottom;
		var pixelMaxValue = m_chartSize.PanelE.Up;
		if (actualMaxValue == actualMinValue) return actualMinValue;

		return ((actualValue - actualMinValue) / (actualMaxValue - actualMinValue)) * (pixelMaxValue - pixelMinValue) + pixelMinValue;
	};
	var getPixelValueP = function (actualValue) {
		var actualMinValue = m_coordinatePara.DispMinP;
		var actualMaxValue = m_coordinatePara.DispMaxP;
		var pixelMinValue = m_chartSize.PanelP.Bottom;
		var pixelMaxValue = m_chartSize.PanelP.Up;
		if (actualMaxValue == actualMinValue) return actualMinValue;

		return ((actualValue - actualMinValue) / (actualMaxValue - actualMinValue)) * (pixelMaxValue - pixelMinValue) + pixelMinValue;
	};
	var getPixelValueNPSH = function (actualValue) {
		var actualMinValue = m_coordinatePara.DispMinNPSH;
		var actualMaxValue = m_coordinatePara.DispMaxNPSH;
		var pixelMinValue = m_chartSize.PanelNPSH.Bottom;
		var pixelMaxValue = m_chartSize.PanelNPSH.Up;
		if (actualMaxValue == actualMinValue) return actualMinValue;

		return ((actualValue - actualMinValue) / (actualMaxValue - actualMinValue)) * (pixelMaxValue - pixelMinValue) + pixelMinValue;
	};

	/**       ----------------对外函数--------------------    **/

	//设置设计点公差
	this.SetUnit = function (unitQ, unitH, unitP, unitNPSH) {
		m_unit.Q = unitQ;
		m_unit.H = unitH;
		m_unit.P = unitP;
		if (unitNPSH > 0) {
			m_unit.NPSH = unitNPSH;
		} else {
			m_unit.NPSH = 0;
		}
	};
	//设置是否是单色显示
	this.setMonorColor = function (isMonorColor) {
		document.getElementById(m_divChartName).innerHTML = '';
		setObjectColor(isMonorColor);
		if (!initialSvg()) return;

		drawChart();
	};
	//设置是否是单色显示
	this.setOnlyWrkCurve = function (isOnlyWrkCurve) {
		m_displayStyle.IsOnlyDispWrkCurve = isOnlyWrkCurve;
		//console.log(m_displayStyle)
		document.getElementById(m_divChartName).innerHTML = '';

		if (!initialSvg()) return;

		drawChart();
	};
	//设置是否显示型谱
	this.setSpectrumDisp = function (isDisp) {
		m_displayStyle.IsDispSpectrum = isDisp;
		drawSpectrumShape();
	};
	//设置容器
	this.setContainerDiv = function (divChartName, divWidth, divHeight) {
		m_divChartName = divChartName;

		if (m_chartSize == null) {
			m_chartSize = {};
		}

		if (divWidth != null) {
			m_chartSize.TotalWidth = divWidth;
		} else {
			m_chartSize.TotalWidth = document.getElementById(divChartName).clientWidth;
		}

		if (divHeight != null) {
			m_chartSize.TotalHeight = divHeight;
		} else {
			m_chartSize.TotalHeight = document.getElementById(divChartName).clientHeight;
		}
	};
	//设置语言
	this.setLocalizationType = function (localizationType) {
		m_localizationType = localizationType;
		//console.log("localizationType:"+localizationType)
	};
	//设置工具提示栏
	this.setToolTipName = function (toolTipName) {
		m_toolTipContent = document.getElementById(toolTipName);
	};
	//获取查询曲线查询得到的数据 给参数查询使用
	this.setChangeQueryDataCb = function (cb) {
		onChangeQueryDataCb = cb;
	};
	this.setQueryIndicatVertLineVisible = function (isVisible) {
		setQueryIndicatVertLineVisible(isVisible);
	};
	this.getQueryIndicatVertLineVisible = function () {
		return m_dispVerticalLine;
	};

	//初始化图表(入口)
	this.initialChart = function (chartFullInfo, displayStyle, cbDict) {
		if (!m_divChartName) return;
		//console.log("initialChart chartFullInfo", chartFullInfo)
		//清空
		document.getElementById(m_divChartName).innerHTML = '';

		if (chartFullInfo.ChartObjectDict == null) return;
		if (chartFullInfo.ChartObjectDict.Coordinate == null) return;

		m_designPointTolerance = PointToleranceConfig.GetDefaultTolerancePara();

		m_chartType = chartFullInfo.BaseInfo.ChartType;
		//console.log("m_chartType", m_chartType)
		m_pumpInfo = chartFullInfo.BaseInfo;
		m_chartPointPara = chartFullInfo.ChartPointPara;
		m_chartSetting = chartFullInfo.SettingInfo;
		m_chartObject = chartFullInfo.ChartObjectDict;
		m_coordinatePara = chartFullInfo.ChartObjectDict.Coordinate; //extend(m_coordinatePara, chartFullInfo.Coordinate);

		this.SetUnit(
			//设置单位
			m_chartSetting.UnitQ,
			m_chartSetting.UnitH,
			m_chartSetting.UnitP,
			m_chartSetting.UnitNPSH
		);
		//console.log(chartFullInfo.SettingInfo)
		//console.log(this.m_coordinatePara,"cccc")

		if (m_chartSetting != null) {
			if (m_chartSetting.IsDispCurveQE != null) {
				m_isDispCurveQE = m_chartSetting.IsDispCurveQE;
			}
			m_d2IsMeter = m_chartSetting ? m_chartSetting.IsD2Meter : true;
		}

		//初始化显示设置
		initialDispStyle(displayStyle, m_chartSetting);

		//
		m_chartDiagramPanelStyle = ConstParas.ChartDiagramPanelStyle.Two;

		//设置各种回调函数
		if (cbDict != null) {
			m_changeWrkCurveCb = cbDict.setChangeWrkCurveCb; //设置曲线修改回调函数
		}

		//计算第二坐标
		calcSecondFlowCoordParas();

		//初始化面板尺寸
		initialPanelSize();

		// console.log(m_displayStyle,m_coordinatePara)

		drawChart();

		return this;
	};
	//修改了区域点
	this.refreshRegionByFlow = function (std_unit_flow, tag) {
		if (tag == null) return null;
		var pt = getGrpPointInWrkCurveByFlow(std_unit_flow);
		if (pt != null) {
			refreshRegionPtPosi(pt, tag);
		}
		return pt;
	};
	//根据流量计算功率
	this.calcPowerByFlow = function (flow, unit) {
		if (flow == null || m_wrkCurveGrp == null) return null;
		var flow_stdUnit = UnitHelper.ConvertQ_toM3H(unit, flow);
		if (flow_stdUnit < 0.1) return null;
		//console.log("flow_stdUnit", flow_stdUnit, unit, flow)
		var xPixel = getPixelValueQ(flow_stdUnit);
		var power_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQP, xPixel);
		if (power_pixel_pt != null) {
			var power = getActualValueP(power_pixel_pt.Y);
			// console.log("flow_power", flow_stdUnit, power.toFixed(2) )
			return power.toFixed(2);
		} else {
			return null;
		}
	};
	//根据流量计算效率
	this.calcEtaByFlow = function (flow, unit) {
		if (flow == null || m_wrkCurveGrp == null) return null;
		var flow_stdUnit = UnitHelper.ConvertQ_toM3H(unit, flow);
		if (flow_stdUnit < 0.1) return null;
		//console.log("flow_stdUnit", flow_stdUnit, unit, flow)
		var xPixel = getPixelValueQ(flow_stdUnit);
		var power_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQE, xPixel);
		if (power_pixel_pt != null) {
			var power = getActualValueE(power_pixel_pt.Y);
			//console.log("flow_power", power.toFixed(2) )
			return power.toFixed(2);
		} else {
			return null;
		}
	};
	//设置水印图片路径
	this.setWatermarkImageUrl = function (img_path) {};
	//修改了设计点
	this.refreshByDp = function (response) {
		//
		var ChartInfo = response.ChartObjectDict;
		//   console.log(response )

		m_chartPointPara = response.ChartPointPara;

		m_chartObject.EquipmentSectPt = ChartInfo.EquipmentSectPt;
		m_chartObject.SimWaterCurveQH = ChartInfo.SimWaterCurveQH;
		m_chartObject.SimWaterCurveQE = ChartInfo.SimWaterCurveQE;
		m_chartObject.SimWaterCurveQP = ChartInfo.SimWaterCurveQP;
		m_chartObject.SimWaterCurveNPSH = ChartInfo.SimWaterCurveNPSH;

		m_chartObject.SimJieZhiCurveQH = ChartInfo.SimJieZhiCurveQH;
		m_chartObject.SimJieZhiCurveQE = ChartInfo.SimJieZhiCurveQE;
		m_chartObject.SimJieZhiCurveQP = ChartInfo.SimJieZhiCurveQP;
		m_chartObject.SimJieZhiCurveNPSH = ChartInfo.SimJieZhiCurveNPSH;

		m_chartObject.DesignPoint4StdUnit = ChartInfo.DesignPoint4StdUnit;

		ClearCurveElement();

		if (m_chartType == ConstParas.ChartType.Cut) {
			m_pumpInfo.WrkD2 = response.BaseInfo.WrkD2;

			if (m_displayStyle.IsOnlyDispWrkCurve) drawAllCurve_Cut_Wrk();
			else drawAllCurve_Cut_Full();
		} else if (m_chartType == ConstParas.ChartType.Speed) {
			m_pumpInfo.WrkSpeed = response.BaseInfo.WrkSpeed;

			if (m_displayStyle.IsOnlyDispWrkCurve) drawAllCurve_Speed_Wrk();
			else drawAllCurve_Speed_Full();
		} else if (m_chartType == ConstParas.ChartType.BaoLuo) {
			drawAllCurve_BaoLuo();
		} else return;

		//设计点
		drawDesignPoint();

		//装置曲线
		drawEquipmentCurve();
	};
	//重绘图表大小
	this.Resize = function (widht, height) {
		if (widht && widht > 0) m_chartSize.TotalWidth = widht;
		if (height && height > 0) m_chartSize.TotalHeight = height;

		document.getElementById(m_divChartName).innerHTML = '';

		//计算第二坐标
		//calcSecondFlowCoordParas();

		//初始化面板
		initialPanelSize();

		drawChart();
	};
};

export default LxpChartDiagram;