public static IPolygon GetVisilityPolygon(IPointCollection points)
{
IGeometryBridge2 geometryBridge2 = new GeometryEnvironmentClass();
IPointCollection4 pointCollection4 = new PolygonClass();
WKSPointZ[] aWKSPoints = new WKSPointZ[points.PointCount];
for (int i = 0; i < aWKSPoints.Length; i++)
{
aWKSPoints[i] = PointToWKSPoint(points.Point[i]);
}
geometryBridge2.SetWKSPointZs(pointCollection4, ref aWKSPoints);
var geometry = pointCollection4 as IGeometry;
IZAware zAware = geometry as IZAware;
zAware.ZAware = true;
var result = pointCollection4 as IPolygon;
result.SpatialReference = points.Point[0].SpatialReference;
return(result);
}
public static void AddPaths([NotNull] IList <Linestring> linestringsToAdd,
[NotNull] IPolyline toResult)
{
Func <Pnt3D, WKSPointZ> createPoint;
if (GeometryUtils.IsZAware(toResult))
{
createPoint = p => WKSPointZUtils.CreatePoint(p.X, p.Y, p.Z);
}
else
{
createPoint = p => WKSPointZUtils.CreatePoint(p.X, p.Y, double.NaN);
}
IPath pathTemplate = GeometryFactory.CreateEmptyPath(toResult);
foreach (Linestring resultLinestring in linestringsToAdd)
{
var pathPoints = new WKSPointZ[resultLinestring.SegmentCount + 1];
var i = 0;
foreach (Line3D line3D in resultLinestring)
{
pathPoints[i++] = createPoint(line3D.StartPoint);
}
Pnt3D last = resultLinestring[resultLinestring.SegmentCount - 1].EndPoint;
pathPoints[i] = createPoint(last);
IPath path = GeometryFactory.Clone(pathTemplate);
GeometryUtils.AddWKSPointZs((IPointCollection4)path, pathPoints);
((IGeometryCollection)toResult).AddGeometry(path);
}
}
private static double GetArea([NotNull] IEnumerable <WKSPointZ> points)
{
double area = 0;
var last = new WKSPointZ();
var first = true;
double y0 = 0;
// y-offset of the co-ordinate system, so that ym does not get to large (will be Y of first point)
foreach (WKSPointZ point in points)
{
if (first)
{
y0 = point.Y;
first = false;
}
else
{
double dx = point.X - last.X;
double ym = (point.Y + last.Y) / 2 - y0;
area += dx * ym;
}
last = point;
}
return(area);
}
private bool Disjoint3D(WKSPointZ wksPoint, IPoint point)
{
return(!GeometryUtils.IsSamePoint(
wksPoint.X, wksPoint.Y, wksPoint.Z,
point.X, point.Y, point.Z,
_xyTolerance, _zTolerance));
}
public void CanCalculateSmallTris()
{
var p0 = new WKSPointZ {
X = 679845.1814, Y = 253110.2683, Z = 447.21000000000004
};
var p1 = new WKSPointZ {
X = 679845.468, Y = 253110.3961, Z = 447.21000000000004
};
var p2 = new WKSPointZ {
X = 679845.4679, Y = 253110.3961, Z = 447.21000000000004
};
var q2 = new WKSPointZ {
X = 679845.46795, Y = 253110.3961, Z = 447.21000000000004
};
foreach (double f in new[] { 0.001, 0.03, 0.5, 1, 7, 15, 76, 1000 })
{
ValidateTri(Scale(new List <WKSPointZ> {
p0, p1, p2, p0
}, f), true);
ValidateTri(Scale(new List <WKSPointZ> {
p0, p1, q2, p0
}, f), false);
}
}
private static void ValidateForm([NotNull] IIndexedMultiPatch indexedMultiPatch,
[NotNull] IEnumerable <WKSPointZ> projected)
{
var pre = new WKSPointZ();
bool notFirst = false;
IEnumerator <SegmentProxy> segments =
indexedMultiPatch.GetSegments().GetEnumerator();
foreach (WKSPointZ wksPoint in projected)
{
Assert.AreEqual(0, wksPoint.Z);
if (notFirst)
{
double dx = wksPoint.X - pre.X;
double dy = wksPoint.Y - pre.Y;
double length = Math.Sqrt(dx * dx + dy * dy);
Assert.IsTrue(segments.MoveNext());
Assert.IsNotNull(segments.Current);
const bool as3D = true;
IPnt start = segments.Current.GetStart(as3D);
IPnt end = segments.Current.GetEnd(as3D);
double segDx = end.X - start.X;
double segDy = end.Y - start.Y;
double segDz = end[2] - start[2];
double segmentLength = Math.Sqrt(segDx * segDx + segDy * segDy + segDz * segDz);
Assert.IsTrue(Math.Abs(segmentLength - length) < 1.0e-8);
}
pre = wksPoint;
notFirst = true;
}
}
public static double GetXyDistanceSquared(WKSPointZ a, WKSPointZ b)
{
double dx = a.X - b.X;
double dy = a.Y - b.Y;
return(dx * dx + dy * dy);
}
protected override int ExecuteCore(IRow row, int tableIndex)
{
var feature = row as IFeature;
if (feature == null)
{
return(NoError);
}
var multiPatch = feature.Shape as IMultiPatch;
if (multiPatch == null)
{
return(NoError);
}
var errorCount = 0;
VerticalFaceProvider verticalFaceProvider = GetPlaneProvider(feature);
VerticalFace verticalFace;
while ((verticalFace = verticalFaceProvider.ReadFace()) != null)
{
Plane plane = verticalFace.Plane;
WKSPointZ normal = plane.GetNormalVector();
double verticalCosinus = Math.Abs(normal.Z);
if (verticalCosinus > _nearCosinus)
{
continue;
}
if (verticalCosinus <= _toleranceSinus)
{
continue;
}
double height = verticalFace.Height;
double toleranceSinus = _xyTolerance / height;
if (verticalCosinus <= toleranceSinus)
{
continue;
}
double nonVerticalAngle = Math.Asin(verticalCosinus);
string description = GetIssueDescription(nonVerticalAngle);
IGeometry errorGeometry = verticalFaceProvider.GetErrorGeometry();
errorCount += ReportError(description, errorGeometry,
Codes[Code.NotSufficientlyVertical],
TestUtils.GetShapeFieldName(row),
row);
}
return(errorCount);
}
public void CanReadWriteMultipointXy()
{
var points = new WKSPointZ[4];
points[0] = new WKSPointZ {
X = 2600000, Y = 1200000, Z = double.NaN
};
points[1] = new WKSPointZ {
X = 2600030, Y = 1200020, Z = double.NaN
};
points[2] = new WKSPointZ {
X = 2600020, Y = 1200030, Z = double.NaN
};
points[3] = new WKSPointZ {
X = 2600040, Y = 1200040, Z = double.NaN
};
ISpatialReference sr =
SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95);
IMultipoint multipoint = GeometryFactory.CreateMultipoint(points, sr);
GeometryUtils.MakeNonZAware(multipoint);
WkbGeometryWriter writer = new WkbGeometryWriter();
byte[] wkb = writer.WriteMultipoint(multipoint);
// ArcObjects
byte[] arcObjectsWkb = GeometryUtils.ToWkb(multipoint);
Assert.AreEqual(wkb, arcObjectsWkb);
// Wkx
byte[] wkx = ToChristianSchwarzWkb(ToWkxMultipoint(points, Ordinates.Xy));
Assert.AreEqual(wkx, wkb);
// Bonus test: Geom
WkbGeomWriter geomWriter = new WkbGeomWriter();
Multipoint <IPnt> multipnt = GeometryConversionUtils.CreateMultipoint(multipoint);
byte[] wkbGeom = geomWriter.WriteMultipoint(multipnt, Ordinates.Xy);
Assert.AreEqual(wkb, wkbGeom);
WkbGeometryReader reader = new WkbGeometryReader();
IMultipoint restored = reader.ReadMultipoint(new MemoryStream(wkb));
Assert.IsTrue(GeometryUtils.AreEqual(multipoint, restored));
// Geom
WkbGeomReader geomReader = new WkbGeomReader();
Multipoint <IPnt> deserializedPnts =
geomReader.ReadMultiPoint(new MemoryStream(wkbGeom));
Assert.IsTrue(
GeomRelationUtils.AreMultipointsEqualXY(multipnt, deserializedPnts,
double.Epsilon));
}
public override double GetDirectionAt(double fraction)
{
WKSPointZ from = FromPoint;
WKSPointZ to = ToPoint;
double dir = Math.Atan2(to.Y - from.Y, to.X - from.X);
return(dir);
}
private static WKSPointZ[] GetPointArray([NotNull] IPointCollection4 points)
{
var pointArray = new WKSPointZ[points.PointCount];
GeometryUtils.QueryWKSPointZs(points, pointArray);
return(pointArray);
}
private static Pnt GetPoint(WKSPointZ wks, bool as3D)
{
Pnt p = !as3D
? (Pnt) new Pnt2D(wks.X, wks.Y)
: new Pnt3D(wks.X, wks.Y, wks.Z);
return(p);
}
private bool IsConnected(WKSPointZ x, WKSPointZ y)
{
double dx = x.X - y.X;
double dy = x.Y - y.Y;
double dz = x.Z - y.Z;
double distanceSquare = dx * dx + dy * dy + dz * dz;
return(distanceSquare <= _connectedTolerance * _connectedTolerance);
}
private static WKSPointZ Factor(WKSPointZ p0, WKSPointZ p1, double factor)
{
return(new WKSPointZ
{
X = p0.X + factor * (p1.X - p0.X),
Y = p0.Y + factor * (p1.Y - p0.Y),
Z = p0.Z + factor * (p1.Z - p0.Z)
});
}
private static WKSPointZ[] CreateSquare(
double lowerLeftX, double lowerLeftY, double sideLength,
int pointsPerSide, bool clockWise, double z)
{
pointsPerSide = Math.Max(1, pointsPerSide);
var points = new WKSPointZ[4 * pointsPerSide];
double dist = sideLength / pointsPerSide;
for (var i = 0; i < pointsPerSide; i++)
{
//if (clockWise)
//{
points[i].X = lowerLeftX;
points[i].Y = lowerLeftY + i * dist;
points[i].Z = z;
points[i + pointsPerSide].X = lowerLeftX + i * dist;
points[i + pointsPerSide].Y = lowerLeftY + sideLength;
points[i + pointsPerSide].Z = z;
points[i + 2 * pointsPerSide].X = lowerLeftX + sideLength;
points[i + 2 * pointsPerSide].Y = lowerLeftY + sideLength - i * dist;
points[i + 2 * pointsPerSide].Z = z;
points[i + 3 * pointsPerSide].X = lowerLeftX + sideLength - i * dist;
points[i + 3 * pointsPerSide].Y = lowerLeftY;
points[i + 3 * pointsPerSide].Z = z;
//}
//else
//{
// points[i].X = lowerLeftX + i * dist;
// points[i].Y = lowerLeftY;
// points[i].Z = z;
// points[i + pointsPerSide].X = lowerLeftX + sideLength;
// points[i + pointsPerSide].Y = lowerLeftY + i * dist;
// points[i + pointsPerSide].Z = z;
// points[i + 2 * pointsPerSide].X = lowerLeftX + sideLength - i * dist;
// points[i + 2 * pointsPerSide].Y = lowerLeftY + sideLength;
// points[i + 2 * pointsPerSide].Z = z;
// points[i + 3 * pointsPerSide].X = lowerLeftX;
// points[i + 3 * pointsPerSide].Y = lowerLeftY + sideLength - i * dist;
// points[i + 3 * pointsPerSide].Z = z;
//}
}
if (!clockWise)
{
Array.Reverse(points);
}
return(points);
}
public IPnt GetPoint(int pointIndex, bool clone = false)
{
int actualIndex = _reverseOrder
? _actualStartIndex - pointIndex
: _actualStartIndex + pointIndex;
WKSPointZ wksPoint = _wksPoints[actualIndex];
return(new Pnt3D(wksPoint.X, wksPoint.Y, wksPoint.Z));
}
private bool Disjoint3D(WKSPointZ wksPoint, IGeometry geometry)
{
_pointTemplate.PutCoords(wksPoint.X, wksPoint.Y);
_pointTemplate.Z = wksPoint.Z;
bool disjoint =
((IRelationalOperator3D)geometry).Disjoint3D(_pointTemplate);
return(disjoint);
}
public static Pnt CreatePoint3D(WKSPointZ wksPoint)
{
Pnt result = Pnt.Create(3);
result.X = wksPoint.X;
result.Y = wksPoint.Y;
result[2] = wksPoint.Z;
return(result);
}
public void CanReadWriteSinglePartPolylineXy()
{
var points = new WKSPointZ[4];
points[0] = new WKSPointZ {
X = 2600000, Y = 1200000, Z = double.NaN
};
points[1] = new WKSPointZ {
X = 2600030, Y = 1200020, Z = double.NaN
};
points[2] = new WKSPointZ {
X = 2600020, Y = 1200030, Z = double.NaN
};
points[3] = new WKSPointZ {
X = 2600040, Y = 1200040, Z = double.NaN
};
IPolyline polyline = GeometryFactory.CreatePolyline(points, null);
GeometryUtils.MakeNonZAware(polyline);
GeometryUtils.Simplify(polyline);
WkbGeometryWriter writer = new WkbGeometryWriter();
byte[] wkb = writer.WritePolyline(polyline);
// ArcObjects
byte[] arcObjectsWkb = GeometryUtils.ToWkb(polyline);
Assert.AreEqual(wkb, arcObjectsWkb);
// Wkx
byte[] wkx = ToChristianSchwarzWkb(ToWkxLineString(points, Ordinates.Xy));
Assert.AreEqual(wkx, wkb);
// Bonus test: Geom
WkbGeomWriter geomWriter = new WkbGeomWriter();
MultiPolycurve multiPlycurve = GeometryConversionUtils.CreateMultiPolycurve(polyline);
byte[] wkbGeom = geomWriter.WriteMultiLinestring(multiPlycurve, Ordinates.Xy);
Assert.AreEqual(wkb, wkbGeom);
WkbGeometryReader reader = new WkbGeometryReader();
IPolyline restored = reader.ReadPolyline(new MemoryStream(wkb));
Assert.IsTrue(GeometryUtils.AreEqual(polyline, restored));
// Geom
WkbGeomReader geomReader = new WkbGeomReader();
Assert.IsTrue(
multiPlycurve.Equals(geomReader.ReadMultiPolycurve(new MemoryStream(wkbGeom))));
}
public static WKSPointVA CreateWksPointVa(WKSPointZ wksPointZ)
{
var wksPoint = new WKSPointVA
{
m_x = wksPointZ.X,
m_y = wksPointZ.Y,
m_z = wksPointZ.Z
};
return(wksPoint);
}
public static WKSPointZ GetNormed(WKSPointZ v)
{
double f = Math.Sqrt(v.X * v.X + v.Y * v.Y + v.Z * v.Z);
WKSPointZ result;
result.X = v.X / f;
result.Y = v.Y / f;
result.Z = v.Z / f;
return(result);
}
public override IPnt GetPointAt(double fraction, bool as3D)
{
WKSPointZ from = FromPoint;
WKSPointZ to = ToPoint;
Pnt p0 = GetPoint(from, as3D);
Pnt p1 = GetPoint(to, as3D);
IPnt at = p0 + fraction * (p1 - p0);
return(at);
}
public void GetCoordinates(int pointIndex, out double x, out double y, out double z)
{
int actualIndex = _reverseOrder
? _actualStartIndex - pointIndex
: _actualStartIndex + pointIndex;
WKSPointZ wksPoint = _wksPoints[actualIndex];
x = wksPoint.X;
y = wksPoint.Y;
z = wksPoint.Z;
}
/// <summary>
/// Calculates the cross product of two vectors.
/// </summary>
/// <param name="u">The first vector.</param>
/// <param name="v">The second vector.</param>
/// <returns></returns>
public static WKSPointZ GetVectorProduct(WKSPointZ u, WKSPointZ v)
{
WKSPointZ result;
result.X = u.Y * v.Z - u.Z * v.Y;
result.Y = u.Z * v.X - u.X * v.Z;
// result.Z = u.Y * v.Y - u.Y * v.X;
result.Z = u.X * v.Y - u.Y * v.X;
return(result);
}
public void CanReadWriteMultipointXyz()
{
var points = new WKSPointZ[4];
points[0] = new WKSPointZ {
X = 2600000, Y = 1200000, Z = 456
};
points[1] = new WKSPointZ {
X = 2600030, Y = 1200020, Z = 457
};
points[2] = new WKSPointZ {
X = 2600020, Y = 1200030, Z = 459
};
points[3] = new WKSPointZ {
X = 2600010, Y = 1200010, Z = 416
};
ISpatialReference sr =
SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95);
IMultipoint multipoint = GeometryFactory.CreateMultipoint(points, sr);
WkbGeometryWriter writer = new WkbGeometryWriter();
byte[] wkb = writer.WriteMultipoint(multipoint);
// Wkx
byte[] wkx = ToChristianSchwarzWkb(ToWkxMultipoint(points, Ordinates.Xyz));
Assert.AreEqual(wkx, wkb);
// Bonus test: Geom
WkbGeomWriter geomWriter = new WkbGeomWriter();
Multipoint <IPnt> multipnt = GeometryConversionUtils.CreateMultipoint(multipoint);
byte[] wkbGeom = geomWriter.WriteMultipoint(multipnt, Ordinates.Xyz);
Assert.AreEqual(wkb, wkbGeom);
WkbGeometryReader reader = new WkbGeometryReader();
IMultipoint restored = reader.ReadMultipoint(new MemoryStream(wkb));
Assert.IsTrue(GeometryUtils.AreEqual(multipoint, restored));
// Geom
WkbGeomReader geomReader = new WkbGeomReader();
Multipoint <IPnt> deserializedPnts =
geomReader.ReadMultiPoint(new MemoryStream(wkbGeom));
Assert.IsTrue(multipnt.Equals(deserializedPnts));
}
GetPerpendicularSegmentPairs()
{
for (var baseIndex = 0; baseIndex < _sortedHorizontalSegments.Count; baseIndex++)
{
AzimuthSegment baseSegment = _sortedHorizontalSegments[baseIndex];
double baseAzimuth = baseSegment.Azimuth;
WKSPointZ baseStart =
QaGeometryUtils.GetWksPoint(baseSegment.Segment.GetStart(true));
WKSPointZ baseEnd =
QaGeometryUtils.GetWksPoint(baseSegment.Segment.GetEnd(true));
double exactPerpendicularAzimuth = baseAzimuth + Math.PI / 2;
double minSearchAzimuth = exactPerpendicularAzimuth - NearAngleRad;
double maxSearchAzimuth = exactPerpendicularAzimuth + NearAngleRad;
for (int perpendicularIndex = baseIndex + 1;
perpendicularIndex < _sortedHorizontalSegments.Count;
perpendicularIndex++)
{
AzimuthSegment candidate = _sortedHorizontalSegments[perpendicularIndex];
if (candidate.Azimuth <= minSearchAzimuth)
{
continue;
}
if (candidate.Azimuth >= maxSearchAzimuth)
{
break;
}
WKSPointZ candidateStart =
QaGeometryUtils.GetWksPoint(candidate.Segment.GetStart(true));
WKSPointZ candidateEnd =
QaGeometryUtils.GetWksPoint(candidate.Segment.GetEnd(true));
if (IsConnected(baseStart, candidateStart) ||
IsConnected(baseStart, candidateEnd) ||
IsConnected(baseEnd, candidateStart) ||
IsConnected(baseEnd, candidateEnd))
{
yield return(new PerpendicularSegmentPair(baseSegment, candidate));
}
}
}
}
/// <summary>
/// Advances the vertex index of coordsToAdvance starting at currentIndex until
/// the point at the index matches coordinateToMatch. All intermediate points are
/// added to changedCoords.
/// </summary>
/// <param name="coordsToAdvance">The list of coordinates (sorted) to go through
/// until a coordinate matches <paramref name="coordinateToMatch"/>.</param>
/// <param name="index">The index to start at which shall be incremented unit the coordinates match.</param>
/// <param name="coordinateToMatch">The target coordinate.</param>
/// <param name="comparer">The comparer.</param>
/// <param name="changedCoords">The list of coordinates that do not match.</param>
/// <param name="addChangesToResult">Whether the changed points should be added to changedCoords</param>
/// <param name="reportDuplicateVertices">Whether duplicate vertices in the coordsToAdvance should be reported or not.</param>
/// <returns>Whether a match was found or not.</returns>
private bool AdvanceIndexUntilMatch(
[NotNull] WKSPointZ[] coordsToAdvance,
ref int index,
WKSPointZ coordinateToMatch,
[NotNull] IComparer <WKSPointZ> comparer,
[NotNull] ICollection <WKSPointZ> changedCoords,
bool addChangesToResult,
bool reportDuplicateVertices)
{
WKSPointZ currentCoord = coordsToAdvance[index];
while (comparer.Compare(coordinateToMatch, currentCoord) >= 0 &&
index < coordsToAdvance.Length)
{
// check if within the tolerance - performance could be improved if comparer could directly handle
// the tolerance.
bool useTolerance = Math.Abs(_xyTolerance) > double.Epsilon ||
(!double.IsNaN(_zTolerance) &&
Math.Abs(_zTolerance) > double.Epsilon);
if (useTolerance &&
GeometryUtils.IsSamePoint(currentCoord, coordinateToMatch,
_xyTolerance, _zTolerance))
{
return(true);
}
if (addChangesToResult)
{
// except if it's a duplicate that should not be reported
bool sameAsPrevious = WKSPointZUtils.ArePointsEqual(
coordsToAdvance, index, index - 1,
_xyTolerance, _zTolerance);
if (!sameAsPrevious || reportDuplicateVertices)
{
changedCoords.Add(currentCoord);
}
}
++index;
if (index < coordsToAdvance.Length)
{
currentCoord = coordsToAdvance[index];
}
}
return(false);
}
private static IEnumerable <IPointList> GetAsPointList(
[NotNull] ICollection <IRing> rings)
{
foreach (IRing ring in rings)
{
IPointCollection4 pointCollection = (IPointCollection4)ring;
WKSPointZ[] pointArray = new WKSPointZ[pointCollection.PointCount];
GeometryUtils.QueryWKSPointZs(pointCollection, pointArray);
yield return(new WksPointZPointList(pointArray, 0, pointCollection.PointCount));
}
}
private static IPoint ReadPoint(BinaryReader reader, Ordinates ordinates)
{
WKSPointZ wksPointZ = ReadPointCore(reader, ordinates, new WksPointZFactory());
bool zAware = ordinates == Ordinates.Xyz || ordinates == Ordinates.Xyzm;
IPoint result = GeometryFactory.CreatePoint(wksPointZ);
if (zAware)
{
GeometryUtils.MakeZAware(result);
}
return(result);
}
private static Point ToWkxPoint(WKSPointZ wksPoint,
Ordinates ordinates)
{
switch (ordinates)
{
case Ordinates.Xy:
return(new Point(wksPoint.X, wksPoint.Y));
case Ordinates.Xyz:
return(new Point(wksPoint.X, wksPoint.Y, wksPoint.Z));
default:
throw new NotImplementedException();
}
}
