public static Graphic NewDonut(double x, double y, double innerRadius, double outerRadius)
{
double[] px = new double[NUM];
double[] py = new double[NUM];
GeometryAlgorithms.CircleToPoints(x, y, outerRadius, NUM, px, py, AngleDirection.CounterClockwise);
Esri.ArcGISRuntime.Geometry.PointCollection pc = new Esri.ArcGISRuntime.Geometry.PointCollection();
for (int i = 0; i < NUM; i++)
{
MapPoint p = new MapPoint(px[i], py[i]);
pc.Add(p);
}
pc.Add(pc[0]);
PolygonBuilder polygon = new PolygonBuilder(pc);
GeometryAlgorithms.CircleToPoints(x, y, innerRadius, NUM, px, py, AngleDirection.Clockwise);
pc = new Esri.ArcGISRuntime.Geometry.PointCollection();
for (int i = 0; i < NUM; i++)
{
MapPoint p = new MapPoint(px[i], py[i]);
pc.Add(p);
}
pc.Add(pc[0]);
polygon.AddPart(pc);
Graphic g = new Graphic();
g.Geometry = polygon.ToGeometry();
return(g);
}
// Project a point to polyline.
// point: (p), polyline: (part)
// output distance relative to the start point of the polyline: (distance)
// output projection point: (outPnt)
// return value:
// true: the point is projected on the polyline without extending the polyline
// false: the point is projected on the polyline through extending the polyline
//
public static bool ProjectPointToPolyline(MapPoint p,
IEnumerable <MapPoint> part,
ref double distance, ref MapPoint outPnt)
{
Esri.ArcGISRuntime.Geometry.PointCollection pts =
new Esri.ArcGISRuntime.Geometry.PointCollection(part);
distance = 0.0;
SpatialReference sf = pts[0].SpatialReference;
double outx = 0.0, outy = 0.0;
MapPoint p0, p1;
for (int i = 0; i < pts.Count - 1; ++i)
{
p0 = pts[i];
p1 = pts[i + 1];
bool canProject = GeometryAlgorithms.ProjectPointToLine(p.X, p.Y,
p0.X, p0.Y, p1.X, p1.Y, ref outx, ref outy);
if (canProject == true)
{
distance += GeometryAlgorithms.PointDistanceToPoint(outx, outy, p0.X, p0.Y);
outPnt = new MapPoint(outx, outy, sf);
return(true);
}
distance += GeometryAlgorithms.PointDistanceToPoint(p0.X, p0.Y, p1.X, p1.Y);
}
// Project the point by extending the polyline
p0 = pts[0];
p1 = pts[pts.Count - 1];
double d0p = GeometryAlgorithms.PointDistanceToPoint(p.X, p.Y, p0.X, p0.Y);
double d1p = GeometryAlgorithms.PointDistanceToPoint(p.X, p.Y, p1.X, p1.Y);
if (d0p < d1p)
{
// the map point is closer to the beginning of the polyline,
// then extend the beginning segment.
p1 = pts[1];
GeometryAlgorithms.ProjectPointToLine(p.X, p.Y,
p0.X, p0.Y, p1.X, p1.Y, ref outx, ref outy);
distance = GeometryAlgorithms.PointDistanceToPoint(outx, outy, p0.X, p0.Y);
distance *= -1.0;
outPnt = new MapPoint(outx, outy, sf);
}
else
{
// the map point is closer to the endding of the polyline,
// since the loop is ended on the last segment, just use the result is OK.
distance += GeometryAlgorithms.PointDistanceToPoint(outx, outy, p1.X, p1.Y);
outPnt = new MapPoint(outx, outy, sf);
}
return(false);
}
public static MapPoint InterpolatePointOnLine(MapPoint p1, MapPoint p2, double scale)
{
MapPointBuilder p = new MapPointBuilder(p1.SpatialReference);
double x = 0.0, y = 0.0;
GeometryAlgorithms.InterpolatePointOnLine(p1.X, p1.Y, p2.X, p2.Y, scale, ref x, ref y);
p.X = x;
p.Y = y;
return(p.ToGeometry());
}
private void SimplifyPointData(System.Drawing.Point[] points, double[] measures, int pointCount, int simplificationFactor, System.Drawing.Point[] reducedPoints, double[] reducedMeasures, ref PointD[] pointsBuffer, ref int reducedPointCount)
{
System.Drawing.Point endPoint = points[pointCount - 1];
bool addEndpoint = endPoint == points[0];
//check for duplicates points at end after they have been converted to pixel coordinates
//polygons need at least 3 points so don't reduce less than this
while (pointCount > 2 && (points[pointCount - 1] == points[0]))
{
--pointCount;
}
if (pointCount <= 2)
{
reducedPoints[0] = points[0];
if (pointCount == 2)
{
reducedPoints[1] = points[1];
}
reducedPointCount = pointCount;
if (addEndpoint)
{
reducedPoints[reducedPointCount++] = endPoint;
}
return;
}
if (pointsBuffer.Length < pointCount)
{
pointsBuffer = new PointD[pointCount];
}
for (int n = 0; n < pointCount; ++n)
{
pointsBuffer[n].X = points[n].X;
pointsBuffer[n].Y = points[n].Y;
}
List <int> reducedIndices = new List <int>();
reducedPointCount = GeometryAlgorithms.SimplifyDouglasPeucker(pointsBuffer, reducedIndices, pointCount, simplificationFactor);
for (int n = 0; n < reducedPointCount; ++n)
{
reducedPoints[n] = points[reducedIndices[n]];
if (measures != null)
{
reducedMeasures[n] = measures[reducedIndices[n]];
}
}
if (addEndpoint)
{
reducedPoints[reducedPointCount++] = endPoint;
}
}
public static Graphic NewCircle(double x, double y, double r)
{
double[] px = new double[NUM];
double[] py = new double[NUM];
GeometryAlgorithms.CircleToPoints(x, y, r, NUM, px, py, AngleDirection.CounterClockwise);
Esri.ArcGISRuntime.Geometry.PointCollection pc = new Esri.ArcGISRuntime.Geometry.PointCollection();
for (int i = 0; i < NUM; i++)
{
MapPoint p = new MapPoint(px[i], py[i]);
pc.Add(p);
}
pc.Add(pc[0]);
return(NewPolygon(pc));
}
private static void Analyze(string stateFips, string tigerFolderPath)
{
var countyShapeFile = new ShapeFile(Path.Combine(tigerFolderPath,
@"tl_2016_us_county\tl_2016_us_county.shp"));
var unifiedShapeFile = new ShapeFile(Path.Combine(tigerFolderPath,
@"tl_2016_us_unsd\tl_2016_us_unsd.shp"));
var unifiedEnumerator = unifiedShapeFile.GetShapeFileEnumerator();
while (unifiedEnumerator.MoveNext())
{
var unifiedFieldValues =
unifiedShapeFile.GetAttributeFieldValues(unifiedEnumerator.CurrentShapeIndex);
var st = unifiedFieldValues[0].Trim();
if (stateFips == null || stateFips == st)
{
var unifiedBounds = unifiedShapeFile.GetShapeBoundsD(unifiedEnumerator.CurrentShapeIndex);
var unifiedData = unifiedShapeFile.GetShapeDataD(unifiedEnumerator.CurrentShapeIndex);
var countyEnumerator = countyShapeFile.GetShapeFileEnumerator(unifiedBounds);
var inCounties = new List <string>();
while (countyEnumerator.MoveNext())
{
var countyFieldValues = countyShapeFile.GetAttributeFieldValues(countyEnumerator.CurrentShapeIndex);
var inCounty = false;
var countyData =
countyShapeFile.GetShapeDataD(countyEnumerator.CurrentShapeIndex);
foreach (var c in countyData)
{
foreach (var p in unifiedData)
{
if (GeometryAlgorithms.PolygonPolygonIntersect(c, c.Length,
p, p.Length))
{
inCounty = true;
}
}
}
if (inCounty)
{
inCounties.Add(countyFieldValues[1]); // fips
}
}
}
}
}
private VectorTileLayer ProcessPolygonTile(ShapeFile shapeFile, int tileX, int tileY, int zoom, OutputTileFeatureDelegate outputTileFeature)
{
int tileSize = TileSize;
RectangleD tileBounds = TileUtil.GetTileLatLonBounds(tileX, tileY, zoom, tileSize);
//create a buffer around the tileBounds
tileBounds.Inflate(tileBounds.Width * 0.05, tileBounds.Height * 0.05);
int simplificationFactor = Math.Min(10, Math.Max(1, SimplificationPixelThreshold));
System.Drawing.Point tilePixelOffset = new System.Drawing.Point((tileX * tileSize), (tileY * tileSize));
List <int> indicies = new List <int>();
shapeFile.GetShapeIndiciesIntersectingRect(indicies, tileBounds);
GeometryAlgorithms.ClipBounds clipBounds = new GeometryAlgorithms.ClipBounds()
{
XMin = -20,
YMin = -20,
XMax = tileSize + 20,
YMax = tileSize + 20
};
List <System.Drawing.Point> clippedPolygon = new List <System.Drawing.Point>();
VectorTileLayer tileLayer = new VectorTileLayer();
tileLayer.Extent = (uint)tileSize;
tileLayer.Version = 2;
tileLayer.Name = !string.IsNullOrEmpty(shapeFile.Name) ? shapeFile.Name : System.IO.Path.GetFileNameWithoutExtension(shapeFile.FilePath);
if (indicies.Count > 0)
{
foreach (int index in indicies)
{
if (outputTileFeature != null && !outputTileFeature(shapeFile, index, zoom, tileX, tileY))
{
continue;
}
VectorTileFeature feature = new VectorTileFeature()
{
Id = index.ToString(System.Globalization.CultureInfo.InvariantCulture),
Geometry = new List <List <Coordinate> >(),
Attributes = new List <AttributeKeyValue>(),
GeometryType = Tile.GeomType.Polygon
};
//get the point data
var recordPoints = shapeFile.GetShapeDataD(index);
int partIndex = 0;
foreach (PointD[] points in recordPoints)
{
//convert to pixel coordinates;
if (pixelPoints.Length < points.Length)
{
pixelPoints = new System.Drawing.Point[points.Length + 10];
simplifiedPixelPoints = new System.Drawing.Point[points.Length + 10];
}
int pointCount = 0;
for (int n = 0; n < points.Length; ++n)
{
Int64 x, y;
TileUtil.LLToPixel(points[n], zoom, out x, out y, tileSize);
pixelPoints[pointCount].X = (int)(x - tilePixelOffset.X);
pixelPoints[pointCount++].Y = (int)(y - tilePixelOffset.Y);
}
////check for duplicates points at end after they have been converted to pixel coordinates
////polygons need at least 3 points so don't reduce less than this
//while(pointCount > 3 && (pixelPoints[pointCount-1] == pixelPoints[pointCount - 2]))
//{
// --pointCount;
//}
int outputCount = 0;
SimplifyPointData(pixelPoints, null, pointCount, simplificationFactor, simplifiedPixelPoints, null, ref pointsBuffer, ref outputCount);
//simplifiedPixelPoints[outputCount++] = pixelPoints[pointCount-1];
if (outputCount > 1)
{
GeometryAlgorithms.PolygonClip(simplifiedPixelPoints, outputCount, clipBounds, clippedPolygon);
if (clippedPolygon.Count > 0)
{
//output the clipped polygon
List <Coordinate> lineString = new List <Coordinate>();
feature.Geometry.Add(lineString);
for (int i = clippedPolygon.Count - 1; i >= 0; --i)
{
lineString.Add(new Coordinate(clippedPolygon[i].X, clippedPolygon[i].Y));
}
}
}
++partIndex;
}
//add the record attributes
string[] fieldNames = shapeFile.GetAttributeFieldNames();
string[] values = shapeFile.GetAttributeFieldValues(index);
for (int n = 0; n < values.Length; ++n)
{
feature.Attributes.Add(new AttributeKeyValue(fieldNames[n], values[n].Trim()));
}
if (feature.Geometry.Count > 0)
{
tileLayer.VectorTileFeatures.Add(feature);
}
}
}
return(tileLayer);
}
private VectorTileLayer ProcessLineStringTile(ShapeFile shapeFile, int tileX, int tileY, int zoom, OutputTileFeatureDelegate outputTileFeature)
{
int tileSize = TileSize;
RectangleD tileBounds = TileUtil.GetTileLatLonBounds(tileX, tileY, zoom, tileSize);
//create a buffer around the tileBounds
tileBounds.Inflate(tileBounds.Width * 0.05, tileBounds.Height * 0.05);
int simplificationFactor = Math.Min(10, Math.Max(1, SimplificationPixelThreshold));
System.Drawing.Point tilePixelOffset = new System.Drawing.Point((tileX * tileSize), (tileY * tileSize));
List <int> indicies = new List <int>();
shapeFile.GetShapeIndiciesIntersectingRect(indicies, tileBounds);
GeometryAlgorithms.ClipBounds clipBounds = new GeometryAlgorithms.ClipBounds()
{
XMin = -20,
YMin = -20,
XMax = tileSize + 20,
YMax = tileSize + 20
};
bool outputMeasureValues = this.OutputMeasureValues && (shapeFile.ShapeType == ShapeType.PolyLineM || shapeFile.ShapeType == ShapeType.PolyLineZ);
System.Drawing.Point[] pixelPoints = new System.Drawing.Point[1024];
System.Drawing.Point[] simplifiedPixelPoints = new System.Drawing.Point[1024];
double[] simplifiedMeasures = new double[1024];
PointD[] pointsBuffer = new PointD[1024];
VectorTileLayer tileLayer = new VectorTileLayer();
tileLayer.Extent = (uint)tileSize;
tileLayer.Version = 2;
tileLayer.Name = !string.IsNullOrEmpty(shapeFile.Name) ? shapeFile.Name : System.IO.Path.GetFileNameWithoutExtension(shapeFile.FilePath);
if (indicies.Count > 0)
{
foreach (int index in indicies)
{
if (outputTileFeature != null && !outputTileFeature(shapeFile, index, zoom, tileX, tileY))
{
continue;
}
VectorTileFeature feature = new VectorTileFeature()
{
Id = index.ToString(System.Globalization.CultureInfo.InvariantCulture),
Geometry = new List <List <Coordinate> >(),
Attributes = new List <AttributeKeyValue>()
};
//get the point data
var recordPoints = shapeFile.GetShapeDataD(index);
System.Collections.ObjectModel.ReadOnlyCollection <double[]> recordMeasures = null;
if (outputMeasureValues)
{
recordMeasures = shapeFile.GetShapeMDataD(index);
}
List <double> outputMeasures = new List <double>();
int partIndex = 0;
foreach (PointD[] points in recordPoints)
{
double[] measures = recordMeasures != null ? recordMeasures[partIndex] : null;
//convert to pixel coordinates;
if (pixelPoints.Length < points.Length)
{
pixelPoints = new System.Drawing.Point[points.Length + 10];
simplifiedPixelPoints = new System.Drawing.Point[points.Length + 10];
simplifiedMeasures = new double[points.Length + 10];
}
for (int n = 0; n < points.Length; ++n)
{
Int64 x, y;
TileUtil.LLToPixel(points[n], zoom, out x, out y, tileSize);
pixelPoints[n].X = (int)(x - tilePixelOffset.X);
pixelPoints[n].Y = (int)(y - tilePixelOffset.Y);
}
int outputCount = 0;
SimplifyPointData(pixelPoints, measures, points.Length, simplificationFactor, simplifiedPixelPoints, simplifiedMeasures, ref pointsBuffer, ref outputCount);
//output count may be zero for short records at low zoom levels as
//the pixel coordinates wil be a single point after simplification
if (outputCount > 0)
{
List <int> clippedPoints = new List <int>();
List <int> parts = new List <int>();
if (outputMeasureValues)
{
List <double> clippedMeasures = new List <double>();
GeometryAlgorithms.PolyLineClip(simplifiedPixelPoints, outputCount, clipBounds, clippedPoints, parts, simplifiedMeasures, clippedMeasures);
outputMeasures.AddRange(clippedMeasures);
}
else
{
GeometryAlgorithms.PolyLineClip(simplifiedPixelPoints, outputCount, clipBounds, clippedPoints, parts);
}
if (parts.Count > 0)
{
//output the clipped polyline
for (int n = 0; n < parts.Count; ++n)
{
int index1 = parts[n];
int index2 = n < parts.Count - 1 ? parts[n + 1] : clippedPoints.Count;
List <Coordinate> lineString = new List <Coordinate>();
feature.GeometryType = Tile.GeomType.LineString;
feature.Geometry.Add(lineString);
//clipped points store separate x/y pairs so there will be two values per measure
for (int i = index1; i < index2; i += 2)
{
lineString.Add(new Coordinate(clippedPoints[i], clippedPoints[i + 1]));
}
}
}
}
++partIndex;
}
//add the record attributes
string[] fieldNames = shapeFile.GetAttributeFieldNames();
string[] values = shapeFile.GetAttributeFieldValues(index);
for (int n = 0; n < values.Length; ++n)
{
feature.Attributes.Add(new AttributeKeyValue(fieldNames[n], values[n].Trim()));
}
if (outputMeasureValues)
{
string s = Newtonsoft.Json.JsonConvert.SerializeObject(outputMeasures, new DoubleFormatConverter(4));
feature.Attributes.Add(new AttributeKeyValue(this.MeasuresAttributeName, s));
}
if (feature.Geometry.Count > 0)
{
tileLayer.VectorTileFeatures.Add(feature);
}
}
}
return(tileLayer);
}
private VectorTileLayer ProcessPolygonTile(ISpatialDataSource spatialLayer, int tileX, int tileY, int zoom)
{
int tileSize = TileSize;
RectangleD tileBounds = TileUtil.GetTileLatLonBounds(tileX, tileY, zoom, tileSize);
//create a buffer around the tileBounds
tileBounds.Inflate(tileBounds.Width * 0.05, tileBounds.Height * 0.05);
int simplificationFactor = Math.Min(10, Math.Max(1, SimplificationPixelThreshold));
System.Drawing.Point tilePixelOffset = new System.Drawing.Point((tileX * tileSize), (tileY * tileSize));
using (IEnumerator <ISpatialData> data = spatialLayer.GetData(new BoundingBox()
{
MinX = tileBounds.Left,
MinY = tileBounds.Top,
MaxX = tileBounds.Right,
MaxY = tileBounds.Bottom
}))
{
GeometryAlgorithms.ClipBounds clipBounds = new GeometryAlgorithms.ClipBounds()
{
XMin = -20,
YMin = -20,
XMax = tileSize + 20,
YMax = tileSize + 20
};
System.Drawing.Point[] pixelPoints = new System.Drawing.Point[1024];
System.Drawing.Point[] simplifiedPixelPoints = new System.Drawing.Point[1024];
PointD[] pointsBuffer = new PointD[1024];
List <System.Drawing.Point> clippedPolygon = new List <System.Drawing.Point>();
VectorTileLayer tileLayer = new VectorTileLayer();
tileLayer.Extent = (uint)tileSize;
tileLayer.Version = 2;
tileLayer.Name = spatialLayer.Name;
while (data.MoveNext())
{
ISpatialData spatialData = data.Current;
VectorTileFeature feature = new VectorTileFeature()
{
Id = spatialData.Id,
Geometry = new List <List <Coordinate> >(),
Attributes = new List <AttributeKeyValue>(),
GeometryType = Tile.GeomType.Polygon
};
//get the point data
var recordPoints = spatialData.Geometry;
int partIndex = 0;
foreach (PointD[] points in recordPoints)
{
//convert to pixel coordinates;
if (pixelPoints.Length < points.Length)
{
pixelPoints = new System.Drawing.Point[points.Length + 10];
simplifiedPixelPoints = new System.Drawing.Point[points.Length + 10];
}
for (int n = 0; n < points.Length; ++n)
{
Int64 x, y;
TileUtil.LLToPixel(points[n], zoom, out x, out y, tileSize);
pixelPoints[n].X = (int)(x - tilePixelOffset.X);
pixelPoints[n].Y = (int)(y - tilePixelOffset.Y);
}
int outputCount = 0;
SimplifyPointData(pixelPoints, null, points.Length, simplificationFactor, simplifiedPixelPoints, null, ref pointsBuffer, ref outputCount);
if (outputCount > 1)
{
GeometryAlgorithms.PolygonClip(simplifiedPixelPoints, outputCount, clipBounds, clippedPolygon);
if (clippedPolygon.Count > 0)
{
//output the clipped polygon
List <Coordinate> lineString = new List <Coordinate>();
feature.Geometry.Add(lineString);
for (int i = clippedPolygon.Count - 1; i >= 0; --i)
{
lineString.Add(new Coordinate(clippedPolygon[i].X, clippedPolygon[i].Y));
}
}
}
++partIndex;
}
//add the record attributes
foreach (var keyValue in spatialData.Attributes)
{
feature.Attributes.Add(new AttributeKeyValue(keyValue.Key, keyValue.Value));
}
if (feature.Geometry.Count > 0)
{
tileLayer.VectorTileFeatures.Add(feature);
}
}
return(tileLayer);
}
}
private VectorTileLayer ProcessLineStringTile(ISpatialDataSource spatialLayer, int tileX, int tileY, int zoom)
{
int tileSize = TileSize;
RectangleD tileBounds = TileUtil.GetTileLatLonBounds(tileX, tileY, zoom, tileSize);
//create a buffer around the tileBounds
tileBounds.Inflate(tileBounds.Width * 0.05, tileBounds.Height * 0.05);
int simplificationFactor = Math.Min(10, Math.Max(1, SimplificationPixelThreshold));
System.Drawing.Point tilePixelOffset = new System.Drawing.Point((tileX * tileSize), (tileY * tileSize));
using (IEnumerator <ISpatialData> data = spatialLayer.GetData(new BoundingBox()
{
MinX = tileBounds.Left,
MinY = tileBounds.Top,
MaxX = tileBounds.Right,
MaxY = tileBounds.Bottom
}))
{
GeometryAlgorithms.ClipBounds clipBounds = new GeometryAlgorithms.ClipBounds()
{
XMin = -20,
YMin = -20,
XMax = tileSize + 20,
YMax = tileSize + 20
};
bool outputMeasureValues = this.OutputMeasureValues && spatialLayer.HasMeasures;
System.Drawing.Point[] pixelPoints = new System.Drawing.Point[1024];
System.Drawing.Point[] simplifiedPixelPoints = new System.Drawing.Point[1024];
double[] simplifiedMeasures = new double[1024];
PointD[] pointsBuffer = new PointD[1024];
VectorTileLayer tileLayer = new VectorTileLayer();
tileLayer.Extent = (uint)tileSize;
tileLayer.Version = 2;
tileLayer.Name = spatialLayer.Name;
//int index = 0;
//foreach (int index in indicies)
while (data.MoveNext())
{
ISpatialData spatialData = data.Current;
VectorTileFeature feature = new VectorTileFeature()
{
Id = spatialData.Id,
Geometry = new List <List <Coordinate> >(),
Attributes = new List <AttributeKeyValue>()
};
//get the point data
var recordPoints = spatialData.Geometry;
List <double[]> recordMeasures = null;
if (outputMeasureValues)
{
recordMeasures = spatialData.Measures;
}
List <double> outputMeasures = new List <double>();
int partIndex = 0;
foreach (PointD[] points in recordPoints)
{
double[] measures = recordMeasures != null ? recordMeasures[partIndex] : null;
//convert to pixel coordinates;
if (pixelPoints.Length < points.Length)
{
pixelPoints = new System.Drawing.Point[points.Length + 10];
simplifiedPixelPoints = new System.Drawing.Point[points.Length + 10];
simplifiedMeasures = new double[points.Length + 10];
}
for (int n = 0; n < points.Length; ++n)
{
Int64 x, y;
TileUtil.LLToPixel(points[n], zoom, out x, out y, tileSize);
pixelPoints[n].X = (int)(x - tilePixelOffset.X);
pixelPoints[n].Y = (int)(y - tilePixelOffset.Y);
}
int outputCount = 0;
SimplifyPointData(pixelPoints, measures, points.Length, simplificationFactor, simplifiedPixelPoints, simplifiedMeasures, ref pointsBuffer, ref outputCount);
//output count may be zero for short records at low zoom levels as
//the pixel coordinates wil be a single point after simplification
if (outputCount > 0)
{
List <int> clippedPoints = new List <int>();
List <int> parts = new List <int>();
if (outputMeasureValues)
{
List <double> clippedMeasures = new List <double>();
GeometryAlgorithms.PolyLineClip(simplifiedPixelPoints, outputCount, clipBounds, clippedPoints, parts, simplifiedMeasures, clippedMeasures);
outputMeasures.AddRange(clippedMeasures);
}
else
{
GeometryAlgorithms.PolyLineClip(simplifiedPixelPoints, outputCount, clipBounds, clippedPoints, parts);
}
if (parts.Count > 0)
{
//output the clipped polyline
for (int n = 0; n < parts.Count; ++n)
{
int index1 = parts[n];
int index2 = n < parts.Count - 1 ? parts[n + 1] : clippedPoints.Count;
List <Coordinate> lineString = new List <Coordinate>();
feature.GeometryType = Tile.GeomType.LineString;
feature.Geometry.Add(lineString);
//clipped points store separate x/y pairs so there will be two values per measure
for (int i = index1; i < index2; i += 2)
{
lineString.Add(new Coordinate(clippedPoints[i], clippedPoints[i + 1]));
}
}
}
}
++partIndex;
}
//add the record attributes
foreach (var keyValue in spatialData.Attributes)
{
feature.Attributes.Add(new AttributeKeyValue(keyValue.Key, keyValue.Value));
}
if (outputMeasureValues)
{
string s = Newtonsoft.Json.JsonConvert.SerializeObject(outputMeasures, new DoubleFormatConverter(4));
feature.Attributes.Add(new AttributeKeyValue(this.MeasuresAttributeName, s));
}
if (feature.Geometry.Count > 0)
{
tileLayer.VectorTileFeatures.Add(feature);
}
}
return(tileLayer);
}
}
public static double Distance(MapPoint p1, MapPoint p2)
{
return(GeometryAlgorithms.PointDistanceToPoint(p1.X, p1.Y, p2.X, p2.Y));
}
public void GeometryAlgorithmsValidateTest()
{
#region testing polygon validation with precision model application
// polygon remains unchanged after validation
PrecisionModel precisionModel = PrecisionModel.Default;
GeometryFactory factory = new GeometryFactory(precisionModel, null);
IPolygon polygon = factory.CreatePolygon(new Coordinate[]
{
new Coordinate(0.000, 0.000),
new Coordinate(0.444, 0.000),
new Coordinate(0.444, 0.040),
new Coordinate(0.440, 0.040),
});
Assert.IsTrue(polygon.IsValid);
IGeometry result = GeometryAlgorithms.Validate(polygon);
Assert.IsInstanceOf <IPolygon>(result);
Assert.AreEqual(5, ((IPolygon)result).Shell.Count);
// polygon becomes another polygon after validation
precisionModel = new PrecisionModel(100);
factory = new GeometryFactory(precisionModel, null);
polygon = factory.CreatePolygon(new Coordinate[]
{
new Coordinate(0.000, 0.000),
new Coordinate(0.444, 0.000),
new Coordinate(0.444, 0.040),
new Coordinate(0.440, 0.040),
});
Assert.IsFalse(polygon.IsValid);
result = GeometryAlgorithms.Validate(polygon);
Assert.IsInstanceOf <IPolygon>(result);
Assert.AreEqual(4, ((IPolygon)result).Shell.Count);
// polygon becomes a line after validation
precisionModel = new PrecisionModel(10);
factory = new GeometryFactory(precisionModel, null);
polygon = factory.CreatePolygon(new Coordinate[]
{
new Coordinate(0.000, 0.000),
new Coordinate(0.444, 0.000),
new Coordinate(0.444, 0.040),
new Coordinate(0.440, 0.040),
});
Assert.IsFalse(polygon.IsValid);
result = GeometryAlgorithms.Validate(polygon);
Assert.IsInstanceOf <ILineString>(result);
Assert.AreEqual(2, ((ILineString)result).Count);
// polygon becomes a point after validation
precisionModel = new PrecisionModel(1);
factory = new GeometryFactory(precisionModel, null);
polygon = factory.CreatePolygon(new Coordinate[]
{
new Coordinate(0.000, 0.000),
new Coordinate(0.444, 0.000),
new Coordinate(0.444, 0.040),
new Coordinate(0.440, 0.040),
});
Assert.IsFalse(polygon.IsValid);
result = GeometryAlgorithms.Validate(polygon);
Assert.IsInstanceOf <IPoint>(result);
Assert.AreEqual(new Coordinate(0, 0), ((IPoint)result).Coordinate);
#endregion
}
