public FullSegmentsPlaneProvider([NotNull] IIndexedSegments indexedSegments,
esriGeometryType shapeType)
: base(indexedSegments)
{
_shapeType = shapeType;
_enumValid = true;
}
protected static void GetConnectedParts <T>(
[NotNull] IIndexedSegments geom,
[NotNull] IEnumerable <T> sortedParts,
double near, double connectedMinLength, bool is3D,
[NotNull] out IList <ConnectedSegmentParts> connected,
[NotNull] out IList <ConnectedSegmentParts> nearSelfConnected)
where T : SegmentParts
{
double nearSquared = near * near;
var curves = new List <ConnectedSegmentParts>();
var nearSelfCurves = new List <ConnectedSegmentParts>();
foreach (T segmentParts in sortedParts)
{
segmentParts.Sort(new SegmentPartComparer());
foreach (SegmentPart part in segmentParts)
{
AddSegment(geom, curves, nearSelfCurves, part, connectedMinLength,
nearSquared, is3D);
}
}
connected = GetClosedConnected(curves);
nearSelfConnected = GetClosedConnected(nearSelfCurves);
}
public IndexedSegmentsLengthProvider([NotNull] IIndexedSegments indexedPolycurve,
bool is3D)
: base(is3D)
{
_indexedPolycurve = indexedPolycurve;
_enumSegments = _indexedPolycurve.GetSegments().GetEnumerator();
}
private void GetSubcurves(IRow row,
SortedDictionary <SegmentPart, SegmentParts> parts,
double near,
double connectedMinLength,
out IList <SubClosedCurve> connected,
out IList <SubClosedCurve> nearSelfConnected)
{
var feat = (IFeature)row;
IIndexedSegments geom = IndexedSegmentUtils.GetIndexedGeometry(feat, false);
double nearSquared = near * near;
var curves = new List <Subcurve>();
var nearSelfCurves = new List <Subcurve>();
foreach (SegmentParts segmentParts in parts.Values)
{
segmentParts.Sort(new SegmentPartComparer());
foreach (SegmentPart part in segmentParts)
{
AddSegment(feat, geom, curves, nearSelfCurves, part, connectedMinLength,
nearSquared);
}
}
connected = GetClosedCurves(curves);
nearSelfConnected = GetClosedCurves(nearSelfCurves);
}
private bool IsConnected([NotNull] IIndexedSegments geometry,
[NotNull] IBox pntsearchBox, [NotNull] Pnt center,
double toleranceSquare,
out int connectedPart, out int connectedFraction)
{
foreach (SegmentProxy segment in geometry.GetSegments(pntsearchBox))
{
foreach (bool atStart in GetConnectedCandidateAtStarts(geometry, segment))
{
Pnt endPnt = atStart ? segment.GetStart(false) : segment.GetEnd(false);
double dx = endPnt.X - center.X;
double dy = endPnt.Y - center.Y;
double dist2 = dx * dx + dy * dy;
if (dist2 < toleranceSquare)
{
connectedPart = segment.PartIndex;
connectedFraction = atStart
? segment.SegmentIndex
: segment.SegmentIndex + 1;
return(true);
}
}
}
connectedPart = -1;
connectedFraction = -1;
return(false);
}
public static WKSEnvelope GetEnvelope([NotNull] IIndexedSegments baseGeometry,
int part, int startSegmentIndex,
double startFraction,
int endSegmentIndex, double endFraction)
{
SegmentProxy segment = baseGeometry.GetSegment(part, startSegmentIndex);
double startEnd = 1;
if (startSegmentIndex == endSegmentIndex)
{
startEnd = endFraction;
}
WKSEnvelope box = segment.GetSubCurveBox(startFraction, startEnd);
for (int i = startSegmentIndex + 1; i < endSegmentIndex - 1; i++)
{
segment = baseGeometry.GetSegment(part, i);
box = GetUnion(box, segment.GetSubCurveBox(0, 1));
}
if (endSegmentIndex > startSegmentIndex && endFraction > 0)
{
segment = baseGeometry.GetSegment(part, endSegmentIndex);
box = GetUnion(box, segment.GetSubCurveBox(0, endFraction));
}
return(box);
}
internal static double GetLength([NotNull] IIndexedSegments baseGeometry,
int partIndex,
int startSegmentIndex, double startFraction,
int endSegmentIndex, double endFraction)
{
double length = 0;
for (int i = startSegmentIndex; i <= endSegmentIndex; i++)
{
SegmentProxy seg = baseGeometry.GetSegment(partIndex, i);
double segLength = seg.Length;
double addLength = segLength;
if (i == startSegmentIndex)
{
addLength -= segLength * startFraction;
}
if (i == endSegmentIndex)
{
addLength -= segLength * (1 - endFraction);
}
length += addLength;
}
return(length);
}
bool IIndexedSegments.TryGetSegmentNeighborhoods(
IIndexedSegments neighborSegments, IBox commonBox, double searchDistance,
out IEnumerable <SegmentProxyNeighborhood> neighborhoods)
{
neighborhoods = null;
return(false);
}
private MeanSegmentLengthProvider GetMeanSegmentLengthProvider(IFeature row)
{
MeanSegmentLengthProvider provider;
if (!_is3D && row.Shape is ICurve)
{
provider = new CurveMeanSegmentsLengthProvider((ICurve)row.Shape, _perPart);
}
else
{
var segmentsFeature = row as IIndexedSegmentsFeature;
if (segmentsFeature != null && segmentsFeature.AreIndexedSegmentsLoaded)
{
provider = new IndexedMeanLengthProvider(row.Shape,
segmentsFeature.IndexedSegments,
_perPart, _is3D);
}
else if (row.Shape is IMultiPatch)
{
IIndexedSegments indexedSegments =
QaGeometryUtils.CreateIndexedMultiPatch((IMultiPatch)row.Shape);
provider = new IndexedMeanLengthProvider(row.Shape, indexedSegments, _perPart,
_is3D);
}
else
{
provider = new SegmentCollectionMeanLengthProvider(
(ISegmentCollection)row.Shape,
_perPart, _is3D);
}
}
return(provider);
}
private SegmentLengthProvider GetSegmentLengthProvider(IFeature row)
{
SegmentLengthProvider provider;
var segmentsFeature = row as IIndexedSegmentsFeature;
if (segmentsFeature != null && segmentsFeature.AreIndexedSegmentsLoaded)
{
provider = new IndexedSegmentsLengthProvider(segmentsFeature.IndexedSegments,
_is3D);
}
else if (row.Shape is IMultiPatch)
{
IIndexedSegments indexedSegments =
QaGeometryUtils.CreateIndexedMultiPatch((IMultiPatch)row.Shape);
provider = new IndexedSegmentsLengthProvider(indexedSegments, _is3D);
}
else
{
provider = new SegmentCollectionLengthProvider((ISegmentCollection)row.Shape,
_is3D);
}
return(provider);
}
public PartSegmentsPlaneProvider([NotNull] IIndexedSegments indexedSegments,
esriGeometryType shapeType)
: base(indexedSegments)
{
_shapeType = shapeType;
_segmentsEnum = _indexedSegments.GetSegments().GetEnumerator();
_enumValid = _segmentsEnum.MoveNext();
}
public IndexedSegmentsNearFeatureCoincidence(
[NotNull] IFeature feature,
[NotNull] IIndexedSegments indexedSegments)
: base(feature)
{
Assert.ArgumentNotNull(indexedSegments, nameof(indexedSegments));
_indexedSegments = indexedSegments;
}
public IndexedMeanLengthProvider([NotNull] IGeometry baseGeometry,
[NotNull] IIndexedSegments indexedSegments,
bool perPart, bool is3D)
{
_baseGeometry = baseGeometry;
_indexedSegments = indexedSegments;
_perPart = perPart;
_is3D = is3D;
}
/// <summary>
///
/// </summary>
/// <param name="row"></param>
/// <param name="sortedParts">Each entry in sortedParts are lists of segmentparts of the same segment.
/// sortedParts must be ordered by partIndex ASC, segmentIndex ASC.
/// However, the entries of sortedParts will sorted in this method.</param>
/// <param name="near">used for near self parts</param>
/// <param name="connectedMinLength">used for near self parts</param>
/// <param name="connected"></param>
/// <param name="nearSelfConnected"></param>
protected void GetSubcurves(IRow row,
IEnumerable <SegmentParts> sortedParts,
double near,
double connectedMinLength,
out IList <SubClosedCurve> connected,
out IList <SubClosedCurve> nearSelfConnected)
{
var feat = (IFeature)row;
IIndexedSegments geom = IndexedSegmentUtils.GetIndexedGeometry(feat, false);
GetSubcurves(geom, sortedParts, near, connectedMinLength, Is3D, out connected,
out nearSelfConnected);
}
private IEnumerable <bool> GetConnectedCandidateAtStarts(IIndexedSegments geometry,
SegmentProxy segment)
{
if (segment.SegmentIndex == 0 ||
ConnectionMode != ConnectionMode.EndpointOnEndpoint)
{
yield return(true);
}
if (segment.SegmentIndex + 1 == geometry.GetPartSegmentCount(segment.PartIndex) ||
ConnectionMode != ConnectionMode.EndpointOnEndpoint)
{
yield return(false);
}
}
protected List <AzimuthSegment> ReadAllHorizontalSegments(
IIndexedSegments multiPatch)
{
var result = new List <AzimuthSegment>();
foreach (SegmentProxy segment in multiPatch.GetSegments())
{
if (IsHorizontal(segment))
{
result.Add(new AzimuthSegment(segment, XyResolution));
}
}
return(result);
}
private static IEnumerable <SegmentProxy> EnumSegments(
[NotNull] Pnt point,
[NotNull] IFeature neighbourFeature,
double maxNeededDistance)
{
IIndexedSegments segments = IndexedSegmentUtils.GetIndexedGeometry(
neighbourFeature, releaseOnDispose: false);
IBox box = GeomUtils.GetExpanded(point, maxNeededDistance);
foreach (SegmentProxy segment in segments.GetSegments(box))
{
yield return(segment);
}
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="sortedParts">Each entry in sortedParts are lists of segmentparts of the same segment.
/// sortedParts must be ordered by partIndex ASC, segmentIndex ASC.
/// However, the entries of sortedParts will sorted in this method.</param>
/// <param name="near">used for near self parts</param>
/// <param name="connectedMinLength">used for near self parts</param>
/// <param name="is3D"></param>
/// <param name="connected"></param>
/// <param name="nearSelfConnected"></param>
protected static void GetSubcurves(IIndexedSegments geom,
IEnumerable <SegmentParts> sortedParts,
double near,
double connectedMinLength, bool is3D,
out IList <SubClosedCurve> connected,
out IList <SubClosedCurve> nearSelfConnected)
{
IList <ConnectedSegmentParts> curves;
IList <ConnectedSegmentParts> nearSelfCurves;
GetConnectedParts(geom, sortedParts, near, connectedMinLength, is3D,
out curves, out nearSelfCurves);
connected = GetSubClosedCurves(curves);
nearSelfConnected = GetSubClosedCurves(nearSelfCurves);
}
protected static IList <Subcurve> GetMissingSegments(
[NotNull] IFeature feature,
[NotNull] IIndexedSegments segList,
[NotNull] SortedDictionary <SegmentPart, SegmentParts> nearList)
{
var result = new List <Subcurve>();
foreach (SegmentProxy segProxy in segList.GetSegments())
{
int partIndex = segProxy.PartIndex;
int segmentIndex = segProxy.SegmentIndex;
var key = new SegmentPart(partIndex, segmentIndex, 0, 1, true);
SegmentParts parts;
if (!nearList.TryGetValue(key, out parts))
{
// ReSharper disable once RedundantAssignment
parts = null;
}
if (parts == null)
{
AddSegment(feature, segList, result, segProxy, 0, 1);
continue;
}
parts.Sort(new SegmentPartComparer());
double tMax = 0;
foreach (SegmentPart part in parts)
{
if (part.MinFraction > tMax)
{
AddSegment(feature, segList, result, segProxy, tMax, part.MinFraction);
}
tMax = Math.Max(tMax, part.MaxFraction);
}
if (tMax < 1)
{
AddSegment(feature, segList, result, segProxy, tMax, 1);
}
}
return(result);
}
public bool TryGetSegmentNeighborhoods(
IIndexedSegments neighborSegments, IBox commonBox, double searchDistance,
out IEnumerable <SegmentProxyNeighborhood> neighborhoods)
{
IndexedPolycurve neighbor = neighborSegments as IndexedPolycurve;
if (neighbor == null)
{
neighborhoods = null;
return(false);
}
BoxTree <SegmentProxy> neighborBoxTree = neighbor._boxTree;
neighborhoods = GetNeighborhoods(neighborBoxTree, searchDistance, commonBox);
return(true);
}
private static void AddSegment([NotNull] IFeature feature,
[NotNull] IIndexedSegments geom,
[NotNull] IList <Subcurve> connectedList,
[NotNull] SegmentProxy segProxy, double min,
double max)
{
if (min >= max)
{
return;
}
Subcurve current = null;
if (connectedList.Count > 0)
{
current = connectedList[connectedList.Count - 1];
}
if (current != null)
{
if (current.PartIndex != segProxy.PartIndex)
{
current = null;
}
else if (current.EndSegmentIndex + current.EndFraction <
segProxy.SegmentIndex + min)
{
current = null;
}
}
if (current == null)
{
current = new Subcurve(geom, segProxy.PartIndex, segProxy.SegmentIndex,
min, segProxy.SegmentIndex, max);
connectedList.Add(current);
}
else
{
if (current.EndSegmentIndex + current.EndFraction < segProxy.SegmentIndex + max)
{
current.EndSegmentIndex = segProxy.SegmentIndex;
current.EndFraction = max;
}
}
}
private int Check([NotNull] IFeature feature,
[NotNull] SortedDictionary <SegmentPart, SegmentParts> nearList,
[CanBeNull] IEnvelope processEnvelope)
{
// using (IIndexedGeometry geom = GetIndexedGeometry((IFeature)row, false)) // TODO revise, causes IClone.IsEqual to return incorrect results afterwards (at least for Z-only differences)
const bool releaseOnDispose = true;
using (IIndexedSegments indexedGeometry =
IndexedSegmentUtils.GetIndexedGeometry(feature, releaseOnDispose))
{
IList <Subcurve> missingSegments = GetMissingSegments(feature,
indexedGeometry,
nearList);
return(missingSegments != null
? ReportErrors(feature, missingSegments, processEnvelope)
: 0);
}
}
private static void GetClosePart([NotNull] SegmentProxy neighbor,
[NotNull] IIndexedSegments geom,
[NotNull] SegmentPart segPart,
double searchDistanceSquared, bool is3D,
out double min, out double max)
{
SegmentProxy part = geom.GetSegment(segPart.PartIndex, segPart.SegmentIndex);
IPnt start = part.GetPointAt(segPart.MinFraction);
double minStart, maxStart;
GetClosePart(neighbor, start, searchDistanceSquared, is3D, out minStart,
out maxStart);
IPnt end = part.GetPointAt(segPart.MaxFraction);
double minEnd, maxEnd;
GetClosePart(neighbor, end, searchDistanceSquared, is3D, out minEnd, out maxEnd);
min = Math.Min(minStart, minEnd);
max = Math.Max(maxStart, maxEnd);
}
public static SegmentsPlaneProvider Create(
[NotNull] IFeature feature,
esriGeometryType shapeType,
bool includeAssociatedParts)
{
if (shapeType == esriGeometryType.esriGeometryMultiPatch)
{
IIndexedMultiPatch indexedMultiPatch = GetIndexedMultiPatch(feature);
return(includeAssociatedParts
? (SegmentsPlaneProvider)
new SurfaceSegmentsPlaneProvider(indexedMultiPatch)
: new PartSegmentsPlaneProvider(indexedMultiPatch, shapeType));
}
IIndexedSegments indexedSegments = GetIndexedSegments(feature);
return(includeAssociatedParts
? (SegmentsPlaneProvider)
new FullSegmentsPlaneProvider(indexedSegments, shapeType)
: new PartSegmentsPlaneProvider(indexedSegments, shapeType));
}
private static WKSPointZ[] GetWksPointZs(
[NotNull] IIndexedSegments indexedSegments,
int partIndex)
{
int partSegmentCount = indexedSegments.GetPartSegmentCount(partIndex);
var segments = new List <SegmentProxy>(partSegmentCount);
for (int segmentIndex = 0; segmentIndex < partSegmentCount; segmentIndex++)
{
segments.Add(indexedSegments.GetSegment(partIndex, segmentIndex));
}
var wksPoints = new List <WKSPointZ>(partSegmentCount + 1);
foreach (Pnt point in QaGeometryUtils.GetPoints(segments))
{
wksPoints.Add(QaGeometryUtils.GetWksPoint(point));
}
return(wksPoints.ToArray());
}
public IndexedSegmentsSlopeAngleProvider(
[NotNull] IIndexedSegments indexedPolycurve)
{
_indexedPolycurve = indexedPolycurve;
_enumSegments = _indexedPolycurve.GetSegments().GetEnumerator();
}
private void AddSegment([NotNull] IFeature feature,
[NotNull] IIndexedSegments geom,
[NotNull] IList <Subcurve> standardConnectedList,
[NotNull] IList <Subcurve> nearSelfConnectedList,
[NotNull] SegmentPart segPart,
double connectedMinLength,
double nearSquared)
{
Subcurve current = null;
IList <Subcurve> connectedList = standardConnectedList;
SegmentProxy neighbor = segPart.NearSelf;
if (neighbor != null)
{
// Get the distance between the parts that are near
double d0 = double.MaxValue;
int partIndex = segPart.PartIndex;
if (geom.IsPartClosed(partIndex) || segPart.SegmentIndex > neighbor.SegmentIndex)
{
if (segPart.PartIndex == neighbor.PartIndex)
// TODO revise; workaround to avoid exception (invalid index)
{
// raw estimate for distance betwenn segPart and neighborPart
// this estimate is too small, because not the entire part of neighbor is near segPart
var curve = new SubClosedCurve(geom, partIndex,
neighbor.SegmentIndex + 1,
segPart.FullMin);
d0 = curve.GetLength();
if (d0 < connectedMinLength)
{
double d0Max = d0 + neighbor.Length;
if (d0Max > connectedMinLength)
{
// closer investigation necessary
double min;
double max;
GetClosePart(neighbor, geom, segPart, nearSquared, Is3D,
out min, out max);
d0 = d0 + (1 - max) * neighbor.Length;
} // else segPart is definitly near neighbor
} //else segPart is definitly not near neighbor
}
}
if (geom.IsPartClosed(partIndex) || segPart.SegmentIndex < neighbor.SegmentIndex)
{
if (segPart.PartIndex == neighbor.PartIndex)
// TODO revise; workaround to avoid exception (invalid index)
{
var curve = new SubClosedCurve(geom, partIndex,
segPart.FullMax,
neighbor.SegmentIndex);
double d0Min = curve.GetLength();
if (d0Min < connectedMinLength)
{
double d0Max = d0Min + neighbor.Length;
if (d0Max > connectedMinLength)
{
// closer investigation necessary
double min;
double max;
GetClosePart(neighbor, geom, segPart, nearSquared, Is3D,
out min, out max);
d0Min = d0Min + min * neighbor.Length;
} //else segPart is definitly near neighbor
} // else segPart is definitly not near neighbor
d0 = Math.Min(d0, d0Min);
}
}
if (d0 < connectedMinLength)
{
connectedList = nearSelfConnectedList;
}
}
if (connectedList.Count > 0)
{
current = connectedList[connectedList.Count - 1];
}
if (current != null)
{
if (current.PartIndex != segPart.PartIndex)
{
current = null;
}
else if (current.EndFullIndex < segPart.FullMin)
{
current = null;
}
}
if (current == null)
{
current = new Subcurve(geom, segPart.PartIndex, segPart.SegmentIndex,
segPart.MinFraction, segPart.SegmentIndex,
segPart.MaxFraction);
connectedList.Add(current);
}
else
{
if (current.EndFullIndex < segPart.FullMax)
{
current.EndSegmentIndex = segPart.SegmentIndex;
current.EndFraction = segPart.MaxFraction;
}
}
}
private void CompleteJunctions()
{
foreach (KeyValuePair <RowKey, SegmentNeighbors> pair in ProcessedList)
{
RowKey key = pair.Key;
if (_conflictTables.ContainsKey(key.TableIndex))
{
continue;
}
// --> junction was not searched
var thisFeature = (IFeature)key.Row;
var thisCurve = (IGeometryCollection)thisFeature.Shape;
IIndexedSegments thisGeom =
IndexedSegmentUtils.GetIndexedGeometry(thisFeature, false);
Dictionary <int, SegmentPart> handledParts = new Dictionary <int, SegmentPart>();
foreach (KeyValuePair <SegmentPart, SegmentParts> segmentPair in pair.Value)
{
if (segmentPair.Value.Count == 0)
{
continue;
}
SegmentPart segment = segmentPair.Key;
if (handledParts.ContainsKey(segment.PartIndex))
{
continue;
}
int segmentsCount = thisGeom.GetPartSegmentCount(segment.PartIndex);
IEnvelope searchBox = thisCurve.Geometry[segment.PartIndex].Envelope;
double tolerance = UsedJunctionCoincidenceTolerance;
searchBox.Expand(tolerance, tolerance, asRatio: false);
Pnt start = thisGeom.GetSegment(segment.PartIndex, 0).GetStart(false);
IBox startBox = new Box(new Pnt2D(start.X - tolerance, start.Y - tolerance),
new Pnt2D(start.X + tolerance, start.Y + tolerance));
Pnt end = thisGeom.GetSegment(segment.PartIndex, segmentsCount - 1)
.GetEnd(false);
IBox endBox = new Box(new Pnt2D(end.X - tolerance, end.Y - tolerance),
new Pnt2D(end.X + tolerance, end.Y + tolerance));
foreach (KeyValuePair <int, IFeatureClass> topoPair in _topoTables)
{
int neighborTableIdx = topoPair.Key;
ISpatialFilter filter = _topoFilters[neighborTableIdx];
filter.Geometry = searchBox;
QueryFilterHelper helper = _topoHelpers[neighborTableIdx];
foreach (IRow neighborRow in Search((ITable)topoPair.Value, filter, helper)
)
{
if (neighborRow.OID == key.Row.OID &&
neighborTableIdx == key.TableIndex)
{
continue;
}
var neighborFeature = (IFeature)neighborRow;
IIndexedSegments neighborGeom =
IndexedSegmentUtils.GetIndexedGeometry(neighborFeature, false);
int connectedPart;
int connectedFraction;
if (IsConnected(neighborGeom, startBox, start,
JunctionCoincidenceToleranceSquare,
out connectedPart, out connectedFraction))
{
var jct =
new Junction(thisFeature, key.TableIndex, segment.PartIndex, 0,
neighborFeature, neighborTableIdx, connectedPart,
connectedFraction);
_junctions.Add(jct);
}
if (IsConnected(neighborGeom, endBox, end,
JunctionCoincidenceToleranceSquare,
out connectedPart, out connectedFraction))
{
var jct = new Junction(
thisFeature, key.TableIndex, segment.PartIndex, segmentsCount,
neighborFeature, neighborTableIdx, connectedPart,
connectedFraction);
_junctions.Add(jct);
}
if (ConnectionMode == ConnectionMode.VertexOnVertex)
{
for (int iSegment = 1; iSegment < segmentsCount; iSegment++)
{
Pnt vertex = thisGeom
.GetSegment(segment.PartIndex, iSegment)
.GetStart(false);
IBox vertexBox =
new Box(
new Pnt2D(vertex.X - tolerance, vertex.Y - tolerance),
new Pnt2D(vertex.X + tolerance, vertex.Y + tolerance));
if (IsConnected(neighborGeom, vertexBox, vertex,
JunctionCoincidenceToleranceSquare,
out connectedPart, out connectedFraction))
{
var jct = new Junction(
thisFeature, key.TableIndex, segment.PartIndex,
iSegment,
neighborFeature, neighborTableIdx, connectedPart,
connectedFraction);
_junctions.Add(jct);
}
}
}
}
}
handledParts.Add(segment.PartIndex, segment);
}
}
}
private SegmentsPlaneProvider([NotNull] IIndexedSegments indexedSegments)
{
_indexedSegments = indexedSegments;
}
public PartVerticalFaceProvider([NotNull] IIndexedSegments indexedSegments)
{
_indexedSegments = indexedSegments;
_segmentsEnum = _indexedSegments.GetSegments().GetEnumerator();
_enumValid = _segmentsEnum.MoveNext();
}
