public IActionResult GetWaterAllocations([HttpTrigger("get", Route = "GetWaterAllocations")] HttpRequest request)
{
var allocations = _waterAllocationAccessor.GetAllocations().ToList();
foreach (var classification in WaDEClassifications)
{
var allocationsByClassification = allocations
.Select(x => x)
.Where(x => x.AllocationBridgeBeneficialUsesFacts.FirstOrDefault().BeneficialUseCvNavigation.WaDename == classification)
.ToList();
var allocationsArray = generateAllocation(allocationsByClassification);
var geoJsonData = new GeoJSON()
{
Type = "geojson",
Data = new GeoJSONData()
{
Type = "FeatureCollection",
Features = allocationsArray
}
};
var serializedData = JsonConvert.SerializeObject(geoJsonData);
System.IO.File.WriteAllText(@"C:\Your\Preferred\Directory\_" + classification + " Allocations.geojson", serializedData);
}
return(Ok());
}
public void TestManholesPropertiesAmsterdam()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Amsterdam;
SewerageLayer seweragelayer = new SewerageLayer();
GeoJSON geojson = new GeoJSON(testStringManholesAmsterdam);
geojson.GotoNextFeature();
var putdekselhoogte1 = geojson.getPropertyFloatValue(seweragelayer.PutdekselhoogteString);
var point1 = geojson.getGeometryPoint2DDouble();
Assert.AreEqual(0.20, putdekselhoogte1, 0.001);
Assert.AreEqual(2, point1.Length);
Assert.AreEqual(4.91561158208928, point1[0], 0.001);
Assert.AreEqual(52.342962335247, point1[1], 0.001);
geojson.GotoNextFeature();
var putdekselhoogte2 = geojson.getPropertyFloatValue(seweragelayer.PutdekselhoogteString);
var point2 = geojson.getGeometryPoint2DDouble();
Assert.AreEqual(0.68, putdekselhoogte2, 0.001);
Assert.AreEqual(2, point2.Length);
Assert.AreEqual(4.90876406244186, point2[0], 0.001);
Assert.AreEqual(52.3425051475584, point2[1], 0.001);
}
public void TestManholesPropertiesPdok()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Pdok;
SewerageLayer seweragelayer = new SewerageLayer();
GeoJSON geojson = new GeoJSON(testStringManholesPdok);
geojson.GotoNextFeature();
var putdekselhoogte1 = geojson.getPropertyFloatValue(seweragelayer.PutdekselhoogteString);
var point1 = geojson.getGeometryPoint2DDouble();
Assert.AreEqual(1.530, putdekselhoogte1, 0.001);
Assert.AreEqual(2, point1.Length);
Assert.AreEqual(132303.35, point1[0], 0.001);
Assert.AreEqual(457990.35, point1[1], 0.001);
geojson.GotoNextFeature();
var putdekselhoogte2 = geojson.getPropertyFloatValue(seweragelayer.PutdekselhoogteString);
var point2 = geojson.getGeometryPoint2DDouble();
Assert.AreEqual(1.540, putdekselhoogte2, 0.001);
Assert.AreEqual(2, point2.Length);
Assert.AreEqual(132347.73, point2[0], 0.001);
Assert.AreEqual(457958.06, point2[1], 0.001);
}
// [Test]
public void TestFilePdok()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Pdok;
SewerageLayer seweragelayer = new SewerageLayer();
//var jsontext = System.IO.File.ReadAllText(@"F:\Data\sewerage\data_utrecht_leidingen.json");
//var jsontext = System.IO.File.ReadAllText(@"F:\Data\sewerage\data_utrecht_leidingen_128000_456000_129000_457000.json");
var jsontext = System.IO.File.ReadAllText(@"F:\Data\sewerage\data_utrecht_leidingen_count_error.json");
GeoJSON geojson = new GeoJSON(jsontext);
while (geojson.GotoNextFeature())
{
double diameter = geojson.getPropertyFloatValue(seweragelayer.DiameterString);
double bobBeginPunt = geojson.getPropertyFloatValue(seweragelayer.BobBeginPuntString);
double bobEindPunt = geojson.getPropertyFloatValue(seweragelayer.BobEindPuntString);
var geom = geojson.getGeometryLineString();
Assert.AreEqual(4, geom.Count);
// Debug.Log($"diameter:{diameter} bobBeginPunt:{bobBeginPunt} bobEindPunt:{bobEindPunt}");
}
}
public void TestGetPropertiesAmsterdam()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Amsterdam;
SewerageLayer seweragelayer = new SewerageLayer();
GeoJSON geojson = new GeoJSON(testStringAmsterdam);
geojson.GotoNextFeature();
double diameter1 = geojson.getPropertyFloatValue(seweragelayer.DiameterString);
double bobBeginPunt1 = geojson.getPropertyFloatValue(seweragelayer.BobBeginPuntString);
double bobEindPunt1 = geojson.getPropertyFloatValue(seweragelayer.BobEindPuntString);
Assert.AreEqual(297, diameter1);
Assert.AreEqual(-1, bobBeginPunt1);
Assert.AreEqual(-1.6, bobEindPunt1, 0.1);
geojson.GotoNextFeature();
double diameter2 = geojson.getPropertyFloatValue(seweragelayer.DiameterString);
double bobBeginPunt2 = geojson.getPropertyFloatValue(seweragelayer.BobBeginPuntString);
double bobEindPunt2 = geojson.getPropertyFloatValue(seweragelayer.BobEindPuntString);
Assert.AreEqual(234, diameter2);
Assert.AreEqual(-1, bobBeginPunt2);
Assert.AreEqual(-1.1, bobEindPunt2, 0.1);
}
private IEnumerator SpawnManHoleObjects(string geoJSONtext, TileChange tileChange, Tile tile, System.Action <TileChange> callback = null)
{
tile.gameObject.SetActive(isEnabled);
GeoJSON customJsonHandler = new GeoJSON(geoJSONtext);
yield return(null);
double[] point2D;
Vector3 point;
int parseCounter = 0;
while (customJsonHandler.GotoNextFeature())
{
parseCounter++;
if ((parseCounter % maxParsesPerFrame) == 0)
{
yield return(new WaitForEndOfFrame());
}
if (customJsonHandler.PropertyValueStringEquals("objectsoort", "Knikpunt"))
{
point2D = customJsonHandler.getGeometryPoint2DDouble();
double putdekselhoogte = customJsonHandler.getPropertyFloatValue("putdekselhoogte");
point = ConvertCoordinates.CoordConvert.WGS84toUnity(new Vector3WGS(point2D[0], point2D[1], putdekselhoogte + Config.activeConfiguration.zeroGroundLevelY));
sewerManholeSpawner.CreateManhole(point, 1.50f, tile.gameObject);
}
}
StartCoroutine(CombineSewerage(tileChange, tile, callback));
}
public void TestCoordinatesAmsterdam()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Amsterdam;
SewerageLayer seweragelayer = new SewerageLayer();
GeoJSON geojson = new GeoJSON(testStringAmsterdam);
geojson.GotoNextFeature();
var geom1 = geojson.getGeometryLineString();
Assert.AreEqual(4, geom1.Count);
Assert.AreEqual(geom1[0], 4.90698478562009, 0.000001);
Assert.AreEqual(geom1[1], 52.3429529014738, 0.000001);
Assert.AreEqual(geom1[2], 4.90702608778446, 0.000001);
Assert.AreEqual(geom1[3], 52.3428382055533, 0.000001);
geojson.GotoNextFeature();
var geom2 = geojson.getGeometryLineString();
Assert.AreEqual(4, geom2.Count);
Assert.AreEqual(geom2[0], 4.90698478562009, 0.000001);
Assert.AreEqual(geom2[1], 52.3429529014738, 0.000001);
Assert.AreEqual(geom2[2], 4.90665251262403, 0.000001);
Assert.AreEqual(geom2[3], 52.3429023897671, 0.000001);
}
public void TestCoordinatesPdok()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Pdok;
SewerageLayer seweragelayer = new SewerageLayer();
GeoJSON geojson = new GeoJSON(testStringPdok);
geojson.GotoNextFeature();
var geom1 = geojson.getGeometryLineString();
Assert.AreEqual(4, geom1.Count);
Assert.AreEqual(geom1[0], 132803.42, 0.1);
Assert.AreEqual(geom1[1], 457145.83, 0.1);
Assert.AreEqual(geom1[2], 132798.02, 0.1);
Assert.AreEqual(geom1[3], 457153.57, 0.1);
geojson.GotoNextFeature();
var geom2 = geojson.getGeometryLineString();
Assert.AreEqual(4, geom2.Count);
Assert.AreEqual(geom2[0], 132652.29, 0.1);
Assert.AreEqual(geom2[1], 457103.23, 0.1);
Assert.AreEqual(geom2[2], 132655.03, 0.1);
Assert.AreEqual(geom2[3], 457110.39, 0.1);
}
public void SqlGeometryToJSONTest()
{
string expected = "{\"type\":\"FeatureCollection\", \"features\":[{\"type\":\"Feature\", \"geometry\":{\"type\":\"Polygon\", \"coordinates\":[[[-41.2281722793271, 174.70763047448], [-41.1553878554989, 174.777668316277], [-41.1560745010067, 174.840839702996], [-41.2171859512021, 174.878605205926], [-41.2549514541317, 174.807880718621], [-41.2803573379208, 174.802387554559], [-41.2824172744442, 174.834659893426], [-41.3270492324521, 174.841526348504], [-41.3531417617489, 174.774921734246], [-41.3043899306942, 174.715870220574], [-41.2281722793271, 174.70763047448]]]}, \"properties\":null, \"crs\":{\"type\":\"name\", \"properties\":{\"name\":\"epsg:4326\"}}}]}";
System.Data.SqlTypes.SqlChars wkbGeometry = new System.Data.SqlTypes.SqlChars("POLYGON ((-41.2281722793271 174.70763047448, -41.1553878554989 174.777668316277, -41.1560745010067 174.840839702996, -41.2171859512021 174.878605205926, -41.2549514541317 174.807880718621, -41.2803573379208 174.802387554559, -41.2824172744442 174.834659893426, -41.3270492324521 174.841526348504, -41.3531417617489 174.774921734246, -41.3043899306942 174.715870220574, -41.2281722793271 174.70763047448))");
SqlGeometry sqlGeometry = SqlGeometry.STGeomFromText(wkbGeometry, 4326);
string actual;
actual = GeoJSON.SqlGeometryToJSON(sqlGeometry);
Assert.AreEqual(expected, actual);
}
public void GeoJSONLineStringToWktTest()
{
string json = "{\"type\":\"FeatureCollection\", \"features\":[{\"type\":\"Feature\", \"crs\" : { \"type\" : \"name\", \"properties\" : { \"name\" : \"epsg:4326\" } } \"geometry\":{\"type\":\"LineString\", \"coordinates\":[[-41.2281722793271, 174.70763047448], [-41.1553878554989, 174.777668316277], [-41.1560745010067, 174.840839702996], [-41.2171859512021, 174.878605205926], [-41.2549514541317, 174.807880718621], [-41.2803573379208, 174.802387554559], [-41.2824172744442, 174.834659893426], [-41.3270492324521, 174.841526348504], [-41.3531417617489, 174.774921734246]]}, \"properties\":{}}]}";
string expected = "LINESTRING (-41.2281722793271 174.70763047448, -41.1553878554989 174.777668316277, -41.1560745010067 174.840839702996, -41.2171859512021 174.878605205926, -41.2549514541317 174.807880718621, -41.2803573379208 174.802387554559, -41.2824172744442 174.834659893426, -41.3270492324521 174.841526348504, -41.3531417617489 174.774921734246)";
string actual;
int srid = 0;
actual = GeoJSON.GeoJSONToWkt(json, out srid);
Assert.AreEqual(expected, actual);
Assert.AreEqual(4326, srid);
}
public void GeoJSONPointToWktTest()
{
string json = "{\"type\":\"FeatureCollection\", \"features\":[{\"type\":\"Feature\", \"crs\" : { \"type\" : \"name\", \"properties\" : { \"name\" : \"epsg:4326\" } } \"geometry\":{\"type\":\"Point\", \"coordinates\":[-41.2281722793271, 174.70763047448]}, \"properties\":{}}]}";
string expected = "POINT (-41.2281722793271 174.70763047448)";
string actual;
int srid = 0;
actual = GeoJSON.GeoJSONToWkt(json, out srid);
Assert.AreEqual(expected, actual);
Assert.AreEqual(4326, srid);
}
IEnumerator GetSewerLinesInBoundingBox(TileChange tileChange, Tile tile, Vector3RD boundingBoxMinimum, Vector3RD boundingBoxMaximum, System.Action <TileChange> callback = null)
{
yield return(null);
yield return(new WaitUntil(() => activeCount < maxSimultaneous));
activeCount++;
tile.gameObject.SetActive(true);
string escapedUrl = sewerPipesWfsUrl;
escapedUrl += UnityWebRequest.EscapeURL((boundingBoxMinimum.x).ToString(CultureInfo.InvariantCulture) + "," + (boundingBoxMinimum.y).ToString(CultureInfo.InvariantCulture) + "," + (boundingBoxMaximum.x).ToString(CultureInfo.InvariantCulture) + "," + (boundingBoxMaximum.y).ToString(CultureInfo.InvariantCulture));
var sewerageRequest = UnityWebRequest.Get(escapedUrl);
yield return(sewerageRequest.SendWebRequest());
if (!sewerageRequest.isNetworkError && !sewerageRequest.isHttpError)
{
GeoJSON customJsonHandler = new GeoJSON(sewerageRequest.downloadHandler.text);
yield return(null);
Vector3 startpoint;
Vector3 endpoint;
int parseCounter = 0;
while (customJsonHandler.GotoNextFeature())
{
parseCounter++;
if ((parseCounter % maxParsesPerFrame) == 0)
{
yield return(null);
}
double diameter = customJsonHandler.getPropertyFloatValue("diameter");
double bobBeginPunt = customJsonHandler.getPropertyFloatValue("bob_beginpunt");
List <double> coordinates = customJsonHandler.getGeometryLineString();
endpoint = ConvertCoordinates.CoordConvert.WGS84toUnity(new Vector3WGS(coordinates[0], coordinates[1], bobBeginPunt + Config.activeConfiguration.zeroGroundLevelY));
for (int i = 2; i < coordinates.Count; i += 2)
{
startpoint = endpoint;
double bobEindPunt = customJsonHandler.getPropertyFloatValue("bob_eindpunt");
endpoint = ConvertCoordinates.CoordConvert.WGS84toUnity(new Vector3WGS(coordinates[i], coordinates[(i + 1)], bobEindPunt + Config.activeConfiguration.zeroGroundLevelY));
sewerPipeSpawner.CreateSewerLine(startpoint, endpoint, diameter, tile.gameObject);
}
}
StartCoroutine(GetSewerManholesInBoundingBox(tileChange, boundingBoxMinimum, boundingBoxMaximum, tile, callback));
}
else
{ //callback if weberror
Debug.Log("sewerlinedata not found");
activeCount--;
callback(tileChange);
}
yield return(null);
}
//[UnityTest]
public IEnumerator TestApiPdok()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Pdok;
Config.activeConfiguration.sewerPipesWfsUrl = "https://geodata.nationaalgeoregister.nl/rioned/gwsw/wfs/v1_0?SERVICE=WFS&language=eng&SERVICE=WFS&REQUEST=GetFeature&VERSION=2.0.0&TYPENAMES=gwsw:beheer_leiding&SRSNAME=urn:ogc:def:crs:EPSG::28992&outputFormat=application/json&BBOX=";
Config.activeConfiguration.sewerManholesWfsUrl = "https://geodata.nationaalgeoregister.nl/rioned/gwsw/wfs/v1_0?SERVICE=WFS&language=eng&SERVICE=WFS&REQUEST=GetFeature&VERSION=2.0.0&TYPENAMES=gwsw:beheer_put&SRSNAME=urn:ogc:def:crs:EPSG::28992&outputFormat=application/json&BBOX=";
SewerageLayer seweragelayer = new SewerageLayer();
int Xmin = 123000;
int Ymin = 443000;
int Xmax = 145000;
int Ymax = 463000;
string url;
int counter = 0;
for (int x = Xmin; x < Xmax; x += 1000)
{
for (int y = Ymin; y < Ymax; y += 1000)
{
counter++;
url = Config.activeConfiguration.sewerPipesWfsUrl + $"{x},{y},{x + 1000},{y + 1000}";
var sewerageRequest = UnityWebRequest.Get(url);
yield return(sewerageRequest.SendWebRequest());
if (!sewerageRequest.isNetworkError && !sewerageRequest.isHttpError)
{
try
{
GeoJSON geojson = new GeoJSON(sewerageRequest.downloadHandler.text);
while (geojson.GotoNextFeature())
{
double diameter = geojson.getPropertyFloatValue(seweragelayer.DiameterString);
double bobBeginPunt = geojson.getPropertyFloatValue(seweragelayer.BobBeginPuntString);
double bobEindPunt = geojson.getPropertyFloatValue(seweragelayer.BobEindPuntString);
//var coordinates = geojson.getGeometryLineString();
//Assert.AreEqual(4, coordinates.Count);
}
}
catch (Exception e)
{
Debug.Log($"url:{url} exception:{e.Message}");
}
}
yield return(null);
}
}
}
public MigrationProject(Project project)
{
TableName = Table.Projects;
Id = project.LegacyProjectID;
ProjectId = project.LegacyProjectID;
ProjectUid = project.ProjectUID;
ProjectName = project.Name;
ProjectType = project.ProjectType;
IsDeleted = project.IsDeleted;
SubscriptionEndDate = project.SubscriptionEndDate;
DcFilename = project.CoordinateSystemFileName;
ProjectArea = GeoJSON.Area(project.GeometryWKT);
CoordinateSystemInfo = new MigrationCoordinateSystemInfo();
}
public void TestApiPdokEmpty()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Pdok;
SewerageLayer seweragelayer = new SewerageLayer();
GeoJSON geojson = new GeoJSON(testStringPdokEmpty);
int counter = 0;
while (geojson.GotoNextFeature())
{
counter++;
}
Assert.AreEqual(0, counter);
}
public void TestApiAmsterdamOne()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Amsterdam;
SewerageLayer seweragelayer = new SewerageLayer();
GeoJSON geojson = new GeoJSON(testStringAmsterdamOne);
geojson.GotoNextFeature();
double diameter = geojson.getPropertyFloatValue(seweragelayer.DiameterString);
double bobBeginPunt = geojson.getPropertyFloatValue(seweragelayer.BobBeginPuntString);
double bobEindPunt = geojson.getPropertyFloatValue(seweragelayer.BobEindPuntString);
var geom = geojson.getGeometryLineString();
Assert.AreEqual(297, diameter);
Assert.AreEqual(-1, bobBeginPunt);
Assert.AreEqual(-1.60, bobEindPunt, 0.1);
Assert.AreEqual(4, geom.Count);
}
public void TestApiPdokOneWhile()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Pdok;
SewerageLayer seweragelayer = new SewerageLayer();
GeoJSON geojson = new GeoJSON(testStringPdokOne);
while (geojson.GotoNextFeature())
{
double diameter = geojson.getPropertyFloatValue(seweragelayer.DiameterString);
double bobBeginPunt = geojson.getPropertyFloatValue(seweragelayer.BobBeginPuntString);
double bobEindPunt = geojson.getPropertyFloatValue(seweragelayer.BobEindPuntString);
var geom = geojson.getGeometryLineString();
Assert.AreEqual(800, diameter);
Assert.AreEqual(0.06, bobBeginPunt, 0.001);
Assert.AreEqual(0.05, bobEindPunt, 0.001);
Assert.AreEqual(4, geom.Count);
}
}
public void TestCoordinatesMultipleSegmentsPdok()
{
Config.activeConfiguration = new ConfigurationFile();
Config.activeConfiguration.sewerageApiType = Amsterdam3D.Sewerage.SewerageApiType.Pdok;
SewerageLayer seweragelayer = new SewerageLayer();
GeoJSON geojson = new GeoJSON(testStringMultipleSegmentPdok);
geojson.GotoNextFeature();
var geom1 = geojson.getGeometryLineString();
// Assert.AreEqual(4, geom1.Count);
Assert.AreEqual(geom1[0], 128714.08, 0.1);
Assert.AreEqual(geom1[1], 456715.91, 0.1);
Assert.AreEqual(geom1[2], 128726.92, 0.1);
Assert.AreEqual(geom1[3], 456784.05, 0.1);
geojson.GotoNextFeature();
var geom2 = geojson.getGeometryLineString();
//Assert.AreEqual(4, geom2.Count);
Assert.AreEqual(geom2[0], 129029.42, 0.1);
Assert.AreEqual(geom2[1], 456653.39, 0.1);
Assert.AreEqual(geom2[2], 129029.21, 0.1);
Assert.AreEqual(geom2[3], 456654.99, 0.1);
geojson.GotoNextFeature();
var geom3 = geojson.getGeometryLineString();
//Assert.AreEqual(4, geom2.Count);
Assert.AreEqual(geom3[0], 128995.88, 0.1);
Assert.AreEqual(geom3[1], 456709.91, 0.1);
Assert.AreEqual(geom3[2], 128980.46, 0.1);
Assert.AreEqual(geom3[3], 456704.58, 0.1);
}
public override void OnScene(bool selected)
{
#region ProgressBar
if (CourseBase.BuildSplinesCount != 0)
{
float count = CourseBase.BuildSplinesCount;
float buildLineCount = CourseBase.BuildLineSplines.Count;
float buildCount = CourseBase.BuildSplines.Count;
float progress = buildLineCount / count * 0.5f + buildCount / count * 0.5f;
string text = "Done";
if (buildLineCount != 0)
{
text = "Updating " + CourseBase.BuildLineSplines[0].name;
}
else if (buildCount != 0)
{
text = "Building " + CourseBase.BuildSplines[0].name;
}
if (EditorUtility.DisplayCancelableProgressBar("Build progress bar", text, 1.0f - progress))
{
CourseBase.BuildLineSplines.Clear();
CourseBase.BuildSplines.Clear();
CourseBase.BuildSplinesCount = 0;
}
else
{
SplineBase spline = null;
if (CourseBase.BuildLineSplines.Count != 0)
{
spline = CourseBase.BuildLineSplines[0];
}
else if (CourseBase.BuildSplines.Count != 0)
{
spline = CourseBase.BuildSplines[0];
}
Exception exception = CourseBase.DoSplineBakeStep();
if (exception != null)
{
string message = exception.Message;
if (exception.StackTrace.Contains("Poly2Tri.DTSweep.FinalizationPolygon (Poly2Tri.DTSweepContext tcx)"))
{
message = "Too big extra/shrink.";
}
if (exception.StackTrace.Contains("New points from triangulation."))
{
message = "Wrong spline shape or/and lines are crossed.";
}
if (exception.Message.Contains("stack overflow"))
{
message = "Too many vertices in one mesh.";
}
Debug.LogException(exception);
if (spline && !string.IsNullOrEmpty(message))
{
PopupToolUI.Add(message, "Focus", spline.name);
}
}
}
progressBar = true;
}
else if (GeoJSON.Exporting)
{
float progress = GeoJSON.Progress;
string text = "Done";
if (progress != 1)
{
text = "Exporting " + (progress * 100).ToString("F2") + "%";
}
if (EditorUtility.DisplayCancelableProgressBar("Export progress bar", text, progress))
{
GeoJSON.CancelExport();
}
else
{
for (int i = 0; i < 10000; ++i)
{
GeoJSON.DoExportTerrainStep();
}
}
progressBar = true;
}
else
{
if (progressBar)
{
EditorUtility.ClearProgressBar();
progressBar = false;
}
}
#endregion
if (selected)
{
OnAutoHide();
OnAutoTerrain();
Update();
if (!HideLines)
{
splineTool.OnScene(SelectedTool == Tool.SplineTool);
}
if (!HideLines)
{
plantTool.OnScene(SelectedTool == Tool.PlantTool);
}
}
OnUI(selected);
if (selected)
{
if (!ToolLocked)
{
if (LayerPanel)
{
layerTool.OnUI(true);
}
if (InfoPanel)
{
infoTool.OnUI(true);
}
if (WarningPanel)
{
popupTool.OnUI(true);
}
if (AndroidPanel)
{
androidTool.OnUI(true);
}
fileTool.OnUI(SelectedTool == Tool.FileTool);
plantTool.OnUI(SelectedTool == Tool.PlantTool);
splineTool.OnUI(SelectedTool == Tool.SplineTool);
}
HandleUtility.Repaint();
}
#region Touch
BeginUI();
if (!ToolLocked)
{
Touch(1, Screen.height / BoxSize);
}
if (SelectedTool != Tool.None)
{
Touch(Screen.width / BoxSize - 2, 1);
}
EndUI();
#endregion
#region Tooltip
if (!string.IsNullOrEmpty(GUI.tooltip))
{
string text = GUI.tooltip;
Rect rect = new Rect();
rect.x = Event.current.mousePosition.x;
rect.y = Event.current.mousePosition.y;
rect.width = GUI.skin.label.CalcSize(new GUIContent(text)).x;
rect.height = GUI.skin.label.CalcSize(new GUIContent(text)).y;
BeginUI();
MoveToPixels((int)rect.x, (int)rect.y);
SetBoxSize((int)rect.width, (int)rect.height);
Background(1, 1, 0.9f);
LabelNoOffset(text);
EndUI();
}
#endregion
}
/// <summary>
/// Write the given GeoJSON it to the given file.
/// </summary>
/// <param name="GeoJSONTask">A GeoJSON task.</param>
/// <param name="FilenameBuilder">A file name.</param>
public static Task <IEnumerable <JObject> > ToGeoJSONFileAsync(this Task <IEnumerable <JObject> > GeoJSONTask,
Func <JObject, String> FilenameBuilder)
{
return(GeoJSONTask.ContinueWith(GeoJSONTasks => GeoJSONTasks.Result.Select(GeoJSON => GeoJSON.ToFile(FilenameBuilder))));
}
private string GetMapJson(DataTable data)
{
var connectionCredentials = new bv.common.Configuration.ConnectionCredentials();
string connection = connectionCredentials.ConnectionString;
var column = new DataColumn {
DataType = typeof(SqlGeometry), ColumnName = "geom"
};
data.Columns.Add(column);
var sqlConnection = new SqlConnection(connection); sqlConnection.Open();
string lTableName = CoordinatesUtils.GetWKBTableName(data, connection);
const int srid = 4326;
string ratio = "0"; // Settlement
if (lTableName == "gisWKBRegion")
{
ratio = "50";
}
if ((lTableName == "gisWKBRayon") || (lTableName == "gisWKBDistrict"))
{
ratio = "100";
}
string strIds = string.Empty;
if (data.Rows.Count > 0)
{
strIds = String.Join(",", data.AsEnumerable().Select(x => x.Field <long>("id").ToString()).ToArray());
strIds = string.Format("idfsGeoObject in ({0}) and ", strIds);
if ((data.PrimaryKey == null) || (data.PrimaryKey.Length == 0))
{
var key = new DataColumn[1];
key[0] = data.Columns["id"];
data.PrimaryKey = key;
}
try // Try get it from precached table geomShape_4326
{
string strBatchSql = "SELECT g.idfsGeoObject as id, g.geomShape_4326 as geom FROM " + lTableName + "Ready g WHERE " + strIds + " Ratio = " + ratio;
var cmdBatch = new SqlCommand(strBatchSql, sqlConnection);
using (SqlDataReader dr = cmdBatch.ExecuteReader())
{
var resBatch = new DataTable();
resBatch.Load(dr);
if ((resBatch != null) && resBatch.Rows.Count > 0)
{
if ((resBatch.PrimaryKey == null) || (resBatch.PrimaryKey.Length == 0))
{
var resBatchKey = new DataColumn[1];
resBatchKey[0] = resBatch.Columns["id"];
resBatch.PrimaryKey = resBatchKey;
}
data.Merge(resBatch, false, MissingSchemaAction.Ignore);
}
}
}
catch (Exception /*ex*/) { /*var strErr = ex.Message;*/ }
foreach (var rEmptyGeom in data.Select("geom is null"))
{
SharpMap.Geometries.Geometry feature = null;
long id = 0;
if (rEmptyGeom["id"].ToString() != "")
{
id = Int64.Parse(rEmptyGeom["id"].ToString());
}
// Try get it as usual
feature = Extents.GetGeomById(sqlConnection, lTableName, id);
if (feature != null)
{
feature = GeometryTransform.TransformGeometry(feature, GIS_V4.Common.CoordinateSystems.SphericalMercatorCS, GIS_V4.Common.CoordinateSystems.WGS84);
var wktGeometry = new System.Data.SqlTypes.SqlChars(feature.AsText());
rEmptyGeom["geom"] = SqlGeometry.STGeomFromText(wktGeometry, srid);
}
if (feature != null)
{
SharpMap.Geometries.Point point = feature.GetBoundingBox().GetCentroid();
rEmptyGeom["x"] = point.X;
rEmptyGeom["y"] = point.Y;
}
else
{
double x, y;
if (CoordinatesUtils.GetAdminUnitCoordinates(connection, id, out x, out y))
{
rEmptyGeom["x"] = x;
rEmptyGeom["y"] = y;
}
}
}
}
sqlConnection.Close();
var ds = new DataSet();
ds.Tables.Add(data.Copy());
string json = GeoJSON.DataSetToJSON(ds);
json = json.Replace("\\r\\n", " ");
return(json);
}
public ActionResult Index(long layoutId)
{
var connectionCredentials = new bv.common.Configuration.ConnectionCredentials();
string connection = connectionCredentials.ConnectionString;
AvrServiceAccessability access = AvrServiceAccessability.Check();
if (!access.IsOk)
{
return(View("AvrServiceError", (object)access.ErrorMessage));
}
return(ObjectStorage.Using <AvrPivotViewModel, ActionResult>(viewModel =>
{
ViewBag.Title = string.Format(Translator.GetMessageString("webMapTitle"), viewModel.ViewHeader.LayoutName);
// have we anything selected in combo admin unit?
if (!string.IsNullOrEmpty(viewModel.ViewHeader.MapAdminUnitViewColumn))
{
DataSet dataSet;
string error = ChartMapHelper.TryToPrepareMapData(viewModel, out dataSet);
if (error.Length > 0)
{
return View("AvrServiceError", (object)error);
}
//TEST
for (int j = 0; j < dataSet.Tables[1].Rows.Count; j++)
{
string c_name = dataSet.Tables[1].Rows[j]["ColumnName"].ToString();
string c_new_name = dataSet.Tables[1].Rows[j]["ColumnDescription"].ToString();
c_new_name = c_new_name.TrimStart(); // Spaces in column name, comes outside
dataSet.Tables[0].Columns[c_name].ColumnName = c_new_name;
}
SharpMap.Rendering.Thematics.ITheme gradLayerTheme;
SharpMap.Rendering.Thematics.ITheme chartLayerTheme;
string gradLayerName, chartLayerName;
gis.GisInterface.GetAvrStyles(layoutId, out gradLayerName, out gradLayerTheme, out chartLayerName, out chartLayerTheme);
if (chartLayerTheme is GIS_V4.Rendering.BarChartTheme)
{
var chart_theme = (GIS_V4.Rendering.BarChartTheme)chartLayerTheme;
string chart_style = "{\"BarCharts\" : [";
for (int j = 0; j < chart_theme.BarChartItems.Count; j++)
{
var c_column = chart_theme.BarChartItems[j].ColumnName;
var c_color = HexConverter(chart_theme.BarChartItems[j].Color);
chart_style += '{' + string.Format("\"title\":\"{0}\", \"color\":\"{1}\"", c_column, c_color) + '}' + ", ";
}
chart_style += "]}";
chart_style = chart_style.Replace(", ]", "]");
ViewBag.chart_style = new HtmlString(chart_style);
}
if (gradLayerTheme is GIS_V4.Rendering.GradientTheme)
{
GIS_V4.Rendering.GradientTheme grad_theme = (GIS_V4.Rendering.GradientTheme)gradLayerTheme;
string min_value = grad_theme.Min.ToString();
string max_value = grad_theme.Max.ToString();
System.Drawing.SolidBrush min_brush = (System.Drawing.SolidBrush)((SharpMap.Styles.VectorStyle)grad_theme.MinStyle).Fill;
string min_r = min_brush.Color.R.ToString();
string min_g = min_brush.Color.G.ToString();
string min_b = min_brush.Color.B.ToString();
System.Drawing.SolidBrush max_brush = (System.Drawing.SolidBrush)((SharpMap.Styles.VectorStyle)grad_theme.MaxStyle).Fill;
string max_r = max_brush.Color.R.ToString();
string max_g = max_brush.Color.G.ToString();
string max_b = max_brush.Color.B.ToString();
ViewBag.grad_style = new HtmlString("{" + string.Format("\"type\":\"gradient\", \"min_value\":{0}, \"max_value\":{1}, \"min_color\":[{2}, {3}, {4}], \"max_color\":[{5}, {6}, {7}]", min_value, max_value, min_r, min_g, min_b, max_r, max_g, max_b) + "}");
}
if (gradLayerTheme is GIS_V4.Rendering.GraduatedTheme)
{
dataSet.Tables[0].Columns.Add("color");
dataSet.Tables[0].Columns.Add("symbol");
string grad_style = "{\"type\":\"graduated\", \"legend\" : [";
GIS_V4.Rendering.GraduatedTheme grad_theme = (GIS_V4.Rendering.GraduatedTheme)gradLayerTheme;
for (int i = 0; i < grad_theme.Rules.Count; i++)
{
string value_title = ((GIS_V4.Rendering.GraduatedTheme)gradLayerTheme).Rules[i].Title;
System.Drawing.SolidBrush value_brush = (System.Drawing.SolidBrush)((SharpMap.Styles.VectorStyle)grad_theme.Rules[i].Style).Fill;
var val_color = HexConverter(value_brush.Color);
var val_symbol = ((SharpMap.Styles.VectorStyle)grad_theme.Rules[i].Style).SymbolId;
grad_style += '{' + string.Format("\"title\":\"{0}\", \"color\":\"{1}\", \"symbol\":\"{2}\"", value_title, val_color, val_symbol) + '}' + ", ";
var dataView = dataSet.DefaultViewManager.CreateDataView(dataSet.Tables[0]);
dataView.RowFilter = grad_theme.Rules[i].Condition;
for (int j = 0; j < dataView.Count; j++)
{
dataView[j].Row["color"] = val_color;
dataView[j].Row["symbol"] = val_symbol;
}
}
grad_style += "]}";
grad_style = grad_style.Replace(", ]", "]");
ViewBag.grad_style = new HtmlString(grad_style);
}
// Space in column fix
for (int j = 0; j < dataSet.Tables[1].Rows.Count; j++)
{
string c_new_name = dataSet.Tables[1].Rows[j]["ColumnDescription"].ToString();
c_new_name = c_new_name.TrimStart(); // Spaces in column name, comes outside
dataSet.Tables[0].Columns[c_new_name].ColumnName = c_new_name.TrimStart();
dataSet.Tables[1].Rows[j]["ColumnDescription"] = c_new_name.TrimStart();
}
using (var sqlConnection = new SqlConnection(connection))
{
try
{
sqlConnection.Open();
var CountryID = EidssSiteContext.Instance.CountryID;
SharpMap.Geometries.Geometry feature = Extents.GetGeomById(sqlConnection, "gisWKBCountry", CountryID);
if (feature != null)
{
feature = GeometryTransform.TransformGeometry(feature, GIS_V4.Common.CoordinateSystems.SphericalMercatorCS, GIS_V4.Common.CoordinateSystems.WGS84);
}
SharpMap.Geometries.Point center_point = feature.GetBoundingBox().GetCentroid();
ViewBag.county_lon = center_point.X;
ViewBag.county_lat = center_point.Y;
}
catch (Exception)
{
ViewBag.county_lon = 0;
ViewBag.county_lat = 0;
}
}
//TEST
if (error.Length == 0)
{
var ds = new DataSet();
ds.Tables.Add(dataSet.Tables[1].Copy());
string json = GeoJSON.DataSetToJSON(ds);
string avr_json = GeoJSON.DataSetToJSON(ds);
ViewBag.avr_json = new HtmlString(avr_json);
string map_json = GetMapJson(dataSet.Tables[0]);
ViewBag.map_json = new HtmlString(map_json);
ViewBag.ColumnName = new HtmlString(dataSet.Tables[1].Rows[0].ItemArray[1].ToString());
ViewBag.ColumnDescription = new HtmlString(dataSet.Tables[1].Rows[0].ItemArray[1].ToString());
ViewBag.blnIsGradient = new HtmlString(dataSet.Tables[1].Rows[0].ItemArray[2].ToString());
ViewBag.gradLayerName = new HtmlString(gradLayerName);
ViewBag.chartLayerName = new HtmlString(chartLayerName);
ViewBag.blnIsChart = new HtmlString(dataSet.Tables[1].Rows[0].ItemArray[3].ToString());
ViewBag.map_localurl = Config.GetSetting("MapLocalUrl");
if (CultureInfo.CurrentUICulture.TextInfo.IsRightToLeft)
{
ViewBag.left2right = 1;
}
else
{
ViewBag.left2right = 0;
}
return View("Index", dataSet);
}
return View("AvrServiceError", (object)error);
}
return View();
}, Session.SessionID, layoutId, ViewLayoutController.StoragePrefix));
}
public override void OnUI(bool selected)
{
if (selected == false)
{
return;
}
BeginUI();
Move(1, 0);
Background(4);
if (MainToolUI.InfoPanel)
{
SetColor(Green);
}
if (Button(courseInfoTexture))
{
MainToolUI.InfoPanel = !MainToolUI.InfoPanel;
}
SetColor();
Move(1, 0);
if (Button(helpTexture))
{
Application.OpenURL("http://perfectparallel.com/documentation");
}
#region Version
Move(0, 0.47f);
SetColor(Black);
MovePixels(1, 1);
Label(CourseBase.version, 1, 1, EditorStyles.boldLabel);
MovePixels(-1, -1);
SetColor();
Label(CourseBase.version, 1, 1, EditorStyles.boldLabel);
Move(0, -0.47f);
#endregion
SetColor();
Move(1, 0);
if (Button(androidTexture))
{
MainToolUI.AndroidPanel = !MainToolUI.AndroidPanel;
}
Move(1, 0);
EditorGUI.BeginDisabledGroup(!PlatformBase.IO.IsEditor);
if (PopupToolUI.Count() != 0)
{
SetColor(Yellow);
}
if (Button(new GUIContent(buildTexture, (PopupToolUI.Count() != 0 ? "Click to build it anyway" : null))))
{
if (PopupToolUI.Count() == 0)
{
CheckCourse();
if (PopupToolUI.Count() == 0)
{
CourseBase.BuildCourse((int)Utility.FromName <UnityEditor.BuildTarget>(BuildTarget));
}
}
else
{
CourseBase.BuildCourse((int)Utility.FromName <UnityEditor.BuildTarget>(BuildTarget));
}
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(MainToolUI.NormalMode);
if (!MainToolUI.NormalMode || BuildTarget != UnityEditor.BuildTarget.WebPlayerStreamed.ToString())
{
Move(1.3f, 0.35f);
Background(2.0f, 0.35f);
Background(2.0f, 0.35f);
BuildTarget = EditorGUI.EnumPopup(GetRect(2.0f, 1.0f), Utility.FromName <UnityEditor.BuildTarget>(BuildTarget)).ToString();
Color color = GUI.color;
SetColor(Black);
Move(-0.45f, -0.15f);
MovePixels(1, 1);
Label("►", 3, 3, EditorStyles.largeLabel);
MovePixels(-1, -1);
SetColor();
GUI.color = color;
Move(-0.01f, 0.01f);
Label("►", 3, 3, EditorStyles.largeLabel);
Move(-0.05f, -0.6f);
}
EditorGUI.EndDisabledGroup();
SetColor();
Move(1, 0);
Move(3, 0);
EditorGUI.BeginDisabledGroup(!PlatformBase.IO.IsEditor);
if (!MainToolUI.CommunityMode)
{
Background(2);
if (Button(importTexture))
{
string path = PlatformBase.Editor.OpenFileDialog("Load .geojson", PlatformBase.IO.CoursesPath, "geojson");
if (!string.IsNullOrEmpty(path))
{
GeoJSON.ImportSplines(path);
}
}
Move(1, 0);
if (Button(exportTexture))
{
string path = PlatformBase.Editor.SaveFileDialog("Save .geojson", PlatformBase.IO.CoursesPath, "", "geojson");
if (!string.IsNullOrEmpty(path))
{
GeoJSON.ExportSplines(path);
}
}
Move(1, 0);
Background(4);
Label("Export Terrain Step", 2.7f);
Move(0, 0.35f);
ExportTerrainStep = FloatSlider(ExportTerrainStep, 0.01f, 10.0f, 3.0f, 0.6f);
Move(0, -0.35f);
Move(3, 0);
if (Button(terrainTexture))
{
string path = PlatformBase.Editor.SaveFileDialog("Save .bil", PlatformBase.IO.CoursesPath, "", "bil");
if (!string.IsNullOrEmpty(path))
{
GeoJSON.ExportTerrain(path, ExportTerrainStep);
}
}
Move(1, 0);
}
EditorGUI.EndDisabledGroup();
EndUI();
}
private void StartConverting(string assetPath)
{
if (GenerateImage == false && GenerateBinary == false && GenerateGeoJSON == false && GenerateHistogram == false)
{
Debug.Log("Nothing to do");
return;
}
IsProcessing = true;
try
{
using (StreamReader sr = new StreamReader(assetPath))
{
bool isReadingHeader = false;
string headerString = "";
string[] allLines = File.ReadAllLines(assetPath);
int currentLineIndex = 0;
for (int i = 0; i < HeaderMaxLines; i++)
{
string line = allLines[currentLineIndex];
currentLineIndex++;
if (line.Length == 0)
{
continue;
}
if (line[0] == '!')
{
continue;
}
if (line[0] == '@')
{
if (isReadingHeader)
{
break;
}
isReadingHeader = true;
}
if (isReadingHeader)
{
headerString += line;
headerString += ',';
}
}
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
// Header DataType ColumnCount ? NoDataValue ? ? ? ColumnCount RowCount RowMin RowMax ColumnMin ColumnMax ? ColumnSize RowSize
string[] splittedHeader = headerString.Split(',');
DataHeader header = new DataHeader();
header.DataType = splittedHeader[1]; //1
header.NoDataValue = float.Parse(splittedHeader[4].Replace('.', ',')); //4
header.ColumnCount = int.Parse(splittedHeader[8]); //8
header.RowCount = int.Parse(splittedHeader[9]); //9
header.RowMin = float.Parse(splittedHeader[10].Replace('.', ',')); //10
header.RowMax = float.Parse(splittedHeader[11].Replace('.', ',')); //11
header.ColumnMin = float.Parse(splittedHeader[12].Replace('.', ',')); //12
header.ColumnMax = float.Parse(splittedHeader[13].Replace('.', ',')); //13
header.ColumnSize = float.Parse(splittedHeader[15].Replace('.', ',')); //15
header.RowSize = float.Parse(splittedHeader[16].Replace('.', ',')); //16
char[] separator = new char[] { ' ' };
float[] floatArray = new float[header.ColumnCount * header.RowCount];
int currentElement = 0;
DateTime startTime = DateTime.UtcNow;
DateTime time = startTime;
float step = 100000;
float minValue = float.MaxValue;
float maxValue = float.MinValue;
while (currentElement < floatArray.Length && IsProcessing)
{
string line = allLines[currentLineIndex];
currentLineIndex++;
string[] lineArray = line.Split(separator, StringSplitOptions.RemoveEmptyEntries);
foreach (string str in lineArray)
{
float value = float.Parse(str.Replace('.', ','));
if (value != header.NoDataValue)
{
if (value < minValue)
{
minValue = value;
}
if (value > maxValue)
{
maxValue = value;
}
}
floatArray[currentElement] = value;
currentElement++;
}
if (currentElement % step == 0)
{
TimeSpan timeDiff = DateTime.UtcNow - time;
time = DateTime.UtcNow;
Debug.Log("Converting progress: " + currentElement + "/" + floatArray.Length);
Debug.Log("Converting speed: " + (step / timeDiff.TotalMinutes).ToString("########") + " entries per minute");
Debug.Log("End in " + (((floatArray.Length - currentElement) / step) * timeDiff.TotalSeconds).ToString("###.##") + " seconds");
}
}
Debug.Log("Converted: " + currentElement + "/" + floatArray.Length + " entries in " + (DateTime.UtcNow - startTime).TotalSeconds.ToString("####.#") + " seconds");
Debug.Log("Min value: " + minValue);
Debug.Log("Max value: " + maxValue);
Debug.Log(" - - - - - - - - - - - - - - - - - - - - - - ");
if (GenerateBinary)
{
Debug.Log("Binary generating started");
DataHeader.Convert(header, assetPath.Split('.')[0] + ".header");
byte[] array = new byte[4 * header.ColumnCount * header.RowCount];
int index = 0;
foreach (float value in floatArray)
{
byte[] bytes = BitConverter.GetBytes(value);
for (int k = 0; k < bytes.Length; k++)
{
array[index] = bytes[k];
index++;
}
}
using (FileStream fs = File.Create(assetPath.Split('.')[0] + ".bin", 2048, FileOptions.None))
using (BinaryWriter bw = new BinaryWriter(fs))
{
bw.Write(array);
}
Debug.Log("Binary generated");
NewAssetAvailable = true;
}
if (this.GenerateHistogram)
{
Debug.Log("Histogram generating started");
int bucketSize = 100;
var histogramResult = HistogrammHelper.Bucketize(floatArray, bucketSize, header.NoDataValue);
switch (this.selectedHistogramLayer)
{
case Layers.Elevation:
layerDataAsset.elevationData = histogramResult;
layerDataAsset.elevationbucketSize = bucketSize;
break;
case Layers.Porosity:
layerDataAsset.porosityData = histogramResult;
layerDataAsset.porositybucketSize = bucketSize;
break;
case Layers.Thickness:
layerDataAsset.thicknessnData = histogramResult;
layerDataAsset.thicknessBucketSize = bucketSize;
break;
case Layers.TOC:
layerDataAsset.tocData = histogramResult;
layerDataAsset.tocBucketSize = bucketSize;
break;
case Layers.VShale:
layerDataAsset.vshaleData = histogramResult;
layerDataAsset.vshaleBucketSize = bucketSize;
break;
}
Debug.Log($"{histogramResult} {bucketSize}");
}
if (GenerateImage)
{
Debug.Log("Image generating started");
ImageWidth = header.ColumnCount;
ImageHeight = header.RowCount;
Pixels = new Color[ImageWidth * ImageHeight];
for (int i = 0; i < floatArray.Length; i++)
{
if (UseCustomRange)
{
Pixels[i] = ConvertFloatToRGB(floatArray[i], CustomBottom, CustomTop, header.NoDataValue);
}
else
{
Pixels[i] = ConvertFloatToRGB(floatArray[i], minValue, maxValue, header.NoDataValue);
}
}
IsNewImageDataAvailable = true;
}
if (GenerateGeoJSON)
{
Debug.Log("GeoJSON generating started");
int current = 0;
int currentColumn = 0;
int currentRow = 0;
GeoJSON gJSON = new GeoJSON();
foreach (float value in floatArray)
{
if (GeoJSONEntryCount != 0 && current >= GeoJSONEntryCount)
{
break;
}
currentColumn = (int)Mathf.Floor(((current / (float)header.ColumnCount) % 1) * header.ColumnCount);
currentRow = (int)Mathf.Floor(current / (float)header.ColumnCount);
current++;
if (value != header.NoDataValue)
{
GeoPoint geogr = tr.TransformUTMToGeographic(new GeoPoint((header.ColumnMin + currentColumn * header.ColumnSize) * Foot, (header.RowMin + currentRow * header.RowSize) * Foot), enumProjection.UTM13N, enumEllipsoid.WGS84);
gJSON.AddPoint(geogr.Y, geogr.X, value);
}
}
string geoJSONString = gJSON.GetJSON();
File.WriteAllText(assetPath.Split('.')[0] + ".geojson", geoJSONString);
Debug.Log("GeoJSON generated");
NewAssetAvailable = true;
}
}
}
catch (IOException e)
{
Debug.Log("The file could not be read: " + e.Message);
}
catch (FormatException e)
{
Debug.Log("Parsing error: " + e.Message);
}
catch (Exception e)
{
Debug.Log("Unknown exception: " + e.Message);
}
finally
{
IsProcessing = false;
}
}
GeoJSON IGeoJSONRepository.Add(GeoJSON item)
{
throw new NotImplementedException();
}
public IHttpActionResult GetGeoJSON(double latFrom, double longFrom)
{
//get data
var data = db.tBusinessEntities.Where(b => b.Status == 3).ToList();
var partialData = new List <BusinessEntityToPartialGeoData>();
//compute for PointToOrigin
foreach (var d in data)
{
BusinessEntityToPartialGeoData betpg = new BusinessEntityToPartialGeoData();
betpg.recNo = d.recNo;
betpg.EntityId = d.EntityId;
betpg.BusinessEntityName = d.BusinessEntityName;
betpg.BusinessEntityAddress = d.BusinessEntityAddress;
if (d.Latitude != null && d.Longitude != null)
{
betpg.Latitude = d.Latitude;
betpg.Longitude = d.Longitude;
betpg.PointsFromOrigin = HaversineFormula(latFrom, longFrom, d.Latitude ?? 0, d.Longitude ?? 0);
}
partialData.Add(betpg);
}
var sortedData = partialData.OrderBy(o => o.PointsFromOrigin);
////generate GeoJSON
GeoJSON geoJson = new GeoJSON();
List <GeoData> list = new List <GeoData>();
foreach (var d in sortedData)
{
GeoData geodata = new GeoData();
geodata.type = "Feature";
GeoDataProperties gdprop = new GeoDataProperties();
gdprop.recNo = d.recNo;
gdprop.id = d.EntityId;
gdprop.title = d.BusinessEntityName;
gdprop.description = d.BusinessEntityAddress;
geodata.properties = gdprop;
if (d.Latitude != null && d.Longitude != null)
{
GeoDataGeometry gdgeometry = new GeoDataGeometry();
double?[] coords = { d.Longitude, d.Latitude };
gdgeometry.coordinates = coords;
gdgeometry.type = "Point";
gdgeometry.PointsToOrigin = d.PointsFromOrigin;
geodata.geometry = gdgeometry;
}
list.Add(geodata);
}
geoJson.features = list;
geoJson.type = "FeatureCollection";
return(Json(geoJson));
}
bool IGeoJSONRepository.Update(GeoJSON item)
{
throw new NotImplementedException();
}
IEnumerator GetSewerLinesInBoundingBox(TileChange tileChange, Tile tile, Vector3RD boundingBoxMinimum, Vector3RD boundingBoxMaximum, System.Action <TileChange> callback = null)
{
yield return(new WaitForEndOfFrame());
var ownCoroutine = tile.runningCoroutine;
yield return(new WaitUntil(() => CoroutineSlotsAvailable()));
coroutinesWaiting[ownCoroutine] = false;
string escapedUrl = Config.activeConfiguration.sewerPipesWfsUrl;
escapedUrl += UnityWebRequest.EscapeURL($"{boundingBoxMinimum.x.ToInvariant()},{boundingBoxMinimum.y.ToInvariant()},{boundingBoxMaximum.x.ToInvariant()},{boundingBoxMaximum.y.ToInvariant()}");
var sewerageRequest = UnityWebRequest.Get(escapedUrl);
tile.runningWebRequest = sewerageRequest;
yield return(sewerageRequest.SendWebRequest());
tile.runningWebRequest = null;
if (!sewerageRequest.isNetworkError && !sewerageRequest.isHttpError)
{
GeoJSON customJsonHandler = new GeoJSON(sewerageRequest.downloadHandler.text);
yield return(null);
Vector3 startpoint;
Vector3 endpoint;
int parseCounter = 0;
while (customJsonHandler.GotoNextFeature())
{
parseCounter++;
if ((parseCounter % maxParsesPerFrame) == 0)
{
yield return(null);
}
double diameter = customJsonHandler.getPropertyFloatValue(DiameterString);
double bobBeginPunt = customJsonHandler.getPropertyFloatValue(BobBeginPuntString);
List <double> coordinates = customJsonHandler.getGeometryLineString();
endpoint = GetUnityPoint(coordinates[0], coordinates[1], bobBeginPunt + Config.activeConfiguration.zeroGroundLevelY);
for (int i = 2; i < coordinates.Count; i += 2)
{
startpoint = endpoint;
double bobEindPunt = customJsonHandler.getPropertyFloatValue(BobEindPuntString);
endpoint = GetUnityPoint(coordinates[i], coordinates[(i + 1)], bobEindPunt + Config.activeConfiguration.zeroGroundLevelY);
sewerPipeSpawner.CreateSewerLine(startpoint, endpoint, diameter, tile.gameObject);
}
}
yield return(GetSewerManholesInBoundingBox(tileChange, boundingBoxMinimum, boundingBoxMaximum, tile, callback));
}
else
{ //callback if weberror
Debug.Log("sewerlinedata not found");
callback(tileChange);
}
if (coroutinesWaiting.ContainsKey(ownCoroutine))
{
coroutinesWaiting.Remove(ownCoroutine);
}
yield return(null);
}
