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
|
}
|
}
|
