private static IEnumerable <Feature> GetFeatures([CanBeNull] BasicFeatureLayer layer,
[NotNull] List <long> oids,
bool recycling = false)
{
if (layer == null)
{
yield break;
}
// TODO: Use layer search (there might habe been an issue with recycling?!)
var featureClass = layer.GetTable();
var filter = new QueryFilter
{
WhereClause =
$"{featureClass.GetDefinition().GetObjectIDField()} IN ({StringUtils.Concatenate(oids, ", ")})"
};
filter.OutputSpatialReference = layer.GetSpatialReference();
foreach (var feature in GdbQueryUtils.GetFeatures(featureClass, filter, recycling))
{
yield return(feature);
}
}
protected override async void OnClick()
{
SharedFunctions.Log("Starting To Create Reservoir Polygons");
DateTime startTime = DateTime.Now;
surfaces = new List <ReservoirSurface>();
try
{
await Project.Current.SaveEditsAsync();
await QueuedTask.Run(async() =>
{
if (!SharedFunctions.LayerExists("DamCandidates") || !SharedFunctions.LayerExists("Contours"))
{
return;
}
damLayer = MapView.Active.Map.FindLayers("DamCandidates").FirstOrDefault() as BasicFeatureLayer;
contourLayer = MapView.Active.Map.FindLayers("Contours").FirstOrDefault() as BasicFeatureLayer;
SpatialReference = damLayer.GetSpatialReference();
reservoirSurfacesLayer = await CreatePolygonFeatureClass("ReservoirSurfaces");
ConstructPolygons();
});
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
finally
{
DateTime endTime = DateTime.Now;
SharedFunctions.Log("Analysed in " + (endTime - startTime).TotalSeconds.ToString() + " seconds");
}
}
protected override async void OnClick()
{
SharedFunctions.Log("Search for candidate dams started");
pointsIntervalOnContour = Convert.ToInt32(Parameter.PointIntervalBox.Text);
DateTime startTime = DateTime.Now;
chosenCandidates = new List <CandidateDam>();
PotentialCandidates = 0;
var pd = new ProgressDialog("Search for candidate dams", "Canceled", 100, false);
cps = new CancelableProgressorSource(pd);
cps.Progressor.Max = 100;
PointsAnalyzed = 0;
TotalPointsCount = 0;
try
{
await Project.Current.SaveEditsAsync();
BasicFeatureLayer layer = null;
await QueuedTask.Run(async() =>
{
if (!SharedFunctions.LayerExists("ContourPoints"))
{
return;
}
CancellationToken ctoken = new CancellationToken();
//create line feature layer if it does not exist
BasicFeatureLayer damCandidatesLayer = await CreateDamFeatureClass("DamCandidates");
var contourPointsLayer = MapView.Active.Map.FindLayers("ContourPoints").FirstOrDefault();
layer = contourPointsLayer as BasicFeatureLayer;
// store the spatial reference of the current layer
SpatialReference = layer.GetSpatialReference();
//Cursor for selected points
RowCursor cursor = layer.GetSelection().Search();
//If no selection was set, use full points layer
if (layer.GetSelection().GetCount() == 0)
{
cursor = layer.Search();
}
Dictionary <int, SortedDictionary <int, SortedDictionary <long, MapPoint> > > contourHeights = new Dictionary <int, SortedDictionary <int, SortedDictionary <long, MapPoint> > >();
cps.Progressor.Status = "Loading ContourPoints into memory";
SharedFunctions.Log("Loading all ContourPoints into memory");
while (cursor.MoveNext())
{
if (ctoken.IsCancellationRequested)
{
SharedFunctions.Log("Canceled");
return;
}
using (Row row = cursor.Current)
{
var point = row[1] as MapPoint;
var pointID = (int)row[0];
var contourHeight = (int)(double)row[4];
var contourID = (int)row[2];
if (!ContourLengths.ContainsKey(contourID))
{
ContourLengths.Add(contourID, (double)row["Shape_Length"]);
}
if (!contourHeights.ContainsKey((int)contourHeight))
{
contourHeights.Add((int)contourHeight, new SortedDictionary <int, SortedDictionary <long, MapPoint> >());
}
if (!contourHeights[contourHeight].ContainsKey((int)contourID))
{
contourHeights[contourHeight].Add((int)contourID, new SortedDictionary <long, MapPoint>());
}
contourHeights[contourHeight][(int)contourID].Add(pointID, point);
TotalPointsCount++;
}
}
cps.Progressor.Status = "Analyze Contours";
SharedFunctions.Log("Analyze Contours");
bool multiThreading = (Parameter.MultiThreadingBox == null || !Parameter.MultiThreadingBox.IsChecked.HasValue || Parameter.MultiThreadingBox.IsChecked.Value);
if (multiThreading)
{
HeightsToProcess = contourHeights.Keys.ToList();
int ThreadCount = Math.Min(HeightsToProcess.Count, Environment.ProcessorCount);
SharedFunctions.Log("Divided work into " + ThreadCount + " threads...");
await Task.WhenAll(Enumerable.Range(1, ThreadCount).Select(c => Task.Run(
() =>
{
while (HeightsToProcess.Count > 0) // && !ctoken.IsCancellationRequested)
{
int height = -1;
lock (HeightsToProcess)
{
height = HeightsToProcess.FirstOrDefault();
if (height != 0)
{
HeightsToProcess.Remove(height);
}
}
if (height != -1)
{
var calc = new Dictionary <int, SortedDictionary <int, SortedDictionary <long, MapPoint> > >();
calc.Add(height, contourHeights[height]);
AnalyseContourHeights(calc, ctoken);
}
}
}
, ctoken))
);
}
else
{
//Single Thread:
AnalyseContourHeights(contourHeights, ctoken);
}
cps.Progressor.Status = "Saving all " + chosenCandidates.Count + " candidates";
SharedFunctions.Log("Saving all " + chosenCandidates.Count + " candidates");
foreach (var candidate in chosenCandidates)
{
if (ctoken.IsCancellationRequested)
{
SharedFunctions.Log("Canceled");
return;
}
//Create coordinates for Polyline Feature with height ContourHeight + 5 Meters!
List <Coordinate3D> coordinates = new List <Coordinate3D>()
{
new Coordinate3D(candidate.StartPoint.X, candidate.StartPoint.Y, candidate.ContourHeight + 5),
new Coordinate3D(candidate.EndPoint.X, candidate.EndPoint.Y, candidate.ContourHeight + 5)
};
//save all selected candidates into the db
var attributes = new Dictionary <string, object>
{
{ "Shape", PolylineBuilder.CreatePolyline(coordinates) },
{ "ContourID", (long)candidate.ContourID },
{ "StartPointID", (long)candidate.StartPointID },
{ "EndPointID", (long)candidate.EndPointID },
{ "ContourHeight", (short)candidate.ContourHeight },
{ "LengthRating", (float)candidate.Rating },
{ "DistanceOnLine", (long)candidate.DistanceOnLine },
{ "Length", (short)candidate.Length },
{ "StartPointDistance", (long)candidate.StartPointDistance },
{ "EndPointDistance", (long)candidate.EndPointDistance },
{ "DamSpansContourStart", (short)(candidate.DamSpansContourStart ? 1 : 0) }
};
var editOp = new EditOperation()
{
Name = "Create dam candidate", SelectNewFeatures = false
};
editOp.Create(damCandidatesLayer, attributes);
////Execute the operations
editOp.Execute();
}
}, cps.Progressor);
//save all edits
await Project.Current.SaveEditsAsync();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
finally
{
DateTime endTime = DateTime.Now;
SharedFunctions.Log("Analysed " + PotentialCandidates.ToString("N0") + " candidates ( " + chosenCandidates.Count.ToString("N0") + " selected) in " + (endTime - startTime).TotalSeconds.ToString("N") + " seconds");
}
}
/// <summary>
/// Write rhino object to ArcGIS feature layer
/// </summary>
/// <param name="mapLayer"></param>
/// <param name="ro"></param>
public static async void ThrowItOverTheFence(BasicFeatureLayer mapLayer, RhinoObject ro, RhinoDoc rhinoDoc)
{
Mesh mesh = null;
var createOperation = new EditOperation();
var projection = mapLayer.GetSpatialReference();
var origin = getOrigin(rhinoDoc);
switch (ro.Geometry.ObjectType)
{
case ObjectType.Point:
{
Point pt = ro.Geometry as Point;
MapPoint mp = ptToGis(pt.Location, origin);
createOperation.Create(mapLayer, mp);
await createOperation.ExecuteAsync();
break;
}
case ObjectType.Surface:
{
Surface srf = ro.Geometry as Surface;
if (!srf.IsPlanar())
{
Console.Out.WriteLine($"Unable to send non-planar surfaces: Guid: ${ro.Id}");
break;
}
goto case ObjectType.Brep;
}
case ObjectType.Curve:
{
Curve c = ro.Geometry as Curve;
var ptList = getPointsFromCurves(new List <Curve>()
{
c
});
var gisPts = ptList.Select(p => ptToGis(p, origin)).ToList();
var polyline = PolylineBuilder.CreatePolyline(gisPts, projection);
createOperation.Create(mapLayer, polyline);
await createOperation.ExecuteAsync();
break;
}
case ObjectType.Brep:
{
Brep brep = ro.Geometry as Brep;
if (brep.IsSolid)
{
mesh = Mesh.CreateFromBrep(brep, MeshingParameters.Default)[0];
goto case ObjectType.Mesh;
}
else
{
var crvs = new List <Curve>();
foreach (BrepEdge ed in brep.Edges)
{
crvs.Add(ed.EdgeCurve);
}
var pts = getPointsFromCurves(crvs);
var gisPts = pts.Select(p => ptToGis(p, origin)).ToList();
var polygon = new PolygonBuilder(gisPts).ToGeometry();
createOperation.Create(mapLayer, polygon);
await createOperation.ExecuteAsync();
break;
}
}
case ObjectType.Extrusion:
{
mesh = (ro.Geometry as Extrusion).GetMesh(MeshType.Default);
goto case ObjectType.Mesh;
}
case ObjectType.Mesh:
{
mesh = mesh ?? ro.Geometry as Mesh;
break;
}
default:
{
Console.Out.WriteLine($"Unable to send geometry type: ${ro.Geometry.ObjectType}");
break;
}
}
}