/// <summary>
/// This method gets a world extent for holding the entire OpenStreed map.
/// </summary>
/// <returns></returns>
protected override RectangleShape GetBoundingBoxCore()
{
RectangleShape bbox = null;
switch (Projection)
{
case Layers.WorldMapKitProjection.SphericalMercator:
bbox = MapUtils.GetDefaultMaxExtent(GeographyUnit.Meter);
break;
default: bbox = MapUtils.GetDefaultMaxExtent(GeographyUnit.DecimalDegree);
break;
}
return(bbox);
}
protected override void OnTrackEnded(TrackEndedTrackInteractiveOverlayEventArgs e)
{
isTracking = false;
base.OnTrackEnded(e);
if (TrackShapeLayer.InternalFeatures.Count != 0)
{
Collection <Feature> features = new Collection <Feature>();
Collection <ErrorFeatureInfo> errorInfo = new Collection <ErrorFeatureInfo>();
Dictionary <string, Collection <Feature> > currentSelectedFeatures = new Dictionary <string, Collection <Feature> >();
foreach (var trackedFeature in TrackShapeLayer.InternalFeatures)
{
Feature currentTrackedFeature = trackedFeature;
if (currentTrackedFeature.CanMakeValid && !currentTrackedFeature.IsValid())
{
currentTrackedFeature = currentTrackedFeature.MakeValid();
}
if (currentTrackedFeature.GetShape() != null && currentTrackedFeature.GetWellKnownType() == WellKnownType.Point)
{
PointShape trackedPoint = (PointShape)currentTrackedFeature.GetShape();
double resolution = MapArguments.CurrentResolution;
currentTrackedFeature = new Feature(new RectangleShape(trackedPoint.X - tolerance * resolution,
trackedPoint.Y + tolerance * resolution,
trackedPoint.X + tolerance * resolution,
trackedPoint.Y - tolerance * resolution).GetWellKnownBinary(), currentTrackedFeature.Id);
}
else if (currentTrackedFeature.GetShape() != null && currentTrackedFeature.GetWellKnownType() == WellKnownType.Line)
{
var toleranceDistance = MapUtils.GetResolutionFromScale(MapArguments.CurrentScale, GeographyUnit.Meter) * tolerance;
try
{
currentTrackedFeature = currentTrackedFeature.Buffer(toleranceDistance, MapArguments.MapUnit, DistanceUnit.Meter);
}
catch { }
}
foreach (var queryingFeatureLayer in TargetFeatureLayers.Where(l => FilteredLayers.Contains(l)))
{
IEnumerable <Feature> queriedFeatures = new Collection <Feature>();
if (currentTrackedFeature.GetShape() != null)
{
bool isClosed = false;
Monitor.Enter(queryingFeatureLayer);
if (!queryingFeatureLayer.IsOpen)
{
isClosed = true;
queryingFeatureLayer.Open();
}
try
{
Func <Feature, bool, Func <Feature, bool>, IEnumerable <Feature> > processSpatialQueryFunc
= new Func <Feature, bool, Func <Feature, bool>, IEnumerable <Feature> >((tmpTrackedFeature, filter, spatialQueryFunc) =>
{
var bbox = tmpTrackedFeature.GetBoundingBox();
Collection <Feature> featuresInsideOfBBox = null;
if (filter)
{
featuresInsideOfBBox = queryingFeatureLayer.QueryTools.GetFeaturesIntersecting(bbox, queryingFeatureLayer.GetDistinctColumnNames());
}
else
{
featuresInsideOfBBox = queryingFeatureLayer.QueryTools.GetAllFeatures(queryingFeatureLayer.GetDistinctColumnNames());
}
var featuresToProcessing = featuresInsideOfBBox.AsParallel().Where(featureToValidate =>
{
if (featureToValidate.IsValid())
{
return(true);
}
else
{
errorInfo.Add(new ErrorFeatureInfo {
FeatureId = featureToValidate.Id, Message = "Invalid feature"
});
return(false);
}
}).ToArray();
var resultQueriedFeatures = new Collection <Feature>();
foreach (var tmpFeature in featuresToProcessing)
{
var validFeature = MakeFeatureValidate(tmpFeature);
if (spatialQueryFunc(validFeature))
{
resultQueriedFeatures.Add(validFeature);
}
}
return(resultQueriedFeatures.GetVisibleFeatures(queryingFeatureLayer.ZoomLevelSet, MapArguments.CurrentExtent, MapArguments.ActualWidth, MapArguments.MapUnit));
});
currentTrackedFeature = currentTrackedFeature.MakeValid();
switch (spatialQueryMode)
{
case SpatialQueryMode.Touching:
queriedFeatures = processSpatialQueryFunc(currentTrackedFeature, true, tmpFeature
=> currentTrackedFeature.GetShape().Intersects(tmpFeature));
break;
case SpatialQueryMode.CompletelyContained:
queriedFeatures = processSpatialQueryFunc(currentTrackedFeature, true, tmpFeature
=> currentTrackedFeature.GetShape().Contains(tmpFeature));
break;
case SpatialQueryMode.Intersecting:
queriedFeatures = processSpatialQueryFunc(currentTrackedFeature, true, tmpFeature
=> currentTrackedFeature.GetShape().Intersects(tmpFeature));
break;
case SpatialQueryMode.Nearest:
queriedFeatures = queryingFeatureLayer.QueryTools.GetFeaturesNearestTo(currentTrackedFeature, GeographyUnit.DecimalDegree, 1, queryingFeatureLayer.GetDistinctColumnNames());
break;
case SpatialQueryMode.NotTouching:
queriedFeatures = processSpatialQueryFunc(currentTrackedFeature, false, tmpFeature
=> tmpFeature.GetShape().IsDisjointed(currentTrackedFeature));
break;
}
}
catch (Exception ex) { System.Windows.Forms.MessageBox.Show(ex.Message, "Invalid Features", MessageBoxButtons.OK, MessageBoxIcon.Error); }
if (isClosed)
{
queryingFeatureLayer.Close();
}
Monitor.Exit(queryingFeatureLayer);
foreach (var feature in queriedFeatures)
{
feature.Tag = queryingFeatureLayer;
features.Add(feature);
}
}
}
}
if (errorInfo.Count > 0)
{
System.Windows.Forms.MessageBox.Show(Resources.InvalidFeatures, "Invalid Features", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
TrackShapeLayer.InternalFeatures.Clear();
features = new Collection <Feature>(RenameFeatures(features).GroupBy(f => f.Id).Select(g => g.FirstOrDefault()).Where(f => f != null).ToList());
switch (selectionMode)
{
case SelectionMode.None:
UsingFeatureLayer(HighlightFeatureLayer, (layer) =>
{
layer.InternalFeatures.Clear();
foreach (var feature in features)
{
//if (!feature.ColumnValues.ContainsKey(featureIdColumnName))
//{
// //string featureIdColumn = LayerPluginHelper.GetFeatureIdColumn(ownerFeatureLayer);
// //if (feature.ColumnValues.ContainsKey(featureIdColumn))
// //{
// // header = feature.ColumnValues[featureIdColumn];
// //}
// string featureId = feature.Id;
// if (featureId.Contains(FeatureIdSeparator))
// {
// featureId = featureId.Split(new string[] { FeatureIdSeparator }, StringSplitOptions.RemoveEmptyEntries)[0];
// }
// feature.ColumnValues.Add(featureIdColumnName, featureId);
//}
layer.EditTools.Add(feature);
}
});
break;
case SelectionMode.Added:
UsingFeatureLayer(HighlightFeatureLayer, (layer) =>
{
ToggleExistingFeatures(features);
foreach (var feature in features)
{
if (!layer.InternalFeatures.Contains(feature))
{
layer.EditTools.Add(feature);
}
}
});
break;
case SelectionMode.Subtract:
UsingFeatureLayer(HighlightFeatureLayer, (layer) =>
{
foreach (var feature in features)
{
if (layer.InternalFeatures.Contains(feature))
{
layer.EditTools.Delete(feature.Id);
}
}
});
break;
}
this.selectionMode = SelectionMode.None;
OnFeatureSelected(this, new EventArgs());
}
}
