using MathNet.Numerics;
using MathNet.Numerics.LinearAlgebra.Double;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System.ComponentModel;
using System.Data;
using System.Drawing.Design;
using System.IO;
using System.Numerics;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Text.RegularExpressions;
using static Hydro.MapViewEnum;
using static Hydro.RepeaterViewModel;
using Cursor = System.Windows.Forms.Cursor;
namespace Hydro;

public class TemplateStoreViewModel
{
    public List<Template> templates { get; set; } = new List<Template>();
}
partial class DMap
{

    #region 核心属性
    public TContainer TC = new TContainer();


    /// 地图选项

    public MapDimensions mapOption
    {
        get { return TC.mapOption; }
        set { TC.mapOption = value; }
    }


    /// 临时管网层

    public Template _newTemplate
    {
        get { return TC.newTemplate; }
        set { TC.newTemplate = value; }
    }


    public Template _Template
    {
        get { return TC.template; }
    }

    #endregion

}
public enum DrawingMode
{
    All,
    Pic,
    Net,
    New,
    Auxiliary

}
public enum DrawingStatus
{
    drawingBase,
    drawingNet,
    drawingNetNew,
    drawingPic,
    drawingOthers,
    Ready,
}
public class MapOption
{
    public float Link_multiply { get; set; } = 0.6667f;
    public float junction_multiply { get; set; } = 1f;
    public bool _ShowValve { get; set; } = true;
    public bool _ShowJunction { get; set; } = true;
    public bool _ShowStatus { get; set; } = false;
    public bool _ShowFlowDirection { get; set; } = false;

}

partial class MapViewer
{
    void DrawBackGroud(Graphics bufferG, Template template)
    {
        if (template == null) return;
        var _Nodes = template.network.Nodes.ViewNodes;
        var _Links = template.network.Links.ViewLinks;

        var Cpoints = getCurclePoints(64).ToList();

        var r = 1.73f / zoom;
        var rt = r;


        r = r * Link_multiply;
        List<PointF> diametersZoom = new List<PointF>() { new PointF(0, 0.08f), new PointF(150, 0.03f), new PointF(300, 0.001f), new PointF(800, 0.0001f) };

        Pen penN = new Pen(Color.FromArgb(0, 0, 255), 1 * r);


        //背景图绘制
        if (this.mapOption.isShowPic && template != null && File.Exists(template.BackGroundImg_FullPath))


        {
            //var gs = bufferG.Save();
            // 应用矩阵变换以抵消之前的翻转效果
            //bufferG.ScaleTransform(1 / Zoom.X, 1 / Zoom.Y);
            List<PointF> p = new List<PointF>();

            if (!this.mapOption.isAutoBackgroundImage)
            {
                var Cps = new List<PointF>
{
template.BackGroundPoint1,
new PointF(template.BackGroundPoint2.X,template.BackGroundPoint1.Y),
new PointF(template.BackGroundPoint1.X,template.BackGroundPoint2.Y),
//template.BackGroundPoint2,


};
                Cps.ForEach(cp => p.Add(WorldPointToMapPoint(cp, template.BackGroundElev, template.OffSet)));
            }
            else
            {

                // 恢复之前保存的绘图状态

                //var Cps = new List<PointF>
                //{
                //template.BackGroundPoint1,
                //new PointF(template.BackGroundPoint2.X,template.BackGroundPoint1.Y),
                //new PointF(template.BackGroundPoint1.X,template.BackGroundPoint2.Y),
                ////template.BackGroundPoint2,


                //};
                var p1 = new PointF(template.BackGroundImgX, template.BackGroundImgY);
                var p2 = new PointF(template.BackGroundImgX + template.BackGroundImgWidth, template.BackGroundImgY + template.BackGroundImgHeight);

                var f = template.BackGroundImgRotaAngle / 180 * Math.PI;
                var djx = Math.Sqrt((Math.Pow(template.BackGroundImgWidth, 2) + Math.Pow(template.BackGroundImgHeight, 2)));
                var p3 = new PointF(p1.X + (float)(Math.Cos(f) * template.BackGroundImgWidth), p1.Y + (float)(Math.Sin(f) * template.BackGroundImgWidth));
                var p4 = new PointF(p1.X - (float)(Math.Sin(f) * template.BackGroundImgHeight), p1.Y + (float)(Math.Cos(f) * template.BackGroundImgHeight));
                p3.Y = p4.Y;
                //p4.Y = -p4.Y;
                var Cps = new List<PointF>
{
//template.BackGroundPoint1,
//new PointF(template.BackGroundImgX,template.BackGroundImgY),
p4,
p3,p1
//template.BackGroundPoint2,

 
};
                template.BackGroundPoint1 = p4;
                template.BackGroundPoint2 = new PointF(p3.X, p1.Y);



                //List<PointF> p = new List<PointF>();
                Cps.ForEach(cp => p.Add(WorldPointToMapPoint(cp, template.BackGroundElev, template.OffSet)));
            }

            //bufferG.DrawImage(System.Drawing.Image.FromFile(@"C:\Users\cloud\Pictures\GenshinImpactCloudGame\QQ截图20230919105637.png"), p[0]);
            try
            {
                var img = System.Drawing.Image.FromFile(template.BackGroundImg_FullPath);
                if (img != null)
                {
                    bufferG.FillPolygon(penN.Brush, p.ToArray());
                    bufferG.DrawImage(img, p.ToArray());
                }
            }
            catch
            {

            }

            //bufferG.Restore(gs);
        }
    }

    void Draw(Graphics bufferG, Template template)
    {
        if (template == null) return;
        var _Nodes = template.network.Nodes.ViewNodes;
        var _Links = template.network.Links.ViewLinks;
        var _Areas = template.network.Areas;
        var Cpoints = getCurclePoints(64).ToList();

        var r = 1.73f / zoom;
        var rt = r;

        float minElve = float.MinValue;
        float maxElve = float.MaxValue;
        //if (this.mapOption!=null && this.mapOption.ShowFloor!=int.MinValue )
        //{
        //var fl = template.Floors.Find(f => f.FloorIndex == this.mapOption.ShowFloor);
        //var fl_1 = template.Floors.Find(f => f.FloorIndex == this.mapOption.ShowFloor+1);
        //if (fl!=null)
        //{
        //minElve = fl.Elev;

        //maxElve = fl_1!=null ? fl_1.Elev : float.MaxValue;
        //}

        //}
        r = r * Link_multiply;
        List<PointF> diametersZoom = new List<PointF>() { new PointF(0, 0.08f), new PointF(150, 0.03f), new PointF(300, 0.001f), new PointF(800, 0.0001f) };

        Pen penN = new Pen(Color.FromArgb(0, 0, 255), 1 * r);

        Pen penChoosed = new Pen(Color.Purple, 5 * r);
        Pen pen_valveChoosed = new Pen(Color.Red, 5 * r);

        Pen penClosed = new Pen(Color.OrangeRed, 2 * r);
        Pen penHovered = new Pen(Color.DeepSkyBlue, 5 * r);


        //绘制面
        using (Pen pen0 = new Pen(Color.FromArgb(0, 0, 255), 2 * r))
        {
            foreach (var area in _Areas)
            {

                if (!area.Visible) continue;
                if (!IsFaceVisibleToCamera(area, GetCameraPosition())) continue;
                if (area.Elev < minElve || area.Elev >= maxElve) continue;

                var p = new List<PointF>();
                foreach (var node in area.InnerNodes)
                {
                    p.Add(CubeWorldPointToMapPoint(node, template.OffSet));
                }
                if (p.Count < 3) continue;
                pen0.Color = penClosed.Color = area.color;
                Pen pen = pen0;
                if (area.Hovered) pen = penHovered;
                bufferG.FillPolygon(pen.Brush, p.ToArray());
                bufferG.DrawPolygon(pen, p.ToArray());
                //显示area的名称
                var c = new PointF(p.Average(p0 => p0.X), p.Average(p0 => p0.Y));
                var brush = new SolidBrush(Color.White);




                var gs = bufferG.Save();
                // 应用矩阵变换以抵消之前的翻转效果
                bufferG.ScaleTransform(1 / Zoom.X, 1 / Zoom.Y);

                Font font = new Font(FontFamily.GenericSansSerif, 10 * 10 * zoom);

                SizeF textSize = bufferG.MeasureString(area.Name, font);
                var center = new PointF(c.X * Zoom.X, c.Y * Zoom.Y);
                float textLeft = center.X - textSize.Width / 2;
                float textTop = center.Y - textSize.Height / 2;
                PointF pd = new PointF(textLeft, textTop);

                bufferG.DrawString(area.Name, font, brush, pd);
                // 恢复之前保存的绘图状态
                bufferG.Restore(gs);
            }
        }


        // 绘制线

        HashSet<long> dict_flow_direction = new HashSet<long>();
        using (Pen pen0 = new Pen(Color.FromArgb(0, 0, 255), 2 * r))
        {

            foreach (var link in _Links)
            {
                if (!link.Visible) continue;
                if (link.Elev < minElve || link.Elev >= maxElve) continue;
                //if (_isMovingObject && (link.StartNode == _OperaNode || link.EndNode == _OperaNode)) continue;
                var p1 = WorldPointToMapPoint(link.StartNode, template.OffSet);
                var p2 = WorldPointToMapPoint(link.EndNode, template.OffSet);
                if (!isVisible(p1) && !isVisible(p2)) continue;
                if (LinkColour != null)
                {
                    pen0.Color = penClosed.Color = GraphHelper.getLinkColor(LinkColour, link);
                }

                Pen pen = pen0;
#if DEBUG
#else
if (_Template != null && _Template.mapOption._ShowStatus && link.Status == Hydro.Core.StatusType.CLOSED) pen = penClosed;
#endif

                if (link.Hovered) pen = penHovered;
                float zoomAtMin = 0;
                for (int i = 0; i < diametersZoom.Count; i++)
                {
                    PointF point = diametersZoom[i];
                    if (link.Diameter >= point.X) continue;
                    zoomAtMin = diametersZoom[i - 1].Y;
                    break;
                }
                if (zoomAtMin >= zoom) continue;
                if (link is ValveViewModel)
                {
                    if (link.Selected || _ShowValve)
                    {

                        var c = new PointF((p1.X + p2.X) / 2, (p1.Y + p2.Y) / 2);
                        bufferG.DrawLines(link.Selected ? penChoosed : pen, new PointF[] { p1, p2 });
                        var valveShapeHeight = link.Selected ? 10 : 5;
                        PointF[] points = new PointF[] {
GraphHelper.getRotatePoint(c.X - valveShapeHeight * r, c.Y + valveShapeHeight * r,c,p1,p2),
GraphHelper.getRotatePoint(c.X - valveShapeHeight * r, c.Y - valveShapeHeight * r,c,p1,p2),
GraphHelper.getRotatePoint(c.X + valveShapeHeight * r, c.Y + valveShapeHeight * r,c,p1,p2),
GraphHelper.getRotatePoint(c.X + valveShapeHeight * r, c.Y - valveShapeHeight * r,c,p1,p2),
GraphHelper.getRotatePoint(c.X - valveShapeHeight * r, c.Y + valveShapeHeight * r,c,p1,p2),

};

                        bufferG.FillPolygon(link.Selected ? pen_valveChoosed.Brush : pen.Brush, points);

                    }


                }
                else if (link is PumpViewModel)
                {
                    if (link.Selected || _ShowValve)
                    {

                        var c = new PointF((p1.X + p2.X) / 2, (p1.Y + p2.Y) / 2);
                        //bufferG.DrawLine(link.Selected ? pen_valveChoosed : pen, p1, p2);

                        bufferG.DrawLines(link.Selected ? penChoosed : pen, new PointF[] { p1, p2 });
                        // 绘制圆形部分（水泵的泵体）
                        float radius = 5 * r;
                        float diameter = radius * 2;
                        #region 圆形拆分
                        //var p = new PointF[] 
                        //{
                        //GraphHelper.getRotatePoint(c.X - radius - radius, c.Y - radius, c, p1, p2),
                        //GraphHelper.getRotatePoint(c.X + radius - radius, c.Y - radius, c, p1, p2),
                        //GraphHelper.getRotatePoint(c.X + radius - radius, c.Y + radius, c, p1, p2),
                        //GraphHelper.getRotatePoint(c.X - radius - radius, c.Y + radius, c, p1, p2),
                        //GraphHelper.getRotatePoint(c.X - radius - radius, c.Y - radius, c, p1, p2),
                        //};
                        List<PointF> p = new List<PointF>();
                        Cpoints.ForEach(cp => p.Add(GraphHelper.getRotatePoint(c.X + cp.X * radius - radius, c.Y + cp.Y * radius, c, p1, p2)));

                        #endregion

                        //RectangleF circleRect = new RectangleF(p[0].X, p[0].Y,p[1].X-p[0].X>0? diameter:-diameter,p[1].Y-p[0].Y>0? diameter:-diameter);
                        //bufferG.FillEllipse(link.Selected ? pen_valveChoosed.Brush : pen.Brush, circleRect);


                        bufferG.FillPolygon(link.Selected ? pen_valveChoosed.Brush : pen.Brush, p.ToArray());

                        //// 绘制矩形部分（水泵的出口）
                        //float rectangleWidth = 6*r;
                        //float rectangleHeight = 2*r;
                        //PointF rectTopLeft = new PointF(c.X - rectangleWidth / 2, c.Y + radius);
                        //SizeF rectSize = new SizeF(rectangleWidth, rectangleHeight);
                        //RectangleF rectangleRect = new RectangleF(rectTopLeft, rectSize);
                        //bufferG.DrawRectangles(link.Selected ? pen_valveChoosed : pen,new RectangleF[] { rectangleRect });

                        // 绘制连接线


                        var valveShapeHeight = link.Selected ? radius * 2 : radius;
                        PointF[] points = new PointF[] {
GraphHelper.getRotatePoint(c.X - valveShapeHeight , c.Y + valveShapeHeight ,c,p1,p2),
GraphHelper.getRotatePoint(c.X - valveShapeHeight , c.Y ,c,p1,p2),
GraphHelper.getRotatePoint(c.X + valveShapeHeight , c.Y ,c,p1,p2),
GraphHelper.getRotatePoint(c.X + valveShapeHeight , c.Y + valveShapeHeight ,c,p1,p2),
GraphHelper.getRotatePoint(c.X - valveShapeHeight , c.Y + valveShapeHeight ,c,p1,p2),

};

                        bufferG.FillPolygon(link.Selected ? pen_valveChoosed.Brush : pen.Brush, points);
                    }


                }
                else if (link is RepeaterViewModel re)
                {
                    if (re.Status == RepeaterViewModel.RepeatStatus.收起 || _IsEditMode)
                    {

                        bufferG.DrawLines(link.Selected ? penChoosed : pen, new PointF[] { p1, p2 });


                        var listNode = GraphHelper.Get等分Nodes(p1, p2, Math.Max(re.RepeatTimes, 1));

                        for (int i = 0; i < listNode.Count; i++)
                        {
                            //foreach (var c in listNode)
                            //{
                            var c = listNode[i];
                            RectangleF[] rects = new RectangleF[] {
new RectangleF(c.X-10*r,c.Y-8*r,20*r,16*r),
};
                            bufferG.FillRectangles(new SolidBrush(Color.White), rects);

                            //bufferG.FillRectangles(link.Selected ? penChoosed.Brush : pen.Brush, new RectangleF[]
                            //{
                            //new RectangleF(c.X-5*r,c.Y-5*r,3*r,3*r),
                            //new RectangleF(c.X-5*r,c.Y+2*r,3*r,3*r),
                            //new RectangleF(c.X+2*r,c.Y+2*r,3*r,3*r),
                            //new RectangleF(c.X+2*r,c.Y-5*r,3*r,3*r),
                            //});
                            // 保存当前绘图状态
                            var gs = bufferG.Save();
                            // 应用矩阵变换以抵消之前的翻转效果
                            bufferG.ScaleTransform(1 / Zoom.X, 1 / Zoom.Y);
                            int index = re.GetIndex(i);
                            string indexString = index == 0 ? "" : index.ToString();
                            Font font = new Font(FontFamily.GenericSansSerif, 10);
                            string text = $"{indexString}{re.NetworkShowName}";
                            SizeF textSize = bufferG.MeasureString(text, font);
                            var center = new PointF(c.X * Zoom.X, c.Y * Zoom.Y);
                            float textLeft = center.X - textSize.Width / 2;
                            float textTop = center.Y - textSize.Height / 2;
                            PointF p = new PointF(textLeft, textTop);

                            bufferG.DrawString(text, font, link.Selected ? penChoosed.Brush : pen.Brush, p);
                            // 恢复之前保存的绘图状态
                            bufferG.Restore(gs);

                            if (textSize.Width / Zoom.X > rects[0].Width)
                            {
                                rects[0] = new RectangleF(c.X - textSize.Width / 2 / Zoom.X - 1 * r, c.Y - 8 * r, textSize.Width / Zoom.X + 2 * r, 16 * r);
                            }
                            try
                            {
                                bufferG.DrawRectangles(penN, rects);

                            }
                            catch { }

                        }
                        //var c = new PointF((p1.X + p2.X) / 2, (p1.Y + p2.Y) / 2);
                    }
                    //else
                    //{
                    //DrawRepeater(bufferG,re);
                    //}
                }
                else
                {

                    if (link.StartNode == null || link.EndNode == null) continue;
                    try
                    {
                        bufferG.DrawLines(link.Selected ? penChoosed : pen, new PointF[] { p1, p2 });
                    }
                    catch (Exception)
                    {

                    }
                    if (_Template.mapOption._ShowFlowDirection)
                    {
                        var c = new PointF((p1.X + p2.X) / 2, (p1.Y + p2.Y) / 2);
                        var ps = MapToScreen(c);
                        //将ps转换为ulong，精度为20，并加入到dict_flow_direction中
                        var ps_20 = GraphHelper.GetUlongByPoint(ps, 5);
                        if (!dict_flow_direction.Contains(ps_20))
                        {
                            dict_flow_direction.Add(ps_20);
                            bufferG.DrawLines(link.Selected ? penChoosed : pen, new PointF[] { p1, p2 });
                            // 绘制圆形部分（水泵的泵体）
                            float radius = 5 * r;
                            float diameter = radius * 2;
                            #region 圆形拆分
                            float activeD = 1;
                            if (link.EN_FLOW < 0) activeD = -1;
                            List<PointF> p = new List<PointF>();
                            Cpoints.ForEach(cp => p.Add(GraphHelper.getRotatePoint(c.X - activeD * cp.X * radius + activeD * radius, c.Y + cp.Y * radius, c, p1, p2)));

                            #endregion


                            bufferG.FillPolygon(link.Selected ? pen_valveChoosed.Brush : pen.Brush, p.ToArray());

                            var valveShapeHeight = link.Selected ? radius * 2 : radius;
                            PointF[] points = new PointF[] {
GraphHelper.getRotatePoint(c.X -activeD* valveShapeHeight , c.Y + valveShapeHeight ,c,p1,p2),
GraphHelper.getRotatePoint(c.X, c.Y ,c,p1,p2),
GraphHelper.getRotatePoint(c.X - activeD*valveShapeHeight , c.Y - valveShapeHeight,c,p1,p2),
GraphHelper.getRotatePoint(c.X + activeD*valveShapeHeight , c.Y - valveShapeHeight,c,p1,p2),
GraphHelper.getRotatePoint(c.X + activeD*valveShapeHeight , c.Y + valveShapeHeight ,c,p1,p2),
GraphHelper.getRotatePoint(c.X - activeD*valveShapeHeight , c.Y + valveShapeHeight ,c,p1,p2),
};

                            bufferG.FillPolygon(link.Selected ? pen_valveChoosed.Brush : pen.Brush, points);
                        }



                    }
                }

            }
        }


        r = rt;


        HashSet<long> dict_point = new HashSet<long>();
        //绘制点
        penChoosed = new Pen(Color.Green, 1f * r);
        Brush brushChoosed = penChoosed.Brush;
        SolidBrush whiteBrush = new SolidBrush(Color.White);

        using (Pen pen0 = new Pen(Color.FromArgb(255, 0, 0), 1 * r))
        {

            foreach (NodeViewModel node in _Nodes)
            {
                if (!node.Visible) continue;
                if (node.Elev < minElve || node.Elev >= maxElve) continue;
                Pen pen = pen0;
                Brush brush = pen.Brush;
                float pr = (float)(r * 0.5);
                pr = pr * junction_multiply;
                PointF p = WorldPointToMapPoint(node, template.OffSet);
                if (!isVisible(p)) continue;
                var ps_20 = GraphHelper.GetUlongByPoint(p, 0.1f);
                if (dict_point.Contains(ps_20))
                    continue;
                dict_point.Add(ps_20);
                //var x = junction.Position.X * zoom + PanningOffset.X - radius / 2.0f;
                //var y = junction.Position.Y * zoom + PanningOffset.Y - radius / 2.0f;
                if (NodeColour != null)
                {
                    pen.Color = penChoosed.Color = GraphHelper.getNodeColor(NodeColour, node);
                    brush = pen.Brush;
                    brushChoosed = penChoosed.Brush;


                }
                if (node.Hovered)
                {
                    pen = penHovered;
                    brush = pen.Brush;
                    pr = pr * 2;
                }

                var rectangle = new RectangleF((float)p.X - 5 * pr, (float)p.Y - 5 * pr, 10 * pr, 10 * pr);
                float zoomAtMin = 0;
                for (int i = 0; i < diametersZoom.Count; i++)
                {
                    PointF point = diametersZoom[i];
                    if (node.MaxDiameter >= point.X) continue;
                    zoomAtMin = diametersZoom[i - 1].Y;
                    break;
                }
                if (zoomAtMin >= zoom) continue;
                //if(node.ID == _StartPoint)
                //{
                //var whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                //bufferG.FillEllipse(whiteBrush, whiteRect);

                //whiteRect = new RectangleF(rectangle.X + 2 * pr, rectangle.Y + 2 * pr, rectangle.Width - 4 * pr, rectangle.Height - 4 * pr);
                //bufferG.DrawEllipse(node.Selected ? penChoosed : pen, whiteRect);

                //whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                //bufferG.DrawEllipse(node.Selected ? penChoosed : pen, whiteRect);
                //}
                //else 
                if (node == _OperaNode)
                {
                    //bufferG.DrawEllipse(junction.Choosed ? penChoosed : pen, rectangle);
                    var whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                    bufferG.FillEllipse(whiteBrush, whiteRect);

                    whiteRect = new RectangleF(rectangle.X + 2 * pr, rectangle.Y + 2 * pr, rectangle.Width - 4 * pr, rectangle.Height - 4 * pr);
                    bufferG.DrawEllipse(node.Selected ? penChoosed : pen, whiteRect);


                    whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                    bufferG.DrawEllipse(node.Selected ? penChoosed : pen, whiteRect);

                    //bufferG.DrawEllipse(junction.Choosed ? penChoosed : pen, rectangle);

                }
                else if (node.ID == _EndPoint)
                {

                    var whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                    bufferG.FillEllipse(whiteBrush, whiteRect);

                    whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                    bufferG.DrawEllipse(node.Selected ? penChoosed : pen, whiteRect);

                    //whiteRect = new RectangleF(rectangle.X + 2 * pr, rectangle.Y + 2 * pr, rectangle.Width - 4 * pr, rectangle.Height - 4 * pr);
                    //bufferG.DrawEllipse(junction.Choosed ? penChoosed : pen, whiteRect);

                    var p1 = new PointF(rectangle.X + 2 * pr, rectangle.Y + 2 * pr);
                    var p2 = new PointF(p1.X + 6 * pr, p1.Y + 6 * pr);
                    bufferG.DrawLine(node.Selected ? penChoosed : pen, p1, p2);
                    p1 = new PointF(rectangle.X + 2 * pr, rectangle.Y + 8 * pr);
                    p2 = new PointF(p1.X + 6 * pr, p1.Y - 6 * pr);
                    bufferG.DrawLine(node.Selected ? penChoosed : pen, p1, p2);

                    //bufferG.FillEllipse(junction.Choosed ? brushChoosed : brush, rectangle);
                    //var whiteRect = new RectangleF(rectangle.X + 1 * pr, rectangle.Y + 1 * pr, rectangle.Width - 2 * pr, rectangle.Height - 2 * pr);
                    //bufferG.FillEllipse(whiteBrush, whiteRect);

                    //whiteRect = new RectangleF(rectangle.X - 2 * pr, rectangle.Y - 2 * pr, rectangle.Width + 4 * pr, rectangle.Height + 4 * pr);
                    //bufferG.DrawEllipse(junction.Choosed ? penChoosed : pen, whiteRect);
                }
                else if (node is TankViewModel)
                {
                    pr *= 2;
                    rectangle = new RectangleF((float)p.X - 5 * pr, (float)p.Y - 5 * pr, 10 * pr, 10 * pr);
                    RectangleF r0 = new RectangleF(rectangle.X, rectangle.Y + 5 * pr, 10 * pr, 5 * pr);
                    RectangleF r1 = new RectangleF(rectangle.X + 2 * pr, rectangle.Y, 6 * pr, 5 * pr);
                    bufferG.FillRectangle(node.Selected ? brushChoosed : brush, r0);
                    bufferG.FillRectangle(node.Selected ? brushChoosed : brush, r1);

                }
                else if (node is ReservoirViewModel)
                {
                    pr *= 2;
                    rectangle = new RectangleF((float)p.X - 5 * pr, (float)p.Y - 5 * pr, 10 * pr, 10 * pr);

                    RectangleF r0 = new RectangleF(rectangle.X, rectangle.Y + 2 * pr, rectangle.Width, 6 * pr);
                    RectangleF r1 = new RectangleF(rectangle.X, rectangle.Y + 8 * pr, 1 * pr, 2 * pr);
                    RectangleF r2 = new RectangleF(rectangle.X + 9 * pr, rectangle.Y + 8 * pr, 1 * pr, 2 * pr);
                    bufferG.FillRectangle(node.Selected ? brushChoosed : brush, r0);
                    bufferG.FillRectangle(node.Selected ? brushChoosed : brush, r1);
                    bufferG.FillRectangle(node.Selected ? brushChoosed : brush, r2);
                }
                else if (node is MeterViewModel)
                {


                    //bufferG.DrawEllipse(junction.Choosed ? penChoosed : pen, rectangle);
                    bufferG.FillEllipse(node.Selected ? brushChoosed : brush, rectangle);
                    var whiteRect = new RectangleF(rectangle.X + 1 * pr, rectangle.Y + 1 * pr, rectangle.Width - 2 * pr, rectangle.Height - 2 * pr);
                    bufferG.FillEllipse(whiteBrush, whiteRect);

                    var p1 = new PointF(rectangle.X + 5 * pr, rectangle.Y);
                    var p2 = new PointF(rectangle.X + 5 * pr, rectangle.Y + 10 * pr);
                    bufferG.DrawLine(node.Selected ? penChoosed : pen, p1, p2);
                }
                else
                {
                    rectangle = new RectangleF((float)p.X - 3 * pr, (float)p.Y - 3 * pr, 6 * pr, 6 * pr);
                    if (node.Selected || _ShowJunction)
                        bufferG.FillEllipse(node.Selected ? brushChoosed : brush, rectangle);
                }

            }
        }

        using (Pen pen = new Pen(Color.FromArgb(255, 0, 0), 1 * r))
        {
            Brush brush = pen.Brush;
            //获取_Nodes中自由水压最小的节点
            var node = _Nodes.Where(n => n is JunctionViewModel || n is MeterViewModel && n.EN_PRESSURE != float.NaN).OrderBy(n => n.EN_PRESSURE).FirstOrDefault();
            //判断node.EN_PRESSURE不是float.NaN



            if (node != null && !float.IsNaN(node.EN_PRESSURE))
            {

                //if (node.Elev < minElve || node.Elev >= maxElve) continue;
                float pr = (float)(r * 0.5);
                pr = pr * junction_multiply;
                PointF p = WorldPointToMapPoint(node, template.OffSet);

                var ps_20 = GraphHelper.GetUlongByPoint(p, 0.1f);

                dict_point.Add(ps_20);
                //var x = junction.Position.X * zoom + PanningOffset.X - radius / 2.0f;
                //var y = junction.Position.Y * zoom + PanningOffset.Y - radius / 2.0f;
                if (NodeColour != null)
                {
                    pen.Color = GraphHelper.getNodeColor(NodeColour, node);
                    brush = pen.Brush;
                    brushChoosed = penChoosed.Brush;


                }


                var rectangle = new RectangleF((float)p.X - 5 * pr, (float)p.Y - 5 * pr, 10 * pr, 10 * pr);
                float zoomAtMin = 0;
                for (int i = 0; i < diametersZoom.Count; i++)
                {
                    PointF point = diametersZoom[i];
                    if (node.MaxDiameter >= point.X) continue;
                    zoomAtMin = diametersZoom[i - 1].Y;
                    break;
                }


                //var whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                //bufferG.FillEllipse(whiteBrush, whiteRect);

                //whiteRect = new RectangleF(rectangle.X + 2 * pr, rectangle.Y + 2 * pr, rectangle.Width - 4 * pr, rectangle.Height - 4 * pr);
                //bufferG.DrawEllipse(node.Selected ? penChoosed : pen, whiteRect);


                //whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                //bufferG.DrawEllipse(node.Selected ? penChoosed : pen, whiteRect);

                var p1 = new PointF((float)p.X - 4 * pr, (float)p.Y - 2 * pr);
                var p2 = new PointF((float)p.X + 4 * pr, (float)p.Y - 2 * pr);
                var p3 = new PointF((float)p.X, (float)p.Y - 4 * pr);
                bufferG.DrawPolygon(node.Selected ? penChoosed : pen, new PointF[] { p1, p2, p3 });

                var whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                bufferG.FillEllipse(whiteBrush, whiteRect);

                whiteRect = new RectangleF(rectangle.X - 4 * pr, rectangle.Y - 4 * pr, rectangle.Width + 8 * pr, rectangle.Height + 8 * pr);
                bufferG.DrawEllipse(node.Selected ? penChoosed : pen, whiteRect);

            }
        }
    }
    //绘制辅助线
    void DrawH(Graphics bufferG, Template template)
    {
        var r = 2f / zoom;
        if (_isDragging && DragStartPos != new PointF(0, 0) && mousePosition != new PointF(0, 0))
        {
            label_center.Text = $"S:{DragStartPos.X}:{DragStartPos.Y} E:{mousePosition.X}:{mousePosition.Y}";
            var _lastMousePosition = DragStartPos;
            // 绘制矩形
            var start = new PointF((float)Math.Min(mousePosition.X, _lastMousePosition.X), (float)Math.Min(mousePosition.Y, _lastMousePosition.Y));
            var size = new SizeF((float)Math.Abs(_lastMousePosition.X - mousePosition.X), (float)Math.Abs(_lastMousePosition.Y - mousePosition.Y));
            if (size.Width == 0) size.Width = 0.01f;
            if (size.Height == 0) size.Height = 0.01f;
            var rectangle0 = new RectangleF(start, size);
            using (var pen = new Pen(Color.Black, 0.5f * r))
            {
                bufferG.DrawRectangles(pen, new RectangleF[] { rectangle0 });
            }
        }
        if (_isPainting)
        {
            if (_mouseState == MapViewEnum.MouseState.新增立管)
            {
                var wPos = GetZZWorldPoint(_select_junction1.Position3D, _MousePosition, new Vector3(0, 0, 1));
                using (var pen = new Pen(Color.Black, 1 * r))
                {
                    pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
                    bufferG.DrawLine(pen, WorldPointToMapPoint(_select_junction1), WorldPointToMapPoint(wPos));
                }
            }
            else
            {

                using (var pen = new Pen(Color.Black, 1 * r))
                {
                    pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
                    if (mapOption.IsOrtho)
                    {
                        var wPos = GetZZWorldPoint(_select_junction1.Position3D, _MousePosition, new Vector3(1, 1, 0));
                        //getPointAndHeight(e, _select_junction1, out p, out z);
                        var mapPos = WorldPointToMapPoint(wPos);
                        bufferG.DrawLine(pen, WorldPointToMapPoint(_select_junction1), mapPos);
                    }
                    else
                    {
                        bufferG.DrawLine(pen, WorldPointToMapPoint(_select_junction1), _MousePosition);
                    }

                }
            }
        }
        if (_isDrawingPolygon && polygonPoints.Count > 0)
        {
            List<PointF> pf = polygonPoints.ToList();
            pf.Add(new PointF(mousePosition.X, mousePosition.Y));
            using (var pen = new Pen(Color.Black, 1 * r))
            {
                // 绘制多边形虚线边框
                pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
                bufferG.DrawLines(pen, pf.ToArray());
            }
        }
        if (_isSettingBackGroundPictur)
        {

            var _lastMousePosition = DragStartPos;
            // 绘制矩形
            var start = new PointF((float)Math.Min(mousePosition.X, _lastMousePosition.X), (float)Math.Min(mousePosition.Y, _lastMousePosition.Y));
            var size = new SizeF((float)Math.Abs(_lastMousePosition.X - mousePosition.X), (float)Math.Abs(_lastMousePosition.Y - mousePosition.Y));
            var rectangle0 = new RectangleF(start, size);
            using (var pen = new Pen(Color.Black, 1 * r))
            {
                bufferG.DrawRectangles(pen, new RectangleF[] { rectangle0 });
            }
        }

        if (_isMovingObject)
        {
            var newP = _MousePosition;
            //var p = MapPointToWorldPoint(, _OperaNode.Elev);
            var oldP3D = (PointF3D)_undoOldValue;
            var oldP = WorldPointToMapPoint(new PointF(oldP3D.X, oldP3D.Y), oldP3D.Z);
            List<PointF> pf = new List<PointF> { oldP, newP };
            using (var pen = new Pen(Color.Black, 1 * r))
            {
                // 绘制多边形虚线边框
                pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
                bufferG.DrawLines(pen, pf.ToArray());
            }
        }
    }

    #region 基础坐标转换方法

    /// 将屏幕坐标转换为世界坐标。输入屏幕坐标 (x,y)，返回世界坐标 (wx, wy)。

    /// <param name="screenPos"></param>

    private PointF ScreenToVMap(PointF screenPos, float z = 0)
    {
        var centerX = this.map.Width / 2;
        var centerY = this.map.Height / 2;
        var worldX = (screenPos.X - centerX - Z(z).X) / Zoom.X + MapCenter.X;
        var worldY = (screenPos.Y - centerY) / Zoom.Y + 0;
        return new PointF(worldX, worldY);
    }



    /// 将屏幕坐标转换为世界坐标。输入屏幕坐标 (x,y)，返回世界坐标 (wx, wy)。

    /// <param name="screenPos"></param>

    private PointF ScreenToMap(PointF screenPos, float z = 0)
    {

        var centerX = this.map.Width / 2;
        var centerY = this.map.Height / 2;
        var worldX = (screenPos.X - centerX - Z(z).X) / Zoom.X + MapCenter.X;
        var worldY = (screenPos.Y - centerY - Z(z).Y) / Zoom.Y + MapCenter.Y;
        return new PointF(worldX, worldY);
    }


    /// 世界投影坐标转换为屏幕坐标

    private PointF MapToScreen(PointF mapPos, float z = 0)
    {

        var centerX = this.map.Width / 2;
        var centerY = this.map.Height / 2;
        var screenX = (mapPos.X - MapCenter.X) * Zoom.X + centerX + Z(z).X;
        var screenY = (mapPos.Y - MapCenter.Y) * Zoom.Y + centerY + Z(z).Y;
        //if (is3Dview) screenY = -(mapPos.Y - center.Y) * (0.5f * zoom) + centerY - 2 * z;
        return new PointF(screenX, screenY);
    }


    // 根据旋转角度计算旋转后的坐标
    private PointF Get平面旋转Point(PointF p, PointF MapC)
    {

        PointF center = MapC;
        double radian = Rotation * Math.PI / 180;// 角度转弧度
        float x = (float)(Math.Cos(radian) * (p.X - center.X) - Math.Sin(radian) * (p.Y - center.Y) + center.X);
        float y = (float)(Math.Sin(radian) * (p.X - center.X) + Math.Cos(radian) * (p.Y - center.Y) + center.Y);
        return new PointF(x, y);
    }
    private PointF Get平面还原Point(PointF p, PointF MapC)
    {
        PointF center = MapC;
        double radian = -Rotation * Math.PI / 180;// 角度转弧度
        float x = (float)(Math.Cos(radian) * (p.X - center.X) - Math.Sin(radian) * (p.Y - center.Y) + center.X);
        float y = (float)(Math.Sin(radian) * (p.X - center.X) + Math.Cos(radian) * (p.Y - center.Y) + center.Y);
        return new PointF(x, y);
    }

    private PointF Get俯视角旋转Point(PointF p, float z, PointF MapC)
    {
        PointF center = MapC;
        double radian_fushi = 俯视弧度;
        float sin = (float)Math.Sin(radian_fushi);
        float cos = (float)Math.Cos(radian_fushi);
        float x = (float)p.X;
        float y = (float)(sin * (p.Y - center.Y) + center.Y) + cos * z;
        return new PointF(x, y);
    }
    private PointF Get俯视角还原Point(PointF p, float z, PointF MapC)
    {
        PointF center = MapC;
        double radian_fushi = 俯视弧度;
        float sin = (float)Math.Sin(radian_fushi);
        float cos = (float)Math.Cos(radian_fushi);
        float x = (float)p.X;
        float y = (p.Y - center.Y - cos * z) / sin + center.Y;
        return new PointF(x, y);
    }
    private PointF GetRotateVector(PointF p, PointF p0)
    {

        double radian = Rotation * Math.PI / 180;// 角度转弧度
        float x = (float)(Math.Cos(radian) * (p.X - p0.X) - Math.Sin(radian) * (p.Y - p0.Y));
        float y = (float)(Math.Sin(radian) * (p.X - p0.X) + Math.Cos(radian) * (p.Y - p0.Y));
        return new PointF(x, y);
    }


    /// 获取世界投影坐标

    private PointF WorldPointToMapPoint(PointF point, float z, PointF3D offset = null)
    {
        if (offset == null) offset = new PointF3D(0, 0, 0);
        point = new PointF(point.X + offset.X, point.Y + offset.Y);

        var pointR = Get平面旋转Point(point, MapCenter);

        var pointT = Get俯视角旋转Point(pointR, z + offset.Z, MapCenter);

        //var n=new PointF((float)pointR.X - Z(z).X, (float)(pointR.Y - Z(z).Y));
        return pointT;
    }
    private PointF WorldPointToMapPoint(PointF3D point, PointF3D offset = null)
    {
        return WorldPointToMapPoint(new PointF(point.X, point.Y), point.Z, offset);

    }
    private PointF WorldPointToMapPoint(NodeViewModel junction, PointF3D offset = null)
    {
        PointF p;
        if (junction == null) return new PointF(0, 0);
        p = WorldPointToMapPoint(junction.Position, junction.Elev, offset);
        return p;
    }
    private PointF CubeWorldPointToMapPoint(NodeViewModel junction, PointF3D offset = null)
    {
        if (junction == null) return new PointF(0, 0);
        var point = junction.Position;
        var z = junction.Elev;
        if (offset == null) offset = new PointF3D(0, 0, 0);
        point = new PointF(point.X + offset.X, point.Y + offset.Y);
        var pointR = Get平面旋转Point(point, new PointF(0, 0));
        var pointT = Get俯视角旋转Point(pointR, z + offset.Z, new PointF(0, 0));
        return pointT;
    }
    private List<PointF> WorldPointToMapPoint(LinkViewModel pipe, PointF3D offset = null)
    {
        List<PointF> list = new List<PointF>();

        PointF p;
        p = WorldPointToMapPoint(pipe.StartNode, offset);
        list.Add(p);
        p = WorldPointToMapPoint(pipe.EndNode, offset);
        list.Add(p);
        return list;

    }

    /// 获取正交投影坐标,返回的是世界坐标

    /// <param name="position3D">世界坐标</param>
    /// <param name="mousePosition">地图坐标</param>
    /// <param name="vector3">投影向量</param>

    /// <exception cref="NotImplementedException"></exception>
    private PointF3D GetZZWorldPoint(PointF3D position3D, PointF mousePosition, Vector3 vector3)
    {
        //做一条通过position3D的平行于vector3的直线，
        if (vector3 == new Vector3(0, 0, 1))
        {
            return GetLGWorldPoint(position3D, mousePosition);
        }
        else
        {
            var p2 = MapPointToWorldPoint(mousePosition, position3D.Z);
            var vector = new Vector2(p2.X - position3D.X, p2.Y - position3D.Y);
            //判断二维向量vector在第几象限，距离哪个轴最近
            var x = vector.X;
            var y = vector.Y;
            var x1 = Math.Abs(x);
            var y1 = Math.Abs(y);
            if (x1 > y1)
            {
                if (x > 0)
                {
                    //第一象限
                    return new PointF3D(position3D.X + Math.Abs(x), position3D.Y, position3D.Z);
                }
                else
                {
                    //第三象限
                    return new PointF3D(position3D.X - Math.Abs(x), position3D.Y, position3D.Z);
                }
            }
            else
            {
                if (y > 0)
                {
                    //第二象限
                    return new PointF3D(position3D.X, position3D.Y + Math.Abs(y), position3D.Z);
                }
                else
                {
                    //第四象限
                    return new PointF3D(position3D.X, position3D.Y - Math.Abs(y), position3D.Z);
                }
            }
        }
    }


    /// 获取正交投影坐标,返回的是世界坐标

    /// <param name="position3D">世界坐标</param>
    /// <param name="mousePosition">地图坐标</param>
    /// <param name="vector3">投影向量</param>

    /// <exception cref="NotImplementedException"></exception>
    private PointF3D GetLGWorldPoint(PointF3D position3D, PointF p2)
    {
        double radian_fushi = 俯视弧度;
        float sin = (float)Math.Sin(radian_fushi);
        float cos = (float)Math.Cos(radian_fushi);
        var p1 = WorldPointToMapPoint(position3D);
        var dy = p2.Y - p1.Y;
        float dz = dy / cos;
        return new PointF3D(position3D.X, position3D.Y, position3D.Z + dz);

    }

    private PointF MapPointToWorldPoint(PointF3D point)
    {
        return MapPointToWorldPoint(new PointF(point.X, point.Y), point.Z);
    }

    /// 获取地图投影坐标

    /// <param name="point"></param>
    /// <param name="z"></param>

    public PointF MapPointToWorldPoint(PointF point, float z = 0)
    {
        var pointT = Get俯视角还原Point(point, z, MapCenter);
        pointT = Get平面还原Point(pointT, MapCenter);

        //var n=new PointF((float)pointR.X - Z(z).X, (float)(pointR.Y - Z(z).Y));
        return pointT;
    }
    private PointF GetMapPoint_还原(NodeViewModel junction)
    {
        PointF p;

        p = MapPointToWorldPoint(junction.Position, junction.Elev);
        return p;

    }



    #endregion
    #region 计算三维相机
    public PointF3D GetCameraPosition(float distance = 1)
    {
        // 将角度转换为弧度
        float rotationRadians = (float)Rotation * (float)Math.PI / 180;
        float rotationFRadians = (float)RotationF * (float)Math.PI / 180;

        // 计算相机的球坐标系位置
        float x = distance * (float)Math.Sin(rotationFRadians) * (float)Math.Cos(rotationRadians);
        float y = distance * (float)Math.Sin(rotationFRadians) * (float)Math.Sin(rotationRadians);
        float z = distance * (float)Math.Cos(rotationFRadians);

        return new PointF3D(x, y, z);
    }
    public bool IsFaceVisibleToCamera(AreaViewModel area, PointF3D cameraPosition)
    {

        //正面是2，右面是1，左面是3，背面是4
        //Rotation为0时，只显示正面，Rotation为90时，只显示右面，Rotation为180时，只显示背面，Rotation为270时，只显示左面
        int delta = 5;
        bool flag = false;
        switch (area.Name)
        {
            case "左":
                //Rotation为0~180时显示
                if (RotationF <= 90 - delta && Rotation >= 0 + delta && Rotation <= 180 - delta)
                    flag = true;
                break;
            case "前":
                //Rotation为0~180时显示
                if (RotationF <= 90 - delta && Rotation >= -90 + delta && Rotation <= 90 - delta)
                    flag = true;
                break;
            case "右":
                //Rotation为0~180时显示
                if (RotationF <= 90 - delta && Rotation >= -180 + delta && Rotation <= 0 - delta)
                    flag = true;
                break;
            case "后":
                //Rotation为0~180时显示
                if (RotationF <= 90 - delta && ((Rotation >= 90 + delta && Rotation <= 180) || (Rotation >= -180 && Rotation <= -90 - delta)))
                    flag = true;
                break;
            case "上":
                if (RotationF >= 0 + delta)
                    flag = true;
                break;
            case "下":
                if (RotationF <= 0 - delta)
                    flag = true;
                break;
        }
        return flag;


    }


    #endregion

    #region 判断可见性
    private float Get_dist(PointF A, PointF B)
    {
        float dx = A.X - B.X;
        float dy = A.Y - B.Y;
        float dist = (float)Math.Sqrt(dx * dx + dy * dy);
        return dist;
    }
    //判断A距离线段B和C的距离，如果超出了线段的范围，则返回到最近的端点的距离；距离线段中心点越远，返回的距离越大；
    private float Get_dist(PointF A, PointF B, PointF C, float MaxOff)
    {
        //PointF A, PointF B,PointF C，求点A到B、C构成线段的中心点的距离

        float dist_off = GetDistanceFromPointAToMidpointOfLineSegmentBC(A, B, C);
        //使用dist_off 跟 线段A、B的长度比较，如果大于1/2，则返回MaxOff，否则按照比例返回
        float dist_len = Get_dist(B, C);
        if (dist_len < 5) dist_len = 5;
        float dist_add = (dist_off / dist_len > 0.5 ? MaxOff : dist_off / dist_len * 2 * MaxOff);

        float dx = C.X - B.X;
        float dy = C.Y - B.Y;
        float dist = (float)Math.Sqrt(dx * dx + dy * dy);
        if (dist == 0) return Get_dist(A, B) + dist_add;
        float t = ((A.X - B.X) * dx + (A.Y - B.Y) * dy) / (dist * dist);
        if (t < 0) return Get_dist(A, B) + dist_add;
        if (t > 1) return Get_dist(A, C) + dist_add;
        float x = B.X + t * dx;
        float y = B.Y + t * dy;
        return Get_dist(A, new PointF(x, y)) + dist_add;

    }
    private float GetDistanceFromPointAToMidpointOfLineSegmentBC(PointF A, PointF B, PointF C)
    {
        // Calculate the midpoint of the line segment BC
        PointF midpoint = new PointF((B.X + C.X) / 2, (B.Y + C.Y) / 2);

        // Calculate the distance from point A to the midpoint
        float dx = midpoint.X - A.X;
        float dy = midpoint.Y - A.Y;
        float distance = (float)Math.Sqrt(dx * dx + dy * dy);

        return distance;
    }

    PointF PMin_Show, PMax_Show;


    /// 判断是否在屏幕坐标内

    /// <param name="screenPos"></param>

    public bool isVisible(PointF MapPos)
    {
        if (MapPos.X < PMin_Show.X || MapPos.X > PMax_Show.X || MapPos.Y < PMin_Show.Y || MapPos.Y > PMax_Show.Y)
            return false;
        else
            return true;
    }


    /// 判断是否在屏幕坐标内

    /// <param name="screenPos"></param>

    public bool isVisible(List<PointF> list_MapPos)
    {
        bool visible = false;
        foreach (var MapPos in list_MapPos)
        {
            if (MapPos.X < PMin_Show.X || MapPos.X > PMax_Show.X || MapPos.Y < PMin_Show.Y || MapPos.Y > PMax_Show.Y)
            {

            }
            else
            {
                visible = true;
                return true;
            }

        }

        return visible;
    }
    #endregion

}
public partial class MapViewer
{

    #region 核心属性
    TContainer TC = new TContainer();


    /// 地图选项

    public MapDimensions mapOption
    {
        get { return TC.mapOption; }
        set { TC.mapOption = value; }
    }

    /// 地图选项_起始操作时

    private MapDimensions mapOption0 = new MapDimensions();

    /// 临时管网层


    public Template _newTemplate
    {
        get { return TC.newTemplate; }
        set { TC.newTemplate = value; }
    }



    public Template _Template
    {
        get { return TC.template; }
        set
        {
            TC.template = value;

            label_file.Text = TC.template?.filePath;
        }
    }

    #endregion
    #region 交互属性

    /// 悬停对象

    private List<IBaseViewModel> hoveredObjs = new List<IBaseViewModel>();

    /// 选中对象

    public List<IBaseViewModel> selectedObjs = new List<IBaseViewModel>();


    private List<NodeViewModel> selectedNodes => selectedObjs.FindAll(o => o is NodeViewModel).Select(o => (NodeViewModel)o).ToList();
    private List<LinkViewModel> selectedLinks => selectedObjs.FindAll(o => o is LinkViewModel).Select(o => (LinkViewModel)o).ToList();

    MouseState _mouseState = MouseState.无;
    private NodeViewModel _OperaNode = null;
    public PointF mouseXY = new PointF(0, 0);

    PointF DragStartPos;
    PointF _ClickStartPos;
    PointF RotaStartPos;
    PointF BackGroudPicLeftPos;
    bool _isPanning;

    /// 拖拽选择

    bool _isDragging;
    bool _isRotating;
    bool _isPainting;


    PointF mousePosition;
    // control+鼠标中间按下缩放
    bool _isInsertingObject = false;
    bool _isMovingObject = false;
    bool _isPastingObject = false;
    Cursor _lastCursor;
    object _undoOldValue = null;
    private List<PointF> polygonPoints = new List<PointF>();

    private bool _isDrawingPolygon;

    #endregion
    #region 新增管网（辅助）

    MapViewNetWork _NewNet
    {
        get
        {
            if (_newTemplate == null) _newTemplate = new Template();
            if (_newTemplate.network == null) _newTemplate.network = new MapViewNetWork();
            return _newTemplate.network;
        }
    }
    #endregion
    #region 显示选项（辅助）


    private string _StartPoint = null;
    private string _EndPoint = null;
    //private bool __isEditMode = true;

    public bool _IsEditMode
    {
        get { return this.mapOption?.isEditMode ?? true; }
        set
        {
            toolStripComboBox_浏览模式.Text = value ? "编辑模式" : "浏览模式";

            if (this.mapOption != null) this.mapOption.isEditMode = value;
            转换为ToolStripMenuItem.Visible = _IsEditMode;
            toolStripSeparator9.Visible = _IsEditMode;
            删除ToolStripMenuItem.Visible = _IsEditMode;
            删除ToolStripMenuItem1.Visible = _IsEditMode;

            复制ToolStripMenuItem.Visible = _IsEditMode;
            复制ToolStripMenuItem1.Visible = _IsEditMode;
            粘贴ToolStripMenuItem.Visible = _IsEditMode;
            粘贴ToolStripMenuItem1.Visible = _IsEditMode;
            设置长度ToolStripMenuItem.Visible = _IsEditMode;
            设为关闭ToolStripMenuItem.Visible = _IsEditMode;
            设为立管点ToolStripMenuItem.Visible = _IsEditMode;
            对齐ToolStripMenuItem.Visible = _IsEditMode;
            对齐ToolStripMenuItem1.Visible = _IsEditMode;

            toolStripButton_新建节点.Enabled = _IsEditMode;
            toolStripButton_新建管线.Enabled = _IsEditMode;
            toolStripButton_新建立管.Enabled = _IsEditMode;
            toolStripButton_添加水库.Enabled = _IsEditMode;
            toolStripButton_添加水池.Enabled = _IsEditMode;
            toolStripButton_添加水表.Enabled = _IsEditMode;
            toolStripButton_添加阀门.Enabled = _IsEditMode;
            toolStripButton_重复器.Enabled = _IsEditMode;



        }
    }



    public float Link_multiply
    {
        get
        {
            if (_Template == null || _Template.mapOption == null) return 1.0f;
            return _Template.mapOption.Link_multiply;
        }
        set
        {
            if (_Template == null || _Template.mapOption == null) return; _Template.mapOption.Link_multiply = value;
        }
    }

    public float junction_multiply
    {
        get
        {
            if (_Template == null || _Template.mapOption == null) return 1.0f;
            return _Template.mapOption.junction_multiply;
        }
        set
        {
            if (_Template == null || _Template.mapOption == null) return; _Template.mapOption.junction_multiply = value;
        }
    }
    [DisplayName("显示阀门")]

    public bool _ShowValve
    {
        get
        {
            if (_Template == null || _Template.mapOption == null) return true;
            return _Template.mapOption._ShowValve;
        }
        set
        {
            if (_Template == null || _Template.mapOption == null) return; _Template.mapOption._ShowValve = value;
        }
    }
    [DisplayName("显示节点")]
    public bool _ShowJunction
    {
        get
        {
            if (_Template == null || _Template.mapOption == null) return true;
            return _Template.mapOption._ShowJunction;
        }
        set
        {

            if (_Template == null || _Template.mapOption == null) return; _Template.mapOption._ShowJunction = value;
        }
    }
    string _filePath
    {
        get
        {
            if (string.IsNullOrEmpty(_Template?.filePath))
                return null;
            string path = _Template.filePath.TrimStart('\\');
            return
            Path.Combine(Directory.GetCurrentDirectory(), path);
        }
        //set 
        //{

        //_Template.路径 = value; 
        //} 
    }
    private MapViewNetWork _Network
    {
        get
        {
            return _Template?.network;
        }
    }
    #endregion
    #region 管网属性（辅助）

    public List<NodeCalcModel> _Nodes
    {
        get { return _Network?.Nodes ?? new List<NodeCalcModel>(); }

    }

    public List<LinkCalcModel> _Links
    {
        get { return _Network?.Links ?? new List<LinkCalcModel>(); }

    }

    private List<Area> _areas = new List<Area>();

    public List<Area> _Areas
    {
        get { return _areas; }

    }
    #endregion
    #region 视角设置（辅助）



    private const float MinZoom = 0.1f;
    private const float MaxZoom = 1000.0f;

    [DisplayName("缩放系数")]
    public float zoom
    {
        get
        {
            return mapOption.zoom;
        }
        set
        {
            label_zoom.Text = $"Zoom：{zoom.ToString("0.000")}";
            mapOption.zoom = value;
        }
    }
    [DisplayName("旋转角度")]
    public double Rotation
    {
        get
        {
            return mapOption.rotation;
        }
        set
        {
            toolStripStatusLabel_rotation.Text = $"Rotation：({Rotation.ToString("0")}，{RotationF.ToString("0")})";
            //将旋转角度转换为-180~180
            value = value % 360;
            if (value > 180)
                value -= 360;
            else if (value < -180)
                value += 360;
            mapOption.rotation = value;
        }
    }

    private double Rotation0 = 0;

    public PointF MapCenter
    {
        get
        {
            return mapOption.Center;
        }
        set
        {
            label_center.Text = $"center：({MapCenter.X.ToString("0.00")} ，{MapCenter.Y.ToString("0.00")}）";
            mapOption.Center = value;
        }
    }
    private PointF MapCenter0;
    private bool is3Dview = false;
    double 俯视角度_start = 90;



    public bool Lock2DView
    {
        get
        {
            return mapOption.Lock2DView;
        }
        set
        {
            mapOption.Lock2DView = value;
        }
    }



    /// 俯视线与底面的夹角，投影用sin

    [DisplayName("俯视角度")]
    public double RotationF
    {
        get
        {
            return mapOption.rotationF;
        }
        set
        {
            mapOption.rotationF = value;
        }
    }

    public double 俯视弧度
    {
        get
        {
            return RotationF / 180 * Math.PI;
        }
    }


    public PointF Zoom
    {
        get
        {
            return new PointF(zoom, -zoom);
        }
    }


    private PointF Z(float z)
    {
        return new PointF(0, 0);
    }
    #endregion
    #region 颜色分级（辅助）
    public Colour NodeColour
    {
        set
        {
            var type = value.Type;
            value.isChoosed = true;
            _Template?.Colours?.RemoveAll(cl => cl.Type == type);
            _Template.Colours.Add(value);
            mapOption.ColourNode = type;
        }
        private get
        {
            return _Template?.Colours?.FirstOrDefault(cl => cl.isChoosed && cl.Type == mapOption.ColourNode);
        }
    }
    public Colour LinkColour
    {
        set
        {
            var type = value.Type;
            value.isChoosed = true;
            _Template?.Colours?.RemoveAll(cl => cl.Type == type);
            _Template.Colours.Add(value);
            mapOption.ColourLink = type;
        }
        private get
        {
            return _Template?.Colours?.FirstOrDefault(cl => cl.isChoosed && cl.Type == mapOption.ColourLink);
        }
    }

    //private bool __isOrtho = true;

    #endregion
    #region 正交模式
    private bool _isOrtho
    {
        get
        {
            return mapOption.IsOrtho;
        }
        set
        {
            mapOption.IsOrtho = value;
            if (mapOption.IsOrtho)
            {
                label_ZZ.Text = "正交模式:开";
            }
            else
            {
                label_ZZ.Text = "正交模式:关";
            }
        }
    }
    #endregion
    #region 事件
    //按帧数判断是否重绘，减少计算量（每帧最多重绘一次）
    bool _timerDraw = false;
    //按帧数判断鼠标悬停对象，减少计算量（每帧最多判断一次）
    bool _mouseHoverCheckFlag = false;
    #endregion
}


/// <summary>
/// 几何计算辅助类
class GraphHelper
{
    public static Color getNodeColor(Colour colour, NodeViewModel node)
    {
        double value = 0;
        Color color = Color.Gray;

        switch (colour.Type)
        {
            case ColourType.节点自由压力:
                value = node.EN_PRESSURE;
                break;
            case ColourType.节点绝对压力:
                value = node.EN_HEAD;
                break;
            case ColourType.节点需水量:
                value = node.EN_DEMAND;
                break;
        }

        for (int i = 0; i < colour.Items.Count; i++)
        {
            if (colour.Items[i].DRange.IsInside(value))
            {
                color = colour.Items[i].value;
                break;
            }
        }
        return color;
    }
    public static Color getLinkColor(Colour colour, LinkViewModel link)
    {
        double value = 0;
        Color color = Color.Gray;
        switch (colour.Type)
        {
            case ColourType.管线流量:
                value = link.EN_FLOW;
                break;
            case ColourType.管线流速:
                value = link.EN_VELOCITY;
                break;
        }

        for (int i = 0; i < colour.Items.Count; i++)
        {
            if (colour.Items[i].DRange.IsInside(value))
            {
                color = colour.Items[i].value;
                break;
            }
        }
        return color;
    }
    public static long GetUlongByPoint(PointF ps, float delta = 20, int MaxY = 2000)
    {
        return (long)((int)(ps.X / delta) + ((int)Math.Round(ps.Y / delta)) * MaxY / delta);
    }

    public static List<PointF> Get等分Nodes(PointF p1, PointF p2, int n)
    {
        // 计算线段长度
        float len = (float)Math.Sqrt(Math.Pow(p2.X - p1.X, 2) + Math.Pow(p2.Y - p1.Y, 2));
        if (len == 0) len = 0.00001f;
        // 计算单位向量
        PointF u = new PointF((p2.X - p1.X) / len, (p2.Y - p1.Y) / len);

        // 计算间距
        float d = len / (n + 1);


        // 计算n等分点
        List<PointF> nodes = new List<PointF>();
        for (int i = 1; i < n + 1; i++)
        {
            PointF node = new PointF(p1.X + i * d * u.X, p1.Y + i * d * u.Y);
            if (node.X == float.NaN || node.Y == float.NaN) node = p1;
            nodes.Add(node);
        }

        return nodes;
    }

    public static PointF getRotatePoint(float px, float py, PointF center, PointF x, PointF y)
    {
        PointF p = new PointF(px, py);

        return getRotatePoint(p, center, x, y);
    }

    private static PointF getRotatePoint(PointF p, PointF center, PointF x, PointF y)
    {
        float angle = (float)Math.Atan2(y.Y - x.Y, y.X - x.X);
        float distance = (float)Math.Sqrt(Math.Pow(p.X - center.X, 2) + Math.Pow(p.Y - center.Y, 2));
        float rotationAngle = (float)(Math.Atan2(p.Y - center.Y, p.X - center.X) + angle);
        float rotatedX = center.X + distance * (float)Math.Cos(rotationAngle);
        float rotatedY = center.Y + distance * (float)Math.Sin(rotationAngle);
        return new PointF(rotatedX, rotatedY);
    }

}

public class Prompt : Form
{
    private static TextBox textBox;
    private static Button okButton;

    public static string ShowDialog(string text, string caption, string defaultTxt = "")
    {
        Form prompt = new Form()
        {
            Width = 200,
            Height = 150,
            FormBorderStyle = FormBorderStyle.FixedDialog,
            Text = caption,
            StartPosition = FormStartPosition.CenterScreen
        };

        Label textLabel = new Label() { Left = 20, Top = 20, Text = text };
        textBox = new TextBox() { Left = 20, Top = 50, Width = 150 };
        textBox.Text = defaultTxt;
        okButton = new Button() { Text = "确定", Left = 75, Width = 75, Top = 80 };
        okButton.Click += (sender, e) => { prompt.Close(); };

        prompt.Controls.Add(textBox);
        prompt.Controls.Add(textLabel);
        prompt.Controls.Add(okButton);
        prompt.ShowDialog();

        return textBox.Text;
    }
}

public class GlobalObject
{
    public static PropertyForm PropertyForm;
    public static MapViewer map;
    public static bool LockSelect = false;
    public static bool ApplyFilter = false;
}


partial class empty { }

//定义一个委托，用来存储void Draw(Graphics bufferG, Template template)
public delegate void DrawDelegate(Graphics bufferG, Template template);

public delegate void MouseDelegate(MouseEventArgs e);


public class TContainer
{

    public MapDimensions mapOption = new MapDimensions();

    public Template newTemplate = null;

    public Template template = null;

}

public class Area : BaseModel, IBaseViewModel
{
    public List<PointF> Points { get; set; }


    public bool Selected { get; set; }


    [Description("鼠标悬于上方")]
    [DisplayName("鼠标悬于上方")]

    public bool Hovered { get; set; }





    [DisplayName("位置信息")]




    public PointF Position { get; set; } = new PointF(0, 0);



    public String regionName { get; set; } = null;


    [Description("X坐标")]
    [DisplayName("X坐标")]
    [Browsable(true)]
    public float X
    {
        get
        {
            return Position.X;
        }
        set
        {
            Position = new PointF(value, Position.Y);
        }
    }

    [Description("Y坐标")]
    [DisplayName("Y坐标")]
    [Browsable(true)]
    public float Y
    {
        get
        {
            return Position.Y;
        }
        set
        {
            Position = new PointF(Position.X, value);
        }
    }


    [Description("标高")]
    [DisplayName("标高")]
    [Browsable(true)]
    public float Elev { get; set; }


    [Description("对象的等级")]
    [DisplayName("级别")]


    public int Level { get; set; } = 0;

    [Description("对象的等级")]
    [DisplayName("是否显示")]
    public bool Visible { get; set; } = true;





    public MapObjectType Type { get { return this.GetTypeString(); } }



    [Description("ID类型")]
    [DisplayName("ID类型")]

    public string IDType => Type.ToString() + "\t" + ID;



    [Description("标签")]
    [DisplayName("标签")]
    [Editor(typeof(MyEditor), typeof(UITypeEditor))]
    public TagList Tags { get; set; } = null;



    public MapObjectType GetTypeString()
    {
        if (this is JunctionViewModel) return MapObjectType.节点;
        if (this is ReservoirViewModel) return MapObjectType.水库;
        if (this is TankViewModel) return MapObjectType.水池;
        if (this is MeterViewModel) return MapObjectType.水表;
        if (this is NozzleViewModel) return MapObjectType.喷头;
        if (this is ValveNodeViewModel) return MapObjectType.阀门点;


        if (this is PipeViewModel) return MapObjectType.管线;
        if (this is ValveViewModel) return MapObjectType.阀门;
        if (this is RepeaterViewModel) return MapObjectType.重复器;
        if (this is PumpViewModel) return MapObjectType.水泵;
        if (this is PumpNodeViewModel) return MapObjectType.水泵点;

        return MapObjectType.节点;
    }

    public bool isNode()
    {
        if (this is JunctionViewModel) return true;
        if (this is ReservoirViewModel) return true;
        if (this is TankViewModel) return true;
        if (this is MeterViewModel) return true;
        if (this is NozzleViewModel) return true;
        return false;
    }
}

public interface IBaseViewModel
{

    [Description("对象的ID唯一标识")]
    [DisplayName(" 编号 ")]
    string ID { get; set; }






    bool Selected { get; set; }

    bool Hovered { get; set; }




    [DisplayName("位置信息")]

    PointF Position { get; set; }//= new PointF(0, 0);



    String regionName { get; set; }//= null; 


    [Description("X坐标")]
    [DisplayName("X坐标")]
    [Browsable(true)]
    float X { get; set; }
    //{
    //get
    //{
    //return Position.X;
    //}
    //set
    //{
    //Position = new PointF(value, Position.Y);
    //}
    //}

    [Description("Y坐标")]
    [DisplayName("Y坐标")]
    [Browsable(true)]
    float Y { get; set; }
    //{
    //get
    //{
    //return Position.Y;
    //}
    //set
    //{
    //Position = new PointF(Position.X, value);
    //}
    //}


    [Description("标高")]
    [DisplayName("标高")]
    [Browsable(true)]
    float Elev { get; set; }


    [Description("对象的等级")]
    [DisplayName("级别")]
    //[Editor(typeof(MyPropertyEditor), typeof(UITypeEditor))]

    int Level { get; set; } //= 0;

    [Description("对象的等级")]
    [DisplayName("是否显示")]
    bool Visible { get; set; } //= true;

    //
    //[Description("标签集合")]
    //[DisplayName("标签")]
    //public string Tags { get; set; } = null;




    MapObjectType Type { get; }// { get { return this.GetTypeString(); } }

    //

    [Description("ID类型")]
    [DisplayName("ID类型")]

    string IDType { get; }// => Type.ToString()+"\t"+ ID;
    MapObjectType GetTypeString();

    TagList Tags { get; set; }

    //string TagsString { get; set; }

    bool isNode();


}

public class TagList : List<string>
{


    public override string ToString()
    {
        if (Count == 0)
            return "null";
        else
            return string.Join(",", this);
    }

    //public TagList(string value):base(value.Split(','))
    //{
    //if (string.IsNullOrEmpty(value) || value == "null")
    //{
    //base.Clear();
    //return;
    //}

    //}
    public TagList()
    {
    }
    public TagList(string value)
    {
        if (string.IsNullOrEmpty(value) || value == "null")
        {
            base.Clear();
            return;
        }
        string[] tags = value.Split(',');
        base.AddRange(tags);
    }
}

public class MyEditor : UITypeEditor
{
    public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
    {
        return UITypeEditorEditStyle.Modal;
    }

    public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
    {
        List<string> tags = value as List<string>;

        // Create and show dialog
        TagEditorForm form = new TagEditorForm(tags);
        //form弹出时，位置在鼠标位置
        form.StartPosition = FormStartPosition.Manual;
        form.Location = new Point(Cursor.Position.X - form.Width + 10, Cursor.Position.Y - 10);

        //if (form.ShowDialog() == DialogResult.OK)
        //{

        //}
        form.ShowDialog();
        return form.Tags;
        //return base.EditValue(context, provider, value);
    }
}

public class TagEditorForm : Form
{
    public List<string> Tags { get; set; }

    private ListBox listBox;
    private TextBox tb_text;

    public TagEditorForm(List<string> tags)
    {
        Tags = tags;


        // Initialize ListBox
        listBox = new ListBox();
        listBox.DataSource = Tags;
        listBox.Dock = DockStyle.Fill;
        this.Controls.Add(listBox);

        // Add buttons for add, remove, update operations
        tb_text = new TextBox();
        tb_text.Dock = DockStyle.Top;

        this.Controls.Add(tb_text);
        Button addButton = new Button();
        addButton.Dock = DockStyle.Bottom;
        addButton.Text = "添加";
        addButton.Click += AddButton_Click;
        this.Controls.Add(addButton);

        Button removeButton = new Button();
        removeButton.Dock = DockStyle.Bottom;
        removeButton.Text = "删除";
        removeButton.Click += RemoveButton_Click;
        this.Controls.Add(removeButton);

        Button updateButton = new Button();
        updateButton.Dock = DockStyle.Bottom;
        updateButton.Text = "更新";
        updateButton.Click += UpdateButton_Click;
        this.Controls.Add(updateButton);

        Panel panel = new Panel();
        updateButton.Dock = DockStyle.Bottom;
        this.Controls.Add(panel);

        Button btn_ok = new Button();
        btn_ok.Dock = DockStyle.Left;
        btn_ok.Click += (o, e) => { this.DialogResult = DialogResult.OK; };
        btn_ok.Text = "确定";
        panel.Controls.Add(btn_ok);

        Button btn_cancel = new Button();
        btn_cancel.Dock = DockStyle.Right;
        btn_ok.Click += (o, e) => { this.DialogResult = DialogResult.Cancel; };
        btn_cancel.Text = "取消";
        panel.Controls.Add(btn_cancel);

        listBox.SelectedIndexChanged += (o, e) =>
        {
            if (listBox.SelectedItem != null)
                tb_text.Text = listBox.SelectedItem.ToString();
        };
        this.Icon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
    }

    private void AddButton_Click(object sender, EventArgs e)
    {

        // 在listBox中按tb_text的内容，添加新的tag
        if (tb_text.Text != null && tb_text.Text != "")
        {
            if (Tags == null)
                Tags = new List<string>();
            Tags.Add(tb_text.Text);
            listBox.DataSource = null;
            listBox.DataSource = Tags;
        }

    }

    private void RemoveButton_Click(object sender, EventArgs e)
    {
        //删除listBox中选中的tag
        if (listBox.SelectedItem != null)
        {

            Tags.Remove(listBox.SelectedItem.ToString());
            listBox.DataSource = null;
            listBox.DataSource = Tags;
        }
        // Remove tag
    }

    private void UpdateButton_Click(object sender, EventArgs e)
    {
        // 在listBox中按tb_text的内容，更新tag，但是不改变顺序
        if (listBox.SelectedItem != null)
        {

            Tags[listBox.SelectedIndex] = tb_text.Text;
            listBox.DataSource = null;
            listBox.DataSource = Tags;
        }
    }
}


public class LinkViewModel : LinkCalcModel, IBaseViewModel
{
    #region 构造函数


    public LinkViewModel()
    {

    }
    public LinkViewModel(PointF startPoint, PointF endPoint)
    {
        StartNode = new NodeViewModel(startPoint);
        EndNode = new NodeViewModel(endPoint);
    }
    public LinkViewModel(PointF startPoint, PointF endPoint, List<PointF> points)
    {
        StartNode = new NodeViewModel(startPoint);
        EndNode = new NodeViewModel(endPoint);

    }
    #endregion
    #region 属性



    [DisplayName("编号")]
    [Browsable(true)]
    public new string ID { get { return base.ID; } set { base.ID = value; } }


    [DisplayName("名称")]
    [Browsable(true)]
    public new string Name { get { return base.Name; } set { base.Name = value; } }


    [DisplayName("起始节点")]
    [Browsable(true)]
    public string Node1
    {
        get
        {
            return base.Node1;
        }
        set
        {

            base.Node1 = value;
        }
    }



    [DisplayName("终止节点")]
    [Browsable(true)]
    public string Node2
    {
        get
        {
            return base.Node2;
        }
        set
        {
            base.Node2 = value;
        }
    }



    public NodeViewModel StartNode { get { return (NodeViewModel)base.StartNode; } set { base.StartNode = value; } }


    public NodeViewModel EndNode { get { return (NodeViewModel)base.EndNode; } set { base.EndNode = value; } }

    private PointF _position { get; set; } = new PointF(0, 0);
    public PointF Position
    {
        get
        {
            {
                if (StartNode == null || EndNode == null) return _position;
                var x = (StartNode.Position.X + EndNode.Position.X) / 2;
                var y = (StartNode.Position.Y + EndNode.Position.Y) / 2;
                _position = new PointF(x, y);


            }
            return _position;
        }
        set
        {
        }

    }




    public List<PointF> Points { get { return new List<PointF>() { StartNode.Position, EndNode.Position }; } }
    public PointF[] ToArray(bool is3Dview = false)
    {
        if (!is3Dview)
            return new PointF[] { new PointF((float)(StartNode.X), (float)(StartNode.Y)), new PointF((float)(EndNode.X), (float)(EndNode.Y)) };
        else
            return new PointF[] { new PointF((float)(StartNode.X), (float)(StartNode.Y - 2 * StartNode.Elev)), new PointF((float)(EndNode.X), (float)(EndNode.Y - 2 * EndNode.Elev)) };
    }



    [DisplayName("标高(m)")]

    public float Elev
    {
        get
        {
            if (StartNode == null || EndNode == null) return 0;
            return (StartNode.Elev + EndNode.Elev) / 2;
        }
        set
        {

        }
    }

    [Category("计算参数")]
    [DisplayName("初始状态")]
    [Browsable(true)]
    public StatusType Status
    {
        get { return base.Status; }
        set { base.Status = value; }
    }



    [DisplayName("口径(mm)")]
    [Browsable(true)]
    public new float Diameter { get { return base.Diameter; } set { base.Diameter = value; } }


    [DisplayName("长度(m)")]
    [Browsable(true)]

    /// 长度

    public float Length
    {
        get
        {
            return base.Length;

        }
        set
        {
            base.Length = value;
        }
    }



    public String regionName { get; set; } = null;


    [Description("X坐标")]
    [DisplayName("X坐标")]
    [Browsable(true)]
    public float X
    {
        get
        {
            return Position.X;
        }
        set
        {

        }
    }

    [Description("Y坐标")]
    [DisplayName("Y坐标")]
    [Browsable(true)]
    public float Y
    {
        get
        {
            return Position.Y;
        }
        set
        {

        }
    }



    [Description("对象的等级")]
    [DisplayName("级别")]


    public int Level { get; set; } = 0;

    [Description("对象的等级")]
    [DisplayName("是否显示")]
    public bool Visible { get; set; } = true;


    [Description("标签")]
    [DisplayName("标签")]
    [Editor(typeof(MyEditor), typeof(UITypeEditor))]
    public TagList Tags { get; set; } = null;







    public MapObjectType Type { get { return this.GetTypeString(); } }



    [Description("ID类型")]
    [DisplayName("ID类型")]

    #endregion
    #region 方法


    public string IDType => Type.ToString() + "\t" + ID;

    public MapObjectType GetTypeString()
    {
        if (this is JunctionViewModel) return MapObjectType.节点;
        if (this is ReservoirViewModel) return MapObjectType.水库;
        if (this is TankViewModel) return MapObjectType.水池;
        if (this is MeterViewModel) return MapObjectType.水表;
        if (this is NozzleViewModel) return MapObjectType.喷头;
        if (this is ValveNodeViewModel) return MapObjectType.阀门点;


        if (this is PipeViewModel) return MapObjectType.管线;
        if (this is ValveViewModel) return MapObjectType.阀门;
        if (this is RepeaterViewModel) return MapObjectType.重复器;
        if (this is PumpViewModel) return MapObjectType.水泵;
        if (this is PumpNodeViewModel) return MapObjectType.水泵点;

        return MapObjectType.节点;
    }

    public bool isNode()
    {
        if (this is JunctionViewModel) return true;
        if (this is ReservoirViewModel) return true;
        if (this is TankViewModel) return true;
        if (this is MeterViewModel) return true;
        if (this is NozzleViewModel) return true;
        return false;
    }
    #endregion
}


public class NodeViewModel : NodeCalcModel, IBaseViewModel
{
    #region 构造函数
    public NodeViewModel()
    {
    }
    public NodeViewModel(PointF position)
    {
        Position = position;
    }
    public NodeViewModel(int X, int Y)
    {
        Position = new PointF(X, Y);
    }
    #endregion

    #region 属性



    [DisplayName("编号")]
    [Browsable(true)]
    public new string ID { get { return base.ID; } set { base.ID = value; } }


    [DisplayName("名称")]
    [Browsable(true)]
    public new string Name { get { return base.Name; } set { base.Name = value; } }


    public PointF3D Position3D
    {
        get
        {
            return new PointF3D(X, Y, Elev);
        }
        set
        {
            Position = new PointF(value.X, value.Y);
            Elev = value.Z;
        }

    }


    [Description("X坐标")]
    [DisplayName("X坐标")]
    [Browsable(true)]
    public new float X
    {
        get
        {
            return base.X;
        }
        set
        {
            base.X = value;
        }
    }

    [Description("Y坐标")]
    [DisplayName("Y坐标")]
    [Browsable(true)]
    public new float Y
    {
        get
        {
            return base.Y;
        }
        set
        {
            base.Y = value;
        }
    }


    [Description("标高(m)")]
    [DisplayName("标高(m)")]
    [Browsable(true)]
    public new float Elev { get { return base.Elev; } set { base.Elev = value; } }



    public MapObjectType Type { get { return this.GetTypeString(); } }

    [Category("计算参数")]
    [Description("最大口径(mm)")]
    [DisplayName("最大口径(mm)")]

    public virtual float MaxDiameter { get; set; } = 0;



    [Category("计算参数")]
    [Description("需水量(m³/h)")]
    [DisplayName("需水量(m³/h)")]
    [Browsable(true)]
    public virtual float Demand { get; set; }


    /// 模式的编号

    [Category("计算参数")]
    [Description("用水量模式的编号")]
    [DisplayName("模式编号")]
    [Browsable(true)]
    public virtual string PatternID { get; set; }




    [DisplayName("链表清单")]
    [Browsable(true)]

    public List<LinkCalcModel> Links
    {
        get
        {
            return base.Links;
        }
        set
        {
            base.Links = value;
        }

    }

    public List<LinkViewModel> ViewLinks
    {
        get
        {
            return base.Links.Select(oo => oo as LinkViewModel).ToList();
        }

    }




    [DisplayName("位置信息")]

    public PointF Position
    {
        get { return new PointF(X, Y); }
        set { if (value != null) X = value.X; Y = value.Y; }
    }


    [Description("标签")]
    [DisplayName("标签")]
    [Editor(typeof(MyEditor), typeof(UITypeEditor))]
    public TagList Tags { get; set; } = null;





    public String regionName { get; set; } = null;




    [Description("对象的等级")]
    [DisplayName("级别")]


    public int Level { get; set; } = 0;

    [Description("对象的等级")]
    [DisplayName("是否显示")]
    public bool Visible { get; set; } = true;






    [Description("ID类型")]
    [DisplayName("ID类型")]

    public string IDType => Type.ToString() + "\t" + ID;

    #endregion

    #region 方法
    public void Move(Vector3 vector)
    {
        X += vector.X;
        Y += vector.Y;
        Elev += vector.Z;
    }


    public MapObjectType GetTypeString()
    {
        if (this is JunctionViewModel) return MapObjectType.节点;
        if (this is ReservoirViewModel) return MapObjectType.水库;
        if (this is TankViewModel) return MapObjectType.水池;
        if (this is MeterViewModel) return MapObjectType.水表;
        if (this is NozzleViewModel) return MapObjectType.喷头;
        if (this is ValveNodeViewModel) return MapObjectType.阀门点;


        if (this is PipeViewModel) return MapObjectType.管线;
        if (this is ValveViewModel) return MapObjectType.阀门;
        if (this is RepeaterViewModel) return MapObjectType.重复器;
        if (this is PumpViewModel) return MapObjectType.水泵;
        if (this is PumpNodeViewModel) return MapObjectType.水泵点;

        return MapObjectType.节点;
    }

    public bool isNode()
    {
        if (this is JunctionViewModel) return true;
        if (this is ReservoirViewModel) return true;
        if (this is TankViewModel) return true;
        if (this is MeterViewModel) return true;
        if (this is NozzleViewModel) return true;
        return false;
    }
    public string ToEmitterString()
    {
        if (this is NozzleViewModel n)
        {
            if (n.FlowCoefficient > 0)
                return $"{ID}\t{n.FlowCoefficient * Math.Pow(10 / 101.972, 0.5) / 1000 * 60}\r\n";
        }
        return null;
    }

    #endregion


}

public static class Copy
{

    public static T DeepCopy<T>(this T obj)
    {
        dynamic retval;
        using (MemoryStream ms = new MemoryStream())
        {
            BinaryFormatter bf = new BinaryFormatter();
            //序列化成流
            bf.Serialize(ms, obj);
            ms.Seek(0, SeekOrigin.Begin);
            //反序列化成对象
            retval = bf.Deserialize(ms);
            ms.Close();
        }
        return (T)retval;
    }
}


public class Dataset
{
    //设置Dataset的default值



    public static List<string> listString = new List<string>() { "流量扬程曲线", "流量功率曲线", "流量效率曲线" };
    public Dataset(string name, PumpViewModel pump, int Degree = 2)
    {
        Name = name;
        this.pump = pump;
        this.degree = Degree;
    }

    public override string ToString()
    {
        StringBuilder txt = new StringBuilder();
        foreach (PointF point in _data)
        {
            txt.AppendLine($"{Name}\t{point.X}\t{point.Y}");
        }
        return txt.ToString();
    }
    //public Dataset()
    //{

    //}
    public Color Color
    {
        get
        {
            switch (Name)
            {
                case "流量扬程曲线":
                    return Color.Blue;
                //break;
                case "流量功率曲线":
                    return Color.Orange;
                //break;
                case "流量效率曲线":
                    return Color.Red;
                //break;
                default:
                    return Color.Blue;
            }

        }

    }
    public string Name { get; set; }


    public List<PointF> _data = new List<PointF>();

    int FitTimes = 2;

    public List<PointF> Data
    {
        get
        {

            if (pump == null || pump.额定转速 == 0) return _data;
            float eg = (float)pump.当前转速 / (float)pump.额定转速;
            if (eg >= 1) return _data;
            else
            {
                switch (Name)
                {
                    case "流量扬程曲线":
                        return _data.Select(p => { p.X *= eg; p.Y *= eg * eg; return p; }).ToList();
                    case "流量功率曲线":
                        return _data.Select(p => { p.X *= eg; p.Y *= eg * eg * eg; return p; }).ToList();
                    case "流量效率曲线":
                        var c1 = pump.Datasets["流量扬程曲线"];
                        var c2 = pump.Datasets["流量功率曲线"];
                        if (c1.IsFitted && c2.IsFitted && c1.Data.Count == c2.Data.Count)
                        {
                            List<PointF> points = new List<PointF>();
                            for (int i = 0; i < c1.Data.Count; i++)
                            {
                                float x = c1.Data[i].X;
                                float y = x * c1.Data[i].Y / c2.Data[i].Y / 3.6f;
                                points.Add(new PointF(x, y));

                                //功率=流量* 扬程 / 效率 / 3.6f
                                //效率=流量* 扬程 / 功率 / 3.6f
                            }
                            return points;
                        }
                        else
                        {
                            return _data;
                        }

                    default:
                        return _data;
                }



            }
        }
        set
        {
            IsFitted = false;
            _data = value;
        }
    }

    public int degree { get { return FitTimes; } set { if (FitTimes != value) this.IsFitted = false; FitTimes = value; } }

    public List<double> ForumParams = null;


    public DenseVector coefficients = null; // 存储多项式系数

    public static double ErrNum { get { return -1; } }

    public static double stepNum { get { return 800; } }

    private double step { get { return (range_X.Max - range_X.Min) / stepNum; } }


    [NonSerialized]

    public PumpViewModel pump = null;




    /// 不需要读取

    public string Legend
    {
        get
        {
            switch (Name)
            {
                case "流量扬程曲线":
                    return "Legend1";
                case "流量功率曲线":
                    return "Legend1";
                case "流量效率曲线":
                    return "Legend1";

            }
            return "Legend1";
        }
    }

    public void CurveFit()
    {

        if (!HasData)
        {
            IsFitted = false;
            return;
        }

        coefficients = Fit.Polynomial(Data.Select(p => (double)p.X).ToArray(), Data.Select(p => (double)p.Y).ToArray(), degree);

        if (range_X == null)
        {
            range_X = new DRange(double.MaxValue, double.MinValue);
            Data.ForEach(p =>
            {
                if (range_X.Min > p.X) range_X.Min = p.X;
                if (range_X.Max < p.X) range_X.Max = p.X;
            });
        }
        IsFitted = true;
    }
    public double Evaluate(double x)
    {
        if (!IsFitted) return ErrNum;
        // 计算多项式在点 x 处的取值
        double y = 0;
        for (int i = 0; i < coefficients.Count; i++)
        {
            y += coefficients[i] * Math.Pow(x, i);
        }
        return y;
    }


    double Solve(double y)
    {
        List<PointF> points = FittedCurve.ToList();
        PointF prevPoint = PointF.Empty;
        PointF nextPoint = PointF.Empty;

        foreach (var point in points)
        {
            if (point.Y == y)
            {
                return point.X;
            }
            else if (point.Y > y)
            {
                nextPoint = point;
            }
            else
            {
                prevPoint = point;
                break;
            }
        }

        if (prevPoint.IsEmpty)
        {
            return points[points.Count - 1].X; //throw new Exception("No valid interpolation range found.");
        }
        else if (nextPoint.IsEmpty)
        {
            return points[0].X;
        }

        double xDiff = nextPoint.X - prevPoint.X;
        double yDiff = nextPoint.Y - prevPoint.Y;
        double slope = yDiff / xDiff;
        double x = prevPoint.X + (y - prevPoint.Y) / slope;
        if (double.IsNaN(x)) return ErrNum;
        else
            return x;
    }

    public double Evaluate_Solve(double y)
    {
        if (!IsFitted) return ErrNum;
        if (degree == 2) // 多项式次数
        {
            if (!is_Yvalue_validate(y)) return ErrNum;


            double a = coefficients[2]; // 二次项系数
            double b = coefficients[1]; // 一次项系数
            double c = coefficients[0] - y; // 常数项系数减去给定的 y 值


            var roots = MathSolver.Solve(a, b, c);
            if (roots == null) return ErrNum;
            else return roots.Max();

        }
        else if (degree == 3)
        {
            double a = coefficients[3]; // 3次项系数
            double b = coefficients[2]; // 2次项系数
            double c = coefficients[1]; // 1次项系数
            double d = coefficients[0] - y;// 常数项系数减去给定的 y 值
            var roots = MathSolver.Solve(a, b, c, d);
            if (roots == null) return ErrNum;
            else return roots.Max();
        }
        else
        {

            return Solve(y);
        }
    }



    public double YMax
    {
        get
        {
            if (!IsFitted) return ErrNum;
            double a = coefficients[degree];
            double b = coefficients[degree - 1];
            double c = coefficients[0];
            double delta = b * b - 4 * a * c;
            double minExtremePoint = -b / (2 * a);// 计算导函数的零点
            double maxValue = 0;
            if (a < 0)

                maxValue = -delta / (4 * a) + c;
            else
                maxValue = a * minExtremePoint * minExtremePoint + b * minExtremePoint + c;// 计算最小值
            return maxValue;
        }
    }
    public double YdataMax
    {
        get
        {
            double max = -99999;
            foreach (var p in Data)
            {
                if (max < p.Y) max = p.Y;
            }
            return max;
        }
    }
    public bool is_Yvalue_validate(double y)
    {
        if (!IsFitted) return false;
        double a = coefficients[degree];
        if (a < 0)

            return y <= YMax;
        else
            return y >= YMax;
    }


    /// X显示的范围

    public DRange range_X;



    /// Y显示的范围

    public DRange range_Y;
    public bool HasData { get { return Data.Count >= 3; } }
    public bool IsFitted = false;
    public List<PointF> FittedCurve
    {
        get
        {
            if (range_X == null) return null;
            List<PointF> doubles = new List<PointF>();
            for (double x = range_X.Min; x <= range_X.Max; x += step)
            {
                double y = Evaluate(x);
                doubles.Add(new PointF((float)x, (float)y));
            }
            return doubles;

        }

    }
    public List<PointF> FittedCurvebyRange(DRange range)
    {
        List<PointF> doubles = new List<PointF>();

        if (range == null)
        {
            range = new DRange();
            range.Min = range_X.Min;
            range.Max = range_X.Max;
        }
        var step = (range.Max - range.Min) / stepNum;
        for (double x = range.Min; x <= range.Max; x += step)
        {
            double y = Evaluate(x);
            doubles.Add(new PointF((float)x, (float)y));
        }
        return doubles;
    }


}
public class Default
{
    static string _filePath = Path.Combine(Directory.GetCurrentDirectory(), @"default.ini");
    public NodeViewModel junction;
    public ReservoirViewModel reservoir;
    public TankViewModel tank;
    public MeterViewModel meter;
    public NozzleViewModel nozzle;
    public LinkViewModel pipe;
    public ValveViewModel valve;
    public RepeaterViewModel repeater;
    public PumpViewModel pump;
    public static Default GetfaultINI()
    {
        StreamReader sr = new StreamReader(_filePath);
        string json = sr.ReadToEnd();
        sr.Close();
        return JsonConvert.DeserializeObject<Default>(json);

    }
    public void SaveFile()
    {
        StreamWriter sw = new StreamWriter(_filePath);
        sw.WriteLine(JsonConvert.SerializeObject(this));
        sw.Close();
    }

    public static Dictionary<MapObjectType, string> PreName = new Dictionary<MapObjectType, string>()
{
{MapObjectType.节点,"J" },
{MapObjectType.水库,"R" },
{MapObjectType.水池,"T" },
{MapObjectType.水表,"M" },
{MapObjectType.喷头,"N" },
{MapObjectType.管线,"P" },
{MapObjectType.阀门,"V" },
{MapObjectType.重复器,"Rp" },
{MapObjectType.水泵,"Pump" },
{MapObjectType.阀门点,"Vn" },
};
    public static string GetPreString(IBaseViewModel obj)
    {
        return PreName[obj.Type];
    }
}


public static class Global
{


    public static List<MapObjectRecord> mapObjectRecords = new List<MapObjectRecord>();
    public static int RecordIndex = 0;
    public static List<string> curveStrings = new List<string>() { "流量扬程曲线", "流量功率曲线", "流量效率曲线" };
    public static void ClearFileReadOnly(string filePath)
    {
        if (File.Exists(filePath))
        {
            // 获取当前文件属性
            FileAttributes attributes = File.GetAttributes(filePath);

            // 如果文件被设置为只读，则移除只读属性
            if ((attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
            {
                attributes &= ~FileAttributes.ReadOnly; // 移除只读标志

                // 设置新的文件属性
                File.SetAttributes(filePath, attributes);


            }

        }
    }
}


public static class GlobalExtension
{
    public static Type GetObjType(this MapObjectType type)
    {
        switch (type)
        {
            case MapObjectType.全部: return null;
            case MapObjectType.节点: return typeof(JunctionViewModel);
            case MapObjectType.水表: return typeof(MeterViewModel);
            case MapObjectType.水库: return typeof(ReservoirViewModel);
            case MapObjectType.水池: return typeof(TankViewModel);
            case MapObjectType.喷头: return typeof(NozzleViewModel);
            case MapObjectType.管线: return typeof(PipeViewModel);
            case MapObjectType.阀门: return typeof(ValveViewModel);
            case MapObjectType.重复器: return typeof(RepeaterViewModel);
            case MapObjectType.水泵: return typeof(PumpViewModel);
            case MapObjectType.阀门点: return typeof(ValveNodeViewModel);
            case MapObjectType.水泵点: return typeof(PumpNodeViewModel);
            default: return null;
        }

    }


}
public class MapObjectRecord
{
    public IBaseViewModel mapObject { get; set; }
    public string ValueName { get; set; }

    public dynamic Value { get; set; }

}

public class MapDimensions
{


    [Category("视角")]
    [DisplayName("中心")]
    [Browsable(true)]
    public PointF Center { get; set; }

    [Category("视角")]
    [DisplayName("缩放")]
    [Browsable(true)]
    public float zoom { get; set; } = 0.1f;

    [Category("视角")]
    [DisplayName("旋转角度")]
    [Browsable(true)]
    public double rotation { get; set; } = 0;


    private double _rotationF;
    [Category("视角")]
    [DisplayName("俯视角度")]
    [Browsable(true)]
    public double rotationF
    {
        get
        {
            if (Lock2DView) _rotationF = 90;
            return _rotationF;
        }
        set
        {
            _rotationF = value;
            if (Lock2DView) _rotationF = 90;
        }
    }

    [Category("视角")]
    [DisplayName("显示楼层")]
    [Browsable(true)]
    public int ShowFloor { get; set; } = int.MinValue;

    [Category("视角")]
    [DisplayName("显示背景")]
    [Browsable(true)]
    public bool isShowPic { get; set; } = true;



    public bool isAutoBackgroundImage = false;


    [Category("视角")]
    [DisplayName("显示最不利点")]
    [Browsable(true)]
    public bool isShowUnfavor { get; set; } = true;

    //
    //public int NodeColourIndex { get; set; } = 0;

    //
    //public int LinkColourIndex { get; set; } = 0;

    [Category("视角")]
    [DisplayName("锁定平面视角")]
    [Browsable(true)]
    public bool Lock2DView { get; set; } = false;


    /// 编辑模式true,浏览模式false；默认值：true；浏览模式下,不能编辑模型
    public bool isEditMode { get; set; } = true;



    /// 正交模式
    public bool IsOrtho { get; set; } = true;


    /// 显示的颜色分级
    public ColourType ColourNode { get; set; } = ColourType.无;
    public ColourType ColourLink { get; set; } = ColourType.无;

    public MapDimensions Copy()
    {
        MapDimensions mv = new MapDimensions();
        mv.Center = Center;
        mv.zoom = zoom;
        mv.rotation = rotation;
        mv.rotationF = rotationF;
        mv.ShowFloor = ShowFloor;
        return mv;
    }

}

public class UndoRedoCommand<T>
{
    private readonly Action<T> _undoAction;
    private readonly Action<T> _redoAction;
    private readonly T _oldValue;
    private readonly T _newValue;

    public UndoRedoCommand(T oldValue, T newValue, Action<T> undoAction, Action<T> redoAction)
    {
        _oldValue = oldValue;
        _newValue = newValue;
        _undoAction = undoAction;
        _redoAction = redoAction;
    }

    public void Undo()
    {
        _undoAction?.Invoke(_oldValue);
    }

    public void Redo()
    {
        _redoAction?.Invoke(_newValue);
    }
}

public static class MapObjectExtensions
{
    private static readonly Stack<UndoRedoCommand<object>> _undoStack = new Stack<UndoRedoCommand<object>>();
    private static readonly Stack<UndoRedoCommand<object>> _redoStack = new Stack<UndoRedoCommand<object>>();

    public static void AddUndoRedoSupport(this List<IBaseViewModel> list, PropertyGrid propertyGrid)
    {
        propertyGrid.PropertyValueChanged += (sender, e) =>
        {
            if (propertyGrid.SelectedObject is IBaseViewModel obj && obj != null)
            {
                var propertyDescriptor = TypeDescriptor.GetProperties(obj)[e.ChangedItem.PropertyDescriptor.Name];
                var oldValue = e.OldValue;//propertyDescriptor.GetValue(obj);
                var newValue = e.ChangedItem.Value;

                var undoAction = new Action<object>(v => propertyDescriptor.SetValue(obj, v));
                var redoAction = new Action<object>(v => propertyDescriptor.SetValue(obj, v));


                var command = new UndoRedoCommand<object>(oldValue, newValue, undoAction, redoAction);

                _undoStack.Push(command);
                _redoStack.Clear();
            }
        };
    }
    public static void AddCommand(UndoRedoCommand<object> command)
    {
        _undoStack.Push(command);
        _redoStack.Clear();
    }
    private static List<IBaseViewModel> getObj(object o)
    {
        var list = o as List<IBaseViewModel>;
        if (list == null)
        {
            if (o is List<NodeViewModel> list_nodes) list = new List<IBaseViewModel>(list_nodes);
            if (o is List<LinkViewModel> list_links) list = new List<IBaseViewModel>(list_links);
        }
        return list;
    }
    public static void AddCommand(object o, string PropertyDescriptorName, dynamic oldValue, dynamic newValue)
    {
        switch (PropertyDescriptorName)
        {
            case "Add":
                {

                    var net = o as MapViewNetWork;
                    var undoAction = new Action<object>(v => net.Remove(newValue));
                    var redoAction = new Action<object>(v => net.Add(newValue));
                    var command = new UndoRedoCommand<object>(oldValue, newValue, undoAction, redoAction);
                    AddCommand(command);
                }
                return;
            case "Remove":
                {
                    var net = o as MapViewNetWork;
                    var undoAction = new Action<object>(v => net.Add(newValue));
                    var redoAction = new Action<object>(v => net.Remove(newValue));
                    var command = new UndoRedoCommand<object>(oldValue, newValue, undoAction, redoAction);
                    AddCommand(command);
                }
                return;
            case "Map":
                {
                    var mv = o as MapDimensions;
                    var undoAction = new Action<object>(v =>
                    {
                        mv.Center = oldValue.Center;
                        mv.zoom = oldValue.zoom;
                        mv.rotation = oldValue.rotation;
                        mv.rotationF = oldValue.rotationF;

                    });
                    var redoAction = new Action<object>(v =>
                    {
                        mv.Center = newValue.Center;
                        mv.zoom = newValue.zoom;
                        mv.rotation = newValue.rotation;
                        mv.rotationF = newValue.rotationF;

                    });
                    //object oldValue=propertyDescriptor.GetValue(obj);
                    var command = new UndoRedoCommand<object>(oldValue, newValue, undoAction, redoAction);
                    AddCommand(command);
                }
                return;
        }


        if (o is IBaseViewModel obj && obj != null)
        {
            var propertyDescriptor = TypeDescriptor.GetProperties(obj)[PropertyDescriptorName];
            if (propertyDescriptor == null) return;
            var undoAction = new Action<object>(v => propertyDescriptor.SetValue(obj, v));
            var redoAction = new Action<object>(v => propertyDescriptor.SetValue(obj, v));
            var command = new UndoRedoCommand<object>(oldValue, newValue, undoAction, redoAction);
            AddCommand(command);
        }
        else if (o is List<IBaseViewModel> || o is List<NodeViewModel>)
        {
            var list = getObj(o);
            List<UndoRedoCommand<object>> list_command = new List<UndoRedoCommand<object>>();
            PropertyDescriptor propertyDescriptor = null;
            for (int i = 0; i < list.Count; i++)
            {
                var item = list[i];
                if (propertyDescriptor == null) propertyDescriptor = TypeDescriptor.GetProperties(item)[PropertyDescriptorName];
                if (propertyDescriptor == null) continue;
                IBaseViewModel obj0 = (IBaseViewModel)item;
                var undoAction0 = new Action<object>(v => propertyDescriptor.SetValue(obj0, v));
                var redoAction0 = new Action<object>(v => propertyDescriptor.SetValue(obj0, v));

                var command0 = new UndoRedoCommand<object>(oldValue[i], newValue[i], undoAction0, redoAction0);
                list_command.Add(command0);

            }

            var undoAction = new Action<object>(v =>
            {
                for (int i = 0; i < list_command.Count; i++)
                {
                    list_command[i].Undo();
                }
            });

            var redoAction = new Action<object>(v =>
            {
                for (int i = 0; i < list_command.Count; i++)
                {
                    list_command[i].Redo();
                }
            });
            var command = new UndoRedoCommand<object>(null, null, undoAction, redoAction);
            AddCommand(command);

        }

    }

    public static void Undo()
    {
        if (_undoStack.Count > 0)
        {
            var command = _undoStack.Pop();
            command.Undo();
            _redoStack.Push(command);
        }

    }

    public static void Redo()
    {
        if (_redoStack.Count > 0)
        {
            var command = _redoStack.Pop();
            command.Redo();
            _undoStack.Push(command);
        }

    }
}


public class Colour
{
    public string Name { get; set; }
    public ColourType Type { get; set; }
    public List<ColourItem> Items { get; set; }

    public bool isNode
    {
        get
        {
            if (Type == ColourType.节点自由压力 || Type == ColourType.节点需水量)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

    public bool isChoosed { get; set; } = false;

    public float minNum = 0;
    public float maxNum = 50;
    public int ColourCount = 5;
    public Color color0 = Color.Red;
    public Color color1 = Color.Blue;


    public Colour(ColourType type = ColourType.节点自由压力, List<ColourItem> value = null, string name = null)
    {
        Name = name;
        Type = type;
        Items = value;
        if (Items == null) Items = new List<ColourItem>();
        if (Name == null) Name = type.ToString();
    }
    public override string ToString()
    {
        return Name;
    }

    public static List<ColourItem> GetColourItems(float minValue, float maxValue, int ColourNum, Color color0, Color color1)
    {
        var colourItems = new List<ColourItem>();
        for (int i = 0; i < ColourNum; i++)
        {
            DRange currentRange = new DRange(minValue + i * (maxValue - minValue) / ColourNum, minValue + (i + 1) * (maxValue - minValue) / ColourNum);
            Color c;
            if (i == 0)
            {
                c = color0;
            }
            else if (i == ColourNum - 1)
            {
                c = color1;
            }
            else
            {
                c = Color.FromArgb(color0.R + (color1.R - color0.R) / (ColourNum - 1) * i, color0.G + (color1.G - color0.G) / (ColourNum - 1) * i, color0.B + (color1.B - color0.B) / (ColourNum - 1) * i);

            }


            ColourItem newFloor = new ColourItem(currentRange, c);
            colourItems.Add(newFloor);
        }
        return colourItems;
    }

    public static int NodeTypeCount = 3;
}

public class ColourItem
{
    public DRange DRange { get; set; } = new DRange();
    public Color value;
    public ColourItem(DRange dRange, Color value)
    {
        DRange = dRange;
        this.value = value;
    }

}
public enum ColourType
{
    无 = 0,
    节点自由压力 = 1,
    节点绝对压力 = 2,
    节点需水量 = 3,
    管线流量 = 4,
    管线流速 = 5
}


public class TempForEnum
{
    public string Item1;
    public dynamic Item2;
    public TempForEnum(string key, dynamic value)
    {
        Item1 = key;
        Item2 = value;
    }
}


public class EquivalentTemplateModel
{
    public string Name { get; set; }

    public long ID { get; set; }

    public List<WaterEquivalentModel> waterEquivalents { get; set; }


}

public class WaterEquivalentModel
{

    /// 器具名称
    public string WaterUtensilName { get; set; }


    /// 数量
    public int Count { get; set; }


    /// 额定流量
    public double RatedFlow { get; set; }


    /// 最小额定流量
    public double MinRatedFlow { get; set; }
}


public class MapViewEnum
{
    public enum MapObjectType
    {
        全部,
        节点,
        水库,
        水池,
        水表,
        喷头,
        管线,
        阀门,
        重复器,
        水泵,
        阀门点,
        水泵点,
    }

    public enum MouseState
    {
        无,
        新增节点,
        新建水库,
        新建水池,
        新建水表,
        新增喷头,
        新增管线,
        新增立管,
        新建阀门,
        新建重复器,
        新建水泵,
        设置底图范围,

    }

    public enum FactoryType
    {
        水厂,
        泵站
    }

    public enum TemplateType
    {
        全部,
        小区模板,
        单元模板,
        单元分区模板,
        楼层模板,
        其他
    }
}

public class AreaViewModel : NodeViewModel, IBaseViewModel
{
    public List<NodeViewModel> InnerNodes = new List<NodeViewModel>();
    public Color color { get; set; }
}

public class Factory
{
    public string Name { get; set; }
    public MapViewEnum.FactoryType Type { get; set; }
    public List<PumpViewModel> Pumps { get; set; }

    public void CurveFit()
    {
        foreach (var p in Pumps)
        {
            p.CurveFit();
        }
    }
}


public class JunctionViewModel : NodeViewModel
{
    public override string ToString()
    {
        var pTemp = PatternID;
        if (string.IsNullOrEmpty(pTemp) || pTemp == ";") pTemp = "";
        return $"{ID}\t{Elev}\t{Demand}\t{pTemp}\t;\t";
    }
}


public class MeterViewModel : NodeViewModel
{
    public string DlTemplateID { get; set; }
    public override string ToString()
    {
        if (string.IsNullOrEmpty(PatternID)) PatternID = "";
        return $"{ID}\t{Elev}\t{Demand}\t{PatternID}\t;\t";
    }

}


public class NozzleViewModel : NodeViewModel
{


    [Description("房间")]
    [DisplayName("房间")]
    public string Room { get; set; }

    [Category("计算参数")]
    [Description("流量系数")]
    [DisplayName("流量系数K")]
    public float FlowCoefficient { get; set; }
    public override string ToString()
    {
        if (string.IsNullOrEmpty(PatternID)) PatternID = "";
        return $"{ID}\t{Elev}\t{Demand}\t{PatternID}\t;\t";
    }
}


public class PipeViewModel : LinkViewModel
{

}


public class PointF3D
{
    public float X { get; set; }
    public float Y { get; set; }
    public float Z { get; set; }

    public PointF3D(float x, float y, float z)
    {
        X = x;
        Y = y;
        Z = z;
    }
    //定义减法运算符
    public static PointF3D operator -(PointF3D p1, PointF3D p2)
    {
        return new PointF3D(p1.X - p2.X, p1.Y - p2.Y, p1.Z - p2.Z);
    }
    //定义加法运算符
    public static PointF3D operator +(PointF3D p1, PointF3D p2)
    {
        return new PointF3D(p1.X + p2.X, p1.Y + p2.Y, p1.Z + p2.Z);
    }
    //定义乘法运算符
    public static PointF3D operator *(PointF3D p1, float f)
    {
        return new PointF3D(p1.X * f, p1.Y * f, p1.Z * f);
    }
    //定义点乘运算符
    public static float operator *(PointF3D p1, PointF3D p2)
    {
        return p1.X * p2.X + p1.Y * p2.Y + p1.Z * p2.Z;
    }
    //定义叉乘运算符
    public static PointF3D operator ^(PointF3D p1, PointF3D p2)
    {
        return new PointF3D(p1.Y * p2.Z - p1.Z * p2.Y, p1.Z * p2.X - p1.X * p2.Z, p1.X * p2.Y - p1.Y * p2.X);
    }
}

public class Cube
{
    public Dictionary<int, List<PointF3D>> FacesVertices { get; private set; }
    public List<PointF3D> Vertices { get; private set; }

    public Cube()
    {
        InitializeVertices();
        InitializeFaces();
    }

    private void InitializeVertices()
    {
        Vertices = new List<PointF3D>
{
new PointF3D(200, 200, 200), // Vertex 0
new PointF3D(200, 200, -200), // Vertex 1
new PointF3D(200, -200, 200), // Vertex 2
new PointF3D(200, -200, -200), // Vertex 3
new PointF3D(-200, 200, 200), // Vertex 4
new PointF3D(-200, 200, -200), // Vertex 5
new PointF3D(-200, -200, 200), // Vertex 6
new PointF3D(-200, -200, -200) // Vertex 7
};
    }

    private void InitializeFaces()
    {
        FacesVertices = new Dictionary<int, List<PointF3D>>
{
{ 1, new List<PointF3D> { Vertices[0], Vertices[1], Vertices[3], Vertices[2] } }, // Face 1
{ 2, new List<PointF3D> { Vertices[4], Vertices[5], Vertices[7], Vertices[6] } }, // Face 2
{ 3, new List<PointF3D> { Vertices[0], Vertices[1], Vertices[5], Vertices[4] } }, // Face 3
{ 4, new List<PointF3D> { Vertices[2], Vertices[3], Vertices[7], Vertices[6] } }, // Face 4
{ 5, new List<PointF3D> { Vertices[0], Vertices[2], Vertices[6], Vertices[4] } }, // Face 5
{ 6, new List<PointF3D> { Vertices[1], Vertices[3], Vertices[7], Vertices[5] } }// Face 6
};
    }
}


public class PumpNodeViewModel : NodeViewModel
{
    public PumpNodeViewModel()
    {
        Datasets = new Dictionary<string, Dataset>() {
{"流量扬程曲线",new Dataset("流量扬程曲线",new PumpViewModel())},
{"流量功率曲线",new Dataset("流量功率曲线",new PumpViewModel()) },
{"流量效率曲线",new Dataset("流量效率曲线",new PumpViewModel()) }
};
    }
    public string HeadCurve { get; set; }
    public List<string> Parameters { get; set; }

    public string Node1 { get; set; }
    public string Node2 { get; set; }

    public Dictionary<string, Dataset> Datasets { get; set; }

    public double 额定转速 { get; set; } = 1500;
    public double 额定流量 { get; set; } = 0;
    public double 额定扬程 { get; set; } = 0;

    public double 额定功率 { get; set; } = 75;

    public double 当前转速 { get; set; } = 1500;

    public double 转速比 { get; set; } = 1;

    public Dataset 流量扬程曲线 { get { return Datasets["流量扬程曲线"]; } }

    public Dataset 流量功率曲线 { get { return Datasets["流量功率曲线"]; } }

    public Dataset 流量效率曲线 { get { return Datasets["流量效率曲线"]; } }

}


public class PumpViewModel : LinkViewModel
{
    public static List<string> CurveStrings = new List<string> { "流量扬程曲线", "流量功率曲线", "流量效率曲线" };

    public new string Name
    {
        get { return base.Name; }
        set { base.Name = value; }
    }

    [DisplayName("水泵类型")]
    public new PumpType Type { get; set; }


    public dict<string, Dataset> Datasets { get; set; } = new dict<string, Dataset>();


    [Category("计算参数")]
    public double 额定转速 { get; set; } = 1500;

    [Category("计算参数")]
    public double 额定流量 { get; set; } = 200;
    [Category("计算参数")]
    public double 额定扬程 { get; set; } = 50;
    [Category("计算参数")]
    public double 额定功率 { get; set; } = 75;

    public double 转速比 { get; set; } = 1;

    [DisplayName("当前转速")]
    [Category("计算参数")]
    public double 当前转速 { get; set; } = 1500;

    public Dataset 流量扬程曲线
    {
        get
        {
            if (!Datasets.ContainsKey("流量扬程曲线")) Datasets.Add("流量扬程曲线", new Dataset("流量扬程曲线", null));
            return Datasets["流量扬程曲线"];
        }
    }

    public Dataset 流量功率曲线
    {
        get
        {
            if (!Datasets.ContainsKey("流量功率曲线")) Datasets.Add("流量功率曲线", new Dataset("流量功率曲线", null));
            return Datasets["流量功率曲线"];
        }
    }

    public Dataset 流量效率曲线
    {
        get
        {
            if (!Datasets.ContainsKey("流量效率曲线")) Datasets.Add("流量效率曲线", new Dataset("流量效率曲线", null));
            return Datasets["流量效率曲线"];
        }
    }

    public string factoryName
    {
        set; get;
    }



    public Factory factory { get; set; } = null;


    public PumpViewModel Copy()
    {
        PumpViewModel p = new PumpViewModel();
        p.Name = Name;
        p.额定流量 = 额定流量;
        p.额定扬程 = 额定扬程;
        p.额定功率 = 额定功率;
        p.额定转速 = 额定转速;
        p.当前转速 = 当前转速;
        p.Type = Type;
        p.factory = factory;
        foreach (var str in CurveStrings)
        {
            if (!p.Datasets.ContainsKey(str))
            {
                p.Datasets.Add(str, new Dataset(str, p));
            }
        }

        foreach (var pair in Datasets)
        {
            List<PointF> list = new List<PointF>();
            pair.Value._data.ForEach(m => list.Add(m));
            p.Datasets[pair.Key].Data = list;
            DRange rangeDefault = new DRange(double.MaxValue, double.MinValue);
            p.Datasets[pair.Key].range_X = DRange.Union(rangeDefault, pair.Value.range_X);
            p.Datasets[pair.Key].range_Y = DRange.Union(rangeDefault, pair.Value.range_Y);
        }
        p.CurveFit();
        return p;
    }

    public void CurveFit()
    {


        foreach (var data in Datasets)
        {
            data.Value.Data.Sort((a, b) => a.X > b.X ? 1 : (a.X == b.X ? 0 : -1));
            if (data.Value.HasData) data.Value.CurveFit();
        }
        string basetype = "流量扬程曲线";
        string type = "";


        type = "流量效率曲线";
        var type1 = "流量功率曲线";
        if (!Datasets.ContainsKey(type)) Datasets.Add(type, new Dataset(type, null));
        if (!Datasets.ContainsKey(type1)) Datasets.Add(type1, new Dataset(type1, null));
        if (Datasets[type].IsFitted && !Datasets[type1].IsFitted)
        {
            List<PointF> points = new List<PointF>();
            List<PointF> points1 = new List<PointF>();

            foreach (var yc in Datasets[basetype].Data)
            {
                float x = yc.X;
                float y_扬程 = yc.Y;

                float y_效率 = (float)Datasets[type].Evaluate(x);
                float y_功率 = (float)x * y_扬程 / y_效率 / 3.6f;
                points.Add(new PointF(x, y_效率));
                points1.Add(new PointF(x, y_功率));
            }
            Datasets[type].Data = points;
            Datasets[type1].Data = points1;
            Datasets[type].CurveFit();
            Datasets[type1].CurveFit();
        }



        if (!Datasets[type].IsFitted && Datasets[type1].IsFitted)
        {
            List<PointF> points = new List<PointF>();
            List<PointF> points1 = new List<PointF>();

            foreach (var yc in Datasets[basetype].Data)
            {
                float x = yc.X;
                float y_扬程 = yc.Y;
                float y_功率 = (float)Datasets[type1].Evaluate(x);
                float y_效率 = (float)x * y_扬程 / y_功率 / 3.6f;

                points.Add(new PointF(x, y_效率));
                points1.Add(new PointF(x, y_功率));


            }
            Datasets[type].Data = points;
            Datasets[type1].Data = points1;
            Datasets[type].CurveFit();
            Datasets[type1].CurveFit();
        }

    }

    public void ShowInGrid(DataGridView dataGridView)
    {
        dataGridView.Rows.Clear();
        // if ()
        for (int i = 0; i < 流量扬程曲线.Data.Count; i++)
        {
            PointF p = 流量扬程曲线.Data[i];
            PointF p_temp;
            double y1 = 0, y2 = 0;
            if (流量功率曲线.IsFitted)
            {
                if ((p_temp = 流量功率曲线.Data.Find(p0 => p0.X == p.X)) == default(PointF))
                    y1 = 流量功率曲线.Evaluate(p.X);
                else
                    y1 = p_temp.Y;
            }

            if (流量效率曲线.IsFitted)
            {
                if ((p_temp = 流量效率曲线.Data.Find(p0 => p0.X == p.X)) == default(PointF))
                    y2 = 流量效率曲线.Evaluate(p.X);
                else
                    y2 = p_temp.Y;
            }
            dataGridView.Rows.Add(Math.Round(p.X, 1), Math.Round(p.Y, 2), Math.Round(y1, 2), Math.Round(y2, 2));
        }
    }


    [Category("计算参数")]
    [DisplayName("流量扬程曲线")]
    public List<PointF> HeadCurvePoints
    {
        get
        {
            this.Datasets.TryGetValue("流量扬程曲线", out Dataset dataset);
            if (dataset != null)
            {
                return dataset._data;
            }
            return null;
        }
        set
        {
            this.Datasets.TryGetValue("流量扬程曲线", out Dataset dataset);
            if (dataset == null)
            {
                dataset = new Dataset("流量扬程曲线", this);
            }
            dataset._data = value;

        }
    }
    [Category("计算参数")]
    [DisplayName("流量效率曲线")]
    public List<PointF> EfficCurvePoints
    {
        get
        {
            this.Datasets.TryGetValue("流量效率曲线", out Dataset dataset);
            if (dataset != null)
            {
                return dataset._data;
            }
            return null;
        }
        set
        {
            this.Datasets.TryGetValue("流量效率曲线", out Dataset dataset);
            if (dataset == null)
            {
                dataset = new Dataset("流量效率曲线", this);
            }
            dataset._data = value;

        }
    }

    public string HeadCurve { get; set; } = "PumpDefault";

    public List<string> Parameters { get; set; }

    //实际需水量

    [DisplayName("扬程")]
    [Browsable(true)]
    public new float EN_HEADLOSS { get { return -base.EN_HEADLOSS; } }


    public new float EN_VELOCITY { get { return base.EN_VELOCITY; } }


    public override string ToString()
    {
        string para = Parameters == null ? null : string.Join("\t", Parameters);
        return $"{ID}\t{Node1}\t{Node2}\tHead\t{HeadCurve}\tSPEED\t{转速比}\t{para}\t;\t";
    }
}

public class RepeaterViewModel : LinkViewModel
{

    [DisplayName("对象前缀名称")]
    [Browsable(true)]

    /// 模板ID
    public string NetworkPreName { get; set; }


    [DisplayName("显示名称")]
    [Browsable(true)]

    /// 模板ID
    public string NetworkShowName { get; set; }


    [DisplayName("前缀最小序号")]
    [Browsable(true)]

    /// 模板ID

    public int NetworkPreStartNum { get; set; } = 1;


    [DisplayName("前缀正序")]
    [Browsable(true)]

    /// 模板ID

    public bool NetworkIsAscNum { get; set; } = true;

    [Category("计算参数")]
    [DisplayName("模板ID")]


    /// 模板ID

    public string TemplateID { get; set; }


    [Category("计算参数")]
    [DisplayName("模板名称")]
    [Browsable(true)]
    public string TempName => TemplateList.GetTemplate(TemplateID)?.Name;

    public Template template = null;

    [NonSerialized]
    public MapViewNetWork netList = null;



    public NodeViewModel StartNode_inner;

    public NodeViewModel EndNode_inner;


    public bool isLoadded = false;


    [Category("计算参数")]
    [DisplayName("重复次数")]
    [Browsable(true)]

    /// 重复次数

    public int RepeatTimes { get; set; }




    [Category("计算参数")]
    [DisplayName("海森威廉系数")]

    public new float Roughness { get; set; }
    [Category("计算参数")]
    [DisplayName("局部阻力系数")]

    public override float MinorLoss { get; set; }

    [DisplayName("长度(m)")]
    [Browsable(true)]
    public new float Length { get; set; }


    [DisplayName("口径(mm)")]

    public new float Diameter { get; set; }


    [Category("计算参数")]
    [DisplayName("显示状态")]
    [Browsable(true)]
    public new RepeatStatus Status { get; set; }

    public bool Load(int MaxLevel, dict<string, dynamic> param, Dictionary<TemplateType, bool> viewModel, bool viewMode = true)
    {

        if (template == null)
        {
            template = TemplateList.GetTemplate(TemplateID);
            if (template == null)
            {
                return false;
            }
            template.loadInpFile();
            template.network.MapObjects.ForEach(o =>
            {
                if (o.Level > MaxLevel)
                    o.Visible = false;
                else
                    o.Visible = true;
            });
            MapViewNetWork net = template.network;
            net.StartPoint = net.GetNode(template.Node1)[0];
            net.EndPoint = net.GetNode(template.Node2)[0];

        }


        if (!viewMode)
        {
            Status = RepeatStatus.收起;
        }
        else if (viewModel != null)
        {
            if (viewModel[template.Type])
                Status = RepeatStatus.显示;
            else
                Status = RepeatStatus.收起;
        }
        else
        {
            Status = RepeatStatus.显示;
        }


        if (param.Contains("层数") && param["层数"] > 0 && template.Type == TemplateType.楼层模板)
        {
            RepeatTimes = (int)param["层数"];
        }

        if (Status == RepeatStatus.收起)
        {
            return false;
        }
        PointF3D basepoint = StartNode.Position3D;
        netList = new MapViewNetWork();
        for (int i = 0; i < RepeatTimes; i++)
        {
            MapViewNetWork net = template.network.CreateNew(basepoint);
            int index = GetIndex(i);

            net.Name = NetworkPreName + (index == 0 ? "" : index.ToString("00"));
            net.StartPoint = net.GetNode(template.Node1)[0];
            net.EndPoint = net.GetNode(template.Node2)[0];
            if (template.Type == TemplateType.楼层模板)
                ChangeNetbyParam(net, param);
            if (i == 0) StartNode_inner = net.StartPoint;
            EndNode_inner = net.EndPoint;
            net.LoadRepeaters(MaxLevel, param, viewModel);
            net.Rename();
            netList.AddJoinNet(net);
            basepoint = netList.EndPoint.Position3D;
        }
        return true;
    }
    void ChangeNetbyParam(MapViewNetWork net, dict<string, dynamic> param)
    {
        if (param.Contains("层高") && param["层高"] > 0 && net.StartPoint != null && net.EndPoint != null)
        {
            var currentHeight = Math.Abs(net.StartPoint.Elev - net.EndPoint.Elev);
            var k = (float)param["层高"] / currentHeight;
            net.Nodes.ForEach(n => n.Elev = (n.Elev - net.StartPoint.Elev) * k + net.StartPoint.Elev);
        }

        if (param.Contains("系统最大流量") && param["系统最大流量"] > 0 && net.StartPoint != null && net.EndPoint != null)
        {
            Dictionary<NodeViewModel, float> Distance = new Dictionary<NodeViewModel, float>();
            CalcDistance(net, net.StartPoint, Distance);
            float sumDistance = 0;
            net.meters.ForEach(m => sumDistance += Distance[m]);
            float avgDistance = sumDistance / net.meters.Count;
            var k = (float)param["系统最大流量"] / avgDistance;
            net.Nodes.ForEach(n =>
            {
                n.X = (n.X - net.StartPoint.X) * k + net.StartPoint.X;
                n.Y = (n.Y - net.StartPoint.Y) * k + net.StartPoint.Y;
            });
        }
        if (param.Contains("户数") && template.Type == TemplateType.楼层模板)
        {
            var MaxLevel = (int)param["户数"];
            net.MapObjects.ForEach(o =>
            {
                if (o.Level > MaxLevel)
                    o.Visible = false;
                else
                    o.Visible = true;
            });
        }
    }



    public static void CalcDistance(MapViewNetWork net, NodeViewModel startNode, Dictionary<NodeViewModel, float> Distance)
    {
        // 定义 visited 字典记录已访问过的节点和待访问的节点队列
        Queue<NodeViewModel> queue = new Queue<NodeViewModel>();

        // 标记起始节点为已访问，并加入队列
        Distance[startNode] = 0;
        queue.Enqueue(startNode);

        // 不断从队列中取出节点进行访问，直到队列为空
        while (queue.Count > 0)
        {
            // 取出队首节点并输出
            NodeViewModel node = queue.Dequeue();
            //Console.WriteLine(node.Name);

            // 遍历当前节点的所有未访问邻居节点，并标记为已访问
            foreach (LinkViewModel link in net.Links)
            {
                if (link.StartNode == node)
                {
                    var node1 = link.EndNode;
                    var dis = Distance[node] + (float)Math.Sqrt(Math.Pow(node.X - node1.X, 2) + Math.Pow(node.Y - node1.Y, 2));
                    if (!Distance.ContainsKey(node1) || Distance[node1] > dis)
                        Distance[link.EndNode] = dis;
                    queue.Enqueue(link.EndNode);
                }
                else if (link.EndNode == node && !Distance.ContainsKey(link.StartNode))
                {
                    var node1 = link.StartNode;
                    var dis = Distance[node] + (float)Math.Sqrt(Math.Pow(node.X - node1.X, 2) + Math.Pow(node.Y - node1.Y, 2));
                    if (!Distance.ContainsKey(node1) || Distance[node1] > dis)
                        Distance[link.StartNode] = dis;
                    queue.Enqueue(link.StartNode);
                }
            }
        }
    }

    public int GetIndex(int i)
    {
        int index = 0;
        if (NetworkIsAscNum)
        {
            index = NetworkPreStartNum + i;
        }
        else
        {
            index = RepeatTimes - 1 - i + NetworkPreStartNum;
        }

        return index;
    }



    public enum RepeatStatus
    {
        收起,
        显示
    }
}


public class ReservoirViewModel : NodeViewModel
{
    [Category("计算参数")]
    [Description("需水量")]
    [DisplayName("需水量(m³/h)")]

    public new float Demand { get; set; }
    [Category("计算参数")]
    [Description("总水头")]
    [DisplayName("绝对水压(m)")]
    public float Head { get; set; }
    //public string Pattern { get; set; }
    public override string ToString()
    {
        return $"{ID}\t{Head}\t{PatternID}\t;\t";
    }
}


public class TankViewModel : NodeViewModel
{
    [Category("计算参数")]
    [DisplayName("初始水位(m)")]
    public float InitLevel { get; set; } = 5;
    [Category("计算参数")]
    [DisplayName("最低水位(m)")]
    public float MinLevel { get; set; } = 0;
    [Category("计算参数")]
    [DisplayName("最高水位(m)")]
    public float MaxLevel { get; set; } = 10;
    [Category("计算参数")]
    [DisplayName("直径(mm)")]

    public float Diameter { get; set; } = 10;

    [Category("计算参数")]
    [DisplayName("池底面积")]
    public double Area
    {
        get
        {
            return Math.PI * Math.Pow(Diameter, 2) / 4;
        }
        set
        {
            Diameter = (float)Math.Pow(value / Math.PI, 0.5) * 2;
        }
    }
    [Category("计算参数")]
    [DisplayName("最小容积")]
    public float MinVol { get; set; } = 0;

    [Category("计算参数")]
    [DisplayName("容积曲线")]
    public string VolCurve { get; set; } = "";
    [Category("计算参数")]
    [DisplayName("是否允许溢流")]
    public string Overflow { get; set; } = "";

    public TankViewModel()
    {

    }
    public TankViewModel(string id, string elevation, string initlevel, string minlevel, string maxlevel, string diameter, string minvol, string volcurve, string overflow)
    {
        ID = id;
        Elev = float.Parse(elevation);
        float d = 0;
        float.TryParse(initlevel, out d);
        InitLevel = d;
        float.TryParse(minlevel, out d);
        MinLevel = d;
        float.TryParse(maxlevel, out d);
        MaxLevel = d;
        float.TryParse(diameter, out d);
        Diameter = d;
        float.TryParse(minvol, out d);
        MinVol = d;
        VolCurve = "";
        //float.TryParse(overflow, out d );
        Overflow = "";
    }
    public override string ToString()
    {
        VolCurve = "";
        Overflow = "";
        return $"{ID}\t{Elev}\t{InitLevel}\t{MinLevel}\t{MaxLevel}\t{Diameter}\t{MinVol}\t{VolCurve}\t{Overflow}\t;\t";
    }
}


public class ValveNodeViewModel : NodeViewModel
{
    public string Node1 { get; set; }
    public string Node2 { get; set; }



    [DisplayName("长度(m)")]
    [Browsable(true)]
    public float Length { get; set; }


    [DisplayName("口径(mm)")]
    [Browsable(true)]
    public float Diameter { get; set; }

    [Category("计算参数")]
    [DisplayName("海森威廉系数")]
    [Browsable(true)]
    public float Roughness { get; set; } = 110;
    [Category("计算参数")]
    [DisplayName("局部阻力系数")]
    [Browsable(true)]
    public float MinorLoss { get; set; } = 0;
    [Category("计算参数")]
    [DisplayName("初始状态")]
    [Browsable(true)]
    public new StatusType Status { get; set; }


    [Browsable(true)]
    public new string Type { get; set; } = "GPV";

    [DisplayName("曲线")]
    [Browsable(true)]
    public string Setting { get; set; } = "GPVDefault";
}


public class ValveViewModel : LinkViewModel
{

    [DisplayName("长度(m)")]
    [Browsable(true)]
    public new float Length { get; set; }


    [DisplayName("口径(mm)")]
    [Browsable(true)]
    public new float Diameter { get; set; }

    [Category("计算参数")]
    [DisplayName("海森威廉系数")]
    [Browsable(true)]
    public new float Roughness { get; set; } = 110;
    [Category("计算参数")]
    [DisplayName("局部阻力系数")]
    [Browsable(true)]
    public new float MinorLoss { get; set; } = 0;
    //[Category("计算参数")]
    //[DisplayName("初始状态")]
    //[Browsable(true)]
    //public string Status { get; set; } = "";


    [Browsable(true)]
    public new string Type { get; set; } = "GPV";

    [DisplayName("曲线")]
    [Browsable(true)]
    public string Setting { get; set; } = "GPVDefault";

    // 重写ToString()方法以便将阀门属性转换为字符串
    public override string ToString()
    {

        return $"{ID}\t{Node1}\t{Node2}\t{Diameter:F4}\t{Type}\t{Setting}\t{MinorLoss:F4}\t;\t";
    }

}


public class TRegion
{
    public string Name { get; set; } = "新分区";
    public List<Floor> Floors { get; set; } = new List<Floor>();
    public bool isDirectionUp { get; set; } = true;
    public string JoinNode { get; set; } = null;

    public override string ToString()
    {
        return Name;
    }

}


public class Floor
{
    public int FloorIndex = 1;
    public string BackgroundImg = null;
    public float Elev = 0;
    public MapDimensions MapView { get; set; } = null;

    public string Name => $"{FloorIndex}楼";
    public Floor()
    {

    }


    public Floor(Floor other)
    {
        // 进行属性的深拷贝赋值
        this.FloorIndex = other.FloorIndex;
        this.BackgroundImg = other.BackgroundImg;
        this.Elev = other.Elev;
        this.MapView = (other.MapView != null) ? other.MapView.DeepCopyByBin<MapDimensions>() : null;
    }
    public Floor(int floorIndex, string tempID, float floorElevation, MapDimensions otherInfo)
    {
        FloorIndex = floorIndex;
        TemplateID = tempID;
        Elev = floorElevation;
        MapView = otherInfo;
    }
    public string TemplateID { get; set; } = null;


    public Template template { get { return TemplateList.GetTemplate(TemplateID); } }

     


}


public class Template
{
    private string _ID;

    [Description("对象的ID唯一标识")]
    [DisplayName("模板ID")]
    [Browsable(true)]
    public string ID { get { if (_ID == null || _ID == "") _ID = Guid.NewGuid().ToString(); return _ID; } set { _ID = value; } }

    [DisplayName("名称")]
    public string Name { get; set; }

    public MapOption mapOption { get; set; } = new MapOption();

    private string _filePath = null;

    [Category("计算参数")]
    [DisplayName("路径INP")]
    public string filePath
    {
        get
        {
            return _filePath;
        }
        set
        {
            var filePath = value;
            var CurDir = Directory.GetCurrentDirectory();
            if (filePath != null && filePath.IndexOf(CurDir) >= 0)
            {

                filePath = filePath.Replace(CurDir, "");
                if (filePath[0] == '\\')
                    filePath = filePath.Substring(1);
            }


            _filePath = filePath;
        }
    }


    public PointF3D OffSet { get; set; } = new PointF3D(0, 0, 0);

    private string _BackGroundImg_FullPath;

    public string BackGroundImg_FullPath
    {
        get
        {
            if (string.IsNullOrEmpty(_BackGroundImg_FullPath))
            {
                FileInfo fi = new FileInfo(FullPath);
                return fi.FullName.Substring(0, fi.FullName.Length - fi.Extension.Length) + ".png";
            }
            else return _BackGroundImg_FullPath;
        }
        set
        {
            _BackGroundImg_FullPath = value;
        }
    }

    public float BackGroundElev = 0;


    /// 底图X

    public float BackGroundImgX = 0;


    /// 底图Y

    public float BackGroundImgY = 0;

    /// 底图高度

    public float BackGroundImgHeight = 0;

    /// 底图宽度

    public float BackGroundImgWidth = 0;

    /// 底图旋转角度

    public float BackGroundImgRotaAngle = 0;
    public PointF BackGroundPoint1 = new PointF();

    public PointF BackGroundPoint2 = new PointF();

    public string FullPath
    {
        get
        {
            if (filePath != null) filePath = filePath.TrimStart('\\');
            return
            Path.Combine(Directory.GetCurrentDirectory(), (filePath == null ? "" : filePath));

        }
    }


    public string ImportExcelPath { get; set; }


    public int ImportExcelIndex { get; set; }



    [Category("计算参数")]
    [DisplayName("最高级数")]
    public int MaxLevel { get; set; } = 99;



    [Browsable(true)]
    public TemplateType Type { get; set; }


    public Template()
    {

        ID = new Guid().ToString();
        Name = "临时";
        filePath = null;

    }
    public Template(string ID, string name, string address, TemplateType type)
    {
        if (ID == null)
            this.ID = new Guid().ToString();
        Name = name;
        filePath = address;
        Type = type;
    }



    [Description("对象的ID唯一标识")]

    [NonSerialized]
    public MapViewNetWork network = null;



    [Category("楼层")]
    [DisplayName("楼层")]

    public List<TRegion> Regions { get; set; } = null;


    [DisplayName("标高")]

    public float Elev { get { return 0; } }

    public float Diameter { get { return 0; } }


    public float Level { get { return 0; } }




    [DisplayName("开始节点")]
    public string Node1 { get; set; }



    [DisplayName("结束节点")]
    public string Node2 { get; set; }


    public string X { get; set; }

    public string Y { get; set; }


    public string Visible { get; set; }

    [Category("默认视角")]
    [DisplayName("视角")]

    public MapDimensions view { get; set; } = new MapDimensions();


    [Category("默认视角")]
    [DisplayName("中心X")]
    [Browsable(true)]
    public float CenterX
    {
        get
        {
            if (view != null) return view.Center.X;
            else return 0;
        }
        set
        {
            if (view == null) view = new MapDimensions();
            view.Center = new PointF(value, view.Center.Y);
        }
    }
    [Category("默认视角")]
    [DisplayName("中心Y")]
    [Browsable(true)]
    public float CenterY
    {
        get
        {
            if (view != null) return view.Center.Y;
            else return 0;
        }
        set
        {
            if (view == null) view = new MapDimensions();
            view.Center = new PointF(view.Center.X, value);
        }
    }

    [Category("默认视角")]
    [DisplayName("缩放")]
    [Browsable(true)]
    public float zoom
    {
        get
        {
            if (view != null)
                return view.zoom;
            else return 1f;
        }
        set
        {
            if (view == null) view = new MapDimensions();
            view.zoom = value;
        }
    }

    [Category("默认视角")]
    [DisplayName("旋转角度")]
    [Browsable(true)]
    public double rotation
    {
        get { if (view != null) return view.rotation; else return 0; }
        set
        {
            if (view == null) view = new MapDimensions();
            view.rotation = value;
        }
    }

    [Category("默认视角")]
    [DisplayName("俯视角度")]
    [Browsable(true)]
    public double rotationF
    {
        get { if (view != null) return view.rotationF; else return 90; }
        set
        {
            if (view == null) view = new MapDimensions();
            view.rotationF = value;
        }
    }




    public bool loadInpFile()
    {
        network = new MapViewNetWork();
        var result = network.BuildFromInp(FullPath);
        if (result)
        {
            network.MapObjects.ForEach(o =>
            {
                if (o.Level > MaxLevel)
                    o.Visible = false;
                else
                    o.Visible = true;
            });


            return true;
        }
        else
            return false;
    }
    [DisplayName("颜色分级方案")]
    public List<Colour> Colours { get; set; } = new List<Colour>();


    public void Export(string path)
    {
        network.BuildToInp(path);
    }
}


public class TemplateList
{
    public List<Template> templates = new List<Template>();
    public static TemplateList instance;
    public static string _tempListPath = null;
    public static bool Inited = false;

    public static Template AddTemp(Template temp)
    {
        instance.templates.Add(temp);
        return temp;
    }
    public static Template GetTemplate(string ID)
    {
        return instance.templates.Find(t => t.ID == ID);
    }

    public static void Init(string filePath = null)
    {
        if (filePath == null)
            _tempListPath = Path.Combine(Directory.GetCurrentDirectory(), "templates.json");
        else
            _tempListPath = filePath;
        if (File.Exists(_tempListPath))
        {
            string jsonString = File.ReadAllText(_tempListPath);

            if (jsonString != null && jsonString != "")
            {
                try
                {
                    instance = JsonConvert.DeserializeObject<TemplateList>(jsonString);
                }
                catch
                {

                }

            }


        }
        if (instance == null)
        {
            instance = new TemplateList();
            // 添加测试数据
            AddTemp(new Template(null, "小区模板", @"template\小区模板\", TemplateType.小区模板));
            AddTemp(new Template(null, "分区模板", @"template\单元分区模板\", TemplateType.单元分区模板));
            AddTemp(new Template(null, "单元模板", @"template\单元模板\", TemplateType.单元模板));
            AddTemp(new Template(null, "楼层1", @"template\楼层模板\楼层1.inp", TemplateType.楼层模板));
        }
        Inited = true;
    }

    // 保存模板数据到文件中
    public static void SaveToFile(string filePath = null)
    {
        if (filePath == null) filePath = _tempListPath;
        // 备份历史保存文件
        if (File.Exists(filePath))
        {
            string backupPath = filePath + ".bak";
            if (File.Exists(backupPath))
            {
                File.Delete(backupPath);
            }

            FileCopy.Copy(filePath, backupPath);
        }

        JsonSerializerSettings settings = new JsonSerializerSettings
        {
            Formatting = Formatting.Indented,
            ContractResolver = new ShouldSerializeContractResolver(),
        };
        string json = JsonConvert.SerializeObject(instance, Formatting.Indented, settings);
        File.WriteAllText(_tempListPath, json);

        //MessageCompressHelper.SaveCompressedBase64ToFile<TemplateList>(instance, filePath);
    }

    public static List<Template> GetTemplates()
    {
        if (instance != null)
        {
            return instance.templates;
        }
        else
            return new List<Template>();
    }
}
public class ShouldSerializeContractResolver : DefaultContractResolver
{
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);

        if (property.DeclaringType == typeof(Template) && member.Name == "network")
        {
            property.ShouldSerialize = instance => false;
        }

        return property;
    }
}


public class WaterEquivalent
{
    public WaterEquivalent() { }
    public WaterEquivalent(WaterEquivalent rhs)
    {
        this.ID = rhs.ID;
        this.BelongID = rhs.BelongID;
        this.BelongType = rhs.BelongType;
        this.WaterUtensilID = rhs.WaterUtensilID;
        this.Count = rhs.Count;
        this.MinRatedFlow = rhs.MinRatedFlow;
        this.RatedFlow = rhs.RatedFlow;
        this.Flags = rhs.Flags;
        this.TagName = rhs.TagName;
        this.UseStatus = rhs.UseStatus;
        this.SortCode = rhs.SortCode;
        this.Description = rhs.Description;
    }

    public long ID { get; set; }


    /// 所属对象标识 
    public long BelongID { get; set; }


    /// 所属对象类型 
    public string BelongType { get; set; }


    /// 用水器具标识
    public long WaterUtensilID { get; set; }


    /// 数量
    public int Count { get; set; }


    /// 额定流量
    public double RatedFlow { get; set; }


    /// 最小额定流量
    public double MinRatedFlow { get; set; }


    /// 标签列表
    public string Flags { get; set; }


    /// 标签名称
    public string TagName { get; set; }

    /// 使用状态
    public int UseStatus { get; set; }


    /// 排序码
    public int SortCode { get; set; }


    /// 说明
    public string Description { get; set; }


}


public class WaterEquivalentCollection : List<WaterEquivalent>
{
    public WaterEquivalentCollection() { }
    public WaterEquivalentCollection(WaterEquivalentCollection rhs)
    {
        foreach (var item in rhs)
        {
            this.Add(new WaterEquivalent(item));
        }
    }
}

public class WaterEquivalentTemplate
{
    public WaterEquivalentTemplate() { }
    public WaterEquivalentTemplate(WaterEquivalentTemplate rhs)
    {
        this.ID = rhs.ID;
        this.Name = rhs.Name;
        this.Description = rhs.Description;
        this.WaterEquivalentCollection = new WaterEquivalentCollection(rhs.WaterEquivalentCollection);
    }
    public string ID { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }

    public WaterEquivalentCollection WaterEquivalentCollection { get; set; }
}

public class WaterEquivalentSettings
{

    /// 当量模板

    public WaterEquivalentTemplate waterEquivalents = new WaterEquivalentTemplate();

    /// 用户水表的集合

    public List<string> Meters = new List<string>();
}


public class NetWork //: INetWork
{
    public NetWork()
    {
    }

    public List<JunctionModel> Junctions
    {
        get
        {
            var js = Nodes.Where(d => d is JunctionModel);
            return js?.Select(d => d as JunctionModel).ToList();
        }

    }
    public List<TankModel> Tanks
    {
        get
        {
            var js = Nodes.Where(d => d is TankModel);
            return js?.Select(d => d as TankModel).ToList();
        }
    }

    public List<PipeModel> Pipes
    {
        get
        {
            var js = Links.Where(d => d is PipeModel);
            return js?.Select(d => d as PipeModel).ToList();
        }
    }

    public List<PumpModel> Pumps
    {
        get
        {
            var js = Links.Where(d => d is PumpModel);
            return js?.Select(d => d as PumpModel).ToList();
        }
    }

    public List<ValveModel> Valves
    {
        get
        {
            var js = Links.Where(d => d is ValveModel);
            return js?.Select(d => d as ValveModel).ToList();
        }
    }

    public List<ReservoisModel> Reservos
    {
        get
        {
            var js = Nodes.Where(d => d is ReservoisModel);
            return js?.Select(d => d as ReservoisModel).ToList();
        }
    }

    public List<MeterModel> Meters
    {
        get
        {
            var js = Nodes.Where(d => d is MeterModel);
            return js?.Select(d => d as MeterModel).ToList();
        }
    }

    public List<NozzleModel> Nozzles
    {
        get
        {
            var js = Nodes.Where(d => d is NozzleModel);
            return js?.Select(d => d as NozzleModel).ToList();
        }
    }

    public virtual void AddJunction(JunctionModel junction)
    {
        CheckNodesExist(junction);
        Nodes.Add(junction);
    }

    public virtual void AddJunctions(List<JunctionModel> junctions)
    {
        junctions.ForEach(junction => { AddJunction(junction); });
    }

    public virtual void AddTank(TankModel tank)
    {
        CheckNodesExist(tank);
        Nodes.Add(tank);
    }

    public virtual void AddTanks(List<TankModel> tanks)
    {
        tanks.ForEach(tank => { AddTank(tank); });
    }

    public virtual void AddPipe(PipeModel pipe)
    {
        CheckLinksExist(pipe);
        Links.Add(pipe);
    }

    public virtual void AddPipes(List<PipeModel> pipes)
    {
        pipes.ForEach(pipe => { AddPipe(pipe); });
    }
    public virtual void AddPump(PumpModel pump)
    {
        CheckLinksExist(pump);
        Links.Add(pump);
    }

    public virtual void AddPumps(List<PumpModel> pumps)
    {
        pumps.ForEach(pump => { AddPump(pump); });
    }
    public virtual void AddValve(ValveModel valve)
    {
        CheckLinksExist(valve);
        Links.Add(valve);
    }

    public virtual void AddValves(List<ValveModel> valves)
    {
        valves.ForEach(valve => { AddValve(valve); });
    }
    public virtual void AddReservos(ReservoisModel reservois)
    {
        CheckNodesExist(reservois);
        Nodes.Add(reservois);
    }
    public virtual void AddReservoss(List<ReservoisModel> reservoiss)
    {
        reservoiss.ForEach(reservois => { AddReservos(reservois); });
    }
    public virtual void AddMeter(MeterModel meter)
    {
        CheckNodesExist(meter);
        Nodes.Add(meter);
    }
    public virtual void AddMeters(List<MeterModel> meters)
    {
        meters.ForEach(meter => { AddMeter(meter); });
    }
    public virtual void AddNozzle(NozzleModel nozzle)
    {
        CheckNodesExist(nozzle);
        Nodes.Add(nozzle);
    }
    public virtual void AddNozzles(List<NozzleModel> nozzles)
    {
        nozzles.ForEach(nozzle => { AddNozzle(nozzle); });
    }

    private void CheckNodesExist(NodeCalcModel node)
    {
        if (Nodes.Any(d => d.ID == node.ID))
            throw new Exception("已存在重复的对象");
    }

    private void CheckLinksExist(LinkCalcModel link)
    {
        if (Links.Any(d => d.ID == link.ID))
            throw new Exception("已存在重复的对象");
    }

    public List<NodeCalcModel> Nodes { get; set; } = new List<NodeCalcModel>();
    public List<LinkCalcModel> Links { get; set; } = new List<LinkCalcModel>();


    /// 根据INP文件生成
    public virtual bool BuildFromInp(string InpPath)
    {
        if (InpPath == null || !File.Exists(InpPath)) return false;
        List<Coor> points = new List<Coor>();
        StreamReader sr = new StreamReader(InpPath);

        {
            string line;
            string section = "";
            while ((line = sr.ReadLine()) != null)
            {
                if (line.Trim().StartsWith("["))
                {
                    section = line.TrimStart('[').TrimEnd(']');
                }
                else
                {
                    string s = line.Trim('\t').Trim(' ');
                    if (s.Length == 0 || s[0] == ';') continue;
                    line = line.Replace("\t\t", "\t_\t").Replace("\t \t", "\t_\t");
                    Parts parts = new Parts(line.Split(new char[] { '\t', ' ', ';' }, StringSplitOptions.RemoveEmptyEntries));
                    switch (section)
                    {
                        case "JUNCTIONS":
                            {
                                var ID = parts[0];
                                float elev;
                                float.TryParse(parts[1], out elev);
                                var Elev = elev;
                                float demand;
                                float.TryParse(parts[2], out demand);
                                var Demand = demand;
                                var PatternID = parts[3];
                                int level;
                                int.TryParse(parts[6], out level);
                                var Level = level;

                                if (parts[5] == "Meter")
                                {
                                    AddMeter(new MeterModel()
                                    {
                                        ID = ID,
                                        Elev = Elev,
                                        Demand = Demand,
                                        PatternID = PatternID,
                                    });
                                }
                                else if (parts[5] == "Nozzle")
                                {
                                    AddNozzle(new NozzleModel()
                                    {
                                        ID = ID,
                                        Elev = Elev,
                                        Demand = Demand,
                                        PatternID = PatternID,
                                    });
                                }
                                else
                                {
                                    AddJunction(new JunctionModel()
                                    {
                                        ID = ID,
                                        Elev = Elev,
                                        Demand = Demand,
                                        PatternID = PatternID,
                                    });
                                }

                            }
                            break;
                        case "RESERVOIRS":
                            {
                                ReservoisModel r = new ReservoisModel();
                                r.ID = parts[0];
                                float head;
                                if (float.TryParse(parts[1], out head))
                                    r.Head = head;
                                r.PatternID = parts.Length > 2 ? parts[2] : "";
                                int level;

                                AddReservos(r);
                            }
                            break;
                        case "TANKS":
                            {
                                float initLevel = 0;
                                float.TryParse(parts[2], out initLevel);

                                float minLevel = 0;
                                float.TryParse(parts[3], out minLevel);

                                float maxLevel = 0;
                                float.TryParse(parts[4], out maxLevel);

                                float diamter = 0;
                                float.TryParse(parts[5], out diamter);

                                float minVol = 0;
                                float.TryParse(parts[6], out minVol);
                                var tank = new TankModel()
                                {
                                    ID = parts[0],
                                    Elev = float.Parse(parts[1]),
                                    InitLevel = initLevel,
                                    MinLevel = minLevel,
                                    MaxLevel = maxLevel,
                                    Diameter = diamter,
                                    MinVol = minVol,
                                    VolCurve = "",
                                    IsOverFlow = true
                                };
                                AddTank(tank);
                            }
                            break;
                        case "PIPES":
                            {
                                PipeModel p = new PipeModel();
                                p.ID = parts[0];
                                p.Node1 = parts[1];
                                p.Node2 = parts[2];
                                float length;
                                if (float.TryParse(parts[3], out length))
                                    p.Length = length;
                                float diameter;
                                if (float.TryParse(parts[4], out diameter))
                                    p.Diameter = diameter;
                                float roughness;
                                if (float.TryParse(parts[5], out roughness))
                                    p.Roughness = roughness;
                                float minorLoss;
                                if (float.TryParse(parts[6], out minorLoss))
                                    p.MinorLoss = minorLoss;
                                p.Status = parts.Length > 7 ? StatusType.CLOSED : StatusType.DEFAULT;
                                AddPipe(p);
                            }
                            break;
                        case "VALVES":
                            {
                                ValveModel valve = new ValveModel();
                                valve.ID = parts[0];

                                valve.Node1 = parts[1];
                                valve.Node2 = parts[2];

                                float diameter;
                                if (float.TryParse(parts[3], out diameter))
                                    valve.Diameter = diameter;
                                valve.Type = parts[4];
                                valve.CurvSetting = parts[5];
                                float minorLoss;
                                if (float.TryParse(parts[6], out minorLoss))
                                    valve.MinorLoss = minorLoss;
                                AddValve(valve);
                            }
                            break;
                        case "REPEATERS":
                            {

                            }
                            break;
                        case "COORDINATES":
                            {
                                string id = parts[0];
                                float x;
                                float y;
                                if (float.TryParse(parts[1], out x) && float.TryParse(parts[2], out y))
                                {
                                    points.Add(new Coor(id, new PointF(x, y)));
                                }
                            }
                            break;
                    }
                }
            }
            sr.Close();

            #region 坐标匹配方法
            #endregion



            #region 优化方案
            int k1 = 0;
            int k2 = 0;


            Nodes.Sort((a, b) => string.Compare(a.ID, b.ID));
            points.Sort((a, b) => string.Compare(a.ID, b.ID));
            k1 = 0;
            k2 = 0;
            while (k1 < Nodes.Count)
            {
                var J = Nodes[k1];
                var coor = points[k2];

                while (J.ID != coor.ID && k2 < points.Count)
                {
                    k2++;
                    if (k2 < points.Count) coor = points[k2];

                }
                if (k2 == points.Count)
                {
                    throw new Exception($"未找到Node[{J.ID}]的坐标");
                }
                J.X = coor.Position.X;
                J.Y = coor.Position.Y;

                k1++;
            }
            #endregion





            Links.Sort((a, b) => string.Compare(a.Node1, b.Node1));
            k1 = 0;
            k2 = 0;
            while (k2 < Links.Count)
            {
                var p = Links[k2];
                var J = Nodes[k1];
                while (J.ID != p.Node1 && k1 < Nodes.Count)
                {
                    k1++;
                    if (k1 < Nodes.Count) J = Nodes[k1];

                }
                if (k1 == Nodes.Count)
                {
                    throw new Exception($"未找到Link[{p.ID}]的起始节点[{p.Node1}]");
                }
                k2++;
            }



            Links.Sort((a, b) => string.Compare(a.Node2, b.Node2));
            k1 = 0;
            k2 = 0;
            while (k2 < Links.Count)
            {
                var p = Links[k2];
                var J = Nodes[k1];
                while (J.ID != p.Node2 && k1 < Nodes.Count)
                {
                    k1++;
                    if (k1 < Nodes.Count) J = Nodes[k1];
                }
                if (k1 == Nodes.Count)
                {
                    throw new Exception($"未找到Link[{p.ID}]的终止节点[{p.Node2}]");
                }
                k2++;
            }
            return true;
        }
    }



    public static string ReplaceCoordinatesSection(string text, string content, string str)
    {
        string pattern = $@"(\[{content}\]).*?(\[|$)";

        string replacedText = Regex.Replace(text, pattern, match =>
        {
            string section = match.Groups[2].Value.Trim();

            if (!string.IsNullOrEmpty(section))
            {
                return $"{match.Groups[1].Value}\n{str}\n[";
            }
            else
            {
                return $"{match.Groups[1].Value}\n{str}\n[";
            }
        }, RegexOptions.Singleline);

        return replacedText;
    }

}



public partial class MapViewNetWork : NetWork
{
    bool use_old = false;
    public string Name;
    private LinkViewModelList _links = new LinkViewModelList();
    public LinkViewModelList Links { get { return _links; } set { base.Links = _links = value; } }

    private NodeViewModelList _nodes = new NodeViewModelList();
    public NodeViewModelList Nodes { get { return _nodes; } set { base.Nodes = _nodes = value; } }

    private List<AreaViewModel> _areas = new List<AreaViewModel>();
    public List<AreaViewModel> Areas { get { return _areas; } set { _areas = value; } }

    public NodeViewModel StartPoint { get; set; }

    public NodeViewModel EndPoint { get; set; }

    public double[] getMinMax(ColourType colourType)
    {
        //根据当前选中的ColourType,判断是否有对应的网络数据

        double max = 0;
        double min = 0;

        switch (colourType)
        {
            case ColourType.节点自由压力:
                max = Nodes.Where(node => !(node is ReservoirViewModel || node is TankViewModel)).Max(node => node.EN_PRESSURE);
                min = Nodes.Where(node => !(node is ReservoirViewModel || node is TankViewModel)).Min(node => node.EN_PRESSURE);
                break;
            case ColourType.节点绝对压力:
                max = Nodes.Where(node => !(node is ReservoirViewModel || node is TankViewModel)).Max(node => node.EN_PRESSURE);
                min = Nodes.Where(node => !(node is ReservoirViewModel || node is TankViewModel)).Min(node => node.EN_PRESSURE);
                break;
            case ColourType.节点需水量:
                max = Nodes.Where(node => !(node is ReservoirViewModel || node is TankViewModel)).Max(node => node.EN_DEMAND);
                min = Nodes.Where(node => !(node is ReservoirViewModel || node is TankViewModel)).Min(node => node.EN_DEMAND);
                break;
            case ColourType.管线流量:
                max = Links.Max(link => link.EN_FLOW);
                min = Links.Min(link => link.EN_FLOW);
                break;
            case ColourType.管线流速:
                max = Links.Max(link => link.EN_VELOCITY);
                min = Links.Min(link => link.EN_VELOCITY);
                break;
            default:
                break;

        }
        return new double[] { min, max };
    }



    public Dictionary<string, Dataset> dict_dataset = new Dictionary<string, Dataset>();

    public HashSet<string> Hash_ID;


    public List<JunctionViewModel> junctions
    {
        get
        {
            return Nodes.FindAll(n => n is JunctionViewModel).Select(n => n as JunctionViewModel).ToList();
        }
        set
        {
            if (value == null) return;
            Nodes.RemoveAll(n => n is JunctionViewModel);
            Nodes.AddRange(value);
        }
    }


    public List<ReservoirViewModel> reservoirs
    {
        get
        {
            return Nodes.FindAll(n => n is ReservoirViewModel).Select(n => n as ReservoirViewModel).ToList();
        }
        set
        {
            if (value == null) return;
            Nodes.RemoveAll(n => n is ReservoirViewModel);
            Nodes.AddRange(value);
        }
    }

    public List<TankViewModel> tanks
    {
        get
        {
            return Nodes.FindAll(n => n is TankViewModel).Select(n => n as TankViewModel).ToList();
        }
        set
        {
            if (value == null) return;
            Nodes.RemoveAll(n => n is TankViewModel);
            Nodes.AddRange(value);
        }
    }

    public List<MeterViewModel> meters
    {
        get
        {
            return Nodes.FindAll(n => n is MeterViewModel).Select(n => n as MeterViewModel).ToList();

        }
        set
        {
            if (value == null) return;
            Nodes.RemoveAll(n => n is MeterViewModel);
            Nodes.AddRange(value);
        }
    }

    public List<NozzleViewModel> nozzles
    {
        get
        {
            return Nodes.FindAll(n => n is NozzleViewModel).Select(n => n as NozzleViewModel).ToList();

        }
        set
        {
            if (value == null) return;
            Nodes.RemoveAll(n => n is NozzleViewModel);
            Nodes.AddRange(value);
        }
    }


    public List<PipeViewModel> pipes
    {
        get
        {
            return Links.FindAll(n => n is PipeViewModel).Select(n => n as PipeViewModel).ToList();
        }
        set
        {
            if (value == null) return;
            Links.RemoveAll(n => n is PipeViewModel);
            Links.AddRange(value);
        }
    }

    public List<ValveViewModel> valves
    {
        get
        {
            return Links.FindAll(n => n is ValveViewModel).Select(n => n as ValveViewModel).ToList();
        }
        set
        {
            if (value == null) return;
            Links.RemoveAll(n => n is ValveViewModel);
            Links.AddRange(value);
        }
    }

    public List<ValveNodeViewModel> valveNodes
    {
        get
        {
            return Nodes.FindAll(n => n is ValveNodeViewModel).Select(n => n as ValveNodeViewModel).ToList();
        }
        set
        {
            if (value == null) return;
            Nodes.RemoveAll(n => n is ValveNodeViewModel);
            Nodes.AddRange(value);
        }
    }


    public List<RepeaterViewModel> repeaters
    {
        get
        {
            return Links.FindAll(n => n is RepeaterViewModel).Select(n => n as RepeaterViewModel).ToList();
        }
        set
        {
            if (value == null) return;
            Links.RemoveAll(n => n is RepeaterViewModel);
            Links.AddRange(value);
        }
    }

    public List<PumpViewModel> pumps
    {
        get
        {
            return Links.FindAll(n => n is PumpViewModel).Select(n => n as PumpViewModel).ToList();
        }
        set
        {
            if (value == null) return;
            Links.RemoveAll(n => n is PumpViewModel);
            Links.AddRange(value);
        }
    }

    public List<PumpNodeViewModel> pumpNodes
    {
        get
        {
            return Nodes.FindAll(n => n is PumpNodeViewModel).Select(n => n as PumpNodeViewModel).ToList();
        }
        set
        {
            if (value == null) return;
            Nodes.RemoveAll(n => n is PumpNodeViewModel);
            Nodes.AddRange(value);
        }
    }
    public List<JunctionViewModel> Deserialized_junctions { get; set; }
    public List<TankViewModel> Deserialized_tanks { get; set; }
    public List<ReservoirViewModel> Deserialized_reservoirs { get; set; }
    public List<MeterViewModel> Deserialized_meters { get; set; }
    public List<NozzleViewModel> Deserialized_nozzles { get; set; }
    public List<PipeViewModel> Deserialized_pipes { get; set; }
    public List<ValveViewModel> Deserialized_valves { get; set; }
    public List<ValveNodeViewModel> Deserialized_valveNodes { get; set; }
    public List<RepeaterViewModel> Deserialized_repeaters { get; set; }
    public List<PumpViewModel> Deserialized_pumps { get; set; }
    public List<PumpNodeViewModel> Deserialized_pumpNodes { get; set; }

    public List<AreaViewModel> areas = new List<AreaViewModel>();

    public bool ReadFromJson(string json)
    {
        try
        {
            var net = JsonConvert.DeserializeObject<MapViewNetWork>(json);
            junctions = net.Deserialized_junctions;
            tanks = net.Deserialized_tanks;
            reservoirs = net.Deserialized_reservoirs;
            meters = net.Deserialized_meters;
            nozzles = net.Deserialized_nozzles;
            pipes = net.Deserialized_pipes;
            valves = net.Deserialized_valves;
            valveNodes = net.Deserialized_valveNodes;
            repeaters = net.Deserialized_repeaters;
            pumps = net.Deserialized_pumps;
            pumpNodes = net.Deserialized_pumpNodes;
            StartPoint = net.StartPoint;
            EndPoint = net.EndPoint;
            return true;
        }
        catch
        {
            return false;
        }



    }
    public string WriteToJson()
    {
        var net = new MapViewNetWork();
        net.Deserialized_junctions = junctions;
        net.Deserialized_tanks = tanks;
        net.Deserialized_reservoirs = reservoirs;
        net.Deserialized_meters = meters;
        net.Deserialized_nozzles = nozzles;
        net.Deserialized_pipes = pipes;
        net.Deserialized_valves = valves;
        net.Deserialized_repeaters = repeaters;
        net.Deserialized_pumps = pumps;
        net.StartPoint = StartPoint;
        net.EndPoint = EndPoint;
        string json = JsonConvert.SerializeObject(net);
        return json;
    }


    public JunctionViewModel AddJunction(string ID, PointF position, float z = 0)
    {
        JunctionViewModel j = new JunctionViewModel();

        j.ID = ID;
        j.Demand = 0;
        j.PatternID = "";
        j.Elev = z;
        j.X = position.X;
        j.Y = position.Y;
        Nodes.Add(j);
        return j;
    }
    public JunctionViewModel AddJunction(PointF position, float z = 0)
    {
        JunctionViewModel j = new JunctionViewModel();
        int i = 0;
        string ID = $"{Default.GetPreString(j)}{i}";
        while (Nodes.Find(p0 => p0.ID == ID) != null)
        {
            i++;
            ID = $"{Default.GetPreString(j)}{i}";
        }
        j.ID = ID;
        j.Elev = 0;
        j.Demand = 0;
        j.PatternID = "";
        j.Elev = z;
        j.X = position.X;
        j.Y = position.Y;
        Nodes.Add(j);
        return j;
    }
    public MeterViewModel AddMeter(PointF position)
    {
        MeterViewModel j = new MeterViewModel();
        int i = 0;
        string ID = $"{Default.GetPreString(j)}{i}";
        while (Nodes.Find(p0 => p0.ID == ID) != null)
        {
            i++;
            ID = $"{Default.GetPreString(j)}{i}";
        }
        j.ID = ID;
        j.Elev = 0;
        j.Demand = 0;
        j.PatternID = "";

        j.X = position.X;
        j.Y = position.Y;
        Nodes.Add(j);

        return j;
    }
    public ReservoirViewModel AddReservoir(PointF position)
    {
        ReservoirViewModel j = new ReservoirViewModel();
        int i = 0;
        string ID = $"{Default.GetPreString(j)}{i}";
        while (Nodes.Find(p0 => p0.ID == ID) != null)
        {
            i++;
            ID = $"{Default.GetPreString(j)}{i}";
        }
        j.ID = ID;
        j.Elev = 0;
        j.Demand = 0;
        j.PatternID = "";
        j.Head = 100;
        j.X = position.X;
        j.Y = position.Y;
        Nodes.Add(j);

        return j;
    }
    public TankViewModel AddTank(PointF position)
    {
        TankViewModel j = new TankViewModel();
        int i = 0;
        string ID = $"{Default.GetPreString(j)}{i}";
        while (Nodes.Find(p0 => p0.ID == ID) != null)
        {
            i++;
            ID = $"{Default.GetPreString(j)}{i}";
        }
        j.ID = ID;
        j.Elev = 0;
        j.Demand = 0;
        j.PatternID = "";

        j.X = position.X;
        j.Y = position.Y;
        Nodes.Add(j);

        return j;
    }
    public PipeViewModel AddPipe(NodeViewModel node1, NodeViewModel node2)
    {
        PipeViewModel pipe = new PipeViewModel();
        int i = 0;
        string ID = $"{Default.GetPreString(pipe)}{i}";
        while (Links.Find(p0 => p0.ID == ID) != null)
        {
            i++;
            ID = $"{Default.GetPreString(pipe)}{i}";
        }
        pipe.ID = ID;
        pipe.Diameter = 100;
        pipe.MinorLoss = 0;
        pipe.Roughness = 100;
        pipe.Status = StatusType.DEFAULT;
        pipe.StartNode = node1;
        pipe.EndNode = node2;
        pipe.Length = -1;



        Links.Add(pipe);
        return pipe;
    }
    public ValveViewModel AddValve(NodeViewModel node1, NodeViewModel node2)
    {
        ValveViewModel valve = new ValveViewModel();
        int i = 0;
        string ID = $"{Default.GetPreString(valve)}{i}";
        while (Links.Find(p0 => p0.ID == ID) != null)
        {
            i++;
            ID = $"{Default.GetPreString(valve)}{i}";
        }
        valve.ID = ID;

        valve.Diameter = 100;
        valve.Status = StatusType.DEFAULT;
        valve.StartNode = node1;
        valve.EndNode = node2;

        Links.Add(valve);

        return valve;
    }
    public RepeaterViewModel AddRepeater(NodeViewModel node1, NodeViewModel node2)
    {
        RepeaterViewModel repeater = new RepeaterViewModel();
        int i = 0;
        string ID = $"{Default.GetPreString(repeater)}{i}";
        while (Links.Find(p0 => p0.ID == ID) != null)
        {
            i++;
            ID = $"{Default.GetPreString(repeater)}{i}";
        }
        repeater.ID = ID;


        repeater.StartNode = node1;
        repeater.EndNode = node2;

        Links.Add(repeater);

        return repeater;
    }
    public PumpViewModel AddPump(NodeViewModel node1, NodeViewModel node2)
    {
        PumpViewModel pump = new PumpViewModel();
        int i = 0;
        string ID = $"{Default.GetPreString(pump)}{i}";
        while (Links.Find(p0 => p0.ID == ID) != null)
        {
            i++;
            ID = $"{Default.GetPreString(pump)}{i}";
        }
        pump.ID = ID;


        pump.StartNode = node1;
        pump.EndNode = node2;

        Links.Add(pump);

        return pump;
    }

    public List<IBaseViewModel> Remove(List<IBaseViewModel> list)
    {

        List<IBaseViewModel> objs = new List<IBaseViewModel>();
        list.ForEach(o =>
        {
            if (o == null) return;
            o.Selected = false;
            if (o is NodeViewModel n)
            {
                n.Links.ForEach(l =>
        {
            if (this.Links.Remove(l)) objs.Add((LinkViewModel)l);
        });
                if (this.Nodes.Remove(n)) objs.Add(n);

            }
            else if (o is LinkViewModel l)
            {
                if (this.Links.Remove(l)) objs.Add(l);

            }
        });
        return objs;

    }

    public void ChangePoint(NodeViewModel source, NodeViewModel newPoint)
    {
        Links.ForEach(l =>
        {
            if (l.StartNode == source)
            {
                l.StartNode = newPoint;
            }
            else if (l.EndNode == source)
            {
                l.EndNode = newPoint;
            }

        });
        source.Visible = false;
    }
    public void ChangeNodeID(NodeViewModel node, string ID)
    {
        node.ID = ID;
        node.Links.ForEach(l =>
        {
            if (l.StartNode == node)
            {
                l.Node1 = node.ID;
            }
            else
            {
                l.Node2 = node.ID;
            }
        });
    }
    public string GetValidID(IBaseViewModel obj)
    {
        string DefaultString = Default.GetPreString(obj);
        int i = 0;
        string ID = obj.ID;
        ID = $"{DefaultString}{i}";
        while (Hash_ID.Contains(ID))
        {
            ID = $"{DefaultString}{i}";
            i++;
        }
        return ID;
    }

    public MapViewNetWork CreateNew(PointF3D basepoint)
    {
        MapViewNetWork net = this.DeepCopy<MapViewNetWork>();
        var BasePos = StartPoint.Position3D;

        net.Nodes.ForEach(n =>
        {
            n.X += basepoint.X - BasePos.X;
            n.Y += basepoint.Y - BasePos.Y;
            n.Elev += basepoint.Z - BasePos.Z;
        });

        return net;
    }

    public void AddJoinNet(MapViewNetWork network)
    {

        if (Nodes.Count == 0)
        {
            Nodes.AddRange(network.Nodes);
            Links.AddRange(network.Links);
            StartPoint = network.StartPoint;
            EndPoint = network.EndPoint;
        }
        else
        {

            ChangePoint(EndPoint, network.StartPoint);
            Nodes.AddRange(network.Nodes);
            Links.AddRange(network.Links);
            EndPoint = network.EndPoint;
        }
    }
    public List<IBaseViewModel> Add(MapViewNetWork net0, PointF3D offset = null, bool isCopy = false, NodeViewModel ConnectNode = null)
    {
        if (offset == null)
        {
            offset = new PointF3D(0, 0, 0);
        }
        List<IBaseViewModel> list = new List<IBaseViewModel>();
        if (Hash_ID == null) Hash_ID = new HashSet<string>();

        MapViewNetWork net = isCopy ? net0.DeepCopy() : net0;
        net.Nodes.ForEach(n0 =>
        {
            NodeViewModel n = (NodeViewModel)n0;
            if (Hash_ID.Contains(n.ID))
            {
                string ID = GetValidID(n);
                net.ChangeNodeID(n, ID);
            }
            n.X += offset.X;
            n.Y += offset.Y;
            n.Elev += offset.Z;
            Nodes.Add(n);
            Hash_ID.Add(n.ID);
            list.Add(n);
            if (n0 == net.EndPoint && list[0] != n)
            {
                int index = list.IndexOf(n);
                var o = list[0];
                list[0] = n;
                list[index] = o;
            }
        });
        net.Links.ForEach(l0 =>
        {
            LinkViewModel l = (LinkViewModel)l0;
            if (Hash_ID.Contains(l.ID))
            {
                string ID = GetValidID(l);
                l.ID = ID;
            }
            Links.Add(l);
            Hash_ID.Add(l.ID);
            list.Add(l);
        });
        if (ConnectNode != null)
        {
            var l = AddPipe(ConnectNode, net.StartPoint);
            list.Add(l);
            Hash_ID.Add(l.ID);
        }
        return list;
    }


    public void Add(List<IBaseViewModel> objects)
    {
        Nodes.AddRange(objects.FindAll(o => o is NodeViewModel).Select(o => (NodeViewModel)o));
        Links.AddRange(objects.FindAll(o => o is LinkViewModel).Select(o => (LinkViewModel)o));
    }

    public void Clear()
    {
        Nodes.Clear();
        Links.Clear();
    }


    public List<IBaseViewModel> MapObjects
    {
        get
        {
            List<BaseModel> objects = new List<BaseModel>();
            objects.AddRange(Nodes);
            objects.AddRange(Links);
            return objects.Select(o => (IBaseViewModel)o).ToList();
        }
    }
    public void Rename()
    {
        MapObjects.ForEach(o => o.ID = $"{Name}_{o.ID}");
    }
    public void Add(RepeaterViewModel repeater)
    {
        ChangePoint(repeater.StartNode, repeater.StartNode_inner);
        MoveDownNetwork(repeater);
        ChangePoint(repeater.EndNode, repeater.EndNode_inner);

        Nodes.AddRange(repeater.netList.Nodes);
        Links.AddRange(repeater.netList.Links);
    }
    public void LoadRepeaters(int MaxLevel, dict<string, dynamic> param, Dictionary<TemplateType, bool> viewModel, bool ViewMode = true)
    {


        repeaters.ForEach(r =>
        {

            if (!r.Load(MaxLevel, param, viewModel, ViewMode))
            {
                r.Status = RepeaterViewModel.RepeatStatus.收起;
                r.Visible = true;
            }

            else
            {
                Add(r);
                r.Visible = false;
            }


        });
    }

    public void MoveDownNetwork(RepeaterViewModel repeater)
    {
        visited = new Dictionary<NodeViewModel, bool>();
        visited.Add(repeater.StartNode, true);
        var p1 = repeater.EndNode_inner;
        var p2 = repeater.EndNode;
        PointF3D p = new PointF3D(p1.X - p2.X, p1.Y - p2.Y, p1.Elev - p2.Elev);
        BFS(this, repeater.EndNode, new Vector3(p.X, p.Y, p.Z));

    }


    // 定义 visited 字典记录已访问过的节点和待访问的节点队列
    Dictionary<NodeViewModel, bool> visited;
    private bool _isCalculated = false;

    public void BFS(MapViewNetWork net, NodeViewModel startNode, Vector3 vector)
    {

        Queue<NodeViewModel> queue = new Queue<NodeViewModel>();

        // 标记起始节点为已访问，并加入队列
        visited[startNode] = true;
        queue.Enqueue(startNode);

        // 不断从队列中取出节点进行访问，直到队列为空
        while (queue.Count > 0)
        {
            // 取出队首节点并输出
            NodeViewModel node = queue.Dequeue();
            node.Move(vector);


            // 遍历当前节点的所有未访问邻居节点，并标记为已访问
            foreach (LinkViewModel link in net.Links)
            {
                if (link.StartNode == node && !visited.ContainsKey(link.EndNode))
                {
                    visited[link.EndNode] = true;
                    queue.Enqueue(link.EndNode);

                }
                else if (link.EndNode == node && !visited.ContainsKey(link.StartNode))
                {
                    visited[link.StartNode] = true;
                    queue.Enqueue(link.StartNode);
                }
            }
        }
    }

    public List<NodeViewModel> GetNode(string node)
    {
        return Nodes.FindAll(n => n.ID == node).Select(n => (NodeViewModel)n).ToList();
    }


    public Dictionary<string, List<string>> CheckValidate()
    {
        BuildRelation();
        string result = null;
        Dictionary<string, List<string>> result_dict = new Dictionary<string, List<string>>();
        StringBuilder result_sb = new StringBuilder();
        //to-do
        var objs = Links.Select(o => o as LinkViewModel).ToList();//new List<LinkViewModel>() { Links[0] }; //Links.FindAll(o => o is LinkViewModel).Select(o => o as LinkViewModel).ToList();
                                                                  //objs去掉重复的元素
        objs = objs.Distinct().ToList();
        var visitedNodes = new HashSet<NodeViewModel>();
        FindObjs = new HashSet<IBaseViewModel>();
        objs.ForEach(o => TraversePipeNetworkALL(o, visitedNodes));
        List<string> list_孤立点 = new List<string>();
        for (int i = 0; i < Nodes.Count; i++)
        {
            if (!FindObjs.Contains(Nodes[i]))
            {
                result_sb.AppendLine($"节点{Nodes[i].ID}是孤立点");
                list_孤立点.Add(Nodes[i].ID);
            }

        }
        if (list_孤立点.Count > 0) result_dict.Add("孤立点", list_孤立点);
        //属性判断
        var list_管道连接关系异常 = new List<string>();
        var list_管道长度小于等于0 = new List<string>();
        var list_粗糙系数设置错误 = new List<string>();
        var list_管径设置错误 = new List<string>();

        pipes.ForEach(p =>
        {
            if (p.StartNode == null || p.EndNode == null)
            {
                result_sb.AppendLine($"{p.ID}管道连接关系异常");
                list_管道连接关系异常.Add(p.ID);
            }
            if (p.Length <= 0)
            {
                result_sb.AppendLine($"{p.ID}管道长度小于等于0");
                list_管道长度小于等于0.Add(p.ID);
            }
            if (p.Roughness <= 0.1 || p.Roughness > 10000)
            {
                result_sb.AppendLine($"{p.ID}粗糙系数设置错误");
                list_粗糙系数设置错误.Add(p.ID);
            }
            if (p.Diameter <= 0.1 || p.Diameter > 10000)
            {
                result_sb.AppendLine($"{p.ID}管径设置错误");
                list_管径设置错误.Add(p.ID);
            }

        });
        if (list_管道连接关系异常.Count > 0) result_dict.Add("管道连接关系异常", list_管道连接关系异常);
        if (list_管道长度小于等于0.Count > 0) result_dict.Add("管道长度小于等于0", list_管道长度小于等于0);
        if (list_粗糙系数设置错误.Count > 0) result_dict.Add("粗糙系数设置错误", list_粗糙系数设置错误);
        if (list_管径设置错误.Count > 0) result_dict.Add("管径设置错误", list_管径设置错误);
        return result_dict;



    }
    HashSet<IBaseViewModel> FindObjs;
    private void TraversePipeNetworkALL(LinkViewModel startLink, HashSet<NodeViewModel> visitedNodes = null, int direction = 0)
    {

        Queue<LinkViewModel> queue = new Queue<LinkViewModel>();



        queue.Enqueue(startLink);
        if (visitedNodes == null)
            visitedNodes = new HashSet<NodeViewModel>();

        while (queue.Count > 0)
        {
            LinkViewModel currentLink = queue.Dequeue();

            foreach (var node in new NodeViewModel[] { currentLink.StartNode, currentLink.EndNode })
            {
                if (direction == 1 && currentLink.EN_FLOW >= 0 && node == currentLink.StartNode) continue;
                if (direction == -1 && currentLink.EN_FLOW <= 0 && node == currentLink.EndNode) continue;
                if (node != null && !visitedNodes.Contains(node))
                {
                    visitedNodes.Add(node);
                    if (!FindObjs.Contains(node)) FindObjs.Add(node);

                    foreach (var link in node.ViewLinks)
                    {
                        if (!visitedNodes.Contains(link.StartNode) || !visitedNodes.Contains(link.EndNode))
                        {

                            if (!FindObjs.Contains(link)) FindObjs.Add(link);
                            queue.Enqueue(link);




                        }
                    }
                }
            }

        }



    }


    public void SetNodeDemand()
    {
        Nodes.ForEach(n =>
        {
            if (n is NodeViewModel node && node.Demand == 0)
            {
                node.Demand = 0.01f;
            }
            else if (n is MeterViewModel meter && meter.Demand == 0)
            {
                meter.Demand = 0.01f;
            }
            else if (n is NozzleViewModel nozzle && nozzle.Demand == 0)
            {
                nozzle.Demand = 0.01f;
            }
        });
    }
}


//构造一个List<LinkViewModel>类，能够实现List的所有功能

public class LinkViewModelList : List<LinkCalcModel>
{
    //List<LinkCalcModel> base;
    Dictionary<string, LinkViewModel> dict;//
    public LinkViewModelList() : base()
    {
        this.dict = new Dictionary<string, LinkViewModel>();
    }

    public List<LinkViewModel> ViewLinks
    {
        get
        {
            var list = new List<LinkViewModel>();
            base.ForEach(l =>
            {
                //if (l is LinkViewModel)
                list.Add((LinkViewModel)l);
            });
            return list;
            //return base.Select(l => (LinkViewModel)l).ToList();
        }
    }


    /// 实现Add方法，同时更新字典
    public void Add(LinkViewModel linkCalcModel)
    {
        base.Add(linkCalcModel);
        if (!dict.ContainsKey(linkCalcModel.ID))
            dict.Add(linkCalcModel.ID, linkCalcModel);
    }

    /// 实现AddRange方法，同时更新字典

    /// <param name="linkCalcModels"></param>
    public void AddRange(List<LinkViewModel> linkCalcModels)
    {
        base.AddRange(linkCalcModels);
        linkCalcModels.ForEach(link =>
        {
            if (!dict.ContainsKey(link.ID))
                dict.Add(link.ID, link);
        });
    }


    public LinkViewModel this[string ID]
    {
        get
        {
            if (dict.ContainsKey(ID))
                return dict[ID];
            else
                return (LinkViewModel)base.Find(l => l.ID == ID);
        }
    }
    public LinkViewModel this[int index]
    {
        get
        {
            return (LinkViewModel)base[index];
        }
    }

    public void Sort()
    {
        base.Sort();
    }
    public void Sort(Comparison<LinkCalcModel> comparison)
    {
        base.Sort(comparison);
    }

    public void Select(Action<LinkViewModel> action)
    {
        ViewLinks.ForEach(action);
    }
    //实现Find方法
    public LinkViewModel Find(Predicate<LinkViewModel> match)
    {
        //base.Find(match);
        return ViewLinks.Find(match);
    }
    //实现FindAll方法
    public List<LinkViewModel> FindAll(Predicate<LinkViewModel> match)
    {
        return ViewLinks.FindAll(match);
    }
    //实现ForEach方法
    public void ForEach(Action<LinkViewModel> action)
    {
        ViewLinks.ForEach(action);
    }
    //实现RemoveAll方法
    public int RemoveAll(Predicate<LinkCalcModel> match)
    {
        return base.RemoveAll(match);
    }

    /// 实现Remove方法，同时更新字典

    public bool Remove(LinkViewModel linkCalcModel)
    {
        if (base.Remove(linkCalcModel))
        {
            if (dict.ContainsKey(linkCalcModel.ID))
                dict.Remove(linkCalcModel.ID);
            return true;
        }
        else
            return false;
    }


}

public class NodeViewModelList : List<NodeCalcModel>
{
    Dictionary<string, NodeCalcModel> dict;
    public NodeViewModelList() : base()
    {
        this.dict = new Dictionary<string, NodeCalcModel>();
    }


    public void ChangeID(string oldID, string newID)
    {
        if (dict.ContainsKey(oldID))
        {
            dict[oldID].ID = newID;
            dict.Add(newID, dict[oldID]);
            dict.Remove(oldID);
        }
    }

    /// 实现Add方法，同时更新字典
    public void Add(NodeViewModel nodeCalcModel)
    {
        base.Add(nodeCalcModel);
        if (!dict.ContainsKey(nodeCalcModel.ID))
            dict.Add(nodeCalcModel.ID, nodeCalcModel);
    }

    /// 实现AddRange方法，同时更新字典
    /// <param name="nodeCalcModels"></param>
    public void AddRange(List<NodeViewModel> nodeCalcModels)
    {
        base.AddRange(nodeCalcModels);
        nodeCalcModels.ForEach(node =>
        {
            if (!dict.ContainsKey(node.ID))
                dict.Add(node.ID, node);
        });
    }

    /// 实现Remove方法，同时更新字典
    public bool Remove(NodeViewModel nodeCalcModel)
    {
        if (base.Remove(nodeCalcModel))
        {
            if (dict.ContainsKey(nodeCalcModel.ID))
                dict.Remove(nodeCalcModel.ID);
            return true;
        }
        else
            return false;
    }


    /// 统计数量
    public int Count { get { return base.Count; } }
    public NodeViewModel this[string ID]
    {
        get
        {
            if (dict.ContainsKey(ID))
                return (NodeViewModel)dict[ID];
            else
                return (NodeViewModel)base.Find(l => l.ID == ID);
        }
    }
    public NodeViewModel this[int index]
    {
        get
        {
            return (NodeViewModel)base[index];
        }
    }

    public List<NodeViewModel> ViewNodes
    {
        get
        {
            List<NodeViewModel> list = new List<NodeViewModel>();
            foreach (var item in this)
            {
                list.Add((NodeViewModel)item);
            }
            return list;
        }

    }



    public NodeViewModel Find(Predicate<NodeViewModel> match)
    {
        return ViewNodes.Find(match);
    }
    //实现FindAll方法
    public List<NodeViewModel> FindAll(Predicate<NodeViewModel> match)
    {
        return ViewNodes.FindAll(match);
    }
    //实现ForEach方法
    public void ForEach(Action<NodeViewModel> action)
    {
        ViewNodes.ForEach(action);
    }


}


public partial class MapViewNetWork
{
    public bool BuildFromInp(string filePath, bool use_old = false)
    {
        this.use_old = use_old;
        if (this.use_old)
        {
            return loadInpFile_old(filePath);
        }
        if (filePath == null || !File.Exists(filePath)) return false;
        List<Coor> points = new List<Coor>();
        dict_dataset = new Dictionary<string, Dataset>();
        StreamReader sr = new StreamReader(filePath);

        {
            Nodes = new NodeViewModelList();
            Links = new LinkViewModelList();

            string line;
            string section = "";
            while ((line = sr.ReadLine()) != null)
            {
                if (line.Trim().StartsWith("["))
                {
                    section = line.TrimStart('[').TrimEnd(']');
                }
                else
                {
                    string s = line.Trim('\t').Trim(' ');
                    if (s.Length == 0 || s[0] == ';') continue;
                    Parts parts = new Parts(line);
                    section = section.ToUpper();
                    IBaseViewModel o = null;
                    switch (section)
                    {
                        case "JUNCTIONS":
                            {
                                NodeViewModel j = null;
                                if (parts[-2] == "Meter")
                                {
                                    var m = new MeterViewModel();
                                    j = m;
                                }
                                else if (parts[-2] == "Nozzle")
                                {
                                    var n = new NozzleViewModel();
                                    j = n;
                                    n.FlowCoefficient = parts.ToFloat(-4, 0);
                                }
                                else
                                    j = new JunctionViewModel();

                                o = j;
                                j.ID = parts.ToString(0, null);
                                j.Elev = parts.ToFloat(1, 0);
                                j.Demand = parts.ToFloat(2, 0);
                                j.PatternID = parts.ToString(3, null);
                                if (j.PatternID == "NONE") j.PatternID = null;
                                j.Level = parts.ToInt(-1, 0);

                                Nodes.Add(j);
                            }
                            break;

                        case "RESERVOIRS":
                            {
                                ReservoirViewModel r = new ReservoirViewModel();
                                o = r;
                                r.ID = parts.ToString(0, null);
                                r.Head = parts.ToFloat(1, 0);
                                r.PatternID = parts.ToString(2, null);
                                r.Level = parts.ToInt(-1, 0);
                                r.Elev = parts.ToFloat(-2, 0);
                                Nodes.Add(r);
                            }
                            break;

                        case "TANKS":
                            {
                                TankViewModel tank = new TankViewModel();
                                o = tank;
                                tank.ID = parts.ToString(0, null);
                                tank.Elev = parts.ToFloat(1, 0);
                                tank.InitLevel = parts.ToFloat(2, 0);
                                tank.MinLevel = parts.ToFloat(3, 0);
                                tank.MaxLevel = parts.ToFloat(4, 0);
                                tank.Diameter = parts.ToFloat(5, 0);
                                tank.MinVol = parts.ToFloat(6, 0);
                                tank.VolCurve = parts.ToString(7, null);
                                tank.Overflow = "";
                                tank.Level = parts.ToInt(-1, 0);
                                Nodes.Add(tank);
                            }
                            break;

                        case "PIPES":
                            {
                                if (parts[-2] == "Repeater")
                                {
                                    RepeaterViewModel repeater = new RepeaterViewModel();
                                    o = repeater;
                                    repeater.ID = parts.ToString(0, null);
                                    repeater.Node1 = parts.ToString(1, null);
                                    repeater.Node2 = parts.ToString(2, null);
                                    repeater.Length = parts.ToFloat(3, 0.1f);
                                    repeater.Diameter = parts.ToFloat(4, 150f);
                                    repeater.Roughness = parts.ToFloat(5, 100f);
                                    repeater.MinorLoss = parts.ToFloat(6, 0);
                                    repeater.Level = parts.ToInt(-1, 0);
                                    repeater.TemplateID = parts.ToString(-3, null);
                                    repeater.RepeatTimes = parts.ToInt(-4, 1);
                                    RepeatStatus status;
                                    if (Enum.TryParse(parts[-5], out status))
                                        repeater.Status = status;
                                    repeater.NetworkPreName = parts.ToString(-6, null);
                                    repeater.NetworkPreStartNum = parts.ToInt(-7, 0);
                                    repeater.NetworkIsAscNum = parts.ToBool(-8, false);
                                    repeater.NetworkShowName = parts.ToString(-9, null);

                                    Links.Add(repeater);
                                }
                                else
                                {
                                    PipeViewModel p = new PipeViewModel();
                                    o = p;
                                    p.ID = parts.ToString(0, null);
                                    p.Node1 = parts.ToString(1, null);
                                    p.Node2 = parts.ToString(2, null);
                                    p.Length = parts.ToFloat(3, 0.1f);
                                    p.Diameter = parts.ToFloat(4, 150f);
                                    p.Roughness = parts.ToFloat(5, 100f);
                                    p.MinorLoss = parts.ToFloat(6, 0);
                                    p.Status = StringToStatus(parts.ToString(7, "OPEN"));

                                    p.Level = parts.ToInt(-1, 0);
                                    Links.Add(p);
                                }
                            }
                            break;

                        case "VALVES":
                            {
                                ValveViewModel valve = new ValveViewModel();
                                o = valve;
                                valve.ID = parts.ToString(0, null);

                                valve.Node1 = parts.ToString(1, null);
                                valve.Node2 = parts.ToString(2, null);
                                valve.Diameter = parts.ToFloat(3, 0);
                                valve.Type = parts.ToString(4, null);
                                valve.Setting = parts.ToString(5, null);
                                valve.MinorLoss = parts.ToFloat(6, 0);
                                valve.Level = parts.ToInt(-1, 0);
                                Links.Add(valve);
                            }
                            break;

                        case "PUMPS":
                            {
                                PumpViewModel pump = new PumpViewModel();
                                o = pump;
                                pump.ID = parts.ToString(0, null);

                                pump.Node1 = parts.ToString(1, null);
                                pump.Node2 = parts.ToString(2, null);
                                int index = 3;
                                string label = null;
                                while ((label = parts.ToString(index, null)) != null)
                                {
                                    label = label.ToUpper();
                                    switch (label)
                                    {
                                        case "HEAD":
                                            pump.HeadCurve = parts.ToString(index + 1, "PumpDefault");
                                            break;

                                        case "SPEED":
                                            pump.当前转速 = parts.ToFloat(index + 1, 0);
                                            break;
                                    }
                                    index += 2;
                                }

                                pump.Level = parts.ToInt(-1, 0);
                                Links.Add(pump);
                            }
                            break;

                        case "CURVES":
                            {
                                string ID = parts.ToString(0, "");
                                if (!dict_dataset.ContainsKey(ID))
                                {
                                    var ds = new Dataset(ID, null);
                                    dict_dataset.Add(ID, ds);
                                }
                                dict_dataset[ID]._data.Add(new PointF(parts.ToFloat(1, 0), parts.ToFloat(2, 0)));
                            }
                            break;

                        case "COORDINATES":
                            {
                                string id = parts[0];
                                float x;
                                float y;
                                if (float.TryParse(parts[1], out x) && float.TryParse(parts[2], out y))
                                {
                                    points.Add(new Coor(id, new PointF(x, y)));
                                }
                            }
                            break;

                        case "STATUS":
                            {
                                LinkViewModel link = Links.Find(l => l.ID == parts.ToString(0, null));
                                if (link != null)
                                    link.Status = StringToStatus(parts.ToString(1, "OPEN"));
                            }
                            break;
                    }
                    if (o != null)
                    {
                        o.Tags = new TagList(parts.ToString(-3, null));
                    }
                }
            }
            sr.Close();

            if (!dict_dataset.ContainsKey("GPVDefault"))
            {
                var data = new Dataset("GPVDefault", null);
                data.Data = new List<PointF>()
{
new PointF(0,0),
new PointF(100,0),
};
                dict_dataset.Add("GPVDefault", data);
            }
            if (!dict_dataset.ContainsKey("PumpDefault"))
            {
                var data = new Dataset("PumpDefault", null);
                data.Data = new List<PointF>()
{
new PointF(0f, 45.38f),
new PointF(83.33333333f ,45.25f),
new PointF(111.1111111f ,45.12f),
new PointF(138.8888889f ,44.96f),
new PointF(166.6666667f ,44.76f),
new PointF(194.4444444f ,44.52f),
new PointF(222.2222222f ,44.24f),
new PointF(250f ,43.92f),
new PointF(277.7777778f ,43.56f),
new PointF(305.5555556f ,43.17f),
new PointF(333.3333333f ,42.73f),
new PointF(361.1111111f ,42.25f),
new PointF(388.8888889f ,41.74f),
new PointF(416.6666667f ,41.18f),
new PointF(444.4444444f ,40.58f),
new PointF(472.2222222f ,39.95f),
new PointF(500f ,39.28f),
new PointF(527.7777778f ,38.56f),
new PointF(555.5555556f ,37.81f),
new PointF(583.3333333f ,37.02f),
new PointF(611.1111111f ,36.19f),
new PointF(638.8888889f ,35.32f),
new PointF(666.6666667f ,34.41f),
new PointF(694.4444444f ,33.46f),
new PointF(722.2222222f ,32.47f),
new PointF(750f ,31.44f),
new PointF(777.7777778f ,30.37f),
new PointF(805.5555556f ,29.27f),
};
                dict_dataset.Add("PumpDefault", data);
            }

            //读取坐标
            int k1 = 0;
            int k2 = 0;
            Nodes.Sort((a, b) => string.Compare(a.ID, b.ID));
            points.Sort((a, b) => string.Compare(a.ID, b.ID));
            k1 = 0;
            k2 = 0;
            while (k1 < Nodes.Count)
            {
                var J = Nodes[k1];
                var coor = points[k2];

                while (J.ID != coor.ID && k2 < points.Count)
                {
                    k2++;
                    if (k2 < points.Count) coor = points[k2];
                }
                if (k2 == points.Count)
                {
                    throw new Exception($"未找到Node[{J.ID}]的坐标");
                }
                J.X = coor.Position.X;
                J.Y = coor.Position.Y;

                k1++;
            }

            BuildRelation();

            return true;
        }
    }

    private StatusType StringToStatus(string status)
    {
        switch (status)
        {
            case "CLOESD":
            case "0":
                return StatusType.CLOSED;

            case "OPEN":
            case "1":
                return StatusType.OPEN;

            case "ACTIVE":
                return StatusType.ACTIVE;

            default:
                return StatusType.DEFAULT;
        }
    }

    public void BuildRelation()
    {
        //读取坐标
        int k1 = 0;//表示管线索引
        int k2 = 0;//表示节点索引
        Nodes.Sort((a, b) => string.Compare(a.ID, b.ID));



        Links.Sort((a, b) => string.Compare(a.Node1, b.Node1));
        k2 = 0;
        k1 = 0;
        while (k1 < Links.Count)
        {
            var p = Links[k1];
            var J = Nodes[k2];
            var k0 = k2;
            while (J.ID != p.Node1 && k2 < Nodes.Count)
            {
                k2++;
                if (k2 < Nodes.Count) J = Nodes[k2];
            }
            if (k2 == Nodes.Count)
            {
                k2 = k0;
                k1++;
                p.Visible = false;
                continue;
                //throw new Exception($"未找到Link[{p.ID}]的起始节点[{p.Node1}]");
            }
            p.StartNode = J;
            p.Node1 = J.ID;
            if (J.MaxDiameter < p.Diameter) J.MaxDiameter = p.Diameter;
            J.Links.Add(p);
            k1++;
        }



        Links.Sort((a, b) => string.Compare(a.Node2, b.Node2));
        k2 = 0;
        k1 = 0;
        while (k1 < Links.Count)
        {
            var p = Links[k1];
            var J = Nodes[k2];
            var k0 = k2;
            while (J.ID != p.Node2 && k2 < Nodes.Count)
            {
                k2++;
                if (k2 < Nodes.Count) J = Nodes[k2];
            }
            if (k2 == Nodes.Count)
            {
                k2 = k0;
                k1++;
                p.Visible = false;

                continue;
            }
            p.EndNode = J;
            p.Node2 = J.ID;
            if (J.MaxDiameter < p.Diameter) J.MaxDiameter = p.Diameter;
            J.Links.Add(p);
            k1++;
        }

        foreach (ValveNodeViewModel vn in valveNodes.ToList())
        {
            if (vn.Links.Count != 2) continue;

            var junc1 = AddJunction("S__" + vn.ID, vn.Position, vn.Elev);
            if (vn.Links[0].StartNode.ID == vn.ID)
            {
                vn.Links[0].StartNode = junc1;
            }
            else
            {
                vn.Links[0].EndNode = junc1;
            }
            junc1.Links.Add(vn.Links[0]);

            var junc2 = AddJunction("E__" + vn.ID, vn.Position, vn.Elev);
            if (vn.Links[1].StartNode.ID == vn.ID)
            {
                vn.Links[1].StartNode = junc2;
            }
            else
            {
                vn.Links[1].EndNode = junc2;
            }
            junc2.Links.Add(vn.Links[1]);
            ValveViewModel valve = AddValve(junc1, junc2);

            valve.ID = vn.ID;
            valve.Status = vn.Status;
            junc1.Links.Add(valve);
            junc2.Links.Add(valve);
            Nodes.Remove(vn);
        }

        foreach (PumpNodeViewModel pn in pumpNodes.ToList())
        {
            if (pn.Links.Count != 2) continue;
            if (pn.Links[0].ID != pn.Node1)
            {
                LinkViewModel temp0 = pn.Links[0] as LinkViewModel;
                pn.Links.RemoveAt(0);
                pn.Links.Add(temp0);
            }
            var junc1 = AddJunction("S__" + pn.ID, pn.Position, pn.Elev);
            if (pn.Links[0].StartNode.ID == pn.ID)
            {
                pn.Links[0].StartNode = junc1;
            }
            else
            {
                pn.Links[0].EndNode = junc1;
            }
            junc1.Links.Add(pn.Links[0]);

            var junc2 = AddJunction("E__" + pn.ID, pn.Position, pn.Elev);
            if (pn.Links[1].StartNode.ID == pn.ID)
            {
                pn.Links[1].StartNode = junc2;
            }
            else
            {
                pn.Links[1].EndNode = junc2;
            }
            junc2.Links.Add(pn.Links[1]);
            PumpViewModel pump = AddPump(junc1, junc2);
            pump.Status = pn.Status;
            pump.ID = pn.ID;
            pump.额定功率 = pn.额定功率;
            pump.额定扬程 = pn.额定扬程;
            pump.额定流量 = pn.额定流量;
            pump.HeadCurve = pn.HeadCurve;
            pump.额定转速 = pn.额定转速;
            pump.转速比 = pn.转速比;
            junc1.Links.Add(pump);
            junc2.Links.Add(pump);
            Nodes.Remove(pn);
        }
        if (dict_dataset == null)
        {
            dict_dataset = new Dictionary<string, Dataset>();
        }
        pumps.ForEach(p =>
        {
            foreach (var kp in p.Datasets)
            {
                if (!dict_dataset.ContainsKey(kp.Value.Name))
                {
                    dict_dataset.Add(kp.Value.Name, kp.Value);
                }
            }
        });
        pumps.ForEach((pump) =>
        {
            if (dict_dataset.ContainsKey(pump.HeadCurve))
            {
                Dataset ds = dict_dataset[pump.HeadCurve];

                if (!pump.Datasets.ContainsKey("流量扬程曲线"))
                {
                    pump.Datasets.Add("流量扬程曲线", ds);
                }
                else
                {
                    pump.Datasets["流量扬程曲线"] = ds;
                }
                ds.pump = pump;
            }

            if (!pump.Datasets.ContainsKey("流量扬程曲线"))
            {
                pump.Datasets.Add("流量扬程曲线", new Dataset(pump.ID + "_Head", pump));
            }
            if (pump.Datasets["流量扬程曲线"].Data.Count <= 0)
            {
                pump.Datasets["流量扬程曲线"].Data.Add(new PointF((float)pump.额定流量, (float)pump.额定扬程));
            }
            pump.HeadCurve = pump.Datasets["流量扬程曲线"].Name;
        });


        Hash_ID = new HashSet<string>();
        Nodes.ForEach(o => Hash_ID.Add(o.ID));
        Links.ForEach(o => Hash_ID.Add(o.ID));
    }

    public bool loadInpFile_old(string filePath)
    {
        if (filePath == null || !File.Exists(filePath)) return false;
        List<Coor> points = new List<Coor>();
        StreamReader sr = new StreamReader(filePath);

        {
            Nodes = new NodeViewModelList();


            Links = new LinkViewModelList();

            string line;
            string section = "";
            while ((line = sr.ReadLine()) != null)
            {
                if (line.Trim().StartsWith("["))
                {
                    section = line.TrimStart('[').TrimEnd(']');
                }
                else
                {
                    string s = line.Trim('\t').Trim(' ');
                    if (s.Length == 0 || s[0] == ';') continue;
                    line = line.Replace("\t\t", "\t_\t").Replace("\t \t", "\t_\t");
                    Parts parts = new Parts(line.Split(new char[] {
'\t', ' ', ';'
}, StringSplitOptions.RemoveEmptyEntries));
                    switch (section)
                    {
                        case "JUNCTIONS":
                            {
                                NodeViewModel j = null;
                                if (parts[4] == "Meter")
                                {
                                    j = new MeterViewModel();
                                    meters.Add((MeterViewModel)j);
                                }
                                else if (parts[4] == "Nozzle")
                                    j = new NozzleViewModel();
                                else
                                    j = new JunctionViewModel();

                                j.ID = parts[0];
                                float elev;
                                if (float.TryParse(parts[1], out elev))
                                    j.Elev = elev;
                                float demand;
                                if (float.TryParse(parts[2], out demand))
                                    j.Demand = demand;
                                j.PatternID = parts[3];
                                int level;
                                if (int.TryParse(parts[5], out level))
                                    j.Level = level;

                                Nodes.Add(j);
                            }
                            break;

                        case "RESERVOIRS":
                            {
                                ReservoirViewModel r = new ReservoirViewModel();
                                r.ID = parts[0];
                                float head;
                                if (float.TryParse(parts[1], out head))
                                    r.Head = head;
                                r.PatternID = parts.Length > 2 ? parts[2] : "";
                                int level;
                                if (int.TryParse(parts[3], out level))
                                    r.Level = level;
                                Nodes.Add(r);
                            }
                            break;

                        case "TANKS":
                            {
                                TankViewModel tank = new TankViewModel(parts[0], parts[1], parts[2], parts[3], parts[4], parts[5], parts[6], parts[7], parts[8]);
                                int level;
                                if (int.TryParse(parts[9], out level))
                                    tank.Level = level;
                                Nodes.Add(tank);
                            }
                            break;

                        case "PIPES":
                            {
                                PipeViewModel p = new PipeViewModel();
                                p.ID = parts[0];
                                p.Node1 = parts[1];
                                p.Node2 = parts[2];
                                float length;
                                if (float.TryParse(parts[3], out length))
                                    p.Length = length;
                                float diameter;
                                if (float.TryParse(parts[4], out diameter))
                                    p.Diameter = diameter;
                                float roughness;
                                if (float.TryParse(parts[5], out roughness))
                                    p.Roughness = roughness;
                                float minorLoss;
                                if (float.TryParse(parts[6], out minorLoss))
                                    p.MinorLoss = minorLoss;
                                p.Status = parts.Length > 7 ? StringToStatus(parts[7]) : StatusType.DEFAULT;
                                int level;
                                if (int.TryParse(parts[8], out level))
                                    p.Level = level;
                                Links.Add(p);
                            }
                            break;

                        case "VALVES":
                            {
                                ValveViewModel valve = new ValveViewModel();
                                valve.ID = parts[0];

                                valve.Node1 = parts[1];
                                valve.Node2 = parts[2];

                                float diameter;
                                if (float.TryParse(parts[3], out diameter))
                                    valve.Diameter = diameter;
                                valve.Type = parts[4];
                                valve.Setting = parts[5];
                                float minorLoss;
                                if (float.TryParse(parts[6], out minorLoss))
                                    valve.MinorLoss = minorLoss;
                                int level;
                                if (int.TryParse(parts[7], out level))
                                    valve.Level = level;
                                Links.Add(valve);
                            }
                            break;

                        case "REPEATERS":
                            {
                                RepeaterViewModel repeater = new RepeaterViewModel();
                                repeater.ID = parts[0];
                                repeater.Node1 = parts[1];
                                repeater.Node2 = parts[2];
                                repeater.TemplateID = parts[3];
                                int repeatTimes;
                                if (int.TryParse(parts[4], out repeatTimes))
                                    repeater.RepeatTimes = repeatTimes;
                                RepeatStatus status;
                                if (Enum.TryParse(parts[5], out status))
                                    repeater.Status = status;
                                repeater.NetworkPreName = parts[6];
                                int networkPreStartNum;
                                if (int.TryParse(parts[7], out networkPreStartNum))
                                    repeater.NetworkPreStartNum = networkPreStartNum;
                                bool networkIsAscNum;
                                if (bool.TryParse(parts[8], out networkIsAscNum))
                                    repeater.NetworkIsAscNum = networkIsAscNum;
                                repeater.NetworkShowName = parts[9];
                                int level;
                                if (int.TryParse(parts[10], out level))
                                    repeater.Level = level;
                                Links.Add(repeater);
                            }
                            break;

                        case "COORDINATES":
                            {
                                string id = parts[0];
                                float x;
                                float y;
                                if (float.TryParse(parts[1], out x) && float.TryParse(parts[2], out y))
                                {
                                    points.Add(new Coor(id, new PointF(x, y)));
                                }
                            }
                            break;
                    }
                }
            }
            sr.Close();

            //读取坐标
            int k1 = 0;
            int k2 = 0;
            Nodes.Sort((a, b) => string.Compare(a.ID, b.ID));
            points.Sort((a, b) => string.Compare(a.ID, b.ID));
            k1 = 0;
            k2 = 0;
            while (k1 < Nodes.Count)
            {
                var J = Nodes[k1];
                var coor = points[k2];

                while (J.ID != coor.ID && k2 < points.Count)
                {
                    k2++;
                    if (k2 < points.Count) coor = points[k2];
                }
                if (k2 == points.Count)
                {
                    throw new Exception($"未找到Node[{J.ID}]的坐标");
                }
                J.X = coor.Position.X;
                J.Y = coor.Position.Y;

                k1++;
            }



            Links.Sort((a, b) => string.Compare(a.Node1, b.Node1));
            k1 = 0;
            k2 = 0;
            while (k2 < Links.Count)
            {
                var p = Links[k2];
                var J = Nodes[k1];
                while (J.ID != p.Node1 && k1 < Nodes.Count)
                {
                    k1++;
                    if (k1 < Nodes.Count) J = Nodes[k1];
                }
                if (k1 == Nodes.Count)
                {
                    throw new Exception($"未找到Link[{p.ID}]的起始节点[{p.Node1}]");
                }
                p.StartNode = J;
                if (J.MaxDiameter < p.Diameter) J.MaxDiameter = p.Diameter;
                J.Links.Add(p);
                k2++;
            }



            Links.Sort((a, b) => string.Compare(a.Node2, b.Node2));
            k1 = 0;
            k2 = 0;
            while (k2 < Links.Count)
            {
                var p = Links[k2];
                var J = Nodes[k1];
                while (J.ID != p.Node2 && k1 < Nodes.Count)
                {
                    k1++;
                    if (k1 < Nodes.Count) J = Nodes[k1];
                }
                if (k1 == Nodes.Count)
                {
                    throw new Exception($"未找到Link[{p.ID}]的终止节点[{p.Node2}]");
                }
                p.EndNode = J;
                if (J.MaxDiameter < p.Diameter) J.MaxDiameter = p.Diameter;
                J.Links.Add(p);
                k2++;
            }

            return true;
        }
    }

    public void ClearMinorLoss()
    {
        Links.ForEach(l => l.MinorLoss = 0);
    }

    public void CalcLinkMinorLoss()
    {
        Links.ForEach(l => l.MinorLoss = 0);
        Nodes.ForEach(n =>
        {
            var links_Down = n.ViewLinks.FindAll(l => l.StartNode == n ? l.EN_FLOW > 0 : l.EN_FLOW < 0);
            var links_Up = n.ViewLinks.FindAll(l => l.StartNode == n ? l.EN_FLOW < 0 : l.EN_FLOW > 0);
            /*两侧均连接一个管线*/
            if (links_Down.Count == 1 && links_Up.Count == 1)
            {
                var link_Down = links_Down[0];
                var link_Up = links_Up[0];
                double angle = GetAngle(link_Down, link_Up);
                var minorLoss = 0f;
                minorLoss += GetMinorLossByAngle(angle);
                minorLoss += GetChangeDiameterMinorLoss(link_Down, link_Up);
                link_Up.MinorLoss += minorLoss;
            }
            /*上游管线为1根，下游管线为多个*/
            if (links_Up.Count == 1 && links_Down.Count > 1)
            {
                var link_Up = links_Up[0];

                //计算两个管线的夹角，根据夹角计算损失系数
                foreach (var link_Down in links_Down)
                {
                    var angle = GetAngle(link_Down, link_Up);
                    var minorLoss = 0f;
                    minorLoss += GetMinorLossByAngle(angle);
                    minorLoss += GetChangeDiameterMinorLoss(link_Down, link_Up);
                    link_Down.MinorLoss += minorLoss;
                }
            }

            /*下游管线为1根，上游管线为多个*/
            if (links_Up.Count > 1 && links_Down.Count == 1)
            {
                var link_Down = links_Down[0];

                //计算两个管线的夹角，根据夹角计算损失系数
                foreach (var link_Up in links_Up)
                {
                    var angle = GetAngle(link_Down, link_Up);
                    var minorLoss = 0f;
                    minorLoss += GetMinorLossByAngle(angle);
                    minorLoss += GetChangeDiameterMinorLoss(link_Down, link_Up);
                    link_Up.MinorLoss += minorLoss;
                }
            }

            /*下游管线为多个，上游管线为多个*/
            if (links_Up.Count > 1 && links_Down.Count > 1)
            {
                var UpCount = links_Up.Count;

                //计算两个管线的夹角，根据夹角计算损失系数
                foreach (var link_Up in links_Up)
                {
                    foreach (var link_Down in links_Down)
                    {
                        var angle = GetAngle(link_Down, link_Up);
                        var minorLoss = 0f;
                        minorLoss += GetMinorLossByAngle(angle);
                        minorLoss += GetChangeDiameterMinorLoss(link_Down, link_Up);
                        link_Up.MinorLoss += minorLoss / UpCount;
                    }
                }
            }
        });
    }

    private static float GetChangeDiameterMinorLoss(LinkViewModel link_Down, LinkViewModel link_Up)
    {
        var Diameter_Down = link_Down.Diameter;
        var Diameter_Up = link_Up.Diameter;
        //计算两个管线变径的损失系数
        var minorLoss = 0f;
        if (Diameter_Down >= Diameter_Up)//突然变粗
        {
            minorLoss = (float)Math.Pow(1 - Diameter_Up / Diameter_Down, 2);
        }
        else//突然变细
        {
            minorLoss = 0.5f * (1 - Diameter_Down / Diameter_Up);
        }

        return minorLoss;
    }

    private static double GetAngle(LinkViewModel link_Down, LinkViewModel link_Up)
    {
        //两个管线link_Down,link_Up的向量
        Vector3D vector_Down = new Vector3D(link_Down.EndNode.X - link_Down.StartNode.X, link_Down.EndNode.Y - link_Down.StartNode.Y, link_Down.EndNode.Elev - link_Down.StartNode.Elev);
        Vector3D vector_Up = new Vector3D(link_Up.EndNode.X - link_Up.StartNode.X, link_Up.EndNode.Y - link_Up.StartNode.Y, link_Up.EndNode.Elev - link_Up.StartNode.Elev);
        //获取两个向量vector_Down,vector_Up的空间夹角
        if (vector_Down.Length == 0 || vector_Up.Length == 0) return 0;
        else
            return Vector3D.CalculateAngle(vector_Down, vector_Up);
    }

    private static float GetMinorLossByAngle(double angle)
    {
        double minorLoss;
        minorLoss = 0.946 * Math.Pow(Math.Sin(Math.Abs(angle) / 2), 2) + 2.05 * Math.Pow(Math.Sin(Math.Abs(angle) / 2), 4);

        return (float)minorLoss;
    }

    public void BuildToInp(string filePath, string userCoorString = null, string sourcePath = null, bool isReplace = false)
    {
        if (sourcePath == null) sourcePath = filePath;

        string tempString = "";
        if (!isReplace)
        {
            var tempPath = Path.Combine(Directory.GetCurrentDirectory(), @"template\inp\导出模板.inp");
            if (!File.Exists(tempPath))
            {
                //MessageBox.Show($"模板文件不存在[{tempPath}]");
                return;
            }
            tempString = File.ReadAllText(tempPath);
        }
        else
        {
            tempString = File.ReadAllText(sourcePath);
        }

        Dictionary<string, string> dictExchange = new Dictionary<string, string>() {
                {"{junctions}","{0}" },
                {"{reservoirs}","{1}" },
                {"{tanks}","{2}" },
                {"{pipes}","{3}" },
                {"{valves}","{4}" },
                {"{pumps}","{5}" },
                {"{coor}","{6}" },
                {"{curve}","{7}" },
            };
        dictExchange.ToList().ForEach(m => tempString = tempString.Replace(m.Key, m.Value));

        StringBuilder junctionStringBuilder = new StringBuilder();

        junctionStringBuilder.AppendLine(";ID              	Elev        	Demand      	Pattern         Type");

        Nodes.ForEach(o0 =>
        {
            var o = o0;
            if (!o.Visible) return;

            if (o is JunctionViewModel j)
                junctionStringBuilder.AppendLine(j.ToString() + $"{j.Level}\tJunction\t{o.Tags}");
            else if (o is MeterViewModel m)
                junctionStringBuilder.AppendLine(m.ToString() + $"{o.Level}\tMeter\t{o.Tags}\t{m.DlTemplateID}");
            else if (o is NozzleViewModel no)
                junctionStringBuilder.AppendLine(no.ToString() + $"{o.Level}\tNozzle\t{o.Tags}\t{no.FlowCoefficient}");
        });
        string junctionString = junctionStringBuilder.ToString();

        StringBuilder reservoirStringBuilder = new StringBuilder();

        reservoirStringBuilder.AppendLine(";ID              	Head        	Pattern ");

        reservoirs.ForEach(o =>
        {
            if (!o.Visible) return;
            reservoirStringBuilder.AppendLine(o.ToString() + $"{o.Level}\t{o.Elev}\t{o.Tags}");
        });
        string reserverString = reservoirStringBuilder.ToString();

        StringBuilder tankStringBuilder = new StringBuilder();

        tankStringBuilder.AppendLine(";ID              	Elevation   	InitLevel   	MinLevel    	MaxLevel    	Diameter    	MinVol      	VolCurve        	Overflow");

        tanks.ForEach(o =>
        {
            if (!o.Visible) return;
            tankStringBuilder.AppendLine(o.ToString() + $"{o.Level}\tTank\t{o.Tags}");
        });
        string tankString = tankStringBuilder.ToString();

        StringBuilder pipeStringBuilder = new StringBuilder();

        pipeStringBuilder.AppendLine(";ID              	Node1           	Node2           	Length      	Diameter    	Roughness   	MinorLoss   	Status");

        Links.ForEach(o0 =>
        {
            var o = (LinkViewModel)o0;
            if (!o.Visible) return;
            if (o is PipeViewModel p)
                pipeStringBuilder.AppendLine(p.ToString() + $"{p.Level}\tPipe\t{p.Tags}");
            else if (o is RepeaterViewModel r)
                pipeStringBuilder.AppendLine(r.ToString());
        });
        string pipeString = pipeStringBuilder.ToString();

        StringBuilder valveStringBuilder = new StringBuilder();

        valveStringBuilder.AppendLine(";ID              	Node1           	Node2           	Diameter    	Type	Setting     	MinorLoss  ");

        valves.ForEach(o =>
        {
            if (!o.Visible) return;
            valveStringBuilder.AppendLine(o.ToString() + $"{o.Level}\tValve\t{o.Tags}");
        });
        string valveString = valveStringBuilder.ToString();

        StringBuilder pumpStringBuilder = new StringBuilder();

        pumpStringBuilder.AppendLine(";ID              	Node1           	Node2           	Diameter    	Type	Setting     	MinorLoss  ");

        pumps.ForEach(o =>
        {
            if (!o.Visible) return;
            pumpStringBuilder.AppendLine(o.ToString() + $"{o.Level}\tPump\t{o.Tags}");
        });
        string pumpString = pumpStringBuilder.ToString();

        StringBuilder curveStringBuilder = new StringBuilder();

        curveStringBuilder.AppendLine(@";ID              	X-Value     	Y-Value
;HEADLOSS:
 GPVDefault      	0           	0
 GPVDefault      	100         	0           ");
        if (dict_dataset != null)
            curveStringBuilder.AppendLine(";PUMP: ");
        foreach (var kp in dict_dataset)
        {
            curveStringBuilder.AppendLine(kp.Value.ToString());
        }
        string curveString = curveStringBuilder.ToString();

        StringBuilder coorStringBuilder = new StringBuilder();
        if (userCoorString == null)
        {
            coorStringBuilder.AppendLine(";Node            	X-Coord           	Y-Coord");
            Nodes.ForEach(o => coorStringBuilder.AppendLine(o.ToCoorString()));
        }
        else
        {
            coorStringBuilder.Append(userCoorString);
        }

        string coorString = coorStringBuilder.ToString();
        string output = "";

        StringBuilder emitterStringBuilder = new StringBuilder();
        emitterStringBuilder.AppendLine(";Junction        \tCoefficient");
        Nodes.ForEach(o => emitterStringBuilder.Append((o).ToEmitterString()));

        string emitterString = emitterStringBuilder.ToString();

        StringBuilder statusStringBuilder = new StringBuilder();
        statusStringBuilder.AppendLine(";ID              \tStatus/Setting\r\n");
        Links.ForEach(o => statusStringBuilder.Append(o.ToStatusString()));

        string statusString = statusStringBuilder.ToString();

        output = tempString;

        output = replaceContent(output, "JUNCTIONS", junctionString);
        output = replaceContent(output, "RESERVOIRS", reserverString);
        output = replaceContent(output, "TANKS", tankString);
        output = replaceContent(output, "PIPES", pipeString);
        output = replaceContent(output, "VALVES", valveString);
        output = replaceContent(output, "PUMPS", pumpString);
        output = replaceContent(output, "CURVES", curveString);

        output = replaceContent(output, "COORDINATES", coorString);
        output = replaceContent(output, "EMITTERS", emitterString);
        output = replaceContent(output, "STATUS", statusString);
        string backupFolderPath = Path.Combine(Path.GetDirectoryName(filePath), "bk");
        if (!Directory.Exists(backupFolderPath))
        {
            Directory.CreateDirectory(backupFolderPath);
        }

        string backupFileName = $"{Path.GetFileNameWithoutExtension(filePath)}_{DateTime.Now:yyyyMMddHHmmss}{Path.GetExtension(filePath)}";
        string backupFilePath = Path.Combine(backupFolderPath, backupFileName);
        FileCopy.Copy(filePath, backupFilePath, true);


        // 检查文件是否存在
        try
        {
            Global.ClearFileReadOnly(filePath);

            File.WriteAllText(filePath, output);
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }

        //MessageBox.Show($"保存成功!");
    }

    private string replaceContent(string text, string content, string replaceString)
    {
        string str = replaceString;

        string replacedText = ReplaceCoordinatesSection(text, content, str);

        return replacedText;
        //Console.WriteLine(replacedText);
    }
}

public class Vector3D
{
    public double X { get; set; }
    public double Y { get; set; }
    public double Z { get; set; }

    public Vector3D(double x, double y, double z)
    {
        X = x;
        Y = y;
        Z = z;
    }

    public static double CalculateAngle(Vector3D v1, Vector3D v2)
    {
        // 计算两个向量的点积
        double dotProduct = v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z;

        // 计算两个向量的模长
        double v1Magnitude = Math.Sqrt(v1.X * v1.X + v1.Y * v1.Y + v1.Z * v1.Z);
        double v2Magnitude = Math.Sqrt(v2.X * v2.X + v2.Y * v2.Y + v2.Z * v2.Z);

        // 计算夹角（弧度）
        double angleInRadians = Math.Acos(dotProduct / (v1Magnitude * v2Magnitude));

        // 将弧度转换为度数
        //double angleInDegrees = angleInRadians * (180 / Math.PI);

        return angleInRadians;
    }

    public double Length
    {
        get
        {
            return Math.Sqrt(X * X + Y * Y + Z * Z);
        }
    }
}

public abstract class BaseModel
{
    public BaseModel() { }

    public BaseModel(BaseModel model)
    {
        this.ID = model.ID;
        this.Name = model.Name;
        this.Status = model.Status;
    }
    public virtual string ID { get; set; }
    public virtual string Name { get; set; }

    public virtual StatusType Status { get; set; } = StatusType.OPEN;


    [Description("楼层")]
    [DisplayName("楼层")]
    public virtual string Floor { get; set; }



}


public class LinkModel : BaseModel
{
    public LinkModel() { }

    public LinkModel(LinkModel model) : base(model)
    {
        this.Node1 = model.Node1;
        this.Node2 = model.Node2;
        this.Diameter = model.Diameter;
        this.Length = model.Length;
        this.Roughness = model.Roughness;
        this.MinorLoss = model.MinorLoss;

    }

    /// Node1

    public virtual string Node1 { get; set; }

    /// Node2

    public virtual string Node2 { get; set; }

    /// 口径

    public virtual float Diameter { get; set; }


    /// 长度

    public virtual float Length { get; set; }


    /// 海森威廉系数

    public virtual float Roughness { get; set; }


    /// 局部阻力系数

    public virtual float MinorLoss { get; set; }
    public virtual string ToStatusString()
    {
        if (Status == StatusType.CLOSED)
        {
            return $"{ID}\tCLOSED\r\n";
        }
        return "";
    }

}

public class LinkCalcModel : LinkModel
{
    public LinkCalcModel() { }

    public LinkCalcModel(LinkCalcModel model) : base(model)
    {
        this.Node1 = model.Node1;
        this.Node2 = model.Node2;
        this.Diameter = model.Diameter;
        this.Length = model.Length;
        this.Roughness = model.Roughness;
        this.MinorLoss = model.MinorLoss;
    }

    public string Node1
    {
        get
        {
            if (_StartNode != null) return _StartNode.ID;
            return base.Node1;
        }
        set
        {

            base.Node1 = value;
        }
    }

    public string Node2
    {
        get
        {
            if (_EndNode != null) return _EndNode.ID;
            return base.Node2;
        }
        set
        {
            base.Node2 = value;
        }
    }


    private NodeCalcModel _StartNode;

    public NodeCalcModel StartNode
    {
        get { return _StartNode; }
        set { _StartNode = value; if (_StartNode != null) this.Node1 = _StartNode.ID; }
    }

    private NodeCalcModel _EndNode;

    public NodeCalcModel EndNode
    {
        get { return _EndNode; }
        set { _EndNode = value; if (_EndNode != null) this.Node2 = _EndNode.ID; }
    }


    /// 长度

    public float Length
    {
        get
        {
            if (base.Length > 0) return base.Length;
            else
            {
                if (_StartNode != null && _EndNode != null)
                {
                    ////求_StartNode到_EndNode的距离
                    return (float)Math.Sqrt(Math.Pow(_StartNode.X - _EndNode.X, 2) + Math.Pow(_StartNode.Y - _EndNode.Y, 2) + Math.Pow(_StartNode.Elev - _EndNode.Elev, 2));
                }
                else
                {
                    return 0;
                }
            }
        }
        set
        {
            base.Length = value;
        }
    }

    //实际需水量
    [DisplayName("流量(m³/h)")]
    [Browsable(true)]
    public float EN_FLOW { get; set; } = float.NaN;

    //实际需水量
    [DisplayName("流速(m/s)")]
    [Browsable(true)]
    public float EN_VELOCITY { get; set; } = float.NaN;
    //实际需水量

    [DisplayName("水头损失(m)")]
    [Browsable(true)]
    public float EN_HEADLOSS { get; set; } = float.NaN;


    [DisplayName("沿程水损(m)")]
    [Browsable(true)]
    public float EN_HEADLOSS_LINE { get; set; } = float.NaN;


    [DisplayName("局部水损(m)")]
    [Browsable(true)]
    public float EN_HEADLOSS_MINOR { get; set; } = float.NaN;
    //实际需水量

    [DisplayName("当前状态")]

    public float EN_STATUS { get; set; } = float.NaN;




    public bool Selected { get; set; }


    [Description("鼠标悬于上方")]
    [DisplayName("鼠标悬于上方")]

    public bool Hovered { get; set; }
}


public class NodeModel : BaseModel
{
    public NodeModel() { }

    public NodeModel(NodeModel model) : base(model)
    {
        this.X = model.X;
        this.Y = model.Y;
        this.Elev = model.Elev;
    }
    public virtual float X { get; set; }

    public virtual float Y { get; set; }



    /// 标高

    public virtual float Elev { get; set; }

    public virtual string ToCoorString()
    {
        return $"{ID}\t{X}\t{Y}";
    }

}

public class NodeCalcModel : NodeModel
{
    public NodeCalcModel() { }

    public NodeCalcModel(NodeCalcModel model) : base(model)
    {
        this.X = model.X;
        this.Y = model.Y;
        this.Elev = model.Elev;
    }
    public List<LinkCalcModel> Links = new List<LinkCalcModel>();

    //实际需水量

    [DisplayName("实际需水量(m³/h)")]
    [Browsable(true)]
    public float EN_DEMAND { get; set; } = float.NaN;

    //实际需水量

    [DisplayName("绝对水压(m)")]
    [Browsable(true)]
    public float EN_HEAD { get; set; } = float.NaN;
    //实际需水量

    [DisplayName("自由水压(m)")]
    [Browsable(true)]
    public float EN_PRESSURE { get; set; } = float.NaN;
    //实际需水量

    [DisplayName("水龄")]
    public float EN_QUALITY { get; set; } = float.NaN;




    public bool Selected { get; set; }



    [Description("鼠标悬于上方")]
    [DisplayName("鼠标悬于上方")]

    public bool Hovered { get; set; }
}


public enum StatusType
{
    CLOSED = 0,
    OPEN = 1,
    ACTIVE = 2,
    DEFAULT = 3
}

public enum PumpType
{
    调速泵,
    定速泵
}

public enum FlowCurveType
{
    流量扬程曲线 = 1,
    流量功率曲线 = 2,
    流量效率曲线 = 3
}

public enum FailType
{
    缺少Node1或Node2连接属性 = 1,
    喷头只能连接管道 = 2,
    缺少水箱或水池对象 = 3,
    管件对象连管件对象 = 4
}

public class JunctionModel : NodeCalcModel
{

    /// 需水量
    public float Demand { get; set; }

    /// 用水模式编号
    public string PatternID { get; set; }
    public override string ToString()
    {
        var pTemp = PatternID;
        if (string.IsNullOrEmpty(pTemp) || pTemp == ";") pTemp = "";
        return $"{ID}\t{Elev}\t{Demand}\t{pTemp}\t;\t";
    }

    public MeterModel ToMeter()
    {
        return new MeterModel()
        {
            Elev = base.Elev,
            ID = base.ID,
            Name = base.Name,
            Status = base.Status,
            X = base.X,
            Y = base.Y,
        };
    }

    public NozzleModel ToNozzle()
    {
        return new NozzleModel()
        {
            Y = base.Y,
            X = base.X,
            Status = base.Status,
            Name = base.Name,
            ID = base.ID,
            Elev = base.Elev,
        };
    }
}

public class MeterModel : NodeCalcModel
{

    /// 需水量
    public float Demand { get; set; }

    /// 用水模式编号
    public string PatternID { get; set; }
    public override string ToString()
    {
        if (string.IsNullOrEmpty(PatternID)) PatternID = "";
        return $"{ID}\t{Elev}\t{Demand}\t{PatternID}\tMeter\t;\t";
    }

    public JunctionModel ToJunction()
    {
        return new JunctionModel()
        {
            Y = base.Y,
            Elev = base.Elev,
            ID = base.ID,
            Name = base.Name,
            Status = base.Status,
            X = base.X,
        };
    }
}

public class NozzleModel : NodeCalcModel
{

    /// 流量系数K

    public float FlowCoefficient { get; set; }


    /// 需水量

    public float Demand { get; set; }

    /// 用水模式编号

    public string PatternID { get; set; }

    public string Node1 { get; set; }
    public string Node2 { get; set; }

    public override string ToString()
    {
        if (string.IsNullOrEmpty(PatternID)) PatternID = "";
        return $"{ID}\t{Elev}\t{Demand}\t{PatternID}\t;\t";
    }

    public string ToEmitterString()
    {
        if (FlowCoefficient > 0)
            return $"{ID}\t{FlowCoefficient * Math.Pow(10 / 101.972, 0.5) / 1000 * 60}\r\n";
        return null;
    }

    public JunctionModel ToJunction()
    {
        return new JunctionModel()
        {
            Y = base.Y,
            Elev = base.Elev,
            ID = base.ID,
            Name = base.Name,
            Status = base.Status,
            X = base.X,
        };
    }
}

public class ReservoisModel : NodeCalcModel
{

    /// 总水头|绝对水压 

    public float Head { get; set; }


    /// 用水模式编号

    public string PatternID { get; set; }

    public override string ToString()
    {
        return $"{ID}\t{Head}\t{PatternID}\t;\t";
    }

}

public class TankModel : NodeCalcModel
{

    /// 初始水位

    public float InitLevel { get; set; } = 5;


    /// 最低水位

    public float MinLevel { get; set; } = 10;


    /// 最高水位

    public float MaxLevel { get; set; } = 0;


    /// 直径

    public float Diameter { get; set; } = 10;


    /// 最小容积

    public float MinVol { get; set; } = 0;


    /// 容积曲线

    public string VolCurve { get; set; }


    /// 是否允许溢流

    public bool IsOverFlow { get; set; }

    public override string ToString()
    {
        VolCurve = "";
        var Overflow = IsOverFlow ? "" : "";
        return $"{ID}\t{Elev}\t{InitLevel}\t{MinLevel}\t{MaxLevel}\t{Diameter}\t{MinVol}\t{VolCurve}\t{Overflow}\t;\t";
    }
}

public class PipeModel : LinkCalcModel
{
    public override string ToString()
    {
        if (Roughness == 0) Roughness = 110;
        return $"{ID}\t{Node1}\t{Node2}\t{Length}\t{Diameter}\t{Roughness}\t{MinorLoss}\t{Status}\t;\t";
    }
}

public class PumpModel : LinkCalcModel
{

    /// 泵类型

    public PumpType Type { get; set; }

    /// 额定转速

    public double RatedSpeed { get; set; } = 1500;


    /// 额定流量

    public double RatedFlow { get; set; } = 0;


    /// 额定扬程

    public double RatedHead { get; set; } = 0;


    /// 额定功率

    public double RatedPower { get; set; } = 75;


    /// 扬程曲线

    public string FlowCurveID { get; set; } = "PumpDefault";


    /// 参数

    public List<string> Parameters { get; set; }


    /// 流量曲线

    public FlowCurve FlowCurve { get; set; }



}

public class ValveModel : LinkCalcModel
{

    /// 类型

    public string Type { get; set; } = "GPV";

    /// 曲线

    public string CurvSetting { get; set; } = "GPVDefault";


}/// <summary>
 /// 流量曲线


public class FlowCurve
{
    public string Name { get; set; }

    public FlowCurveType FlowCurveType { get; set; }

    public List<PointF> Data { get; set; } = new List<PointF>();
}


public class Coor
{
    public string ID;
    public PointF Position;
    public Coor(string id, PointF position)
    {
        ID = id;
        this.Position = position;
    }
}
public class Parts
{
    List<string> _parts = null;
    List<string> _parts_before = null;

    public int Length
    {
        get
        {
            if (_parts != null)
                return _parts.Count;
            else
                return -1;
        }
    }

    public int Count
    {
        get
        {
            if (_parts != null)
                return _parts.Count;
            else
                return -1;
        }
    }

    public Parts(string[] strings)
    {
        _parts = strings.ToList();
    }

    public Parts(string line)
    {
        List<string> sp = line.Split(new char[] {
'\t', ' '
}, StringSplitOptions.RemoveEmptyEntries).ToList();
        int pos = sp.IndexOf(";");
        if (pos > 0)
        {
            _parts = new List<string>();
            _parts_before = new List<string>();
            for (int i = 0; i < pos; i++)
            {
                _parts.Add(sp[i]);
            }
            for (int i = pos; i < sp.Count; i++)
            {
                _parts_before.Add(sp[i]);
            }
        }
        else
        {
            _parts = new List<string>();
            _parts.AddRange(sp);
        }
    }
    public string this[int index]
    {
        get
        {
            if (index < 0)
            {
                index = Math.Abs(index);
                if (_parts_before != null && _parts_before.Count > index)
                    return _parts_before[index];
                else
                    return null;
            }
            else
            {
                if (_parts != null && _parts.Count > index)
                    return _parts[index];
                else
                    return null;
            }

        }
        set
        {
            _parts[index] = value;
        }
    }
    public float ToFloat(int index, float defaultValue)
    {
        float f = defaultValue;
        if (this[index] != null && float.TryParse(this[index], out f))
        {

        }
        return f;
    }
    public int ToInt(int index, int defaultValue)
    {
        int f = defaultValue;
        if (this[index] != null && int.TryParse(this[index], out f))
        {

        }
        return f;
    }
    public string ToString(int index, string defaultValue)
    {
        string f = defaultValue;
        if (this[index] != null)
        {
            return this[index];
        }
        return f;
    }
    public bool ToBool(int index, bool defaultValue)
    {
        bool f = defaultValue;
        if (this[index] != null && bool.TryParse(this[index], out f))
        {

        }
        return f;
    }
}



public class TimePoint
{
    public TimePoint()
    {

    }
    public TimePoint(string key, double value)
    {
        Key = key;
        Value = value;
    }
    public TimePoint(TimePoint point)
    {
        this.Key = point.Key;
        this.Value = point.Value;
        this.Name = point.Name;
        this.ValueTime = point.ValueTime;
        this.SearchRange = point.SearchRange;
        this.isNeedtoSave = point.isNeedtoSave;
        this.SaveKey = point.SaveKey;
        if (point.Pattern != null) this.Pattern = point.Pattern.ToArray();

    }
    public string Name;
    public DateTime ValueTime { get; set; }
    public string Key { get; set; }
    public double Value { get; set; }
    public double[] Pattern { get; set; } = null;

    public double SearchRange = 0;

    public bool isNeedtoSave = false;

    public string SaveKey = null;

    public override string ToString()
    {
        return $"{Name}\t[{Key}]\t{Value}";
    }
}



public class dict<TKey, TValue> : Dictionary<TKey, TValue>
{
    private List<TKey> keys
    {
        get
        {
            return this.Keys.ToList();
        }
    }

    public bool emptyCreate = true;
    //List<dict> _list = null;
    public dict() : base()
    {
    }

    public dict(int capacity) : base(capacity)
    {
    }
    public dict(IEnumerable<KeyValuePair<TKey, TValue>> collection) : base((IDictionary<TKey, TValue>)collection)
    {
    }
    public bool Value { get; set; }

    public bool SetKey(TKey key, dynamic Value)
    {
        if (this.Contains(key))
        {
            this[key] = Value;
            return false;
        }
        else
        {
            this.Add(key, Value);
            return true;
        }
    }
    public TKey[] GetKeys()
    {
        return this.Keys.ToArray();
    }

    public bool Contains(TKey[] keys)
    {
        foreach (var key in keys)
            if (!this.Contains(key)) return false;
        return true;
    }
    public bool Contains(TKey key)
    {
        return this.ContainsKey(key);
    }
    public bool Contains(KeyValuePair<TKey, dynamic> key)
    {
        return this.ContainsKey(key.Key);
    }
    public TValue Get(TKey key, TValue @default = default(TValue))
    {
        if (this.Contains(key))
            return this[key];
        else
            return @default;
    }
    public TValue Get(KeyValuePair<TKey, TValue> key, TValue @default = default(TValue))
    {
        if (this.Contains(key))
            return this[key.Key];
        else
            return @default;
    }
    public TValue pop(TKey key, TValue @default = default(TValue))
    {
        if (this.Contains(key))
        {
            var temp = this[key];
            this.Remove(key);
            return temp;
        }
        else
            return @default;
    }
    public TValue pop(KeyValuePair<TKey, TValue> key, TValue @default = default(TValue))
    {
        if (this.Contains(key))
        {
            var temp = this[key.Key];
            this.Remove(key);
            return temp;
        }
        else
            return @default;
    }
    public TValue this[KeyValuePair<TKey, TValue> key]
    {
        get { return this[key.Key]; }
        set { this[key.Key] = value; }
    }
    public TValue this[TKey key]
    {
        get
        {
            if (!this.ContainsKey(key))
            {
                lock (this)
                {
                    if (!this.ContainsKey(key))
                    {
                        if (emptyCreate)
                            this.Add(key, default(TValue));
                        else
                            return default(TValue);
                    }
                }
            }
            return base[key];

        }
        set
        {
            if (!this.ContainsKey(key))
            {
                lock (this)
                {
                    if (!this.ContainsKey(key))
                    {
                        if (emptyCreate)
                            this.Add(key, value);
                        else
                            return;
                    }
                }
            }
            base[key] = value;
        }

    }

    public TValue this[int index]
    {
        get
        {
            TKey key = default(TKey);
            if (typeof(TKey) == typeof(int))
                key = (TKey)(object)index;
            else
                key = keys[index];
            if (!base.ContainsKey(key))
                base.Add(key, default(TValue));

            return base[key];
        }
        set
        {
            TKey key = default(TKey);
            if (typeof(TKey) == typeof(int))
            {
                key = (TKey)(object)index;
                base[key] = value;
            }

            else
            {
                if (index < keys.Count)
                {
                    key = keys[index];
                    base[key] = value;
                }
            }


        }
    }

    public override string ToString()
    {
        return JsonConvert.SerializeObject(this);
    }
    public void LoadFromString(string s)
    {
        dict<TKey, TValue> d = JsonConvert.DeserializeObject<dict<TKey, TValue>>(s);
        this.Clear();
        foreach (var kp in d)
        {
            this.Add(kp.Key, kp.Value);
        }

    }
    public bool Remove(KeyValuePair<TKey, TValue> key)
    {
        return this.Remove(key.Key);
    }


    public List<TValue> values()
    {
        return this.Values.ToList();
    }

    #region 将Session的元素简单放进dict中,简单处理方便使用
    private DateTime 发送计时;
    private string msgList = "";
    private System.Timers.Timer t = new System.Timers.Timer();


    public dict<TKey, TValue> ctx
    {
        get { return this; }
    }

    #endregion

    #region IntentCommand
    public double confidence;
    public string methodName;
    public dict<TKey, TValue> args;
    public string current_arg;
    //current_arg: str = ''
    public dict(double confidence, string methodName, string current_arg = "", dict<TKey, TValue> args = null)
    {
        this.confidence = confidence;
        this.methodName = methodName;
        this.args = args;
        this.current_arg = current_arg;
    }
    #endregion

}
public partial class PropertyForm : UserControl
{
    private IBaseViewModel _selectedObject;
    private MapObjectType _selectedType = MapObjectType.全部;
    private List<SelectionSet> selectionSets;
    public SelectionSet selectionSet = new SelectionSet();
    private Form fr = null;
    public PropertyForm()
    {
        InitializeComponent();
    }
    public void SetEnabled(bool isReadOnly)
    {
        _isEnable = isReadOnly;
    }

    public void SetWindows(Form mg)
    {
        if (mg.WindowState == FormWindowState.Maximized)
        {
            //this.StartPosition = FormStartPosition.Manual; //设置窗体位置由程序控制
            this.Height = mg.Height - 50;
            this.Location = new Point(mg.Left + mg.Width - this.Width, mg.Top + 50); //设置新窗体位置，当前窗体的右侧（X轴方向）
        }
        else
        {
            //this.StartPosition = FormStartPosition.Manual; //设置窗体位置由程序控制
            this.Height = mg.Height;
            this.Location = new Point(mg.Left + mg.Width - 15, mg.Top); //设置新窗体位置，当前窗体的右侧（X轴方向）
        }
        fr = mg;

        //GlobalObject.PropertyForm.Show();
    }
    public Form GetWindow()
    {
        return this.fr;
    }
    public void SetObj(object o)
    {
        propertyGrid.SelectedObject = o;
        this.Text = o.GetType().Name;
    }
    public void SetObj(IBaseViewModel selectedObject)
    {
        lock (selectedObject)
        {
            _selectedObject = selectedObject;



            if (_selectedObject is JunctionViewModel junc)
            {
                _selectedType = MapObjectType.节点;
                propertyGrid.SelectedObjects = new JunctionViewModel[] { junc };
            }
            else if (_selectedObject is ReservoirViewModel res)
            {
                _selectedType = MapObjectType.水库;
                propertyGrid.SelectedObjects = new ReservoirViewModel[] { res };
            }
            else if (_selectedObject is TankViewModel tank)
            {
                _selectedType = MapObjectType.水池;
                propertyGrid.SelectedObjects = new TankViewModel[] { tank };
            }
            else if (_selectedObject is PipeViewModel pipe)
            {
                _selectedType = MapObjectType.管线;
                propertyGrid.SelectedObjects = new PipeViewModel[] { pipe };
            }
            else if (_selectedObject is ValveViewModel valve)
            {
                _selectedType = MapObjectType.阀门;
                propertyGrid.SelectedObjects = new ValveViewModel[] { valve };
            }
            else if (_selectedObject is RepeaterViewModel repeater)
            {
                _selectedType = MapObjectType.重复器;
                propertyGrid.SelectedObjects = new RepeaterViewModel[] { repeater };
            }
            //水表
            else if (_selectedObject is MeterViewModel meter)
            {
                _selectedType = MapObjectType.水表;
                propertyGrid.SelectedObjects = new MeterViewModel[] { meter };
            }
            //水泵
            else if (_selectedObject is PumpViewModel pump)
            {
                _selectedType = MapObjectType.水泵;
                propertyGrid.SelectedObjects = new PumpViewModel[] { pump };
            }
            //喷头Nozzle
            else if (_selectedObject is NozzleViewModel nozzle)
            {
                _selectedType = MapObjectType.喷头;
                propertyGrid.SelectedObjects = new NozzleViewModel[] { nozzle };
            }
            else
            {
                _selectedType = MapObjectType.全部;
                propertyGrid.SelectedObjects = new IBaseViewModel[] { selectedObject };
            }
            switch (_selectedType)
            {
                case MapObjectType.节点:
                    Text = "节点 Properties";
                    break;
                case MapObjectType.水库:
                    Text = "水库 Properties";
                    break;
                case MapObjectType.水池:
                    Text = "水池 Properties";
                    break;
                case MapObjectType.管线:
                    Text = "管线 Properties";
                    break;
                case MapObjectType.阀门:
                    Text = "阀门 Properties";
                    break;
                case MapObjectType.重复器:
                    Text = "重复器 Properties";
                    break;
            }


        }

    }
    public void SetNet(MapViewNetWork net)
    {
        selectionSet.net = net;
    }
    public void SetObjs(List<IBaseViewModel> selectedObjects)
    {
        if (selectedObjects == null) return;
        selectedObjects.RemoveAll(obj => obj == null);
        selectedObjects.ForEach(obj =>
        {
            if (obj.Tags == null)
            {
                obj.Tags = new TagList();
            }

        });

        selectionSet.selectedObjects = selectedObjects.ToList();
        if (selectedObjects.Count == 1)
            SetObj(selectedObjects[0]);
        else
            ShowProperties(selectedObjects);

        if (selectionSet.OnlyViewSelected)
            RefreshListBox();
    }

    private void PropertyForm_Load_1(object sender, EventArgs e)
    {
        foreach (var item in Enum.GetValues(typeof(MapObjectType)))
        {
            comboBox_type.Items.Add(item);
        }
        comboBox_type.SelectedIndex = 0;
        selectionSets = new List<SelectionSet>();
        selectionSet = new SelectionSet();
        listBox1.DataSource = selectionSet.View;
    }

    private void comboBox_type_SelectedIndexChanged(object sender, EventArgs e)
    {
        RefreshListBox();
    }
    void RefreshListBox()
    {
        if (selectionSet == null) return;
        string txt = comboBox_type.SelectedItem.ToString();
        MapObjectType selectedType = (MapObjectType)Enum.Parse(typeof(MapObjectType), txt);
        // 使用 LINQ 查询筛选选择集
        selectionSet.filterType = selectedType;
        selectionSet.FilterString = textBox_search.Text;


        listBox1.SelectedIndexChanged -= listBox1_SelectedIndexChanged;


        listBox1.DataSource = selectionSet.View;

        listBox1.SelectedIndexChanged += listBox1_SelectedIndexChanged;
    }

    private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
    {

        if (listBox1.SelectedItems.Count == 0)
        {
            return;
        }
        else if (listBox1.SelectedItems.Count == 1)
        {
            var objID = listBox1.SelectedItems[0];
            var findlist = selectionSet.net.MapObjects.FindAll(o => o.ID == objID);
            if (findlist.Count <= 0) return;
            IBaseViewModel mapObject = findlist[0];
            if (mapObject != null) SetObj(mapObject);
            GlobalObject.map.selectedObjs.ForEach(o => o.Selected = false); ;
            GlobalObject.map.selectedObjs.Clear();
            GlobalObject.map.selectedObjs.Add(mapObject);
            mapObject.Selected = true;
            GlobalObject.map.SetMapInvalidate();
        }
        else
        {
            List<IBaseViewModel> list = new List<IBaseViewModel>();
            foreach (var o in listBox1.SelectedItems)
            {
                var objID = listBox1.SelectedItems[0];
                IBaseViewModel mapObject = selectionSet.net.MapObjects.FindAll(obj => obj.ID == objID)[0];
                list.Add(mapObject);
            }
            ShowProperties(list);
            GlobalObject.map.selectedObjs.ForEach(o => o.Selected = false); ;
            GlobalObject.map.selectedObjs.Clear();
            list.ForEach(o => o.Selected = true);
            GlobalObject.map.selectedObjs.AddRange(list);
            GlobalObject.map.SetMapInvalidate();
        }



    }
    private void listBox1_DoubleClick(object sender, EventArgs e)
    {
        if (listBox1.SelectedItems.Count == 1)
        {

            var objID = listBox1.SelectedItems[0];
            IBaseViewModel mapObject = selectionSet.net.MapObjects.FindAll(obj => obj.ID == objID)[0];
            GlobalObject.map.setCenter(mapObject);


            GlobalObject.map.SetMapInvalidate();
        }
    }
    private void PropertyForm_FormClosing(object sender, FormClosingEventArgs e)
    {
        e.Cancel = true;
        this.Hide();
    }

    bool _isEnable = true;

    private static Dictionary<object, List<object>> _selectedObjectsDict = new Dictionary<object, List<object>>();
    private void propertyGrid_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
    {

        if (!_isEnable)
        {
            MessageBox.Show("当前状态的修改将不会被保存", "重复器展开中");
            _isEnable = true;
        }

        GlobalObject.map.SetMapInvalidate();
    }



    public void ShowProperties(IEnumerable<IBaseViewModel> selectedObjects)
    {
        IBaseViewModel[] objs = null;
        try
        {
            if (selectedObjects != null)
                objs = selectedObjects.ToArray();
        }
        catch
        {
            return;
        }
        propertyGrid.SelectedObjects = objs;



    }

    private void textBox_search_TextChanged(object sender, EventArgs e)
    {
        RefreshListBox();
    }

    private void checkBox_OnlyShowSelected_CheckedChanged(object sender, EventArgs e)
    {
        selectionSet.OnlyViewSelected = checkBox_OnlyShowSelected.Checked;
        RefreshListBox();
    }

    private void label_lock_Click(object sender, EventArgs e)
    {
        var label_lock = (Label)sender;

        GlobalObject.LockSelect = !GlobalObject.LockSelect;
        if (GlobalObject.LockSelect)
        {
            label_lock.BackColor = Color.Blue;
            label_lock.Text = "🔒";
        }
        else
        {
            label_lock.BackColor = Color.Green;
            label_lock.Text = "🔓";
        }
    }
    private void label_filter_Click(object sender, EventArgs e)
    {




    }

    private void PropertyForm_KeyDown(object sender, KeyEventArgs e)
    {
        //Ctrl+A，则选中当前listbox中的所有项
        if (e.Control && e.KeyCode == Keys.A)
        {
            for (int i = 0; i < listBox1.Items.Count; i++)
            {
                listBox1.SetSelected(i, true);
            }
        }
    }


    private void 全选ToolStripMenuItem_Click(object sender, EventArgs e)
    {
        listBox1.SelectedIndexChanged -= listBox1_SelectedIndexChanged;
        for (int i = 0; i < listBox1.Items.Count; i++)
        {
            listBox1.SetSelected(i, true);
        }
        listBox1.SelectedIndexChanged += listBox1_SelectedIndexChanged;
        this.propertyGrid.SelectedObjects = selectionSet.CurrentSelectedObjects?.ToArray();
        GlobalObject.map.selectedObjs.ForEach(o => o.Selected = false);
        if (selectionSet.CurrentSelectedObjects != null)
        {
            GlobalObject.map.selectedObjs.AddRange(selectionSet.CurrentSelectedObjects);
            selectionSet.CurrentSelectedObjects.ForEach(o =>
            {
                o.Selected = true;
            });
        }
        GlobalObject.map.SetMapInvalidate();


    }

    private void listBox1_MouseDown(object sender, MouseEventArgs e)
    {
        if (e.Button == MouseButtons.Right)
        {
            if (listBox1.SelectedItems.Count > 0)
            {
                contextMenuStrip1.Show(listBox1, e.Location);
            }
        }
    }
}

public class SelectionSet
{
    public string Name;
    public MapObjectType filterType = MapObjectType.全部;

    public string FilterString { get; set; } = "";

    public TagList FilterTags { get; set; } = new TagList();
    public List<Func<IBaseViewModel, bool>> rules = new List<Func<IBaseViewModel, bool>>();
    public List<MapObjectType> FilterTypes = new List<MapObjectType>();
    public MapViewNetWork net { get; set; } = null;
    public bool OnlyViewSelected { get; set; } = true;

    public List<IBaseViewModel> selectedObjects = new List<IBaseViewModel>();
    public List<IBaseViewModel> CurrentSelectedObjects = new List<IBaseViewModel>();
    public List<string> View
    {
        get
        {
            List<IBaseViewModel> originList;
            List<IBaseViewModel> list;
            List<string> list_result = new List<string>();
            if (!OnlyViewSelected && net != null)
            {
                originList = net.MapObjects;
            }
            else
            {
                originList = selectedObjects;
            }


            if (filterType == MapObjectType.全部)
            {
                list = originList;
            }

            else
            {

                var filteredSets = from obj in originList
                                   where obj.GetType() == filterType.GetObjType()
                                   select obj;
                list = filteredSets?.ToList();
            }



            if (FilterString != null && FilterString != "")
            {
                list = list?.FindAll(o => o.ID.IndexOf(FilterString) >= 0);
            }

            if (FilterTags.Count > 0)
            {
                foreach (var tag in FilterTags)
                {
                    var filteredSets = from obj in list
                                       where obj.Tags.Contains(tag)
                                       select obj;
                    list = filteredSets?.ToList();
                }
            }

            if (rules.Count > 0)
            {
                foreach (var rule in rules)
                {
                    var filteredSets = from obj in list
                                       where rule(obj)
                                       select obj;
                    list = filteredSets?.ToList();
                }
            }

            CurrentSelectedObjects = list;
            list_result = list.Select(o => o.ID).ToList();
            return list_result;


        }
    }


}

partial class PropertyForm
{


    private System.ComponentModel.IContainer components = null;


    /// Clean up any resources being used.

    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
    protected override void Dispose(bool disposing)
    {
        if (disposing && (components != null))
        {
            components.Dispose();
        }
        base.Dispose(disposing);
    }

    #region Windows Form Designer generated code

    private void InitializeComponent()
    {
        this.components = new System.ComponentModel.Container();
        this.propertyGrid = new System.Windows.Forms.PropertyGrid();
        this.listBox1 = new System.Windows.Forms.ListBox();
        this.comboBox_type = new System.Windows.Forms.ComboBox();
        this.splitContainer1 = new System.Windows.Forms.SplitContainer();
        this.panel1 = new System.Windows.Forms.Panel();
        this.checkBox_OnlyShowSelected = new System.Windows.Forms.CheckBox();
        this.textBox_search = new System.Windows.Forms.TextBox();
        this.label_filter = new System.Windows.Forms.Label();
        this.label_lock = new System.Windows.Forms.Label();
        this.label1 = new System.Windows.Forms.Label();
        this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
        this.全选ToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
        ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
        this.splitContainer1.Panel1.SuspendLayout();
        this.splitContainer1.Panel2.SuspendLayout();
        this.splitContainer1.SuspendLayout();
        this.panel1.SuspendLayout();
        this.contextMenuStrip1.SuspendLayout();
        this.SuspendLayout();
        // 
        // propertyGrid
        // 
        this.propertyGrid.Dock = System.Windows.Forms.DockStyle.Fill;
        this.propertyGrid.Location = new System.Drawing.Point(0, 0);
        this.propertyGrid.Name = "propertyGrid";
        this.propertyGrid.Size = new System.Drawing.Size(202, 346);
        this.propertyGrid.TabIndex = 0;
        this.propertyGrid.PropertyValueChanged += new System.Windows.Forms.PropertyValueChangedEventHandler(this.propertyGrid_PropertyValueChanged);
        // 
        // listBox1
        // 
        this.listBox1.Dock = System.Windows.Forms.DockStyle.Fill;
        this.listBox1.FormattingEnabled = true;
        this.listBox1.ItemHeight = 12;
        this.listBox1.Location = new System.Drawing.Point(0, 41);
        this.listBox1.Name = "listBox1";
        this.listBox1.SelectionMode = System.Windows.Forms.SelectionMode.MultiExtended;
        this.listBox1.Size = new System.Drawing.Size(202, 75);
        this.listBox1.TabIndex = 1;
        this.listBox1.SelectedIndexChanged += new System.EventHandler(this.listBox1_SelectedIndexChanged);
        this.listBox1.DoubleClick += new System.EventHandler(this.listBox1_DoubleClick);
        this.listBox1.MouseDown += new System.Windows.Forms.MouseEventHandler(this.listBox1_MouseDown);
        // 
        // comboBox_type
        // 
        this.comboBox_type.Dock = System.Windows.Forms.DockStyle.Top;
        this.comboBox_type.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
        this.comboBox_type.FormattingEnabled = true;
        this.comboBox_type.Location = new System.Drawing.Point(0, 21);
        this.comboBox_type.Name = "comboBox_type";
        this.comboBox_type.Size = new System.Drawing.Size(202, 20);
        this.comboBox_type.TabIndex = 2;
        this.comboBox_type.SelectedIndexChanged += new System.EventHandler(this.comboBox_type_SelectedIndexChanged);
        // 
        // splitContainer1
        // 
        this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
        this.splitContainer1.Location = new System.Drawing.Point(0, 0);
        this.splitContainer1.Name = "splitContainer1";
        this.splitContainer1.Orientation = System.Windows.Forms.Orientation.Horizontal;
        // 
        // splitContainer1.Panel1
        // 
        this.splitContainer1.Panel1.Controls.Add(this.propertyGrid);
        // 
        // splitContainer1.Panel2
        // 
        this.splitContainer1.Panel2.Controls.Add(this.listBox1);
        this.splitContainer1.Panel2.Controls.Add(this.comboBox_type);
        this.splitContainer1.Panel2.Controls.Add(this.panel1);
        this.splitContainer1.Size = new System.Drawing.Size(202, 466);
        this.splitContainer1.SplitterDistance = 346;
        this.splitContainer1.TabIndex = 3;
        // 
        // panel1
        // 
        this.panel1.Controls.Add(this.checkBox_OnlyShowSelected);
        this.panel1.Controls.Add(this.textBox_search);
        this.panel1.Controls.Add(this.label_filter);
        this.panel1.Controls.Add(this.label_lock);
        this.panel1.Controls.Add(this.label1);
        this.panel1.Dock = System.Windows.Forms.DockStyle.Top;
        this.panel1.Location = new System.Drawing.Point(0, 0);
        this.panel1.Name = "panel1";
        this.panel1.Size = new System.Drawing.Size(202, 21);
        this.panel1.TabIndex = 4;
        // 
        // checkBox_OnlyShowSelected
        // 
        this.checkBox_OnlyShowSelected.AutoSize = true;
        this.checkBox_OnlyShowSelected.Checked = true;
        this.checkBox_OnlyShowSelected.CheckState = System.Windows.Forms.CheckState.Checked;
        this.checkBox_OnlyShowSelected.Location = new System.Drawing.Point(127, 2);
        this.checkBox_OnlyShowSelected.Name = "checkBox_OnlyShowSelected";
        this.checkBox_OnlyShowSelected.Size = new System.Drawing.Size(48, 16);
        this.checkBox_OnlyShowSelected.TabIndex = 3;
        this.checkBox_OnlyShowSelected.Text = "选择";
        this.checkBox_OnlyShowSelected.UseVisualStyleBackColor = true;
        this.checkBox_OnlyShowSelected.CheckedChanged += new System.EventHandler(this.checkBox_OnlyShowSelected_CheckedChanged);
        // 
        // textBox_search
        // 
        this.textBox_search.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
        this.textBox_search.Location = new System.Drawing.Point(44, 0);
        this.textBox_search.Name = "textBox_search";
        this.textBox_search.Size = new System.Drawing.Size(77, 21);
        this.textBox_search.TabIndex = 3;
        this.textBox_search.TextChanged += new System.EventHandler(this.textBox_search_TextChanged);
        // 
        // label_filter
        // 
        this.label_filter.BackColor = System.Drawing.Color.Green;
        this.label_filter.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
        this.label_filter.Font = new System.Drawing.Font("宋体", 12F);
        this.label_filter.ForeColor = System.Drawing.Color.White;
        this.label_filter.Location = new System.Drawing.Point(177, -1);
        this.label_filter.Name = "label_filter";
        this.label_filter.Size = new System.Drawing.Size(21, 21);
        this.label_filter.TabIndex = 4;
        this.label_filter.Text = "🔽";
        this.label_filter.Click += new System.EventHandler(this.label_filter_Click);
        // 
        // label_lock
        // 
        this.label_lock.BackColor = System.Drawing.Color.Green;
        this.label_lock.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
        this.label_lock.Font = new System.Drawing.Font("宋体", 12F);
        this.label_lock.ForeColor = System.Drawing.Color.White;
        this.label_lock.Location = new System.Drawing.Point(1, 0);
        this.label_lock.Name = "label_lock";
        this.label_lock.Size = new System.Drawing.Size(21, 21);
        this.label_lock.TabIndex = 4;
        this.label_lock.Text = "🔓";
        this.label_lock.Click += new System.EventHandler(this.label_lock_Click);
        // 
        // label1
        // 
        this.label1.BackColor = System.Drawing.SystemColors.AppWorkspace;
        this.label1.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
        this.label1.Font = new System.Drawing.Font("宋体", 12F);
        this.label1.ForeColor = System.Drawing.Color.White;
        this.label1.Location = new System.Drawing.Point(22, 0);
        this.label1.Name = "label1";
        this.label1.Size = new System.Drawing.Size(21, 21);
        this.label1.TabIndex = 4;
        this.label1.Text = "🔍";
        // 
        // contextMenuStrip1
        // 
        this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.全选ToolStripMenuItem});
        this.contextMenuStrip1.Name = "contextMenuStrip1";
        this.contextMenuStrip1.Size = new System.Drawing.Size(101, 26);
        // 
        // 全选ToolStripMenuItem
        // 
        this.全选ToolStripMenuItem.Name = "全选ToolStripMenuItem";
        this.全选ToolStripMenuItem.Size = new System.Drawing.Size(100, 22);
        this.全选ToolStripMenuItem.Text = "全选";
        this.全选ToolStripMenuItem.Click += new System.EventHandler(this.全选ToolStripMenuItem_Click);
        // 
        // PropertyForm
        // 
        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
        this.Controls.Add(this.splitContainer1);
        this.Name = "PropertyForm";
        this.Size = new System.Drawing.Size(202, 466);
        this.Load += new System.EventHandler(this.PropertyForm_Load_1);
        this.KeyDown += new System.Windows.Forms.KeyEventHandler(this.PropertyForm_KeyDown);
        this.splitContainer1.Panel1.ResumeLayout(false);
        this.splitContainer1.Panel2.ResumeLayout(false);
        ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
        this.splitContainer1.ResumeLayout(false);
        this.panel1.ResumeLayout(false);
        this.panel1.PerformLayout();
        this.contextMenuStrip1.ResumeLayout(false);
        this.ResumeLayout(false);

    }

    #endregion

    public System.Windows.Forms.PropertyGrid propertyGrid;
    public System.Windows.Forms.ListBox listBox1;
    private System.Windows.Forms.ComboBox comboBox_type;
    private System.Windows.Forms.SplitContainer splitContainer1;
    private System.Windows.Forms.CheckBox checkBox_OnlyShowSelected;
    private System.Windows.Forms.TextBox textBox_search;
    private System.Windows.Forms.Panel panel1;
    private System.Windows.Forms.Label label1;
    private System.Windows.Forms.Label label_lock;
    private System.Windows.Forms.Label label_filter;
    private System.Windows.Forms.ContextMenuStrip contextMenuStrip1;
    private System.Windows.Forms.ToolStripMenuItem 全选ToolStripMenuItem;
}

public class DRange
{

    public DRange(double min, double max)
    {
        Min = min;
        Max = max;
    }
    public DRange(DRange range)
    {
        if (range == null)
        {
            Min = 0;
            Max = 0;
        }
        else
        {
            Min = range.Min;
            Max = range.Max;
        }

    }
    public DRange()
    {
        Min = 0;
        Max = 0;
    }
    public double Min { get; set; }
    public double Max { get; set; }

    public double Length { get { return Max - Min; } }

    public bool IsInside(double x)
    {
        return x >= Min && x <= Max;
    }
    public bool isValid { get { return Min <= Max; } }
    public void Union(DRange range)
    {
        if (range.Min < Min)
        {
            Min = range.Min;
        }
        if (range.Max > Max)
        {
            Max = range.Max;
        }
    }
    public static DRange Union(DRange range1, DRange range2)
    {
        DRange range = new DRange(range1);
        range.Union(range2);
        return range;
    }
    public override string ToString()
    {
        return $"{Min:0.000}-{Max:0.000}";
    }
}
public class MathSolver
{
    static double ErrNum = -1;
    public static List<double> Solve(double a, double b, double c)
    {
        // 求解二次方程 ax^2 + bx + c = 0
        double delta = b * b - 4 * a * c;

        if (delta >= 0)
        {
            double x1 = (-b + Math.Sqrt(delta)) / (2 * a);
            double x2 = (-b - Math.Sqrt(delta)) / (2 * a);
            return new List<double> { x1, x2 };
        }
        else
        {
            return null;
        }
    }
    public static List<double> Solve(double a, double b, double c, double d)
    {
        double[] roots = null;
        roots = new double[3];
        double f = ((3 * c / a) - ((b * b) / (a * a))) / 3;
        double g = ((2 * (b * b * b) / (a * a * a)) - (9 * b * c / (a * a)) + (27 * d / a)) / 27;
        double h = ((g * g) / 4) + ((f * f * f) / 27);

        if (h > 0)
        {
            double r = -(g / 2) + Math.Sqrt(h);
            double s = Math.Sign(r) * Math.Pow(Math.Abs(r), (1 / 3.0));
            double t = -(g / 2) - Math.Sqrt(h);
            double u = Math.Sign(t) * Math.Pow(Math.Abs(t), (1 / 3.0));

            roots[0] = (s + u) - (b / (3 * a));
            roots[1] = -1;
            roots[2] = -1;
        }
        else if (f == 0 && g == 0 && h == 0)
        {
            roots[0] = Math.Pow((d / a), 1 / 3.0) * -1;
            roots[1] = roots[0];
            roots[2] = roots[0];
        }
        else
        {
            double i = Math.Sqrt(((g * g) / 4) - h);
            double j = Math.Pow(i, (1 / 3.0));
            double k = Math.Acos(-(g / (2 * i)));
            double l = j * -1;
            double m = Math.Cos(k / 3);
            double n = Math.Sqrt(3) * Math.Sin(k / 3);
            double p = (b / (3 * a)) * -1;

            roots[0] = 2 * j * Math.Cos(k / 3) - (b / (3 * a));
            roots[1] = l * (m + n) + p;
            roots[2] = l * (m - n) + p;
        }
        return roots?.ToList();
    }

    public static List<double> Solve(double a, double b, double c, double d, double e)
    {
        double x = 0; // Initial guess
        double epsilon = 1e-7; // Precision
        double diff = 1;
        double maxRoot = -1;
        List<double> roots = new List<double>();
        while (diff > epsilon)
        {
            double x2 = x * x;
            double x3 = x2 * x;
            double x4 = x2 * x2;

            double f = a * x4 + b * x3 + c * x2 + d * x + e;
            double df = 4 * a * x3 + 3 * b * x2 + 2 * c * x + d;

            double x1 = x - f / df;
            diff = Math.Abs(x1 - x);
            x = x1;

            if (x > maxRoot)
            {
                maxRoot = x;
            }
        }
        if (maxRoot < 0) roots = null;
        else roots.Add(maxRoot);
        return roots;
    }

}
public partial class InputBox : Form
{
    DialogResult _DialogResult;

    void initPosition()
    {
        this.StartPosition = FormStartPosition.Manual;
        int offsetX = -1 * this.Width / 2; // 距离鼠标左侧的间距
        int offsetY = -1 * this.Height / 2; // 距离鼠标顶部的间距
        int newWindowWidth = this.Width; // 新窗口的宽度
        int newWindowHeight = this.Height; // 新窗口的高度
        Point mousePosition = MousePosition; // 获取鼠标位置

        this.Location = new Point(mousePosition.X + offsetX, mousePosition.Y + offsetY); // 计算新窗口的位置
    }
    public InputBox()
    {
        InitializeComponent();
        initPosition();

    }
    public InputBox(string txt, string content = "")
    {

        InitializeComponent();
        initPosition();
        this.Text = txt;
        this.textBox1.Text = content;

    }

    private void button1_Click(object sender, EventArgs e)
    {
        _DialogResult = DialogResult.OK;
        this.Close();

    }
    private void button2_Click(object sender, EventArgs e)
    {
        _DialogResult = DialogResult.Cancel;
        this.Close();
    }
    public new string ShowDialog()
    {

        base.ShowDialog();
        if (_DialogResult == DialogResult.OK)
            return textBox1.Text;
        else
            return null;

    }


}
partial class InputBox
{


    private System.ComponentModel.IContainer components = null;

    protected override void Dispose(bool disposing)
    {
        if (disposing && (components != null))
        {
            components.Dispose();
        }
        base.Dispose(disposing);
    }

    #region Windows Form Designer generated code


    /// Required method for Designer support - do not modify
    /// the contents of this method with the code editor.

    private void InitializeComponent()
    {
        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(InputBox));
        this.textBox1 = new System.Windows.Forms.TextBox();
        this.button1 = new System.Windows.Forms.Button();
        this.button2 = new System.Windows.Forms.Button();
        this.SuspendLayout();
        // 
        // textBox1
        // 
        this.textBox1.Location = new System.Drawing.Point(12, 12);
        this.textBox1.Name = "textBox1";
        this.textBox1.Size = new System.Drawing.Size(380, 21);
        this.textBox1.TabIndex = 0;
        // 
        // button1
        // 
        this.button1.Location = new System.Drawing.Point(268, 45);
        this.button1.Name = "button1";
        this.button1.Size = new System.Drawing.Size(59, 20);
        this.button1.TabIndex = 1;
        this.button1.Text = "确定";
        this.button1.UseVisualStyleBackColor = true;
        this.button1.Click += new System.EventHandler(this.button1_Click);
        // 
        // button2
        // 
        this.button2.Location = new System.Drawing.Point(333, 45);
        this.button2.Name = "button2";
        this.button2.Size = new System.Drawing.Size(59, 20);
        this.button2.TabIndex = 1;
        this.button2.Text = "取消";
        this.button2.UseVisualStyleBackColor = true;
        this.button2.Click += new System.EventHandler(this.button2_Click);
        // 
        // InputBox
        // 
        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
        this.ClientSize = new System.Drawing.Size(404, 74);
        this.Controls.Add(this.button2);
        this.Controls.Add(this.button1);
        this.Controls.Add(this.textBox1);
        this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
        this.MaximizeBox = false;
        this.MinimizeBox = false;
        this.Name = "InputBox";
        this.Text = "输入名称";
        this.TopMost = true;
        this.ResumeLayout(false);
        this.PerformLayout();

    }

    #endregion

    private System.Windows.Forms.TextBox textBox1;
    private System.Windows.Forms.Button button1;
    private System.Windows.Forms.Button button2;
}
public static class FileCopy
{
    public static void Copy(string source, string destination, bool isOverWrite = true)
    {
        //判断源文件是否存在
        if (!System.IO.File.Exists(source))
        {
            return;
        }
        //判断源文件是否为只读,如果是则更改为非只读
        System.IO.FileInfo file = new System.IO.FileInfo(source);
        if (file.IsReadOnly)
        {
            file.IsReadOnly = false;
        }
        //判断目标文件夹是否存在,不存在则创建
        string dir = System.IO.Path.GetDirectoryName(destination);
        try
        {
            System.IO.File.Copy(source, destination, isOverWrite);
        }
        catch (Exception)
        {

        }

    }
}

public static class PointFExtansion
{
    public static Point ToPoint(this PointF p)
    {
        return new Point((int)p.X, (int)p.Y);
    }
}

public static class DeepCopyClass
{
    public static T DeepCopyByBin<T>(this T obj)
    {
        object retval;
        using (MemoryStream ms = new MemoryStream())
        {
            BinaryFormatter bf = new BinaryFormatter();
            //序列化成流
            bf.Serialize(ms, obj);
            ms.Seek(0, SeekOrigin.Begin);
            //反序列化成对象
            retval = bf.Deserialize(ms);
            ms.Close();
        }
        return (T)retval;
    }

    public static void SerialToFile(this object obj, string filePath)
    {
        // 创建文件流
        FileStream fileStream = new FileStream(filePath, FileMode.Create);

        try
        {
            // 创建BinaryFormatter对象
            BinaryFormatter formatter = new BinaryFormatter();

            // 序列化并保存对象到文件流
            formatter.Serialize(fileStream, obj);

            Console.WriteLine("对象已经成功序列化并保存到文件中！");
        }
        catch (Exception ex)
        {
            Console.WriteLine("发生错误：" + ex.Message);
        }
        finally
        {
            // 关闭文件流
            fileStream.Close();
        }

    }
    private static T CloneModel<T>(T oModel)
    {
        var oRes = default(T);
        var oType = typeof(T);

        //create new obj
        oRes = (T)Activator.CreateInstance(oType);

        //pass 1 property
        var lstPro = oType.GetProperties();
        foreach (var oPro in lstPro)
        {
            var oValue = oPro.GetValue(oModel, null);
            oPro.SetValue(oRes, DeepCopy(oValue), null);
        }

        var lstField = oType.GetFields();
        foreach (var oField in lstField)
        {
            var oValue = oField.GetValue(oModel);
            oField.SetValue(oRes, DeepCopy(oValue));
        }
        return oRes;
    }
    public static object DeepCopy(this object obj)
    {
        if (obj == null)
            return null;
        Type type = obj.GetType();

        if (type.IsValueType || type == typeof(string))
        {
            return obj;
        }
        else if (type.IsArray)
        {
            Type elementType = Type.GetType(
                 type.FullName.Replace("[]", string.Empty));
            var array = obj as Array;
            Array copied = Array.CreateInstance(elementType, array.Length);
            for (int i = 0; i < array.Length; i++)
            {
                copied.SetValue(DeepCopy(array.GetValue(i)), i);
            }
            return Convert.ChangeType(copied, obj.GetType());
        }
        else if (type.IsClass)
        {

            object toret = Activator.CreateInstance(obj.GetType());
            FieldInfo[] fields = type.GetFields(BindingFlags.Public |
                        BindingFlags.NonPublic | BindingFlags.Instance);
            foreach (FieldInfo field in fields)
            {
                object fieldValue = field.GetValue(obj);
                if (fieldValue == null)
                    continue;
                field.SetValue(toret, DeepCopy(fieldValue));
            }
            return toret;
        }
        else
            throw new ArgumentException("Unknown type");
    }
}

public class message
{
    public static bool show(string caption, string content, MessageBoxButtons boxButtons = MessageBoxButtons.OKCancel)
    {
        var result = MessageBox.Show(content, caption, boxButtons, MessageBoxIcon.Information);
        if (result == DialogResult.OK || result == DialogResult.Yes)
            return true;
        else
            return false;
    }
}