public GeoJson ConvertToGeoJson(bool convertLineStringCoordsToPolygon, int maxVerticesToApproximateTo)
{
if (LineworkBoundaries == null)
{
return(null);
}
var geoJson = new GeoJson
{
Type = GeoJson.FeatureType.FEATURE_COLLECTION,
Features = new List <Feature>()
};
foreach (var boundary in LineworkBoundaries)
{
var fencePoints = DouglasPeucker.DouglasPeuckerByCount(
boundary.Boundary.Select(p => new WGSPoint(latitude: p.Lat, longtitude: p.Lon)).ToArray(),
maxVerticesToApproximateTo);
geoJson.Features.Add(new Feature
{
Type = GeoJson.FeatureType.FEATURE,
Properties = new Properties {
Name = boundary.BoundaryName
},
Geometry = GetCoordinatesFromFencePoints(fencePoints, convertLineStringCoordsToPolygon)
});
}
return(geoJson);
}
public IHttpActionResult GetPathElevation(Location[] path, int samples = 100)
{
try
{
var geoPoints = ModelFactory.Create(path);
var geom = GeometryService.ParseGeoPointAsGeometryLine(geoPoints);
_elevationService.DownloadMissingFiles(DEMDataSet.AW3D30, geom.GetBoundingBox());
geoPoints = _elevationService.GetLineGeometryElevation(geom, DEMDataSet.AW3D30, InterpolationMode.Bilinear);
ElevationMetrics metrics = GeometryService.ComputeMetrics(geoPoints);
if (samples > 2)
{
double ratio = 4 / 2;
double tolerance = (metrics.MaxElevation - metrics.MinElevation) / (samples / ratio);
geoPoints = DouglasPeucker.DouglasPeuckerReduction(geoPoints, tolerance);
}
// Model
ElevationMetricsModel metricsModel = ModelFactory.CreateElevationMetricsModel(geoPoints, metrics);
var feature = ModelFactory.CreateFeature(geoPoints, metricsModel);
return(Ok(feature));
}
catch (Exception ex)
{
return(InternalServerError(new Exception(ex.Message)));
}
}
public void Simplify(float epsilon)
{
Debug.Log("Start simplify with epsilon = " + epsilon + ", number of points before: " + line.positionCount);
var newList = DouglasPeucker.DouglasPeuckerReduction(GetPositions(), epsilon);
SetPositions(newList);
Debug.Log("End simplify with epsilon = " + epsilon + ", number of points after: " + line.positionCount);
}
private void douglasPeuckerbox_Click(object sender, RoutedEventArgs e)
{
MapCanvas.Children.Clear();
var dp = new DouglasPeucker();
for (var index = 0; index < Points.Count; index++)
{
Points[index] = dp.DouglasPeuckerReduction(Points[index], 25);
DrawMap(Points[index]);
}
}
private void btnSmartFilter_Click(object sender, RoutedEventArgs e)
{
DouglasPeucker dp = new DouglasPeucker();
var d = poly.Points.ToList();
var t = dp.DouglasPeuckerReduction(d, 10);
PointCollection pc = new PointCollection();
foreach (var point in t)
{
pc.Add(point);
}
poly.Points = pc;
}
public IActionResult PolylineReducePoints([FromBody] SmoothPolylineRequest requestDto)
{
Log.LogDebug($"{nameof(PolylineReducePoints)}: {requestDto}");
if (requestDto.MaxPoints > SmoothPolylineRequest.NOT_DEFINED && requestDto.MaxPoints < 3)
{
return(StatusCode((int)HttpStatusCode.BadRequest, new { Message = "Cannot reduce polyline to fewer than 3 points." }));
}
var fencePoints = DouglasPeucker.DouglasPeuckerByCount(requestDto.Coordinates, requestDto.MaxPoints);
return(StatusCode((int)HttpStatusCode.OK, new { coordinates = fencePoints }));
}
private void douglasPeucker_Click(object sender, RoutedEventArgs e)
{
MapCanvas.Children.Clear();
var dp = new DouglasPeucker();
for (var index = 0; index < Points.Count; index++)
{
var pointlist = Points[index];
Points[index] = dp.DouglasPeuckerReduction(pointlist, 5);
DrawMap(pointlist);
}
}
public static CollisionDefinition FromTexture(Texture2D texture, float tolerance, Transform transform)
{
List <CollisionDefinitionEntry> collisions = new List <CollisionDefinitionEntry>();
//Get the pixellated outline
TextureToPerimeter texP = new TextureToPerimeter();
foreach (var perimeter in texP.March(texture))
{
//Remove redundant aligned points
var simplifiedLine = new List <Vector2>();
Vector2 lastDir = Vector2.Zero;
for (int i = 1; i < perimeter.Count; i++)
{
Vector2 dir = perimeter[i] - perimeter[i - 1];
if (lastDir != dir)
{
simplifiedLine.Add(perimeter[i - 1]);
}
lastDir = dir;
}
//Use dougles peucker to further simplify the outline, and fix local coordinates
simplifiedLine = DouglasPeucker.DouglasPeuckerReduction(simplifiedLine, tolerance);
for (int i = 0; i < simplifiedLine.Count; i++)
{
simplifiedLine[i] -= new Vector2(texture.Width, texture.Height) * 0.5f;
simplifiedLine[i] = new Vector2(simplifiedLine[i].X, -simplifiedLine[i].Y);
simplifiedLine[i] = simplifiedLine[i].Rotate(transform.Orientation);
simplifiedLine[i] += transform.Position;
}
//Triangulate the resulting outline
Triangulator tr = new Triangulator(simplifiedLine.ToArray());
var indices = tr.Triangulate();
collisions.Add(new CollisionDefinitionEntry()
{
Indices = indices, Vertices = simplifiedLine.ToArray()
});
}
return(new CollisionDefinition()
{
Entries = collisions.ToArray()
});
}
List <Vector3> getPoints(MPath path2)
{
var points = new List <Vector3> ();
List <Vertex> vertices = new List <Vertex> ();
for (int i = 0; i < path2.Count; i++)
{
var point = path2.GetPosition(i);
points.Add(point);
}
for (int i = path1.Count - 2; i > 0; i--)
{
var point = path1.GetPosition(i);
points.Add(point);
}
points = DouglasPeucker.DouglasPeuckerReduction(points, 0.01d);
return(points);
}
void BuildReducedSeries(LineSeries lineSeries, List <DouglasPeucker.Point> fullList, double tolerance)
{
if (Config.Result.PlotSmoothingEnabled)
{
// reduce the samples (keep only significant) -> smoothing in plot is much better
IList <DouglasPeucker.Point> reducedList = DouglasPeucker.Reduce(fullList, tolerance);
foreach (DouglasPeucker.Point p in reducedList)
{
lineSeries.Points.Add(new DataPoint(p.X, p.Y));
}
}
else
{
// no smoothing in plot -> copy all samples
foreach (DouglasPeucker.Point p in fullList)
{
lineSeries.Points.Add(new DataPoint(p.X, p.Y));
}
}
}
static void LineDEMTest(ElevationService elevationService, DEMDataSet dataSet, string wkt, int numSamples)
{
Stopwatch sw = Stopwatch.StartNew();
elevationService.DownloadMissingFiles(dataSet, GetBoundingBox(wkt));
var lineElevationData = elevationService.GetLineGeometryElevation(wkt, dataSet, InterpolationMode.Bilinear);
ElevationMetrics metrics = GeometryService.ComputeMetrics(ref lineElevationData);
var lineElevationData_Reduced = DouglasPeucker.DouglasPeuckerReduction(lineElevationData, (metrics.MaxElevation - metrics.MinElevation) / numSamples);
sw.Stop();
Console.WriteLine($"LineDEMTest performed in {sw.Elapsed:g}.");
SpatialTrace.Enable();
SpatialTrace.Clear();
SpatialTraceLine(lineElevationData, $"Full resolution line ({lineElevationData.Count} points)");
SpatialTraceLine(lineElevationData_Reduced, $"Reduced line ({lineElevationData_Reduced.Count} points)");
SpatialTrace.ShowDialog();
}
public void OnProcessDrawing()
{
foreach (LineRenderer line in m_lineList)
{
LineRenderer item = Instantiate(line);
m_duplicatedLineList.Add(item);
}
float num = float.MaxValue;
float num2 = float.MaxValue;
float num3 = float.MinValue;
float num4 = float.MinValue;
foreach (LineRenderer duplicatedLine in m_duplicatedLineList)
{
Vector3[] array = new Vector3[duplicatedLine.positionCount];
duplicatedLine.GetPositions(array);
for (int i = 0; i < array.Length; i++)
{
Vector3 vector = array[i];
if (vector.x < num)
{
num = vector.x;
}
if (vector.y < num2)
{
num2 = vector.y;
}
if (vector.x > num3)
{
num3 = vector.x;
}
if (vector.y > num4)
{
num4 = vector.y;
}
}
}
int num5 = 2;
if (m_duplicatedLineList.Count > 15)
{
num5 = 6;
}
else if (m_duplicatedLineList.Count > 10)
{
num5 = 5;
}
else if (m_duplicatedLineList.Count > 5)
{
num5 = 4;
}
float a = 255f / (num3 - num);
float b = 255f / (num4 - num2);
float num6 = Mathf.Min(a, b);
List <double> list = new List <double>();
int num7 = 0;
int num8 = 0;
foreach (LineRenderer duplicatedLine2 in m_duplicatedLineList)
{
Vector3[] array2 = new Vector3[duplicatedLine2.positionCount];
duplicatedLine2.GetPositions(array2);
for (int j = 0; j < array2.Length; j++)
{
Vector3 vector2 = array2[j];
vector2.x -= num;
vector2.x *= num6;
vector2.x = Mathf.Floor(vector2.x);
vector2.y -= num2;
vector2.y *= num6;
vector2.y = Mathf.Floor(vector2.y);
int num9 = 127 - (int)vector2.y;
vector2.y += 2 * num9;
array2[j] = vector2;
}
List <Vector2> list2 = new List <Vector2>();
for (int k = 0; k < array2.Length; k++)
{
list2.Add(array2[k]);
}
IList <Vector2> list3 = DouglasPeucker.DouglasPeuckerReduction(list2, num5);
List <Vector3> list4 = new List <Vector3>();
foreach (Vector2 item2 in list3)
{
Vector2 current4 = item2;
list4.Add(new Vector3(current4.x, current4.y, 0f));
list.Add((double)current4.x / 255.0);
list.Add((double)current4.y / 255.0);
list.Add(0.0);
num7 += 3;
num8++;
}
list[num7 - 1] = 1.0;
duplicatedLine2.positionCount = list4.Count;
duplicatedLine2.SetPositions(list4.ToArray());
}
for (int l = 0; l < num8 - 1; l++)
{
list[l * 3] = list[(l + 1) * 3] - list[l * 3];
list[l * 3 + 1] = list[(l + 1) * 3 + 1] - list[l * 3 + 1];
list[l * 3 + 2] = list[(l + 1) * 3 + 2];
}
double[] inferData = list.ToArray();
string str = "[";
bool flag = false;
foreach (LineRenderer duplicatedLine3 in m_duplicatedLineList)
{
ImageDataStroke imageDataStroke = new ImageDataStroke();
Vector3[] array3 = new Vector3[duplicatedLine3.positionCount];
duplicatedLine3.GetPositions(array3);
if (flag)
{
str += ",";
}
flag = true;
str += "[";
for (int m = 0; m < array3.Length; m++)
{
Vector3 vector3 = array3[m];
imageDataStroke.x.Add((int)vector3.x);
imageDataStroke.y.Add((int)vector3.y);
}
string input = JsonUtility.ToJson(imageDataStroke);
string str2 = Regex.Replace(input, "[{}a-zA-Z:?\"]", string.Empty);
str += str2;
str += "]";
}
str = (m_opuput = str + "]");
Debug.Log(str);
//TensorModel.Infer(inferData, 5);
/* string sttr = "";
* foreach(double d in inferData)
* {
* sttr += d.ToString() +"|";
* }
* Debug.Log(sttr);*/
foreach (LineRenderer duplicatedLine4 in m_duplicatedLineList)
{
Destroy(duplicatedLine4.gameObject);
}
m_duplicatedLineList.Clear();
}
/// <summary>
/// Exports the geographic data in packed string format with reduced quality.
/// </summary>
public string GetCountryGeoDataLowQuality()
{
// step 1: duplicate data
IAdminEntity[] entities;
if (editingMode == EDITING_MODE.COUNTRIES)
{
entities = map.countries;
}
else
{
entities = map.provinces;
}
List <IAdminEntity> entities1 = new List <IAdminEntity>(entities);
// step 1: prepare data structures
for (int k = 0; k < entities1.Count; k++)
{
entities1[k].regions = new List <Region>(entities1[k].regions);
}
// step 2: catalog points
int totalPoints = 0;
List <PolygonPoint> allPoints = new List <PolygonPoint>(150000);
for (int k = 0; k < entities1.Count; k++)
{
for (int r = 0; r < entities1[k].regions.Count; r++)
{
Region region1 = entities1[k].regions[r];
totalPoints += region1.latlon.Length;
allPoints.AddRange(region1.latlon);
}
}
allPoints = DouglasPeucker.SimplifyCurve(allPoints, 0.1);
Dictionary <PolygonPoint, bool> allPointsLookup = new Dictionary <PolygonPoint, bool>(allPoints.Count);
for (int k = 0; k < allPoints.Count; k++)
{
if (!allPointsLookup.ContainsKey(allPoints[k]))
{
allPointsLookup.Add(allPoints[k], true);
}
}
// step 3: reduce region points according to exclusion catalog
int savings = 0;
List <PolygonPoint> goodLatLons = new List <PolygonPoint>(15000);
for (int k = 0; k < entities1.Count; k++)
{
for (int r = 0; r < entities1[k].regions.Count; r++)
{
goodLatLons.Clear();
Region region = entities1[k].regions[r];
for (int p = 0; p < region.latlon.Length; p++)
{
PolygonPoint latlon = region.latlon[p];
if (allPointsLookup.ContainsKey(latlon))
{
goodLatLons.Add(latlon);
}
}
goodLatLons = PolygonSanitizer.RemoveCrossingSegments(goodLatLons);
if (goodLatLons.Count < 5)
{
entities1[k].regions.Remove(region);
r--;
}
else
{
totalPoints += region.latlon.Length;
savings += (region.latlon.Length - goodLatLons.Count);
region.latlon = goodLatLons.ToArray();
}
}
}
Debug.Log(savings + " points removed of " + totalPoints + " (" + (((float)savings / totalPoints) * 100.0f).ToString("F1") + "%)");
StringBuilder sb = new StringBuilder();
for (int k = 0; k < entities1.Count; k++)
{
IAdminEntity entity = entities1[k];
if (entity.regions.Count == 0)
{
continue;
}
if (k > 0)
{
sb.Append("|");
}
sb.Append(entity.name + "$");
if (entity is Country)
{
sb.Append(((Country)entity).continent + "$");
}
else
{
sb.Append(map.countries[((Province)entity).countryIndex].name + "$");
}
for (int r = 0; r < entity.regions.Count; r++)
{
if (r > 0)
{
sb.Append("*");
}
Region region = entity.regions [r];
for (int p = 0; p < region.latlon.Length; p++)
{
if (p > 0)
{
sb.Append(";");
}
Point2D point = region.latlon [p] * WorldMapGlobe.MAP_PRECISION;
sb.Append(Mathf.RoundToInt(point.Xf).ToString() + ",");
sb.Append(Mathf.RoundToInt(point.Yf).ToString());
}
}
}
return(sb.ToString());
}
