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";
import languageHelper from "@/utils/languageHelper.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_equipCurve = {
    //装置曲线
    isVisble: false,
    ZeroH: 0,
    DpSectPt: null,
  };
  var m_chartType; //类型
  var m_pumpInfo; //基本信息
  var m_chartPointPara;
  var m_chartObject;
  var m_coordinatePara; //坐标
  var m_groupPointQeMethod = 2;//0 计算效率 1 计算功率  2 不计算
  var m_secondFlowCoord; //第二坐标参数(流量)
  var m_displayStyle; //显示设置
  var m_changeWrkCurveCb; //修改工作曲线的回调函数
  var m_chartDiagramPanelStyle = ConstParas.ChartDiagramPanelStyle.Two;

  var m_isDispCurveQE = true; //是否显示效率
  var m_isDispCurveQP = true; //是否显示功率
  var m_isHaveBottomPanel = true; //是否有底部面板
  var m_isDrawEquepEtaCurve = true;
  var m_isDispNpsh; //是否显示汽蚀
  var m_d2IsMeter = true; //公制

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

  //设置颜色
  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.SpectrumColor = "#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.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;

      m_isDispCurveQE = chartSetting.IsDispCurveQE;
      m_isDispCurveQP = chartSetting.IsDispCurveQP;
    }
    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_isDispCurveQP == false && m_isDispNpsh == false)
      m_isHaveBottomPanel = false;

    if (m_displayStyle.BlodRegionCurveWidth == null)
      m_displayStyle.BlodRegionCurveWidth = 4;

    m_displayStyle.FeatCurveSize = 10;
    m_displayStyle.EqualCurveSize = 9;

    m_displayStyle.isDrawWaterMark = true;
    //是否显示子刻度
    m_displayStyle.isDispMiniTick = true;
    m_displayStyle.isRotateLabelX = false;
    m_displayStyle.isAxisIntervalX = false;
    m_displayStyle.MiniTickNumber = 3;
    //装置曲线
    if (m_displayStyle.IsDispEquipCurve) {
      m_equipCurve.isVisble = true;
    }

    //面板显示
    m_chartDiagramPanelStyle = ConstParas.ChartDiagramPanelStyle.Two;
    if (m_displayStyle.DiagramPanelStyle == "Whole") {
      m_chartDiagramPanelStyle = ConstParas.ChartDiagramPanelStyle.Whole;
    } else if (m_displayStyle.DiagramPanelStyle == "Two") {
      m_chartDiagramPanelStyle = ConstParas.ChartDiagramPanelStyle.Two;
    }

    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;
    var height = 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.DiagramHeight = height;
      m_chartSize.UpDiagram.SpaceGridY = height / m_coordinatePara.GridNumberY;
      m_chartSize.UpDiagram.GridNumberY = m_coordinatePara.GridNumberY;

      m_chartSize.DownDiagram = {}; //一样
      m_chartSize.DownDiagram.Up = space_top;
      m_chartSize.DownDiagram.DiagramHeight = height;
      m_chartSize.DownDiagram.Bottom = m_chartSize.TotalHeight - space_bottom;
      m_chartSize.DownDiagram.SpaceGridY =
        height / 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;

      //把间隙弄小点
      var areaAttr = {
        x: space_left,
        y: space_top,
        width: m_chartSize.DiagramWidth,
        height: m_chartSize.UpDiagram.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);
      if (m_coordinatePara.DislocationNumUp > 0)
        grid_num_up = grid_num_up + m_coordinatePara.DislocationNumUp;
      else grid_num_up = grid_num_up + 2; //多两条

      if (!m_isDispCurveQE) {
        grid_num_up =
          m_coordinatePara.EndLineNoH - m_coordinatePara.StartLineNoH;
      }

      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) +
        m_coordinatePara.DislocationNumDown;

      m_chartSize.UpDiagram = {};
      m_chartSize.DownDiagram = {};

      if (m_isHaveBottomPanel == false) {
        m_chartSize.UpDiagram.DiagramHeight = height - panel_space;
        m_chartSize.DownDiagram.DiagramHeight = 5;
      } else {
        m_chartSize.UpDiagram.DiagramHeight = (height - panel_space) * 0.6;
        m_chartSize.DownDiagram.DiagramHeight = (height - panel_space) * 0.4;
      }

      m_chartSize.UpDiagram.Up = space_top;
      m_chartSize.UpDiagram.SpaceGridY =
        m_chartSize.UpDiagram.DiagramHeight / grid_num_up;
      m_chartSize.UpDiagram.Bottom =
        space_top + grid_num_up * m_chartSize.UpDiagram.SpaceGridY;
      m_chartSize.UpDiagram.GridNumberY = grid_num_up;

      m_chartSize.DownDiagram.Up = m_chartSize.UpDiagram.Bottom + panel_space;
      m_chartSize.DownDiagram.SpaceGridY =
        m_chartSize.DownDiagram.DiagramHeight / 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;
    }
  };
  //第二流量坐标
  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 = [];

    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) {

        m_secondFlowCoord.Labels.push({ DispValue: disQ, M3H: m3h });
      } else {
        break;
      }
    }

  };

  //代码临时注释
  var svgClick = function (e) {
    // if (m_toolTipContent == null)
    //     return;
    // if (e.clientX - (svg).offset().left > m_chartSize.SpaceLeft && m_chartSize.DiagramRightX + (svg).offset().left - e.clientX > 0 &&
    //     e.clientY - (svg).offset().top > m_chartSize.SpaceTop && m_chartSize.DiagramBottomY + (svg).offset().top - e.clientY > 0) {
    //     var htmlContent = new Array();
    //     var xPixel = e.clientX - (svg).offset().left;
    //     var yPixel = e.clientY + (document).scrollTop() - (svg).offset().top; //可视区域  滚动有问题,所以要加上(document).scrollTop()
    //     var flow = "点击处: 流量";
    //     var head = "扬程";
    //     var power = "功率";
    //     if (m_localizationType == 2) {
    //         flow = "Click point : Q";
    //         head = "H";
    //         cavitation = "NPSH";
    //     }
    //     flow = flow + " : " + parseFloat(getActualValue(m_coordinatePara.CoordMinQ, m_coordinatePara.CoordMaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX, xPixel)).toFixed(1);
    //     htmlContent.push(flow + " m³/h");
    //     htmlContent.push("&nbsp;&nbsp;");
    //     if (yPixel <= m_coordinatePara.ValidPixelMinH && yPixel >= m_coordinatePara.ValidPixelMaxH) {
    //         head = head + " : " + parseFloat(getActualValue(m_coordinatePara.CoordMinH, m_coordinatePara.CoordMaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop, yPixel)).toFixed(1);
    //         //alert(yPixel); alert(head);
    //         htmlContent.push(head + " m");
    //         htmlContent.push("&nbsp;&nbsp;");
    //     }
    //     m_toolTipContent.html(htmlContent.join(''));
    // }
  };
  //
  var svgMove = function (e) {
    //alert("svgMove");
  };

  //翻译
  var getTranslateString = function (cn) {
    if (m_localizationType == 0) return cn;
    return languageHelper.translateString(m_localizationType, 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;user-select:none;"; //font-weight:bold

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

    //
    for (var i = 0; i <= m_coordinatePara.GridNumberX; i++) {
      let q = m_coordinatePara.MinQ + i * m_coordinatePara.SpaceQ;

      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;user-select:none;"; //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 (var 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 (var j = 1; j < 10; j++) {
          var pois_minTick = posiX_grid + sub_spaix_space * j;
          if (pois_minTick > m_chartSize.DiagramRight - sub_spaix_space) {
            break;
          }

          var 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;user-select:none;"; //font-weight:bold

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

      let q = m_coordinatePara.MinQ + i * m_coordinatePara.SpaceQ;
      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 +
        ";user-select:none;";
      //标签
      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;
            var 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)";
        }
        var 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",
        };
        var content = UnitHelper.valueFormat(
          m_coordinatePara.DispMinH +
          (i - m_coordinatePara.StartLineNoH) * 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 +
        ";user-select:none;";
      //标签
      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;
        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;
        var transform =
          "rotate(-90 " + attrAxisTitleE.x + "," + attrAxisTitleE.y + ")";
        m_svg.createText(
          attrAxisTitleE,
          styleAxisTitleE,
          "Eta (%)",
          10,
          null,
          transform
        );
      }

      //
      for (
        var i = m_coordinatePara.StartLineNoE;
        i <= m_coordinatePara.EndLineNoE;
        i++
      ) {
        var content = m_coordinatePara.MinE + i * m_coordinatePara.SpaceE;
        var posiY_grid =
          m_chartSize.UpDiagram.Bottom - m_chartSize.UpDiagram.SpaceGridY * i;
        //主刻度
        var 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,
        };

        if (content <= 100)
          m_svg.createText(attrAxisLabelE, styleAxisLabelE, content);

        //子刻度线
        if (m_displayStyle.isDispMiniTick && i != m_coordinatePara.EndLineNoE) {
          for (var j = 0; j < m_displayStyle.MiniTickNumber; j++) {
            var pois_minTick =
              posiY_grid -
              (m_chartSize.UpDiagram.SpaceGridY * j) /
              m_displayStyle.MiniTickNumber;
            var 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 &&
      m_isDispCurveQP
    ) {
      //刻度线
      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;
        var transform =
          "rotate(-90 " + attrAxisTitleP.x + "," + attrAxisTitleP.y + ")";
        m_svg.createText(
          attrAxisTitleP,
          styleAxisTitleP,
          "(" + unit_p_name + ")",
          10,
          null,
          transform
        );
      } else {
        var 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;
        var 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++
      ) {
        var content = UnitHelper.valueFormat(
          m_coordinatePara.MinP + i * m_coordinatePara.SpaceP
        );

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

        var posiY_grid =
          m_chartSize.DownDiagram.Bottom -
          m_chartSize.DownDiagram.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(""), 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 (var j = 1; j < m_displayStyle.MiniTickNumber; j++) {
            var pois_minTick =
              posiY_grid -
              (m_chartSize.DownDiagram.SpaceGridY * j) /
              m_displayStyle.MiniTickNumber;
            var 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",
      };
      var npsh_unit_name = "(" + UnitHelper.GetUnitNameNPSH(m_unit.NPSH) + ")";
      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;
        var transform =
          "rotate(-90 " + attrAxisTitleNPSH.x + "," + attrAxisTitleNPSH.y + ")";
        m_svg.createText(
          attrAxisTitleNPSH,
          styleAxisTitleNPSH,
          npsh_unit_name,
          10,
          null,
          transform
        );
      } else {
        attrAxisTitleNPSH.x = attrAxisTitleNPSH.x + 6;
        attrAxisTitleNPSH.y = attrAxisTitleNPSH.y + 24;
        var transform =
          "rotate(-90 " + attrAxisTitleNPSH.x + "," + attrAxisTitleNPSH.y + ")";
        m_svg.createText(
          attrAxisTitleNPSH,
          styleAxisTitleNPSH,
          "NPSHr" + npsh_unit_name,
          10,
          null,
          transform
        );
      }

      //
      for (
        var i = m_coordinatePara.StartLineNoNPSH;
        i <= m_coordinatePara.EndLineNoNPSH;
        i++
      ) {
        var axis_npsh_m =
          m_coordinatePara.MinNPSH + i * m_coordinatePara.SpaceNPSH;
        var axis_npsh_v = UnitHelper.ConvertNPSH_fromM(
          m_unit.NPSH,
          axis_npsh_m
        );

        var content = UnitHelper.valueFormat(axis_npsh_v);
        var posiY_grid =
          m_chartSize.DownDiagram.Bottom -
          m_chartSize.DownDiagram.SpaceGridY * i;
        //主刻度
        var 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 (var j = 0; j < m_displayStyle.MiniTickNumber; j++) {
            var pois_minTick =
              posiY_grid -
              (m_chartSize.DownDiagram.SpaceGridY * j) /
              m_displayStyle.MiniTickNumber;
            var 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;user-select:none;fill-opacity:1;fill:" +
        m_displayStyle.ColorH +
        ";user-select:none;";
      //
      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.DispMinH + i * 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;user-select:none;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;user-select:none;fill-opacity:1;fill:" +
        m_displayStyle.ColorE +
        ";";
      //刻度线
      var attrAxisTickE = {
        stroke: m_displayStyle.ColorE,
        "stroke-width": "1",
        fill: "none",
      };
      //
      for (
        var i = 0;
        i <= m_coordinatePara.EndLineNoE - m_coordinatePara.StartLineNoE;
        i++
      ) {
        var posiY_grid =
          m_chartSize.PanelE.Bottom - m_chartSize.UpDiagram.SpaceGridY * i;
        //主刻度
        var 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,
        };

        var eta_disp =
          m_coordinatePara.MinE +
          (i + m_coordinatePara.StartLineNoE) * m_coordinatePara.SpaceE;
        if (eta_disp >= 0 && eta_disp <= 100) {
          var content = UnitHelper.valueFormat(eta_disp);
          m_svg.createText(attrAxisLabelE, styleAxisLabelE, content);
        }

        //子刻度线
        if (
          m_displayStyle.isDispMiniTick &&
          i != m_coordinatePara.EndLineNoE - m_coordinatePara.StartLineNoE
        ) {
          for (var j = 0; j < m_displayStyle.MiniTickNumber; j++) {
            var pois_minTick =
              posiY_grid -
              (m_chartSize.UpDiagram.SpaceGridY * j) /
              m_displayStyle.MiniTickNumber;
            var 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 &&
      m_isDispCurveQP
    ) {
      if (m_displayStyle.AxisTitlePosiAxisUpY == false) {
        //标题放在刻度上
        createAxisTitleP();
      }

      //刻度线
      var attrAxisTickP = {
        stroke: m_displayStyle.ColorP,
        "stroke-width": "1",
        fill: "none",
      };
      var styleAxisLabelP =
        "font-size:11px;user-select:none;fill-opacity:1;fill:" +
        m_displayStyle.ColorP +
        ";";

      for (
        var i = 0;
        i <= m_coordinatePara.EndLineNoP - m_coordinatePara.StartLineNoP;
        i++
      ) {
        var posiY_grid =
          m_chartSize.PanelP.Bottom - m_chartSize.DownDiagram.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(""), 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;
        var content = UnitHelper.toStringTrim(aixs_p);

        if (i == m_coordinatePara.EndLineNoP - m_coordinatePara.StartLineNoP) {
          if (m_displayStyle.AxisTitlePosiAxisUpY == true) {
            styleAxisLabelP =
              "font-size:12px;fill-opacity:1;user-select:none;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++) {
            var pois_minTick =
              posiY_grid -
              (m_chartSize.DownDiagram.SpaceGridY * j) /
              m_displayStyle.MiniTickNumber;
            var 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;user-select:none;fill-opacity:1;fill:" +
        m_displayStyle.ColorNPSH +
        ";";

      //
      for (
        var i = 0;
        i <= m_coordinatePara.EndLineNoNPSH - m_coordinatePara.StartLineNoNPSH;
        i++
      ) {
        var posiY_grid =
          m_chartSize.PanelNPSH.Bottom - m_chartSize.DownDiagram.SpaceGridY * i;
        //主刻度
        var 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_m =
          m_coordinatePara.MinNPSH +
          (i + m_coordinatePara.StartLineNoNPSH) * m_coordinatePara.SpaceNPSH;
        var axis_npsh_v = UnitHelper.ConvertNPSH_fromM(
          m_unit.NPSH,
          axis_npsh_m
        );
        if (axis_npsh_v < 0) continue;

        var content = UnitHelper.toStringTrim(
          UnitHelper.getDispValueNPSH(axis_npsh_v)
        );
        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++) {
            var pois_minTick =
              posiY_grid -
              (m_chartSize.DownDiagram.SpaceGridY * j) /
              m_displayStyle.MiniTickNumber;
            var valueMini = [];
            valueMini.push(
              "M ",
              m_chartSize.DiagramRight,
              " ",
              pois_minTick,
              " L ",
              m_chartSize.DiagramRight + minTickLength,
              " ",
              pois_minTick
            );
            m_svg.createPath(null, valueMini.join(""), attrAxisTickNPSH, null);
          }
        }
      }
    }
  };
  //绘制图表边界
  var createDiagramBoundary = function () {
    var attrBoundary = {
      stroke: "black",
      "stroke-width": "1",
      fill: "none",
    };

    var valueMain1Up = [];
    valueMain1Up.push(
      "M ",
      m_chartSize.DiagramLeft,
      " ",
      m_chartSize.UpDiagram.Up,
      " L ",
      m_chartSize.DiagramLeft,
      " ",
      m_chartSize.UpDiagram.Bottom
    );
    m_svg.createPath(null, valueMain1Up.join(""), attrBoundary, null);

    var valueMain2Up = [];
    valueMain2Up.push(
      "M ",
      m_chartSize.DiagramRight,
      " ",
      m_chartSize.UpDiagram.Up,
      " L ",
      m_chartSize.DiagramRight,
      " ",
      m_chartSize.UpDiagram.Bottom
    );
    m_svg.createPath(null, valueMain2Up.join(""), attrBoundary, null);

    var valueMain3Up = [];
    valueMain3Up.push(
      "M ",
      m_chartSize.DiagramLeft,
      " ",
      m_chartSize.UpDiagram.Up,
      " L ",
      m_chartSize.DiagramRight,
      " ",
      m_chartSize.UpDiagram.Up
    );
    m_svg.createPath(null, valueMain3Up.join(""), attrBoundary, null);

    var valueMain4Up = [];
    valueMain4Up.push(
      "M ",
      m_chartSize.DiagramLeft,
      " ",
      m_chartSize.UpDiagram.Bottom,
      " L ",
      m_chartSize.DiagramRight,
      " ",
      m_chartSize.UpDiagram.Bottom
    );
    m_svg.createPath(null, valueMain4Up.join(""), attrBoundary, null);

    if (m_isHaveBottomPanel) {
      var valueMain1Down = [];
      valueMain1Down.push(
        "M ",
        m_chartSize.DiagramLeft,
        " ",
        m_chartSize.DownDiagram.Up,
        " L ",
        m_chartSize.DiagramLeft,
        " ",
        m_chartSize.DownDiagram.Bottom
      );
      m_svg.createPath(null, valueMain1Down.join(""), attrBoundary, null);

      var valueMain2Down = [];
      valueMain2Down.push(
        "M ",
        m_chartSize.DiagramRight,
        " ",
        m_chartSize.DownDiagram.Up,
        " L ",
        m_chartSize.DiagramRight,
        " ",
        m_chartSize.DownDiagram.Bottom
      );
      m_svg.createPath(null, valueMain2Down.join(""), attrBoundary, null);

      var valueMain3Down = [];
      valueMain3Down.push(
        "M ",
        m_chartSize.DiagramLeft,
        " ",
        m_chartSize.DownDiagram.Up,
        " L ",
        m_chartSize.DiagramRight,
        " ",
        m_chartSize.DownDiagram.Up
      );
      m_svg.createPath(null, valueMain3Down.join(""), attrBoundary, null);

      var valueMain4Down = [];
      valueMain4Down.push(
        "M ",
        m_chartSize.DiagramLeft,
        " ",
        m_chartSize.DownDiagram.Bottom,
        " L ",
        m_chartSize.DiagramRight,
        " ",
        m_chartSize.DownDiagram.Bottom
      );
      m_svg.createPath(null, valueMain4Down.join(""), attrBoundary, null);
    }
  };
  //绘制Y坐标标题(扬程)
  var creatAxisTitleH = function () {
    var styleAxisTitleH =
      "font-size:14px; ;fill-opacity:1;user-select:none;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,
          "(" + unit_h_name + ")",
          10,
          null,
          transform
        );
      } else {
        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 + ")"; //不用多出空格否则全屏会有问题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)";
      }
      var 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;user-select:none;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 {
      var styleAxisTitleE =
        "font-size:14px;fill-opacity:1;user-select:none;font-weight:bold; fill:" +
        m_displayStyle.ColorE +
        ";";
      //
      var 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;
        var 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;user-select:none;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 {
      var 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;
      var 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;user-select:none;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",
      };
      var title_content = "(" + UnitHelper.GetUnitNameNPSH(m_unit.NPSH) + ")";
      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,
          title_content,
          10,
          null,
          transform
        );
      } else {
        attrAxisTitleNPSH.x = attrAxisTitleNPSH.x + 6;
        attrAxisTitleNPSH.y = attrAxisTitleNPSH.y + 24;
        var transform =
          "rotate(90 " + attrAxisTitleNPSH.x + "," + attrAxisTitleNPSH.y + ")";
        m_svg.createText(
          attrAxisTitleNPSH,
          styleAxisTitleNPSH,
          "NPSHr" + title_content,
          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();

      if (m_isHaveBottomPanel) createFlowAxisBottom();

      //绘制Y坐标
      createYAxis_TwoPanel();

      //绘制图表边界
      createDiagramBoundary();
    }
  };

  //产生型谱
  var drawSpectrumShape = function () {
    var spectrumShape = m_chartObject.SpectrumShape;

    if (spectrumShape == null) return;

    removeElementById("SpectrumShape");

    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 (var v = 0; v < points_top.length; v++) {
      var pt = points_top[v];
      var x = getPixelValueQ(pt.X);
      var y = getPixelValueH(pt.Y);
      pixelPoints_Top.push({ X: x, Y: y });
    }
    var bezierCurve_points_top = transBezierCurveModel(pixelPoints_Top);
    for (var h = 0; h < bezierCurve_points_top.length; h++) {
      var 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 (var v = 0; v < points_bottom.length; v++) {
      var pt = points_bottom[v];
      var x = getPixelValueQ(pt.X);
      var y = getPixelValueH(pt.Y);
      pixelPoints_bottom.push({ X: x, Y: y });
    }
    var bezierCurve_points_bottom = transBezierCurveModel(pixelPoints_bottom);
    for (var h = 0; h < bezierCurve_points_bottom.length; h++) {
      var 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 (var v = 0; v < points_right.length; v++) {
      var pt = points_right[v];
      var x = getPixelValueQ(pt.X);
      var y = getPixelValueH(pt.Y);
      pixelPoints_right.push({ X: x, Y: y });
    }
    var bezierCurve_points_right = transBezierCurveModel(pixelPoints_right);
    for (var h = 0; h < bezierCurve_points_right.length; h++) {
      var 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);
      }
    }

    if (pathValue.toString().indexOf("M ,NaN, ,NaN") == 0) {
      return;
    }

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

  //绘制曲线(流量扬程) curveDashType 类型 例如 "5 5"
  var createCurveQH = function (
    curveElementName,
    curvePoints,
    curveWidth,
    curveColor,
    curveIsDisp,
    curveDashType
  ) {
    if (curvePoints == null || curvePoints.length == 0) {
      return;
    }

    var pixelPoints = [];
    for (var v = 0; v < curvePoints.length; v++) {
      var pt = curvePoints[v];
      var x = getPixelValueQ(pt.X);
      if (pt.Y < 0) pt.Y = 0;
      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;
    }

    var pathValue = transBezierCurveToPath(pixelPoints);
    if (pathValue == null || pathValue == undefined) return;
    //
    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'
    }

    //绘制
    m_svg.createPath(
      curveElementName,
      pathValue.join(""),
      {
        id: curveElementName,
      },
      style
    );
    //是否显示
    if (isDisp != null && !isDisp) {
      hideElementById(curveElementName);
    }

    //绘制定义点
    /*pixelPoints.forEach(pixel_pt => {
            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;
    }

    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);
  };
  //虚线 curveDashType 类型 "5 3"
  var createDashedLineQH = function (
    curveElementName,
    point1,
    point2,
    curveWidth,
    curveColor,
    curveDashType,
    objTag
  ) {
    if (point1 == null || point2 == 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": curveDashType,
      "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 createLine_pixel = function (
    curveElementName,
    point1,
    point2,
    curveWidth,
    curveColor,
    objTag
  ) {
    if (point1 == null || point2 == null) {
      return;
    }

    var x1 = point1.X;
    var y1 = point1.Y;

    var x2 = point2.X;
    var y2 = point2.Y;

    var style = {
      "stroke-width": "2px",
      stroke: curveColor,
      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);
  };
  //绘制文字
  var drawTextByQH = function (elementName, content, point, style) {
    if (!content) {
      return;
    }
    if (!point) {
      return;
    }

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

    var textStyle = "user-select:none;stroke-width:1px;"; // fill-opacity:0.9;

    if (style.color != null) {
      textStyle += " fill:" + style.color + ";";
    } else {
      textStyle += " fill:#000000;";
    }
    var textHeight = 12;
    if (style.size != null) {
      textHeight = style.size;
      textStyle += " font-size:" + style.size + "px;";
    } else {
      textStyle += " font-size:12px;";
    }

    if (style.anchor != null) {
      textStyle += " text-anchor:" + style.anchor + ";";
    }
    //
    if (style.textAligment == 0) {
      //Right 文字对齐 start | middle | end
      xPixel += 2;
      textStyle += " text-anchor:start;dominant-baseline: middle;";
    } else if (style.textAligment == 1) {
      //Bottom
      yPixel = yPixel + (textHeight + 2);
      textStyle += " text-anchor:middle;";
    } else if (style.textAligment == 2) {
      //Left
      yPixel = yPixel - 2;
      textStyle += " text-anchor:end;dominant-baseline: middle;";
    } else if (style.textAligment == 3) {
      //Top
      yPixel = yPixel - 5;
      textStyle += " text-anchor:middle;";
    } else if (style.textAligment == 4) {
      //TopLeft
      yPixel = yPixel - 5;
      textStyle += " text-anchor:start;";
    }

    if (style.fontWeight != null) {
      textStyle += " font-weight:" + style.fontWeight + ";";
    }

    var opacity = 0.5;
    if (style.opacity != null) {
      opacity = style.opacity;
    }

    return m_svg.createText(
      {
        id: elementName,
        opacity: opacity,
        y: yPixel,
        x: xPixel,
      },
      textStyle,
      content
    );
  };
  //绘制文字 textAnchor 文字对齐 start | middle | end
  var drawTextByQP = function (elementName, content, point, style) {
    if (!content) {
      return;
    }
    if (!point) {
      return;
    }
    var xPixel = getPixelValueQ(point.X);
    var yPixel = getPixelValueP(point.Y);
    if (style.offsetPixelX != null) {
      xPixel += style.offsetPixelX;
    }
    if (style.offsetPixelY != null) {
      yPixel += style.offsetPixelY;
    }

    var textStyle = "user-select:none;stroke-width:1px;"; //font-weight:bold; fill-opacity:0.9;

    if (style.color != null) {
      textStyle += " fill:" + style.color + ";";
    } else {
      textStyle += " fill:#000000;";
    }
    var textHeight = 12;
    if (style.size != null) {
      textHeight = style.size;
      textStyle += " font-size:" + style.size + "px;";
    } else {
      textStyle += " font-size:12px;";
    }

    if (style.anchor != null) {
      textStyle += " text-anchor:" + style.anchor + ";";
    }
    if (style.textAligment == 0) {
      //Right 文字对齐 start | middle | end
      xPixel += 2;
      yPixel = yPixel + textHeight / 2;
      textStyle += " text-anchor:start;";
    } else if (style.textAligment == 1) {
      //Bottom
      yPixel = yPixel + (textHeight + 2);
      textStyle += " text-anchor:middle;";
    } else if (style.textAligment == 2) {
      //Left
      xPixel -= 2;
      yPixel = yPixel + (textHeight / 2 + 1);
      textStyle += " text-anchor:end;";
    } else if (style.textAligment == 3) {
      //Top
      yPixel = yPixel - 2;
      textStyle += " text-anchor:middle;";
    }

    if (style.fontWeight != null) {
      textStyle += " font-weight:" + style.fontWeight + ";";
    }

    var opacity = 0.5;
    if (style.opacity != null) {
      opacity = style.opacity;
    }

    return m_svg.createText(
      {
        id: elementName,
        opacity: opacity,
        y: yPixel,
        x: xPixel,
      },
      textStyle,
      content
    );
  };
  //绘制文字 textAnchor 文字对齐 start | middle | end
  var drawText_pixel = function (
    curveElementName,
    text,
    point,
    textSize,
    textColor,
    textAnchor,
    textStyle
  ) {
    if (!text) {
      return;
    }
    if (!point) {
      return;
    }

    var xPixel = point.X;
    var yPixel = point.Y;

    if (textStyle == null) textStyle = "user-select:none;";
    //font-weight:bold; fill-opacity:0.9; stroke-width:1px;
    else textStyle += "user-select:none;";

    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 getSvgObjByName = function (objName) {
    return m_svg.getPathByName(objName);
  };
  var removeElementById = function (id) {
    var obj = document.getElementById(id);
    if (obj != null) {
      obj.remove();
    }
  };
  var hideElementById = function (id) {
    var obj = document.getElementById(id);
    if (obj != null) {
      obj.style.display = "none";
    }
  };
  var showElementById = function (id) {
    var obj = document.getElementById(id);
    if (obj != null) {
      obj.style.display = "";
    }
  };
  //绘制设计点:0 Cross  1 LeftDownHalfCross    2 LeftDownTriangle       3 CrossAnPointCircle     4  PointCircle  5 BlodTriangle
  var drawDesignPoint = function () {
    if (m_chartObject.DesignPoint4StdUnit == null) return;

    removeElementById("DesignPointWater1");
    removeElementById("DesignPointWater2");
    removeElementById("DesignPointWater3");
    removeElementById("DesignPointWater4");
    removeElementById("DesignPointWater5");

    var defaultDp = m_chartObject.DesignPoint4StdUnit;
    var dp_color = "red";
    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: dp_color,
        fill: "none",
        "fill-opacity": "0.5",
        //"stroke-dasharray":"5 3",
        "shape-rendering": "geometricPrecision",
        "zIndex:": 18,
      };

      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,
        {
          tag: "DesignPoint1",
        },
        style
      );
      pathValue = temp
        .replace("x1", xPixel)
        .replace("y1", yPixel)
        .replace("x2", xPixel)
        .replace("y2", yPixel + yTri);
      m_svg.createPath(
        "DesignPointWater2",
        pathValue,
        {
          tag: "DesignPoint1",
        },
        style
      );
      pathValue = temp
        .replace("x1", xPixel - xTri)
        .replace("y1", yPixel)
        .replace("x2", xPixel)
        .replace("y2", yPixel + yTri);
      m_svg.createPath(
        "DesignPointWater3",
        pathValue,
        {
          tag: "DesignPoint1",
        },
        style
      );

      pathValue = temp
        .replace("x1", xPixel - xTri / 3)
        .replace("y1", yPixel)
        .replace("x2", xPixel)
        .replace("y2", yPixel + yTri / 3);
      m_svg.createPath(
        "DesignPointWater4",
        pathValue,
        {
          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,
        {
          tag: "DesignPoint1",
        },
        style
      );
    } else if (dispStyleType == 4) {
      //圆点
      var attr_pt = {
        cx: getPixelValueQ(defaultDp.X),
        cy: getPixelValueH(defaultDp.Y),
        r: 6,
      };
      var style_pt = {
        "stroke-width": "2px",
        stroke: "none",
        fill: dp_color,
        "fill-opacity": "0.5",
        "shape-rendering": "geometricPrecision",
        "zIndex:": 7,
      };

      m_svg.createCircle("DesignPointWater1", attr_pt, style_pt);
    } else if (dispStyleType == 5) {
      //加粗三角

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

      var attr1 = {
        id: "DesignPointWater1",
        x: xPixel - 20,
        y: yPixel,
        width: 20,
        height: 6,
      };
      var attr2 = {
        id: "DesignPointWater2",
        x: xPixel - 6,
        y: yPixel,
        width: 6,
        height: 20,
      };
      var style1 = {
        "stroke-width": "1",
        stroke: "none",
        fill: dp_color,
        //"stroke-opacity": '0.1',
        //"fill-opacity": "0.3",
        "shape-rendering": "geometricPrecision",
        "zIndex:": -1,
      };
      m_svg.createRect(attr1, style1, "DesignPointWater1");
      m_svg.createRect(attr2, style1, "DesignPointWater2");
    } 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,
        dp_color,
        "DesignPoint1"
      );

      point1 = { X: x * m_designPointTolerance[0], Y: y };
      point2 = { X: x * m_designPointTolerance[1], Y: y };
      createLineQH(
        "DesignPointWater2",
        point1,
        point2,
        3,
        dp_color,
        "DesignPoint1"
      );
    }
  };
  //绘制工作点
  var drawWorkPoint = function () {
    removeElementById("RealWorkPointQH");
    removeElementById("RealWorkPointQE");
    removeElementById("RealWorkPointQP");
    removeElementById("RealWorkPointQNPSH");


    if (m_chartObject.DesignPoint4StdUnit == null || m_chartObject.JieZhiWorkPoint == null) return;



    if (m_chartObject.JieZhiWorkPoint.Q < 0.1)
      return;

    var dp_color = "Purple";
    var dp_radial = 5;

    var style_pt = {
      "stroke-width": "2px",
      stroke: "none",
      fill: dp_color,
      //"fill-opacity": "0.5",
      "shape-rendering": "geometricPrecision",
      "zIndex:": 7,
    };
    //圆点
    var pixel_flow = getPixelValueQ(m_chartObject.JieZhiWorkPoint.Q);

    var attr_pt_qh = {
      cx: pixel_flow,
      cy: getPixelValueH(m_chartObject.JieZhiWorkPoint.H),
      r: dp_radial
    };
    m_svg.createCircle("RealWorkPointQH", attr_pt_qh, style_pt);


    if (m_isDispCurveQE) {
      var eta_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQE, pixel_flow);
      var pixel_eta = getPixelValueE(m_chartObject.JieZhiWorkPoint.E);
      if (Math.abs(pixel_eta - eta_pixel_pt.Y) < 5) {//差距过大就不显示, 需要后台处理
        var attr_pt_qe = {
          cx: pixel_flow,
          cy: pixel_eta,
          r: dp_radial
        };

        m_svg.createCircle("RealWorkPointQE", attr_pt_qe, style_pt);
      }
    }


    if (m_isDispCurveQP) {
      var power_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQP, pixel_flow);
      var pixel_power = getPixelValueP(m_chartObject.JieZhiWorkPoint.P);
      if (Math.abs(pixel_power - power_pixel_pt.Y) < 5) {
        var attr_pt_qp = {
          cx: pixel_flow,
          cy: pixel_power,
          r: dp_radial
        };

        m_svg.createCircle("RealWorkPointQP", attr_pt_qp, style_pt);
      }
    }

    if (m_chartObject.JieZhiWorkPoint.NPSH > 0.01) {
      var attr_pt_qp = {
        cx: pixel_flow,
        cy: getPixelValueNPSH(m_chartObject.JieZhiWorkPoint.NPSH),
        r: dp_radial
      };

      m_svg.createCircle("RealWorkPointQNPSH", attr_pt_qp, style_pt);
    }

  };

  //绘制消防泵的点
  var drawFirePumpPoint = function () {
    if (m_chartPointPara.Percent150Pt == null) return;
    removeElementById("Percent150Pt1");

    var attr_pt = {
      cx: getPixelValueQ(m_chartPointPara.Percent150Pt.Q),
      cy: getPixelValueH(m_chartPointPara.Percent150Pt.H),
      r: 6,
    };
    var dp_color = "red";
    var style_pt = {
      "stroke-width": "2px",
      stroke: "none",
      fill: dp_color,
      "fill-opacity": "0.9",
      "shape-rendering": "geometricPrecision",
      "zIndex:": 7,
    };

    m_svg.createCircle("Percent150Pt1", attr_pt, style_pt);
  };
  //刷新区域点位置
  var refreshRegionPtPosi = function (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 () {
    removeElementById("RegionBlodCurveQH_Allow");
    removeElementById("RegionBlodCurveQP_Allow");
    removeElementById("RegionBlodCurveQE_Allow");
    removeElementById("RegionBlodCurveNPSH_Allow");

    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;

    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);
        }
        if (m_isDispCurveQP) {
          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);
      }

      var 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
        );

        space = (max_q - min_q) / (pt_num - 1);
        for (var i = 0; i < pt_num; i++) {
          var 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);
          }
        }
      }

      createCurveQH_pixel(
        "RegionBlodCurveQH_Allow",
        pixelPoints_QH,
        m_displayStyle.BlodRegionCurveWidth,
        m_chartObject.WorkCurveColorQH
      );
      createCurveQE_pixel(
        "RegionBlodCurveQE_Allow",
        pixelPoints_QE,
        m_displayStyle.BlodRegionCurveWidth,
        m_chartObject.WorkCurveColorQE
      );
      createCurveQP_pixel(
        "RegionBlodCurveQP_Allow",
        pixelPoints_QP,
        m_displayStyle.BlodRegionCurveWidth,
        m_chartObject.WorkCurveColorQP
      );
      createCurveNPSH_pixel(
        "RegionBlodCurveNPSH_Allow",
        pixelPoints_NPSH,
        m_displayStyle.BlodRegionCurveWidth,
        m_chartObject.WorkCurveColorQNPSH
      );
    } else if (
      m_chartPointPara.AllowRegionDispStyle ==
      ConstParas.ChartRegionDispStyle.Strip
    ) {
      // 条带
      removeElementById("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.UpDiagram.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 = [];
      var 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);
        }
        if (m_isDispCurveQP) {
          var power_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQP, xPixel);
          if (power_pixel_pt != null) pixelPoints_QP.push(power_pixel_pt);
        }
      }

      var pixelPoints_NPSH = [];
      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
        );

        space = (max_q - min_q) / (pt_num - 1);
        for (var i = 0; i < pt_num; i++) {
          var 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);

          }
        }
      }

      removeElementById("RegionBlodCurveQH_Perfer");
      removeElementById("RegionBlodCurveQP_Perfer");
      removeElementById("RegionBlodCurveQE_Perfer");
      removeElementById("RegionBlodCurveNPSH_Perfer");

      createCurveQH_pixel(
        "RegionBlodCurveQH_Perfer",
        pixelPoints_QH,
        m_displayStyle.BlodRegionCurveWidth,
        m_chartObject.WorkCurveColorQH
      );
      createCurveQE_pixel(
        "RegionBlodCurveQE_Perfer",
        pixelPoints_QE,
        m_displayStyle.BlodRegionCurveWidth,
        m_chartObject.WorkCurveColorQE
      );
      createCurveQP_pixel(
        "RegionBlodCurveQP_Perfer",
        pixelPoints_QP,
        m_displayStyle.BlodRegionCurveWidth,
        m_chartObject.WorkCurveColorQP
      );
      createCurveNPSH_pixel(
        "RegionBlodCurveNPSH_Perfer",
        pixelPoints_NPSH,
        m_displayStyle.BlodRegionCurveWidth,
        m_chartObject.WorkCurveColorQNPSH
      );
    } else if (
      m_chartPointPara.PerferRegionDispStyle ==
      ConstParas.ChartRegionDispStyle.Strip
    ) {
      // 条带
      removeElementById("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.UpDiagram.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") {
    } else if (curveElementName == "PerferBlodCurveQE_Allow") {
    } 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 = [];

    for (var v = 0; v < point_num; v++) {
      var pt = points[v];
      var x = getPixelValueQ(pt.X);
      if (pt.Y < 0) pt.Y = 0;
      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;

    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) {
      hideElementById(curveElementName);
    }
    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);
      if (pt.Y < 0) pt.Y = 0;
      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;

    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",
      "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) {
      hideElementById(curveElementName);
    }

    return pixelPoints;
  };
  //绘制曲线(流量汽蚀)
  var createCurveNPSH = function (
    curveElementName,
    points,
    curveWidth,
    curveColor,
    curveIsDisp,
    curveDashType
  ) {
    if (points == null || m_coordinatePara.SpaceNPSH < 0.01) {
      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);
      if (pt.Y < 0) pt.Y = 0;
      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;
    if (pathValue.toString().indexOf("M ,NaN, ,NaN") == 0) {
      return;
    }
    var style = {
      "stroke-width": "2px",
      stroke: m_displayStyle.ColorNPSH,
      fill: "none",
      "fill-opacity": "0.5",
      "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) {
      hideElementById(curveElementName);
    }
  };
  //清理
  var ClearCurveElement = function () {
    removeElementById("SimJieZhiCurveQH");
    removeElementById("SimJieZhiCurveQE");
    removeElementById("SimJieZhiCurveQP");
    removeElementById("SimJieZhiCurveNPSH");

    removeElementById("SimWaterCurveQH");
    removeElementById("SimWaterCurveQE");
    removeElementById("SimWaterCurveQP");
    removeElementById("SimWaterCurveNPSH");

    removeElementById("MaxWaterCurveQH");
    removeElementById("MaxWaterCurveQE");
    removeElementById("MaxWaterCurveQP");
    removeElementById("MaxWaterCurveNPSH");

    removeElementById("MinWaterCurveQH");
    removeElementById("MinWaterCurveQE");
    removeElementById("MinWaterCurveQP");
    removeElementById("MinWaterCurveNPSH");

    removeElementById("RegionBlodCurveQH_Allow");
    removeElementById("RegionBlodCurveQP_Allow");
    removeElementById("RegionBlodCurveQE_Allow");
    removeElementById("RegionBlodCurveNPSH_Allow");

    removeElementById("PerferBlodCurveQH_Allow");
    removeElementById("PerferBlodCurveQP_Allow");
    removeElementById("PerferBlodCurveQE_Allow");
    removeElementById("PerferBlodCurveNPSH_Allow");

    removeElementById("DesignPointWater1");
    removeElementById("DesignPointWater2");
    removeElementById("DesignPointWater3");
    removeElementById("DesignPointWater4");
    removeElementById("DesignPointWater5");

    removeElementById("RealWorkPointQH");
    removeElementById("RealWorkPointQE");
    removeElementById("RealWorkPointQP");
    removeElementById("RealWorkPointQNPSH");
  };

  //初始化工作曲线
  var intitalWrkCurveInfo = function () {
    m_wrkCurveGrp = {};
    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_chartType == ConstParas.ChartType.Cut) {
      m_wrkCurveGrp.CurvePara = m_pumpInfo.WrkD2;
    } else if (m_chartType == ConstParas.ChartType.Speed) {
      m_wrkCurveGrp.CurvePara = m_pumpInfo.WrkSpeed;
    }
    //通知外部
    if (m_changeWrkCurveCb != null) {
      m_changeWrkCurveCb(m_wrkCurveGrp);
    }

    //
    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 getCurveColor = function (index) {
    if (index <= 0) return "#4169E1";
    if (index == 1) return "#FF4500";
    if (index == 2) return "#FF00FF";
    if (index == 3) return "#A0522D";
    if (index == 4) return "#6495ED";
    if (index == 5) return "#00CED1";
    if (index == 6) return "#2E8B57";
    if (index == 7) return "#FFA500";

    return null;
  };

  var drawChartTextAnnotation = function () {
    if (m_chartObject.LabelPosi == null || m_chartObject.LabelPosi.length == 0)
      return;

    if (m_wrkCurveGrp != null) {
      var lst_pt_qh = m_wrkCurveGrp.RealQH[m_wrkCurveGrp.RealQH.length - 1];

      var text = "unknow";
      if (m_chartType == ConstParas.ChartType.Cut) {
        text = UnitHelper.getDispValueLength(
          m_wrkCurveGrp.CurvePara,
          m_d2IsMeter,
          true
        );
      } else if (m_chartType == ConstParas.ChartType.Speed) {
        text = m_wrkCurveGrp.CurvePara + " rpm";
      }

      drawTextByQH("WorkCurveParasQH", text, lst_pt_qh, {
        size: m_displayStyle.FeatCurveSize,
        color: "black",
        offsetPixelX: 2,
        textAligment: 0,
        fontWeight: "900",
      });
      if (m_isDispCurveQP) {
        var lst_pt_qp = m_wrkCurveGrp.RealQP[m_wrkCurveGrp.RealQP.length - 1];
        drawTextByQP("WorkCurveParasQP", text, lst_pt_qp, {
          size: m_displayStyle.FeatCurveSize,
          color: "black",
          offsetPixelX: 2,
          textAligment: 0,
          fontWeight: "900",
        });
      }
    }
    if (m_displayStyle.LxpCurveBundleDispStyle == 0)
      return;

    for (var j = 0; j < m_chartObject.LabelPosi.length; j++) {
      var anno = m_chartObject.LabelPosi[j];

      var posi = {};
      posi.X = anno.X;
      posi.Y = anno.Y;

      var curveName = "CurvePara_" + anno.CurveTag + "_" + anno.ID;
      anno.ObjectName = curveName;

      var lblColor = m_displayStyle.ColorH;
      if (anno.CurveTag == "QE") {
        lblColor = m_displayStyle.ColorE;
        if (!m_isDrawEquepEtaCurve)
          continue;
      }
      else {
        if (Math.abs(anno.Para - m_wrkCurveGrp.CurvePara) < 2) continue;


        if (anno.CurveTag == "DMH" || anno.CurveTag == "DMP") {//切割叶轮外径,和最大叶轮外径 (扬程线上)

        }
        else if (anno.CurveTag == "PN") {//泵型号

        }
        else if (anno.CurveTag == "WRP" || anno.CurveTag == "WRH") {//切割叶轮外径,和最大叶轮外径 (功率线上)

        }
        else if (anno.CurveTag == "SIMU" || anno.CurveTag == "DSP" || anno.CurveTag == "DSH") {//切割线子型号
          var min_d2_text = m_pumpInfo.MinD2 + "mm";
          if (anno.Text != min_d2_text && m_displayStyle.LxpCurveBundleDispStyle == 1) {
            continue;
          }
        }


        if (m_curveColorDict != null) {
          if (anno.CurveTag == "DIH" || anno.CurveTag == "DIP") {
            for (var i = 0; i < m_curveColorDict.length; i++) {
              if (m_curveColorDict[i].type == "min") {
                lblColor = m_curveColorDict[i].color;
              }
            }
          }
          if (anno.CurveTag == "DMH" || anno.CurveTag == "DMP") {
            for (var i = 0; i < m_curveColorDict.length; i++) {
              if (m_curveColorDict[i].type == "max") {
                lblColor = m_curveColorDict[i].color;
              }
            }
          }
        }
      }

      if (anno.Panel == 0) {
        drawTextByQH(curveName, anno.Text, posi, {
          size: m_displayStyle.FeatCurveSize,
          color: lblColor,
          textAligment: anno.TextAligment,
        });
      } else if (anno.Panel == 1 && m_isDispCurveQP) {
        drawTextByQP(curveName, anno.Text, posi, {
          size: m_displayStyle.FeatCurveSize,
          color: lblColor,
          textAligment: anno.TextAligment,
        });
      }
    }
  };
  //最小流量线
  var drawMinContinueFlowCurve = function () {
    if (
      m_chartObject.MinContinueFlowCurve == null ||
      m_chartObject.MinContinueFlowCurve.length < 2
    ) {
      return;
    }
    removeElementById("MinContinueFlowCurve");

    var color_curve = "#FF1493";
    if (m_chartObject.MinContinueFlowCurve.length > 3) {
      createCurveQH(
        "MinContinueFlowCurve",
        m_chartObject.MinContinueFlowCurve,
        0.5,
        color_curve,
        true,
        "3 3"
      );
    } else {
      createDashedLineQH(
        "MinContinueFlowCurve",
        m_chartObject.MinContinueFlowCurve[0],
        m_chartObject.MinContinueFlowCurve[1],
        0.5,
        color_curve,
        "3 3"
      );
    }
  };

  //绘制等效线
  var drawEquepEtaCurveList = function () {
    m_displayStyle.ColorEqualParaCurvesE = m_displayStyle.ColorE;
    if (
      m_chartObject.EqualParaCurvesE == null ||
      m_chartObject.EqualParaCurvesE.length == 0
    ) {
      m_isDrawEquepEtaCurve = false;
      return;
    }
    for (var i = 0; i < m_chartObject.EqualParaCurvesE.length; i++) {
      m_isDrawEquepEtaCurve = true;
      var points = m_chartObject.EqualParaCurvesE[i].PointInfo;
      if (points.length >= 4) {
        //曲线
        createCurveQH(
          "EqualParaCurvesE" + i,
          points,
          1,
          m_displayStyle.ColorEqualParaCurvesE
        );
      } else if (points.length == 3) {
        //也按直线绘制
        createLineQH(
          "EqualParaCurvesEA" + i,
          points[0],
          points[1],
          1,
          m_displayStyle.ColorEqualParaCurvesE
        );
        createLineQH(
          "EqualParaCurvesEB" + i,
          points[1],
          points[2],
          1,
          m_displayStyle.ColorEqualParaCurvesE
        );
      } else if (points.length == 2 || points.length == 3) {
        //直线
        createLineQH(
          "EqualParaCurvesE" + i,
          points[0],
          points[1],
          1,
          m_displayStyle.ColorEqualParaCurvesE
        );
      } else if (points.length == 1) {
        //点
        createPointQH(
          "EqualParaCurvesE" + i,
          points[0],
          3,
          m_displayStyle.ColorEqualParaCurvesE
        );
      }
    }
  };
  //绘制性能曲线
  var drawFeatCurve = function () {
    //绘制线
    if (m_chartType == ConstParas.ChartType.Cut) {
      if (m_displayStyle.LxpCurveBundleDispStyle == 0) {
        //只绘制工作曲线
        drawAllCurve_Cut_Wrk();

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

        calcAllowRegionCurve();

        calcPerferRegionCurve();

      } else if (m_displayStyle.LxpCurveBundleDispStyle == 1) {
        //只绘制最大最小工作曲线
        drawAllCurve_Cut_Full_singleColor();

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

        //绘制型谱
        drawSpectrumShape();

        //绘制区域
        calcAllowRegionCurve();
        calcPerferRegionCurve();

        //等效线
        drawEquepEtaCurveList();

        //最小流量线
        drawMinContinueFlowCurve();

        //绘制文字
        drawChartTextAnnotation();


      } else {

        if (m_displayStyle.IsMultiColorCurve) {
          drawAllCurve_Cut_Full_multiColor();
        } else {
          drawAllCurve_Cut_Full_singleColor();
        }

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

        //绘制型谱
        drawSpectrumShape();

        //绘制区域
        calcAllowRegionCurve();
        calcPerferRegionCurve();

        //等效线
        drawEquepEtaCurveList();

        //最小流量线
        drawMinContinueFlowCurve();

        //叶轮外径提示框
        drawCurveParasPanel();


        //绘制文字
        drawChartTextAnnotation();
      }
    } else if (m_chartType == ConstParas.ChartType.Speed) {
      if (m_displayStyle.LxpCurveBundleDispStyle == 0) {
        //只绘制工作曲线
        drawAllCurve_Speed_Wrk();
        //初始化工作曲线
        intitalWrkCurveInfo();

      } else {
        drawAllCurve_Speed_Full();

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

        //等效线
        drawEquepEtaCurveList();

        //绘制型谱
        drawSpectrumShape();

        calcAllowRegionCurve();
        calcPerferRegionCurve();

        //绘制文字
        drawChartTextAnnotation();
      }
    } else if (m_chartType == ConstParas.ChartType.BaoLuo) {

      drawAllCurve_BaoLuo();

    } else {
      return;
    }
  };
  //切割,工作曲线
  var drawAllCurve_Cut_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;
    }

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

      if (m_isDispCurveQE)
        createCurveQE(
          "SimWaterCurveQE",
          m_chartObject.SimWaterCurveQE,
          fullCurveWidth
        );
      if (m_isDispCurveQP)
        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"
          );
        if (m_isDispCurveQP)
          createCurveQP(
            "SimJieZhiCurveQP",
            m_chartObject.SimJieZhiCurveQP,
            1,
            null,
            true,
            "10, 10"
          );
      }
    } else {
      //
      var curveMaxPathQH = createCurveQH(
        "MaxWaterCurveQH",
        m_chartObject.MaxWaterCurveQH,
        fullCurveWidth
      );

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

      if (m_isDispCurveQP)
        createCurveQP(
          "MaxWaterCurveQP",
          m_chartObject.MaxWaterCurveQP,
          fullCurveWidth
        );

      createCurveNPSH(
        "MaxWaterCurveNPSH",
        m_chartObject.MaxWaterCurveNPSH,
        fullCurveWidth
      );
    }
  };
  //切割,全部, 单色
  var drawAllCurve_Cut_Full_singleColor = function () {
    if (m_pumpInfo.MaxD2 == null || m_pumpInfo.MaxD2 < 1) {
      console.log("m_pumpInfo.MaxD2 is null:" + m_pumpInfo.MaxD2);
      return;
    }

    //最大叶轮外径
    var maxCurveWidth = 2;
    if (
      m_chartObject.MaxWaterCurveQH != null &&
      Math.abs(m_pumpInfo.WrkD2 - m_pumpInfo.MaxD2) > 1
    ) {
      var curveMaxPathQH = createCurveQH(
        "MaxWaterCurveQH",
        m_chartObject.MaxWaterCurveQH,
        maxCurveWidth
      );

      if (m_isDispCurveQE && m_chartObject.MaxWaterCurveQE != null) {
        createCurveQE(
          "MaxWaterCurveQE",
          m_chartObject.MaxWaterCurveQE,
          maxCurveWidth
        );
      }

      if (m_isDispCurveQP && m_chartObject.MaxWaterCurveQP != null) {
        createCurveQP(
          "MaxWaterCurveQP",
          m_chartObject.MaxWaterCurveQP,
          maxCurveWidth
        );
      }
    }
    //   绘制其他切割线 
    if (m_chartObject.SpectrumList != null && m_displayStyle.LxpCurveBundleDispStyle == 2) {

      for (var i = 0; i < m_chartObject.SpectrumList.length; i++) {
        var subSpectrumCurve = m_chartObject.SpectrumList[i];

        if (subSpectrumCurve.IsVisible == false)
          continue;

        if (Math.abs(m_pumpInfo.WrkD2 - subSpectrumCurve.CurvePara) < 0.4)
          continue;
        if (Math.abs(m_pumpInfo.MinD2 - subSpectrumCurve.CurvePara) < 0.4)
          continue;

 

        if (subSpectrumCurve.QH != null) {
          var curve_points_pixl = createCurveQH(
            "SpectrumList" + i,
            subSpectrumCurve.QH,
            maxCurveWidth
          );
        }

        if (m_isDispCurveQP && subSpectrumCurve.QP != null) {
          var curve_points_pixl = createCurveQP(
            "SpectrumList" + i,
            subSpectrumCurve.QP,
            maxCurveWidth
          );
        }
      }
    }

    //最小叶轮外径
    var minCurveWidth = 2;
    if (
      m_chartObject.MinWaterCurveQH != null &&
      Math.abs(m_pumpInfo.WrkD2 - m_pumpInfo.MinD2) > 1
    ) {
      var curveMinPathQH = createCurveQH(
        "MinWaterCurveQH",
        m_chartObject.MinWaterCurveQH,
        minCurveWidth
      );

      if (m_isDispCurveQP && m_chartObject.MinWaterCurveQP != null) {
        var curveMinPathQP = createCurveQP(
          "MinWaterCurveQP",
          m_chartObject.MinWaterCurveQP,
          minCurveWidth
        );
      }
    }

    var color_wrk_curve = "black";
    if (m_chartObject != null) {
      m_chartObject.WorkCurveColorQH = color_wrk_curve;
      m_chartObject.WorkCurveColorQE = color_wrk_curve;
      m_chartObject.WorkCurveColorQP = color_wrk_curve;
      m_chartObject.WorkCurveColorQNPSH = color_wrk_curve;
    }

    //工作曲线
    var simuWaterCurveWidth = 3;
    m_curveColorDict.push({
      color: color_wrk_curve,
      para: m_pumpInfo.WrkD2,
      type: "wrk",
    });
    if (m_chartObject.SimWaterCurveQH != null) {

      var curveSimuPathQH = createCurveQH(
        "SimWaterCurveQH",
        m_chartObject.SimWaterCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve
      );
    } else if (m_chartObject.MaxWaterCurveQH != null) {

      var curveSimuPathQH = createCurveQH(
        "SimWaterCurveQH",
        m_chartObject.MaxWaterCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve
      );
    }

    //效率
    if (m_isDispCurveQE) {
      removeElementById("MaxWaterCurveQE"); //只显示一条效率线
      if (m_chartObject.SimWaterCurveQE != null) {
        var curveSimuPathQE = createCurveQE(
          "SimWaterCurveQE",
          m_chartObject.SimWaterCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else {
        var curveSimuPathQE = createCurveQE(
          "SimWaterCurveQE",
          m_chartObject.MaxWaterCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    }

    //功率
    if (m_isDispCurveQP) {
      if (m_chartObject.SimWaterCurveQP != null) {
        createCurveQP(
          "SimWaterCurveQP",
          m_chartObject.SimWaterCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else {
        createCurveQP(
          "SimWaterCurveQP",
          m_chartObject.MaxWaterCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    }

    //介质
    if (m_chartObject.SimJieZhiCurveQH != null) {
      createCurveQH(
        "SimJieZhiCurveQH",
        m_chartObject.SimJieZhiCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve,
        true,
        "10, 10"
      );
      if (m_isDispCurveQE && m_chartObject.SimJieZhiCurveQE != null)
        createCurveQE(
          "SimJieZhiCurveQE",
          m_chartObject.SimJieZhiCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve,
          true,
          "10, 10"
        );
      if (m_isDispCurveQP && m_chartObject.SimJieZhiCurveQP != null)
        createCurveQP(
          "SimJieZhiCurveQP",
          m_chartObject.SimJieZhiCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve,
          true,
          "10, 10"
        );
    }

    //气蚀
    if (m_chartObject.NpshCurveStatus != 2) {
      //只有一条
      if (m_chartObject.SimWaterCurveNPSH != null) {
        createCurveNPSH(
          "SimWaterCurveNPSH",
          m_chartObject.SimWaterCurveNPSH,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else if (m_chartObject.MaxWaterCurveNPSH != null) {
        createCurveNPSH(
          "SimWaterCurveNPSH",
          m_chartObject.MaxWaterCurveNPSH,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    } else {
      if (
        m_chartObject.MaxWaterCurveNPSH &&
        m_chartObject.NpshMaxCurveDispStatus == 1
      ) {
        createCurveNPSH(
          "MaxWaterCurveNPSH",
          m_chartObject.MaxWaterCurveNPSH,
          maxCurveWidth,
          color_max_curve
        );
      }
      if (
        m_chartObject.MinWaterCurveNPSH &&
        m_chartObject.NpshMinCurveDispStatus == 1
      ) {
        createCurveNPSH(
          "MinWaterCurveNPSH",
          m_chartObject.MinWaterCurveNPSH,
          minCurveWidth,
          color_min_curve
        );
      }
      if (m_chartObject.SimWaterCurveNPSH) {
        createCurveNPSH(
          "SimWaterCurveNPSH",
          m_chartObject.SimWaterCurveNPSH,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else {
        createCurveNPSH(
          "MaxWaterCurveNPSH",
          m_chartObject.MaxWaterCurveNPSH,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    }
  };
  // 切割,全部, 含其他切割线(多彩)
  var drawAllCurve_Cut_Full_multiColor = function () {
    if (m_pumpInfo.MaxD2 == null || m_pumpInfo.MaxD2 < 1) {
      return;
    }

    m_curveColorDict = []; //曲线颜色

    //最大叶轮外径
    if (
      m_chartObject.MaxWaterCurveQH != null &&
      Math.abs(m_pumpInfo.WrkD2 - m_pumpInfo.MaxD2) > 1
    ) {
      var maxCurveWidth = 2;
      var color_max_curve = getCurveColor(0);

      m_curveColorDict.push({
        color: color_max_curve,
        para: m_pumpInfo.MaxD2,
        type: "max",
      });

      var curveMaxPathQH = createCurveQH(
        "MaxWaterCurveQH",
        m_chartObject.MaxWaterCurveQH,
        maxCurveWidth,
        color_max_curve
      );

      if (m_isDispCurveQE && m_chartObject.MaxWaterCurveQE != null) {
        createCurveQE(
          "MaxWaterCurveQE",
          m_chartObject.MaxWaterCurveQE,
          maxCurveWidth,
          color_max_curve
        );
      }

      if (m_isDispCurveQP && m_chartObject.MaxWaterCurveQP != null) {
        createCurveQP(
          "MaxWaterCurveQP",
          m_chartObject.MaxWaterCurveQP,
          maxCurveWidth,
          color_max_curve
        );
      }
    }

    var color_wrk_curve = "black";
    if (m_chartObject != null) {
      m_chartObject.WorkCurveColorQH = color_wrk_curve;
      m_chartObject.WorkCurveColorQE = color_wrk_curve;
      m_chartObject.WorkCurveColorQP = color_wrk_curve;
      m_chartObject.WorkCurveColorQNPSH = color_wrk_curve;
    }

    //工作曲线
    var simuWaterCurveWidth = 3;
    m_curveColorDict.push({
      color: color_wrk_curve,
      para: m_pumpInfo.WrkD2,
      type: "wrk",
    });
    if (m_chartObject.SimWaterCurveQH != null) {
      var curveSimuPathQH = createCurveQH(
        "SimWaterCurveQH",
        m_chartObject.SimWaterCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve
      );
    } else {
      var curveSimuPathQH = createCurveQH(
        "SimWaterCurveQH",
        m_chartObject.MaxWaterCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve
      );
    }
    if (m_isDispCurveQE) {
      removeElementById("MaxWaterCurveQE"); //只显示一条效率线
      if (m_chartObject.SimWaterCurveQE != null) {
        var curveSimuPathQE = createCurveQE(
          "SimWaterCurveQE",
          m_chartObject.SimWaterCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else {
        var curveSimuPathQE = createCurveQE(
          "SimWaterCurveQE",
          m_chartObject.MaxWaterCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    }
    if (m_isDispCurveQP) {
      if (m_chartObject.SimWaterCurveQP != null) {
        createCurveQP(
          "SimWaterCurveQP",
          m_chartObject.SimWaterCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else {
        createCurveQP(
          "SimWaterCurveQP",
          m_chartObject.MaxWaterCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    }

    //介质工作曲线
    if (m_chartObject.SimJieZhiCurveQH != null) {
      createCurveQH(
        "SimJieZhiCurveQH",
        m_chartObject.SimJieZhiCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve,
        true,
        "10, 10"
      );
      if (m_isDispCurveQE && m_chartObject.SimJieZhiCurveQE != null)
        createCurveQE(
          "SimJieZhiCurveQE",
          m_chartObject.SimJieZhiCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve,
          true,
          "10, 10"
        );
      if (m_isDispCurveQP && m_chartObject.SimJieZhiCurveQP != null)
        createCurveQP(
          "SimJieZhiCurveQP",
          m_chartObject.SimJieZhiCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve,
          true,
          "10, 10"
        );
    }
    //   绘制其他切割线
    if (m_chartObject.SpectrumList != null) {

      for (var i = 0; i < m_chartObject.SpectrumList.length; i++) {
        var subSpectrumCurve = m_chartObject.SpectrumList[i];

        if (subSpectrumCurve.IsVisible == false)
          //可能靠得太近, 就不显示了
          continue;
        if (Math.abs(m_pumpInfo.WrkD2 - subSpectrumCurve.CurvePara) < 0.4)
          continue;
        if (Math.abs(m_pumpInfo.MinD2 - subSpectrumCurve.CurvePara) < 0.4)
          continue;

        var color_curve = getCurveColor(m_curveColorDict.length);

        m_curveColorDict.push({
          color: color_curve,
          para: subSpectrumCurve.CurvePara,
          type: "simu",
        });

        if (subSpectrumCurve.QH != null) {
          var curve_points_pixl = createCurveQH(
            "SpectrumList" + i,
            subSpectrumCurve.QH,
            2,
            color_curve
          );
        }

        if (m_isDispCurveQP && subSpectrumCurve.QP != null) {
          var curve_points_pixl = createCurveQP(
            "SpectrumList" + i,
            subSpectrumCurve.QP,
            2,
            color_curve
          );
        }
      }
    }

    //最小叶轮外径
    var minCurveWidth = 2;
    if (
      m_chartObject.MinWaterCurveQH != null &&
      Math.abs(m_pumpInfo.WrkD2 - m_pumpInfo.MinD2) > 1
    ) {
      var color_min_curve = getCurveColor(m_curveColorDict.length);
      m_curveColorDict.push({
        color: color_min_curve,
        para: m_pumpInfo.MinD2,
        type: "min",
      });

      var curveMinPathQH = createCurveQH(
        "MinWaterCurveQH",
        m_chartObject.MinWaterCurveQH,
        minCurveWidth,
        color_min_curve
      );

      if (m_isDispCurveQP && m_chartObject.MinWaterCurveQP != null) {
        var curveMinPathQP = createCurveQP(
          "MinWaterCurveQP",
          m_chartObject.MinWaterCurveQP,
          minCurveWidth,
          color_min_curve
        );
      }
    }

    //气蚀
    if (m_chartObject.NpshCurveStatus != 2) {
      //只有一条
      if (m_chartObject.SimWaterCurveNPSH != null) {
        createCurveNPSH(
          "SimWaterCurveNPSH",
          m_chartObject.SimWaterCurveNPSH,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else if (m_chartObject.MaxWaterCurveNPSH != null) {
        createCurveNPSH(
          "SimWaterCurveNPSH",
          m_chartObject.MaxWaterCurveNPSH,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    } else {
      if (
        m_chartObject.MaxWaterCurveNPSH &&
        m_chartObject.NpshMaxCurveDispStatus == 1
      ) {
        createCurveNPSH(
          "MaxWaterCurveNPSH",
          m_chartObject.MaxWaterCurveNPSH,
          maxCurveWidth,
          color_max_curve
        );
      }
      if (
        m_chartObject.MinWaterCurveNPSH &&
        m_chartObject.NpshMinCurveDispStatus == 1
      ) {
        createCurveNPSH(
          "MinWaterCurveNPSH",
          m_chartObject.MinWaterCurveNPSH,
          minCurveWidth,
          color_min_curve
        );
      }
      if (m_chartObject.SimWaterCurveNPSH) {
        createCurveNPSH(
          "SimWaterCurveNPSH",
          m_chartObject.SimWaterCurveNPSH,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else {
        createCurveNPSH(
          "MaxWaterCurveNPSH",
          m_chartObject.MaxWaterCurveNPSH,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    }
  };
  //叶轮外径参数面板框
  var drawCurveParasPanel = function () {
    if (m_displayStyle.IsDispCurveParasPanel == false)
      return;
    if (m_displayStyle.IsMultiColorCurve == false)
      return;
    if (m_curveColorDict == null) return;
    var curve_count = m_curveColorDict.length;
    if (curve_count < 2) return;

    var tip_cell_height = 20;

    var _curveDiaTipRectangleWidth = 70;
    var _curveDiaTipRectangleHeight = curve_count * tip_cell_height;

    m_curveColorDict.sort((a, b) => b.para - a.para);

    for (var i = 0; i < curve_count; i++) {
      var sapce = tip_cell_height * i + tip_cell_height / 2;

      var para = m_curveColorDict[i].para;
      var color = m_curveColorDict[i].color;

      createLine_pixel(
        null,
        {
          X: m_chartSize.DiagramRight - _curveDiaTipRectangleWidth,
          Y: m_chartSize.UpDiagram.Up + tip_cell_height * i + tip_cell_height,
        },
        {
          X: m_chartSize.DiagramRight,
          Y: m_chartSize.UpDiagram.Up + tip_cell_height * i + tip_cell_height,
        },
        1,
        "black"
      );

      drawText_pixel(
        null,
        "--- Ø" + para,
        {
          X: m_chartSize.DiagramRight - _curveDiaTipRectangleWidth + 6,
          Y: m_chartSize.UpDiagram.Up + sapce + 5,
        },
        13,
        color,
        "start",
        "font-weight:bold;"
      );
    }
    createLine_pixel(
      null,
      {
        X: m_chartSize.DiagramRight - _curveDiaTipRectangleWidth,
        Y: m_chartSize.UpDiagram.Up,
      },
      {
        X: m_chartSize.DiagramRight - _curveDiaTipRectangleWidth,
        Y: m_chartSize.UpDiagram.Up + _curveDiaTipRectangleHeight,
      },
      1,
      "black"
    );
  };

  //变频,全部曲线
  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;
    // }

    //最大
    if (
      m_chartObject.MaxWaterCurveQH != null &&
      Math.abs(m_pumpInfo.WrkSpeed - m_pumpInfo.Ratedn) > 1
    ) {

      var maxCurveWidth = 2;

      var curveMaxPathQH = createCurveQH(
        "MaxWaterCurveQH",
        m_chartObject.MaxWaterCurveQH,
        maxCurveWidth
      );

      if (m_isDispCurveQE && m_chartObject.MaxWaterCurveQE != null) {
        createCurveQE(
          "MaxWaterCurveQE",
          m_chartObject.MaxWaterCurveQE,
          maxCurveWidth
        );
      }

      if (m_isDispCurveQP && m_chartObject.MaxWaterCurveQP != null) {
        createCurveQP(
          "MaxWaterCurveQP",
          m_chartObject.MaxWaterCurveQP,
          maxCurveWidth
        );
      }

      if (m_chartObject.MaxWaterCurveNPSH) {
        createCurveNPSH(
          "MaxWaterCurveNPSH",
          m_chartObject.MaxWaterCurveNPSH,
          maxCurveWidth
        );
      }
    }

    //最小速度
    if (
      m_chartObject.MinWaterCurveQH != null &&
      Math.abs(m_pumpInfo.WrkSpeed - m_pumpInfo.MinSpeed) > 1
    ) {
      var minCurveWidth = 2;
      var curveMinPathQH = createCurveQH(
        "MinWaterCurveQH",
        m_chartObject.MinWaterCurveQH,
        minCurveWidth
      );

      if (m_isDispCurveQP && m_chartObject.MinWaterCurveQP != null) {
        var curveMinPathQP = createCurveQP(
          "MinWaterCurveQP",
          m_chartObject.MinWaterCurveQP,
          minCurveWidth
        );
      }
    }

    var color_wrk_curve = "black";
    if (m_chartObject != null) {
      m_chartObject.WorkCurveColorQH = color_wrk_curve;
      m_chartObject.WorkCurveColorQE = color_wrk_curve;
      m_chartObject.WorkCurveColorQP = color_wrk_curve;
      m_chartObject.WorkCurveColorQNPSH = color_wrk_curve;
    }

    //工作曲线
    var simuWaterCurveWidth = 3;

    if (m_chartObject.SimWaterCurveQH != null) {
      var curveSimuPathQH = createCurveQH(
        "SimWaterCurveQH",
        m_chartObject.SimWaterCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve
      );
    } else {
      var curveSimuPathQH = createCurveQH(
        "SimWaterCurveQH",
        m_chartObject.MaxWaterCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve
      );
    }

    //效率
    if (m_isDispCurveQE) {
      removeElementById("MaxWaterCurveQE"); //只显示一条效率线
      if (m_chartObject.SimWaterCurveQE != null) {
        var curveSimuPathQE = createCurveQE(
          "SimWaterCurveQE",
          m_chartObject.SimWaterCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else {
        var curveSimuPathQE = createCurveQE(
          "SimWaterCurveQE",
          m_chartObject.MaxWaterCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    }

    //功率
    if (m_isDispCurveQP) {
      if (m_chartObject.SimWaterCurveQP != null) {
        createCurveQP(
          "SimWaterCurveQP",
          m_chartObject.SimWaterCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      } else {
        createCurveQP(
          "SimWaterCurveQP",
          m_chartObject.MaxWaterCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve
        );
      }
    }

    //气蚀
    if (m_chartObject.SimWaterCurveNPSH != null) {
      createCurveNPSH(
        "SimWaterCurveNPSH",
        m_chartObject.SimWaterCurveNPSH,
        simuWaterCurveWidth,
        color_wrk_curve
      );
    } else if (m_chartObject.MaxWaterCurveNPSH != null) {
      createCurveNPSH(
        "SimWaterCurveNPSH",
        m_chartObject.MaxWaterCurveNPSH,
        simuWaterCurveWidth,
        color_wrk_curve
      );
    }

    //介质
    if (m_chartObject.SimJieZhiCurveQH != null) {
      createCurveQH(
        "SimJieZhiCurveQH",
        m_chartObject.SimJieZhiCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve,
        true,
        "10, 10"
      );
      if (m_isDispCurveQE && m_chartObject.SimJieZhiCurveQE != null)
        createCurveQE(
          "SimJieZhiCurveQE",
          m_chartObject.SimJieZhiCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve,
          true,
          "10, 10"
        );
      if (m_isDispCurveQP && m_chartObject.SimJieZhiCurveQP != null)
        createCurveQP(
          "SimJieZhiCurveQP",
          m_chartObject.SimJieZhiCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve,
          true,
          "10, 10"
        );
    }
  };
  //变频,工作曲线
  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;
    }

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

      if (m_isDispCurveQE)
        createCurveQE(
          "SimWaterCurveQE",
          m_chartObject.SimWaterCurveQE,
          fullCurveWidth
        );
      if (m_isDispCurveQP)
        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"
          );
        if (m_isDispCurveQP)
          createCurveQP(
            "SimJieZhiCurveQP",
            m_chartObject.SimJieZhiCurveQP,
            1,
            null,
            true,
            "10, 10"
          );
      }
    } else {
      var curveMaxPathQH = createCurveQH(
        "MaxWaterCurveQH",
        m_chartObject.MaxWaterCurveQH,
        fullCurveWidth
      );

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

      if (m_isDispCurveQP)
        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
    );


    if (m_isDispCurveQE)
      createCurveQE(
        "MaxWaterCurveQE",
        m_chartObject.MaxWaterCurveQE,
        maxCurveWidth
      );
    if (m_isDispCurveQP)
      createCurveQP(
        "MaxWaterCurveQP",
        m_chartObject.MaxWaterCurveQP,
        maxCurveWidth
      );
    createCurveNPSH(
      "MaxWaterCurveNPSH",
      m_chartObject.MaxWaterCurveNPSH,
      maxCurveWidth
    );

    //介质
    if (m_chartObject.SimJieZhiCurveQH != null) {
      var simuWaterCurveWidth = 1;
      var color_wrk_curve = "black";
      createCurveQH(
        "SimJieZhiCurveQH",
        m_chartObject.SimJieZhiCurveQH,
        simuWaterCurveWidth,
        color_wrk_curve,
        true,
        "10, 10"
      );
      if (m_isDispCurveQE && m_chartObject.SimJieZhiCurveQE != null)
        createCurveQE(
          "SimJieZhiCurveQE",
          m_chartObject.SimJieZhiCurveQE,
          simuWaterCurveWidth,
          color_wrk_curve,
          true,
          "10, 10"
        );
      if (m_isDispCurveQP && m_chartObject.SimJieZhiCurveQP != null)
        createCurveQP(
          "SimJieZhiCurveQP",
          m_chartObject.SimJieZhiCurveQP,
          simuWaterCurveWidth,
          color_wrk_curve,
          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.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 () {
    removeElementById("EquipmentCurve");
    if (m_equipCurve == null) return;
    if (m_equipCurve.DpSectPt == null) return;
    if (m_equipCurve.isVisble == false) return;


    var pointNumber = 20;
    var equipmentCurvePts = [];
    var space = m_equipCurve.DpSectPt.X / (pointNumber - 1.0);
    var k =
      (m_equipCurve.DpSectPt.Y - m_equipCurve.ZeroH) /
      (m_equipCurve.DpSectPt.X * m_equipCurve.DpSectPt.X);

    for (var i = 0; i < pointNumber; i++) {
      var pt = {};
      pt.X = space * i;
      if (Object.is(pt.X, NaN)) continue;

      pt.Y = m_equipCurve.ZeroH + k * pt.X * pt.X;
      if (
        pt.Y <
        m_coordinatePara.DispMinH -
        m_coordinatePara.DislocationNumUp * m_coordinatePara.SpaceH
      )
        continue;
      equipmentCurvePts.push(pt);
    }

    if (equipmentCurvePts.length < 4) return;

    createCurveQH(
      "EquipmentCurve",
      equipmentCurvePts,
      1,
      m_displayStyle.ColorEquipment
    );
  };

  //绘制查询竖直指导线 
  var drawQueryIndicatVertLine = function (index) {

    //
    removeElementById("infoDv4VerticalLine1");
    removeElementById("infoDv4VerticalLine2");

    var obj_divChart = document.getElementById(m_divChartName);

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

    obj_divChart.appendChild(info_div1);


    var info_div2 = document.createElement("div");
    info_div2.innerHTML = "<lable style='font-size:7px'>" + getTranslateString("流量") + "</label>";
    info_div2.id = "infoDv4VerticalLine2";
    info_div2.style.display = 'none';
    info_div2.style.position = 'relative';
    info_div2.style.color = 'gray';
    info_div2.style.fontSize = '9px';
    info_div2.style.textAlign = "left";
    info_div2.style.width = "120px";
    info_div2.style.left = (m_chartSize.DiagramRight - 120).toString() + "px";
    info_div2.style.top = (120 - m_chartSize.TotalHeight).toString() + "px";

    obj_divChart.appendChild(info_div2);



    var attr4verticalLine1 = {
      "stroke": "rgb(136 136 221)",
      "stroke-width": "3",
      "fill": "none",
      "zIndex": 100,
      "stroke-dasharray": "18 3",
      "cursor": 'pointer',
      "stroke-opacity": '1',
      "shape-rendering": "geometricPrecision",
    };
    var attr4verticalLine2 = {
      "stroke": "rgb(175 175 235)",
      "stroke-width": "3",
      "fill": "none",
      "zIndex": 100,
      "stroke-dasharray": "18 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
    }, attr4verticalLine1, null);

    var pathValue2 = [];
    var vertialLinePathName2 = "verticalLine2";
    pathValue2.push("M ", xStartValuePixel, " ", m_chartSize.UpDiagram.Up, " L ", xStartValuePixel, " ", m_chartSize.DownDiagram.Bottom);
    m_svg.createPath(vertialLinePathName2, pathValue1.join(''), {
      id: vertialLinePathName2
    }, attr4verticalLine2, null);


    drawQueryDataInfoByPixel(xStartValuePixel, 1);
    drawQueryDataInfoByPixel(xStartValuePixel, 2);

    var isMoveVerticalLine1 = false;
    var objIndicatorLine1 = document.getElementById("verticalLine1");
    objIndicatorLine1.onmousedown = function (e) {
      isMoveVerticalLine1 = true;
      e.preventDefault();
    }

    var isMoveVerticalLine2 = false;
    var objIndicatorLine2 = document.getElementById("verticalLine2");
    objIndicatorLine2.onmousedown = function (e) {
      isMoveVerticalLine2 = true;
      e.preventDefault();
    }

    obj_divChart.onmousemove = function (e) {
      if (isMoveVerticalLine1 == true) {
        if (objIndicatorLine1 == null)
          return;
        var svg_root = m_svg.getRootNode();
        const box = svg_root.getBoundingClientRect();
        var top = box.top + window.scrollY - document.documentElement.clientTop;
        var left = box.left + window.scrollX - document.documentElement.clientLeft
        var e = window.event || e;
        if (e.clientX - left > m_chartSize.DiagramLeft &&
          m_chartSize.DiagramRight + left - e.clientX > 0 &&
          e.clientY - top > m_chartSize.DiagramTop &&
          m_chartSize.DiagramBottom + top - e.clientY > 0) {
          //当前鼠标位置 x的像素
          var xPixel = parseFloat(e.clientX - left);
          //   
          drawQueryDataInfoByPixel(xPixel, 1);
          //修改位置
          var pathValue1 = [];
          pathValue1.push("M ", xPixel, " ", m_chartSize.UpDiagram.Up, " L ", xPixel, " ", m_chartSize.DownDiagram.Bottom);
          objIndicatorLine1.setAttribute('d', pathValue1.join(''));
        }
      }

      if (isMoveVerticalLine2 == true) {
        if (objIndicatorLine2 == null)
          return;
        var svg_root = m_svg.getRootNode();
        const box = svg_root.getBoundingClientRect();
        var top = box.top + window.scrollY - document.documentElement.clientTop;
        var left = box.left + window.scrollX - document.documentElement.clientLeft
        var e = window.event || e;
        if (e.clientX - left > m_chartSize.DiagramLeft &&
          m_chartSize.DiagramRight + left - e.clientX > 0 &&
          e.clientY - top > m_chartSize.DiagramTop &&
          m_chartSize.DiagramBottom + top - e.clientY > 0) {
          //当前鼠标位置 x的像素
          var xPixel = parseFloat(e.clientX - left);
          //   
          drawQueryDataInfoByPixel(xPixel, 2);
          //修改位置
          var pathValue1 = [];
          pathValue1.push("M ", xPixel, " ", m_chartSize.UpDiagram.Up, " L ", xPixel, " ", m_chartSize.DownDiagram.Bottom);
          objIndicatorLine2.setAttribute('d', pathValue1.join(''));
        }
      }
    };
    obj_divChart.onmouseup = function (e) {
      if (isMoveVerticalLine1) {
        isMoveVerticalLine1 = false;
      }
      if (isMoveVerticalLine2) {
        isMoveVerticalLine2 = false;
      }
    };


    //设置显示
    setQueryIndicatVertLineVisible(m_dispVerticalLine1, 1);
    setQueryIndicatVertLineVisible(m_dispVerticalLine2, 2);
  };
  //获取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) {
          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 calculateE = function (Q, H, P, midu) {
      var gavity = 9.81;
      P = P * 1000;//此处 1000 是 kw换成w 
      Q = Q / 3600;//此处 3600 是 小时换成秒
      var E = 0;
      if (P < 0.1)
          E = 0;
      else
          E = midu * gavity * Q * H / P;
      return Math.round(E * 100, 2);//效率用百分数
  };
  var calculateP = function (Q, H, E, midu) {
      var gavity = 9.81;
      H = H * 1000 / gavity;//换成m
      E = E / 100;//效率用百分数
      Q = Q / 1000;//此处 1000 是 L/s
      var P = 0;
      if (E < 0.01)
          P = 0;
      else
          P = midu * gavity * Q * H / E;
      return Math.round(P / 1000, 2);//此处 1000 是 kw换成w 
  };  
  //绘制/显示 参数查询信息
  var drawQueryDataInfoByPixel = function (xPixel, index) {//x的像素   
    if (xPixel == null)
      return;
    if (m_wrkCurveGrp == null)
      return;
    if (m_wrkCurveGrp.PixelQH == null)
      return;
    //流量  
    let flow_m3h = getActualValueQ(xPixel);
    if (flow_m3h == null)
      return;

    drawQueryDataInfoByReal(flow_m3h, xPixel, index);
  };
  //绘制/显示 参数查询信息 ( flow_m3h 实际值 )
  var drawQueryDataInfoByReal = function (flow_m3h, xPixel, index) {

    if (flow_m3h < 0.1)
      return;

    var query_pt = {};


    var flow_info = {};
    flow_info.text = getTranslateString("流量");
    flow_info.value = UnitHelper.getDispValueQ(UnitHelper.ConvertQ_fromM3H(m_unit.Q, flow_m3h));
    flow_info.unit = UnitHelper.GetUnitNameQ(m_unit.Q);
    if (flow_info.value == null || flow_info.value == "")
      return;
    query_pt.Q = flow_m3h;

    //扬程  
    var head_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQH, xPixel);
    if (head_pixel_pt == null)
      return;
    var head_m = 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_m));
    query_pt.H = head_m;

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

        eff_info.text = getTranslateString("效率");
        eff_info.value = parseFloat(eta_std.toFixed(1));
        eff_info.unit = "%";

        query_pt.E = parseFloat(eta_std.toFixed(1));
      }
    }

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

        query_pt.P = power_kw;
      }
    }
        //0 计算效率 1 计算功率  2 不计算 
        if (m_chartObject.SimJieZhiCurveQP == null && query_pt.E>0) {//有介质曲线，暂时不考虑，不然要传入密度
          if (m_groupPointQeMethod == 0) {
              query_pt.E = parseFloat(calculateE(query_pt.Q, query_pt.H, query_pt.P, 1000).toFixed(1));
              eff_info.value = query_pt.E;
          } else if (m_groupPointQeMethod == 1) {
              query_pt.P = parseFloat(calculateP(query_pt.Q, query_pt.H, query_pt.E, 1000).toFixed(2));
              power_info.value = UnitHelper.getDispValueP(UnitHelper.ConvertP_fromKW(m_unit.P, query_pt.P));
          }
      }


    var npsh_info = {};//汽蚀  
    npsh_info.text = getTranslateString("汽蚀");
    npsh_info.value = '';
    npsh_info.unit = UnitHelper.GetUnitNameH(m_unit.NPSH);

    if (m_wrkCurveGrp.PixelNPSH != null && m_isDispNpsh) {
      var npsh_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelNPSH, xPixel);

      if (npsh_pixel_pt != null) {
        npsh_info.unit = UnitHelper.GetUnitNameNPSH(m_unit.NPSH);
        var npsh_m = getActualValueNPSH(npsh_pixel_pt.Y);
        npsh_info.value = UnitHelper.getDispValueNPSH(UnitHelper.ConvertNPSH_fromM(m_unit.NPSH, npsh_m));

        query_pt.NPSH = npsh_m;
      }
    }

    var tip_html = "";
    var flow_html = flow_info.text + ": &nbsp;&nbsp;" + flow_info.value + "&nbsp;&nbsp;" + flow_info.unit;
    tip_html = flow_html;

    var head_html = head_info.text + ": &nbsp;&nbsp;" + head_info.value + "&nbsp;&nbsp;" + head_info.unit;
    tip_html += "</br>" + head_html;

    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;
    }
    if (index == 2) {
      var objInfo = document.getElementById("infoDv4VerticalLine2");
      if (objInfo != null) {
        objInfo.innerHTML = tip_html;
        objInfo.style.display = "";
      }
    }
    else {
      var objInfo = document.getElementById("infoDv4VerticalLine1");
      if (objInfo != null) {
        objInfo.innerHTML = tip_html;
        objInfo.style.display = "";
      }

      //获取查询曲线查询得到的数据 给参数查询使用
      if (onChangeQueryDataCb != null) {
        onChangeQueryDataCb(query_pt)
      }
    }


  };
  //根据流量获取点(m3h单位下的)
  var getGrpPointInWrkCurveByFlow = function (flow_m3h) {
    if (flow_m3h == null) return null;
    if (typeof flow_m3h == "string") flow_m3h = parseFloat(flow_m3h);

    if (flow_m3h < 0.1) return null;

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

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

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

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

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

    var grp_pt = {};
    grp_pt.Q = flow_m3h;
    grp_pt.H = head_m;
    grp_pt.E = eta_std;
    grp_pt.P = power_kw;
    grp_pt.NPSH = npsh_m;

    return grp_pt;
  };
  //查询线
  var m_dispVerticalLine1 = false;
  var m_dispVerticalLine2 = false;
  var onChangeQueryDataCb = null; //查询外部回调
  //设置查询线 是否显示
  var setQueryIndicatVertLineVisible = function (disp, index) {

    var objInfo;
    var objLine;
    if (index == 2) {
      objLine = document.getElementById("verticalLine2");
      objInfo = document.getElementById("infoDv4VerticalLine2");
    }
    else {
      m_dispVerticalLine1 = disp;
      objInfo = document.getElementById("infoDv4VerticalLine1");
      objLine = document.getElementById("verticalLine1");
    }
    if (objInfo != null && objLine != null) {
      if (disp) {
        objInfo.style.display = '';
        objLine.style.display = '';
      }
      else {
        objInfo.style.display = 'none';
        objLine.style.display = 'none';
      }
    }

  };
  //设置查询线 的值
  var setQueryIndicatValue = function (flow_m3h, index) {
    if (index == 2) {
      m_dispVerticalLine2 = true;
      setQueryIndicatVertLineVisible(m_dispVerticalLine2, 2);
      return setQueryIndicatValue2(flow_m3h);
    }
    else {
      m_dispVerticalLine1 = true;
      setQueryIndicatVertLineVisible(m_dispVerticalLine1, 1);
      return setQueryIndicatValue1(flow_m3h);
    }
  };
  var setQueryIndicatValue1 = function (flow_m3h) {
    if (m_dispVerticalLine1 == false)
      return;

    var xPixel = getPixelValueQ(flow_m3h);

    var pathValue1 = [];
    pathValue1.push("M ", xPixel, " ", m_chartSize.UpDiagram.Up, " L ", xPixel, " ", m_chartSize.DownDiagram.Bottom);

    var objLine = document.getElementById("verticalLine1");
    if (objLine == null)
      return;

    objLine.setAttribute('d', pathValue1.join(''));

    drawQueryDataInfoByReal(flow_m3h, xPixel, 1);
  };
  var setQueryIndicatValue2 = function (flow_m3h) {
    m_dispVerticalLine2 = true;

    var xPixel = getPixelValueQ(flow_m3h);

    var pathValue1 = [];
    pathValue1.push("M ", xPixel, " ", m_chartSize.UpDiagram.Up, " L ", xPixel, " ", m_chartSize.DownDiagram.Bottom);

    var objLine = document.getElementById("verticalLine2");
    if (objLine == null)
      return;

    objLine.setAttribute('d', pathValue1.join(''));

    drawQueryDataInfoByReal(flow_m3h, xPixel, 2);
  };

  //绘制图表(核心代码)
  var drawChart = function () {
    //面板(含坐标)
    drawDiagramPanel();

    //绘制性能曲线
    drawFeatCurve();

    //设计点
    drawDesignPoint();
    drawWorkPoint();

    //消防点
    drawFirePumpPoint();

    //绘制水印
    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 (var i = 0; i <= m_coordinatePara.GridNumberY; i++) {
      var distance = m_chartSize.UpDiagram.SpaceGridY * i;
      var 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);

    }

    //产生网格线水平方向
    for (var i = 0; i <= m_chartSize.UpDiagram.GridNumberY; i++) {
      var distance = m_chartSize.UpDiagram.SpaceGridY * i;
      var 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);
    }

    if (m_isHaveBottomPanel) {
      //产生网格线竖直方向
      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.DownDiagram.Up,
          " L ",
          m_chartSize.DiagramLeft + distance,
          " ",
          m_chartSize.DownDiagram.Bottom
        );
        m_svg.createPath(null, valueTemp.join(""), attr, null);
      }
      //产生网格线水平方向
      for (var i = 0; i <= m_chartSize.DownDiagram.GridNumberY; i++) {
        var distance = m_chartSize.DownDiagram.SpaceGridY * i;
        var 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 controlPoint = [];
    var smooth_value = 0.6;
    for (var i = 0; i < iPointCout - 1; i++) {
      var x0, y0;
      if (i > 0) {
        x0 = pixelPoints[i - 1].X;
        y0 = pixelPoints[i - 1].Y;
      } else {
        x0 = pixelPoints[i].X;
        y0 = pixelPoints[i].Y;
      }

      var x1 = pixelPoints[i].X;
      var y1 = pixelPoints[i].Y;

      var x2 = pixelPoints[i + 1].X;
      var y2 = pixelPoints[i + 1].Y;

      var x3, y3;
      if (i >= iPointCout - 2) {
        x3 = pixelPoints[i + 1].X;
        y3 = pixelPoints[i + 1].Y;
      } else {
        x3 = pixelPoints[i + 2].X;
        y3 = pixelPoints[i + 2].Y;
      }

      var xc1 = (x0 + x1) / 2.0;
      var yc1 = (y0 + y1) / 2.0;
      var xc2 = (x1 + x2) / 2.0;
      var yc2 = (y1 + y2) / 2.0;
      var xc3 = (x2 + x3) / 2.0;
      var yc3 = (y2 + y3) / 2.0;

      var len1 = Math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
      var len2 = Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
      var len3 = Math.sqrt((x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2));

      var k1 = len1 / (len1 + len2);
      var k2 = len2 / (len2 + len3);

      var xm1 = xc1 + (xc2 - xc1) * k1;
      var ym1 = yc1 + (yc2 - yc1) * k1;

      var xm2 = xc2 + (xc3 - xc2) * k2;
      var ym2 = yc2 + (yc3 - yc2) * k2;

      // Resulting control points. Here smooth_value is mentioned
      // above coefficient K whose value should be in range [0...1].
      var ctrl1_x = xm1 + (xc2 - xm1) * smooth_value + x1 - xm1;
      var ctrl1_y = ym1 + (yc2 - ym1) * smooth_value + y1 - ym1;

      var ctrl2_x = xm2 + (xc2 - xm2) * smooth_value + x2 - xm2;
      var ctrl2_y = ym2 + (yc2 - ym2) * smooth_value + y2 - ym2;

      var bezier = {};
      bezier.Point0 = pixelPoints[i];
      bezier.Point1 = {
        X: ctrl1_x,
        Y: ctrl1_y,
      };

      bezier.Point2 = {
        X: ctrl2_x,
        Y: ctrl2_y,
      };
      bezier.Point3 = pixelPoints[i + 1];
      controlPoint.push(bezier);
    }
    return controlPoint;
  };
  //转成Bezier曲线模型
  var transBezierCurveModel_bak = 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) {
        var x1 =
          pixelPoints[i].X + a * (pixelPoints[i + 1].X - pixelPoints[i].X);
        var y1 =
          pixelPoints[i].Y + a * (pixelPoints[i + 1].Y - pixelPoints[i].Y);
        bezier.Point1 = {
          X: x1,
          Y: y1,
        };
      } else {
        var x1 =
          pixelPoints[i].X + a * (pixelPoints[i + 1].X - pixelPoints[i - 1].X);
        var y1 =
          pixelPoints[i].Y + a * (pixelPoints[i + 1].Y - pixelPoints[i - 1].Y);
        bezier.Point1 = {
          X: x1,
          Y: y1,
        };
      }

      if (i == iPointCout - 2) {
        var x2 =
          pixelPoints[i + 1].X - b * (pixelPoints[i + 1].X - pixelPoints[i].X);
        var y2 =
          pixelPoints[i + 1].Y - b * (pixelPoints[i + 1].Y - pixelPoints[i].Y);
        bezier.Point2 = {
          X: x2,
          Y: y2,
        };
      } else {
        var x2 =
          pixelPoints[i + 1].X - b * (pixelPoints[i + 2].X - pixelPoints[i].X);
        var 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;

    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;

    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;

    return actualValue;
  };

  //  actualValue 是(m3h单位下的值)m_coordinatePara里面的数据单位m3h
  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
    );
  };
  //  actualValue 是(m 单位下的值)m_coordinatePara里面的数据单位m
  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;

    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.setUserSetting = function (
    uiUserSetting,
    seriesUnitQ,
    seriesUnitH,
    seriesUnitP,
    seriesIsD2Meter
  ) {

    if (uiUserSetting == null) return;
    if (uiUserSetting.isAdjustCoordUnitByUserSetting) {
      if (uiUserSetting.Q != null) {
        m_unit.Q = uiUserSetting.Q;
      } else {
        m_unit.Q = seriesUnitQ;
      }

      if (uiUserSetting.H != null) {
        m_unit.H = uiUserSetting.H;
      } else {
        m_unit.H = seriesUnitH;
      }

      if (uiUserSetting.P != null) {
        m_unit.P = uiUserSetting.P;
      } else {
        m_unit.P = seriesUnitP;
      }

      if (uiUserSetting.NPSH != null) {
        m_unit.NPSH = uiUserSetting.NPSH;
      } else {
        m_unit.NPSH = 0;
      }

      if (uiUserSetting.D2 != null) m_d2IsMeter = uiUserSetting.D2;
      else m_d2IsMeter = seriesIsD2Meter;
    } else {
      m_unit.Q = seriesUnitQ;
      m_unit.H = seriesUnitH;
      m_unit.P = seriesUnitP;
      m_d2IsMeter = seriesIsD2Meter;
    }
  };
  //获取单位
  this.getUserUnit = function () {
    return m_unit;
  };
  //转化成m3h流量
  this.transFlowToM3H = function (flow) {
    return UnitHelper.ConvertQ_fromM3H(m_unit.Q, flow);
  };
  //设置是否是单色显示
  this.setMonorColor = function (isMonorColor) {
    document.getElementById(m_divChartName).innerHTML = "";
    setObjectColor(isMonorColor);
    if (!initialSvg()) return;

    drawChart();
  };
  //设置是否是只显示工作曲线
  this.setCurveBundleDispStyle = function (style) {
    m_displayStyle.LxpCurveBundleDispStyle = style;
    document.getElementById(m_divChartName).innerHTML = "";
    if (!initialSvg())
      return;

    drawChart();
  };
  //设置是否是曲线参数显示方式
  this.setCurveParasPanelDisp = function (isDisp) {
    m_displayStyle.IsDispCurveParasPanel = isDisp;

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

    if (!initialSvg()) return;

    drawChart();
  };
  //设置是否是曲线多彩曲线
  this.setCurveMultiColor = function (isMultiColor) {
    m_displayStyle.IsMultiColorCurve = isMultiColor;

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

    if (!initialSvg()) return;

    drawChart();
  };

  //设置是否显示型谱
  this.setSpectrumDisp = function (isDisp) {
    m_displayStyle.IsDispSpectrum = isDisp;
    drawSpectrumShape();
  };
  this.updateCoordinatePara = function (Coordinate) { };
  this.getCoordinatePara = function () {
    return m_coordinatePara;
  };
  //设置容器
  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;
  };
  //设置工具提示栏
  this.setToolTipName = function (toolTipName) { };
  //获取查询曲线查询得到的数据 给参数查询使用
  this.setChangeQueryDataCb = function (cb) {
    onChangeQueryDataCb = cb;
  };
  //查询线 是否显示
  this.setQueryIndicatVertLineVisible = function (isVisible, index) {
    setQueryIndicatVertLineVisible(isVisible, index);
  };
  this.getQueryIndicatVertLineVisible = function (index) {
    if (index == 2)
      return m_dispVerticalLine2;
    else
      return m_dispVerticalLine1;
  };
  //设置查询值
  this.setQueryIndicatValue = function (value, index) {
    setQueryIndicatValue(value, index);
  };

  //初始化图表(入口)
  this.initialChart = function (chartFullInfo, displayStyle, cbDict) {
    if (!m_divChartName) return;

    //清空
    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;
    m_pumpInfo = chartFullInfo.BaseInfo;
    m_chartPointPara = chartFullInfo.ChartPointPara;
    m_groupPointQeMethod = chartFullInfo.SettingInfo.GroupPointQeMethod;
    m_chartObject = chartFullInfo.ChartObjectDict;

    m_coordinatePara = chartFullInfo.ChartObjectDict.Coordinate; 

    //初始化显示设置
    var chartSetting = chartFullInfo.SettingInfo;
    initialDispStyle(displayStyle, chartSetting);

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

    //装置曲线相交点
    if (m_equipCurve == null)
      m_equipCurve = {};
    m_equipCurve.DpSectPt = m_chartObject.EquipmentSectPt;

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

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

    drawChart();

    return this;
  };
  //修改了区域参数的流量(m3h单位下)
  this.refreshRegionByFlow = function (flow_m3h, tag) {
    if (tag == null) return null;
    var pt = getGrpPointInWrkCurveByFlow(flow_m3h);
    if (pt != null) {
      refreshRegionPtPosi(pt, tag);
    }
    return pt;
  };
  //设置设计点是否显示
  this.setDesignPointDisp = (status) => {
    if (status) {
      drawDesignPoint();
    } else {
      removeElementById("DesignPointWater1");
      removeElementById("DesignPointWater2");
      removeElementById("DesignPointWater3");
      removeElementById("DesignPointWater4");
      removeElementById("DesignPointWater5");
    }
  };
  //设置设计点显示方式
  this.setDesignPointDispType = function (dispStyleType) {
    m_displayStyle.DesignPointDispType = dispStyleType;

    drawDesignPoint();
  };
  //根据流量计算功率
  this.calcPowerByFlow = function (flow, unit) {
    if (flow == null || m_wrkCurveGrp == null) return null;
    var flow_m3h = UnitHelper.ConvertQ_toM3H(unit, flow);
    if (flow_m3h < 0.1) return null;

    var xPixel = getPixelValueQ(flow_m3h);
    var power_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQP, xPixel);
    if (power_pixel_pt != null) {
      var power = getActualValueP(power_pixel_pt.Y);

      return parseFloat(power.toFixed(2));
    } else {
      return null;
    }
  };
  //根据流量计算效率
  this.calcEtaByFlow = function (flow, unit) {
    if (flow == null || m_wrkCurveGrp == null) return null;
    var flow_m3h = UnitHelper.ConvertQ_toM3H(unit, flow);
    if (flow_m3h < 0.1) return null;

    var xPixel = getPixelValueQ(flow_m3h);
    var eta_pixel_pt = getBezierPointY(m_wrkCurveGrp.PixelQE, xPixel);
    if (eta_pixel_pt != null) {
      var power = getActualValueE(eta_pixel_pt.Y);

      return parseFloat(power.toFixed(2));
    } else {
      return null;
    }
  };
  //设置装置曲线是否显示
  this.setEquipCurveVisible = function (isVisible) {
    m_equipCurve.isVisble = isVisible;

    if (isVisible) {
      drawEquipmentCurve();
    } else {
      removeElementById("EquipmentCurve");
    }
  };
  this.setEquipCurveZeroH = function (zeroH) {
    if (zeroH == null) return;
    m_equipCurve.ZeroH = zeroH;
    if (m_equipCurve.isVisble) {
      drawEquipmentCurve();
    }
  };
  //获取装置曲线信息(报告会用)
  this.getEquipCurveInfo = function () {
    if (m_equipCurve == null) return null;
    if (m_equipCurve.isVisble == false) return null;
    if (m_equipCurve.DpSectPt == null) return null;
    return {
      //装置曲线(给选型报告用)
      IsDisp: true,
      ZeroPointH: m_equipCurve.ZeroH,
      EndPointX: m_equipCurve.DpSectPt.X,
      EndPointX: m_equipCurve.DpSectPt.Y,
    };
  };
  this.getCoordinatePara = function () {
    return m_coordinatePara;
  };
  this.getChartDispStyle = function () {
    return m_displayStyle;
  };
  //修改了设计点
  this.refreshByDp = function (response) {
    //
    var ChartInfo = response.ChartObjectDict;
    if (ChartInfo == null) return;
    m_chartPointPara = response.ChartPointPara;

    if (response.IsChangeOriginCurve) {
      m_chartObject = ChartInfo;
    }
    else {
      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.WaterWorkPoint = ChartInfo.WaterWorkPoint;
      m_chartObject.JieZhiWorkPoint = ChartInfo.JieZhiWorkPoint;

      m_chartObject.DesignPoint4StdUnit = ChartInfo.DesignPoint4StdUnit;
    }

    m_equipCurve.DpSectPt = ChartInfo.EquipmentSectPt; //装置曲线相交点

    if (m_chartType == ConstParas.ChartType.Cut) {
      m_pumpInfo.WrkD2 = response.BaseInfo.WrkD2;
    } else if (m_chartType == ConstParas.ChartType.Speed) {
      m_pumpInfo.WrkSpeed = response.BaseInfo.WrkSpeed;
    }

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

    // 
    if (!initialSvg()) return;

    drawChart();
  };
  //重绘图表大小
  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;