private static void PackReshapeResponseFeatures(
AdvancedReshapeResponse result,
[NotNull] IEnumerable <IFeature> storedFeatures,
[NotNull] IDictionary <IGeometry, NotificationCollection> reshapedGeometries,
bool openJawReshapeOccurred,
bool notificationIsWarning)
{
foreach (IFeature storedFeature in storedFeatures)
{
IFeature feature = storedFeature;
IGeometry newGeometry = storedFeature.Shape;
var resultFeature = new ResultObjectMsg();
GdbObjectMsg resultFeatureMsg =
ProtobufGdbUtils.ToGdbObjectMsg(feature, newGeometry,
storedFeature.Class.ObjectClassID);
resultFeature.Update = resultFeatureMsg;
if (reshapedGeometries.ContainsKey(newGeometry) &&
(reshapedGeometries[newGeometry] != null))
{
foreach (INotification notification in reshapedGeometries[newGeometry])
{
resultFeature.Notifications.Add(notification.Message);
resultFeature.HasWarning = notificationIsWarning;
}
}
result.ResultFeatures.Add(resultFeature);
}
}
private static GdbObjectReference GetOriginalGdbObjectReference(
[NotNull] ResultObjectMsg resultObjectMsg)
{
Assert.ArgumentNotNull(nameof(resultObjectMsg));
// TODO: long int!
int classHandle, objectId;
if (resultObjectMsg.FeatureCase == ResultObjectMsg.FeatureOneofCase.Insert)
{
InsertedObjectMsg insert = Assert.NotNull(resultObjectMsg.Insert);
GdbObjRefMsg originalObjRefMsg = insert.OriginalReference;
classHandle = originalObjRefMsg.ClassHandle;
objectId = originalObjRefMsg.ObjectId;
}
else
{
GdbObjectMsg updateMsg = Assert.NotNull(resultObjectMsg.Update);
classHandle = updateMsg.ClassHandle;
objectId = updateMsg.ObjectId;
}
return(new GdbObjectReference(classHandle, objectId));
}
public ResultFeature(Feature feature,
ResultObjectMsg resultFeatureMsg)
{
_resultFeatureMsg = resultFeatureMsg;
Feature = feature;
ChangeType = ToChangeType(_resultFeatureMsg.FeatureCase);
HasWarningMessage = _resultFeatureMsg.HasWarning;
}
private static int GetObjectId(ResultObjectMsg resultObjectMsg)
{
switch (resultObjectMsg.FeatureCase)
{
case ResultObjectMsg.FeatureOneofCase.Update:
return(resultObjectMsg.Update.ObjectId);
case ResultObjectMsg.FeatureOneofCase.Insert:
return(resultObjectMsg.Insert.InsertedObject.ObjectId);
case ResultObjectMsg.FeatureOneofCase.Delete:
return(resultObjectMsg.Delete.ObjectId);
default:
return(-1);
}
}
private static void AddNotification(IFeature feature, ResultObjectMsg featureMsg,
Func <IFeature, IEnumerable <string> >
notificationsForFeature,
Func <IFeature, bool> warningForFeature)
{
if (notificationsForFeature != null)
{
foreach (string notification in notificationsForFeature(feature))
{
featureMsg.Notifications.Add(notification);
}
}
if (warningForFeature != null)
{
featureMsg.HasWarning = warningForFeature(feature);
}
}
private static IGeometry GetShape(ResultObjectMsg resultObjectMsg)
{
ShapeMsg shapeMsg;
switch (resultObjectMsg.FeatureCase)
{
case ResultObjectMsg.FeatureOneofCase.Update:
shapeMsg = resultObjectMsg.Update.Shape;
break;
case ResultObjectMsg.FeatureOneofCase.Insert:
shapeMsg = resultObjectMsg.Insert.InsertedObject.Shape;
break;
default:
return(null);
}
return(shapeMsg == null ? null : ProtobufGeometryUtils.FromShapeMsg(shapeMsg));
}
public void CanCutAlong()
{
GetOverlappingPolygons(out GdbFeature sourceFeature, out GdbFeature targetFeature);
CalculateCutLinesRequest calculationRequest =
CreateCalculateCutLinesRequest(sourceFeature, targetFeature);
CalculateCutLinesResponse calculateResponse =
ChangeAlongServiceUtils.CalculateCutLines(calculationRequest, null);
Assert.AreEqual(ReshapeAlongCurveUsability.CanReshape,
(ReshapeAlongCurveUsability)calculateResponse.ReshapeLinesUsability);
AssertReshapeLineCount(calculateResponse.CutLines, 1, 1);
IPolyline reshapeLine =
(IPolyline)ProtobufGeometryUtils.FromShapeMsg(calculateResponse.CutLines[0].Path);
Assert.NotNull(reshapeLine);
Assert.AreEqual(1000, (reshapeLine).Length);
//
// Cutting
//
var applyRequest = new ApplyCutLinesRequest();
applyRequest.CutLines.Add(calculateResponse.CutLines[0]);
applyRequest.CalculationRequest = calculationRequest;
applyRequest.InsertVerticesInTarget = false;
ApplyCutLinesResponse applyResponse =
ChangeAlongServiceUtils.ApplyCutLines(applyRequest, null);
Assert.AreEqual(2, applyResponse.ResultFeatures.Count);
List <IGeometry> geometries = applyResponse.ResultFeatures.Select(GetShape).ToList();
Assert.AreEqual(1000 * 1000, geometries.Sum(g => ((IArea)g).Area));
ResultObjectMsg updateResultMsg =
applyResponse.ResultFeatures.First(
r => r.FeatureCase == ResultObjectMsg.FeatureOneofCase.Update);
GdbObjectReference updateObjRef =
new GdbObjectReference(updateResultMsg.Update.ClassHandle,
updateResultMsg.Update.ObjectId);
Assert.AreEqual(new GdbObjectReference(sourceFeature), updateObjRef);
IGeometry firstGeometry =
ProtobufGeometryUtils.FromShapeMsg(updateResultMsg.Update.Shape);
Assert.IsNotNull(firstGeometry);
Assert.AreEqual(1000 * 1000 * 3 / 4, ((IArea)firstGeometry).Area);
// Check the new reshape line:
AssertReshapeLineCount(applyResponse.NewCutLines, 0, 0);
Assert.AreEqual(ReshapeAlongCurveUsability.NoReshapeCurves,
(ReshapeAlongCurveUsability)applyResponse.CutLinesUsability);
}
public void CanReshapeAlongInsertTargetVertices()
{
GetOverlappingPolygons(out GdbFeature sourceFeature, out GdbFeature targetFeature);
CalculateReshapeLinesRequest calculationRequest =
CreateCalculateReshapeLinesRequest(sourceFeature, targetFeature);
CalculateReshapeLinesResponse calculateResponse =
ChangeAlongServiceUtils.CalculateReshapeLines(calculationRequest, null);
Assert.AreEqual((int)ReshapeAlongCurveUsability.CanReshape,
calculateResponse.ReshapeLinesUsability);
AssertReshapeLineCount(calculateResponse.ReshapeLines, 2, 2);
int insideLineIndex =
GetInsideReshapeLineIndex(calculateResponse.ReshapeLines, sourceFeature.Shape);
IPolyline insideLine =
(IPolyline)ProtobufGeometryUtils.FromShapeMsg(
calculateResponse.ReshapeLines[insideLineIndex].Path);
Assert.NotNull(insideLine);
Assert.AreEqual(1000.0, insideLine.Length);
//
// Reshape the default side:
//
ApplyReshapeLinesRequest applyRequest = new ApplyReshapeLinesRequest();
applyRequest.ReshapeLines.Add(calculateResponse.ReshapeLines[insideLineIndex]);
applyRequest.CalculationRequest = calculationRequest;
applyRequest.InsertVerticesInTarget = true;
applyRequest.UseNonDefaultReshapeSide = false;
ApplyReshapeLinesResponse applyResponse =
ChangeAlongServiceUtils.ApplyReshapeLines(applyRequest, null);
Assert.AreEqual(2, applyResponse.ResultFeatures.Count);
ResultObjectMsg sourceResultMsg =
applyResponse.ResultFeatures.First(
f => f.Update.ObjectId == sourceFeature.OID);
IGeometry updatedSourceGeometry =
ProtobufGeometryUtils.FromShapeMsg(sourceResultMsg.Update.Shape);
Assert.IsNotNull(updatedSourceGeometry);
Assert.AreEqual(1000 * 1000 * 3 / 4, ((IArea)updatedSourceGeometry).Area);
ResultObjectMsg targetResultMsg =
applyResponse.ResultFeatures.First(
f => f.Update.ObjectId == targetFeature.OID);
IGeometry updatedTargetGeometry =
ProtobufGeometryUtils.FromShapeMsg(targetResultMsg.Update.Shape);
Assert.AreEqual(GeometryUtils.GetPointCount(targetFeature.Shape) + 2,
GeometryUtils.GetPointCount(updatedTargetGeometry));
// Check the new reshape line:
AssertReshapeLineCount(applyResponse.NewReshapeLines, 1, 1);
Assert.AreEqual((int)ReshapeAlongCurveUsability.CanReshape,
applyResponse.ReshapeLinesUsability);
}
private static IList <ResultObjectMsg> GetResultFeatureMessages(
[CanBeNull] ICollection <KeyValuePair <IFeature, IList <IFeature> > > insertsByOriginal,
[CanBeNull] IEnumerable <IFeature> allResultFeatures,
[CanBeNull] Func <IFeature, IEnumerable <string> > notificationsForFeature = null,
[CanBeNull] Func <IFeature, bool> warningForFeature = null)
{
IList <ResultObjectMsg> ResultObjectMsgs = new List <ResultObjectMsg>();
HashSet <IFeature> allInserts = new HashSet <IFeature>();
if (insertsByOriginal != null)
{
foreach (KeyValuePair <IFeature, IList <IFeature> > kvp in insertsByOriginal)
{
IList <IFeature> inserts = kvp.Value;
IFeature original = kvp.Key;
var originalRef = new GdbObjRefMsg
{
ClassHandle = original.Class.ObjectClassID,
ObjectId = original.OID
};
foreach (IFeature insert in inserts)
{
allInserts.Add(insert);
var insertMsg =
new InsertedObjectMsg
{
InsertedObject = ProtobufGdbUtils.ToGdbObjectMsg(insert),
OriginalReference = originalRef
};
var featureMsg = new ResultObjectMsg
{
Insert = insertMsg
};
AddNotification(insert, featureMsg, notificationsForFeature,
warningForFeature);
ResultObjectMsgs.Add(featureMsg);
}
}
}
if (allResultFeatures != null)
{
foreach (IFeature resultFeature in allResultFeatures)
{
if (allInserts.Contains(resultFeature))
{
continue;
}
ResultObjectMsg updateMsg =
new ResultObjectMsg
{
Update = ProtobufGdbUtils.ToGdbObjectMsg(resultFeature)
};
AddNotification(resultFeature, updateMsg, notificationsForFeature,
warningForFeature);
ResultObjectMsgs.Add(updateMsg);
}
}
return(ResultObjectMsgs);
}
