泵状态更新

Shuxia Ning

2025-02-13 2f1cbec203dcff25df7a5c2b51b13ec558f2c3db

 02-desktop/Model/IStation.Model.Curve/ÇúÏß×ø±ê²ÎÊý/CurveCoordinateParas_Disp.cs

@@ -2,6 +2,764 @@
using System.Collections.Generic;
using System.Linq;

//namespace IStation.Model
//{
//    /// <summary>
//    ///  
//    /// </summary>
//    public partial class CurveCoordinateParas
//    {
//        #region è®¡ç®—显示参数方法

//        #region é»˜è®¤
//        /// <summary>
//        /// æœ€å¤§æµé‡(显示参数)
//        /// </summary> 
//        public double DispMaxQ()
//        {
//            return this.CoordMinQ + (double)this.GridNumberX * this.CoordSpaceQ;
//        }

//        /// <summary>
//        /// æœ€å°æ‰¬ç¨‹(显示参数)
//        /// </summary> 
//        public double DispMinH()
//        {
//            return this.CoordMinH + (double)this.StartLineNoH * this.CoordSpaceH;
//        }

//        /// <summary>
//        /// æœ€å¤§æ‰¬ç¨‹(显示参数)
//        /// </summary> 
//        public double DispMaxH()
//        {
//            return CoordMinH + (double)this.EndLineNoH * this.CoordSpaceH;
//        }

//        /// <summary>
//        /// æœ€å°æ•ˆçŽ‡(显示参数)
//        /// </summary> 
//        public double DispMinE()
//        {
//            return this.CoordMinE + (double)this.StartLineNoE * this.CoordSpaceE;
//        }

//        /// <summary>
//        /// æœ€å¤§æ•ˆçŽ‡(显示参数)
//        /// </summary> 
//        public double DispMaxE()
//        {
//            return this.CoordMinE + (double)this.EndLineNoE * this.CoordSpaceE;
//        }

//        /// <summary>
//        /// æœ€å°åŠŸçŽ‡(显示参数)
//        /// </summary> 
//        public double DispMinP()
//        {
//            return this.CoordMinP + (double)this.StartLineNoP * this.CoordSpaceP;
//        }

//        /// <summary>
//        /// æœ€å¤§åŠŸçŽ‡(显示参数)
//        /// </summary> 
//        public double DispMaxP()
//        {
//            return this.CoordMinP + (double)this.EndLineNoP * this.CoordSpaceP;
//        }

//        #endregion

//        /// <summary>
//        /// é‡ç½®æ‰¬ç¨‹åæ ‡
//        /// </summary> 
//        public void ResetCoordH(double space, double disMinH, double disMaxH)
//        {
//            this.CoordSpaceH = space;
//            this.EndLineNoH = this.GridNumberY;
//            this.StartLineNoH = this.EndLineNoH - (int)((disMaxH - disMinH) / this.CoordSpaceH);
//            this.CoordMinH = disMaxH - (double)this.EndLineNoH * this.CoordSpaceH;
//        }
//        #endregion

//        #region è®¡ç®—坐标
//        /// <summary>
//        /// è®¡ç®—坐标
//        /// </summary>
//        /// <param name="group">曲线组</param>
//        /// <returns></returns>
//        public static CurveCoordinateParas CalcCoordinate(Model.FeatCurveExpressGroup group)
//        {
//            if (group == null)
//                return null;
//            return CalcCoordinate(group.CurveQH, group.CurveQE, group.CurveQP);
//        }

//        /// <summary>
//        /// è®¡ç®—坐标
//        /// </summary>
//        /// <param name="QH">流量扬程线</param>
//        /// <param name="QE">流量效率线</param>
//        /// <param name="QP">流量功率线</param>
//        /// <returns></returns>
//        public static CurveCoordinateParas CalcCoordinate(Model.CurveExpress QH, Model.CurveExpress QE, Model.CurveExpress QP)
//        {
//            if (QH == null)
//                return null;

//            List<Model.CurvePoint> pointsQH = QH.GetFitPoints();
//            List<Model.CurvePoint> pointsQE = null;
//            if (QE != null)
//                pointsQE = QE.GetFitPoints();
//            List<Model.CurvePoint> pointsQP = null;
//            if (QP != null)
//                pointsQP = QP.GetFitPoints();

//            return CalcCoordinate(pointsQH, pointsQE, pointsQP);
//        }

//        /// <summary>
//        /// è®¡ç®—坐标
//        /// </summary>
//        /// <param name="QH">流量扬程线</param>
//        /// <param name="QE">流量效率线</param>
//        /// <param name="QP">流量功率线</param>
//        /// <returns></returns>
//        public static CurveCoordinateParas CalcCoordinate(List<Model.CurvePoint> QH, List<Model.CurvePoint> QE, List<Model.CurvePoint> QP)
//        {
//            if (QH == null)
//                return null;
//            double maxQ = 0.0;
//            double minQ = 1000.0;
//            double maxH = 0.0;
//            double minH = 1000.0;
//            double maxE = 0.0;
//            double minE = 1000.0;
//            double maxP = 0.0;
//            double minP = 1000.0;

//            if (QE == null && QP == null)
//            {
//                minQ = QH.Min(x => x.X);
//                maxQ = QH.Max(x => x.X);
//                if (minQ > maxQ)
//                {
//                    return null;
//                }
//                minH = QH.Min(x => x.Y);
//                maxH = QH.Max(x => x.Y);
//                if (minH > maxH)
//                {
//                    return null;
//                }
//            }
//            else
//            {
//                CalcMinMaxValue(QH, QE, QP, ref maxQ, ref minQ, ref maxH, ref minH, ref maxE, ref minE, ref maxP, ref minP);
//            }

//            return CalcCoordinate(minQ, maxQ, minH, maxH, minE, maxE, minP, maxP);
//        }

//        /// <summary>
//        /// è®¡ç®—最大最小值
//        /// </summary>
//        /// <param name="QH">流量扬程线</param>
//        /// <param name="QE">流量效率线</param>
//        /// <param name="QP">流量功率线</param>
//        /// <param name="maxQ">最大流量</param>
//        /// <param name="minQ">最小流量</param>
//        /// <param name="maxH">最大扬程</param>
//        /// <param name="minH">最小扬程</param>
//        /// <param name="maxE">最大效率</param>
//        /// <param name="minE">最小效率</param>
//        /// <param name="maxP">最大功率</param>
//        /// <param name="minP">最小功率</param>
//        /// <returns></returns>
//        public static bool CalcMinMaxValue(List<Model.CurvePoint> QH, List<Model.CurvePoint> QE, List<Model.CurvePoint> QP, ref double maxQ, ref double minQ, ref double maxH, ref double minH, ref double maxE, ref double minE, ref double maxP, ref double minP)
//        {
//            maxQ = 0.0;
//            minQ = 1000.0;
//            maxH = 0.0;
//            minH = 1000.0;
//            maxE = 0.0;
//            minE = 1000.0;
//            maxP = 0.0;
//            minP = 1000.0;
//            if (QH == null)
//            {
//                return false;
//            }
//            minQ = QH.Min(x => x.X);
//            maxQ = QH.Max(x => x.X);
//            if (minQ > maxQ)
//            {
//                return false;
//            }
//            minH = QH.Min(x => x.Y);
//            maxH = QH.Max(x => x.Y);
//            if (QE != null && QE.Count > 0)
//            {
//                minE = QE.Min(x => x.Y);
//                maxE = QE.Max(x => x.Y);
//            }
//            if (QP != null && QP.Count > 0)
//            {
//                minP = QP.Min(x => x.Y);
//                maxP = QP.Max(x => x.Y);
//            }
//            return true;
//        }

//        /// <summary>
//        /// è®¡ç®—坐标
//        /// </summary>
//        /// <param name="minQ">最小流量</param>
//        /// <param name="maxQ">最大流量</param>
//        /// <param name="minH">最小扬程</param>
//        /// <param name="maxH">最大扬程</param>
//        /// <param name="minE">最小效率</param>
//        /// <param name="maxE">最大效率</param>
//        /// <param name="minP">最小功率</param>
//        /// <param name="maxP">最大功率</param>
//        /// <returns></returns>
//        public static CurveCoordinateParas CalcCoordinate(double minQ, double maxQ, double minH, double maxH, double minE, double maxE, double minP, double maxP)
//        {
//            if (minQ > maxQ - 0.01)
//                return null;

//            if (minH > maxH - 0.01)
//                return null;

//            var validGridNumH = 6;
//            var coordinateParas = new CurveCoordinateParas();
//            coordinateParas.GridNumberX = 10;
//            coordinateParas.GridNumberY = 18;
//            CalcCoordinateQ(minQ, maxQ, ref coordinateParas, coordinateParas.GridNumberX);
//            CalcCoordinateH(minH, maxH, validGridNumH, ref coordinateParas, out double disMinH, out double disMaxH);

//            if (maxP > minP + 0.01)
//                CalcCoordinateP(minP, maxP, disMaxH, 0, ref coordinateParas);

//            if (maxE > minE + 0.01)
//                CalcCoordinateE(minE, maxE, ref coordinateParas);

//            return coordinateParas;
//        }

//        #endregion

//        #region è®¡ç®—对应线坐标

//        /// <summary>
//        /// è®¡ç®—流量坐标
//        /// </summary>
//        /// <param name="minQ">最小流量</param>
//        /// <param name="maxQ">最大流量</param>
//        /// <param name="coordinateParas">坐标Model</param>
//        /// <param name="validGridNum">有效刻度点</param>
//        /// <param name="default_num">放大系数</param>
//        public static void CalcCoordinateQ(double minQ, double maxQ, ref CurveCoordinateParas coordinateParas, int validGridNum = 10, double default_num = 1.0)
//        {
//            var coordSpaceQ = GetOptimalSpaceMin(minQ / default_num, maxQ / default_num, validGridNum, out double disMinQ, out double disMaxQ) * default_num;
//            coordSpaceQ = Math.Max(0.5, coordSpaceQ / default_num) * default_num;
//            if (coordSpaceQ == 8.0)
//                coordSpaceQ = 10.0;

//            disMinQ *= default_num;
//            //disMaxQ *= default_num;
//            var gridNumberX = 0;

//            double min_q = disMinQ;
//            while (min_q < maxQ)
//            {
//                gridNumberX++;
//                min_q = disMinQ + gridNumberX * coordSpaceQ;
//            }

//            if (gridNumberX <= 5)
//            {
//                coordSpaceQ *= 0.5;
//                gridNumberX *= 2;
//            }

//            coordinateParas.CoordSpaceQ = coordSpaceQ;
//            coordinateParas.CoordMinQ = disMinQ;
//            coordinateParas.GridNumberX = gridNumberX;
//        }

//        /// <summary>
//        /// è®¡ç®—扬程坐标 å«è¿‡æ»¤ (Eventech: CalcCoordinateH2) 
//        /// </summary>
//        /// <param name="minH">最小扬程</param>
//        /// <param name="maxH">最大扬程</param>
//        /// <param name="validGridNumH">有效扬程刻度数</param>
//        /// <param name="coordinateParas">坐标Model</param>
//        /// <param name="disMinH">最小显示扬程</param>
//        /// <param name="disMaxH">最大显示扬程</param>
//        public static void CalcCoordinateH_Filter(double minH, double maxH, int validGridNumH, ref CurveCoordinateParas coordinateParas, out double disMinH, out double disMaxH)
//        {
//            if (maxH < 1.0)
//            {
//                disMinH = 0.0;
//                disMaxH = 1.0;
//                coordinateParas.ResetCoordH(0.1, disMinH, disMaxH);
//            }
//            else if (maxH < 2.0)
//            {
//                disMinH = 0.0;
//                disMaxH = 2.0;
//                coordinateParas.ResetCoordH(0.2, disMinH, disMaxH);
//            }
//            else if (maxH < 5.0)
//            {
//                disMinH = 0.0;
//                disMaxH = 5.0;
//                coordinateParas.ResetCoordH(0.5, disMinH, disMaxH);
//            }
//            else if (maxH < 10.0)
//            {
//                disMinH = 0.0;
//                disMaxH = 10.0;
//                coordinateParas.ResetCoordH(1.0, disMinH, disMaxH);
//            }
//            else if (maxH < 12.0)
//            {
//                coordinateParas.CoordSpaceH = 1.0;
//                disMinH = 0.0;
//                disMaxH = 12.0;
//                coordinateParas.ResetCoordH(1.0, disMinH, disMaxH);
//            }
//            else if (maxH < 15.0)
//            {
//                coordinateParas.CoordSpaceH = 2.0;
//                disMinH = 0.0;
//                disMaxH = 16.0;
//                coordinateParas.ResetCoordH(2.0, disMinH, disMaxH);
//            }
//            else if (maxH < 20.0)
//            {
//                coordinateParas.CoordSpaceH = 2.0;
//                disMinH = 0.0;
//                disMaxH = 20.0;
//                coordinateParas.ResetCoordH(2.0, disMinH, disMaxH);
//            }
//            else
//            {
//                CalcCoordinateH(minH, maxH, validGridNumH, ref coordinateParas, out disMinH, out disMaxH);
//            }
//        }

//        /// <summary>
//        /// è®¡ç®—扬程坐标
//        /// </summary>
//        /// <param name="minH">最小扬程</param>
//        /// <param name="maxH">最大扬程</param>
//        /// <param name="validGridNumH">有效扬程刻度数</param>
//        /// <param name="coordinateParas">坐标Model</param>
//        /// <param name="disMinH">最小显示扬程</param>
//        /// <param name="disMaxH">最大显示扬程</param>
//        public static void CalcCoordinateH(double minH, double maxH, int validGridNumH, ref CurveCoordinateParas coordinateParas, out double disMinH, out double disMaxH)
//        {
//            var coordSpaceH = GetOptimalSpaceMax(minH, maxH, validGridNumH, out disMinH, out disMaxH);
//            int endLineNoH = coordinateParas.GridNumberY;
//            int stratLineNoH = endLineNoH;

//            double max_h = disMaxH;//判断条件
//            while (max_h > minH * 0.98)
//            {
//                max_h -= coordSpaceH;
//                if (max_h < 0.0)
//                    break;
//                stratLineNoH--;
//            }

//            coordinateParas.CoordSpaceH = coordSpaceH;
//            coordinateParas.EndLineNoH = endLineNoH;
//            coordinateParas.StartLineNoH = stratLineNoH;
//            coordinateParas.CoordMinH = disMaxH - (double)endLineNoH * coordSpaceH;
//        }

//        /// <summary>
//        /// è®¡ç®—功率坐标
//        /// </summary>
//        /// <param name="minP">最小功率</param>
//        /// <param name="maxP">最大功率</param>
//        /// <param name="disMaxH">最大显示扬程</param>
//        /// <param name="downGridNum">最低点刻度</param>
//        /// <param name="coordinateParas">坐标Model</param>
//        public static void CalcCoordinateP(double minP, double maxP, double disMaxH, int downGridNum, ref CurveCoordinateParas coordinateParas)
//        {
//            int default_num = 5;
//            int spaceNum = coordinateParas.StartLineNoH - default_num - downGridNum;
//            if (spaceNum < 3)
//                spaceNum = 3;

//            var coordSpaceP = GetOptimalSpaceMax(minP, maxP, spaceNum, out double disMinP, out double disMaxP);
//            int endLineNoP = coordinateParas.StartLineNoH - default_num;
//            int stratLineNoP = endLineNoP;

//            double max_p = disMaxP;
//            while (max_p > minP * 0.98)
//            {
//                max_p -= coordSpaceP;
//                if (max_p < 0.0)
//                    break;
//                stratLineNoP--;
//            }

//            coordinateParas.CoordSpaceP = coordSpaceP;
//            coordinateParas.EndLineNoP = endLineNoP;
//            coordinateParas.StartLineNoP = stratLineNoP;

//            //如果开始刻度低于最低点刻度 éƒ½å¾€ä¸ŠåŠ å·®å€¼
//            if (coordinateParas.StartLineNoP < downGridNum)
//            {
//                int diff_num = downGridNum - coordinateParas.StartLineNoP;

//                coordinateParas.EndLineNoP += diff_num;
//                coordinateParas.StartLineNoP += diff_num;
//            }

//            coordinateParas.CoordMinH = GetByPlacesLength(disMaxH - (double)coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH, 3);
//            coordinateParas.CoordMinP = GetByPlacesLength(disMaxP - (double)coordinateParas.EndLineNoP * coordinateParas.CoordSpaceP, 3);
//        }

//        /// <summary>
//        /// è®¡ç®—效率坐标
//        /// </summary>
//        /// <param name="minE">最小效率</param>
//        /// <param name="maxE">最大效率</param>
//        /// <param name="coordinateParas">坐标Model</param>
//        public static void CalcCoordinateE(double minE, double maxE, ref CurveCoordinateParas coordinateParas)
//        {
//            int startLineNoE = coordinateParas.StartLineNoH - 6;
//            if (maxE <= 40.0)
//            {
//                coordinateParas.StartLineNoE = startLineNoE;
//                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 6;
//                coordinateParas.CoordSpaceE = 5.0;
//            }
//            else if (maxE <= 50.0)
//            {
//                coordinateParas.StartLineNoE = startLineNoE - 5;
//                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 10;
//                coordinateParas.CoordSpaceE = 5.0;
//            }
//            else if (maxE <= 60)
//            {
//                coordinateParas.StartLineNoE = startLineNoE;
//                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 6;
//                coordinateParas.CoordSpaceE = 10.0;
//            }
//            else
//            {
//                coordinateParas.StartLineNoE = startLineNoE;
//                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 5;
//                coordinateParas.CoordSpaceE = 20.0;
//            }
//            coordinateParas.CoordMinE = (double)(-coordinateParas.StartLineNoE) * coordinateParas.CoordSpaceE;
//        }

//        #endregion

//        #region Space é—´éš” 
//        /// <summary>
//        /// èŽ·å–最小的间隔
//        /// </summary>
//        /// <param name="minValue">最小值</param>
//        /// <param name="maxValue">最大值</param>
//        /// <param name="spaceNum">间隔数量</param>
//        /// <param name="minDisplay">最小显示参数</param>
//        /// <param name="maxDisplay">最大显示参数</param>
//        /// <returns></returns>
//        public static double GetOptimalSpaceMin(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
//        {
//            minDisplay = minValue;
//            maxDisplay = maxValue;
//            double num = maxValue - minValue;
//            if (num < 0.0 || spaceNum < 1)
//            {
//                return (maxValue - minValue) / 10.0;
//            }

//            double optimalSpace = GetOptimalSpace((maxValue - minValue) / (double)spaceNum);
//            if (optimalSpace < 2.0)
//            {
//                minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
//                maxDisplay = minDisplay + (double)spaceNum * optimalSpace;
//            }
//            else
//            {
//                minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
//                maxDisplay = minDisplay + (double)spaceNum * optimalSpace;
//            }

//            return optimalSpace;
//        }

//        /// <summary> 
//        /// èŽ·å–最大的间隔
//        /// </summary>
//        /// <param name="minValue">最小值</param>
//        /// <param name="maxValue">最大值</param>
//        /// <param name="spaceNum">间隔数量</param>
//        /// <param name="minDisplay">最小显示参数</param>
//        /// <param name="maxDisplay">最大显示参数</param>
//        /// <returns></returns>
//        public static double GetOptimalSpaceMax(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
//        {
//            minDisplay = minValue;
//            maxDisplay = maxValue;
//            double num = maxValue - minValue;

//            if (maxValue > 20)
//            {
//                if (num < 0.0 || spaceNum < 1)
//                {
//                    return (maxValue - minValue) / 5.0;
//                }
//            }
//            else
//            {
//                if (num < 0.0 || spaceNum < 1)
//                {
//                    return (maxValue - minValue) / 10.0;
//                }
//            }

//            double optimalSpace = GetOptimalSpace((maxValue - minValue) / (double)spaceNum, true);
//            maxDisplay = Math.Ceiling(maxValue / optimalSpace) * optimalSpace;
//            minDisplay = maxDisplay - (double)spaceNum * optimalSpace;

//            if (minDisplay > minValue)
//            {
//                var diff = minDisplay - minValue;
//                if (diff < optimalSpace)
//                {
//                    minDisplay -= optimalSpace;
//                }

//            }

//            return optimalSpace;
//        }

//        /// <summary>
//        /// èŽ·å–最佳间隔 (精细取整)
//        /// </summary>
//        /// <param name="refSpace"> é—´éš”</param>
//        /// <returns></returns>
//        public static double GetOptimalSpace(double refSpace, bool IsAccurate = false)
//        {
//            if (refSpace < 1E-06)
//            {
//                return 1.0;
//            }

//            if (refSpace < 0.01)
//            {
//                double refSpace2 = refSpace * 100.0;
//                return GetOptimalSpace(refSpace2) / 100.0;
//            }

//            if (refSpace < 0.1)
//            {
//                double refSpace3 = refSpace * 10.0;
//                return GetOptimalSpace(refSpace3) / 10.0;
//            }

//            if (IsAccurate)
//            {
//                if (refSpace < 11.0)
//                {
//                    if (refSpace < 1.35)
//                    {
//                        return 1.0;
//                    }

//                    if (refSpace < 2.2)
//                    {
//                        return 2.0;
//                    }

//                    if (refSpace < 5.5)
//                    {
//                        return 5.0;
//                    }

//                    if (refSpace < 8.5)
//                    {
//                        return 8.0;
//                    }

//                    return 10.0;
//                }
//            }

//            if (refSpace < 1.0)
//            {
//                if (refSpace < 0.15)
//                {
//                    return 0.1;
//                }

//                if (refSpace < 0.22)
//                {
//                    return 0.2;
//                }

//                if (refSpace < 0.6)
//                {
//                    return 0.5;
//                }

//                return 1.0;
//            }

//            if (refSpace < 1.2)
//            {
//                return 1.0;
//            }

//            if (refSpace < 3.0)
//            {
//                if (refSpace < 1.2)
//                {
//                    return 1.0;
//                }

//                if (refSpace < 2.3)
//                {
//                    return 2.0;
//                }

//                return 3.0;
//            }

//            if (refSpace < 11.0)
//            {
//                if (refSpace < 1.35)
//                {
//                    return 1.0;
//                }

//                if (refSpace < 2.2)
//                {
//                    return 2.0;
//                }

//                if (refSpace < 5.5)
//                {
//                    return 5.0;
//                }

//                if (refSpace < 8.5)
//                {
//                    return 8.0;
//                }

//                return 10.0;
//            }

//            if (refSpace < 16.0)
//            {
//                return 15.0;
//            }

//            if (refSpace < 22.0)
//            {
//                return 20.0;
//            }

//            if (refSpace < 35.0)
//            {
//                return 25.0;
//            }

//            if (refSpace < 41.0)
//            {
//                return 40.0;
//            }

//            if (refSpace < 51.0)
//            {
//                return 50.0;
//            }

//            if (refSpace < 61.0)
//            {
//                return 60.0;
//            }

//            if (refSpace < 71.0)
//            {
//                return 70.0;
//            }

//            if (refSpace < 78.0)
//            {
//                return 75.0;
//            }

//            if (refSpace < 150.0)
//            {
//                return 100.0;
//            }

//            if (refSpace < 230.0)
//            {
//                return 200.0;
//            }

//            if (refSpace < 270.0)
//            {
//                return 250.0;
//            }

//            if (refSpace < 1500.0)
//            {
//                int num = (int)(refSpace / 100.0);
//                return num * 100;
//            }

//            int num2 = (int)(refSpace / 1000.0);
//            return num2 * 1000;
//        }

//        #endregion

//        #region æ•°å­—辅助方法
//        /// <summary>
//        /// æŒ‰æŒ‡å®šé•¿åº¦èŽ·å–
//        /// </summary> 
//        public static double GetByPlacesLength(double value, int length)
//        {
//            int decimalPlacesLength = GetDecimalPlacesLength(value);
//            if (decimalPlacesLength > length)
//            {
//                return Math.Round(value, length);
//            }
//            return value;
//        }

//        /// <summary>
//        /// èŽ·å–小数点长度
//        /// </summary> 
//        private static int GetDecimalPlacesLength(double value)
//        {
//            string text = value.ToString();
//            int num = text.IndexOf('.');
//            if (num >= 0)
//            {
//                return text.Length - num - 1;
//            }
//            return 0;
//        }
//        #endregion

//    }
//}
namespace IStation.Model
{
    /// <summary>
@@ -17,7 +775,7 @@
        /// </summary> 
        public double DispMaxQ()
        {
            return this.CoordMinQ + (double)this.GridNumberX * this.CoordSpaceQ;
            return this.CoordMinQ + this.GridNumberX * this.CoordSpaceQ;
        }

        /// <summary>
@@ -25,7 +783,7 @@
        /// </summary> 
        public double DispMinH()
        {
            return this.CoordMinH + (double)this.StartLineNoH * this.CoordSpaceH;
            return this.CoordMinH + this.StartLineNoH * this.CoordSpaceH;
        }

        /// <summary>
@@ -33,7 +791,7 @@
        /// </summary> 
        public double DispMaxH()
        {
            return CoordMinH + (double)this.EndLineNoH * this.CoordSpaceH;
            return CoordMinH + this.EndLineNoH * this.CoordSpaceH;
        }

        /// <summary>
@@ -41,7 +799,7 @@
        /// </summary> 
        public double DispMinE()
        {
            return this.CoordMinE + (double)this.StartLineNoE * this.CoordSpaceE;
            return this.CoordMinE + this.StartLineNoE * this.CoordSpaceE;
        }

        /// <summary>
@@ -49,7 +807,7 @@
        /// </summary> 
        public double DispMaxE()
        {
            return this.CoordMinE + (double)this.EndLineNoE * this.CoordSpaceE;
            return this.CoordMinE + this.EndLineNoE * this.CoordSpaceE;
        }

        /// <summary>
@@ -57,7 +815,7 @@
        /// </summary> 
        public double DispMinP()
        {
            return this.CoordMinP + (double)this.StartLineNoP * this.CoordSpaceP;
            return this.CoordMinP + this.StartLineNoP * this.CoordSpaceP;
        }

        /// <summary>
@@ -65,7 +823,7 @@
        /// </summary> 
        public double DispMaxP()
        {
            return this.CoordMinP + (double)this.EndLineNoP * this.CoordSpaceP;
            return this.CoordMinP + this.EndLineNoP * this.CoordSpaceP;
        }

        #endregion
@@ -78,20 +836,21 @@
            this.CoordSpaceH = space;
            this.EndLineNoH = this.GridNumberY;
            this.StartLineNoH = this.EndLineNoH - (int)((disMaxH - disMinH) / this.CoordSpaceH);
            this.CoordMinH = disMaxH - (double)this.EndLineNoH * this.CoordSpaceH;
            this.CoordMinH = disMaxH - this.EndLineNoH * this.CoordSpaceH;
        }
        #endregion

        #region è®¡ç®—坐标

        /// <summary>
        /// è®¡ç®—坐标
        /// </summary>
        /// <param name="group">曲线组</param>
        /// <param name="QH">流量扬程线</param>
        /// <param name="QE">流量效率线</param>
        /// <param name="QP">流量功率线</param>
        /// <returns></returns>
        public static CurveCoordinateParas CalcCoordinate(Model.FeatCurveExpressGroup group)
        public static CurveCoordinateParas CalcCoordinate(FeatCurveExpressGroup group)
        {
            if (group == null)
                return null;
            return CalcCoordinate(group.CurveQH, group.CurveQE, group.CurveQP);
        }

@@ -102,21 +861,11 @@
        /// <param name="QE">流量效率线</param>
        /// <param name="QP">流量功率线</param>
        /// <returns></returns>
        public static CurveCoordinateParas CalcCoordinate(Model.CurveExpress QH, Model.CurveExpress QE, Model.CurveExpress QP)
        public static CurveCoordinateParas CalcCoordinate(CurveExpress QH, CurveExpress QE, CurveExpress QP)
        {
            if (QH == null)
                return null;

            List<Model.CurvePoint> pointsQH = QH.GetFitPoints();
            List<Model.CurvePoint> pointsQE = null;
            if (QE != null)
                pointsQE = QE.GetFitPoints();
            List<Model.CurvePoint> pointsQP = null;
            if (QP != null)
                pointsQP = QP.GetFitPoints();

            return CalcCoordinate(pointsQH, pointsQE, pointsQP);
            return CalcCoordinate(QH.GetFitPoints(),QE.GetFitPoints(),QP.GetFitPoints());
        }


        /// <summary>
        /// è®¡ç®—坐标
@@ -125,40 +874,54 @@
        /// <param name="QE">流量效率线</param>
        /// <param name="QP">流量功率线</param>
        /// <returns></returns>
        public static CurveCoordinateParas CalcCoordinate(List<Model.CurvePoint> QH, List<Model.CurvePoint> QE, List<Model.CurvePoint> QP)
        public static CurveCoordinateParas CalcCoordinate(List<CurvePoint> QH, List<CurvePoint> QE, List<CurvePoint> QP)
        {
            if (QH == null)
                return null;
            double maxQ = 0.0;
            double minQ = 1000.0;
            double maxH = 0.0;
            double minH = 1000.0;
            double maxE = 0.0;
            double minE = 1000.0;
            double maxP = 0.0;
            double minP = 1000.0;
            double max_flow = 0.0;
            double min_flow = 1000.0;
            double max_head = 0.0;
            double min_head = 1000.0;
            double max_eff = 0.0;
            double min_eff = 1000.0;
            double max_power = 0.0;
            double min_power = 1000.0;

            if (QE == null && QP == null)
            {
                minQ = QH.Min(x => x.X);
                maxQ = QH.Max(x => x.X);
                if (minQ > maxQ)
                min_flow = QH.Min(x => x.X);
                max_flow = QH.Max(x => x.X);
                if (min_flow > max_flow)
                {
                    return null;
                }
                minH = QH.Min(x => x.Y);
                maxH = QH.Max(x => x.Y);
                if (minH > maxH)
                min_head = QH.Min(x => x.Y);
                max_head = QH.Max(x => x.Y);
                if (min_head > max_head)
                {
                    return null;
                }
            }
            else
            {
                CalcMinMaxValue(QH, QE, QP, ref maxQ, ref minQ, ref maxH, ref minH, ref maxE, ref minE, ref maxP, ref minP);
                CalcMinMaxValue(QH, QE, QP, ref max_flow, ref min_flow, ref max_head, ref min_head, ref max_eff, ref min_eff, ref max_power, ref min_power);
            }

            return CalcCoordinate(minQ, maxQ, minH, maxH, minE, maxE, minP, maxP);
            var calc_corrd = CalcCoordinate(min_flow, max_flow, min_head, max_head, min_eff, max_eff, min_power, max_power);

            #region ä¿®æ­£Yè½´

            var head_num_y = calc_corrd.EndLineNoH - calc_corrd.StartLineNoH;
            var eff_num_y = calc_corrd.EndLineNoE - calc_corrd.StartLineNoE;
            var power_num_y = calc_corrd.EndLineNoP - calc_corrd.StartLineNoP;
            var sun_num_y = Math.Abs(head_num_y + eff_num_y + power_num_y);
            if (sun_num_y < calc_corrd.GridNumberY)
            {
                calc_corrd.StartLineNoP = 1;
            }
            #endregion

            return calc_corrd;
        }

        /// <summary>
@@ -167,46 +930,46 @@
        /// <param name="QH">流量扬程线</param>
        /// <param name="QE">流量效率线</param>
        /// <param name="QP">流量功率线</param>
        /// <param name="maxQ">最大流量</param>
        /// <param name="minQ">最小流量</param>
        /// <param name="maxH">最大扬程</param>
        /// <param name="minH">最小扬程</param>
        /// <param name="maxE">最大效率</param>
        /// <param name="minE">最小效率</param>
        /// <param name="maxP">最大功率</param>
        /// <param name="minP">最小功率</param>
        /// <param name="max_flow">最大流量</param>
        /// <param name="min_flow">最小流量</param>
        /// <param name="max_head">最大扬程</param>
        /// <param name="min_head">最小扬程</param>
        /// <param name="max_eff">最大效率</param>
        /// <param name="min_eff">最小效率</param>
        /// <param name="max_power">最大功率</param>
        /// <param name="min_power">最小功率</param>
        /// <returns></returns>
        public static bool CalcMinMaxValue(List<Model.CurvePoint> QH, List<Model.CurvePoint> QE, List<Model.CurvePoint> QP, ref double maxQ, ref double minQ, ref double maxH, ref double minH, ref double maxE, ref double minE, ref double maxP, ref double minP)
        public static bool CalcMinMaxValue(List<CurvePoint> QH, List<CurvePoint> QE, List<CurvePoint> QP, ref double max_flow, ref double min_flow, ref double max_head, ref double min_head, ref double max_eff, ref double min_eff, ref double max_power, ref double min_power)
        {
            maxQ = 0.0;
            minQ = 1000.0;
            maxH = 0.0;
            minH = 1000.0;
            maxE = 0.0;
            minE = 1000.0;
            maxP = 0.0;
            minP = 1000.0;
            max_flow = 0.0;
            min_flow = 1000.0;
            max_head = 0.0;
            min_head = 1000.0;
            max_eff = 0.0;
            min_eff = 1000.0;
            max_power = 0.0;
            min_power = 1000.0;
            if (QH == null)
            {
                return false;
            }
            minQ = QH.Min(x => x.X);
            maxQ = QH.Max(x => x.X);
            if (minQ > maxQ)
            min_flow = QH.Min(x => x.X);
            max_flow = QH.Max(x => x.X);
            if (min_flow > max_flow)
            {
                return false;
            }
            minH = QH.Min(x => x.Y);
            maxH = QH.Max(x => x.Y);
            min_head = QH.Min(x => x.Y);
            max_head = QH.Max(x => x.Y);
            if (QE != null && QE.Count > 0)
            {
                minE = QE.Min(x => x.Y);
                maxE = QE.Max(x => x.Y);
                min_eff = QE.Min(x => x.Y);
                max_eff = QE.Max(x => x.Y);
            }
            if (QP != null && QP.Count > 0)
            {
                minP = QP.Min(x => x.Y);
                maxP = QP.Max(x => x.Y);
                min_power = QP.Min(x => x.Y);
                max_power = QP.Max(x => x.Y);
            }
            return true;
        }
@@ -214,37 +977,37 @@
        /// <summary>
        /// è®¡ç®—坐标
        /// </summary>
        /// <param name="minQ">最小流量</param>
        /// <param name="maxQ">最大流量</param>
        /// <param name="minH">最小扬程</param>
        /// <param name="maxH">最大扬程</param>
        /// <param name="minE">最小效率</param>
        /// <param name="maxE">最大效率</param>
        /// <param name="minP">最小功率</param>
        /// <param name="maxP">最大功率</param>
        /// <param name="min_flow">最小流量</param>
        /// <param name="max_flow">最大流量</param>
        /// <param name="min_head">最小扬程</param>
        /// <param name="max_head">最大扬程</param>
        /// <param name="min_eff">最小效率</param>
        /// <param name="max_eff">最大效率</param>
        /// <param name="min_power">最小功率</param>
        /// <param name="max_power">最大功率</param>
        /// <returns></returns>
        public static CurveCoordinateParas CalcCoordinate(double minQ, double maxQ, double minH, double maxH, double minE, double maxE, double minP, double maxP)
        public static CurveCoordinateParas CalcCoordinate(double min_flow, double max_flow, double min_head, double max_head, double min_eff, double max_eff, double min_power, double max_power)
        {
            if (minQ > maxQ - 0.01)
            if (min_flow > max_flow - 0.01)
                return null;

            if (minH > maxH - 0.01)
            if (min_head > max_head - 0.01)
                return null;

            var validGridNumH = 6;
            var coordinateParas = new CurveCoordinateParas();
            coordinateParas.GridNumberX = 10;
            coordinateParas.GridNumberY = 18;
            CalcCoordinateQ(minQ, maxQ, ref coordinateParas, coordinateParas.GridNumberX);
            CalcCoordinateH(minH, maxH, validGridNumH, ref coordinateParas, out double disMinH, out double disMaxH);
            var valid_grid_num_h = 6;
            var coordinate_paras = new CurveCoordinateParas();
            coordinate_paras.GridNumberX = 10;//10
            coordinate_paras.GridNumberY = 18;//18
            CalcCoordinateQ(min_flow, max_flow, ref coordinate_paras, coordinate_paras.GridNumberX);
            CalcCoordinateH(min_head, max_head, valid_grid_num_h, ref coordinate_paras, out double disMinH, out double disMaxH);

            if (maxP > minP + 0.01)
                CalcCoordinateP(minP, maxP, disMaxH, 0, ref coordinateParas);
            if (max_power > min_power + 0.01)
                CalcCoordinateP(min_power, max_power, disMaxH, 0, ref coordinate_paras);

            if (maxE > minE + 0.01)
                CalcCoordinateE(minE, maxE, ref coordinateParas);
            if (max_eff > min_eff + 0.01)
                CalcCoordinateE(min_eff, max_eff, ref coordinate_paras);

            return coordinateParas;
            return coordinate_paras;
        }

        #endregion
@@ -254,14 +1017,14 @@
        /// <summary>
        /// è®¡ç®—流量坐标
        /// </summary>
        /// <param name="minQ">最小流量</param>
        /// <param name="maxQ">最大流量</param>
        /// <param name="coordinateParas">坐标Model</param>
        /// <param name="min_flow">最小流量</param>
        /// <param name="max_flow">最大流量</param>
        /// <param name="coordinate_paras">坐标Model</param>
        /// <param name="validGridNum">有效刻度点</param>
        /// <param name="default_num">放大系数</param>
        public static void CalcCoordinateQ(double minQ, double maxQ, ref CurveCoordinateParas coordinateParas, int validGridNum = 10, double default_num = 1.0)
        public static void CalcCoordinateQ(double min_flow, double max_flow, ref CurveCoordinateParas coordinate_paras, int validGridNum = 10, double default_num = 1.0)
        {
            var coordSpaceQ = GetOptimalSpaceMin(minQ / default_num, maxQ / default_num, validGridNum, out double disMinQ, out double disMaxQ) * default_num;
            var coordSpaceQ = PhartCoordinateHelper.GetOptimalSpaceMin(min_flow / default_num, max_flow / default_num, validGridNum, out double disMinQ, out double disMaxQ) * default_num;
            coordSpaceQ = Math.Max(0.5, coordSpaceQ / default_num) * default_num;
            if (coordSpaceQ == 8.0)
                coordSpaceQ = 10.0;
@@ -271,7 +1034,7 @@
            var gridNumberX = 0;

            double min_q = disMinQ;
            while (min_q < maxQ)
            while (min_q < max_flow)
            {
                gridNumberX++;
                min_q = disMinQ + gridNumberX * coordSpaceQ;
@@ -283,90 +1046,90 @@
                gridNumberX *= 2;
            }

            coordinateParas.CoordSpaceQ = coordSpaceQ;
            coordinateParas.CoordMinQ = disMinQ;
            coordinateParas.GridNumberX = gridNumberX;
            coordinate_paras.CoordSpaceQ = coordSpaceQ;
            coordinate_paras.CoordMinQ = disMinQ;
            coordinate_paras.GridNumberX = gridNumberX;
        }

        /// <summary>
        /// è®¡ç®—扬程坐标 å«è¿‡æ»¤ (Eventech: CalcCoordinateH2) 
        /// </summary>
        /// <param name="minH">最小扬程</param>
        /// <param name="maxH">最大扬程</param>
        /// <param name="validGridNumH">有效扬程刻度数</param>
        /// <param name="coordinateParas">坐标Model</param>
        /// <param name="min_head">最小扬程</param>
        /// <param name="max_head">最大扬程</param>
        /// <param name="valid_grid_num_h">有效扬程刻度数</param>
        /// <param name="coordinate_paras">坐标Model</param>
        /// <param name="disMinH">最小显示扬程</param>
        /// <param name="disMaxH">最大显示扬程</param>
        public static void CalcCoordinateH_Filter(double minH, double maxH, int validGridNumH, ref CurveCoordinateParas coordinateParas, out double disMinH, out double disMaxH)
        public static void CalcCoordinateH_Filter(double min_head, double max_head, int valid_grid_num_h, ref CurveCoordinateParas coordinate_paras, out double disMinH, out double disMaxH)
        {
            if (maxH < 1.0)
            if (max_head < 1.0)
            {
                disMinH = 0.0;
                disMaxH = 1.0;
                coordinateParas.ResetCoordH(0.1, disMinH, disMaxH);
                coordinate_paras.ResetCoordH(0.1, disMinH, disMaxH);
            }
            else if (maxH < 2.0)
            else if (max_head < 2.0)
            {
                disMinH = 0.0;
                disMaxH = 2.0;
                coordinateParas.ResetCoordH(0.2, disMinH, disMaxH);
                coordinate_paras.ResetCoordH(0.2, disMinH, disMaxH);
            }
            else if (maxH < 5.0)
            else if (max_head < 5.0)
            {
                disMinH = 0.0;
                disMaxH = 5.0;
                coordinateParas.ResetCoordH(0.5, disMinH, disMaxH);
                coordinate_paras.ResetCoordH(0.5, disMinH, disMaxH);
            }
            else if (maxH < 10.0)
            else if (max_head < 10.0)
            {
                disMinH = 0.0;
                disMaxH = 10.0;
                coordinateParas.ResetCoordH(1.0, disMinH, disMaxH);
                coordinate_paras.ResetCoordH(1.0, disMinH, disMaxH);
            }
            else if (maxH < 12.0)
            else if (max_head < 12.0)
            {
                coordinateParas.CoordSpaceH = 1.0;
                coordinate_paras.CoordSpaceH = 1.0;
                disMinH = 0.0;
                disMaxH = 12.0;
                coordinateParas.ResetCoordH(1.0, disMinH, disMaxH);
                coordinate_paras.ResetCoordH(1.0, disMinH, disMaxH);
            }
            else if (maxH < 15.0)
            else if (max_head < 15.0)
            {
                coordinateParas.CoordSpaceH = 2.0;
                coordinate_paras.CoordSpaceH = 2.0;
                disMinH = 0.0;
                disMaxH = 16.0;
                coordinateParas.ResetCoordH(2.0, disMinH, disMaxH);
                coordinate_paras.ResetCoordH(2.0, disMinH, disMaxH);
            }
            else if (maxH < 20.0)
            else if (max_head < 20.0)
            {
                coordinateParas.CoordSpaceH = 2.0;
                coordinate_paras.CoordSpaceH = 2.0;
                disMinH = 0.0;
                disMaxH = 20.0;
                coordinateParas.ResetCoordH(2.0, disMinH, disMaxH);
                coordinate_paras.ResetCoordH(2.0, disMinH, disMaxH);
            }
            else
            {
                CalcCoordinateH(minH, maxH, validGridNumH, ref coordinateParas, out disMinH, out disMaxH);
                CalcCoordinateH(min_head, max_head, valid_grid_num_h, ref coordinate_paras, out disMinH, out disMaxH);
            }
        }

        /// <summary>
        /// è®¡ç®—扬程坐标
        /// </summary>
        /// <param name="minH">最小扬程</param>
        /// <param name="maxH">最大扬程</param>
        /// <param name="validGridNumH">有效扬程刻度数</param>
        /// <param name="coordinateParas">坐标Model</param>
        /// <param name="min_head">最小扬程</param>
        /// <param name="max_head">最大扬程</param>
        /// <param name="valid_grid_num_h">有效扬程刻度数</param>
        /// <param name="coordinate_paras">坐标Model</param>
        /// <param name="disMinH">最小显示扬程</param>
        /// <param name="disMaxH">最大显示扬程</param>
        public static void CalcCoordinateH(double minH, double maxH, int validGridNumH, ref CurveCoordinateParas coordinateParas, out double disMinH, out double disMaxH)
        public static void CalcCoordinateH(double min_head, double max_head, int valid_grid_num_h, ref CurveCoordinateParas coordinate_paras, out double disMinH, out double disMaxH)
        {
            var coordSpaceH = GetOptimalSpaceMax(minH, maxH, validGridNumH, out disMinH, out disMaxH);
            int endLineNoH = coordinateParas.GridNumberY;
            var coordSpaceH = PhartCoordinateHelper.GetOptimalSpaceMax(min_head, max_head, valid_grid_num_h, out disMinH, out disMaxH);
            int endLineNoH = coordinate_paras.GridNumberY;
            int stratLineNoH = endLineNoH;

            double max_h = disMaxH;//判断条件
            while (max_h > minH * 0.98)
            while (max_h > min_head * 0.98)
            {
                max_h -= coordSpaceH;
                if (max_h < 0.0)
@@ -374,33 +1137,33 @@
                stratLineNoH--;
            }

            coordinateParas.CoordSpaceH = coordSpaceH;
            coordinateParas.EndLineNoH = endLineNoH;
            coordinateParas.StartLineNoH = stratLineNoH;
            coordinateParas.CoordMinH = disMaxH - (double)endLineNoH * coordSpaceH;
            coordinate_paras.CoordSpaceH = coordSpaceH;
            coordinate_paras.EndLineNoH = endLineNoH;
            coordinate_paras.StartLineNoH = stratLineNoH;
            coordinate_paras.CoordMinH = disMaxH - endLineNoH * coordSpaceH;
        }

        /// <summary>
        /// è®¡ç®—功率坐标
        /// </summary>
        /// <param name="minP">最小功率</param>
        /// <param name="maxP">最大功率</param>
        /// <param name="min_power">最小功率</param>
        /// <param name="max_power">最大功率</param>
        /// <param name="disMaxH">最大显示扬程</param>
        /// <param name="downGridNum">最低点刻度</param>
        /// <param name="coordinateParas">坐标Model</param>
        public static void CalcCoordinateP(double minP, double maxP, double disMaxH, int downGridNum, ref CurveCoordinateParas coordinateParas)
        /// <param name="coordinate_paras">坐标Model</param>
        public static void CalcCoordinateP(double min_power, double max_power, double disMaxH, int downGridNum, ref CurveCoordinateParas coordinate_paras)
        {
            int default_num = 5;
            int spaceNum = coordinateParas.StartLineNoH - default_num - downGridNum;
            int default_num = 7;
            int spaceNum = coordinate_paras.StartLineNoH - default_num - downGridNum;
            if (spaceNum < 3)
                spaceNum = 3;

            var coordSpaceP = GetOptimalSpaceMax(minP, maxP, spaceNum, out double disMinP, out double disMaxP);
            int endLineNoP = coordinateParas.StartLineNoH - default_num;
            var coordSpaceP = PhartCoordinateHelper.GetOptimalSpaceMax(min_power, max_power, spaceNum, out double disMinP, out double disMaxP);
            int endLineNoP = coordinate_paras.StartLineNoH - default_num;
            int stratLineNoP = endLineNoP;

            double max_p = disMaxP;
            while (max_p > minP * 0.98)
            while (max_p > min_power)
            {
                max_p -= coordSpaceP;
                if (max_p < 0.0)
@@ -408,62 +1171,71 @@
                stratLineNoP--;
            }

            coordinateParas.CoordSpaceP = coordSpaceP;
            coordinateParas.EndLineNoP = endLineNoP;
            coordinateParas.StartLineNoP = stratLineNoP;
            coordinate_paras.CoordSpaceP = coordSpaceP;
            coordinate_paras.EndLineNoP = endLineNoP;
            coordinate_paras.StartLineNoP = stratLineNoP;

            //如果开始刻度低于最低点刻度 éƒ½å¾€ä¸ŠåŠ å·®å€¼
            if (coordinateParas.StartLineNoP < downGridNum)
            if (coordinate_paras.StartLineNoP < downGridNum)
            {
                int diff_num = downGridNum - coordinateParas.StartLineNoP;

                coordinateParas.EndLineNoP += diff_num;
                coordinateParas.StartLineNoP += diff_num;
                int diff_num = downGridNum - coordinate_paras.StartLineNoP;
                coordinate_paras.EndLineNoP += diff_num;
                coordinate_paras.StartLineNoP += diff_num;
            }

            coordinateParas.CoordMinH = GetByPlacesLength(disMaxH - (double)coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH, 3);
            coordinateParas.CoordMinP = GetByPlacesLength(disMaxP - (double)coordinateParas.EndLineNoP * coordinateParas.CoordSpaceP, 3);


            coordinate_paras.CoordMinH = PhartCoordinateHelper.GetByPlacesLength(disMaxH - coordinate_paras.EndLineNoH * coordinate_paras.CoordSpaceH, 3);
            coordinate_paras.CoordMinP = PhartCoordinateHelper.GetByPlacesLength(disMaxP - coordinate_paras.EndLineNoP * coordinate_paras.CoordSpaceP, 3);
        }

        /// <summary>
        /// è®¡ç®—效率坐标
        /// </summary>
        /// <param name="minE">最小效率</param>
        /// <param name="maxE">最大效率</param>
        /// <param name="coordinateParas">坐标Model</param>
        public static void CalcCoordinateE(double minE, double maxE, ref CurveCoordinateParas coordinateParas)
        /// <param name="min_eff">最小效率</param>
        /// <param name="max_eff">最大效率</param>
        /// <param name="coordinate_paras">坐标Model</param>
        public static void CalcCoordinateE(double min_eff, double max_eff, ref CurveCoordinateParas coordinate_paras)
        {
            int startLineNoE = coordinateParas.StartLineNoH - 6;
            if (maxE <= 40.0)
            int startLineNoE = coordinate_paras.StartLineNoH - 6;
            if (max_eff <= 40.0)
            {
                coordinateParas.StartLineNoE = startLineNoE;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 6;
                coordinateParas.CoordSpaceE = 5.0;
                coordinate_paras.StartLineNoE = startLineNoE;
                coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 6;
                coordinate_paras.CoordSpaceE = 5.0;
            }
            else if (maxE <= 50.0)
            else if (max_eff <= 50.0)
            {
                coordinateParas.StartLineNoE = startLineNoE - 5;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 10;
                coordinateParas.CoordSpaceE = 5.0;
                coordinate_paras.StartLineNoE = startLineNoE - 5;
                coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 10;
                coordinate_paras.CoordSpaceE = 5.0;
            }
            else if (maxE <= 60)
            else if (max_eff <= 60)
            {
                coordinateParas.StartLineNoE = startLineNoE;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 6;
                coordinateParas.CoordSpaceE = 10.0;
                coordinate_paras.StartLineNoE = startLineNoE;
                coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 6;
                coordinate_paras.CoordSpaceE = 10.0;
            }
            else
            {
                coordinateParas.StartLineNoE = startLineNoE;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 5;
                coordinateParas.CoordSpaceE = 20.0;
                coordinate_paras.StartLineNoE = startLineNoE;
                coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 5;
                coordinate_paras.CoordSpaceE = 20.0;
            }
            coordinateParas.CoordMinE = (double)(-coordinateParas.StartLineNoE) * coordinateParas.CoordSpaceE;
            coordinate_paras.CoordMinE = (-coordinate_paras.StartLineNoE) * coordinate_paras.CoordSpaceE;
        }

        #endregion

        #region Space é—´éš” 

    }


    /// <summary>
    /// åæ ‡è¾…助类
    /// </summary>
    public class PhartCoordinateHelper
    {
        /// <summary>
        /// èŽ·å–最小的间隔
        /// </summary>
@@ -483,16 +1255,16 @@
                return (maxValue - minValue) / 10.0;
            }

            double optimalSpace = GetOptimalSpace((maxValue - minValue) / (double)spaceNum);
            if (optimalSpace < 2.0)
            double optimalSpace = GetOptimalSpace((maxValue - minValue) / spaceNum);
            if (optimalSpace < 2)
            {
                minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
                maxDisplay = minDisplay + (double)spaceNum * optimalSpace;
                maxDisplay = minDisplay + spaceNum * optimalSpace;
            }
            else
            {
                minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
                maxDisplay = minDisplay + (double)spaceNum * optimalSpace;
                maxDisplay = minDisplay + spaceNum * optimalSpace;
            }

            return optimalSpace;
@@ -528,9 +1300,9 @@
                }
            }

            double optimalSpace = GetOptimalSpace((maxValue - minValue) / (double)spaceNum, true);
            double optimalSpace = GetOptimalSpace((maxValue - minValue) / spaceNum, true);
            maxDisplay = Math.Ceiling(maxValue / optimalSpace) * optimalSpace;
            minDisplay = maxDisplay - (double)spaceNum * optimalSpace;
            minDisplay = maxDisplay - spaceNum * optimalSpace;

            if (minDisplay > minValue)
            {
@@ -573,6 +1345,10 @@
            {
                if (refSpace < 11.0)
                {
                    if (refSpace < 1)
                    {
                        return 0.5;
                    }
                    if (refSpace < 1.35)
                    {
                        return 1.0;
@@ -727,9 +1503,8 @@
            return num2 * 1000;
        }

        #endregion

        #region æ•°å­—辅助方法

        /// <summary>
        /// æŒ‰æŒ‡å®šé•¿åº¦èŽ·å–
        /// </summary> 
@@ -756,7 +1531,8 @@
            }
            return 0;
        }
        #endregion

    }
}