添加坐标辅助类

tangxu

2024-01-27 29a6de30e328c46cbbcae15066f449b0660c2db1

添加坐标辅助类

 Yw.Application.Curve.Core/1-pump-curve/2-chat/PumpChart_Controller.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,77 @@
namespace Yw.Application
{
    /// <summary>
    /// PumpCurve
    /// </summary>
    [Route("Curve/PumpChart")]
    [ApiDescriptionSettings("Chart", Name = "泵曲线", Order = 10000)]
    public class PumpChart_Controller : IDynamicApiController
    {

        private readonly Service.PumpCurve _service = new();

        #region Query

 

        /// <summary>
        /// é€šè¿‡ ID èŽ·å–
        /// </summary>
        [Route("GetByID@V1.0")]
        [HttpGet]
        public PumpChartDto GetByID([FromQuery][Required] IDInput input)
        {
            var model = _service.GetByID(input.ID);
            return model == null ? null : new PumpChartDto(model);
        }

       

        #endregion

   

        #region Update



        /// <summary>
        /// æ›´æ–°åæ ‡ä¿¡æ¯
        /// </summary>
        [Route("UpdateCoordParas@V1.0")]
        [HttpPut]
        public bool UpdateCoordParas(UpdatePumpCoordParasInput input)
        {
            var bol = _service.UpdateCoordParas(input.ID, input.CoordParas, UserManager.UserID, DateTime.Now);
            return bol;
        }

       

        #endregion

        #region Delete

        /// <summary>
        /// åˆ é™¤æ›²çº¿
        /// </summary>
        [Route("DeleteByID@V1.0")]
        [HttpDelete]
        public bool DeleteByID([FromQuery][Required] IDInput input)
        {
            var bol = _service.DeleteByID(input.ID, out string Msg);
            if (!bol)
            {
                throw YOops.Oh(eResultCode.Alert, ErrorCodes.D999, Msg);
            }
            return bol;
        }

        #endregion





    }
}

 Yw.Application.Curve.Core/1-pump-curve/2-chat/dto/CoordinateParasLxp.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,122 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Yw.Dto
{
    /// <summary>
    /// 
    /// </summary>
    public class CoordinateParasLxp
    {
        /// <summary>
        /// 
        /// </summary>
        public CoordinateParasLxp() { }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dsChartCoord"></param>
        public CoordinateParasLxp(Yw.Coordinate.LxpCoordinateParas dsChartCoord)
        {
            if (dsChartCoord == null)
            {
                return;
            }
        
            //坐标间隔数,坐标线会比坐标间隔数多一
            this.GridNumberX = dsChartCoord.GridNumberX;
            this.GridNumberY = dsChartCoord.GridNumberY;

 
            // 
            this.MinQ = dsChartCoord.CoordMinQ; 
            this.SpaceQ = dsChartCoord.CoordSpaceQ;
            this.DispMinQ = dsChartCoord.CoordMinQ;
            this.DispMaxQ = dsChartCoord.DispMaxQ();

            this.MinH = dsChartCoord.CoordMinH; 
            this.SpaceH = dsChartCoord.CoordSpaceH;
            this.DispMinH = dsChartCoord.DispMinH();
            this.DispMaxH = dsChartCoord.DispMaxH();
            this.StartLineNoH = dsChartCoord.StartLineNoH;
            this.EndLineNoH = dsChartCoord.EndLineNoH;


            this.MinE = dsChartCoord.CoordMinE;
            this.SpaceE = dsChartCoord.CoordSpaceE;
            this.DispMinE = dsChartCoord.DispMinE();
            this.DispMaxE = dsChartCoord.DispMaxE();
            this.StartLineNoE = dsChartCoord.StartLineNoE;
            this.EndLineNoE = dsChartCoord.EndLineNoE;


            this.MinP = dsChartCoord.CoordMinP;
            this.SpaceP = dsChartCoord.CoordSpaceP;
            this.DispMinP = dsChartCoord.DispMinP();
            this.DispMaxP = dsChartCoord.DispMaxP();
            this.StartLineNoP = dsChartCoord.StartLineNoP;
            this.EndLineNoP = dsChartCoord.EndLineNoP;


 

            this.DislocationNumUp = dsChartCoord.DislocationNumUp;
 
           
        }

        /// <summary>
        /// åæ ‡é—´éš”æ•°,坐标线会比坐标间隔数多一
        /// </summary>
        public int GridNumberX = 30;//X坐标
        /// <summary>
        /// 
        /// </summary>
        public int GridNumberY = 16;//Y坐标

        /// <summary>
        /// æ˜¾ç¤ºçš„坐标线号
        /// </summary>
        public int StartLineNoH, EndLineNoH;

        /// <summary>
        /// 
        /// </summary>
        public int StartLineNoE, EndLineNoE;
 

        /// <summary>
        /// 
        /// </summary>
        public int StartLineNoP, EndLineNoP;
 




        /// <summary>
        /// åæ ‡æœ€å°å€¼å’Œé—´éš”
        /// </summary>
        public double MinQ, DispMinQ, DispMaxQ, SpaceQ;
        /// <summary>
        /// 
        /// </summary>
        public double MinH, DispMinH, DispMaxH, SpaceH;
        /// <summary>
        /// 
        /// </summary>
        public double MinE, DispMinE, DispMaxE, SpaceE;
        /// <summary>
        /// 
        /// </summary>
        public double MinP, DispMinP, DispMaxP, SpaceP;
 
        /// <summary>
        /// 
        /// </summary>
        public int DislocationNumUp = 2;//扬程效率刻度 é”™ä½æ•°  (QH和QE坐标的错位) å°±æ˜¯QH下面的空格数 
 
    }
}

 Yw.Application.Curve.Core/1-pump-curve/2-chat/dto/PumpChart.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,151 @@
namespace Yw.Application
{
    /// <summary>
    /// æ³µæ›²çº¿
    /// </summary>
    public class PumpChartDto  
    {

        /// <summary>
        /// 
        /// </summary>
        public PumpChartDto() { }

        /// <summary>
        /// 
        /// </summary>
        public PumpChartDto(Model.PumpCurve rhs)  
        {
            this.Name = rhs.Name;
            this.SourceWay = rhs.SourceWay;
            this.CreateMethod = rhs.CreateMethod;
            //this.CoordParas = rhs.CoordParas;
            //this.CurveInfo = rhs.CurveInfo;
            this.ReliabilityStatus = rhs.ReliabilityStatus;
            this.InputTime = rhs.InputTime;
            this.CreateTime = rhs.CreateTime;
            this.CreateUserID = rhs.CreateUserID;
            this.CreateUserName = rhs.CreateUserName;
            this.UpdateTime = rhs.UpdateTime;
            this.UpdateUserID = rhs.UpdateUserID;
            this.UpdateUserName = rhs.UpdateUserName;
            this.Description = rhs.Description;

            _dictChartObject = new Dictionary<string, object>();
            if(rhs.CurveInfo != null && rhs.CurveInfo.CurveQH != null)
            {
                //最大叶轮曲线
                List<Yw.Curve.CurvePoint> qhPointMax = Yw.Curve.FitHelper.GetFitPoints(rhs.CurveInfo.CurveQH, 20);
                List<Yw.Curve.CurvePoint> qePointMax = Yw.Curve.FitHelper.GetFitPoints(rhs.CurveInfo.CurveQE, 14);
                List<Yw.Curve.CurvePoint> qpPointMax = Yw.Curve.FitHelper.GetFitPoints(rhs.CurveInfo.CurveQP, 14);
                //List<Yw.Curve.CurvePoint> npshPointMax = Yw.Curve.FitHelper.GetFitPoints(_maxCurveGrp.CurveExpressNPSH, 8);

                if (!string.IsNullOrEmpty(rhs.CoordParas))
                {
                    var lxp = new Yw.Coordinate.LxpCoordinateParas(rhs.CoordParas);
                    _dictChartObject["Coordinate"] = new Yw.Dto.CoordinateParasLxp(lxp);
                }
                else
                {
                    var lxp = Yw.Coordinate.CoordinateHelper.CalcCoordinate(qhPointMax, qePointMax, qpPointMax);
                    _dictChartObject["Coordinate"] = new Yw.Dto.CoordinateParasLxp(lxp);
                }

                _dictChartObject["MaxCurveQH"] = BuildDispElement4UI(qhPointMax);
                _dictChartObject["MaxCurveQE"] = BuildDispElement4UI(qePointMax);
                _dictChartObject["MaxCurveQP"] = BuildDispElement4UI(qpPointMax);
                //_dictChartObject["MaxWaterCurveNPSH"] = BuildDispElement4UI(npshPointMax);
            }

        }
        //传入到前端,没必要有过多小数点
        private List<Yw.Curve.CurvePoint> BuildDispElement4UI(List<Yw.Curve.CurvePoint> points)
        {
            if (points != null && points.Count > 0)
            {
                foreach (var pt in points)
                {
                    if (pt != null)
                    {
                        pt.X = Math.Round(pt.X, 3);
                        pt.Y = Math.Round(pt.Y, 3);
                    }
                }
            }
            return points;
        }

        /// <summary>
        /// 
        /// </summary>
        public virtual long ID { get; set; }
        /// <summary>
        /// åç§°
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// æ¥æºæ–¹å¼
        /// </summary>
        public eSourceWay SourceWay { get; set; }

        /// <summary>
        /// åˆ›å»ºæ–¹æ³•
        /// </summary>
        public string CreateMethod { get; set; }


        private Dictionary<string, object> _dictChartObject = null;
        /// <summary>
        /// 
        /// </summary>
        public Dictionary<string, object> DictChartObject { get { return _dictChartObject; }set { _dictChartObject = value; } }
        /// <summary>
        /// å¯ä¿¡åº¦
        /// </summary>
        public eReliabilityStatus ReliabilityStatus { get; set; }

        /// <summary>
        /// å½•å…¥æ—¶é—´
        /// </summary>
        public DateTime InputTime { get; set; }

        /// <summary>
        /// åˆ›å»ºæ—¶é—´
        /// </summary>
        public DateTime CreateTime { get; set; }

        /// <summary>
        /// åˆ›å»ºäººid
        /// </summary>
        public long CreateUserID { get; set; }

        /// <summary>
        /// åˆ›å»ºäººåç§°
        /// </summary>
        public string CreateUserName { get; set; }

        /// <summary>
        /// æ›´æ–°æ—¶é—´
        /// </summary>
        public DateTime? UpdateTime { get; set; }

        /// <summary>
        /// æ›´æ–°äººid
        /// </summary>
        public long? UpdateUserID { get; set; }

        /// <summary>
        /// æ›´æ–°äººåç§°
        /// </summary>
        public string UpdateUserName { get; set; }

        /// <summary>
        /// è¯´æ˜Ž
        /// </summary>
        public string Description { get; set; }

 
    }

}

 Yw.Coordinate/Axis/AxisBase.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; 

namespace Yw.Coordinate 
{
    [DataContract]
    [Serializable]
    public class AxisBase
    {
        [DataMember]
        public double Max { set; get; }//可能不是全部时, 
        [DataMember]
        public double Min { set; get; }//可能不是全部时, å’ŒLabel不一致
        [DataMember]
        public int Unit { set; get; }
    }
}

 Yw.Coordinate/Axis/AxisNonuniform.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,30 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;

namespace Yw.Coordinate 
{
    /// <summary>
    /// éžå‡åŒ€åæ ‡
    /// </summary>
    [DataContract]
    [Serializable]
    public class AxisNonuniform : AxisBase
    {
        [DataMember]
        public List<double> GridValues { get; set; }

        public int GridNumber
        {
            get
            {
                if (GridValues == null)
                    return 0;

                return GridValues.Count();
            }
        }
    }
}

 Yw.Coordinate/Axis/AxisUniform.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;

namespace Yw.Coordinate 
{
    /// <summary>
    /// å‡åŒ€åæ ‡
    /// </summary>
    [DataContract]
    [Serializable]
    public class AxisUniform : AxisBase
    {
        public AxisUniform() { }
        public AxisUniform(double minAcoord, double maxAcoord, double refSpace) {
            this.GridMin = minAcoord;
            this.Min = minAcoord;
            this.GridMax = maxAcoord;
            this.Max = maxAcoord;

            this.GridSpace = refSpace;
        }
        [DataMember]
        public double GridMax { set; get; }//刻度最大值
        [DataMember]
        public double GridMin { set; get; }//刻度最小值
        [DataMember]
        public double GridSpace { set; get; }//刻度间隔

        public int GridNumber
        {
            get
            {
                if (GridSpace <= 0)
                    return 0;

                return 1 + (int)((GridMax - GridMin) / GridSpace);
            }
        }

    }
}

 Yw.Coordinate/Axis/IAxisCalcer.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,55 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Yw.Coordinate 
{
    public interface IAxisCalcer
    {
        double Calc(double v);
        double RevCalc(double v);
    }

    public class ConstantAxis : IAxisCalcer
    {
        public double Calc(double v)
        {
            return v;
        }
        public double RevCalc(double v)
        {
            return v;
        }
    }

    public class Log10Axis : IAxisCalcer
    {
        public double Calc(double v)
        {
            return Math.Log10(v);
        }
        public double RevCalc(double v)
        {
            return Math.Pow(10, v);
        }
    }

    public class CoefficientAxis : IAxisCalcer
    {
        private double Coeff = 1;
        public CoefficientAxis(double coeff)
        {
            Coeff = coeff;
        }
        public double Calc(double v)
        {
            return v * Coeff;
        }
        public double RevCalc(double v)
        {
            return v / Coeff;
        }
    }
}


 Yw.Coordinate/AxisXyCalcer.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,36 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Yw.Model
{
    public class AxisXyCalcer
    {
        IAxisCalcer xCalc = null;
        IAxisCalcer yCalc = null;
        public AxisXyCalcer()
        {
        }
        public AxisXyCalcer(IAxisCalcer AxisCalcerX, IAxisCalcer AxisCalcerY)
        {
            SetCalcer( AxisCalcerX,AxisCalcerY);
        }
        public void SetCalcer(IAxisCalcer AxisCalcerX, IAxisCalcer AxisCalcerY)
        {
            xCalc = AxisCalcerX;
            yCalc = AxisCalcerY;
        }
        public double ToChartX(double v)
        {
            return xCalc.Calc(v);
        }

        public double ToChartY(double v)
        {
            return yCalc.Calc(v);
        }

 
    }
}

 Yw.Coordinate/CoordinateHelper.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,1287 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Yw.Coordinate;

namespace Yw.Coordinate
{
    public class CoordinateHelper
    {
        #region å¾—到最优坐标间隔
        //所有
        public static double GetOptimalSpace(double refSpace)
        {
            if (refSpace < 0.000001)
            {
                return 1;
            }
            if (refSpace < 0.01)
            {
                var refSpace2 = refSpace * 100;
                return GetOptimalSpace(refSpace2) / 100;
            }
            else if (refSpace < 0.1)
            {
                var refSpace2 = refSpace * 10;
                return GetOptimalSpace(refSpace2) / 10;
            }
            else if (refSpace < 1)
            {
                if (refSpace < 0.15)
                    return 0.1;
                else if (refSpace < 0.22)
                    return 0.2;
                //else if (refSpace < 0.32)
                //    return 0.25;
                else if (refSpace < 0.6)
                    return 0.5;
                //else if (refSpace < 0.85)
                //    return 0.75;
                else
                    return 1;
            }
 
            else if (refSpace < 3)
            {                 
                if (refSpace < 1.2)
                    return 1;
                //else if (refSpace < 1.7)
                //    return 1.5;
                else if (refSpace < 2.3)
                    return 2;
                //else if (refSpace < 2.7)
                //    return 2.5;
                else
                    return 3;
            }
            else if (refSpace < 11)
            {
                if (refSpace < 5.5)
                    return 5;
                //else if (refSpace < 6.5)
                //    return 6;
                //else if (refSpace < 7.8)
                //    return 7.5;
                else if (refSpace < 8.5)
                    return 8;
                else
                    return 10;
            }
            else if (refSpace < 16)
                return 15;
            else if (refSpace < 22)
                return 20;
            else if (refSpace < 35)
                return 25;
            else if (refSpace < 41)
                return 40;
            else if (refSpace < 51)
                return 50;
            else if (refSpace < 61)
                return 60;
            else if (refSpace < 71)
                return 70;
            else if (refSpace < 78)
                return 75;
            else if (refSpace < 150)
                return 100;
            else if (refSpace < 230)
                return 200;
            else if (refSpace < 270)
            {
                return 250;
            }
            else
            {
                if (refSpace < 1500)
                {
                    int a = (int)(refSpace / 100);
                    return a * 100;
                }
                else
                {
                    int a = (int)(refSpace / 1000);
                    return a * 1000;
                }
            }
        }

        //取下一档
        public static double GetNextSpace(double refSpace)
        {
            if (refSpace < 0.01)
            {
                var refSpace2 = refSpace * 100;
                return GetNextSpace(refSpace2) / 100;
            }
            else if (refSpace < 0.1)
            {
                var refSpace2 = refSpace * 10;
                return GetNextSpace(refSpace2) / 10;
            }

            if (refSpace < 0.11)
                return 0.2;
            else if (refSpace < 0.201)
                return 0.25;
            else if (refSpace < 0.251)
                return 0.5;
            else if (refSpace < 0.51)
                return 0.75;
            else if (refSpace < 0.751)
                return 1;
            else if (refSpace < 1.01)
                return 1.5;
            else if (refSpace < 1.51)
                return 2;
            else if (refSpace < 2.01)
                return 2.5;
            else if (refSpace < 2.51)
                return 3;
            else if (refSpace < 3.01)
                return 5;
            else if (refSpace < 5.01)
                return 6;
            else if (refSpace < 6.01)
                return 7.5;
            else if (refSpace < 7.51)
                return 8;
            else if (refSpace < 8.01)
                return 10;

            else if (refSpace < 10.1)
                return 15;
            else if (refSpace < 15.1)
                return 20;
            else if (refSpace < 20.1)
                return 25;
            else if (refSpace < 40.1)
                return 40;
            else if (refSpace < 40.1)
                return 50;
            else if (refSpace < 50.1)
                return 60;
            else if (refSpace < 70.1)
                return 70;
            else if (refSpace < 70.1)
                return 75;
            else if (refSpace < 75.1)
                return 100;
            else if (refSpace < 100.1)
                return 200;
            else if (refSpace < 200.1)
                return 250;
            else if (refSpace < 250.1)
                return 500;
            else if (refSpace < 1500)
            {
                int a = (int)(refSpace / 100);
                return a * 100 + 100;
            }
            else
            {
                int a = (int)(refSpace / 1000);
                return a * 1000 + 1000;
            }

        }
       
        //不带小数点
        public static double GetOptimalSpace2(double refSpace)
        {
            if (refSpace < 1.2)
            {
               return 1;
            }
            else if (refSpace < 11)
            {
                if (refSpace < 1.35)
                    return 1;
                else if (refSpace < 2.2)
                    return 2;
                else if (refSpace < 5.5)
                    return 5;
                else if (refSpace < 8.5)
                    return 8;
                else
                    return 10;
            }
            else
            {
                return GetOptimalSpace(refSpace);
            }
        } 
        #endregion

        //所有
        public static Yw.Coordinate.AxisUniform GetCoordAxis(double minRecord, double maxRecord, double spaceNumber)
        {
            if (spaceNumber < 2)
                return null;
            if (minRecord > maxRecord - 0.001)
                return null;
            if (maxRecord < 0.1)
            {
                var coord = GetCoordAxis(minRecord * 100, maxRecord * 100, spaceNumber);
                coord.GridMin = coord.GridMin / 100;
                coord.GridMax = coord.GridMax / 100;
                coord.GridSpace = coord.GridSpace / 100;
                coord.Min = coord.Min / 100;
                coord.Max = coord.Max / 100;
                return coord;
            }
            else if (maxRecord < 1)
            {
                var coord = GetCoordAxis(minRecord * 10, maxRecord * 10, spaceNumber);
                coord.GridMin = coord.GridMin / 10;
                coord.GridMax = coord.GridMax / 10;
                coord.GridSpace = coord.GridSpace / 10;
                coord.Min = coord.Min / 10;
                coord.Max = coord.Max / 10;

                return coord;
            }
            else if (maxRecord < 100)
            {
                double refSpace = (maxRecord - minRecord) / spaceNumber;
                refSpace = GetOptimalSpace(refSpace);

                double minAcoord = Math.Round(((int)minRecord / refSpace) * refSpace, 0);
                double maxAcoord = minAcoord + spaceNumber * refSpace;
                if (maxAcoord < maxRecord)
                {
                    refSpace = GetNextSpace(refSpace);//取一下档
                    minAcoord = Math.Round(((int)minRecord / refSpace) * refSpace, 0);
                    maxAcoord = minAcoord + spaceNumber * refSpace;
                    return new Yw.Coordinate.AxisUniform(minAcoord, maxAcoord, refSpace);
                }
                else
                {
                    return new Yw.Coordinate.AxisUniform(minAcoord, maxAcoord, refSpace);
                }
            }
            else if (maxRecord < 10000)
            {
                double refSpace = (maxRecord - minRecord) / spaceNumber;
                refSpace = GetOptimalSpace(refSpace);

                double minAcoord = (int)((minRecord / refSpace) * refSpace / 100) * 100;//取100的整数
                double maxAcoord = minAcoord + spaceNumber * refSpace;
                if (maxAcoord < maxRecord)
                {
                    refSpace = GetNextSpace(refSpace);//取一下档
                    minAcoord = (int)((minRecord / refSpace) * refSpace / 100) * 100;//取100的整数
                    maxAcoord = minAcoord + spaceNumber * refSpace;
                    return new Yw.Coordinate.AxisUniform(minAcoord, maxAcoord, refSpace);
                }
                else
                {
                    return new Yw.Coordinate.AxisUniform(minAcoord, maxAcoord, refSpace);
                }
            }
            else 
            {//大于10000

                double refSpace = (maxRecord - minRecord) / spaceNumber;
                double minAcoord, maxAcoord;
                if (refSpace > 500 && refSpace < 1000)
                {
                    for (refSpace = 500; refSpace <= 2000; refSpace = refSpace + 100)
                    {
                        minAcoord = (int)((minRecord / refSpace) * refSpace / 1000) * 1000;//取100的整数
                        maxAcoord = minAcoord + spaceNumber * refSpace;
                        if (maxAcoord < maxRecord)
                            continue;
                        return new Yw.Coordinate.AxisUniform(minAcoord, maxAcoord, refSpace);
                    }
                }
                else if (refSpace > 1000)
                {
                    for (refSpace = 1000; refSpace <= 20000; refSpace = refSpace + 500)
                    {
                        minAcoord = (int)((minRecord / refSpace) * refSpace / 1000) * 1000;//取100的整数
                        maxAcoord = minAcoord + spaceNumber * refSpace;
                        if (maxAcoord < maxRecord)
                            continue;

                        return new Yw.Coordinate.AxisUniform(minAcoord, maxAcoord, refSpace);
                    }
                }

                refSpace = GetOptimalSpace(refSpace);

                minAcoord = (int)((minRecord / refSpace) * refSpace / 1000) * 1000;//取1000的整数
                maxAcoord = minAcoord + spaceNumber * refSpace;
                if (maxAcoord < maxRecord)
                {
                    refSpace = GetNextSpace(refSpace);//取一下档
                    minAcoord = (int)((minRecord / refSpace) * refSpace / 1000) * 1000;//取1000的整数
                    maxAcoord = minAcoord + spaceNumber * refSpace;

                    if (maxAcoord < maxRecord)
                    {
                        refSpace = GetNextSpace(refSpace);//取一下档
                        minAcoord = (int)((minRecord / refSpace) * refSpace / 1000) * 1000;//取1000的整数
                        maxAcoord = minAcoord + spaceNumber * refSpace;

                        if (maxAcoord < maxRecord)
                        {
                            refSpace = GetNextSpace(refSpace);//取一下档
                            minAcoord = (int)((minRecord / refSpace) * refSpace / 1000) * 1000;//取1000的整数
                            maxAcoord = minAcoord + spaceNumber * refSpace;

                            return new Yw.Coordinate.AxisUniform(minAcoord, maxAcoord, refSpace);
                        }
                        else
                        {
                            return new Yw.Coordinate.AxisUniform( minAcoord,  maxAcoord,   refSpace );
                        }
                    }
                    else
                    {
                        return new Yw.Coordinate.AxisUniform(minAcoord, maxAcoord, refSpace);
                    }
                }
                else
                {
                    return new Yw.Coordinate.AxisUniform(minAcoord, maxAcoord, refSpace);
                }
            }

        }
       


        #region æ ¹æ®æœ€å°å€¼Min计算
        //得到最优坐标间隔,还会返回显示的最大最小值,保证minDisplay是比minValue小的最大间隙整数倍
        public static double GetOptimalSpaceMin(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
        {
            minDisplay = minValue;
            maxDisplay = maxValue;
            double dis = maxValue - minValue;
            if (dis < 0 || spaceNum < 1)
                return (maxValue - minValue) / 10;

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


            return space;
        }

        public static double GetOptimalSpaceMin(double minValue, double maxValue, double coeff, int spaceNum, out double minDisplay, out double maxDisplay)
        {
            minDisplay = minValue;
            maxDisplay = maxValue;
            double dis = maxValue - minValue;
            if (dis < 0 || spaceNum < 1)
            {
                return (maxValue - minValue) / 10;
            }

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


            return space;
        }
   

        //得到最优坐标间隔,还会返回显示的最大最小值,保证minDisplay是比minValue小的最大间隙整数倍
        public static double GetOptimalSpaceMin(double minValue, double space)
        {
            double minDisplay = minValue;

            return  Math.Floor(minValue / space) * space;
        }      
        #endregion

        #region æ ¹æ®æœ€å¤§å€¼Max计算
        //得到最优坐标间隔,还会返回显示的最大最小值,保证maxDisplay是比maxValue大的最小间隙整数倍
        public static double GetOptimalSpaceMax(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
        {
            minDisplay = minValue;
            maxDisplay = maxValue;
            double dis = maxValue - minValue;
            if (dis < 0 || spaceNum < 1)
                return (maxValue - minValue) / 10;

            double space = GetOptimalSpace((maxValue - minValue) / spaceNum);

            maxDisplay = Math.Ceiling(maxValue / space) * space;
            minDisplay = maxDisplay - spaceNum * space;

            return space;
        }
        //不需要小数点
        public static double GetOptimalSpaceMax2(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
        {
            minDisplay = minValue;
            maxDisplay = maxValue;
            double dis = maxValue - minValue;
            if (dis < 0 || spaceNum < 1)
                return (maxValue - minValue) / 5;

            double space = GetOptimalSpace2((maxValue - minValue) / spaceNum);

            maxDisplay = Math.Ceiling(maxValue / space) * space;
            minDisplay = maxDisplay - spaceNum * space;

            return space;
        }
             
        #endregion

        #region Optimal
        //得到最优坐标间隔,还会返回显示的最大最小值,不保证刻度数spaceNum,保证真实值在显示值内部
        public static double GetOptimalSpaceNum(double minValue, double maxValue, ref int spaceNum, out double minDisplay, out double maxDisplay)
        {
            minDisplay = minValue;
            maxDisplay = maxValue;
            double dis = maxValue - minValue;
            if (dis < 0 || spaceNum < 1)
                return (maxValue - minValue) / 10;

            double space = GetOptimalSpace((maxValue - minValue) / spaceNum);

            minDisplay = Math.Floor(minValue / space) * space;
            maxDisplay = minDisplay + spaceNum * space;

            while (maxDisplay < maxValue)
            {
                spaceNum++;
                maxDisplay = minDisplay + spaceNum * space;
            }

            return space;
        }

        //注意 è¿”回的List大小为spaceNum+1
        public static List<double> GetOptimal(double min, double max, int spaceNum)
        {
            double dis = max - min;
            if (dis < 0 || spaceNum < 1)
                return null;

            double space = GetOptimalSpace((max - min) / spaceNum);

            List<double> valueList = new List<double>();

            int startK = (int)Math.Floor(min / space);//Ceiling
            double start = startK * space;

            double total = start;
            //while (total < max + firstSplitSpace)
            for (int i = 0; i < spaceNum + 1; i++)
            {
                valueList.Add(total);
                total = total + space;
            }

            return valueList;
        }

        
        #endregion

        #region è®¾ç½®åæ ‡å€¼(只有H值)
        //设置坐标值 åªæ˜¾ç¤ºæµé‡æ‰¬ç¨‹
        public static void CalcCoordinate2(ref Yw.Coordinate.QhCoordinateParas coordinateParas, double minQ, double maxQ, double minH, double maxH,
            int GridNumberX = 10, int GridNumberY = 12)
        {
            if (minQ < 0)
                minQ = 0;
            if(coordinateParas==null)
                coordinateParas = new Yw.Coordinate.QhCoordinateParas();

            //流量  
            double dispMinQ = 0;
            double dispMaxQ = 0;
            double CoordSpaceQ = GetOptimalSpaceMin(minQ , maxQ , GridNumberX, out dispMinQ, out dispMaxQ);
            //计算有效刻度
            double dispQ = dispMinQ - CoordSpaceQ;
            coordinateParas.GridValueQ = new List<double>();
            while (dispQ < maxQ)
            {
                dispQ = dispQ + CoordSpaceQ;
                if (dispQ >= 0)
                    coordinateParas.GridValueQ.Add(dispQ);
            }

            //扬程
            double dispMinH = 0;
            double dispMaxH = 0;
            double CoordSpaceH = GetOptimalSpaceMin(minH , maxH , GridNumberY, out dispMinH, out dispMaxH);
            CoordSpaceH = Math.Max(1, CoordSpaceH);

            //计算有效刻度
            double disH = dispMinH - CoordSpaceH;
            coordinateParas.GridValueH = new List<double>();
            while (disH < maxH)
            {
                disH = disH + CoordSpaceH;
                if (disH >= 0)
                    coordinateParas.GridValueH.Add(disH);
            }
        }

        //计算均匀坐标
        public static void CalcCoordinate(
            ref Yw.Coordinate.QhCoordinateParas coordinateParas, 
            double minQ, double maxQ, double minH, double maxH,
            int gridNumX = 10, int gridNumY = 10)
        {
            if (minQ < 0)
                minQ = 0;
            if (coordinateParas == null)
                coordinateParas = new Yw.Coordinate.QhCoordinateParas();

            double spaceQ = (maxQ - minQ) / gridNumX;
            spaceQ = Yw.Coordinate.CoordinateHelper.GetOptimalSpace(spaceQ);
 
            double q = 0;
            int index = (int)(minQ / spaceQ);
            q = index * spaceQ;
            coordinateParas.GridValueQ = new List<double>();
            while (q < maxQ)
            {
                if (q >= 0)
                {
                    coordinateParas.GridValueQ.Add(q);
                }

                q = q + spaceQ;
            }
            coordinateParas.GridValueQ.Add(q);

            if (maxH == minH)
            {
                coordinateParas.GridValueH.Add(maxH/2);
                coordinateParas.GridValueH.Add(maxH);
                coordinateParas.GridValueH.Add(maxH + maxH / 2);
                coordinateParas.GridValueH.Add(maxH + maxH );
            }
            else
            {
                double spaceH = (maxH - minH) / gridNumY;
                spaceH = Yw.Coordinate.CoordinateHelper.GetOptimalSpace(spaceH);
                double h = 0;
                index = (int)(minH / spaceH);
                h = index * spaceH;
                coordinateParas.GridValueH = new List<double>();
                while (h < maxH)
                {
                    if (h >= 0)
                        coordinateParas.GridValueH.Add(h);

                    h = h + spaceH;
                }
                coordinateParas.GridValueH.Add(h);
            }
        }    
   
        
        
        #endregion


        #region è®¾ç½®åæ ‡å€¼(多Y值)
        //计算最大最小值
        public static bool CalcMinMaxValue(
            List<Yw.Curve.CurvePoint> PointInfoQH,
            List<Yw.Curve.CurvePoint> PointInfoQE,
            List<Yw.Curve.CurvePoint> PointInfoQP, 
            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; minQ = 1000;
             maxH = 0; minH = 1000;
             maxE = 0; minE = 1000;
             maxP = 0; minP = 1000; 

            if (PointInfoQH == null  )
                return false;

            minQ = (from x in PointInfoQH select x.X).Min();
            maxQ = (from x in PointInfoQH select x.X).Max();
            if (minQ > maxQ)
                return false;

            minH = (from x in PointInfoQH select x.Y).Min();
            maxH = (from x in PointInfoQH select x.Y).Max();

            if (PointInfoQE != null && PointInfoQE.Count>0)
            {
                minE = (from x in PointInfoQE select x.Y).Min();
                maxE = (from x in PointInfoQE select x.Y).Max();
            }
            if (PointInfoQP != null && PointInfoQP.Count > 0)
            {
                minP = (from x in PointInfoQP select x.Y).Min();
                maxP = (from x in PointInfoQP select x.Y).Max();
            }
 
            return true;
        }

        //设置坐标值
        public static Yw.Coordinate.LxpCoordinateParas CalcCoordinate(
            List<Yw.Curve.CurvePoint> PointInfoQH,
            List<Yw.Curve.CurvePoint> PointInfoQE, 
            List<Yw.Curve.CurvePoint> PointInfoQP )
        {
            if (PointInfoQH == null)
                return null;
            if (PointInfoQE == null)
                return null;
            if (PointInfoQP == null)
                return null;

            //计算最大最小值
            double maxQ = 0, minQ = 1000;
            double maxH = 0, minH = 1000;
            double maxE = 0, minE = 1000;
            double maxP = 0, minP = 1000; 

            CalcMinMaxValue(PointInfoQH, PointInfoQE, PointInfoQP, 
                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 );
        }



 


 
 

        //
        public static Yw.Coordinate.LxpCoordinateParas CalcCoordinate(
            double minQ,double maxQ,
            double minH,double maxH,
            double minE,double maxE,
            double minP,double maxP )
        {
            if (minQ >= maxQ)
            {
                minQ = maxQ / 2;
                maxQ = maxQ * 2;
            }
            if (minH >= maxH)
            {
                minH = maxH / 2;
                maxH = maxH * 2;
            }


            //扬程都设置从0开始
            Yw.Coordinate.LxpCoordinateParas coordinateParas = new Yw.Coordinate.LxpCoordinateParas();
            coordinateParas.GridNumberX = 10;
            coordinateParas.GridNumberY = 18;

            //计算X坐标
            CalcCoordinateQ1(minQ, maxQ, ref coordinateParas, coordinateParas.GridNumberX);


 
                if (maxP > minP + 0.01)
                {
                    CalcCoordinateY_Left(minH, maxH, minP, maxP, 0, ref coordinateParas);
                }
                else
                {
                    double dispMinH, dispMaxH;
                    CalcCoordinateH(minH, maxH, coordinateParas.GridNumberY, ref coordinateParas,
                        out dispMinH, out dispMaxH);
                }
            
 


            //再计算右边:
            if (maxE > minE + 0.01)
                CalcCoordinateEta(minE, maxE , ref coordinateParas);


            return coordinateParas;
        }

 


 
        #endregion


        #region ç¦»å¿ƒæ³µåæ ‡Y
        //根据validGridNumH计算H值
        private static void CalcCoordinateH(
            double minH, double maxH,
            int validGridNumH, 
            ref Yw.Coordinate.LxpCoordinateParas coordinateParas,
            out double disMinH,
            out double disMaxH)
        {
            if (minH > 100 && maxH > 100)
            {
                CalcCoordinateH低于100(minH/100, maxH/100, validGridNumH, ref coordinateParas, out disMinH, out disMaxH);
                if (coordinateParas != null)
                {
                    coordinateParas.CoordMinH = coordinateParas.CoordMinH * 100; 
                    coordinateParas.CoordSpaceH = coordinateParas.CoordSpaceH * 100;

                    disMinH = disMinH * 100;
                    disMaxH = disMaxH * 100;
                }
            }
            else
            {
                  CalcCoordinateH低于100(minH, maxH, validGridNumH,ref coordinateParas, out disMinH, out disMaxH);
            }
        }
        private static void CalcCoordinateH低于100(
            double minH, double maxH,
            int validGridNumH,
            ref Yw.Coordinate.LxpCoordinateParas coordinateParas,
            out double disMinH,
            out double disMaxH)
        {
            if (minH == maxH)
            {
                minH = minH / 2;
                maxH = maxH * 2;
            }
             disMinH = 0;
             disMaxH = 0;

             if (maxH > 20)
                coordinateParas.CoordSpaceH = GetOptimalSpaceMax2(minH, maxH, validGridNumH, out disMinH, out disMaxH);
            else
                coordinateParas.CoordSpaceH = GetOptimalSpaceMax(minH, maxH , validGridNumH, out disMinH, out disMaxH);

            double disH = disMaxH;
            coordinateParas.EndLineNoH = coordinateParas.GridNumberY;
            coordinateParas.StartLineNoH = coordinateParas.EndLineNoH;
            while (disH > minH * 0.98)
            {
                disH = disH - coordinateParas.CoordSpaceH;
                if (disH < 0)
                    break;
                coordinateParas.StartLineNoH--;
            }
            coordinateParas.CoordMinH = disMaxH - coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH;
        }

 


        //根据validGridNumH计算H值,但会比较maxH值
        private static void CalcCoordinateH2(
            double minH, double maxH, 
            int validGridNumH, 
            ref Yw.Coordinate.LxpCoordinateParas coordinateParas,
            out double disMinH,
            out double disMaxH)
        {
            if (minH == maxH)
            {
                minH = minH / 2;
                maxH = maxH * 2;
            }
            if (maxH < 1)
            {
                coordinateParas.CoordSpaceH = 0.1;
                disMinH = 0;
                disMaxH = 1;
                coordinateParas.EndLineNoH = coordinateParas.GridNumberY;
                coordinateParas.StartLineNoH = coordinateParas.EndLineNoH - (int)((disMaxH - disMinH )/ coordinateParas.CoordSpaceH);
                coordinateParas.CoordMinH = disMaxH - coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH;
            }
            else if (maxH < 2)
            {
                coordinateParas.CoordSpaceH = 0.2;
                disMinH = 0;
                disMaxH = 2;
                coordinateParas.EndLineNoH = coordinateParas.GridNumberY;
                coordinateParas.StartLineNoH = coordinateParas.EndLineNoH - (int)((disMaxH - disMinH) / coordinateParas.CoordSpaceH);
                coordinateParas.CoordMinH = disMaxH - coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH;
            }
            else if (maxH < 5)
            {
                coordinateParas.CoordSpaceH = 0.5;
                disMinH = 0;
                disMaxH = 5;
                coordinateParas.EndLineNoH = coordinateParas.GridNumberY;
                coordinateParas.StartLineNoH = coordinateParas.EndLineNoH - (int)((disMaxH - disMinH) / coordinateParas.CoordSpaceH);
                coordinateParas.CoordMinH = disMaxH - coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH;
            }
            else if (maxH < 10)
            {
                coordinateParas.CoordSpaceH = 1;
                disMinH = 0;
                disMaxH = 10;
                coordinateParas.EndLineNoH = coordinateParas.GridNumberY;
                coordinateParas.StartLineNoH = coordinateParas.EndLineNoH - (int)((disMaxH - disMinH) / coordinateParas.CoordSpaceH);
                coordinateParas.CoordMinH = disMaxH - coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH;
            }
            else if (maxH < 12)
            {
                coordinateParas.CoordSpaceH = 1;
                disMinH = 0;
                disMaxH = 12;
                coordinateParas.EndLineNoH = coordinateParas.GridNumberY;
                coordinateParas.StartLineNoH = coordinateParas.EndLineNoH - (int)((disMaxH - disMinH) / coordinateParas.CoordSpaceH);
                coordinateParas.CoordMinH = disMaxH - coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH;
            }
            else if (maxH < 15)
            {
                coordinateParas.CoordSpaceH = 2;
                disMinH = 0;
                disMaxH = 16;
                coordinateParas.EndLineNoH = coordinateParas.GridNumberY;
                coordinateParas.StartLineNoH = coordinateParas.EndLineNoH - (int)((disMaxH - disMinH) / coordinateParas.CoordSpaceH);
                coordinateParas.CoordMinH = disMaxH - coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH;
            }
            else if (maxH < 20)
            {
                coordinateParas.CoordSpaceH = 2;
                disMinH = 0;
                disMaxH = 20;
                coordinateParas.EndLineNoH = coordinateParas.GridNumberY;
                coordinateParas.StartLineNoH = coordinateParas.EndLineNoH - (int)((disMaxH - disMinH) / coordinateParas.CoordSpaceH);
                coordinateParas.CoordMinH = disMaxH - coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH;
            }
            else
            {
                CalcCoordinateH(minH, maxH, validGridNumH, ref coordinateParas, out disMinH, out disMaxH);
            }
        }

 

        //downGridNum ä¸‹éƒ¨ä¿ç•™åˆ»åº¦çº¿çš„数量
        private static void CalcCoordinateY_Left(
            double minH, double maxH, 
            double minP, double maxP,
            int downGridNum,
            ref Yw.Coordinate.LxpCoordinateParas coordinateParas)
        {
            //扬程
            int validGridNumH = 6;
            double disMinH = 0;
            double disMaxH = 0;
            CalcCoordinateH2(minH, maxH, validGridNumH, ref coordinateParas, out disMinH, out disMaxH);
            //扬程和功率之间的格子数
            int HP_grid_dis = 5;

            #region åŠŸçŽ‡
            int validGridNumP = coordinateParas.StartLineNoH - HP_grid_dis - downGridNum;
            if (validGridNumP < 3)
                validGridNumP = 3;
            double disMinP = 0;
            double disMaxP = 0;
            coordinateParas.CoordSpaceP = GetOptimalSpaceMax(minP, maxP, validGridNumP, out disMinP, out disMaxP);
            //
            double disP = disMaxP;
            coordinateParas.EndLineNoP = coordinateParas.StartLineNoH - HP_grid_dis;
            coordinateParas.StartLineNoP = coordinateParas.EndLineNoP;
            while (disP > minP * 0.98)
            {
                disP = disP - coordinateParas.CoordSpaceP;
                if (disP < 0)
                    break;
                coordinateParas.StartLineNoP--;
            } 
            #endregion

            if (coordinateParas.StartLineNoP < downGridNum)
            {
                int addGridNum = downGridNum - coordinateParas.StartLineNoP;
                coordinateParas.GridNumberY = coordinateParas.GridNumberY + addGridNum;//Y刻度数也要添加
                coordinateParas.EndLineNoH = coordinateParas.EndLineNoH + addGridNum;
                coordinateParas.StartLineNoH = coordinateParas.StartLineNoH + addGridNum;
                coordinateParas.EndLineNoP = coordinateParas.EndLineNoP + addGridNum;
                coordinateParas.StartLineNoP = coordinateParas.StartLineNoP + addGridNum;
            }

            //计算最小值
            coordinateParas.CoordMinH =  disMaxH - coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH ;
            coordinateParas.CoordMinP =  disMaxP - coordinateParas.EndLineNoP * coordinateParas.CoordSpaceP ;
        }

 
        //效率
        public static void CalcCoordinateEta(double minE, double maxE,  
            ref Yw.Coordinate.LxpCoordinateParas coordinateParas)
        {           
            if (maxE <= 50)
            {
                coordinateParas.StartLineNoE = coordinateParas.EndLineNoNPSH + 3;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 5;
                coordinateParas.CoordSpaceE = 10;
            }
            else if (maxE <= 60)
            {
                coordinateParas.StartLineNoE = coordinateParas.EndLineNoNPSH + 3;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 6;
                coordinateParas.CoordSpaceE = 10;
            }
            else
            {
                coordinateParas.StartLineNoE = coordinateParas.EndLineNoNPSH + 3;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 5;
                coordinateParas.CoordSpaceE = 20;
            }

            coordinateParas.CoordMinE = -coordinateParas.StartLineNoE * coordinateParas.CoordSpaceE;
        }

        public static void CalcCoordinateEta( double maxE,   ref Yw.Coordinate.LxpCoordinateParas coordinateParas)
        {
            //效率
            if (maxE <= 50)
            {
                coordinateParas.StartLineNoE = coordinateParas.EndLineNoNPSH + 3;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 5;
                coordinateParas.CoordSpaceE = 5;
            }
            else if (maxE <= 75)
            {
                coordinateParas.StartLineNoE = coordinateParas.EndLineNoNPSH + 3;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 6;
                coordinateParas.CoordSpaceE = 10;
            }
            else
            {
                coordinateParas.StartLineNoE = coordinateParas.EndLineNoNPSH + 3;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 5;
                coordinateParas.CoordSpaceE = 20;
            }

            coordinateParas.CoordMinE = -coordinateParas.StartLineNoE * coordinateParas.CoordSpaceE;
        }


 
 
        
        
        
        #endregion


        #region è®¡ç®—流量坐标
        //
        public  static void CalcCoordinateQ1(double minQ, double maxQ, ref Yw.Coordinate.LxpCoordinateParas coordinateParas, int validGridNum = 10)
        {
            double dispMinQ = 0;
            double dispMaxQ = 0;
            coordinateParas.CoordSpaceQ = GetOptimalSpaceMin(minQ, maxQ, validGridNum, out dispMinQ, out dispMaxQ);
            coordinateParas.CoordSpaceQ = Math.Max(0.5, coordinateParas.CoordSpaceQ);//最小也是0.5
            if (coordinateParas.CoordSpaceQ == 8)
                coordinateParas.CoordSpaceQ = 10;

            //计算有效刻度
            double disQ = dispMinQ;
            coordinateParas.CoordMinQ = dispMinQ;
            coordinateParas.GridNumberX = 0;
            while (disQ < maxQ)
            {
                coordinateParas.GridNumberX++;
                disQ = dispMinQ + coordinateParas.GridNumberX * coordinateParas.CoordSpaceQ;
            }
            if (coordinateParas.GridNumberX <= 5)
            {
                coordinateParas.CoordSpaceQ = coordinateParas.CoordSpaceQ * 0.5;
                coordinateParas.GridNumberX = coordinateParas.GridNumberX*2;
            }
            //if (coordinateParas.GridNumberX < 5)
            //{
            //    coordinateParas.GridNumberX = 5;
            //}
        }

        
        
        //只有5:6:10 ä¸‰ç§é—´éš”(代码保留)
        public static void CalcCoordinateQ2(double minQ, double maxQ, ref Yw.Coordinate.LxpCoordinateParas coordinateParas)
        {
            //流量(比较哪种方法分段好)
            if (minQ < maxQ)
            {
                double dispMinQ = 0;
                double dispMaxQ = 0;
                int spaceNum = -1;
                double cz = -1;

                double space5 = GetOptimalSpace((maxQ - minQ) / 5);
                double dispMinQ5 = Math.Floor(minQ / space5) * space5;
                double dispMaxQ5 = dispMinQ5 + space5 * 5;
                double cz5 = dispMaxQ5 - maxQ;
                bool isCZ5 = cz5 > 0;
                if (isCZ5)
                {
                    spaceNum = 5;
                    cz = cz5;
                }

                double space6 = GetOptimalSpace((maxQ - minQ) / 6);
                double dispMinQ6 = Math.Floor(minQ / space6) * space6;//小于minQ的最大值
                double dispMaxQ6 = dispMinQ6 + space6 * 6;
                double cz6 = dispMaxQ6 - maxQ;
                bool isCZ6 = cz6 > 0;
                if (isCZ6)
                {
                    if (spaceNum > 0)
                    {
                        if (cz6 < cz)
                        {
                            spaceNum = 6;
                            cz = cz6;
                        }
                    }
                    else
                    {
                        spaceNum = 6;
                        cz = cz6;
                    }
                }

                double space10 = GetOptimalSpace((maxQ - minQ) / 10);
                double dispMinQ10 = Math.Floor(minQ / space10) * space10;
                double dispMaxQ10 = dispMinQ10 + space10 * 10;
                double cz10 = dispMaxQ10 - maxQ;
                bool isCZ10 = cz10 > 0;
                if (isCZ10)
                {
                    if (spaceNum > 0)
                    {
                        if (cz10 < cz)
                        {
                            spaceNum = 10;
                            cz = cz10;
                        }
                    }
                    else
                    {
                        spaceNum = 10;
                        cz = cz10;
                    }
                }

                //
                switch (spaceNum)
                {
                    case 5:
                        coordinateParas.GridNumberX = 5;
                        coordinateParas.CoordSpaceQ = space5;
                        dispMinQ = dispMinQ5;
                        dispMaxQ = dispMinQ5 + 5 * space5;
                        break;
                    case 6:
                        coordinateParas.GridNumberX = 6;
                        coordinateParas.CoordSpaceQ = space6;
                        dispMinQ = dispMinQ6;
                        dispMaxQ = dispMinQ6 + 6 * space6;
                        break;
                    case 10:
                        coordinateParas.GridNumberX = 10;
                        coordinateParas.CoordSpaceQ = space10;
                        dispMinQ = dispMinQ10;
                        dispMaxQ = dispMinQ10 + 10 * space10;
                        break;
                    default:
                        //都不符合,只能用5的然后多取一个
                        coordinateParas.GridNumberX = 6;
                        coordinateParas.CoordSpaceQ = space5;
                        dispMinQ = dispMinQ5;
                        dispMaxQ = dispMinQ5 + 6 * space5;
                        break;
                }

                coordinateParas.CoordMinQ = dispMinQ;
            }
        }
        //只有5:6:10 ä¸‰ç§é—´éš”(代码保留)
        private static void CalcCoordinateQ3(double minQ, double maxQ, ref Yw.Coordinate.LxpCoordinateParas CoordinateParas)
        {
            //流量(比较哪种方法分段好)
            if (minQ < maxQ)
            {
                double dispMinQ = 0;
                double dispMaxQ = 0;
                int spaceNum = -1;
                double cz = -1;

                double space5 = CoordinateHelper.GetOptimalSpace((maxQ - minQ) / 5);
                double dispMinQ5 = Math.Floor(minQ / space5) * space5;
                double dispMaxQ5 = dispMinQ5 + space5 * 5;
                double cz5 = dispMaxQ5 - maxQ;
                bool isCZ5 = cz5 > 0;
                if (isCZ5)
                {
                    spaceNum = 5;
                    cz = cz5;
                }

                double space6 = CoordinateHelper.GetOptimalSpace((maxQ - minQ) / 6);
                double dispMinQ6 = Math.Floor(minQ / space6) * space6;//小于minQ的最大值
                double dispMaxQ6 = dispMinQ6 + space6 * 6;
                double cz6 = dispMaxQ6 - maxQ;
                bool isCZ6 = cz6 > 0;
                if (isCZ6)
                {
                    if (spaceNum > 0)
                    {
                        if (cz6 < cz)
                        {
                            spaceNum = 6;
                            cz = cz6;
                        }
                    }
                    else
                    {
                        spaceNum = 6;
                        cz = cz6;
                    }
                }

                double space10 = CoordinateHelper.GetOptimalSpace((maxQ - minQ) / 10);
                double dispMinQ10 = Math.Floor(minQ / space10) * space10;
                double dispMaxQ10 = dispMinQ10 + space10 * 10;
                double cz10 = dispMaxQ10 - maxQ;
                bool isCZ10 = cz10 > 0;
                if (isCZ10)
                {
                    if (spaceNum > 0)
                    {
                        if (cz10 < cz)
                        {
                            spaceNum = 10;
                            cz = cz10;
                        }
                    }
                    else
                    {
                        spaceNum = 10;
                        cz = cz10;
                    }
                }

                //
                switch (spaceNum)
                {
                    case 5:
                        CoordinateParas.GridNumberX = 5;
                        CoordinateParas.CoordSpaceQ = space5;
                        dispMinQ = dispMinQ5;
                        dispMaxQ = dispMinQ5 + 5 * space5;
                        break;
                    case 6:
                        CoordinateParas.GridNumberX = 6;
                        CoordinateParas.CoordSpaceQ = space6;
                        dispMinQ = dispMinQ6;
                        dispMaxQ = dispMinQ6 + 6 * space6;
                        break;
                    case 10:
                        CoordinateParas.GridNumberX = 10;
                        CoordinateParas.CoordSpaceQ = space10;
                        dispMinQ = dispMinQ10;
                        dispMaxQ = dispMinQ10 + 10 * space10;
                        break;
                    default:
                        //都不符合,只能用5的然后多取一个
                        CoordinateParas.GridNumberX = 5;
                        CoordinateParas.CoordSpaceQ = space5;
                        dispMinQ = dispMinQ5;
                        dispMaxQ = dispMinQ5 + 6 * space5;
                        break;
                }

                CoordinateParas.CoordMinQ = dispMinQ;
            }
        }
        
        #endregion



        #region å­åˆ»åº¦æ•°é‡
        //获取子刻度数量
        public static int GetMiniCount(double space)
        {
            if (space > 10000)
                return GetMiniCount2(space / 10000);
            else if (space > 1000)
                return GetMiniCount2(space / 1000);
            else if (space > 100)
                return GetMiniCount2(space / 100);
            else if (space > 10)
                return GetMiniCount2(space / 10);
            else if (space > 1)
                return GetMiniCount2(space);
            else if (space > 0.1)
                return GetMiniCount2(space * 10);
            else if (space > 0.01)
                return GetMiniCount2(space * 100);
            else if (space > 0.001)
                return GetMiniCount2(space * 1000);
            return 2;
        }
        //1-10之间
        private static int GetMiniCount2(double space)
        {
            if (Math.Abs(space - 9) < 0.1)
                return 2;
            else if (Math.Abs(space - 8) < 0.1)
                return 3;
            else if (Math.Abs(space - 7.5) < 0.1)
                return 2;
            else if (Math.Abs(space - 7) < 0.1)
                return 1;
            else if (Math.Abs(space - 6) < 0.1)
                return 2;
            else if (Math.Abs(space - 5) < 0.1)
                return 4;
            else if (Math.Abs(space - 4) < 0.1)
                return 3;
            else if (Math.Abs(space - 3) < 0.1)
                return 2;
            else if (Math.Abs(space - 2) < 0.1)
                return 1;
            else if (Math.Abs(space - 1) < 0.1)
                return 4;

            return 2;
        }
        
        #endregion 
    }
}

 Yw.Coordinate/GlobalUsings.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,7 @@
 
global using MathNet.Numerics;
global using System.Runtime.Serialization;
global using System.ComponentModel.DataAnnotations;
global using System.ComponentModel;
global using System.Text;
global using Yw.Coordinate;

 Yw.Coordinate/IGetLxpCoordinate.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Yw.Coordinate
{
    public interface IGetLxpCoordinate
    {
        Yw.Coordinate.LxpCoordinateParas GetCoordinateParas();
    }

    public interface ISetLxpCoordinate
    {
        void  SetCoordinateParas(Yw.Coordinate.LxpCoordinateParas coord);
    }
}

 Yw.Coordinate/IGetQhCoordinate.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Yw.Coordinate
{
    public interface IGetQhCoordinate
    {
        Yw.Coordinate.QhCoordinateParas GetCoordinateParas();
    }

    public interface ISetQhCoordinate
    {
        void  SetCoordinateParas(Yw.Coordinate.QhCoordinateParas coord);
    }
}

 Yw.Coordinate/LxpCoordinateParas.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,383 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Data;
using System.Text;

namespace Yw.Coordinate
{
    public class LxpCoordinateParas
    {
        public LxpCoordinateParas() { }

        public LxpCoordinateParas(string strChartCoord)
        {
            try
            {
                if (string.IsNullOrEmpty(strChartCoord))
                {
                    isNull = true;
                    return;
                }

                string[] coords = strChartCoord.Split('|');
                if (coords.Count() < 6)
                {
                    isNull = true;
                    return;
                }

                //
                string sbQ = coords[0];
                string[] coordParasQ = sbQ.Split(',');
                //coordParasQ[0] =1 è¡¨ç¤ºå‡åŒ€ é»˜è®¤å°±æ˜¯å‡åŒ€çš„
                //this.UnitQ = Convert.ToInt32(coordParasQ[1]);
                this.GridNumberX = Convert.ToInt32(coordParasQ[2]);
                this.CoordMinQ = Convert.ToDouble(coordParasQ[3]);
                this.CoordSpaceQ = Convert.ToDouble(coordParasQ[4]);


                //
                string sbY = coords[1];
                string[] coordParasY = sbY.Split(',');
                //coordParasQ[0] =1 è¡¨ç¤ºå‡åŒ€:默认就是均匀的
                this.GridNumberY = Convert.ToInt32(coordParasY[1]);

                //H
                string sbH = coords[2];
                string[] coordParasH = sbH.Split(',');
                //this.UnitH = (UnitH)Convert.ToInt32(coordParasH[0]);
                this.CoordMinH =  Convert.ToDouble(coordParasH[1]) ;
                this.CoordSpaceH = Convert.ToDouble(coordParasH[2]);
                this.StartLineNoH = Convert.ToInt32(coordParasH[3]);
                this.EndLineNoH = Convert.ToInt32(coordParasH[4]);

                //Eff
                string sbE = coords[3];
                string[] coordParasE = sbE.Split(',');
                // this.UnitE = (UnitE)Convert.ToInt32(coordParasE[0]);
                this.CoordMinE =  Convert.ToDouble(coordParasE[1]) ;
                this.CoordSpaceE = Convert.ToDouble(coordParasE[2]);
                this.StartLineNoE = Convert.ToInt32(coordParasE[3]);
                this.EndLineNoE = Convert.ToInt32(coordParasE[4]);
                if (this.CoordSpaceE < 0.01)
                    this.CoordSpaceE = 10;
                if (this.EndLineNoE == 0)
                    this.EndLineNoE = 10;

                //Power
                string sbP = coords[4];
                string[] coordParasP = sbP.Split(',');
                // paras.UnitP = (UnitE)Convert.ToInt32(coordParasP[0]);
                this.CoordMinP =  Convert.ToDouble(coordParasP[1]) ;
                this.CoordSpaceP = Convert.ToDouble(coordParasP[2]);
                this.StartLineNoP = Convert.ToInt32(coordParasP[3]);
                this.EndLineNoP = Convert.ToInt32(coordParasP[4]);
                if (this.CoordSpaceP < 0.001)
                    this.CoordSpaceP = 10;
                if (this.EndLineNoP == 0)
                    this.EndLineNoP = 5;

                //QNPSH
                string sbNPSH = coords[5];
                string[] coordParasNPSH = sbNPSH.Split(',');
                // this.UnitNPSH = (UnitH)Convert.ToInt32(coordParasNPSH[0]);
                this.CoordMinNPSH = Convert.ToDouble(coordParasNPSH[1]);
                this.CoordSpaceNPSH = Convert.ToDouble(coordParasNPSH[2]);
                this.StartLineNoNPSH = Convert.ToInt32(coordParasNPSH[3]);
                this.EndLineNoNPSH = Convert.ToInt32(coordParasNPSH[4]);
                if (this.CoordSpaceNPSH < 0.1)
                    this.CoordSpaceNPSH = 1;
                if (this.EndLineNoNPSH == 0)
                    this.EndLineNoNPSH = 5;

                if (coords.Count() > 6)
                {//大于6
                    string sbPanel = coords[6];
                    string[] coordParasPanel = sbPanel.Split(',');
                    this.DispStyle = Convert.ToInt32(coordParasPanel[0]);
                    var num1 = Convert.ToInt32(coordParasPanel[1]);
                    if (num1 > 0)//不能是0 ä¸ºäº†å…¼å®¹è€æ•°æ®, è€çš„数据里面是0
                        this.DislocationNumUp = num1;

                    var num2 = Convert.ToInt32(coordParasPanel[2]);
                    if (num2 > 0)
                        this.DislocationNumDown = num2;
                }
            }
            catch (Exception)
            {
                isNull = true;
                return;
            }
        }

        public LxpCoordinateParas(LxpCoordinateParas rhs)
        {
            if (rhs == null)
            {
                return;
            }


            this.UnitQ = rhs.UnitQ;
            this.GridNumberX = rhs.GridNumberX;
            this.CoordMinQ = rhs.CoordMinQ;
            this.CoordSpaceQ = rhs.CoordSpaceQ;

            //
            this.GridNumberY = rhs.GridNumberY;

            //H
            this.UnitH = rhs.UnitH;
            this.CoordMinH = rhs.CoordMinH;
            this.CoordSpaceH = rhs.CoordSpaceH;
            this.StartLineNoH = rhs.StartLineNoH;
            this.EndLineNoH = rhs.EndLineNoH;

            //Eff
            this.CoordMinE = rhs.CoordMinE;
            this.CoordSpaceE = rhs.CoordSpaceE;
            this.StartLineNoE = rhs.StartLineNoE;
            this.EndLineNoE = rhs.EndLineNoE;


            //Power
            this.CoordMinP = rhs.CoordMinP;
            this.CoordSpaceP = rhs.CoordSpaceP;
            this.StartLineNoP = rhs.StartLineNoP;
            this.EndLineNoP = rhs.EndLineNoP;


            //QNPSH
            this.CoordMinNPSH = rhs.CoordMinNPSH;
            this.CoordSpaceNPSH = rhs.CoordSpaceNPSH;
            this.StartLineNoNPSH = rhs.StartLineNoNPSH;
            this.EndLineNoNPSH = rhs.EndLineNoNPSH;

            this.DispStyle = rhs.DispStyle;
            this.DislocationNumUp = rhs.DislocationNumUp;
            this.DislocationNumDown = rhs.DislocationNumDown;
        }


        //得到空白的坐标值
        public static LxpCoordinateParas GetBlankCoordinate()
        {
            LxpCoordinateParas para = new LxpCoordinateParas();
            para.GridNumberX = 30;
            para.GridNumberY = 16;

            //显示的坐标线号
            para.StartLineNoH = 10;
            para.EndLineNoH = 15;

            para.StartLineNoE = 0;
            para.EndLineNoE = 10;

            para.StartLineNoP = 2;
            para.EndLineNoP = 9;

            //坐标最小值和间隔
            para.CoordMinQ = 0; para.CoordSpaceQ = 1000;
            para.CoordMinH = 10; para.CoordSpaceH = 100;
            para.CoordMinE = 0; para.CoordSpaceE = 100;
            para.CoordMinP = 10; para.CoordSpaceP = 100;

            return para;
        }


        //坐标间隔数,坐标线会比坐标间隔数多一
        public int GridNumberX = 30;//X坐标
        public int GridNumberY = 16;//Y坐标

        //显示的坐标线号
        public int StartLineNoH;
        public int EndLineNoH;

        public int StartLineNoE;
        public int EndLineNoE;

        public int StartLineNoP;
        public int EndLineNoP;

        public int StartLineNoNPSH;
        public int EndLineNoNPSH;

        //面板显示设置
        public int DispStyle = 0;//显示风格 0 è·Ÿéšç³»ç»Ÿ: ä»¥åŽæ‹“展
        public int DislocationNumUp = 2;//扬程效率刻度 é”™ä½æ•°  (QH和QE坐标的错位) å°±æ˜¯QH下面的空格数 
        public int DislocationNumDown = 1;//气蚀功率刻度 é”™ä½æ•°

 
        //坐标最小值和间隔
        public double CoordMinQ, CoordSpaceQ;
        public double CoordMinH, CoordSpaceH;
        public double CoordMinE, CoordSpaceE;
        public double CoordMinP, CoordSpaceP;
        public double CoordMinNPSH, CoordSpaceNPSH;

        //
        public double DispMaxQ()
        {
            return this.CoordMinQ + this.GridNumberX * this.CoordSpaceQ;
        }

        public double DispMinH()
        {
            return this.CoordMinH + this.StartLineNoH * this.CoordSpaceH;
        }
        public double DispMaxH()
        {
            return this.CoordMinH + this.EndLineNoH * this.CoordSpaceH;
        }
        public double DispMinE()
        {
            return this.CoordMinE + this.StartLineNoE * this.CoordSpaceE;
        }
        public double DispMaxE()
        {
            return this.CoordMinE + this.EndLineNoE * this.CoordSpaceE;
        }
        public double DispMinP()
        {
            return this.CoordMinP + this.StartLineNoP * this.CoordSpaceP;
        }
        public double DispMaxP()
        {
            return this.CoordMinP + this.EndLineNoP * this.CoordSpaceP;
        }
        public double DispMinNPSH()
        {
            return this.CoordMinNPSH + this.StartLineNoNPSH * this.CoordSpaceNPSH;
        }
        public double DispMaxNPSH()
        {
            return this.CoordMinNPSH + this.EndLineNoNPSH * this.CoordSpaceNPSH;
        }
        // 
        public int? UnitQ
        {
            get { return _unitQ; }
            set
            {
                _unitQ = value; 
            }
        }
        private int? _unitQ = null;

        //
        public int? UnitH
        {
            get { return _unitH; }
            set
            {
                _unitH = value; 
            }
        }
        private int? _unitH = null;
    
        //
        public int? UnitP { get { return _unitP; } set { _unitP = value;  } }
        private int? _unitP = null;
 

        public Object Clone()  //对外提供一个创建自身的浅表副本的能力
        {
            return this.MemberwiseClone();
        }

        //坐标刻度的最小值
        public double TitleMinH { get { return CoordMinH + StartLineNoH * CoordSpaceH; } }

        //
        protected bool isNull = false;
        public bool IsNull
        {
            get { return isNull; }
        }

        public static LxpCoordinateParas ToParameter(string strChartCoord)
        {
            try
            {
                var paras = new LxpCoordinateParas(strChartCoord);
                if (paras.isNull)
                    return null;
                else
                    return paras;
            }
            catch (Exception)
            {
                return null;
            }
        }

        public string ToDsString()
        {
            return ToDsString(this);
        }

        public static string ToDsString(LxpCoordinateParas paras)
        {
            if (paras == null)
                return "";//为了ACCESS只能用""

            StringBuilder sbQ = new StringBuilder();
            sbQ.Append("1,");//1：表示均匀
            sbQ.Append(paras.UnitQ==null?"": paras.UnitQ.ToString()); sbQ.Append(",");
            sbQ.Append(paras.GridNumberX); sbQ.Append(",");
            sbQ.Append(paras.CoordMinQ); sbQ.Append(",");
            sbQ.Append(paras.CoordSpaceQ);

            //
            StringBuilder sbY = new StringBuilder();
            sbY.Append("1,");//1：表示均匀
            sbY.Append(paras.GridNumberY);

            //
            StringBuilder sbH = new StringBuilder();
            sbH.Append(paras.UnitH == null ? "" : paras.UnitH.ToString()); sbH.Append(",");//要保留小数, å› ä¸ºå•ä½åŽŸå› 
            sbH.Append(paras.CoordMinH); sbH.Append(",");
            sbH.Append(paras.CoordSpaceH); sbH.Append(",");
            sbH.Append(paras.StartLineNoH); sbH.Append(",");
            sbH.Append(paras.EndLineNoH);

            StringBuilder sbE = new StringBuilder();
            sbE.Append("0,");//暂时没有单位

            sbE.Append(paras.CoordMinE); sbE.Append(",");
            sbE.Append(paras.CoordSpaceE); sbE.Append(",");
            sbE.Append(paras.StartLineNoE); sbE.Append(",");
            sbE.Append(paras.EndLineNoE);

            StringBuilder sbP = new StringBuilder();
            sbP.Append(paras.UnitP == null ? "" : paras.UnitP.ToString()); sbP.Append(",");
            sbP.Append(paras.CoordMinP); sbP.Append(",");
            sbP.Append(paras.CoordSpaceP); sbP.Append(",");
            sbP.Append(paras.StartLineNoP); sbP.Append(",");
            sbP.Append(paras.EndLineNoP);

            StringBuilder sbNPSH = new StringBuilder();
            sbNPSH.Append(",");//暂时没有单位
            sbNPSH.Append(paras.CoordMinNPSH); sbNPSH.Append(",");
            sbNPSH.Append(paras.CoordSpaceNPSH); sbNPSH.Append(",");
            sbNPSH.Append(paras.StartLineNoNPSH); sbNPSH.Append(",");
            sbNPSH.Append(paras.EndLineNoNPSH);

            StringBuilder sbPanel = new StringBuilder();
            sbPanel.Append(paras.DispStyle); sbPanel.Append(",");
            sbPanel.Append(paras.DislocationNumUp); sbPanel.Append(",");
            sbPanel.Append(paras.DislocationNumDown);

            string strChartCoord = string.Format("{0}|{1}|{2}|{3}|{4}|{5}|{6}",
                sbQ.ToString(), sbY.ToString(), sbH.ToString(), sbE.ToString(), sbP.ToString(), sbNPSH.ToString(),
                sbPanel.ToString());

            return strChartCoord;
        }

  
    }
}

 Yw.Coordinate/LxpCoordinateParasConver.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,21 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Yw.Coordinate;

namespace Yw.Coordinate
{
    // ç¦»å¿ƒæ³µ
    public class LxpCoordinateParasConver
    {
        public static string ToDsString(LxpCoordinateParas paras)
        {
            return LxpCoordinateParas.ToDsString(paras);     
        }
        public static LxpCoordinateParas ToParameter(string strChartCoord)
        {
            return LxpCoordinateParas.ToParameter(strChartCoord);
        }
    }
}

 Yw.Coordinate/Properties/PublishProfiles/FolderProfile.pubxml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
https://go.microsoft.com/fwlink/?LinkID=208121.
-->
<Project>
  <PropertyGroup>
    <Configuration>Release</Configuration>
    <Platform>Any CPU</Platform>
    <PublishDir>bin\Release\net6.0\publish\</PublishDir>
    <PublishProtocol>FileSystem</PublishProtocol>
  </PropertyGroup>
</Project>

 Yw.Coordinate/Properties/PublishProfiles/FolderProfile.pubxml.user

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,9 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
https://go.microsoft.com/fwlink/?LinkID=208121.
-->
<Project>
  <PropertyGroup>
    <History>True|2023-11-24T04:41:35.1109248Z;True|2023-11-07T10:59:03.8484346+08:00;True|2023-09-22T13:16:35.5213053+08:00;True|2023-09-19T13:47:08.6616971+08:00;True|2023-09-19T13:42:42.1690038+08:00;True|2023-09-18T15:12:24.4129783+08:00;False|2023-09-18T15:11:19.1798407+08:00;True|2023-09-01T13:20:20.4261550+08:00;True|2023-09-01T11:08:43.5292206+08:00;True|2023-08-29T16:21:32.3346453+08:00;</History>
  </PropertyGroup>
</Project>

 Yw.Coordinate/QhCoordinateParas.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,224 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Yw.Coordinate
{
    public class QhCoordinateParas: ICloneable
    {
        public QhCoordinateParas( )
        { 
        }
        public QhCoordinateParas(ZlpCoordinateParas rhs)
        {
            this.IsLogQ = rhs.IsLogQ;
            this.GridValueQ = rhs.GridValueQ;
            this.UnitQ = rhs.UnitQ;

            this.IsLogH = rhs.IsLogH;
            this.GridValueH = rhs.GridValueH;
            this.UnitH = rhs.UnitH;
        }
        public QhCoordinateParas(QhCoordinateParas rhs)
        {
            this.IsLogQ = rhs.IsLogQ;
            this.GridValueQ = rhs.GridValueQ;
            this.UnitQ = rhs.UnitQ;

            this.IsLogH = rhs.IsLogH;
            this.GridValueH = rhs.GridValueH;
            this.UnitH = rhs.UnitH;
        }
        public QhCoordinateParas(string strChartCoord)
        {
            if (string.IsNullOrEmpty(strChartCoord))
            {
                isNull = true;
                return;
            }

            string[] coords = strChartCoord.Split('|');
            if (coords.Count() != 2)
            {
                isNull = true;
                return;
            }


            this.GridValueQ = new List<double>();
            string sbQ = coords[0];
            string[] coordParasQ = sbQ.Split(',');
            //this.UnitQ = (UnitQ)Convert.ToInt32(coordParasQ[0]);
            this.IsLogQ = Convert.ToBoolean(coordParasQ[1]);
            
            for (int i = 2; i < coordParasQ.Count(); i++)
                this.GridValueQ.Add(Convert.ToDouble(coordParasQ[i]));

            this.GridValueH = new List<double>();
            string sbH = coords[1];
            string[] coordParasH = sbH.Split(',');
            //this.UnitH = (UnitH)Convert.ToInt32(coordParasH[0]);
            this.IsLogH = Convert.ToBoolean(coordParasH[1]);
            for (int i = 2; i < coordParasH.Count(); i++)
                this.GridValueH.Add(Convert.ToDouble(coordParasH[i]));
        }

        private bool _isLogQ = false;//默认不是对数坐标
        public bool IsLogQ
        {
            get { return _isLogQ; }
            set
            {
                _isLogQ = value;
            }
        }

        public List<double> GridValueQ = null;
        private int? _unitQ = null;
        public int? UnitQ
        {
            get { return _unitQ; }
            set
            {
                _unitQ = value; 
            }
        }


        public int? UnitH
        {
            get { return _unitH; }
            set
            {
                _unitH = value; 
            }
        }
        private int? _unitH = null;
        public List<double> GridValueH = null;
        private bool _isLogH = false;//默认不是对数坐标
        public bool IsLogH
        {
            get { return _isLogH; }
            set
            {
                _isLogH = value;
            }
        }


        protected bool isNull = false;
        public bool IsNull
        {
            get { return isNull; }
        }

      
        public double MinH
        {
            get
            {
                if (GridValueH == null || GridValueH.Count == 0)
                    return 0;
                return GridValueH.First();
            }
        }
        public double MaxH
        {
            get
            {
                if (GridValueH == null || GridValueH.Count == 0)
                    return 0;
                return GridValueH.Last();
            }
        }

  
        public double MinQ
        {
            get
            {
                if (GridValueQ == null || GridValueQ.Count == 0)
                    return 0;
                return GridValueQ.First();
            }
        }
        public double MaxQ
        {
            get
            {
                if (GridValueQ == null || GridValueQ.Count == 0)
                    return 0;
                return GridValueQ.Last();
            }
        }


  

 







        #region Clone
        public QhCoordinateParas Clone()  //对外提供一个创建自身的浅表副本的能力
        {
            return new QhCoordinateParas(this);
        }
        object ICloneable.Clone()
        {
            return this.Clone();
        }

        #endregion

        public string ToDsString()
        {
            return ToDsString(this);
        }
        public static string ToDsString(QhCoordinateParas paras)
        {
            if (paras == null)
                return "";//为了ACCESS只能用""
            if (paras.GridValueQ == null || paras.GridValueQ.Count < 3)
                return "";
            if (paras.GridValueH == null || paras.GridValueH.Count < 3)
                return "";

            StringBuilder sbQ = new StringBuilder();
            sbQ.Append(paras.UnitQ == null ? "" : paras.UnitQ.ToString());sbQ.Append(",");
            sbQ.Append(paras.IsLogQ); sbQ.Append(",");
            sbQ.Append(string.Join(",", paras.GridValueQ));

            //
            StringBuilder sbH = new StringBuilder();
            sbH.Append(paras.UnitH == null ? "" : paras.UnitH.ToString()); sbH.Append(",");
            sbQ.Append(paras.IsLogH); sbQ.Append(",");
            sbH.Append(string.Join(",", paras.GridValueH));

            string strChartCoord = string.Format("{0}|{1}", sbQ.ToString(), sbH.ToString());

            return strChartCoord;
        }
        public static QhCoordinateParas ToParameter(string strChartCoord)
        {
            try
            {
                var paras = new QhCoordinateParas(strChartCoord);
                if (paras.isNull)
                    return null;
                else
                    return paras;
            }
            catch (Exception)
            {
                return null;
            }
        }

    }
}

 Yw.Coordinate/Yw.Coordinate.csproj

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,34 @@
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>disable</Nullable>
    <AssemblyName>$(MSBuildProjectName)</AssemblyName>
    <RootNamespace>$(MSBuildProjectName.Replace(" ", "_"))</RootNamespace>
    <GenerateDocumentationFile>True</GenerateDocumentationFile>
    <ProduceReferenceAssembly>True</ProduceReferenceAssembly>
    <Version>1.0.1</Version>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
    <NoWarn>1701;1702;1591;CS8632</NoWarn>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
    <NoWarn>1701;1702;1591;CS8632</NoWarn>
  </PropertyGroup>

  <ItemGroup>
    <Compile Remove="AxisXyCalcer.cs" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Yw.Calculation.Core" Version="1.0.3" />
    <PackageReference Include="Yw.MathNet.Core" Version="1.0.0" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\Yw.CurveBase.Core\Yw.CurveBase.Core.csproj" />
  </ItemGroup>
</Project>

 Yw.Coordinate/ZlpCoordinateParas.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,214 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Yw.Coordinate
{
    public class ZlpCoordinateParas : ICloneable
    {
        public ZlpCoordinateParas()
        {
        }
        public ZlpCoordinateParas(ZlpCoordinateParas rhs)
        {
            this.IsLogQ = rhs.IsLogQ;
            this.GridValueQ = rhs.GridValueQ;
            this.UnitQ = rhs.UnitQ;

            this.IsLogH = rhs.IsLogH;
            this.GridValueH = rhs.GridValueH;
            this.UnitH = rhs.UnitH;
        }
        public ZlpCoordinateParas(string strChartCoord)
        {
            if (string.IsNullOrEmpty(strChartCoord))
            {
                isNull = true;
                return;
            }

            string[] coords = strChartCoord.Split('|');
            if (coords.Count() != 2)
            {
                isNull = true;
                return;
            }


            this.GridValueQ = new List<double>();
            string sbQ = coords[0];
            string[] coordParasQ = sbQ.Split(',');
            //this.UnitQ = (UnitQ)Convert.ToInt32(coordParasQ[0]);
            this.IsLogQ = Convert.ToBoolean(coordParasQ[1]);

            for (int i = 2; i < coordParasQ.Count(); i++)
                this.GridValueQ.Add(Convert.ToDouble(coordParasQ[i]));

            this.GridValueH = new List<double>();
            string sbH = coords[1];
            string[] coordParasH = sbH.Split(',');
            //this.UnitH = (UnitH)Convert.ToInt32(coordParasH[0]);
            this.IsLogH = Convert.ToBoolean(coordParasH[1]);
            for (int i = 2; i < coordParasH.Count(); i++)
                this.GridValueH.Add(Convert.ToDouble(coordParasH[i]));
        }

        private bool _isLogQ = false;//默认不是对数坐标
        public bool IsLogQ
        {
            get { return _isLogQ; }
            set
            {
                _isLogQ = value;
            }
        }

        public List<double> GridValueQ = null;
        private int? _unitQ = null;
        public int? UnitQ
        {
            get { return _unitQ; }
            set
            {
                _unitQ = value;
            }
        }


        public int? UnitH
        {
            get { return _unitH; }
            set
            {
                _unitH = value;
            }
        }
        private int? _unitH = null;
        public List<double> GridValueH = null;
        private bool _isLogH = false;//默认不是对数坐标
        public bool IsLogH
        {
            get { return _isLogH; }
            set
            {
                _isLogH = value;
            }
        }


        protected bool isNull = false;
        public bool IsNull
        {
            get { return isNull; }
        }


        public double MinH
        {
            get
            {
                if (GridValueH == null || GridValueH.Count == 0)
                    return 0;
                return GridValueH.First();
            }
        }
        public double MaxH
        {
            get
            {
                if (GridValueH == null || GridValueH.Count == 0)
                    return 0;
                return GridValueH.Last();
            }
        }


        public double MinQ
        {
            get
            {
                if (GridValueQ == null || GridValueQ.Count == 0)
                    return 0;
                return GridValueQ.First();
            }
        }
        public double MaxQ
        {
            get
            {
                if (GridValueQ == null || GridValueQ.Count == 0)
                    return 0;
                return GridValueQ.Last();
            }
        }












        #region Clone
        public ZlpCoordinateParas Clone()  //对外提供一个创建自身的浅表副本的能力
        {
            return new ZlpCoordinateParas(this);
        }
        object ICloneable.Clone()
        {
            return this.Clone();
        }

        #endregion

        public string ToDsString()
        {
            return ToDsString(this);
        }
        public static string ToDsString(ZlpCoordinateParas paras)
        {
            if (paras == null)
                return "";//为了ACCESS只能用""
            if (paras.GridValueQ == null || paras.GridValueQ.Count < 3)
                return "";
            if (paras.GridValueH == null || paras.GridValueH.Count < 3)
                return "";

            StringBuilder sbQ = new StringBuilder();
            sbQ.Append(paras.UnitQ == null ? "" : paras.UnitQ.ToString()); sbQ.Append(",");
            sbQ.Append(paras.IsLogQ); sbQ.Append(",");
            sbQ.Append(string.Join(",", paras.GridValueQ));

            //
            StringBuilder sbH = new StringBuilder();
            sbH.Append(paras.UnitH == null ? "" : paras.UnitH.ToString()); sbH.Append(",");
            sbQ.Append(paras.IsLogH); sbQ.Append(",");
            sbH.Append(string.Join(",", paras.GridValueH));

            string strChartCoord = string.Format("{0}|{1}", sbQ.ToString(), sbH.ToString());

            return strChartCoord;
        }
        public static ZlpCoordinateParas ToParameter(string strChartCoord)
        {
            try
            {
                var paras = new ZlpCoordinateParas(strChartCoord);
                if (paras.isNull)
                    return null;
                else
                    return paras;
            }
            catch (Exception)
            {
                return null;
            }
        }

    }
}