private static AdvancedReshapeRequest CreateReshapeRequest(
[NotNull] IList <Feature> selectedFeatures,
[NotNull] Polyline reshapePath,
[CanBeNull] IList <Feature> adjacentFeatures,
bool allowOpenJaw, bool multiReshapeAsUnion, bool useNonDefaultSide)
{
var request = new AdvancedReshapeRequest();
ProtobufConversionUtils.ToGdbObjectMsgList(selectedFeatures,
request.Features,
request.ClassDefinitions);
ShapeMsg reshapePathMsg = ProtobufConversionUtils.ToShapeMsg(reshapePath);
request.ReshapePaths = reshapePathMsg;
request.AllowOpenJawReshape = allowOpenJaw;
request.UseNonDefaultReshapeSide = useNonDefaultSide;
request.MultipleSourcesTryUnion = multiReshapeAsUnion;
// TODO: from options
request.MoveOpenJawEndJunction = true;
if (adjacentFeatures != null)
{
ProtobufConversionUtils.ToGdbObjectMsgList(
adjacentFeatures, request.PotentiallyConnectedFeatures,
request.ClassDefinitions);
}
return(request);
}
public static async Task <MapPoint> GetOpenJawReplacementPointAsync(
[NotNull] ReshapeGrpc.ReshapeGrpcClient rpcClient,
[NotNull] Feature polylineFeature,
[NotNull] Polyline reshapeLine,
bool useNonDefaultReshapeSide)
{
var request = new OpenJawReshapeLineReplacementRequest()
{
UseNonDefaultReshapeSide = useNonDefaultReshapeSide
};
SpatialReference sr =
await QueuedTaskUtils.Run(
() =>
{
Geometry geometryToReshape = polylineFeature.GetShape();
request.Feature = ProtobufConversionUtils.ToGdbObjectMsg(
polylineFeature, geometryToReshape, true);
request.ReshapePath = ProtobufConversionUtils.ToShapeMsg(reshapeLine);
return(geometryToReshape.SpatialReference);
});
// Not in a queued task (but it is still called multiple times because...)
ShapeMsg pointMsg = rpcClient.GetOpenJawReshapeLineReplaceEndPoint(request);
return(await QueuedTaskUtils.Run(
() => (MapPoint)ProtobufConversionUtils.FromShapeMsg(pointMsg, sr)));
}
public void InitializeSchema(ICollection <Dataset> datasets)
{
if (_dataRequestFunc == null)
{
return;
}
if (_virtualWorkspaces != null)
{
return;
}
var dataRequest = new DataVerificationResponse
{
SchemaRequest = new SchemaRequest()
};
dataRequest.SchemaRequest.DatasetIds.AddRange(datasets.Select(d => d.Id));
DataVerificationRequest dataResponse = _dataRequestFunc(dataRequest);
SetGdbSchema(ProtobufConversionUtils.CreateSchema(
dataResponse.Schema.ClassDefinitions,
dataResponse.Schema.RelclassDefinitions, _dataRequestFunc));
}
private static void AssertCanConvertToDtoAndBack(IList <IFeature> features)
{
ICollection <GdbObjectMsg> dehydrated = new List <GdbObjectMsg>();
HashSet <ObjectClassMsg> dehydratedClasses = new HashSet <ObjectClassMsg>();
ProtobufGdbUtils.ToGdbObjectMsgList(features, dehydrated, dehydratedClasses);
IList <IFeature> rehydrated =
ProtobufConversionUtils.FromGdbObjectMsgList(dehydrated, dehydratedClasses);
Assert.AreEqual(features.Count, rehydrated.Count);
foreach (IFeature original in features)
{
IFeature rehydratedFeature = rehydrated.Single(
f => GdbObjectUtils.IsSameObject(original, f,
ObjectClassEquality.SameTableSameVersion));
Assert.AreEqual(original.Class.ObjectClassID,
rehydratedFeature.Class.ObjectClassID);
Assert.AreEqual(DatasetUtils.GetName(original.Class),
DatasetUtils.GetName(rehydratedFeature.Class));
AssertSameFeature(original, rehydratedFeature);
}
}
public void CanCreateFeatureWithoutTableSchema()
{
ISpatialReference sr =
SpatialReferenceUtils.CreateSpatialReference(WellKnownHorizontalCS.LV95);
IPolygon shape = GeometryFactory.CreatePolygon(
GeometryFactory.CreatePoint(2600000, 1200000, sr),
GeometryFactory.CreatePoint(2600050, 1200080, sr));
GdbObjectMsg featureMsg = new GdbObjectMsg
{
ClassHandle = -1,
ObjectId = 42,
Shape = ProtobufGeometryUtils.ToShapeMsg(shape)
};
GdbFeatureClass fClass =
new GdbFeatureClass(1, "Test", esriGeometryType.esriGeometryPolygon);
GdbRow gdbRow = ProtobufConversionUtils.FromGdbObjectMsg(featureMsg, fClass);
GdbFeature feature = (GdbFeature)gdbRow;
Assert.AreEqual(42, feature.OID);
Assert.True(GeometryUtils.AreEqual(shape, feature.Shape));
Assert.AreEqual(1, feature.Class.ObjectClassID);
}
public override IRow GetRow(int id)
{
Assert.True(_schema.HasOID, "The table {0} has no OID", DatasetUtils.GetName(_schema));
Assert.False(string.IsNullOrEmpty(_schema.OIDFieldName),
"The table {0} has no OID Field Name", DatasetUtils.GetName(_schema));
DataVerificationResponse response =
new DataVerificationResponse
{
DataRequest = new DataRequest
{
WhereClause = $"{_schema.OIDFieldName} = {id}"
}
};
if (_queryDefinition != null)
{
response.DataRequest.RelQueryDef = _queryDefinition;
}
else
{
response.DataRequest.ClassDef = Assert.NotNull(_classDefinition);
}
DataVerificationRequest moreData = GetData(response);
foreach (GdbObjectMsg gdbObjMsg in moreData.Data.GdbObjects)
{
return(ProtobufConversionUtils.FromGdbObjectMsg(gdbObjMsg, _schema));
}
// or better: COMException?
return(null);
}
public static Overlaps CalculateOverlaps(
RemoveOverlapsGrpc.RemoveOverlapsGrpcClient rpcClient,
[NotNull] IList <Feature> selectedFeatures,
[NotNull] IList <Feature> overlappingFeatures,
CancellationToken cancellationToken)
{
CalculateOverlapsResponse response =
CalculateOverlapsRpc(rpcClient, selectedFeatures, overlappingFeatures,
cancellationToken);
if (response == null || cancellationToken.IsCancellationRequested)
{
return(null);
}
var result = new Overlaps();
foreach (OverlapMsg overlapMsg in response.Overlaps)
{
GdbObjectReference gdbObjRef = new GdbObjectReference(
overlapMsg.OriginalFeatureRef.ClassHandle,
overlapMsg.OriginalFeatureRef.ObjectId);
List <Geometry> overlapGeometries =
ProtobufConversionUtils.FromShapeMsgList(overlapMsg.Overlaps);
result.AddGeometries(gdbObjRef, overlapGeometries);
}
result.Notifications.AddRange(
response.Notifications.Select(n => new Notification(n)));
return(result);
}
private static IList <IFeature> GetUpToDateTargets(
[NotNull] GeometryReshaperBase reshaper,
[NotNull] CalculateReshapeLinesRequest originalRequest)
{
var result = new HashSet <IFeature>();
if (reshaper.UpdatedTargets != null)
{
foreach (var updatedTarget in reshaper.UpdatedTargets.Keys)
{
result.Add(updatedTarget);
}
}
if (reshaper.TargetFeatures != null)
{
foreach (IFeature origTarget in reshaper.TargetFeatures)
{
if (!result.Contains(origTarget))
{
result.Add(origTarget);
}
}
}
else
{
IList <IFeature> targetFeatures =
ProtobufConversionUtils.FromGdbObjectMsgList(originalRequest.TargetFeatures,
originalRequest.ClassDefinitions);
return(targetFeatures);
}
return(result.ToList());
}
private static RemoveOverlapsRequest CreateRemoveOverlapsRequest(
IEnumerable <Feature> selectedFeatures,
Overlaps overlapsToRemove,
IList <Feature> targetFeaturesForVertexInsertion, //RemoveOverlapsOptions options,
out List <Feature> updateFeatures)
{
var request = new RemoveOverlapsRequest
{
ExplodeMultipartResults = true, // options.ExplodeMultipartResults,
StoreOverlapsAsNewFeatures =
false // options.StoreOverlapsAsNewFeatures
};
updateFeatures = new List <Feature>();
var selectedFeatureList = CollectionUtils.GetCollection(selectedFeatures);
ProtobufConversionUtils.ToGdbObjectMsgList(
selectedFeatureList, request.SourceFeatures, request.ClassDefinitions);
updateFeatures.AddRange(selectedFeatureList);
foreach (var overlapsBySourceRef in overlapsToRemove.OverlapGeometries)
{
int classId = (int)overlapsBySourceRef.Key.ClassId;
int objectId = (int)overlapsBySourceRef.Key.ObjectId;
var overlapMsg = new OverlapMsg();
overlapMsg.OriginalFeatureRef = new GdbObjRefMsg()
{
ClassHandle = classId,
ObjectId = objectId
};
foreach (Geometry overlap in overlapsBySourceRef.Value)
{
overlapMsg.Overlaps.Add(ProtobufConversionUtils.ToShapeMsg(overlap, true));
}
request.Overlaps.Add(overlapMsg);
}
if (targetFeaturesForVertexInsertion != null)
{
ProtobufConversionUtils.ToGdbObjectMsgList(
targetFeaturesForVertexInsertion, request.UpdatableTargetFeatures,
request.ClassDefinitions);
updateFeatures.AddRange(targetFeaturesForVertexInsertion);
}
return(request);
}
private static void AssertCanConvertToDtoAndBack(GdbFeature feature)
{
GdbObjectMsg dehydrated =
ProtobufGdbUtils.ToGdbObjectMsg(feature);
var featureClass = (GdbFeatureClass)feature.Class;
GdbFeature rehydrated = ProtobufConversionUtils.FromGdbFeatureMsg(
dehydrated, new GdbTableContainer(new[] { featureClass }));
AssertSameFeature(feature, rehydrated);
}
private static void PopulateCalculationRequestLists(
IList <Feature> selectedFeatures,
IList <Feature> targetFeatures,
ICollection <GdbObjectMsg> sourceFeatureMsgs,
ICollection <GdbObjectMsg> targetFeatureMsgs,
ICollection <ObjectClassMsg> classDefinitions)
{
ProtobufConversionUtils.ToGdbObjectMsgList(selectedFeatures,
sourceFeatureMsgs,
classDefinitions);
ProtobufConversionUtils.ToGdbObjectMsgList(targetFeatures,
targetFeatureMsgs,
classDefinitions);
}
private ITable GetRemoteQueryTable([NotNull] string relationshipClassName,
[NotNull] Model model,
[NotNull] IList <ITable> tables,
JoinType joinType,
[CanBeNull] string whereClause)
{
var dataRequest = new DataVerificationResponse
{
SchemaRequest = new SchemaRequest()
};
RelationshipClassQuery relClassQueryMsg =
new RelationshipClassQuery
{
RelationshipClassName = relationshipClassName,
WorkspaceHandle = model.Id,
JoinType = (int)joinType,
};
relClassQueryMsg.Tables.AddRange(tables.Select(DatasetUtils.GetName));
if (!string.IsNullOrEmpty(whereClause))
{
relClassQueryMsg.WhereClause = whereClause;
}
dataRequest.SchemaRequest.RelationshipClassQueries.Add(relClassQueryMsg);
DataVerificationRequest dataResponse = _dataRequestFunc(dataRequest);
GdbWorkspace gdbWorkspace =
Assert.NotNull(_virtualWorkspaces).First(w => w.WorkspaceHandle == model.Id);
ObjectClassMsg queryTableMsg = dataResponse.Schema.RelclassDefinitions.First();
Func <ITable, BackingDataset> createBackingDataset = null;
if (_dataRequestFunc != null)
{
createBackingDataset = (t) =>
new RemoteDataset(t, _dataRequestFunc, null, relClassQueryMsg);
}
// It is cached on the client side, in case various tests utilize the same definition.
// TODO: Test!
return(ProtobufConversionUtils.FromObjectClassMsg(queryTableMsg, gdbWorkspace,
createBackingDataset));
}
private static CalculateOverlapsRequest CreateCalculateOverlapsRequest(
[NotNull] IList <Feature> selectedFeatures,
[NotNull] IList <Feature> overlappingFeatures)
{
var request = new CalculateOverlapsRequest();
ProtobufConversionUtils.ToGdbObjectMsgList(selectedFeatures,
request.SourceFeatures,
request.ClassDefinitions);
ProtobufConversionUtils.ToGdbObjectMsgList(overlappingFeatures,
request.TargetFeatures,
request.ClassDefinitions);
return(request);
}
private static void GetFeatures([NotNull] RepeatedField <GdbObjectMsg> requestSourceFeatures,
[NotNull] RepeatedField <GdbObjectMsg> requestTargetFeatures,
[NotNull] RepeatedField <ObjectClassMsg> classDefinitions,
[NotNull] out IList <IFeature> sourceFeatures,
[NotNull] out IList <IFeature> targetFeatures)
{
Stopwatch watch = Stopwatch.StartNew();
sourceFeatures = ProtobufConversionUtils.FromGdbObjectMsgList(requestSourceFeatures,
classDefinitions);
targetFeatures = ProtobufConversionUtils.FromGdbObjectMsgList(requestTargetFeatures,
classDefinitions);
_msg.DebugStopTiming(
watch,
"CalculateReshapeLinesImpl: Unpacked {0} source and {1} target features from request params",
sourceFeatures.Count, targetFeatures.Count);
}
private static CutSubcurve FromReshapeLineMsg(ReshapeLineMsg reshapeLineMsg)
{
var path = (Polyline)ProtobufConversionUtils.FromShapeMsg(reshapeLineMsg.Path);
var targetSegmentAtFrom =
(Polyline)ProtobufConversionUtils.FromShapeMsg(reshapeLineMsg.TargetSegmentAtFrom);
var targetSegmentAtTo =
(Polyline)ProtobufConversionUtils.FromShapeMsg(reshapeLineMsg.TargetSegmentAtTo);
var extraInsertPoints =
ProtobufConversionUtils.FromShapeMsg(reshapeLineMsg.ExtraTargetInsertPoints);
var result = new CutSubcurve(Assert.NotNull(path),
reshapeLineMsg.CanReshape, reshapeLineMsg.IsCandidate,
reshapeLineMsg.IsFiltered,
targetSegmentAtFrom, targetSegmentAtTo, extraInsertPoints);
return(result);
}
private static IList <IFeature> GetFeaturesToReshape(
[NotNull] AdvancedReshapeRequest request,
out GdbTableContainer container)
{
container = ProtobufConversionUtils.CreateGdbTableContainer(
request.ClassDefinitions, null, out _);
foreach (IDataset dataset in container.GetDatasets(esriDatasetType.esriDTAny))
{
if (dataset is IObjectClass objectClass)
{
objectClass.AddField(FieldUtils.CreateOIDField());
}
}
IList <IFeature> featuresToReshape =
ProtobufConversionUtils.FromGdbObjectMsgList(request.Features, container);
return(featuresToReshape);
}
private static RemoveOverlapsResult GetRemoveOverlapsResult(
RemoveOverlapsResponse response,
List <Feature> updateFeatures)
{
// unpack
var result = new RemoveOverlapsResult
{
ResultHasMultiparts = response.ResultHasMultiparts
};
IList <OverlapResultGeometries> resultGeometriesByFeature = result.ResultsByFeature;
// match the selected features with the protobuf features -> use GdbObjRef (shapefile support!)
ReAssociateResponseGeometries(response, resultGeometriesByFeature,
updateFeatures);
if (response.TargetFeaturesToUpdate != null)
{
result.TargetFeaturesToUpdate = new Dictionary <Feature, Geometry>();
foreach (GdbObjectMsg targetMsg in response.TargetFeaturesToUpdate)
{
Feature originalFeature =
GetOriginalFeature(targetMsg.ObjectId, targetMsg.ClassHandle,
updateFeatures);
result.TargetFeaturesToUpdate.Add(
originalFeature,
ProtobufConversionUtils.FromShapeMsg(targetMsg.Shape));
}
}
foreach (string message in response.NonStorableMessages)
{
result.NonStorableMessages.Add(message);
}
return(result);
}
public override IEnumerable <IRow> Search(IQueryFilter filter, bool recycling)
{
DataRequest dataRequest = CreateDataRequest(filter);
DataVerificationResponse response =
new DataVerificationResponse
{
DataRequest = dataRequest
};
DataVerificationRequest moreData = GetData(response);
if (moreData == null)
{
throw new IOException(
$"No data provided by the client for data request {response.DataRequest}");
}
foreach (GdbObjectMsg gdbObjMsg in moreData.Data.GdbObjects)
{
yield return(ProtobufConversionUtils.FromGdbObjectMsg(gdbObjMsg, _schema));
}
}
private static void ReAssociateResponseGeometries(
RemoveOverlapsResponse response,
IList <OverlapResultGeometries> results,
List <Feature> updateFeatures)
{
foreach (var resultByFeature in response.ResultsByFeature)
{
GdbObjRefMsg featureRef = resultByFeature.OriginalFeatureRef;
Feature originalFeature = GetOriginalFeature(featureRef, updateFeatures);
Geometry updatedGeometry =
ProtobufConversionUtils.FromShapeMsg(resultByFeature.UpdatedGeometry);
List <Geometry> newGeometries =
ProtobufConversionUtils.FromShapeMsgList(resultByFeature.NewGeometries);
var overlapResultGeometries = new OverlapResultGeometries(
originalFeature, Assert.NotNull(updatedGeometry), newGeometries);
results.Add(overlapResultGeometries);
}
}
private static ReshapeLineMsg ToReshapeLineMsg(CutSubcurve subcurve)
{
var result = new ReshapeLineMsg();
result.Path = ProtobufConversionUtils.ToShapeMsg(subcurve.Path);
result.CanReshape = subcurve.CanReshape;
result.IsCandidate = subcurve.IsReshapeMemberCandidate;
result.IsFiltered = subcurve.IsFiltered;
if (subcurve.Source != null)
{
result.Source = ProtobufConversionUtils.ToGdbObjRefMsg(subcurve.Source);
}
result.TargetSegmentAtFrom =
ProtobufConversionUtils.ToShapeMsg(subcurve.TargetSegmentAtFromPoint);
result.TargetSegmentAtTo =
ProtobufConversionUtils.ToShapeMsg(subcurve.TargetSegmentAtToPoint);
result.ExtraTargetInsertPoints =
ProtobufConversionUtils.ToShapeMsg(subcurve.ExtraTargetInsertPoints);
return(result);
}
private ServiceCallStatus VerifyDataQualityCore(
[NotNull] DataVerificationRequest initialRequest,
Func <DataVerificationResponse, DataVerificationRequest> moreDataRequest,
IServerStreamWriter <DataVerificationResponse> responseStream,
ITrackCancel trackCancel)
{
var request = initialRequest.Request;
SetupUserNameProvider(request);
void SendResponse(VerificationResponse r) => responseStream.WriteAsync(
new DataVerificationResponse {
Response = r
});
BackgroundVerificationService qaService = null;
List <GdbObjRefMsg> deletableAllowedErrorRefs = new List <GdbObjRefMsg>();
QualityVerification verification = null;
var issueCollection = new ConcurrentBag <IssueMsg>();
string cancellationMessage = null;
try
{
// TODO: Separate long-lived objects, such as datasetLookup, domainTransactions (add to this class) from
// short-term objects (request) -> add to background verification inputs
IBackgroundVerificationInputs backgroundVerificationInputs =
_verificationInputsFactoryMethod(request);
if (initialRequest.Schema != null)
{
backgroundVerificationInputs.SetGdbSchema(
ProtobufConversionUtils.CreateSchema(initialRequest.Schema.ClassDefinitions,
initialRequest
.Schema.RelclassDefinitions,
moreDataRequest));
}
else if (moreDataRequest != null)
{
backgroundVerificationInputs.SetRemoteDataAccess(moreDataRequest);
}
qaService = CreateVerificationService(backgroundVerificationInputs, issueCollection,
SendResponse, trackCancel);
verification = qaService.Verify(backgroundVerificationInputs, trackCancel);
deletableAllowedErrorRefs.AddRange(
GetDeletableAllowedErrorRefs(request.Parameters, qaService));
}
catch (Exception e)
{
_msg.Error($"Error checking quality for request {request}", e);
cancellationMessage = $"Server error: {e.Message}";
SetUnhealthy();
}
ServiceCallStatus result = SendFinalResponse(
verification, cancellationMessage ?? qaService.CancellationMessage, issueCollection,
deletableAllowedErrorRefs, qaService?.VerifiedPerimeter, SendResponse);
return(result);
}
public void CanCreateGdbRowFromRealData()
{
IWorkspace ws = TestUtils.OpenUserWorkspaceOracle();
const string tlmStrasse = "TOPGIS_TLM.TLM_STRASSE";
IFeatureClass realFeatureClass = DatasetUtils.OpenFeatureClass(ws, tlmStrasse);
var objectClassMsg = ProtobufGdbUtils.ToObjectClassMsg(realFeatureClass, true);
GdbTableContainer gdbTableContainer =
ProtobufConversionUtils.CreateGdbTableContainer(
new[] { objectClassMsg }, null, out GdbWorkspace _);
var virtualFeatureClass = (IFeatureClass)gdbTableContainer.OpenTable(tlmStrasse);
Assert.AreEqual(realFeatureClass.ObjectClassID, virtualFeatureClass.ObjectClassID);
Assert.AreEqual(DatasetUtils.GetName(realFeatureClass),
DatasetUtils.GetName(virtualFeatureClass));
Assert.AreEqual(realFeatureClass.AliasName, virtualFeatureClass.AliasName);
Assert.AreEqual(realFeatureClass.ShapeFieldName, virtualFeatureClass.ShapeFieldName);
Assert.AreEqual(realFeatureClass.OIDFieldName, virtualFeatureClass.OIDFieldName);
Assert.AreEqual(realFeatureClass.FeatureClassID, virtualFeatureClass.FeatureClassID);
Assert.AreEqual(realFeatureClass.FeatureType, virtualFeatureClass.FeatureType);
Assert.AreEqual(realFeatureClass.HasOID, virtualFeatureClass.HasOID);
Assert.AreEqual(realFeatureClass.ShapeType, virtualFeatureClass.ShapeType);
Assert.AreEqual(realFeatureClass.ShapeFieldName, virtualFeatureClass.ShapeFieldName);
Assert.IsTrue(SpatialReferenceUtils.AreEqual(
DatasetUtils.GetSpatialReference(realFeatureClass),
DatasetUtils.GetSpatialReference(virtualFeatureClass), true, true));
Assert.AreEqual(realFeatureClass.Fields.FieldCount,
virtualFeatureClass.Fields.FieldCount);
int featureCount = 0;
foreach (var feature in GdbQueryUtils.GetFeatures(realFeatureClass, true))
{
// TODO: Move all this to separate project referenced by both client and server
GdbObjectMsg gdbObjectMsg =
ProtobufGdbUtils.ToGdbObjectMsg(feature, false, true);
GdbRow gdbRow =
ProtobufConversionUtils.FromGdbObjectMsg(
gdbObjectMsg, (ITable)realFeatureClass);
for (int i = 0; i < feature.Fields.FieldCount; i++)
{
object expected = feature.get_Value(i);
object actual = gdbRow.get_Value(i);
if (expected is IGeometry shape)
{
Assert.IsTrue(
GeometryUtils.AreEqual(shape, (IGeometry)actual));
}
else
{
Assert.AreEqual(expected, actual);
}
}
featureCount++;
if (featureCount > 250)
{
return;
}
}
}
public void CanRemoveOverlaps()
{
var fClass =
new GdbFeatureClass(123, "TestFC", esriGeometryType.esriGeometryPolygon);
var sr = SpatialReferenceUtils.CreateSpatialReference(
WellKnownHorizontalCS.LV95,
WellKnownVerticalCS.LN02);
IPolygon polygon1 = GeometryFactory.CreatePolygon(
GeometryFactory.CreatePoint(2600000, 1200000, sr),
GeometryFactory.CreatePoint(2601000, 1201000, sr));
polygon1.SpatialReference = sr;
GdbFeature sourceFeature = new GdbFeature(42, fClass)
{
Shape = polygon1
};
IPolygon polygon2 = GeometryFactory.CreatePolygon(
GeometryFactory.CreatePoint(2600500, 1200500, sr),
GeometryFactory.CreatePoint(2601500, 1201500, sr));
polygon2.SpatialReference = sr;
GdbFeature targetFeature = new GdbFeature(43, fClass)
{
Shape = polygon2
};
IPolygon overlap = GeometryFactory.CreatePolygon(
GeometryFactory.CreatePoint(2600500, 1200500, sr),
GeometryFactory.CreatePoint(2601000, 1201000, sr));
overlap.SpatialReference = sr;
var sourceFeatureMsg = ProtobufGdbUtils.ToGdbObjectMsg(sourceFeature);
var targetFeatureMsg = ProtobufGdbUtils.ToGdbObjectMsg(targetFeature);
var objectClassMsg = ProtobufGdbUtils.ToObjectClassMsg(sourceFeature.Class);
var removeRequest = new RemoveOverlapsRequest()
{
ClassDefinitions =
{
objectClassMsg
},
SourceFeatures =
{
sourceFeatureMsg
},
UpdatableTargetFeatures =
{
targetFeatureMsg
}
};
var overlapsMsg = new OverlapMsg();
overlapsMsg.OriginalFeatureRef = new GdbObjRefMsg()
{
ClassHandle = sourceFeatureMsg.ClassHandle,
ObjectId = sourceFeatureMsg.ObjectId
};
overlapsMsg.Overlaps.Add(ProtobufGeometryUtils.ToShapeMsg(overlap));
removeRequest.Overlaps.Add(overlapsMsg);
RemoveOverlapsResponse removeResponse =
RemoveOverlapsServiceUtils.RemoveOverlaps(removeRequest);
Assert.AreEqual(1, removeResponse.ResultsByFeature.Count);
ResultGeometriesByFeature resultByFeature = removeResponse.ResultsByFeature[0];
GdbObjectReference originalObjRef = new GdbObjectReference(
resultByFeature.OriginalFeatureRef.ClassHandle,
resultByFeature.OriginalFeatureRef.ObjectId);
Assert.AreEqual(new GdbObjectReference(sourceFeature), originalObjRef);
IGeometry updatedGeometry =
ProtobufGeometryUtils.FromShapeMsg(resultByFeature.UpdatedGeometry);
Assert.IsNotNull(updatedGeometry);
Assert.AreEqual(1000 * 1000 * 3 / 4, ((IArea)updatedGeometry).Area);
Assert.AreEqual(0, resultByFeature.NewGeometries.Count);
IFeature updatedTarget =
ProtobufConversionUtils.FromGdbObjectMsgList(removeResponse.TargetFeaturesToUpdate,
removeRequest.ClassDefinitions)
.Single();
int pointCount = GeometryUtils.GetPointCount(updatedTarget.Shape);
Assert.AreEqual(5 + 2, pointCount);
}
private static GeometryReshaperBase CreateReshaper(
AdvancedReshapeRequest request, IList <IPath> reshapePaths)
{
GeometryReshaperBase result;
bool allowOpenJaw = request.AllowOpenJawReshape;
bool moveOpenJawEndJunction = request.MoveOpenJawEndJunction;
IList <IFeature> featuresToReshape =
GetFeaturesToReshape(request, out GdbTableContainer container);
if (featuresToReshape.Count == 1)
{
IFeature firstFeature = featuresToReshape[0];
var singleGeometryReshaper =
new GeometryReshaper(firstFeature)
{
AllowOpenJawReshape = allowOpenJaw
};
result = singleGeometryReshaper;
}
else
{
var stickyIntersections = new StickyIntersections(featuresToReshape);
foreach (SourceTargetPointPair pair in request.StickyIntersections)
{
stickyIntersections.SourceTargetPairs.Add(
new KeyValuePair <IPoint, IPoint>(
(IPoint)ProtobufGeometryUtils.FromShapeMsg(
pair.SourcePoint),
(IPoint)ProtobufGeometryUtils.FromShapeMsg(
pair.TargetPoint)));
}
result = new MultipleGeometriesReshaper(featuresToReshape)
{
MultipleSourcesTreatIndividually = true,
MultipleSourcesTreatAsUnion =
request.MultipleSourcesTryUnion,
MaxProlongationLengthFactor = 4,
StickyIntersectionPoints = stickyIntersections
};
// Conditions for closed reshape paths being removed:
// - multiple source geometries, at least two of which polygons
// - multiple reshape paths (or a single closed path)
// ... consider checking that the ring-path is completely inside the outermost ring of the source polygon's union
// or at least that several polygons are intersected by the sketch geometry
if ((reshapePaths.Count > 1) || reshapePaths.All(path => path.IsClosed))
{
if (ContainsMultiplePolygonFeatures(featuresToReshape))
{
result.RemoveClosedReshapePathAreas = true;
}
}
}
if (moveOpenJawEndJunction)
{
IList <IFeature> targetCandidates = ProtobufConversionUtils.FromGdbObjectMsgList(
request.PotentiallyConnectedFeatures, container);
result.NetworkFeatureFinder =
new LinearNetworkGdbFeatureFinder(targetCandidates);
result.NetworkFeatureUpdater =
new LinearNetworkNodeUpdater(result.NetworkFeatureFinder);
}
result.MoveLineEndJunction = moveOpenJawEndJunction;
// TODO: Add to admin-options (i.e. central defaults only, no GUI) together with the threshold
// _useSimplifiedReshapeSideDeterminationVertexThreshold in ReshapeInfo
result.AllowSimplifiedReshapeSideDetermination = true;
return(result);
}
public static RemoveOverlapsResponse RemoveOverlaps(
[NotNull] RemoveOverlapsRequest request,
[CanBeNull] ITrackCancel trackCancel = null)
{
// Unpack request
bool explodeMultiparts = request.ExplodeMultipartResults;
bool storeOverlapsAsNewFeatures = request.StoreOverlapsAsNewFeatures;
GdbTableContainer container = ProtobufConversionUtils.CreateGdbTableContainer(
request.ClassDefinitions, null, out _);
IList <IFeature> selectedFeatureList =
ProtobufConversionUtils.FromGdbObjectMsgList(
request.SourceFeatures, container);
IList <IFeature> targetFeaturesForVertexInsertion =
ProtobufConversionUtils.FromGdbObjectMsgList(
request.UpdatableTargetFeatures, container);
Overlaps overlaps = new Overlaps();
foreach (OverlapMsg overlapMsg in request.Overlaps)
{
GdbObjectReference gdbRef = new GdbObjectReference(
overlapMsg.OriginalFeatureRef.ClassHandle,
overlapMsg.OriginalFeatureRef.ObjectId);
IFeatureClass fClass = (IFeatureClass)container.GetByClassId(gdbRef.ClassId);
List <IGeometry> overlapGeometries =
ProtobufGeometryUtils.FromShapeMsgList <IGeometry>(
overlapMsg.Overlaps,
DatasetUtils.GetSpatialReference(fClass));
overlaps.AddGeometries(gdbRef, overlapGeometries);
}
// Remove overlaps
OverlapsRemover overlapsRemover = RemoveOverlaps(
selectedFeatureList, overlaps, targetFeaturesForVertexInsertion, explodeMultiparts,
storeOverlapsAsNewFeatures, trackCancel);
// Pack response
var result = overlapsRemover.Result;
var response = new RemoveOverlapsResponse();
PackResultGeometries(result.ResultsByFeature,
response.ResultsByFeature);
response.NonStorableMessages.AddRange(result.NonStorableMessages);
if (result.TargetFeaturesToUpdate != null)
{
foreach (var keyValuePair in result.TargetFeaturesToUpdate)
{
IFeature feature = keyValuePair.Key;
IGeometry newGeometry = keyValuePair.Value;
GdbObjectMsg targetFeatureMsg =
ProtobufGdbUtils.ToGdbObjectMsg(
feature, newGeometry, feature.Class.ObjectClassID);
response.TargetFeaturesToUpdate.Add(targetFeatureMsg);
}
}
response.ResultHasMultiparts = result.ResultHasMultiparts;
return(response);
}
public static CalculateOverlapsResponse CalculateOverlaps(
[NotNull] CalculateOverlapsRequest request,
[CanBeNull] ITrackCancel trackCancel)
{
var watch = Stopwatch.StartNew();
IList <IFeature> sourceFeatures =
ProtobufConversionUtils.FromGdbObjectMsgList(
request.SourceFeatures, request.ClassDefinitions);
IList <IFeature> targetFeatures =
ProtobufConversionUtils.FromGdbObjectMsgList(
request.TargetFeatures, request.ClassDefinitions);
_msg.DebugStopTiming(watch, "Unpacked feature lists from request params");
Overlaps selectableOverlaps = RemoveOverlapsUtils.GetSelectableOverlaps(
sourceFeatures, targetFeatures, trackCancel);
watch = Stopwatch.StartNew();
var result = new CalculateOverlapsResponse();
foreach (var overlapByGdbRef
in selectableOverlaps.OverlapsBySourceRef)
{
var gdbObjRefMsg = ProtobufGdbUtils.ToGdbObjRefMsg(overlapByGdbRef.Key);
var overlap = overlapByGdbRef.Value;
var overlapsMsg = new OverlapMsg()
{
OriginalFeatureRef = gdbObjRefMsg
};
foreach (IGeometry geometry in overlap)
{
// TODO: At some point the SR-XY tol/res should be transferred separately (via class-lookup?)
var shapeFormat = ShapeMsg.FormatOneofCase.EsriShape;
var srFormat = SpatialReferenceMsg.FormatOneofCase.SpatialReferenceEsriXml;
overlapsMsg.Overlaps.Add(
ProtobufGeometryUtils.ToShapeMsg(
geometry, shapeFormat, srFormat));
if (_msg.IsVerboseDebugEnabled)
{
_msg.VerboseDebug(
$"Calculated overlap: {GeometryUtils.ToString(geometry)}");
}
}
result.Overlaps.Add(overlapsMsg);
}
foreach (var notification in selectableOverlaps.Notifications)
{
result.Notifications.Add(notification.Message);
}
_msg.DebugStopTiming(watch, "Packed overlaps into response");
return(result);
}
