public void Prepare(IEnumerable <IFeature> sourceFeatures,
IList <IFeature> targetFeatures,
IEnvelope processingExtent,
bool useMinimalTolerance,
ReshapeCurveFilterOptions filterOptions)
{
ClipExtent = processingExtent;
UseMinimumTolerance = useMinimalTolerance;
IList <IGeometry> sourceGeometries =
GdbObjectUtils.GetGeometries(sourceFeatures);
// Consider remembering the pre-processed sources. But clipping is really fast.
List <IPolyline> preprocessedSource =
sourceGeometries
.Select(
g => ChangeGeometryAlongUtils.GetPreprocessedGeometryForExtent(
g, processingExtent))
.ToList();
var targetGeometries = GdbObjectUtils.GetGeometries(targetFeatures);
SubcurveFilter.PrepareFilter(
preprocessedSource, targetGeometries, useMinimalTolerance, filterOptions);
foreach (IGeometry sourceGeometry in sourceGeometries)
{
Marshal.ReleaseComObject(sourceGeometry);
}
foreach (IGeometry targetGeometry in targetGeometries)
{
Marshal.ReleaseComObject(targetGeometry);
}
}
public void Prepare(IEnumerable <IFeature> selectedFeatures,
IList <IFeature> targetFeatures,
IEnvelope processingExtent,
bool useMinimalTolerance,
ReshapeCurveFilterOptions filterOptions)
{
_standardSubcurveCalculator.Prepare(selectedFeatures, targetFeatures,
processingExtent, useMinimalTolerance,
filterOptions);
}
/// <summary>
/// Limited reshape curve calculation without support for multiple-sources-as-union, adjust and preview-calculation
/// </summary>
/// <param name="sourceFeatures"></param>
/// <param name="targetFeatures"></param>
/// <param name="visibleExtent"></param>
/// <param name="useMinimalTolerance"></param>
/// <param name="bufferOptions"></param>
/// <param name="filterOptions"></param>
/// <param name="resultSubcurves"></param>
/// <param name="trackCancel"></param>
/// <returns></returns>
public static ReshapeAlongCurveUsability CalculateReshapeCurves(
[NotNull] IList <IFeature> sourceFeatures,
[NotNull] IList <IFeature> targetFeatures,
[CanBeNull] IEnvelope visibleExtent,
bool useMinimalTolerance,
TargetBufferOptions bufferOptions,
ReshapeCurveFilterOptions filterOptions,
IList <CutSubcurve> resultSubcurves,
[CanBeNull] ITrackCancel trackCancel)
{
Assert.ArgumentCondition(sourceFeatures.Count > 0, "No selected features");
IEnvelope clipExtent =
GetClipExtent(visibleExtent,
bufferOptions.BufferTarget ? bufferOptions.BufferDistance : 0);
ISubcurveCalculator curveCalculator = new ReshapableSubcurveCalculator();
curveCalculator.SubcurveFilter =
new SubcurveFilter(new StaticExtentProvider(visibleExtent));
IGeometry targetGeometry = BuildTargetGeometry(targetFeatures, clipExtent);
string reasonForEmptyTargetLine;
IPolyline targetLine = PrepareTargetLine(
sourceFeatures, targetGeometry, clipExtent, bufferOptions,
out reasonForEmptyTargetLine, trackCancel);
if (targetLine == null || targetLine.IsEmpty)
{
return(ReshapeAlongCurveUsability.NoTarget);
}
PrepareSubcurveCalculator(curveCalculator, sourceFeatures, targetFeatures,
useMinimalTolerance, filterOptions, clipExtent);
ReshapeAlongCurveUsability result;
if (sourceFeatures.Count == 1)
{
result = RecalculateReshapableSubcurves(
sourceFeatures[0], targetLine, curveCalculator,
resultSubcurves, trackCancel);
}
else
{
result = AddAdditionalSingleGeometryReshapeCurves(
sourceFeatures, targetLine, null, curveCalculator, resultSubcurves,
trackCancel);
}
// TODO: Adjust lines, Difference areas
return(result);
}
public static void PrepareSubcurveCalculator(
ISubcurveCalculator subCurveCalculator,
[NotNull] IList <IFeature> sourceFeatures,
[NotNull] IList <IFeature> targetFeatures,
bool useMinimalTolerance,
ReshapeCurveFilterOptions filterOptions,
[CanBeNull] IEnvelope clipExtent)
{
Assert.ArgumentNotNull(subCurveCalculator, nameof(subCurveCalculator));
subCurveCalculator.Prepare(sourceFeatures, targetFeatures, clipExtent,
useMinimalTolerance, filterOptions);
}
/// <summary>
/// Cut curve calculation.
/// </summary>
/// <param name="sourceFeatures"></param>
/// <param name="targetFeatures"></param>
/// <param name="visibleExtent"></param>
/// <param name="tolerance"></param>
/// <param name="bufferOptions"></param>
/// <param name="filterOptions"></param>
/// <param name="resultSubcurves"></param>
/// <param name="trackCancel"></param>
/// <returns></returns>
public static ReshapeAlongCurveUsability CalculateCutCurves(
[NotNull] IList <IFeature> sourceFeatures,
[NotNull] IList <IFeature> targetFeatures,
[CanBeNull] IEnvelope visibleExtent,
double tolerance,
TargetBufferOptions bufferOptions,
ReshapeCurveFilterOptions filterOptions,
IList <CutSubcurve> resultSubcurves,
[CanBeNull] ITrackCancel trackCancel = null)
{
ISubcurveCalculator curveCalculator = new CutPolygonSubcurveCalculator();
return(CalculateChangeAlongCurves(sourceFeatures, targetFeatures, visibleExtent,
tolerance, bufferOptions, filterOptions,
resultSubcurves, curveCalculator, trackCancel));
}
/// <summary>
/// Limited reshape curve calculation without support for multiple-sources-as-union,
/// adjust and preview-calculation.
/// </summary>
/// <param name="sourceFeatures"></param>
/// <param name="targetFeatures"></param>
/// <param name="visibleExtent"></param>
/// <param name="tolerance"></param>
/// <param name="bufferOptions"></param>
/// <param name="filterOptions"></param>
/// <param name="resultSubcurves"></param>
/// <param name="curveCalculator"></param>
/// <param name="trackCancel"></param>
/// <returns></returns>
public static ReshapeAlongCurveUsability CalculateChangeAlongCurves(
[NotNull] IList <IFeature> sourceFeatures,
[NotNull] IList <IFeature> targetFeatures,
[CanBeNull] IEnvelope visibleExtent,
double tolerance,
[NotNull] TargetBufferOptions bufferOptions,
[NotNull] ReshapeCurveFilterOptions filterOptions,
IList <CutSubcurve> resultSubcurves,
[NotNull] ISubcurveCalculator curveCalculator,
[CanBeNull] ITrackCancel trackCancel = null)
{
Assert.ArgumentCondition(
sourceFeatures.All(
f => curveCalculator.CanUseSourceGeometryType(
DatasetUtils.GetShapeType(f.Class))),
"Source feature list contains invalid geometry type(s)");
Assert.ArgumentCondition(targetFeatures.All(CanUseAsTargetFeature),
"Target feature list contains invalid features");
if (sourceFeatures.Count == 0)
{
return(ReshapeAlongCurveUsability.NoSource);
}
if (targetFeatures.Count == 0)
{
return(ReshapeAlongCurveUsability.NoTarget);
}
visibleExtent = visibleExtent ?? UnionExtents(sourceFeatures, targetFeatures);
// TODO: Actual tolerance that can be specified (using double for forward compatibility)
bool useMinimalTolerance = MathUtils.AreEqual(0, tolerance);
IEnvelope clipExtent =
GetClipExtent(visibleExtent,
bufferOptions.BufferTarget ? bufferOptions.BufferDistance : 0);
curveCalculator.SubcurveFilter =
new SubcurveFilter(new StaticExtentProvider(visibleExtent));
IGeometry targetGeometry = BuildTargetGeometry(targetFeatures, clipExtent);
IPolyline targetLine = PrepareTargetLine(
sourceFeatures, targetGeometry, clipExtent, bufferOptions,
out string _, trackCancel);
if (targetLine == null || targetLine.IsEmpty)
{
return(ReshapeAlongCurveUsability.NoTarget);
}
PrepareSubcurveCalculator(curveCalculator, sourceFeatures, targetFeatures,
useMinimalTolerance, filterOptions, clipExtent);
ReshapeAlongCurveUsability result;
if (sourceFeatures.Count == 1)
{
result = RecalculateReshapableSubcurves(
sourceFeatures[0], targetLine, curveCalculator,
resultSubcurves, trackCancel);
}
else
{
result = AddAdditionalSingleGeometryReshapeCurves(
sourceFeatures, targetLine, null, curveCalculator, resultSubcurves,
trackCancel);
}
// TODO: Adjust lines, Difference areas
return(result);
}
public SubcurveFilter PrepareFilter(
[NotNull] IList <IPolyline> preprocessedSourceLines,
[NotNull] IList <IGeometry> targetGeometries,
bool useMinimalTolerance,
[NotNull] ReshapeCurveFilterOptions filterOptions)
{
_useMinimalTolerance = useMinimalTolerance;
_filterOptions = filterOptions;
ReleaseFilterObjects();
if (filterOptions.OnlyInVisibleExtent)
{
Assert.NotNull(_extentProvider);
_currentlyVisibleExtents = new List <IEnvelope>();
// add the lens window extents
_currentlyVisibleExtents.AddRange(
_extentProvider.GetVisibleLensWindowExtents());
// plus the main map window
_currentlyVisibleExtents.Add(_extentProvider.GetCurrentExtent());
}
if (filterOptions.ExcludeOutsideTolerance)
{
// NOTE: Buffer lines / outlines -> otherwise we miss lines for individual reshapes
// and clip on extent (pre-process) before buffering to improve performance
var sourceOutline =
(IPolyline)GeometryUtils.UnionGeometries(preprocessedSourceLines);
const int logInfoPointCountThreshold = 10000;
var bufferNotifications = new NotificationCollection();
if (AdjustUtils.TryBuffer(sourceOutline,
filterOptions.ExcludeTolerance,
logInfoPointCountThreshold,
"Calculating reshape line tolerance buffer...",
bufferNotifications,
out _mustBeWithinSourceBuffer))
{
ExclusionOutsideSourceBufferLine =
GeometryFactory.CreatePolyline(
Assert.NotNull(_mustBeWithinSourceBuffer));
}
else
{
_msg.WarnFormat(
"Unable to calculate reshape line tolerance buffer: {0}",
bufferNotifications.Concatenate(". "));
}
Marshal.ReleaseComObject(sourceOutline);
}
if (filterOptions.ExcludeResultingInOverlaps)
{
_targetUnionPoly = ReshapeUtils.CreateUnionPolygon(
targetGeometries, _useMinimalTolerance);
}
return(this);
}
