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 ShapeMsg ToShapeMsg([CanBeNull] Geometry geometry,
bool useSpatialRefWkId = false)
{
if (geometry == null)
{
return(null);
}
SpatialReference spatialRef = geometry.SpatialReference;
Assert.ArgumentCondition(spatialRef != null,
"Spatial reference must not be null");
var result = new ShapeMsg
{
EsriShape = ByteString.CopyFrom(geometry.ToEsriShape())
};
result.SpatialReference = ToSpatialReferenceMsg(
spatialRef,
useSpatialRefWkId
? SpatialReferenceMsg.FormatOneofCase.SpatialReferenceWkid
: SpatialReferenceMsg.FormatOneofCase.SpatialReferenceEsriXml);
return(result);
}
public static ShapeMsg GetOpenJawReshapeReplaceEndPoint(
[NotNull] OpenJawReshapeLineReplacementRequest request,
[CanBeNull] ITrackCancel trackCancel = null)
{
var polylineToReshape =
(IPolyline)ProtobufGeometryUtils.FromShapeMsg(request.Feature.Shape);
var reshapeLine =
(IPolyline)ProtobufGeometryUtils.FromShapeMsg(request.ReshapePath);
IPoint endPoint = null;
if (polylineToReshape != null && reshapeLine != null)
{
endPoint = ReshapeUtils.GetOpenJawReshapeLineReplaceEndPoint(
polylineToReshape, reshapeLine, request.UseNonDefaultReshapeSide);
}
if (endPoint == null)
{
return(new ShapeMsg());
}
ShapeMsg result = ProtobufGeometryUtils.ToShapeMsg(endPoint);
return(result);
}
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)));
}
private DataRequest CreateDataRequest(IQueryFilter filter)
{
ShapeMsg searchGeoMsg =
filter is ISpatialFilter spatialFilter && spatialFilter.Geometry != null
? ProtobufGeometryUtils.ToShapeMsg(spatialFilter.Geometry)
: null;
var dataRequest = new DataRequest
{
WhereClause = filter.WhereClause,
SearchGeometry = searchGeoMsg,
SubFields = filter.SubFields
};
if (_queryDefinition != null)
{
dataRequest.RelQueryDef = _queryDefinition;
}
else
{
dataRequest.ClassDef = Assert.NotNull(_classDefinition);
}
return(dataRequest);
}
public void CanConvertPolygonToFromShapeMsg()
{
string xmlFile = TestData.GetDensifiedWorkUnitPerimeterPath();
var polygon = (IPolygon)GeometryUtils.FromXmlFile(xmlFile);
var shapeMsg = ProtobufGeometryUtils.ToShapeMsg(
polygon, ShapeMsg.FormatOneofCase.EsriShape,
SpatialReferenceMsg.FormatOneofCase.SpatialReferenceEsriXml);
IGeometry rehydrated = ProtobufGeometryUtils.FromShapeMsg(shapeMsg);
Assert.NotNull(rehydrated);
Assert.IsTrue(GeometryUtils.AreEqual(polygon, rehydrated));
Assert.IsTrue(SpatialReferenceUtils.AreEqual(polygon.SpatialReference,
rehydrated.SpatialReference, true, true));
// ... and WKB
var wkbWriter = new WkbGeometryWriter();
byte[] wkb = wkbWriter.WriteGeometry(polygon);
var wkbShapeMsg = new ShapeMsg()
{
Wkb = ByteString.CopyFrom(wkb)
};
IGeometry rehydratedFromWkb = ProtobufGeometryUtils.FromShapeMsg(wkbShapeMsg);
Assert.IsTrue(GeometryUtils.AreEqual(polygon, rehydratedFromWkb));
Assert.IsTrue(
SpatialReferenceUtils.AreEqual(polygon.SpatialReference,
rehydrated.SpatialReference));
// ... and envelope
IEnvelope envelope = polygon.Envelope;
var envShapeMsg = new ShapeMsg()
{
Envelope = new EnvelopeMsg()
{
XMin = envelope.XMin,
YMin = envelope.YMin,
XMax = envelope.XMax,
YMax = envelope.YMax
},
SpatialReference = new SpatialReferenceMsg()
{
SpatialReferenceWkid =
(int)WellKnownHorizontalCS.LV95
}
};
IEnvelope rehydratedEnvelope =
(IEnvelope)ProtobufGeometryUtils.FromShapeMsg(envShapeMsg);
Assert.IsTrue(GeometryUtils.AreEqual(envelope, rehydratedEnvelope));
}
public void CanGetOpenJawReshapeLineReplaceEndPoint()
{
var fClass =
new GdbFeatureClass(123, "TestFC", esriGeometryType.esriGeometryPolyline);
var sr = SpatialReferenceUtils.CreateSpatialReference(
WellKnownHorizontalCS.LV95,
WellKnownVerticalCS.LN02);
fClass.SpatialReference = sr;
IPath sourcePath = GeometryFactory.CreatePath(
GeometryFactory.CreatePoint(2600500, 1200000, sr),
GeometryFactory.CreatePoint(2600500, 1200500, sr),
GeometryFactory.CreatePoint(2601000, 1200500, sr));
sourcePath.SpatialReference = sr;
IPolyline sourcePolyline = GeometryFactory.CreatePolyline(sourcePath);
GdbFeature sourceFeature = new GdbFeature(42, fClass)
{
Shape = sourcePolyline
};
IPath reshapePath = GeometryFactory.CreatePath(
GeometryFactory.CreatePoint(2600500, 1200500, sr),
GeometryFactory.CreatePoint(2600500, 1201000, sr));
reshapePath.SpatialReference = sr;
IPolyline reshapePolyline = GeometryFactory.CreatePolyline(reshapePath);
var sourceFeatureMsg = ProtobufGdbUtils.ToGdbObjectMsg(sourceFeature);
var reshapePathMsg = ProtobufGeometryUtils.ToShapeMsg(reshapePolyline);
var request = new OpenJawReshapeLineReplacementRequest
{
Feature = sourceFeatureMsg,
ReshapePath = reshapePathMsg
};
ShapeMsg response =
AdvancedReshapeServiceUtils.GetOpenJawReshapeReplaceEndPoint(request);
IPoint resultPoint = (IPoint)ProtobufGeometryUtils.FromShapeMsg(response);
Assert.IsTrue(GeometryUtils.AreEqual(sourcePolyline.ToPoint, resultPoint));
// Non-default side:
request.UseNonDefaultReshapeSide = true;
response =
AdvancedReshapeServiceUtils.GetOpenJawReshapeReplaceEndPoint(request);
resultPoint = (IPoint)ProtobufGeometryUtils.FromShapeMsg(response);
Assert.IsTrue(GeometryUtils.AreEqual(sourcePolyline.FromPoint, resultPoint));
}
public static ShapeMsg ToShapeMsg(
[CanBeNull] IGeometry geometry,
ShapeMsg.FormatOneofCase format = ShapeMsg.FormatOneofCase.EsriShape,
SpatialReferenceMsg.FormatOneofCase spatialRefFormat =
SpatialReferenceMsg.FormatOneofCase.SpatialReferenceWkid)
{
if (geometry == null)
{
return(null);
}
Assert.ArgumentCondition(format == ShapeMsg.FormatOneofCase.EsriShape ||
format == ShapeMsg.FormatOneofCase.Wkb,
"Unsupported format");
if (_msg.IsVerboseDebugEnabled)
{
_msg.DebugFormat("Converting geometry {0} to shape msg",
GeometryUtils.ToString(geometry));
}
var highLevelGeometry =
GeometryUtils.GetHighLevelGeometry(geometry, true);
var result = new ShapeMsg();
if (format == ShapeMsg.FormatOneofCase.EsriShape)
{
result.EsriShape = ByteString.CopyFrom(
GeometryUtils.ToEsriShapeBuffer(highLevelGeometry));
}
else
{
var wkbWriter = new WkbGeometryWriter();
byte[] wkb = wkbWriter.WriteGeometry(highLevelGeometry);
result.Wkb = ByteString.CopyFrom(wkb);
}
if (geometry.SpatialReference != null)
{
result.SpatialReference =
ToSpatialReferenceMsg(geometry.SpatialReference, spatialRefFormat);
}
if (highLevelGeometry != geometry)
{
_msg.DebugFormat(
"Geometry was converted to high-level geometry to encode.");
Marshal.ReleaseComObject(highLevelGeometry);
}
return(result);
}
private static IList <IPoint> PointsFromShapeMsg([CanBeNull] ShapeMsg shapeMsg)
{
var geometry = ProtobufGeometryUtils.FromShapeMsg(shapeMsg);
if (geometry == null)
{
return(null);
}
return(GeometryUtils.GetPoints(geometry).ToList());
}
public static IGeometry FromShapeMsg([CanBeNull] ShapeMsg shapeBuffer,
[CanBeNull] ISpatialReference classSpatialRef = null)
{
if (shapeBuffer == null)
{
return(null);
}
if (shapeBuffer.FormatCase == ShapeMsg.FormatOneofCase.None)
{
return(null);
}
IGeometry result;
switch (shapeBuffer.FormatCase)
{
case ShapeMsg.FormatOneofCase.EsriShape:
if (shapeBuffer.EsriShape.IsEmpty)
{
return(null);
}
result = GeometryUtils.FromEsriShapeBuffer(shapeBuffer.EsriShape.ToByteArray());
break;
case ShapeMsg.FormatOneofCase.Wkb:
WkbGeometryReader wkbReader = new WkbGeometryReader();
result = wkbReader.ReadGeometry(
new MemoryStream(shapeBuffer.Wkb.ToByteArray()));
break;
case ShapeMsg.FormatOneofCase.Envelope:
result = FromEnvelopeMsg(shapeBuffer.Envelope);
break;
default:
throw new NotImplementedException(
$"Unsupported format: {shapeBuffer.FormatCase}");
}
result.SpatialReference =
FromSpatialReferenceMsg(shapeBuffer.SpatialReference, classSpatialRef);
return(result);
}
private static IPath GetPath([CanBeNull] ShapeMsg polylineMsg)
{
IPolyline polyline = (IPolyline)ProtobufGeometryUtils.FromShapeMsg(polylineMsg);
if (polyline == null || polyline.IsEmpty)
{
return(null);
}
IPath result = (IPath)((IGeometryCollection)polyline).Geometry[0];
return(result);
}
public void CanConvertPolygonToFromShapeMsgFastEnough()
{
string xmlFile = TestData.GetHugeLockergesteinPolygonPath();
var polygon = (IPolygon)GeometryUtils.FromXmlFile(xmlFile);
var watch = Stopwatch.StartNew();
var runCount = 100;
ShapeMsg shapeMsg = null;
for (int i = 0; i < runCount; i++)
{
shapeMsg = ProtobufGeometryUtils.ToShapeMsg(polygon);
}
long dehydrationAvg = watch.ElapsedMilliseconds / runCount;
Console.WriteLine("Dehydration: {0}ms", dehydrationAvg);
watch.Restart();
IPoint point = new PointClass();
IGeometry rehydrated = null;
for (int i = 0; i < runCount; i++)
{
rehydrated = ProtobufGeometryUtils.FromShapeMsg(shapeMsg);
// This is almost free:
((IPointCollection)rehydrated).QueryPoint(23, point);
// This results in an extra 45ms on average:
//point = ((IPointCollection) rehydrated).Point[23];
}
long rehydrationAvg = watch.ElapsedMilliseconds / runCount;
Assert.IsTrue(GeometryUtils.AreEqual(polygon, rehydrated));
Console.WriteLine("Rehydration: {0}ms", rehydrationAvg);
Assert.Less(dehydrationAvg, 60);
Assert.Less(rehydrationAvg, 30);
// Typical output on a reasonable laptop:
//Dehydration: 45ms
//Rehydration: 20ms
}
public override async Task <ShapeMsg> GetOpenJawReshapeLineReplaceEndPoint(
OpenJawReshapeLineReplacementRequest request,
ServerCallContext context)
{
Func <ITrackCancel, ShapeMsg> func =
trackCancel => AdvancedReshapeServiceUtils.GetOpenJawReshapeReplaceEndPoint(
request, trackCancel);
ShapeMsg response =
await GrpcServerUtils.ExecuteServiceCall(func, context, _staTaskScheduler, true) ??
new ShapeMsg();
return(response);
}
public static Geometry FromShapeMsg(
[CanBeNull] ShapeMsg shapeMsg,
[CanBeNull] SpatialReference knownSpatialReference = null)
{
if (shapeMsg == null)
{
return(null);
}
if (shapeMsg.FormatCase == ShapeMsg.FormatOneofCase.None)
{
return(null);
}
SpatialReference sr = knownSpatialReference ??
FromSpatialReferenceMsg(shapeMsg.SpatialReference);
Geometry result;
switch (shapeMsg.FormatCase)
{
case ShapeMsg.FormatOneofCase.EsriShape:
if (shapeMsg.EsriShape.IsEmpty)
{
return(null);
}
result = FromEsriShapeBuffer(shapeMsg.EsriShape.ToByteArray(), sr);
break;
case ShapeMsg.FormatOneofCase.Wkb:
throw new NotSupportedException(
"WKB format is currently not supported in AGP client.");
case ShapeMsg.FormatOneofCase.Envelope:
result = FromEnvelopeMsg(shapeMsg.Envelope, sr);
break;
default:
throw new NotImplementedException(
$"Unsupported format: {shapeMsg.FormatCase}");
}
return(result);
}
private static ISegment GetSegment([CanBeNull] ShapeMsg segmentMsg)
{
IPolyline polyline =
(IPolyline)ProtobufGeometryUtils.FromShapeMsg(segmentMsg);
if (polyline == null || polyline.IsEmpty)
{
return(null);
}
ISegment result = ((ISegmentCollection)polyline).Segment[0];
return(result);
}
