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);
}
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);
}
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="source">The element set to copy</param>
public ElementSet(IElementSet source)
{
_description = source.Description;
_id = source.ID;
_elementType = source.ElementType;
_spatialReference = source.SpatialReference;
for (int i = 0; i < source.ElementCount; i++)
{
Element element = new Element(source.GetElementID(i));
for (int j = 0; j < source.GetVertexCount(i); j++)
{
double x = source.GetXCoordinate(i, j);
double y = source.GetYCoordinate(i, j);
double z = source.GetZCoordinate(i, j);
element.AddVertex(new Vertex(x, y, z));
}
_elements.Add(element);
}
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="source">The element set to copy</param>
public ElementSet(IElementSet source)
{
_description = source.Description;
_id = source.ID;
_elementType = source.ElementType;
_spatialReference = source.SpatialReference;
for (int i=0;i<source.ElementCount;i++)
{
Element element = new Element(source.GetElementID(i));
for (int j=0;j<source.GetVertexCount(i);j++)
{
double x = source.GetXCoordinate(i,j);
double y = source.GetYCoordinate(i,j);
double z = source.GetZCoordinate(i,j);
element.AddVertex(new Vertex(x,y,z));
}
_elements.Add(element);
}
}
/// <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.XYPoint)
{
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.XYPolyLine)
{
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.GetXCoordinate(i, j), elementSet.GetYCoordinate(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.XYPolygon)
{
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.GetXCoordinate(i, j), elementSet.GetYCoordinate(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.ID + " is invalid", e);
}
}
private XYPolygon CreateXYPolygon(IElementSet elementSet, int index)
{
if (elementSet.ElementType != ElementType.XYPolygon)
{
throw new System.Exception("Cannot create XYPolyline");
}
XYPolygon xyPolygon = new XYPolygon();
for (int i = 0; i < elementSet.GetVertexCount(index); i++)
{
xyPolygon.Points.Add(new XYPoint(elementSet.GetXCoordinate(index,i), elementSet.GetYCoordinate(index,i)));
}
return xyPolygon;
}
private XYPolyline CreateXYPolyline(IElementSet elementSet, int index)
{
if (!(elementSet.ElementType == ElementType.XYPolyLine || elementSet.ElementType == ElementType.XYLine))
{
throw new System.Exception("Cannot create XYPolyline");
}
XYPolyline xyPolyline = new XYPolyline();
for (int i = 0; i < elementSet.GetVertexCount(index); i++)
{
xyPolyline.Points.Add(new XYPoint(elementSet.GetXCoordinate(index,i), elementSet.GetYCoordinate(index,i)));
}
return xyPolyline;
}
public static bool IsSinglePolyLine(IElementSet elementSet, out string whyNot)
{
whyNot = string.Empty;
if (elementSet is ElementSetPolyLineSingle)
return true;
if (elementSet.ElementType != ElementType.PolyLine)
{
whyNot = "elementSet.ElementType != ElementType.PolyLine";
return false;
}
for (int nElement = 0; nElement < elementSet.ElementCount; ++nElement)
{
if (elementSet.GetVertexCount(nElement) != 2)
{
whyNot = "For at least one nElement elementSet.GetVertexCount(nElement) != 2";
return false;
}
}
for (int nElement = 1; nElement < elementSet.ElementCount; ++nElement)
{
var len = Distance(elementSet, nElement, 0, nElement - 1, 1);
if (len > 10.0 * double.Epsilon)
{
whyNot = "adjacent element vertices > 10.0 * double.Epsilon apart";
return false;
}
}
return true;
}
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.XYPoint)
{
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.XYPolyLine)
{
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.GetXCoordinate(i,j),elementSet.GetYCoordinate(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.XYPolygon)
{
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.GetXCoordinate(i,j),elementSet.GetYCoordinate(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.ID+" is invalid",e);
}
}
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));
}
}
}
}
