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);
}
}
/// <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);
}
}
