private static IMultipoint RemoveVertexIntersections(
[NotNull] IMultipoint intersectionPoints,
[NotNull] IPolyline polyline1,
[NotNull] IPolyline polyline2,
double vertexSearchDistance)
{
var remainingPoints = new List <IPoint>();
foreach (IPoint intersectionPoint in
QueryPoints(intersectionPoints, TemplatePoint1))
{
if (IntersectsVertex(intersectionPoint, polyline2, TemplatePoint2,
vertexSearchDistance) &&
IntersectsVertex(intersectionPoint, polyline1, TemplatePoint2,
vertexSearchDistance))
{
// intersection point intersects vertex on both polylines
// -> skip
continue;
}
remainingPoints.Add(GeometryFactory.Clone(intersectionPoint));
}
return(GeometryFactory.CreateMultipoint(remainingPoints));
}
public void CanGetMultipointPolylineCrossesIntersection()
{
var matrix = new IntersectionMatrix("T*T******");
IMultipoint g1 = GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(0, 5, 0),
GeometryFactory.CreatePoint(15, 5, 0));
IPolyline g2 = GeometryFactory.CreatePolyline(5, 5, 1000, 15, 5, 1000);
// TODO with the spatial reference assigned, the intersection contains only one point (0,5)
// without spatial reference, it contains two points (0,5 and 15,5)
//g1.SpatialReference = _spatialReference;
//g2.SpatialReference = _spatialReference;
IList <IGeometry> result12 = matrix.GetIntersections(g1, g2);
Assert.AreEqual(1, result12.Count);
Console.WriteLine(GeometryUtils.ToString(result12[0]));
Assert.AreEqual(2, GeometryUtils.GetPointCount(result12));
//Assert.IsTrue(SpatialReferenceUtils.AreEqual(_spatialReference,
// result12[0].SpatialReference));
IList <IGeometry> result21 = matrix.GetIntersections(g2, g1);
Assert.AreEqual(1, result21.Count);
Console.WriteLine(GeometryUtils.ToString(result21[0]));
Assert.IsTrue(
GeometryUtils.AreEqualInXY(result21[0],
g2)); // can't subtract, same as g2
}
public void CanSearchSingleMultipoint()
{
AssertCanFindGeometry(GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(1000, 1000),
GeometryFactory.CreatePoint(2000, 1000),
GeometryFactory.CreatePoint(3000, 1000)));
}
public void LearningTestCantSubtractMultipointFromPoint()
{
IPoint g1 = GeometryFactory.CreatePoint(10, 5, 1000);
IMultipoint g2 = GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(10, 5, 1000),
GeometryFactory.CreatePoint(10, 6, 1000));
((ITopologicalOperator2)g2).IsKnownSimple_2 = false;
((ITopologicalOperator)g2).Simplify();
try
{
IGeometry result = ((ITopologicalOperator)g1).Difference(g2);
if (RuntimeUtils.Is10_4orHigher)
{
Assert.True(result.IsEmpty, "empty result expected");
}
else
{
Assert.Fail("expected: AccessViolationException");
}
}
catch (AccessViolationException)
{
if (RuntimeUtils.Is10_4orHigher)
{
// no longer expected >= 10.4
throw;
}
// else: expected
}
}
private static IGeometry CreateGeometryToStore(
[NotNull] IGeometry geometry,
[NotNull] ICollection <esriGeometryType> storedGeometryTypes)
{
Assert.ArgumentNotNull(geometry, nameof(geometry));
Assert.ArgumentNotNull(storedGeometryTypes, nameof(storedGeometryTypes));
esriGeometryType geometryType = geometry.GeometryType;
if (storedGeometryTypes.Contains(geometryType))
{
return(GeometryFactory.Clone(geometry));
}
switch (geometry.GeometryType)
{
case esriGeometryType.esriGeometryPoint:
return(storedGeometryTypes.Contains(esriGeometryType.esriGeometryMultipoint)
? GeometryFactory.CreateMultipoint((IPoint)geometry)
: null);
case esriGeometryType.esriGeometryMultiPatch:
return(storedGeometryTypes.Contains(esriGeometryType.esriGeometryPolygon)
? GeometryFactory.CreatePolygon((IMultiPatch)geometry)
: null);
case esriGeometryType.esriGeometryEnvelope:
return(storedGeometryTypes.Contains(esriGeometryType.esriGeometryPolygon)
? GeometryFactory.CreatePolygon((IEnvelope)geometry)
: null);
default:
return(null);
}
}
public void CanGetMultipointPolygonCrossesIntersection()
{
var matrix = new IntersectionMatrix("T*T******");
IMultipoint g1 = GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(5, 5, 0),
GeometryFactory.CreatePoint(10, 5, 0),
GeometryFactory.CreatePoint(15, 5, 0));
IPolygon g2 = GeometryFactory.CreatePolygon(0, 0, 10, 10, 0);
g1.SpatialReference = _spatialReference;
g2.SpatialReference = _spatialReference;
IList <IGeometry> result12 = matrix.GetIntersections(g1, g2);
Assert.AreEqual(1, result12.Count);
Console.WriteLine(GeometryUtils.ToString(result12[0]));
Assert.AreEqual(2, GeometryUtils.GetPointCount(result12));
Assert.IsTrue(SpatialReferenceUtils.AreEqual(_spatialReference,
result12[0].SpatialReference));
IList <IGeometry> result21 = matrix.GetIntersections(g2, g1);
Assert.AreEqual(1, result21.Count);
Console.WriteLine(GeometryUtils.ToString(result21[0]));
Assert.IsTrue(
GeometryUtils.AreEqualInXY(result21[0],
g2)); // can't subtract, same as g2
}
private static IGeometry CreateMultipointFromEnvelopeCentroid(
[NotNull] IEnvelope envelope, bool zAware)
{
double xmin;
double ymin;
double xmax;
double ymax;
envelope.QueryCoords(out xmin, out ymin,
out xmax, out ymax);
IPoint point;
if (zAware)
{
point = GeometryFactory.CreatePoint((xmax + xmin) / 2,
(ymax + ymin) / 2,
(envelope.ZMax + envelope.ZMin) / 2);
}
else
{
point = GeometryFactory.CreatePoint((xmax + xmin) / 2,
(ymax + ymin) / 2);
}
point.SpatialReference = envelope.SpatialReference;
return(GeometryFactory.CreateMultipoint(point));
}
public void CanReportMultiPointErrorInSameTile()
{
const string testName = "CanReportMultiPointErrorInSameTile";
IFeatureClass vertexClass = CreateFeatureClass(
$"{testName}_vertex", esriGeometryType.esriGeometryMultipoint);
IFeature multiPointClass = vertexClass.CreateFeature();
multiPointClass.Shape =
GeometryFactory.CreateMultipoint(GeometryFactory.CreatePoint(201, 199));
multiPointClass.Store();
IFeature vertexRow1 = vertexClass.CreateFeature();
vertexRow1.Shape =
GeometryFactory.CreateMultipoint(GeometryFactory.CreatePoint(199, 199));
vertexRow1.Store();
IEnvelope verificationEnvelope =
GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaVertexCoincidenceSelf(vertexClass)
{
PointTolerance = 3
};
var runner = new QaContainerTestRunner(500, test);
runner.Execute(verificationEnvelope);
Assert.AreEqual(2, runner.Errors.Count);
}
public void CanCreateUnionWithIntersectingPointsMultipointsPolylinesAndPolygons()
{
var input = new List <IGeometry>
{
GeometryFactory.CreatePoint(100, 100),
GeometryFactory.CreatePoint(200, 200),
GeometryFactory.CreatePolyline(500, 100, 600, 100),
GeometryFactory.CreatePolyline(550, 100, 650, 100),
GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(1000, 2000),
GeometryFactory.CreatePoint(2000, 3000)),
GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(2000, 3000),
GeometryFactory.CreatePoint(3000, 4000)),
GeometryFactory.CreatePolygon(100, 100, 200, 200)
};
const double expansionDistance = 10;
IGeometry union = GeometryFactory.CreateUnion(input, expansionDistance);
Console.WriteLine(GeometryUtils.ToString(union));
Assert.AreEqual(esriGeometryType.esriGeometryPolygon, union.GeometryType);
Assert.AreEqual(5, GeometryUtils.GetPartCount(union));
}
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));
}
private static IGeometry GetErrorGeometry(
int vertexIndex,
[NotNull] ICollection <int> ignoredVertices,
[NotNull] IPointCollection transformedPoints,
[NotNull] IsClosedEvaluator isClosedEvaluator,
IList <double> sourceAngles,
double ignoredAngleValue)
{
if (ignoredVertices.Count <= 0)
{
return(transformedPoints.Point[vertexIndex]);
}
List <IPoint> points = ignoredVertices.Select(
index => transformedPoints.Point[index])
.ToList();
if (ignoredVertices.Contains(0) && isClosedEvaluator.IsClosed)
{
// the first vertex is ignored, and the path is closed
// --> check if there are ignored vertices at the end of the path which should be added
int lastVertexIndexBeforeEndpoint = transformedPoints.PointCount - 2;
if (Math.Abs(sourceAngles[lastVertexIndexBeforeEndpoint] - ignoredAngleValue) <
double.Epsilon)
{
// the vertex before the end vertex is also ignored
// --> add the ending sequence of ignored vertices to the list
for (int vertexIndexFromEnd = lastVertexIndexBeforeEndpoint;
vertexIndexFromEnd >= 0;
vertexIndexFromEnd--)
{
if (Math.Abs(sourceAngles[vertexIndexFromEnd] - ignoredAngleValue) >
double.Epsilon)
{
// the vertex is not ignored --> stop here
break;
}
if (ignoredVertices.Contains(vertexIndexFromEnd))
{
// the end sequence overlaps the start sequence
// --> apparently all vertices are ignored
break;
}
// add the ignored vertex from the end sequence
points.Add(transformedPoints.Point[vertexIndexFromEnd]);
}
}
}
points.Add(transformedPoints.Point[vertexIndex]);
return(GeometryFactory.CreateMultipoint(points));
}
public GeometryComparison([NotNull] WKSPointZ[] baseCoords,
[NotNull] WKSPointZ[] compareCoords,
ISpatialReference spatialReference,
double xyTolerance, double zTolerance)
: this(
GeometryFactory.CreateMultipoint(baseCoords, spatialReference),
GeometryFactory.CreateMultipoint(compareCoords, spatialReference),
xyTolerance, zTolerance)
{
}
private void AddNonCrackPoint(IPoint point)
{
if (NonCrackablePoints == null)
{
NonCrackablePoints = (IPointCollection)GeometryFactory.CreateMultipoint(point);
}
else
{
AddPoint(point, NonCrackablePoints);
}
}
private void AddCrackPoint(IPoint point)
{
if (CrackPointCollection == null)
{
CrackPointCollection =
(IPointCollection)GeometryFactory.CreateMultipoint(point);
}
else
{
AddPoint(point, CrackPointCollection);
}
}
public void CanGetTwoDuplicateMultipointPointsInSequence()
{
const double xyTolerance = 0.1;
const double zTolerance = 0.1;
// the second duplicate is NOT the last one in the sorted coordinate list...
IMultipoint original = GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(100, 1000, 5000), // duplicate 1
GeometryFactory.CreatePoint(100, 1000, 5000), // duplicate 1
GeometryFactory.CreatePoint(150, 1000, 5000), // duplicate 2
GeometryFactory.CreatePoint(150, 1000, 5000), // duplicate 2
GeometryFactory.CreatePoint(200, 1000, 5000),
GeometryFactory.CreatePoint(100, 2000, 5000),
GeometryFactory.CreatePoint(100, 3000, 5000)
);
original.SpatialReference = CreateSpatialReference(xyTolerance, zTolerance);
IMultipoint clone = GeometryFactory.Clone(original);
GeometryUtils.Simplify(clone);
var vertexComparer = new GeometryComparison(original, clone,
xyTolerance, zTolerance);
IList <WKSPointZ> result = vertexComparer.GetDifferentVertices(true);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(100, result[0].X);
Assert.AreEqual(1000, result[0].Y);
Assert.AreEqual(5000, result[0].Z);
Assert.AreEqual(150, result[1].X);
Assert.AreEqual(1000, result[1].Y);
Assert.AreEqual(5000, result[1].Z);
// Flip geometries:
vertexComparer = new GeometryComparison(clone, original,
xyTolerance, zTolerance);
result = vertexComparer.GetDifferentVertices(true);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(100, result[0].X);
Assert.AreEqual(1000, result[0].Y);
Assert.AreEqual(5000, result[0].Z);
Assert.AreEqual(150, result[1].X);
Assert.AreEqual(1000, result[1].Y);
Assert.AreEqual(5000, result[1].Z);
Assert.True(vertexComparer.HaveSameVertices());
Assert.False(vertexComparer.HaveSameVertices(false));
}
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));
}
public void LearningTestCantSubtractMultipointFromEqualMultipoint()
{
IMultipoint g1 = GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(10, 5, 1000),
GeometryFactory.CreatePoint(10, 6, 1000));
IMultipoint g2 = GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(10, 5, 1000),
GeometryFactory.CreatePoint(10, 6, 1000));
IGeometry result = ((ITopologicalOperator)g1).Difference(g2);
Console.WriteLine(GeometryUtils.ToString(result));
Assert.IsTrue(result.IsEmpty);
}
private static IGeometry GetLineEndPoints([NotNull] IGeometry shape,
GeometryComponent component)
{
var polyCurve = shape as IPolycurve;
Assert.NotNull(polyCurve, GetNotSupportedMessage(shape, component));
return(polyCurve.IsEmpty
? new MultipointClass {
SpatialReference = shape.SpatialReference
}
: GeometryFactory.CreateMultipoint(
polyCurve.FromPoint, polyCurve.ToPoint));
}
private static IGeometry GetErrorGeometry(
[NotNull] ICollection <WKSPointZ> changedPoints,
[NotNull] IFeature feature)
{
var changedPointArray = new WKSPointZ[changedPoints.Count];
changedPoints.CopyTo(changedPointArray, 0);
IGeometry result = GeometryFactory.CreateMultipoint(
changedPointArray, DatasetUtils.GetGeometryDef(feature));
// duplicate points are returned for self-intersections -> simplify
GeometryUtils.Simplify(result);
return(result);
}
/// <summary>
/// Updates the source target pairs AND the _unpairedSourceIntersectionPoints
/// </summary>
private void UpdateSourceTargetPairsAndUnpairedSourceIntersections()
{
if (_sourceFeatures.Count == 0 || _targetPoints.Count == 0)
{
SourceTargetPairs.Clear();
}
IList <IPolycurve> sourceGeometries =
GdbObjectUtils.GetGeometries(_sourceFeatures).Cast <IPolycurve>().ToList();
var targetPointCollection =
(IPointCollection)GeometryFactory.CreateMultipoint(_targetPoints);
SourceTargetPairs = CalculateSourceTargetPairs(
sourceGeometries, targetPointCollection).ToList();
}
private void AddIntersectionPoints([CanBeNull] IPointCollection pointCollection)
{
if (pointCollection == null || ((IGeometry)pointCollection).IsEmpty)
{
return;
}
if (IntersectionPoints == null)
{
IntersectionPoints =
(IPointCollection)GeometryFactory.CreateMultipoint(pointCollection);
}
else
{
IntersectionPoints.AddPointCollection(pointCollection);
}
}
public static IList <IFeature> SplitAtJunctions(
[NotNull] IFeature edgeFeature,
[NotNull] IEnumerable <IFeature> splittingJunctions)
{
const bool projectPointsOntoPathToSplit = false;
const bool createParts = true;
var splitPoints =
(IPointCollection)GeometryFactory.CreateMultipoint(
splittingJunctions.Select(f => (IPoint)f.Shape));
var edge = (IPolyline)edgeFeature.Shape;
IList <IPoint> splittedAt = GeometryUtils.CrackPolycurve(
edge, splitPoints, projectPointsOntoPathToSplit, createParts);
var result = new List <IFeature>();
if (splittedAt.Count > 0)
{
IList <IGeometry> splitGeometries = GeometryUtils.Explode(edge);
IGeometry geometryToStoreInOriginal =
Assert.NotNull(GeometryUtils.GetLargestGeometry(splitGeometries));
// store the update
IFeature existingFeature = AssignGeometryToFeature(geometryToStoreInOriginal,
edgeFeature,
false);
existingFeature.Store();
// store other new geometries as inserts
foreach (IGeometry modifyGeometry in
splitGeometries.Where(polycurve => polycurve != geometryToStoreInOriginal))
{
IFeature newEdgeFeature =
AssignGeometryToFeature(modifyGeometry, edgeFeature, true);
newEdgeFeature.Store();
result.Add(newEdgeFeature);
}
}
return(result);
}
private static IMultipoint RemoveEndPointVertexIntersections(
[NotNull] IMultipoint intersectionPoints,
[NotNull] IPolyline polyline1,
[NotNull] IGeometry polyline1Endpoints,
[NotNull] IPolyline polyline2,
[NotNull] IGeometry polyline2Endpoints,
double vertexSearchDistance)
{
var polyline1EndpointsRelOp = (IRelationalOperator)polyline1Endpoints;
var polyline2EndpointsRelOp = (IRelationalOperator)polyline2Endpoints;
var remainingPoints = new List <IPoint>();
foreach (IPoint intersectionPoint in
QueryPoints(intersectionPoints, TemplatePoint1))
{
if (!polyline1EndpointsRelOp.Disjoint(intersectionPoint))
{
// end point of polyline 1
if (IntersectsVertex(intersectionPoint, polyline2, TemplatePoint2,
vertexSearchDistance))
{
// intersection of end point of polyline 1 with vertex of polyline 2
// -> skip
continue;
}
}
else if (!polyline2EndpointsRelOp.Disjoint(intersectionPoint))
{
// end point of polyline 2
if (IntersectsVertex(intersectionPoint, polyline1, TemplatePoint2,
vertexSearchDistance))
{
// intersection of end point of polyline 2 with vertex of polyline 1
// -> skip
continue;
}
}
remainingPoints.Add(GeometryFactory.Clone(intersectionPoint));
}
return(GeometryFactory.CreateMultipoint(remainingPoints));
}
private int ReportError([NotNull] FeatureDangleCount featureDangleCount,
[CanBeNull] string constraintValues)
{
string description = string.IsNullOrEmpty(constraintValues)
? string.Format("Invalid number of dangles: {0}",
featureDangleCount
.DanglingPointCount)
: string.Format(
"Invalid number of dangles: {0} ({1})",
featureDangleCount.DanglingPointCount,
constraintValues);
return(ReportError(description,
GeometryFactory.CreateMultipoint(
featureDangleCount.DanglingPoints),
Codes[Code.InvalidNumberOfDangles],
TestUtils.GetShapeFieldName(featureDangleCount.Feature),
featureDangleCount.Feature));
}
public void TestMultipoint()
{
IFeatureClass featureClass =
TestWorkspaceUtils.CreateSimpleFeatureClass(
_testWs, "multipoints",
null,
esriGeometryType.esriGeometryMultipoint,
esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95, 0d,
true);
var points = new List <IPoint>
{
GeometryFactory.CreatePoint(2000001, 1000000, 0),
GeometryFactory.CreatePoint(2000002, 1000000, 100),
GeometryFactory.CreatePoint(2000003, 1000000, 200),
GeometryFactory.CreatePoint(2000004, 1000000, 300),
GeometryFactory.CreatePoint(2000005, 1000000, 400)
};
IFeature row1 = featureClass.CreateFeature();
row1.Shape = GeometryFactory.CreateMultipoint(points);
row1.Store();
IList <IGeometry> results = RunTest(featureClass, 100, 300, 2);
var errors1 = (IMultipoint)results[0];
Assert.AreEqual(((IPointCollection)errors1).PointCount, 1);
var errors2 = (IMultipoint)results[1];
Assert.AreEqual(((IPointCollection)errors2).PointCount, 1);
IFeature row2 = featureClass.CreateFeature();
row2.Shape = GeometryFactory.CreateMultipoint(points);
row2.Store();
RunTest(featureClass, 100, 300, 4);
}
private static IPolyline GetSplitReshapePath(
[NotNull] IPath reshapePath,
[NotNull] IEnumerable <KeyValuePair <IPoint, IPoint> > intersectingSourceTargetPoints,
[NotNull] IPointCollection sketchOriginalIntersectionPoints)
{
var splitReshapeLine =
(IPolyline)GeometryUtils.GetHighLevelGeometry(reshapePath);
var targetIntersectionPointCollection =
(IPointCollection)
GeometryFactory.CreateMultipoint(
intersectingSourceTargetPoints.Select(sourceTargets => sourceTargets.Value));
// additionally crack at the intersection points of the sketch with the feature
targetIntersectionPointCollection.AddPointCollection(
sketchOriginalIntersectionPoints);
GeometryUtils.CrackPolycurve(splitReshapeLine,
targetIntersectionPointCollection, false, true, null);
return(splitReshapeLine);
}
public void CanUseShapeVertexCountAlias()
{
IFeatureClass featureClass = CreateFeatureClass(
"CanUseShapeVertexCountAlias",
esriGeometryType.esriGeometryMultipoint);
IFeature f1 = featureClass.CreateFeature();
f1.Shape = GeometryFactory.CreateMultipoint(GeometryFactory.CreatePoint(0, 0));
f1.Store();
IFeature f2 = featureClass.CreateFeature();
f2.Shape = GeometryFactory.CreateMultipoint(GeometryFactory.CreatePoint(0, 0),
GeometryFactory.CreatePoint(10, 10),
GeometryFactory.CreatePoint(20, 20));
f2.Store();
AssertFilteredRowCount(1, "$ShapeVertexCount = 3", f1, f2);
AssertFilteredRowCount(1, "$ShapeVertexCount = 1", f1, f2);
}
private static ReshapeLineMsg ToReshapeLineMsg([NotNull] CutSubcurve cutSubcurve)
{
var result = new ReshapeLineMsg();
result.Path = ProtobufGeometryUtils.ToShapeMsg(cutSubcurve.Path);
result.CanReshape = cutSubcurve.CanReshape;
result.IsCandidate = cutSubcurve.IsReshapeMemberCandidate;
result.IsFiltered = cutSubcurve.IsFiltered;
result.TargetSegmentAtFrom =
cutSubcurve.FromPointIsStitchPoint
? ProtobufGeometryUtils.ToShapeMsg(cutSubcurve.TargetSegmentAtFromPoint)
: null;
result.TargetSegmentAtTo =
cutSubcurve.ToPointIsStitchPoint
? ProtobufGeometryUtils.ToShapeMsg(cutSubcurve.TargetSegmentAtToPoint)
: null;
if (cutSubcurve.ExtraTargetInsertPoints != null)
{
result.ExtraTargetInsertPoints =
ProtobufGeometryUtils.ToShapeMsg(
GeometryFactory.CreateMultipoint(cutSubcurve.ExtraTargetInsertPoints));
}
if (cutSubcurve.Source != null)
{
GdbObjectReference sourceObjRef = cutSubcurve.Source.Value;
result.Source = new GdbObjRefMsg
{
ClassHandle = sourceObjRef.ClassId,
ObjectId = sourceObjRef.ObjectId
};
}
return(result);
}
public void CanGetDuplicatedMultipointPoint()
{
const double xyTolerance = 0.1;
const double zTolerance = 0.1;
IMultipoint original = GeometryFactory.CreateMultipoint(
GeometryFactory.CreatePoint(100, 1000, 5000), // duplicate
GeometryFactory.CreatePoint(100, 1000, 5000) // duplicate
);
original.SpatialReference = CreateSpatialReference(xyTolerance, zTolerance);
IMultipoint clone = GeometryFactory.Clone(original);
GeometryUtils.Simplify(clone);
var vertexComparer = new GeometryComparison(original, clone,
xyTolerance, zTolerance);
IList <WKSPointZ> result = vertexComparer.GetDifferentVertices(true);
Assert.AreEqual(1, result.Count);
Assert.AreEqual(100, result[0].X);
Assert.AreEqual(1000, result[0].Y);
Assert.AreEqual(5000, result[0].Z);
// Flip geometries:
vertexComparer = new GeometryComparison(clone, original,
xyTolerance, zTolerance);
result = vertexComparer.GetDifferentVertices(true);
Assert.AreEqual(1, result.Count);
Assert.AreEqual(100, result[0].X);
Assert.AreEqual(1000, result[0].Y);
Assert.AreEqual(5000, result[0].Z);
Assert.True(vertexComparer.HaveSameVertices());
Assert.False(vertexComparer.HaveSameVertices(false));
}
private static IGeometry GetVertices([NotNull] IGeometry shape,
GeometryComponent component)
{
switch (shape.GeometryType)
{
case esriGeometryType.esriGeometryPoint:
return(GeometryFactory.Clone(shape));
case esriGeometryType.esriGeometryMultipoint:
case esriGeometryType.esriGeometryMultiPatch:
case esriGeometryType.esriGeometryPolygon:
case esriGeometryType.esriGeometryPolyline:
var points = (IPointCollection)GeometryFactory.Clone(shape);
IMultipoint multipoint = GeometryFactory.CreateMultipoint(points);
GeometryUtils.Simplify(multipoint);
return(multipoint);
default:
throw new ArgumentException(GetNotSupportedMessage(shape, component));
}
}
