/// <summary>
/// Gets the height at the point
/// </summary>
/// <param name="point"></param>
/// <param name="Height"></param>
/// <returns></returns>
public bool TryGetHeight(IXYPoint point, out double?Height)
{
Height = null;
try
{
if (oOracleConn == null)
{
Connect();
}
// select sætning fra Frants.
//select sdo_geor.getCellValue(rast,0,sdo_geometry(2001,32632,sdo_point_type(719000,6178000,null),null,null),1) val from dhm_test
string select = string.Format("select sdo_geor.getCellValue(rast,0,sdo_geometry(2001,32632,sdo_point_type({0},{1},null),null,null),1) val from {2}", point.X, point.Y, TableName);
var com = oOracleConn.CreateCommand();
com.CommandText = select;
Height = Convert.ToDouble(com.ExecuteScalar());
return(true);
}
catch (Exception e)
{
return(false);
}
}
/// <summary>
/// Calculates the distance from a polyline to a point in the plane.
/// The algorithm decides weather the point lies besides the line
/// segment in which case the distance is the length along a line
/// perpendicular to the line. Alternatively the distance is the
/// smallest of the distances to either endpoint.
/// </summary>
/// <param name="line">Line</param>
/// <param name="point">Point</param>
/// <returns>
/// <p>Length of the shortest path between the line and the point.</p>
/// </returns>
protected static double CalculateLineToPointDistance(XYLine line, IXYPoint point)
{
double dist = 0;
double a = Math.Sqrt((line.P2.X - point.X) * (line.P2.X - point.X) + (line.P2.Y - point.Y) * (line.P2.Y - point.Y));
double b = Math.Sqrt((line.P2.X - line.P1.X) * (line.P2.X - line.P1.X) + (line.P2.Y - line.P1.Y) * (line.P2.Y - line.P1.Y));
double c = Math.Sqrt((line.P1.X - point.X) * (line.P1.X - point.X) + (line.P1.Y - point.Y) * (line.P1.Y - point.Y));
if ((a == 0) || (c == 0))
{
dist = 0;
}
else if (b == 0)
{
dist = a;
}
else
{
double alpha = Math.Acos((b * b + c * c - a * a) / (2 * b * c));
double beta = Math.Acos((a * a + b * b - c * c) / (2 * a * b));
if (Math.Max(alpha, beta) < Math.PI / 2)
{
dist = Math.Abs((line.P2.X - line.P1.X) * (line.P1.Y - point.Y) - (line.P1.X - point.X) * (line.P2.Y - line.P1.Y)) / b;
}
else
{
dist = Math.Min(a, c);
}
}
return(dist);
}
public static ModelVisual3D Representation3D(this XYPolygon Poly, IXYPoint refpoint, double height)
{
MeshBuilder mb = new MeshBuilder();
var pts = new Point3DCollection();
foreach (var p in Poly.Points)
{
pts.Add(new Point3D(refpoint.X - p.X, refpoint.Y - p.Y, height));
}
// POLYGONS (flat and convex)
var poly3D = new Polygon3D(pts);
// Transform the polygon to 2D
var poly2D = poly3D.Flatten();
// Triangulate
var tri = poly2D.Triangulate();
if (tri != null)
{
// Add the triangle indices with the 3D points
mb.Append(pts, tri);
}
var m = MaterialHelper.CreateMaterial(Colors.DimGray, 0.5);
var mv3D = new ModelVisual3D();
mv3D.Content = new GeometryModel3D(mb.ToMesh(), m);
return(mv3D);
}
/// <summary>
/// Returns the height above mean sea level from "den digitale højdemodel" with two decimals.
/// Coordinates must be UTM
/// A request takes almost 1 second
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public static bool TryGetHeight(IXYPoint point, int UTMZone, out double?Height)
{
Height = null;
string url = String.Format("http://kmswwwudv1.kms.dk/FindMinHoejde/Default.aspx?display=show&csIn=utm{2}_euref89&csOut=utm32_euref89&x={0}&y={1}&c=dk", point.X, point.Y, UTMZone);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
string resultString;
using (StreamReader streamReader1 = new StreamReader(response.GetResponseStream()))
{
resultString = streamReader1.ReadToEnd();
}
int start = resultString.LastIndexOf("</strong>") + 9;
int end = resultString.LastIndexOf("m</span>");
if (start != -1 & end != -1)
{
string parsestring = resultString.Substring(start, end - start);
Height = double.Parse(parsestring, new CultureInfo("da-DK", false));
return(true);
}
return(false);
}
/// <summary>
/// Returns the distance
/// </summary>
/// <param name="Other"></param>
/// <returns></returns>
public double GetDistance(IXYPoint Other)
{
double diff_N = this.Y - Other.Y;
double diff_E = this.X - Other.X;
return(Math.Sqrt(Math.Pow(diff_N, 2.0) + Math.Pow(diff_E, 2.0)));
}
/// <summary>
/// Returns the height above mean sea level from "den digitale højdemodel" with two decimals.
/// Coordinates must be UTM
/// A request takes almost 1 second
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public static bool TryGetHeight(IXYPoint point, int UTMZone, out double? Height)
{
Height = null;
string url = String.Format("http://kmswwwudv1.kms.dk/FindMinHoejde/Default.aspx?display=show&csIn=utm{2}_euref89&csOut=utm32_euref89&x={0}&y={1}&c=dk", point.X, point.Y, UTMZone);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
string resultString;
using (StreamReader streamReader1 = new StreamReader(response.GetResponseStream()))
{
resultString = streamReader1.ReadToEnd();
}
int start = resultString.LastIndexOf("</strong>") + 9;
int end = resultString.LastIndexOf("m</span>");
if(start!=-1 & end!= -1)
{
string parsestring = resultString.Substring(start, end - start);
Height =double.Parse(parsestring, new CultureInfo("da-DK", false));
return true;
}
return false;
}
/// <summary>
/// Method splitted to permit testing without reading DHI CrossSection
/// </summary>
/// <param name="P1"></param>
/// <param name="P2"></param>
/// <param name="Chainage"></param>
public void SetPoints(IXYPoint P1, IXYPoint P2, double Chainage1, double Chainage2, double Chainage)
{
double dx = P2.X - P1.X;
double dy = P2.Y - P1.Y;
double dchainage = (Chainage - Chainage1)/( Chainage2 - Chainage1);
MidStreamLocation = new XYPoint(P1.X + dchainage * dx, P1.Y + dchainage * dy);
double lenght = Math.Pow(Math.Pow(dx,2)+ Math.Pow(dy,2),0.5);
UnityVector = new XYPoint(dx / lenght, dy / lenght);
//Now build the line where the cross section is located.
if (_cs != null)
{
Line = new XYPolyline();
//MidPoint is set to where Marker 2 is placed
double xOffset = _xsec.LowestPoint.X;
for (int i = 0; i < _xsec.Points.Count(); i++)
{
Line.Points.Add(new XYPoint(MidStreamLocation.X - UnityVector.Y * (_xsec.Points[i].X - xOffset), MidStreamLocation.Y + UnityVector.X * (_xsec.Points[i].X - xOffset)));
}
}
}
private double?FindHeight(IXYPoint point)
{
double?height;
TryFindDemHeight(point, out height);
return(height);
}
/// <summary>
/// Method splitted to permit testing without reading DHI CrossSection
/// </summary>
/// <param name="P1"></param>
/// <param name="P2"></param>
/// <param name="Chainage"></param>
public void SetPoints(IXYPoint P1, IXYPoint P2, double Chainage1, double Chainage2, double Chainage)
{
double dx = P2.X - P1.X;
double dy = P2.Y - P1.Y;
double dchainage = (Chainage - Chainage1) / (Chainage2 - Chainage1);
MidStreamLocation = new XYPoint(P1.X + dchainage * dx, P1.Y + dchainage * dy);
double lenght = Math.Pow(Math.Pow(dx, 2) + Math.Pow(dy, 2), 0.5);
UnityVector = new XYPoint(dx / lenght, dy / lenght);
//Now build the line where the cross section is located.
if (_cs != null)
{
Line = new XYPolyline();
//MidPoint is set to where Marker 2 is placed
double xOffset = _xsec.LowestPoint.X;
for (int i = 0; i < _xsec.Points.Count(); i++)
{
Line.Points.Add(new XYPoint(MidStreamLocation.X - UnityVector.Y * (_xsec.Points[i].X - xOffset), MidStreamLocation.Y + UnityVector.X * (_xsec.Points[i].X - xOffset)));
}
}
}
/// <summary>
/// Checks if the lines lineA and lineB shares a point either as a real
/// crossing point or as a shared end point or a end point of the one
/// line being in the other line.
/// </summary>
/// <param name="Linea">Line.</param>
/// <param name="Lineb">Line.</param>
/// <param name="intersectionPoint">Point.</param>
/// <returns>
/// <p>True if lineA and lineB has shared point. False otherwise</p>
/// <p>The shared point if any is returned in the intersectionPoint
/// parameter that is called by reference</p>
/// </returns>
protected static bool IntersectionPoint(XYLine Linea, XYLine Lineb, ref IXYPoint intersectionPoint)
{
//Jag: this should be call TryGetValue and ref should be out
if (DoLineSegmentsIntersect(Linea, Lineb))
{
intersectionPoint = CalculateIntersectionPoint(Linea, Lineb);
return(true);
}
if (IsPointInLine(Linea.P2, Lineb))
{
intersectionPoint = Linea.P2;
return(true);
}
if (IsPointInLine(Lineb.P2, Linea))
{
intersectionPoint = Lineb.P2;
return(true);
}
if (IsPointInLine(Lineb.P1, Linea))
{
intersectionPoint = Lineb.P1;
return(true);
}
if (IsPointInLine(Linea.P1, Lineb))
{
intersectionPoint = Linea.P1;
return(true);
}
return(false);
}
/// <summary>
/// Gets the height at the point
/// </summary>
/// <param name="point"></param>
/// <param name="Height"></param>
/// <returns></returns>
public bool TryGetHeight(IXYPoint point, out double? Height)
{
Height = null;
try
{
if (oOracleConn == null)
Connect();
// select sætning fra Frants.
//select sdo_geor.getCellValue(rast,0,sdo_geometry(2001,32632,sdo_point_type(719000,6178000,null),null,null),1) val from dhm_test
string select = string.Format("select sdo_geor.getCellValue(rast,0,sdo_geometry(2001,32632,sdo_point_type({0},{1},null),null,null),1) val from {2}", point.X, point.Y, TableName);
var com = oOracleConn.CreateCommand();
com.CommandText = select;
Height = Convert.ToDouble(com.ExecuteScalar());
return true;
}
catch (Exception e)
{
return false;
}
}
/// <summary>
/// Constructor. Copies input line.
/// </summary>
/// <param name="line">Line to copy</param>
public XYLine(XYLine line)
{
_p1 = new XYPoint();
_p2 = new XYPoint();
_p1.X = line.P1.X;
_p1.Y = line.P1.Y;
_p2.X = line.P2.X;
_p2.Y = line.P2.Y;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="point1">Line start point</param>
/// <param name="point2">Line end point</param>
/// <returns>None</returns>
public XYLine(IXYPoint point1, IXYPoint point2)
{
//JAG: Hvorfor beholder den ikke referencerne i stedet for at kopiere værdierne
_p1 = new XYPoint();
_p2 = new XYPoint();
_p1.X = point1.X;
_p1.Y = point1.Y;;
_p2.X = point2.X;
_p2.Y = point2.Y;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="point1">Line start point</param>
/// <param name="point2">Line end point</param>
/// <returns>None</returns>
public XYLine(IXYPoint point1, IXYPoint point2)
{
//JAG: Hvorfor beholder den ikke referencerne i stedet for at kopiere værdierne
_p1 = new XYPoint();
_p2 = new XYPoint();
_p1.X = point1.X;
_p1.Y = point1.Y;;
_p2.X = point2.X;
_p2.Y = point2.Y;
}
public static XYPolygon GetSquare(double area, IXYPoint LowerLeft)
{
double length = Math.Pow(area, 0.5);
XYPolygon pol = new XYPolygon();
pol.Points.Add(LowerLeft);
pol.Points.Add(new XYPoint(LowerLeft.X + length, LowerLeft.Y));
pol.Points.Add(new XYPoint(LowerLeft.X + length, LowerLeft.Y + length));
pol.Points.Add(new XYPoint(LowerLeft.X, LowerLeft.Y + length));
return pol;
}
public static XYPolygon GetSquare(double area, IXYPoint LowerLeft)
{
double length = Math.Pow(area, 0.5);
XYPolygon pol = new XYPolygon();
pol.Points.Add(LowerLeft);
pol.Points.Add(new XYPoint(LowerLeft.X + length, LowerLeft.Y));
pol.Points.Add(new XYPoint(LowerLeft.X + length, LowerLeft.Y + length));
pol.Points.Add(new XYPoint(LowerLeft.X, LowerLeft.Y + length));
return(pol);
}
/// <summary>
/// Returns the height at the point using the method selected with the enums
/// </summary>
/// <param name="point"></param>
/// <param name="height"></param>
/// <returns></returns>
public bool TryFindDemHeight(IXYPoint point, out double?height)
{
height = null;
switch (DEMSource)
{
case SourceType.Oracle:
return(Oracle.TryGetHeight(point, out height));
case SourceType.KMSWeb:
return(KMSData.TryGetHeight(point, 32, out height));
case SourceType.DFS2:
int col = DFSdem.GetColumnIndex(point.X);
int row = DFSdem.GetRowIndex(point.Y);
if (col >= 0 & row >= 0)
{
height = DFSdem.GetData(0, 1)[row, col];
return(true);
}
else
{
return(false);
}
default:
return(false);
case SourceType.HydroInform:
{
XYPoint p = point as XYPoint;
if (LDC.State == System.ServiceModel.CommunicationState.Faulted)
{
return(false);
}
var d = LDC.GetHeight(p.Latitude, p.Longitude);
if (d.HasValue)
{
height = d.Value;
}
return(d.HasValue);
}
}
return(false);
}
/// <summary>
/// Calculate intersection point between two line segments.
/// </summary>
/// <param name="p1">First point in first line</param>
/// <param name="p2">Second point in first line</param>
/// <param name="p3">First point in second line</param>
/// <param name="p4">Second point in second line</param>
/// <returns>Intersection point</returns>
public static XYPoint CalculateIntersectionPoint(IXYPoint p1, IXYPoint p2, IXYPoint p3, IXYPoint p4)
{
if (!DoLineSegmentsIntersect(p1, p2, p3, p4))
{
throw new System.Exception("Attempt to calculate intersection point between non intersecting lines. CalculateIntersectionPoint failed.");
}
XYPoint interSectionPoint = new XYPoint();
double a = p1.X * p2.Y - p2.X * p1.Y;
double b = p3.X * p4.Y - p4.X * p3.Y;
double c = (p1.X - p2.X) * (p3.Y - p4.Y) - (p3.X - p4.X) * (p1.Y - p2.Y);
interSectionPoint.X = (a * (p3.X - p4.X) - (b * (p1.X - p2.X))) / c;
interSectionPoint.Y = (a * (p3.Y - p4.Y) - (b * (p1.Y - p2.Y))) / c;
return(interSectionPoint);
}
/// <summary>
/// Finds the shortest distance between any line segment of the polyline
/// and the point.
/// </summary>
/// <param name="polyLine">PolyLine.</param>
/// <param name="point">Point</param>
/// <returns>
/// <p>Length of the shortest path between the polyline and the point.</p>
/// </returns>
public static double CalculatePolylineToPointDistance(XYPolyline polyLine, IXYPoint point)
{
double dist = 0;
int i = 0;
while (i < polyLine.Points.Count - 1)
{
if (i == 0)
{
dist = CalculateLineToPointDistance(polyLine.GetLine(0), point);
}
else
{
dist = Math.Min(dist, CalculateLineToPointDistance(polyLine.GetLine(i), point));
}
i++;
}
return(dist);
}
public void Write(GeoRefData geodata)
{
double[] Xs = null;
double[] Ys = null;
ShapeLib.ShapeType type = ShapeLib.ShapeType.NullShape;
if (geodata.Geometry is IXYPoint)
{
IXYPoint p = (IXYPoint)geodata.Geometry;
type = ShapeLib.ShapeType.Point;
Xs = new double[] { p.X };
Ys = new double[] { p.Y };
}
else if (geodata.Geometry.GetType().Equals(typeof(XYPolyline)))
{
XYPolyline p = (XYPolyline)geodata.Geometry;
type = ShapeLib.ShapeType.PolyLine;
int npoints = p.Points.Count;
Xs = new double[npoints];
Ys = new double[npoints];
for (int i = 0; i < npoints; i++)
{
Xs[i] = p.Points[i].X;
Ys[i] = p.Points[i].Y;
}
}
else if (geodata.Geometry.GetType().Equals(typeof(XYLine)))
{
XYLine p = (XYLine)geodata.Geometry;
type = ShapeLib.ShapeType.PolyLine;
int npoints = 2;
Xs = new double[] { p.P1.X, p.P2.X };
Ys = new double[] { p.P1.Y, p.P2.Y };;
}
else if (geodata.Geometry.GetType().Equals(typeof(XYPolygon)))
{
XYPolygon p = (XYPolygon)geodata.Geometry;
type = ShapeLib.ShapeType.Polygon;
int npoints = p.Points.Count;
Xs = new double[npoints];
Ys = new double[npoints];
p.Points.Reverse();
for (int i = 0; i < npoints; i++)
{
Xs[i] = p.Points[i].X;
Ys[i] = p.Points[i].Y;
}
p.Points.Reverse();
}
else if (geodata.Geometry.GetType().Equals(typeof(MultiPartPolygon)))
{
MultiPartPolygon p = (MultiPartPolygon)geodata.Geometry;
type = ShapeLib.ShapeType.Polygon;
int npoints = p.Polygons.Sum(pol => pol.Points.Count);
foreach (var poly in p.Polygons)
{
poly.Points.Reverse();
}
Xs = new double[npoints];
Ys = new double[npoints];
int i = 0;
foreach (var point in p.Polygons.SelectMany(pol => pol.Points))
{
Xs[i] = point.X;
Ys[i] = point.Y;
i++;
}
foreach (var poly in p.Polygons)
{
poly.Points.Reverse();
}
}
if (_shapePointer == IntPtr.Zero)
{
_shapePointer = ShapeLib.SHPCreate(_fileName, type);
}
if (_shapePointer == IntPtr.Zero)
{
throw new Exception("Could not create: " + Path.GetFullPath(_fileName) + "\nMake sure directory exists.");
}
IntPtr obj;
if (geodata.Geometry.GetType().Equals(typeof(MultiPartPolygon)))
{
MultiPartPolygon p = (MultiPartPolygon)geodata.Geometry;
int[] partstarts = new int[p.Polygons.Count];
partstarts[0] = 0;
ShapeLib.PartType[] partype = new ShapeLib.PartType[p.Polygons.Count];
for (int i = 0; i < partype.Count(); i++)
{
partype[i] = ShapeLib.PartType.Ring;
}
for (int i = 1; i < partstarts.Count(); i++)
{
partstarts[i] = partstarts[i - 1] + p.Polygons[i - 1].Points.Count;
}
obj = ShapeLib.SHPCreateObject(type, -1, partstarts.Count(), partstarts, partype, Xs.Count(), Xs, Ys, null, null);
}
else
{
obj = ShapeLib.SHPCreateSimpleObject(type, Xs.Count(), Xs, Ys, null);
}
ShapeLib.SHPWriteObject(_shapePointer, -1, obj);
ShapeLib.SHPDestroyObject(obj);
_dbf.WriteData(geodata.Data);
NoOfEntries++;
}
public double? GetHeight(IXYPoint point)
{
return GetHeight(point.X, point.Y);
}
/// <summary>
/// OverLoad of DoLineSegmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4)
/// </summary>
/// <param name="p1">First point in first line</param>
/// <param name="p2">Second point in first line</param>
/// <param name="p3">First point in second line</param>
/// <param name="p4">Second point in second line</param>
/// <returns>true if the line segmenst intersects otherwise false</returns>
public static bool DoLineSegmentsIntersect(IXYPoint p1, IXYPoint p2, IXYPoint p3, IXYPoint p4)
{
return DoLineSegmentsIntersect(p1.X, p1.Y, p2.X, p2.Y, p3.X, p3.Y, p4.X, p4.Y);
}
/// <summary>
/// Interpolates x, y and height. Does not put in lat-long
/// </summary>
/// <param name="Point"></param>
/// <param name="OtherPoint"></param>
/// <param name="Distance"></param>
/// <returns></returns>
public static XYPoint InterpolatePoint(IXYPoint Point, IXYPoint OtherPoint, double Distance)
{
double relativedistance;
if (Distance == 0)
relativedistance = 0;
else
{
double d = ((XYPoint)Point).GetDistance(OtherPoint);
relativedistance = Distance / d;
}
XYPoint NewCoordinate = new XYPoint();
NewCoordinate.X = Point.X - relativedistance * (Point.X - OtherPoint.X);
NewCoordinate.Y = Point.Y - relativedistance * (Point.Y - OtherPoint.Y);
// NewCoordinate. = Point.Height.Value - relativedistance * (Point.Height.Value - OtherPoint.Height.Value);
return NewCoordinate;
}
/// <summary>
/// The method calculates the intersection points of triangle a and b both
/// of type XYPolygon.
/// </summary>
/// <param name="triangleA">triangle. The search is started along triangleA.</param>
/// <param name="triangleB">triangle. Intersection with this triangle are sought.</param>
/// <param name="p">Starting point for the search. p must be part of triangleA.</param>
/// <param name="i">on input: End index for the first line segment of triangleA in the search.
/// on output: End index for the last intersected line segment in triangleA.</param>
/// <param name="j">on input: -1 if vertices before intersection is not to be added to list.
/// on output: End index for last intersected line segment of triangleB.</param>
/// <param name="intersectionPolygon">polygon eventuallu describing the
/// intersection area between triangleA and triangleB</param>
/// <returns>
/// The p, i, j and intersectionPolygon are called by reference and modified in the method.
/// </returns>
private static void Intersect(XYPolygon triangleA, XYPolygon triangleB,
ref IXYPoint p, ref int i, ref int j,
ref XYPolygon intersectionPolygon)
{
XYLine lineA;
XYLine lineB;
int im1 = Decrease(i, 2); // "i-1"
int count1 = 0;
bool found = false;
while ((count1 < 3) && (!found))
{
lineA = triangleA.GetLine(im1);
if (count1 == 0)
{
lineA.P1.X = p.X;
lineA.P1.Y = p.Y;
}
double MinDist = -1; // Distance used when a line is crossed more than once
int jm1 = 0; // "j-1"
int jm1Store = -1;
while (jm1 < 3)
{
lineB = triangleB.GetLine(jm1);
found = IntersectionPoint(lineA, lineB, ref p);
double Dist = CalculatePointToPointDistance(lineA.P1, p);
if (Dist < EPSILON)
{
found = false;
}
if (found)
{
if ((MinDist < 0) || (Dist < MinDist))
{
MinDist = Dist;
jm1Store = jm1;
}
}
jm1++;
}
if (jm1Store > -1)
{
lineB = triangleB.GetLine(jm1Store);
found = IntersectionPoint(lineA, lineB, ref p);
XYPoint HelpCoordinate = new XYPoint(p.X, p.Y);
XYPoint HelpNode = new XYPoint(HelpCoordinate);
intersectionPolygon.Points.Add(HelpNode);
j = Increase(jm1Store, 2);
}
if (!found)
{
count1++;
im1 = Increase(im1, 2);
i = Increase(i, 2);
if (j != -1)
{
XYPoint HelpCoordinate = new XYPoint(lineA.P2.X, lineA.P2.Y);
XYPoint HelpNode = new XYPoint(HelpCoordinate);
intersectionPolygon.Points.Add(HelpNode);
}
}
}
lineA = triangleA.GetLine(Decrease(i, 2));
if (CalculatePointToPointDistance(p, lineA.P2) < EPSILON)
{
i = Increase(i, 2);
}
lineB = triangleB.GetLine(Decrease(j, 2));
if (CalculatePointToPointDistance(p, lineB.P2) < EPSILON)
{
j = Increase(j, 2);
}
}
/// <summary>
/// Returns the distance in two dimensions!
/// </summary>
/// <param name="Other"></param>
/// <returns></returns>
public double GetDistance(IXYPoint Other)
{
double diff_N = this.Y - Other.Y;
double diff_E = this.X - Other.X;
return Math.Sqrt(Math.Pow(diff_N, 2.0) + Math.Pow(diff_E, 2.0));
}
/// <summary>
/// Determines if a point in inside or outside a polygon.
/// Works for both convex and concave polygons (Winding number test)
/// </summary>
/// <param name="point">Point</param>
/// <param name="polygon">Polygon</param>
/// <returns>
/// <p>true: If the point is inside the polygon</p>
/// <p>false: Otherwise.</p>
/// </returns>
public static bool IsPointInPolygon(IXYPoint point, XYPolygon polygon)
{
return(IsPointInPolygon(point.X, point.Y, polygon));
}
private double? FindHeight(IXYPoint point)
{
double? height;
TryFindDemHeight(point, out height);
return height;
}
/// <summary>
/// Determines if a point is included in a lines interior. I.e. included
/// in the line and not an endpoint.
/// <p>Overload to:IsPointInLineInterior(double x, double y, XYLine line)</p>
/// </summary>
/// <param name="point">Point.</param>
/// <param name="line">Line.</param>
/// <returns>
/// <p>Determines if a point is included in a line.</p>
/// </returns>
protected static bool IsPointInLineInterior(IXYPoint point, XYLine line)
{
return(IsPointInLineInterior(point.X, point.Y, line));
}
/// <summary>
/// Returns the height at the point using the method selected with the enums
/// </summary>
/// <param name="point"></param>
/// <param name="height"></param>
/// <returns></returns>
public bool TryFindDemHeight(IXYPoint point, out double? height)
{
height = null;
switch (DEMSource)
{
case SourceType.Oracle:
return Oracle.TryGetHeight(point, out height);
case SourceType.KMSWeb:
return KMSData.TryGetHeight(point, 32, out height);
case SourceType.DFS2:
int col = DFSdem.GetColumnIndex(point.X);
int row = DFSdem.GetRowIndex(point.Y);
if (col >= 0 & row >= 0)
{
height = DFSdem.GetData(0, 1)[row, col];
return true;
}
else
return false;
default:
return false;
case SourceType.HydroInform:
{
XYPoint p = point as XYPoint;
if (LDC.State == System.ServiceModel.CommunicationState.Faulted)
return false;
var d = LDC.GetHeight(p.Latitude, p.Longitude);
if (d.HasValue)
height = d.Value;
return d.HasValue;
}
}
return false;
}
/// <summary>
/// Returns the distance between the two points.
/// </summary>
/// <param name="p1">Point</param>
/// <param name="p2">Point</param>
/// <returns>Point to point distance</returns>
public static double CalculatePointToPointDistance(IXYPoint p1, IXYPoint p2)
{
return(Math.Sqrt((p1.X - p2.X) * (p1.X - p2.X) + (p1.Y - p2.Y) * (p1.Y - p2.Y)));
}
public bool Contains(IXYPoint p)
{
return(Contains(p.X, p.Y));
//return Polygons.Any(poly => poly.Contains(p));
}
/// <summary>
/// Constructor.
/// </summary>
/// <returns>None</returns>
public XYLine()
{
_p1 = new XYPoint();
_p2 = new XYPoint();
}
/// <summary>
/// OverLoad of DoLineSegmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4)
/// </summary>
/// <param name="p1">First point in first line</param>
/// <param name="p2">Second point in first line</param>
/// <param name="p3">First point in second line</param>
/// <param name="p4">Second point in second line</param>
/// <returns>true if the line segmenst intersects otherwise false</returns>
public static bool DoLineSegmentsIntersect(IXYPoint p1, IXYPoint p2, IXYPoint p3, IXYPoint p4)
{
return(DoLineSegmentsIntersect(p1.X, p1.Y, p2.X, p2.Y, p3.X, p3.Y, p4.X, p4.Y));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="x1">x-coordinate for line start point</param>
/// <param name="y1">y-coordinate for line start point</param>
/// <param name="x2">x-coordinate for line end point</param>
/// <param name="y2">y-coordinate for line end point</param>
/// <returns>None</returns>
public XYLine(double x1, double y1, double x2, double y2)
{
_p1 = new XYPoint(x1, y1);
_p2 = new XYPoint(x2, y2);
}
public static List<Visual3D> Representation3D(this JupiterWell Well, IXYPoint refpoint)
{
List<Visual3D> wellrep = new List<Visual3D>();
double x = refpoint.X - Well.X;
double y = refpoint.Y - Well.Y;
TruncatedConeVisual3D tcvw = new TruncatedConeVisual3D();
tcvw.TopRadius = 0.5;
tcvw.BaseRadius = 0.5;
tcvw.Origin = new System.Windows.Media.Media3D.Point3D(x, y, Well.Terrain - Well.Depth.Value);
if (Well.Depth.HasValue)
tcvw.Height = Well.Depth.Value;
else if (Well.Intakes.SelectMany(var => var.Screens).Count() > 0)
tcvw.Height = Well.Intakes.SelectMany(var => var.Screens).Max(var2 => var2.DepthToBottom.Value);
else
tcvw.Height = Well.LithSamples.Max(var => var.Bottom);
tcvw.Fill = new SolidColorBrush(Colors.Gray);
wellrep.Add(tcvw);
foreach (var sc in Well.Intakes.SelectMany(var => var.Screens))
{
if (sc.DepthToBottom.HasValue & sc.DepthToTop.HasValue)
{
TruncatedConeVisual3D tcv = new TruncatedConeVisual3D();
tcv.TopRadius = 0.7;
tcv.BaseRadius = 0.7;
tcv.Origin = new System.Windows.Media.Media3D.Point3D(x, y, sc.BottomAsKote.Value);
tcv.Height = sc.TopAsKote.Value - sc.BottomAsKote.Value;
tcv.Fill = new SolidColorBrush(Colors.Black);
wellrep.Add(tcv);
}
}
foreach (var l in Well.LithSamples)
{
if (l.Top != -999 & l.Bottom != -999)
{
TruncatedConeVisual3D tcv = new TruncatedConeVisual3D();
tcv.TopRadius = 1;
tcv.BaseRadius = 1;
tcv.Origin = new System.Windows.Media.Media3D.Point3D(x, y, Well.Terrain - l.Bottom);
tcv.Height = l.Bottom - l.Top;
SolidColorBrush m;
if (l.RockSymbol.ToLower().Contains("s"))
{
m = new SolidColorBrush(Colors.Blue);
}
else if (l.RockSymbol.ToLower().Contains("l"))
{
m = new SolidColorBrush(Colors.Red);
}
else
m = new SolidColorBrush(Colors.Green);
m.Opacity = 0.3;
tcv.Fill = m;
wellrep.Add(tcv);
TextVisual3D txt = new TextVisual3D();
txt.Center = new Point3D(x+3, y+3, Well.Terrain - (l.Bottom + l.Top)/2.0);
txt.Text = l.RockSymbol;
txt.Height = 1;
wellrep.Add(txt);
}
}
return wellrep;
}
/// <summary>
/// Returns true if the point is inside the polygon
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public bool Contains(IXYPoint p)
{
return(Contains(p.X, p.Y));
}
public static ModelVisual3D Representation3D(this XYPolygon Poly, IXYPoint refpoint, double height)
{
MeshBuilder mb = new MeshBuilder();
var pts = new Point3DCollection();
foreach (var p in Poly.Points)
{
pts.Add(new Point3D(refpoint.X - p.X, refpoint.Y - p.Y, height));
}
// POLYGONS (flat and convex)
var poly3D = new Polygon3D(pts);
// Transform the polygon to 2D
var poly2D = poly3D.Flatten();
// Triangulate
var tri = poly2D.Triangulate();
if (tri != null)
{
// Add the triangle indices with the 3D points
mb.Append(pts, tri);
}
var m = MaterialHelper.CreateMaterial(Colors.DimGray, 0.5);
var mv3D = new ModelVisual3D();
mv3D.Content = new GeometryModel3D(mb.ToMesh(), m);
return mv3D;
}
/// <summary>
/// Returns unityvector holding the direction
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <returns></returns>
public static XYPoint GetDirection(IXYPoint p1, IXYPoint p2)
{
MathNet.Numerics.LinearAlgebra.Double.DenseVector v = new MathNet.Numerics.LinearAlgebra.Double.DenseVector(2);
v[0] = p2.X - p1.X;
v[1] = p2.Y - p1.Y;
v.Normalize(1);
return new XYPoint(v[0], v[1]);
}
public static List <Visual3D> Representation3D(this JupiterWell Well, IXYPoint refpoint)
{
List <Visual3D> wellrep = new List <Visual3D>();
double x = refpoint.X - Well.X;
double y = refpoint.Y - Well.Y;
TruncatedConeVisual3D tcvw = new TruncatedConeVisual3D();
tcvw.TopRadius = 0.5;
tcvw.BaseRadius = 0.5;
tcvw.Origin = new System.Windows.Media.Media3D.Point3D(x, y, Well.Terrain - Well.Depth.Value);
if (Well.Depth.HasValue)
{
tcvw.Height = Well.Depth.Value;
}
else if (Well.Intakes.SelectMany(var => var.Screens).Count() > 0)
{
tcvw.Height = Well.Intakes.SelectMany(var => var.Screens).Max(var2 => var2.DepthToBottom.Value);
}
else
{
tcvw.Height = Well.LithSamples.Max(var => var.Bottom);
}
tcvw.Fill = new SolidColorBrush(Colors.Gray);
wellrep.Add(tcvw);
foreach (var sc in Well.Intakes.SelectMany(var => var.Screens))
{
if (sc.DepthToBottom.HasValue & sc.DepthToTop.HasValue)
{
TruncatedConeVisual3D tcv = new TruncatedConeVisual3D();
tcv.TopRadius = 0.7;
tcv.BaseRadius = 0.7;
tcv.Origin = new System.Windows.Media.Media3D.Point3D(x, y, sc.BottomAsKote.Value);
tcv.Height = sc.TopAsKote.Value - sc.BottomAsKote.Value;
tcv.Fill = new SolidColorBrush(Colors.Black);
wellrep.Add(tcv);
}
}
foreach (var l in Well.LithSamples)
{
if (l.Top != -999 & l.Bottom != -999)
{
TruncatedConeVisual3D tcv = new TruncatedConeVisual3D();
tcv.TopRadius = 1;
tcv.BaseRadius = 1;
tcv.Origin = new System.Windows.Media.Media3D.Point3D(x, y, Well.Terrain - l.Bottom);
tcv.Height = l.Bottom - l.Top;
SolidColorBrush m;
if (l.RockSymbol.ToLower().Contains("s"))
{
m = new SolidColorBrush(Colors.Blue);
}
else if (l.RockSymbol.ToLower().Contains("l"))
{
m = new SolidColorBrush(Colors.Red);
}
else
{
m = new SolidColorBrush(Colors.Green);
}
m.Opacity = 0.3;
tcv.Fill = m;
wellrep.Add(tcv);
TextVisual3D txt = new TextVisual3D();
txt.Center = new Point3D(x + 3, y + 3, Well.Terrain - (l.Bottom + l.Top) / 2.0);
txt.Text = l.RockSymbol;
txt.Height = 1;
wellrep.Add(txt);
}
}
return(wellrep);
}
/// <summary>
/// Determines if a point in inside or outside a polygon.
/// Works for both convex and concave polygons (Winding number test)
/// </summary>
/// <param name="point">Point</param>
/// <param name="polygon">Polygon</param>
/// <returns>
/// <p>true: If the point is inside the polygon</p>
/// <p>false: Otherwise.</p>
/// </returns>
public static bool IsPointInPolygon(IXYPoint point, XYPolygon polygon)
{
return IsPointInPolygon(point.X, point.Y, polygon);
}
/// <summary>
/// Returns true if the location is with the model area
/// </summary>
/// <param name="Location"></param>
/// <returns></returns>
public bool IsInModelArea(IXYPoint Location)
{
return(IsInModelArea(Location.X, Location.Y));
}
public XYZPoint GetXYZ(IXYPoint point)
{
return new XYZPoint() { X = point.X, Y = point.Y, Z = GetHeight(point).Value };
}
/// <summary>
/// Constructor.
/// </summary>
/// <returns>None</returns>
public XYLine()
{
_p1 = new XYPoint();
_p2 = new XYPoint();
}
/// <summary>
/// Calculates the theis drawdown. Pumpingrate is positive for injection. Pumpingrate and transmissivity time units should be seconds
/// </summary>
/// <param name="PumpingWell"></param>
/// <param name="PumpingRate"></param>
/// <param name="Storativity"></param>
/// <param name="Transmissivity"></param>
/// <param name="Time"></param>
/// <param name="ObservationPoint"></param>
/// <returns></returns>
public double Drawdown(IXYPoint PumpingWell, double PumpingRate, double Storativity, double Transmissivity, TimeSpan Time, IXYPoint ObservationPoint)
{
double r = XYGeometryTools.CalculatePointToPointDistance(PumpingWell, ObservationPoint);
return((PumpingRate / (4 * Math.PI * Transmissivity)) * W(r, Storativity, Transmissivity, Time.TotalSeconds));
}
/// <summary>
/// Calculate intersection point between two line segments.
/// </summary>
/// <param name="p1">First point in first line</param>
/// <param name="p2">Second point in first line</param>
/// <param name="p3">First point in second line</param>
/// <param name="p4">Second point in second line</param>
/// <returns>Intersection point</returns>
public static XYPoint CalculateIntersectionPoint(IXYPoint p1, IXYPoint p2, IXYPoint p3, IXYPoint p4)
{
if (!DoLineSegmentsIntersect(p1,p2,p3,p4))
{
throw new System.Exception("Attempt to calculate intersection point between non intersecting lines. CalculateIntersectionPoint failed.");
}
XYPoint interSectionPoint = new XYPoint();
double a = p1.X * p2.Y - p2.X * p1.Y;
double b = p3.X * p4.Y - p4.X * p3.Y;
double c = (p1.X - p2.X) * (p3.Y - p4.Y) - (p3.X - p4.X) * (p1.Y - p2.Y);
interSectionPoint.X = (a * (p3.X - p4.X) - (b * (p1.X - p2.X))) / c;
interSectionPoint.Y = (a * (p3.Y - p4.Y) - (b * (p1.Y - p2.Y))) / c;
return interSectionPoint;
}
public static bool AIntersectionPoint(XYLine lineA, XYLine lineB, ref IXYPoint intersectionPoint)
{
return(IntersectionPoint(lineA, lineB, ref intersectionPoint));
}
/// <summary>
/// The method calculates the intersection points of triangle a and b both
/// of type XYPolygon.
/// </summary>
/// <param name="triangleA">triangle. The search is started along triangleA.</param>
/// <param name="triangleB">triangle. Intersection with this triangle are sought.</param>
/// <param name="p">Starting point for the search. p must be part of triangleA.</param>
/// <param name="i">on input: End index for the first line segment of triangleA in the search.
/// on output: End index for the last intersected line segment in triangleA.</param>
/// <param name="j">on input: -1 if vertices before intersection is not to be added to list.
/// on output: End index for last intersected line segment of triangleB.</param>
/// <param name="intersectionPolygon">polygon eventuallu describing the
/// intersection area between triangleA and triangleB</param>
/// <returns>
/// The p, i, j and intersectionPolygon are called by reference and modified in the method.
/// </returns>
private static void Intersect (XYPolygon triangleA, XYPolygon triangleB,
ref IXYPoint p, ref int i, ref int j,
ref XYPolygon intersectionPolygon)
{
XYLine lineA;
XYLine lineB;
int im1 = Decrease(i, 2); // "i-1"
int count1 = 0;
bool found = false;
while ((count1 < 3) && (!found))
{
lineA = triangleA.GetLine(im1);
if (count1 == 0)
{
lineA.P1.X = p.X;
lineA.P1.Y = p.Y;
}
double MinDist = -1; // Distance used when a line is crossed more than once
int jm1 = 0; // "j-1"
int jm1Store = -1;
while (jm1 < 3)
{
lineB = triangleB.GetLine(jm1);
found = IntersectionPoint(lineA, lineB, ref p);
double Dist = CalculatePointToPointDistance(lineA.P1,p);
if (Dist < EPSILON)
{
found = false;
}
if (found)
{
if ((MinDist < 0) || (Dist < MinDist))
{
MinDist = Dist;
jm1Store = jm1;
}
}
jm1++;
}
if ( jm1Store > -1 )
{
lineB = triangleB.GetLine(jm1Store);
found = IntersectionPoint(lineA, lineB, ref p);
XYPoint HelpCoordinate = new XYPoint(p.X, p.Y);
XYPoint HelpNode = new XYPoint(HelpCoordinate);
intersectionPolygon.Points.Add(HelpNode);
j = Increase(jm1Store,2);
}
if (!found)
{
count1++;
im1 = Increase(im1,2);
i = Increase(i,2);
if (j!=-1)
{
XYPoint HelpCoordinate = new XYPoint(lineA.P2.X, lineA.P2.Y);
XYPoint HelpNode = new XYPoint(HelpCoordinate);
intersectionPolygon.Points.Add(HelpNode);
}
}
}
lineA = triangleA.GetLine(Decrease(i, 2));
if ( CalculatePointToPointDistance(p, lineA.P2)<EPSILON )
{
i = Increase(i, 2);
}
lineB = triangleB.GetLine(Decrease(j, 2));
if ( CalculatePointToPointDistance(p, lineB.P2)<EPSILON )
{
j = Increase(j, 2);
}
}
public XYPoint GetProjectedPoint(IXYPoint PointToProject)
{
double m = (P2.Y - P1.Y) / (P2.X - P1.X);
double b = P1.Y - (m * P1.X);
double x = (m * PointToProject.Y + PointToProject.X - m * b) / (m * m + 1);
double y = (m * m * PointToProject.Y + m * PointToProject.X + b) / (m * m + 1);
return new XYPoint(x, y);
}
/// <summary>
/// Returns the distance between the two points.
/// </summary>
/// <param name="p1">Point</param>
/// <param name="p2">Point</param>
/// <returns>Point to point distance</returns>
public static double CalculatePointToPointDistance(IXYPoint p1, IXYPoint p2)
{
return Math.Sqrt( (p1.X-p2.X)*(p1.X-p2.X)+(p1.Y -p2.Y )*(p1.Y -p2.Y ) );
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="x1">x-coordinate for line start point</param>
/// <param name="y1">y-coordinate for line start point</param>
/// <param name="x2">x-coordinate for line end point</param>
/// <param name="y2">y-coordinate for line end point</param>
/// <returns>None</returns>
public XYLine(double x1, double y1, double x2, double y2)
{
_p1 = new XYPoint(x1,y1);
_p2 = new XYPoint(x2,y2);
}
/// <summary>
/// Checks if the lines lineA and lineB shares a point either as a real
/// crossing point or as a shared end point or a end point of the one
/// line being in the other line.
/// </summary>
/// <param name="Linea">Line.</param>
/// <param name="Lineb">Line.</param>
/// <param name="intersectionPoint">Point.</param>
/// <returns>
/// <p>True if lineA and lineB has shared point. False otherwise</p>
/// <p>The shared point if any is returned in the intersectionPoint
/// parameter that is called by reference</p>
/// </returns>
protected static bool IntersectionPoint(XYLine Linea, XYLine Lineb, ref IXYPoint intersectionPoint)
{
//Jag: this should be call TryGetValue and ref should be out
if( DoLineSegmentsIntersect(Linea, Lineb))
{
intersectionPoint = CalculateIntersectionPoint(Linea, Lineb);
return true;
}
if( IsPointInLine(Linea.P2, Lineb))
{
intersectionPoint = Linea.P2;
return true;
}
if( IsPointInLine(Lineb.P2, Linea))
{
intersectionPoint = Lineb.P2;
return true;
}
if( IsPointInLine(Lineb.P1, Linea))
{
intersectionPoint = Lineb.P1;
return true;
}
if( IsPointInLine(Linea.P1, Lineb))
{
intersectionPoint = Linea.P1;
return true;
}
return false;
}
/// <summary>
/// Constructor. Copies input line.
/// </summary>
/// <param name="line">Line to copy</param>
public XYLine(XYLine line)
{
_p1 = new XYPoint();
_p2 = new XYPoint();
_p1.X = line.P1.X;
_p1.Y = line.P1.Y;
_p2.X = line.P2.X;
_p2.Y = line.P2.Y;
}
/// <summary>
/// Determines if a point is included in a lines interior. I.e. included
/// in the line and not an endpoint.
/// <p>Overload to:IsPointInLineInterior(double x, double y, XYLine line)</p>
/// </summary>
/// <param name="point">Point.</param>
/// <param name="line">Line.</param>
/// <returns>
/// <p>Determines if a point is included in a line.</p>
/// </returns>
protected static bool IsPointInLineInterior(IXYPoint point, XYLine line)
{
return IsPointInLineInterior( point.X, point.Y, line);
}
/// <summary>
/// Constructor.
/// </summary>
/// <returns>None</returns>
public XYPoint(IXYPoint xypoint)
{
_x = xypoint.X;
_y = xypoint.Y;
}
/// <summary>
/// Calculates the distance from a polyline to a point in the plane.
/// The algorithm decides weather the point lies besides the line
/// segment in which case the distance is the length along a line
/// perpendicular to the line. Alternatively the distance is the
/// smallest of the distances to either endpoint.
/// </summary>
/// <param name="line">Line</param>
/// <param name="point">Point</param>
/// <returns>
/// <p>Length of the shortest path between the line and the point.</p>
/// </returns>
protected static double CalculateLineToPointDistance (XYLine line, IXYPoint point)
{
double dist = 0;
double a = Math.Sqrt((line.P2.X-point.X)*(line.P2.X-point.X) + (line.P2.Y-point.Y)*(line.P2.Y-point.Y));
double b = Math.Sqrt((line.P2.X-line.P1.X)*(line.P2.X-line.P1.X)+(line.P2.Y-line.P1.Y)*(line.P2.Y-line.P1.Y));
double c = Math.Sqrt((line.P1.X-point.X)*(line.P1.X-point.X)+(line.P1.Y-point.Y)*(line.P1.Y-point.Y));
if ((a == 0) || (c == 0))
{
dist = 0;
}
else if (b == 0)
{
dist = a;
}
else
{
double alpha = Math.Acos((b*b+c*c-a*a)/(2*b*c));
double beta = Math.Acos((a*a+b*b-c*c)/(2*a*b));
if (Math.Max(alpha,beta)<Math.PI/2)
{
dist = Math.Abs((line.P2.X-line.P1.X)*(line.P1.Y-point.Y)-(line.P1.X-point.X)*(line.P2.Y-line.P1.Y))/b;
}
else
{
dist = Math.Min(a, c);
}
}
return dist;
}
/// <summary>
/// Gets the id for a point
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public int GetID(IXYPoint point)
{
return GetID(point.X,point.Y);
}
/// <summary>
/// Finds the shortest distance between any line segment of the polyline
/// and the point.
/// </summary>
/// <param name="polyLine">PolyLine.</param>
/// <param name="point">Point</param>
/// <returns>
/// <p>Length of the shortest path between the polyline and the point.</p>
/// </returns>
public static double CalculatePolylineToPointDistance (XYPolyline polyLine, IXYPoint point)
{
double dist = 0;
int i = 0;
while (i < polyLine.Points.Count - 1)
{
if (i == 0)
{
dist = CalculateLineToPointDistance (polyLine.GetLine(0), point);
}
else
{
dist = Math.Min(dist, CalculateLineToPointDistance (polyLine.GetLine(i), point));
}
i++;
}
return dist;
}
/// <summary>
/// Gets the id for a point
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public int GetID(IXYPoint point)
{
return(GetID(point.X, point.Y));
}
/// <summary>
/// Does the same as CalculatePolylineToPointDistance but also returns the line number
/// </summary>
/// <param name="polyLine"></param>
/// <param name="point"></param>
/// <returns></returns>
public static Tuple<int, double> GetClosetLine (XYPolyline polyLine, IXYPoint point)
{
double dist = double.MaxValue;
int i = 0;
int mini=0;
while (i < polyLine.Points.Count - 1)
{
var newdist = CalculateLineToPointDistance(polyLine.GetLine(i), point);
if(newdist<dist)
{
dist=newdist;
mini =i;
}
i++;
}
return new Tuple<int, double>(mini, dist);
}
