public NotNearNeighborhoodFinder(
[NotNull] IFeatureRowsDistance rowsDistance,
[NotNull] IFeature feature, int tableIndex,
[CanBeNull] IFeature neighbor, int neighborTableIndex)
: base(rowsDistance, feature, tableIndex, neighbor, neighborTableIndex)
{
}
protected override NeighborhoodFinder GetNeighborhoodFinder(
IFeatureRowsDistance rowsDistance, IFeature feature, int tableIndex,
IFeature neighbor, int neighborTableIndex)
{
return(new NotNearNeighborhoodFinder(
rowsDistance, feature, tableIndex, neighbor, neighborTableIndex));
}
protected override int ExecuteCore(IRow row, int tableIndex)
{
if (tableIndex > 0)
{
return(NoError);
}
if (_filter == null)
{
InitFilter();
}
ISpatialFilter filter = Assert.NotNull(_filter, "_filter");
var processed0 = new SegmentNeighbors(new SegmentPartComparer());
IGeometry geom0 = ((IFeature)row).Shape;
IEnvelope box0 = geom0.Envelope;
box0.Expand(SearchDistance, SearchDistance, false);
filter.Geometry = box0;
var errorCount = 0;
double maxNear = SearchDistance;
const int neighborTableIndex = 1;
IFeatureRowsDistance rowsDistance =
NearDistanceProvider.GetRowsDistance(row, tableIndex);
foreach (IRow neighborRow in
Search((ITable)_reference, filter, _helper, geom0))
{
var rowNeighbor = (IFeature)neighborRow;
if (IgnoreNeighbor(row, neighborRow))
{
continue;
}
SegmentNeighbors processed1;
var neighborKey = new RowKey(rowNeighbor, neighborTableIndex);
if (!ProcessedList.TryGetValue(neighborKey, out processed1))
{
processed1 = new SegmentNeighbors(new SegmentPartComparer());
ProcessedList.Add(neighborKey, processed1);
}
NeighborhoodFinder finder =
GetNeighborhoodFinder(rowsDistance, (IFeature)row, tableIndex,
rowNeighbor, neighborTableIndex);
errorCount += FindNeighborhood(finder, tableIndex, processed0,
neighborTableIndex, processed1,
maxNear);
}
return(errorCount);
}
protected override NeighborhoodFinder GetNeighborhoodFinder(
IFeatureRowsDistance rowsDistance, IFeature feature, int tableIndex,
IFeature neighbor, int neighborTableIndex)
{
return(new NearNeighborhoodFinder(
rowsDistance, feature, tableIndex, neighbor, neighborTableIndex, _coincidentParts,
_coincidenceTolerance,
_coincidenceToleranceSquared, Is3D));
}
public NearNeighborhoodFinder(
[NotNull] IFeatureRowsDistance rowsDistance,
[NotNull] IFeature feature, int tableIndex,
[CanBeNull] IFeature neighbor, int neighborTableIndex,
SegmentNeighbors coincidentParts,
double coincidenceTolerance,
double coincidenceToleranceSquared, bool is3D)
: base(rowsDistance, feature, tableIndex, neighbor, neighborTableIndex)
{
_coincidentParts = coincidentParts;
_coincidenceTolerance = coincidenceTolerance;
_coincidenceToleranceSquared = coincidenceToleranceSquared;
_is3D = is3D;
}
private void RecalcNeighbor([NotNull] SegmentPartWithNeighbor neighbor,
[NotNull] SegmentPartWithNeighbor part,
[NotNull] SegmentPair hulls)
{
IFeatureRowsDistance rowsDistance =
NearDistanceProvider.GetRowsDistance(part.NeighborFeature,
part.NeighborTableIndex);
SegmentHull neighborhull = CreateSegmentHull(
(SegmentProxy)part.NeighborProxy, rowsDistance,
hulls.Neighbor.StartCap, hulls.Neighbor.EndCap);
SegmentHull hull = CreateNeighborSegmentHull(
(SegmentProxy)Assert.NotNull(part.SegmentProxy, "segmentproxy is null"),
rowsDistance, neighbor.NeighborFeature, // == part.Feature
neighbor.NeighborTableIndex, // == part.TableIndex
hulls.Hull.StartCap, hulls.Hull.EndCap);
RecalcPart(neighbor, neighborhull, hull);
}
protected override int ExecuteCore(IRow row, int tableIndex)
{
if (tableIndex != 0)
{
return(NoError);
}
if (_spatialFilters == null)
{
InitFilter();
}
IList <ISpatialFilter> filters = Assert.NotNull(_spatialFilters);
// iterating over all needed tables
int neighborTableIndex = -1;
IGeometry geom0 = ((IFeature)row).Shape;
geom0.QueryEnvelope(_queryBox);
SegmentNeighbors processed0;
var rowKey = new RowKey(row, tableIndex);
if (!ProcessedList.TryGetValue(rowKey, out processed0))
{
// add to process List
processed0 = new SegmentNeighbors(new SegmentPartComparer());
ProcessedList.Add(rowKey, processed0);
}
_queryBox.Expand(SearchDistance, SearchDistance, false);
double maxNear = SearchDistance;
IFeatureRowsDistance rowsDistance =
NearDistanceProvider.GetRowsDistance(row, tableIndex);
foreach (IFeatureClass neighborFeatureClass in _referenceList)
{
neighborTableIndex++;
ISpatialFilter spatialFilter = filters[neighborTableIndex];
spatialFilter.Geometry = _queryBox;
var neighborTable = (ITable)neighborFeatureClass;
foreach (IRow neighborRow in
Search(neighborTable, spatialFilter, _helperList[neighborTableIndex], geom0))
{
if (IgnoreNeighbor(row, neighborRow, neighborTableIndex))
{
continue;
}
var neighborFeature = (IFeature)neighborRow;
var processed1 = new SegmentNeighbors(new SegmentPartComparer());
var finder = new FullNeighborhoodFinder(
rowsDistance, (IFeature)row, tableIndex, neighborFeature,
neighborTableIndex);
FindNeighborhood(finder, tableIndex, processed0,
neighborTableIndex, processed1,
maxNear);
}
}
// Remark: here only the neighborhood properties are found
// if these properties are correct is checked in OnProgressedChanged
return(NoError);
}
protected override int ExecuteCore(IRow row, int tableIndex)
{
if (tableIndex > 0)
{
return(NoError);
}
var feature = row as IFeature;
if (feature == null)
{
return(NoError);
}
if (_filter == null)
{
InitFilter();
Assert.NotNull(_filter, "_filter");
}
var processed0 = new SegmentNeighbors(new SegmentPartComparer());
IGeometry geom0 = feature.Shape;
IEnvelope box0 = geom0.Envelope;
const bool asRatio = false;
box0.Expand(SearchDistance, SearchDistance, asRatio);
ISpatialFilter filter = Assert.NotNull(_filter);
filter.Geometry = box0;
var errorCount = 0;
double maxNear = SearchDistance;
const int referenceTableIndex = 0;
IFeatureRowsDistance rowsDistance =
NearDistanceProvider.GetRowsDistance(feature, tableIndex);
foreach (IRow neighborRow in Search((ITable)_reference, filter, _helper, geom0))
{
var neighborFeature = (IFeature)neighborRow;
if (neighborFeature == feature)
{
continue;
}
// TODO apply comparison condition to filter out irrelevant pairs
if (IgnoreNeighbor(row, neighborRow))
{
continue;
}
SegmentNeighbors processed1;
var neighborKey = new RowKey(neighborFeature, referenceTableIndex);
if (!ProcessedList.TryGetValue(neighborKey, out processed1))
{
processed1 = new SegmentNeighbors(new SegmentPartComparer());
ProcessedList.Add(neighborKey, processed1);
}
NeighborhoodFinder finder = new NotNearNeighborhoodFinder(
rowsDistance, feature, tableIndex, neighborFeature, referenceTableIndex);
errorCount += FindNeighborhood(finder, tableIndex, processed0,
referenceTableIndex, processed1,
maxNear);
}
return(errorCount);
}
private Dictionary <FeaturePoint, SegmentInfo> GetFlatEnds(
[NotNull] Dictionary <FeaturePoint, List <NeighboredSegmentsSubpart> > splittedParts,
[NotNull] ContinuationFinder continuationFinder, out int errorCount)
{
errorCount = 0;
var flatEnds =
new Dictionary <FeaturePoint, SegmentInfo>(new FeaturePointComparer());
foreach (
KeyValuePair <FeaturePoint, List <NeighboredSegmentsSubpart> > splitted in
splittedParts)
{
foreach (NeighboredSegmentsSubpart segmentsSubpart in splitted.Value)
{
foreach (
KeyValuePair <SegmentPart, SegmentParts> neighboredSegmentPart in
segmentsSubpart.SegmentNeighbors)
{
SegmentPart key = neighboredSegmentPart.Key;
if (key.SegmentIndex > 0 &&
key.SegmentIndex < segmentsSubpart.FullMaxFraction - 1)
{
continue;
}
var flatStart = false;
var flatEnd = false;
foreach (SegmentPart segmentPart in neighboredSegmentPart.Value)
{
if (!flatStart && segmentPart.FullMin <= 0)
{
flatStart = HandleAsFlat(segmentsSubpart, segmentPart.FullMin,
continuationFinder);
}
if (!flatEnd && segmentPart.FullMax >=
segmentsSubpart.FullMaxFraction)
{
flatEnd = HandleAsFlat(segmentsSubpart, segmentPart.FullMax,
continuationFinder);
}
}
if (flatStart || flatEnd)
{
IFeatureRowsDistance rowsDistance =
NearDistanceProvider.GetRowsDistance(splitted.Key.Feature,
splitted.Key.TableIndex);
double rowDistance = rowsDistance.GetRowDistance();
if (flatStart)
{
errorCount += CreateFlatEnds(
segmentsSubpart, rowDistance, flatEnds, continuationFinder,
atStart: true);
}
if (flatEnd)
{
errorCount += CreateFlatEnds(
segmentsSubpart, rowDistance, flatEnds, continuationFinder,
atStart: false);
}
if (flatStart && flatEnd)
{
double sumLength = 0;
double limit = 2 * rowDistance;
foreach (SegmentProxy segmentProxy in segmentsSubpart
.GetSegments())
{
sumLength += segmentProxy.Length;
if (sumLength > limit)
{
break;
}
}
if (sumLength < limit && ReportShortSubpartError != null)
{
errorCount += ReportShortSubpartError(
new ShortSubpartError(
segmentsSubpart, sumLength, limit));
}
}
}
}
}
}
return(flatEnds);
}
private SegmentPair RecalcFlatEnd(
[NotNull] FeaturePoint end,
[NotNull] SegmentPartWithNeighbor segWithNb,
[NotNull] Dictionary <FeaturePoint, SegmentInfo> flatEnds,
out bool neighborIsFlatEnd)
{
IFeatureRowsDistance rowsDistance =
NearDistanceProvider.GetRowsDistance(end.Feature, end.TableIndex);
SegmentInfo segmentInfo;
Find(end, segWithNb.SegmentIndex, flatEnds, out segmentInfo);
SegmentCap startCap = segmentInfo.FlatStart
? (SegmentCap) new RectCap(0)
: new RoundCap();
SegmentCap endCap = segmentInfo.FlatEnd
? (SegmentCap) new RectCap(0)
: new RoundCap();
SegmentHull hull = CreateSegmentHull(
(SegmentProxy)Assert.NotNull(segWithNb.SegmentProxy, "segmentproxy is null"),
rowsDistance, startCap, endCap);
var neighborKey = new FeaturePoint(segWithNb.NeighborFeature,
segWithNb.NeighborTableIndex,
segWithNb.PartIndex, 0);
neighborIsFlatEnd = false;
SegmentInfo neighborInfo;
SegmentCap nbStartCap;
SegmentCap nbEndCap;
if (Find(neighborKey, segWithNb.NeighborProxy.SegmentIndex, flatEnds,
out neighborInfo))
{
neighborIsFlatEnd = true;
nbStartCap = neighborInfo.FlatStart
? (SegmentCap) new RectCap(0)
: new RoundCap();
nbEndCap = neighborInfo.FlatEnd
? (SegmentCap) new RectCap(0)
: new RoundCap();
}
else
{
nbStartCap = new RoundCap();
nbEndCap = new RoundCap();
}
SegmentHull neighborhull = CreateNeighborSegmentHull(
(SegmentProxy)segWithNb.NeighborProxy, rowsDistance, segWithNb.NeighborFeature,
segWithNb.NeighborTableIndex, nbStartCap, nbEndCap);
SegmentPair segPair = RecalcPart(segWithNb, hull, neighborhull);
return(segPair);
}
