namespace Yw.WinFrmUI.Phart
|
{
|
/// <summary>
|
///
|
/// </summary>
|
public partial class ValveCoordinate
|
{
|
#region 计算显示参数方法
|
|
#region 默认
|
/// <summary>
|
/// 最大流量(显示参数)
|
/// </summary>
|
public double DispMaxQ()
|
{
|
return this.CoordMinQ + (double)this.GridNumberX * this.CoordSpaceQ;
|
}
|
|
/// <summary>
|
/// 最小水损(显示参数)
|
/// </summary>
|
public double DispMinL()
|
{
|
return this.CoordMinL + (double)this.StartLineNoL * this.CoordSpaceL;
|
}
|
|
/// <summary>
|
/// 最大水损(显示参数)
|
/// </summary>
|
public double DispMaxL()
|
{
|
return CoordMinL + (double)this.EndLineNoL * this.CoordSpaceL;
|
}
|
|
|
#endregion
|
|
/// <summary>
|
/// 重置水损坐标
|
/// </summary>
|
public void ResetCoordL(double space, double disMinL, double disMaxL)
|
{
|
this.CoordSpaceL = space;
|
this.EndLineNoL = this.GridNumberY;
|
this.StartLineNoL = this.EndLineNoL - (int)((disMaxL - disMinL) / this.CoordSpaceL);
|
this.CoordMinL = disMaxL - (double)this.EndLineNoL * this.CoordSpaceL;
|
}
|
#endregion
|
|
#region 计算坐标
|
|
/// <summary>
|
/// 计算坐标
|
/// </summary>
|
/// <param name="QL">流量水损线</param>
|
/// <returns></returns>
|
public static ValveCoordinate CalcCoordinate(List<Yw.Geometry.Point2d> QL)
|
{
|
if (QL == null)
|
return null;
|
double max_flow = 0.0;
|
double min_flow = 1000.0;
|
double maxL = 0.0;
|
double minL = 1000.0;
|
|
|
min_flow = QL.Min(x => x.X);
|
max_flow = QL.Max(x => x.X);
|
if (min_flow > max_flow)
|
{
|
return null;
|
}
|
minL = QL.Min(x => x.Y);
|
maxL = QL.Max(x => x.Y);
|
if (minL > maxL)
|
{
|
return null;
|
}
|
|
|
return CalcCoordinate(min_flow, max_flow, minL, maxL);
|
}
|
|
/// <summary>
|
/// 计算最大最小值
|
/// </summary>
|
/// <param name="QL">流量水损线</param>
|
/// <param name="max_flow">最大流量</param>
|
/// <param name="min_flow">最小流量</param>
|
/// <param name="maxL">最大水损</param>
|
/// <param name="minL">最小水损</param>
|
/// <returns></returns>
|
public static bool CalcMinMaxValue(List<Yw.Geometry.Point2d> QL, ref double max_flow, ref double min_flow, ref double maxL, ref double minL)
|
{
|
max_flow = 0.0;
|
min_flow = 1000.0;
|
maxL = 0.0;
|
minL = 1000.0;
|
if (QL == null)
|
{
|
return false;
|
}
|
min_flow = QL.Min(x => x.X);
|
max_flow = QL.Max(x => x.X);
|
if (min_flow > max_flow)
|
{
|
return false;
|
}
|
minL = QL.Min(x => x.Y);
|
maxL = QL.Max(x => x.Y);
|
return true;
|
}
|
|
/// <summary>
|
/// 计算坐标
|
/// </summary>
|
/// <param name="min_flow">最小流量</param>
|
/// <param name="max_flow">最大流量</param>
|
/// <param name="minL">最小水损</param>
|
/// <param name="maxL">最大水损</param>
|
/// <returns></returns>
|
public static ValveCoordinate CalcCoordinate(double min_flow, double max_flow, double minL, double maxL)
|
{
|
if (min_flow > max_flow - 0.01)
|
return null;
|
|
if (minL > maxL - 0.01)
|
return null;
|
|
var validGridNumL = 6;
|
var coordinate_paras = new ValveCoordinate();
|
coordinate_paras.GridNumberX = 10;
|
coordinate_paras.GridNumberY = 10;
|
CalcCoordinateQ(min_flow, max_flow, ref coordinate_paras, coordinate_paras.GridNumberX);
|
CalcCoordinateL(minL, maxL, validGridNumL, ref coordinate_paras, out double disMinL, out double disMaxL);
|
|
return coordinate_paras;
|
}
|
|
#endregion
|
|
#region 计算对应线坐标
|
|
/// <summary>
|
/// 计算流量坐标
|
/// </summary>
|
/// <param name="min_flow">最小流量</param>
|
/// <param name="max_flow">最大流量</param>
|
/// <param name="coordinate_paras">坐标Model</param>
|
/// <param name="validGridNum">有效刻度点</param>
|
/// <param name="default_num">放大系数</param>
|
public static void CalcCoordinateQ(double min_flow, double max_flow, ref ValveCoordinate coordinate_paras, int validGridNum = 10, double default_num = 1.0)
|
{
|
var coordSpaceQ = GetOptimalSpaceMin(min_flow / default_num, max_flow / default_num, validGridNum, out double disMinQ, out double disMaxQ) * default_num;
|
coordSpaceQ = Math.Max(0.5, coordSpaceQ / default_num) * default_num;
|
if (coordSpaceQ == 8.0)
|
coordSpaceQ = 10.0;
|
|
disMinQ *= default_num;
|
//disMaxQ *= default_num;
|
var gridNumberX = 0;
|
|
double min_q = disMinQ;
|
while (min_q < max_flow)
|
{
|
gridNumberX++;
|
min_q = disMinQ + gridNumberX * coordSpaceQ;
|
}
|
|
if (gridNumberX <= 5)
|
{
|
coordSpaceQ *= 0.5;
|
gridNumberX *= 2;
|
}
|
|
coordinate_paras.CoordSpaceQ = coordSpaceQ;
|
coordinate_paras.CoordMinQ = disMinQ;
|
coordinate_paras.GridNumberX = gridNumberX;
|
}
|
|
/// <summary>
|
/// 计算水损坐标 含过滤 (Eventech: CalcCoordinateL2)
|
/// </summary>
|
/// <param name="minL">最小水损</param>
|
/// <param name="maxL">最大水损</param>
|
/// <param name="validGridNumL">有效水损刻度数</param>
|
/// <param name="coordinate_paras">坐标Model</param>
|
/// <param name="disMinL">最小显示水损</param>
|
/// <param name="disMaxL">最大显示水损</param>
|
public static void CalcCoordinateL_Filter(double minL, double maxL, int validGridNumL, ref ValveCoordinate coordinate_paras, out double disMinL, out double disMaxL)
|
{
|
if (maxL < 1.0)
|
{
|
disMinL = 0.0;
|
disMaxL = 1.0;
|
coordinate_paras.ResetCoordL(0.1, disMinL, disMaxL);
|
}
|
else if (maxL < 2.0)
|
{
|
disMinL = 0.0;
|
disMaxL = 2.0;
|
coordinate_paras.ResetCoordL(0.2, disMinL, disMaxL);
|
}
|
else if (maxL < 5.0)
|
{
|
disMinL = 0.0;
|
disMaxL = 5.0;
|
coordinate_paras.ResetCoordL(0.5, disMinL, disMaxL);
|
}
|
else if (maxL < 10.0)
|
{
|
disMinL = 0.0;
|
disMaxL = 10.0;
|
coordinate_paras.ResetCoordL(1.0, disMinL, disMaxL);
|
}
|
else if (maxL < 12.0)
|
{
|
coordinate_paras.CoordSpaceL = 1.0;
|
disMinL = 0.0;
|
disMaxL = 12.0;
|
coordinate_paras.ResetCoordL(1.0, disMinL, disMaxL);
|
}
|
else if (maxL < 15.0)
|
{
|
coordinate_paras.CoordSpaceL = 2.0;
|
disMinL = 0.0;
|
disMaxL = 16.0;
|
coordinate_paras.ResetCoordL(2.0, disMinL, disMaxL);
|
}
|
else if (maxL < 20.0)
|
{
|
coordinate_paras.CoordSpaceL = 2.0;
|
disMinL = 0.0;
|
disMaxL = 20.0;
|
coordinate_paras.ResetCoordL(2.0, disMinL, disMaxL);
|
}
|
else
|
{
|
CalcCoordinateL(minL, maxL, validGridNumL, ref coordinate_paras, out disMinL, out disMaxL);
|
}
|
}
|
|
/// <summary>
|
/// 计算水损坐标
|
/// </summary>
|
/// <param name="minL">最小水损</param>
|
/// <param name="maxL">最大水损</param>
|
/// <param name="validGridNumL">有效水损刻度数</param>
|
/// <param name="coordinate_paras">坐标Model</param>
|
/// <param name="disMinL">最小显示水损</param>
|
/// <param name="disMaxL">最大显示水损</param>
|
public static void CalcCoordinateL(double minL, double maxL, int validGridNumL, ref ValveCoordinate coordinate_paras, out double disMinL, out double disMaxL)
|
{
|
var coordSpaceL = GetOptimalSpaceMax(minL, maxL, validGridNumL, out disMinL, out disMaxL);
|
int endLineNoL = coordinate_paras.GridNumberY;
|
int stratLineNoL = endLineNoL;
|
|
double max_h = disMaxL;//判断条件
|
while (max_h > minL * 0.98)
|
{
|
max_h -= coordSpaceL;
|
if (max_h < 0.0)
|
break;
|
stratLineNoL--;
|
}
|
|
coordinate_paras.CoordSpaceL = coordSpaceL;
|
coordinate_paras.EndLineNoL = endLineNoL;
|
coordinate_paras.StartLineNoL = stratLineNoL;
|
coordinate_paras.CoordMinL = disMaxL - (double)endLineNoL * coordSpaceL;
|
}
|
|
#endregion
|
|
#region Space 间隔
|
/// <summary>
|
/// 获取最小的间隔
|
/// </summary>
|
/// <param name="minValue">最小值</param>
|
/// <param name="maxValue">最大值</param>
|
/// <param name="spaceNum">间隔数量</param>
|
/// <param name="minDisplay">最小显示参数</param>
|
/// <param name="maxDisplay">最大显示参数</param>
|
/// <returns></returns>
|
public static double GetOptimalSpaceMin(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
|
{
|
minDisplay = minValue;
|
maxDisplay = maxValue;
|
double num = maxValue - minValue;
|
if (num < 0.0 || spaceNum < 1)
|
{
|
return (maxValue - minValue) / 10.0;
|
}
|
|
double optimalSpace = GetOptimalSpace((maxValue - minValue) / (double)spaceNum);
|
if (optimalSpace < 2.0)
|
{
|
minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
|
maxDisplay = minDisplay + (double)spaceNum * optimalSpace;
|
}
|
else
|
{
|
minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
|
maxDisplay = minDisplay + (double)spaceNum * optimalSpace;
|
}
|
|
return optimalSpace;
|
}
|
|
/// <summary>
|
/// 获取最大的间隔
|
/// </summary>
|
/// <param name="minValue">最小值</param>
|
/// <param name="maxValue">最大值</param>
|
/// <param name="spaceNum">间隔数量</param>
|
/// <param name="minDisplay">最小显示参数</param>
|
/// <param name="maxDisplay">最大显示参数</param>
|
/// <returns></returns>
|
public static double GetOptimalSpaceMax(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
|
{
|
minDisplay = minValue;
|
maxDisplay = maxValue;
|
double num = maxValue - minValue;
|
|
if (maxValue > 20)
|
{
|
if (num < 0.0 || spaceNum < 1)
|
{
|
return (maxValue - minValue) / 5.0;
|
}
|
}
|
else
|
{
|
if (num < 0.0 || spaceNum < 1)
|
{
|
return (maxValue - minValue) / 10.0;
|
}
|
}
|
|
double optimalSpace = GetOptimalSpace((maxValue - minValue) / (double)spaceNum, true);
|
maxDisplay = Math.Ceiling(maxValue / optimalSpace) * optimalSpace;
|
minDisplay = maxDisplay - (double)spaceNum * optimalSpace;
|
|
if (minDisplay > minValue)
|
{
|
var diff = minDisplay - minValue;
|
if (diff < optimalSpace)
|
{
|
minDisplay -= optimalSpace;
|
}
|
|
}
|
|
return optimalSpace;
|
}
|
|
/// <summary>
|
/// 获取最佳间隔 (精细取整)
|
/// </summary>
|
/// <param name="refSpace"> 间隔</param>
|
/// <returns></returns>
|
public static double GetOptimalSpace(double refSpace, bool IsAccurate = false)
|
{
|
if (refSpace < 1E-06)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 0.01)
|
{
|
double refSpace2 = refSpace * 100.0;
|
return GetOptimalSpace(refSpace2) / 100.0;
|
}
|
|
if (refSpace < 0.1)
|
{
|
double refSpace3 = refSpace * 10.0;
|
return GetOptimalSpace(refSpace3) / 10.0;
|
}
|
|
if (IsAccurate)
|
{
|
if (refSpace < 11.0)
|
{
|
if (refSpace < 1.35)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 2.2)
|
{
|
return 2.0;
|
}
|
|
if (refSpace < 5.5)
|
{
|
return 5.0;
|
}
|
|
if (refSpace < 8.5)
|
{
|
return 8.0;
|
}
|
|
return 10.0;
|
}
|
}
|
|
if (refSpace < 1.0)
|
{
|
if (refSpace < 0.15)
|
{
|
return 0.1;
|
}
|
|
if (refSpace < 0.22)
|
{
|
return 0.2;
|
}
|
|
if (refSpace < 0.6)
|
{
|
return 0.5;
|
}
|
|
return 1.0;
|
}
|
|
if (refSpace < 1.2)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 3.0)
|
{
|
if (refSpace < 1.2)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 2.3)
|
{
|
return 2.0;
|
}
|
|
return 3.0;
|
}
|
|
if (refSpace < 11.0)
|
{
|
if (refSpace < 1.35)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 2.2)
|
{
|
return 2.0;
|
}
|
|
if (refSpace < 5.5)
|
{
|
return 5.0;
|
}
|
|
if (refSpace < 8.5)
|
{
|
return 8.0;
|
}
|
|
return 10.0;
|
}
|
|
if (refSpace < 16.0)
|
{
|
return 15.0;
|
}
|
|
if (refSpace < 22.0)
|
{
|
return 20.0;
|
}
|
|
if (refSpace < 35.0)
|
{
|
return 25.0;
|
}
|
|
if (refSpace < 41.0)
|
{
|
return 40.0;
|
}
|
|
if (refSpace < 51.0)
|
{
|
return 50.0;
|
}
|
|
if (refSpace < 61.0)
|
{
|
return 60.0;
|
}
|
|
if (refSpace < 71.0)
|
{
|
return 70.0;
|
}
|
|
if (refSpace < 78.0)
|
{
|
return 75.0;
|
}
|
|
if (refSpace < 150.0)
|
{
|
return 100.0;
|
}
|
|
if (refSpace < 230.0)
|
{
|
return 200.0;
|
}
|
|
if (refSpace < 270.0)
|
{
|
return 250.0;
|
}
|
|
if (refSpace < 1500.0)
|
{
|
int num = (int)(refSpace / 100.0);
|
return num * 100;
|
}
|
|
int num2 = (int)(refSpace / 1000.0);
|
return num2 * 1000;
|
}
|
|
#endregion
|
|
#region 数字辅助方法
|
/// <summary>
|
/// 按指定长度获取
|
/// </summary>
|
public static double GetByPlacesLength(double value, int length)
|
{
|
int decimalPlacesLength = GetDecimalPlacesLength(value);
|
if (decimalPlacesLength > length)
|
{
|
return Math.Round(value, length);
|
}
|
return value;
|
}
|
|
/// <summary>
|
/// 获取小数点长度
|
/// </summary>
|
private static int GetDecimalPlacesLength(double value)
|
{
|
string text = value.ToString();
|
int num = text.IndexOf('.');
|
if (num >= 0)
|
{
|
return text.Length - num - 1;
|
}
|
return 0;
|
}
|
#endregion
|
|
}
|
}
|
