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