添加项目文件。

RevitKits/MetroGauges/LandXMLData/DesignShape.cs

@@ -0,0 +1,290 @@
+using System.Xml.Serialization;
+using ShrlAlgoToolkit.RevitAddins.RvIndependent.MetroGauges.LandXMLData.Interfaces;
+
+namespace ShrlAlgoToolkit.RevitAddins.RvIndependent.MetroGauges.LandXMLData;
+
+[XmlType("DesignCrossSectSurf")]
+[Serializable]
+public class DesignShape : ObjectWithNameSideSegmentPart, IComparableStructure<DesignShape>
+{
+    public DesignShape()
+    {
+        CrossSectionPoints = new List<CrossSectionPoint>();
+        Import = true;
+    }
+
+    public DesignShape(DesignShape refShape)
+        : base(refShape)
+    {
+        CrossSectionPoints = new List<CrossSectionPoint>(refShape.CrossSectionPoints);
+        SurfaceID = refShape.SurfaceID;
+        Area = refShape.Area;
+        ClosedArea = refShape.ClosedArea;
+        BorderColorARGB = refShape.BorderColorARGB;
+        FillColorARGB = refShape.FillColorARGB;
+        Import = refShape.Import;
+    }
+
+    public CrossSectionPoint this[int index]
+    {
+        get { return index < CrossSectionPoints.Count ? CrossSectionPoints[index] : throw new IndexOutOfRangeException(); }
+        set
+        {
+            if (index < CrossSectionPoints.Count)
+            {
+                CrossSectionPoints[index] = value;
+                return;
+            }
+
+            if (index == CrossSectionPoints.Count)
+            {
+                CrossSectionPoints.Add(value);
+                return;
+            }
+
+            throw new IndexOutOfRangeException();
+        }
+    }
+
+    public int Count => CrossSectionPoints.Count;
+
+    public bool IsReadOnly => false;
+
+    [XmlIgnore]
+    public IEnumerable<string> PointCodes => from item in CrossSectionPoints select item.Code;
+
+    [XmlIgnore]
+    public string PointCodesFlat
+    {
+        get
+        {
+            var text = string.Empty;
+            foreach (var str in PointCodes)
+            {
+                text = text + str + " ";
+            }
+
+            return text;
+        }
+    }
+
+    [XmlIgnore]
+    public double Station
+    {
+        get { return CrossSection == null ? double.NaN : CrossSection.Station; }
+    }
+
+    [XmlAttribute("closedArea")]
+    public bool ClosedArea { get; set; }
+
+    [XmlAttribute("import")]
+    public bool Import { get; set; }
+
+    [XmlIgnore]
+    public CrossSection CrossSection { get; internal set; }
+
+    [XmlAttribute("area")]
+    public double Area { get; set; }
+
+    [XmlAttribute("bARGB")]
+    public int BorderColorARGB { get; set; }
+
+    [XmlAttribute("fARGB")]
+    public int FillColorARGB { get; set; }
+
+    [XmlElement("CrossSectPnt")]
+    public List<CrossSectionPoint> CrossSectionPoints { get; set; }
+
+    [XmlAttribute("surfID")]
+    public string SurfaceID { get; set; }
+
+    public bool DifferentDescendants(DesignShape shape)
+    {
+        if (CrossSectionPoints.Count == shape.CrossSectionPoints.Count)
+        {
+            for (var i = 0; i < CrossSectionPoints.Count; i++)
+            {
+                if (!CrossSectionPoints[i].Equals(shape.CrossSectionPoints[i]))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public bool DifferentItem(DesignShape shape)
+    {
+        return Station != shape.Station || Area != shape.Area;
+    }
+
+    public bool Equals(DesignShape shape)
+    {
+        return !ReferenceEquals(shape, null) && !DifferentItem(shape) && !DifferentDescendants(shape);
+    }
+
+    public void Add(CrossSectionPoint item)
+    {
+        CrossSectionPoints.Add(item);
+    }
+
+    public void Clear()
+    {
+        CrossSectionPoints.Clear();
+    }
+
+    public bool Contains(CrossSectionPoint item)
+    {
+        return CrossSectionPoints.Contains(item);
+    }
+
+    public void CopyTo(CrossSectionPoint[] array, int arrayIndex)
+    {
+        CrossSectionPoints.CopyTo(array, arrayIndex);
+    }
+
+    public override bool Equals(object obj)
+    {
+        return Equals(obj as DesignShape);
+    }
+
+    public IEnumerator<CrossSectionPoint> GetEnumerator()
+    {
+        return CrossSectionPoints.GetEnumerator();
+    }
+
+    public override int GetHashCode()
+    {
+        return base.GetHashCode();
+    }
+
+    public IEnumerable<string> GetPointCodes(Side side)
+    {
+        if (side == Side.Left)
+        {
+            return (from item in CrossSectionPoints where item.First <= 0.0 select item.Code).Distinct();
+        }
+
+        return side == Side.Right ? (from item in CrossSectionPoints where item.First >= 0.0 select item.Code).Distinct() : PointCodes.Distinct();
+    }
+
+    public int IndexOf(CrossSectionPoint item)
+    {
+        return CrossSectionPoints.IndexOf(item);
+    }
+
+    public void Insert(int index, CrossSectionPoint item)
+    {
+        CrossSectionPoints.Insert(index, item);
+    }
+
+    public bool NameSideEquals(DesignShape ds)
+    {
+        return ds.Name == Name && ds.Part == Part && ds.Side == Side;
+    }
+
+    public bool NameSideSegmentEquals(DesignShape ds)
+    {
+        return NameSideEquals(ds) && ds.Segment == Segment;
+    }
+
+    public bool Remove(CrossSectionPoint item)
+    {
+        return CrossSectionPoints.Remove(item);
+    }
+
+    public void RemoveAt(int index)
+    {
+        CrossSectionPoints.RemoveAt(index);
+    }
+
+    public void SetArea()
+    {
+        Area = 0.0;
+        if (ClosedArea)
+        {
+            var num = CrossSectionPoints.LastIndexOf(CrossSectionPoints[0]) + 1;
+            for (var i = 0; i < num; i++)
+            {
+                var index = (i + 1) % num;
+                Area +=
+                    (CrossSectionPoints[i].First * CrossSectionPoints[index].Second)
+                    - (CrossSectionPoints[index].First * CrossSectionPoints[i].Second);
+            }
+
+            Area /= 2.0;
+        }
+    }
+
+    public bool SetClosedArea()
+    {
+        return CrossSectionPoints.Count > 3 ? (ClosedArea = CrossSectionPoints.LastIndexOf(CrossSectionPoints[0]) > 0) : (ClosedArea = false);
+    }
+
+    public void SetSegment(CrossSection thisSection, CrossSection prevSection)
+    {
+        var flag = true;
+        if (prevSection != null)
+        {
+            var pcf = PointCodesFlat;
+            Segment = thisSection.DesignShapes.Count(ds => ds.NameSideEquals(this));
+            var designShape = (
+                from ds in prevSection.DesignShapes
+                where ds.NameSideEquals(this) && ds.PointCodesFlat == pcf
+                orderby Math.Abs(ds.Segment - Segment)
+                select ds
+            ).FirstOrDefault();
+            if (designShape != null)
+            {
+                Segment = designShape.Segment;
+                flag = false;
+            }
+        }
+
+        if (flag || thisSection.DesignShapes.Count(ds => ds.NameSideSegmentEquals(this)) > 0)
+        {
+            Segment = thisSection.DesignShapes.Count(ds => ds.NameSideEquals(this));
+        }
+    }
+
+    public void SetSide()
+    {
+        if (Count > 0)
+        {
+            Side side;
+            if (CrossSectionPoints.Count(p => p.First == 0.0) != Count)
+            {
+                side =
+                    CrossSectionPoints.Max(p => p.First) > 0.0
+                        ? CrossSectionPoints.Min(p => p.First) >= 0.0
+                            ? Side.Right
+                            : Side.Both
+                        : Side.Left;
+            }
+            else
+            {
+                side = Side.Both;
+            }
+
+            Side = side;
+        }
+    }
+
+    public void Transform(GeometryTransformations transformations)
+    {
+        foreach (var crossSectionPoint in CrossSectionPoints)
+        {
+            crossSectionPoint.Transform(transformations, false);
+        }
+    }
+
+    public void UpdatePointDependentData()
+    {
+        SetSide();
+        SetClosedArea();
+        SetArea();
+    }
+}