public static double Distance(IElementSet elementSet, int nElement1, int nVertex1, int nElement2, int nVertex2) { var dx = elementSet.GetVertexXCoordinate(nElement2, nVertex2) - elementSet.GetVertexXCoordinate(nElement1, nVertex1); var dy = elementSet.GetVertexYCoordinate(nElement2, nVertex2) - elementSet.GetVertexYCoordinate(nElement1, nVertex1); var dz = elementSet.HasZ ? elementSet.GetVertexZCoordinate(nElement2, nVertex2) - elementSet.GetVertexZCoordinate(nElement1, nVertex1) : 0.0; return Math.Sqrt(dx * dx + dy * dy + dz * dz); }
private void CheckRegularGridElmtSet(IElementSet gridSet) { Assert.AreEqual(8, gridSet.ElementCount); // Check corner coordinates of first element Assert.AreEqual(10, gridSet.GetVertexXCoordinate(0, 0)); Assert.AreEqual(10, gridSet.GetVertexYCoordinate(0, 0)); Assert.AreEqual(110, gridSet.GetVertexXCoordinate(0, 1)); Assert.AreEqual(10, gridSet.GetVertexYCoordinate(0, 1)); Assert.AreEqual(110, gridSet.GetVertexXCoordinate(0, 2)); Assert.AreEqual(210, gridSet.GetVertexYCoordinate(0, 2)); Assert.AreEqual(10, gridSet.GetVertexXCoordinate(0, 3)); Assert.AreEqual(210, gridSet.GetVertexYCoordinate(0, 3)); }
public Element(IElementSet set, int nElement) { Identity = new Identity(set.GetElementId(nElement)); int nV = set.GetVertexCount(nElement); int nF = set.GetFaceCount(nElement); X = new double[nV]; Y = new double[nV]; if (set.HasZ) Z = new double[nV]; if (set.HasM) M = new double[nV]; for (int n = 0; n < nV; ++n) { X[n] = set.GetVertexXCoordinate(nElement, n); Y[n] = set.GetVertexYCoordinate(nElement, n); if (set.HasZ) Z[n] = set.GetVertexZCoordinate(nElement, n); if (set.HasM) M[n] = set.GetVertexMCoordinate(nElement, n); } if (nF > 0) { Faces = new int[nF][]; for (int n = 0; n < nF; ++n) Faces[n] = set.GetFaceVertexIndices(nElement, n); } }
/// <summary> /// Build a search tree based on an <see cref="IElementSet"/>, containing /// element index references. /// </summary> /// <param name="elmtSet">Element set to build search tree around</param> /// <returns>Search tree</returns> public static XYElementSearchTree <int> BuildSearchTree(IElementSet elmtSet) { // Calculate start extent XYExtent extent = new XYExtent(); int elementCount = elmtSet.ElementCount; for (int ielmt = 0; ielmt < elementCount; ielmt++) { int vertixCount = elmtSet.GetVertexCount(ielmt); for (int ivert = 0; ivert < vertixCount; ivert++) { double x = elmtSet.GetVertexXCoordinate(ielmt, ivert); double y = elmtSet.GetVertexYCoordinate(ielmt, ivert); extent.Include(x, y); } } // Create and build search tree, based on all vertex coordinates XYElementSearchTree <int> tree = new XYElementSearchTree <int>(extent); for (int ielmt = 0; ielmt < elementCount; ielmt++) { int vertixCount = elmtSet.GetVertexCount(ielmt); for (int ivert = 0; ivert < vertixCount; ivert++) { double x = elmtSet.GetVertexXCoordinate(ielmt, ivert); double y = elmtSet.GetVertexYCoordinate(ielmt, ivert); tree.Add(new XYPoint(x, y)); } } // Add elements to the search tree for (int ielmt = 0; ielmt < elementCount; ielmt++) { int vertixCount = elmtSet.GetVertexCount(ielmt); XYExtent elmtExtent = new XYExtent(); for (int ivert = 0; ivert < vertixCount; ivert++) { double x = elmtSet.GetVertexXCoordinate(ielmt, ivert); double y = elmtSet.GetVertexYCoordinate(ielmt, ivert); elmtExtent.Include(x, y); } tree.AddElement(ielmt, elmtExtent); } return(tree); }
private static XYPoint CreateXYPoint(IElementSet elementSet, int index) { if (elementSet.ElementType != ElementType.Point) { throw new ArgumentOutOfRangeException("elementSet", "Cannot create XYPoint, the element type of the element set is not XYPoint"); } return(new XYPoint(elementSet.GetVertexXCoordinate(index, 0), elementSet.GetVertexYCoordinate(index, 0))); }
public static XYPolygon CreateFromXYPolygon(IElementSet elementSet, int index) { if (elementSet.ElementType != ElementType.Polygon) { throw new Exception("Cannot create XYPolyline"); } XYPolygon xyPolygon = new XYPolygon(); for (int i = 0; i < elementSet.GetVertexCount(index); i++) { xyPolygon.Points.Add(new XYPoint(elementSet.GetVertexXCoordinate(index, i), elementSet.GetVertexYCoordinate(index, i))); } return(xyPolygon); }
public static XYPolyline CreateXYPolyline(IElementSet elementSet, int index) { if (!(elementSet.ElementType == ElementType.PolyLine)) { throw new Exception("Cannot create XYPolyline"); } var xyPolyline = new XYPolyline(); for (int i = 0; i < elementSet.GetVertexCount(index); i++) { xyPolyline.Points.Add(new XYPoint(elementSet.GetVertexXCoordinate(index, i), elementSet.GetVertexYCoordinate(index, i))); } return(xyPolyline); }
/// <summary> /// Copy constructor /// </summary> /// <param name="source">The element set to copy</param> public ElementSet(IElementSet source) { _description = source.Description; _caption = source.Caption; _elementType = source.ElementType; _spatialReferenceWKT = source.SpatialReferenceSystemWkt; for (int i = 0; i < source.ElementCount; i++) { Element element = new Element(source.GetElementId(i).Id); for (int j = 0; j < source.GetVertexCount(i); j++) { Coordinate vertex = new Coordinate(source.GetVertexXCoordinate(i, j), source.GetVertexYCoordinate(i, j), source.GetVertexZCoordinate(i, j)); element.AddVertex(vertex); } elements.Add(element); } }
public override void UpdateGeometry(IElementSet elementSetEdits) { Contract.Requires(UpdateGeometryAvailable(elementSetEdits), "updateGeometryAvailable(elementSetEdits)"); base.UpdateGeometry(elementSetEdits); X = new double[elementSetEdits.ElementCount]; Y = new double[elementSetEdits.ElementCount]; Z = elementSetEdits.HasZ ? new double[elementSetEdits.ElementCount] : null; M = elementSetEdits.HasM ? new double[elementSetEdits.ElementCount] : null; int nVertex = 0; for (int nElement = 0; nElement < elementSetEdits.ElementCount; ++nElement) { X[nElement] = elementSetEdits.GetVertexXCoordinate(nElement, nVertex); Y[nElement] = elementSetEdits.GetVertexYCoordinate(nElement, nVertex); if (HasZ) Z[nElement] = elementSetEdits.GetVertexZCoordinate(nElement, nVertex); if (HasM) M[nElement] = elementSetEdits.GetVertexMCoordinate(nElement, nVertex); } }
//=============================================================================================== //CheckElementSet(IElementSet elementSet): void static //=============================================================================================== /// <summary> /// Static method that validates an object with an IElementSet interface. The method /// raises an Exception in case IElementSet does not describe a valid ElementSet. /// The checks made are: /// <p>ElementType: Check</p> /// <p>XYPoint: Only one vertex in each element.</p> /// <p>XYPolyline: At least two vertices in each element.</p> /// <p> All line segments in each element has length > 0</p> /// <p>XYPolygon: At least three vertices in each element.</p> /// <p> Area of each element is larger than 0</p> /// <p> All line segments in each element has length > 0</p> /// <p> No line segments within an element crosses.</p> /// </summary> /// /// <param name="elementSet">Object that implement the IElementSet interface</param> /// /// <returns> /// The method has no return value. /// </returns> public static void CheckElementSet(IElementSet elementSet) { try { if (elementSet.ElementType == ElementType.Point) { for (int i = 0; i < elementSet.ElementCount; i++) { try { if (elementSet.GetVertexCount(i) != 1) { throw new System.Exception("Number of vertices in point element is different from 1."); } } catch (System.Exception e) { throw new System.Exception("ElementID = " + elementSet.GetElementId(i), e); } } } else if (elementSet.ElementType == ElementType.PolyLine) { for (int i = 0; i < elementSet.ElementCount; i++) { try { XYPolyline xypolyline = new XYPolyline(); for (int j = 0; j < elementSet.GetVertexCount(i); j++) { XYPoint xypoint = new XYPoint(elementSet.GetVertexXCoordinate(i, j), elementSet.GetVertexYCoordinate(i, j)); xypolyline.Points.Add(xypoint); } xypolyline.Validate(); } catch (System.Exception e) { throw new System.Exception("ElementID = " + elementSet.GetElementId(i), e); } } } else if (elementSet.ElementType == ElementType.Polygon) { for (int i = 0; i < elementSet.ElementCount; i++) { try { XYPolygon xypolygon = new XYPolygon(); for (int j = 0; j < elementSet.GetVertexCount(i); j++) { XYPoint xypoint = new XYPoint(elementSet.GetVertexXCoordinate(i, j), elementSet.GetVertexYCoordinate(i, j)); xypolygon.Points.Add(xypoint); } xypolygon.Validate(); } catch (System.Exception e) { throw new System.Exception("ElementID = " + elementSet.GetElementId(i), e); } } } } catch (System.Exception e) { throw new System.Exception("ElementSet with ID = " + elementSet.Caption + " is invalid", e); } }
public override void UpdateGeometry(IElementSet elementSet) { Contract.Requires(UpdateGeometryAvailable(elementSet), "updateGeometryAvailable(elementSet)"); base.UpdateGeometry(elementSet); var es = elementSet as ElementSetVerticesNonUnique; if (es != null) { X = es.X.Select(a => a.ToArray()).ToArray(); Y = es.Y.Select(a => a.ToArray()).ToArray(); Z = es.Z == null ? null : es.Z.Select(a => a.ToArray()).ToArray(); M = es.M == null ? null : es.M.Select(a => a.ToArray()).ToArray(); return; } X = new double[elementSet.ElementCount][]; Y = new double[elementSet.ElementCount][]; Z = HasZ ? new double[elementSet.ElementCount][] : null; M = HasM ? new double[elementSet.ElementCount][] : null; for (int nElement = 0; nElement < elementSet.ElementCount; ++nElement) { var nVertexLength = elementSet.GetVertexCount(nElement); X[nElement] = new double[nVertexLength]; Y[nElement] = new double[nVertexLength]; if (HasZ) Z[nElement] = new double[nVertexLength]; if (HasM) M[nElement] = new double[nVertexLength]; var vertexIndexs = Enumerable.Range(0, nVertexLength).ToArray(); foreach (var nVertex in vertexIndexs) { X[nElement][nVertex] = elementSet.GetVertexXCoordinate(nElement, nVertex); Y[nElement][nVertex] = elementSet.GetVertexYCoordinate(nElement, nVertex); if (HasZ) Z[nElement][nVertex] = elementSet.GetVertexZCoordinate(nElement, nVertex); if (HasM) M[nElement][nVertex] = elementSet.GetVertexMCoordinate(nElement, nVertex); } } }
private void panelViewer_MouseMove(object sender, System.Windows.Forms.MouseEventArgs e) { // write x and y coordinates double x = ((e.X - _margin) / _scale) + _minX; double y = _minY - (e.Y + _margin - panelViewer.ClientSize.Height) / _scale; if (_scale != double.MaxValue) { this.label3.Text = "(" + x.ToString("F3") + ", " + y.ToString("F3") + ")"; } else { this.label3.Text = ""; } // write elementSet ID and element index this.label4.Text = " "; this.label7.Text = " "; this.label8.Text = " "; this.label9.Text = " "; this.label10.Text = " "; this.label11.Text = " "; for (int elementSetNumber = 0; elementSetNumber < this._elementSets.Count; elementSetNumber++) { string elementID = " "; int elementIndex = -9; double distance = 10e30; IElementSet elementSet = (IElementSet)_elementSets[elementSetNumber]; if (elementSetNumber == 0) { this.label7.Text = elementSet.Caption.Substring(0, Math.Min(20, elementSet.Caption.Length)); } if (elementSetNumber == 1) { this.label9.Text = elementSet.Caption.Substring(0, Math.Min(20, elementSet.Caption.Length)); } for (int index = 0; index < elementSet.ElementCount; index++) { if (((IElementSet)_elementSets[elementSetNumber]).ElementType == ElementType.Polygon) { XYPolygon xyPolygon = new XYPolygon(); for (int i = 0; i < elementSet.GetVertexCount(index); i++) { xyPolygon.Points.Add(new XYPoint(elementSet.GetVertexXCoordinate(index, i), elementSet.GetVertexYCoordinate(index, i))); } if (XYGeometryTools.IsPointInPolygon(x, y, xyPolygon)) { elementID = elementSet.GetElementId(index).Id; elementIndex = index; } } if (((IElementSet)_elementSets[elementSetNumber]).ElementType == ElementType.PolyLine) { XYPolyline xyPolyline = new XYPolyline(); for (int i = 0; i < elementSet.GetVertexCount(index); i++) { xyPolyline.Points.Add(new XYPoint(elementSet.GetVertexXCoordinate(index, i), elementSet.GetVertexYCoordinate(index, i))); } double xx = XYGeometryTools.CalculatePolylineToPointDistance(xyPolyline, new XYPoint(x, y)); if (xx < distance) { distance = xx; if (xx < 0.3 * xyPolyline.GetLength()) { elementIndex = index; elementID = elementSet.GetElementId(index).Id; } } } if (elementSetNumber == 0 && elementIndex >= 0) { this.label4.Text = "Index: " + elementIndex.ToString(); this.label8.Text = "ID: " + elementID.Substring(0, Math.Min(17, elementID.Length)); } if (elementSetNumber == 1 && elementIndex >= 0) { this.label10.Text = "Index: " + elementIndex.ToString(); this.label11.Text = "ID: " + elementID.Substring(0, Math.Min(17, elementID.Length)); } } } }
private static XYPolygon CreateXYPolygon(IElementSet elementSet, int index) { if (elementSet.ElementType != ElementType.Polygon) { throw new Exception("Cannot create XYPolyline"); } var xyPolygon = new XYPolygon(); for (int i = 0; i < elementSet.GetVertexCount(index); i++) { xyPolygon.Points.Add(new XYPoint(elementSet.GetVertexXCoordinate(index, i), elementSet.GetVertexYCoordinate(index, i))); } return xyPolygon; }
private static XYPoint CreateXYPoint(IElementSet elementSet, int index) { if (elementSet.ElementType != ElementType.Point) { throw new ArgumentOutOfRangeException("elementSet", "Cannot create XYPoint, the element type of the element set is not XYPoint"); } return new XYPoint(elementSet.GetVertexXCoordinate(index, 0), elementSet.GetVertexYCoordinate(index, 0)); }
/// <summary> /// Static method that validates an object with an IElementSet interface. The method /// raises an Exception in case IElementSet does not describe a valid ElementSet. /// The checks made are: /// <p>ElementType: Check</p> /// <p>XYPoint: Only one vertex in each element.</p> /// <p>XYPolyline: At least two vertices in each element.</p> /// <p> All line segments in each element has length > 0</p> /// <p>XYPolygon: At least three vertices in each element.</p> /// <p> Area of each element is larger than 0</p> /// <p> All line segments in each element has length > 0</p> /// <p> No line segments within an element crosses.</p> /// </summary> /// /// <param name="elementSet">Object that implement the IElementSet interface</param> /// /// <returns> /// The method has no return value. /// </returns> public static void CheckElementSet(IElementSet elementSet) { try { if (elementSet.ElementType == ElementType.Point) { for (int i = 0; i < elementSet.ElementCount; i++) { try { if (elementSet.GetVertexCount(i) != 1) { throw new System.Exception("Number of vertices in point element is different from 1."); } } catch (System.Exception e) { throw new System.Exception("ElementID = " + elementSet.GetElementId(i), e); } } } else if (elementSet.ElementType == ElementType.PolyLine) { for (int i = 0; i < elementSet.ElementCount; i++) { try { XYPolyline xypolyline = new XYPolyline(); for (int j = 0; j < elementSet.GetVertexCount(i); j++) { Coordinate coordinate = new Coordinate(elementSet.GetVertexXCoordinate(i, j), elementSet.GetVertexYCoordinate(i, j), elementSet.GetVertexZCoordinate(i, j)); XYPoint xypoint = new XYPoint(coordinate.X, coordinate.Y); xypolyline.Points.Add(xypoint); } xypolyline.Validate(); } catch (System.Exception e) { throw new System.Exception("ElementID = " + elementSet.GetElementId(i), e); } } } else if (elementSet.ElementType == ElementType.Polygon) { for (int i = 0; i < elementSet.ElementCount; i++) { try { XYPolygon xypolygon = new XYPolygon(); for (int j = 0; j < elementSet.GetVertexCount(i); j++) { XYPoint xypoint = new XYPoint(elementSet.GetVertexXCoordinate(i, j), elementSet.GetVertexYCoordinate(i, j)); xypolygon.Points.Add(xypoint); } xypolygon.Validate(); } catch (System.Exception e) { throw new System.Exception("ElementID = " + elementSet.GetElementId(i), e); } } } } catch (System.Exception e) { throw new System.Exception("ElementSet with Caption = " + elementSet.Caption + " is invalid", e); } }