private bool CheckIsBuildSync(FeatureLayer featureLayer)
{
var uri = layerPlugin.GetUri(featureLayer);
if (uri != null)
{
string pathFileName = uri.LocalPath;
SimpleShapeType shapeType = layerPlugin.GetFeatureSimpleShapeType(featureLayer);
if (shapeType != SimpleShapeType.Unknown)
{
if (shapeType == SimpleShapeType.Point)
{
bool isSync = true;
featureLayer.SafeProcess(() =>
{
isSync = featureLayer.QueryTools.GetCount() < maxCountForSyncBuildingPoints;
});
return(isSync);
}
else
{
return(FileSizeLessOrEqualThanSyncLimit(pathFileName));
}
}
else
{
return(FileSizeLessOrEqualThanSyncLimit(pathFileName));
}
}
else
{
return(false);
}
}
public static SimpleShapeType GetWellKnownType(FeatureLayer featureLayer)
{
SimpleShapeType type = SimpleShapeType.Unknown;
if (featureLayer != null)
{
var featureLayerPlugin = GisEditor.LayerManager.GetLayerPlugins(featureLayer.GetType()).FirstOrDefault() as FeatureLayerPlugin;
type = featureLayerPlugin.GetFeatureSimpleShapeType(featureLayer);
}
return(type);
}
protected virtual SimpleShapeType GetFeatureSimpleShapeTypeCore(FeatureLayer featureLayer)
{
SimpleShapeType result = SimpleShapeType.Unknown;
FeatureLayerPlugin plugin = GetLayerPlugins(featureLayer.GetType()).OfType <FeatureLayerPlugin>().FirstOrDefault();
if (plugin != null)
{
result = plugin.GetFeatureSimpleShapeType(featureLayer);
}
return(result);
}
protected override SimpleShapeType GetFeatureSimpleShapeTypeCore(FeatureLayer featureLayer)
{
SimpleShapeType result = SimpleShapeType.Unknown;
ShapeFileFeatureLayer shapeFileFeatureLayer = featureLayer as ShapeFileFeatureLayer;
bool isDataSourceAvailable = DataSourceResolveTool.IsDataSourceAvailable(featureLayer);
if (shapeFileFeatureLayer != null && isDataSourceAvailable)
{
ShapeFileType shapeFileType = ShapeFileType.Null;
shapeFileFeatureLayer.SafeProcess(()
=> shapeFileType = shapeFileFeatureLayer.GetShapeFileType());
switch (shapeFileType)
{
case ShapeFileType.Point:
case ShapeFileType.PointZ:
case ShapeFileType.Multipoint:
case ShapeFileType.PointM:
case ShapeFileType.MultipointM:
result = SimpleShapeType.Point;
break;
case ShapeFileType.Polyline:
case ShapeFileType.PolylineZ:
case ShapeFileType.PolylineM:
case ShapeFileType.Multipatch:
result = SimpleShapeType.Line;
break;
case ShapeFileType.Polygon:
case ShapeFileType.PolygonM:
case ShapeFileType.PolygonZ:
result = SimpleShapeType.Area;
break;
}
}
return(result);
}
private LegendImporterItemViewModel GenerateLayerItem(FeatureLayer featureLayer)
{
SimpleShapeType shpType = SimpleShapeType.Area;
var featureLayerPlugin = GisEditor.LayerManager.GetLayerPlugins(featureLayer.GetType()).FirstOrDefault() as FeatureLayerPlugin;
if (featureLayerPlugin != null)
{
featureLayerPlugin.GetFeatureSimpleShapeType(featureLayer);
}
ImageSource imageSource = GetIconSource("pointShp.png");
switch (shpType)
{
case SimpleShapeType.Line:
imageSource = GetIconSource("lineShp.png");
break;
case SimpleShapeType.Area:
imageSource = GetIconSource("areaShp.png");
break;
default:
break;
}
LegendImporterItemViewModel layerLegendImporterItem = new LegendImporterItemViewModel
{
Text = featureLayer.Name,
IconSource = imageSource,
Level = 0
};
layerLegendImporterItem.PropertyChanged += LayerLegendImporterItemPropertyChanged;
return(layerLegendImporterItem);
}
private IEnumerable <Feature> StandardClip(FeatureLayer featureLayer, IEnumerable <Feature> features)
{
lock (featureLayer)
{
Collection <Feature> results = new Collection <Feature>();
#region replace project to null
bool isOpen = false;
Proj4ProjectionInfo projectionInfo = featureLayer.GetProj4ProjectionInfo();
if (projectionInfo != null && projectionInfo.CanProject)
{
if (featureLayer.IsOpen)
{
featureLayer.Close();
projectionInfo.Close();
isOpen = true;
}
featureLayer.FeatureSource.Projection = null;
}
#endregion replace project to null
Collection <Feature> tmpFeatures = new Collection <Feature>();
if (projectionInfo != null && projectionInfo.CanProject)
{
projectionInfo.Open();
foreach (var item in features)
{
tmpFeatures.Add(projectionInfo.ConvertToInternalProjection(item));
}
projectionInfo.Close();
}
else
{
tmpFeatures = new Collection <Feature>(features.ToList());
}
if (!featureLayer.IsOpen)
{
featureLayer.Open();
}
List <Feature> tmpSourceFeatures = featureLayer.FeatureSource.GetFeaturesInsideBoundingBox(ExtentHelper.GetBoundingBoxOfItems(tmpFeatures), featureLayer.GetDistinctColumnNames()).Select(f => f.MakeValidIfCan()).ToList();
Collection <Feature> sourceFeatures = new Collection <Feature>(tmpSourceFeatures);
if (projectionInfo != null)
{
featureLayer.FeatureSource.Projection = projectionInfo.Projection;
if (isOpen)
{
featureLayer.Open();
}
}
SimpleShapeType simpleShapeType = SimpleShapeType.Unknown;
var shapeAdapter = GisEditor.LayerManager.GetLayerPlugins(featureLayer.GetType()).FirstOrDefault() as FeatureLayerPlugin;
if (shapeAdapter != null)
{
simpleShapeType = shapeAdapter.GetFeatureSimpleShapeType(featureLayer);
}
if (featureLayer.IsOpen)
{
featureLayer.Close();
}
int index = 1;
int count = sourceFeatures.Count;
if (simpleShapeType == SimpleShapeType.Point)
{
return(StandardClipPoints(sourceFeatures, tmpFeatures));
}
else if (simpleShapeType == SimpleShapeType.Line)
{
StandardClipLines(tmpFeatures, results, sourceFeatures, index, count);
}
else if (simpleShapeType == SimpleShapeType.Area)
{
//MultipolygonShape areaBaseShape = AreaBaseShape.Union(GetValidFeatures(tmpFeatures));
List <AreaBaseShape> clippingAreaShapes = GetValidFeatures(tmpFeatures)
.Select(f => f.GetShape())
.OfType <AreaBaseShape>()
.ToList();
BaseShape unionResultShape = SqlTypesGeometryHelper.Union(clippingAreaShapes);
MultipolygonShape areaBaseShape = ConvertSqlQueryResultToMultiPolygonShape(unionResultShape);
foreach (var feature in sourceFeatures)
{
isCanceled = ReportProgress(index, count);
if (isCanceled)
{
break;
}
try
{
index++;
//if (areaBaseShape.Contains(feature))
if (SqlTypesGeometryHelper.Contains(areaBaseShape, feature))
{
results.Add(feature);
}
else
{
//var clippedShape = areaBaseShape.GetIntersection(feature);
AreaBaseShape targetAreaShape = feature.GetShape() as AreaBaseShape;
if (targetAreaShape != null)
{
var clippedShape = SqlTypesGeometryHelper.GetIntersection(areaBaseShape, targetAreaShape) as MultipolygonShape;
if (clippedShape != null && clippedShape.Polygons.Count > 0)
{
results.Add(new Feature(clippedShape.GetWellKnownBinary(), feature.Id, feature.ColumnValues));
}
}
}
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
HandleExceptionFromInvalidFeature(feature.Id, ex.Message);
}
}
}
else
{
throw new NotSupportedException("The ShapeFileType is not supported.");
}
Collection <Feature> convertedFeatures = new Collection <Feature>();
if (projectionInfo != null && projectionInfo.CanProject)
{
projectionInfo.Open();
foreach (var item in results)
{
convertedFeatures.Add(projectionInfo.ConvertToExternalProjection(item));
}
projectionInfo.Close();
}
else
{
convertedFeatures = new Collection <Feature>(results.ToList());
}
return(convertedFeatures);
}
}
private IEnumerable <Feature> InverseClipPoints(IEnumerable <Feature> masterFeatures, IEnumerable <Feature> clippingFeatures, SimpleShapeType simpleShapeType)
{
ConcurrentQueue <Feature> results = new ConcurrentQueue <Feature>();
ConcurrentQueue <Feature> cqMasterFeatures = new ConcurrentQueue <Feature>(masterFeatures);
int index = 1;
int count = cqMasterFeatures.Count;
if (simpleShapeType == SimpleShapeType.Point)
{
Parallel.ForEach(cqMasterFeatures, feature =>
{
isCanceled = ReportProgress(index, count);
if (isCanceled)
{
return;
}
index++;
if (!clippingFeatures.Any(f =>
{
try
{
//return f.GetShape().Intersects(feature);
return(SqlTypesGeometryHelper.Intersects(f.GetShape(), feature));
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
HandleExceptionFromInvalidFeature(feature.Id, ex.Message);
return(false);
}
}))
{
results.Enqueue(feature);
}
});
}
else
{
Parallel.ForEach(cqMasterFeatures, feature =>
{
isCanceled = ReportProgress(index, count);
if (isCanceled)
{
return;
}
index++;
MultipointShape multiPoints = feature.GetShape() as MultipointShape;
if (multiPoints != null)
{
MultipointShape resultPoints = new MultipointShape();
Parallel.ForEach(multiPoints.Points, p =>
{
if (!clippingFeatures.Any(f =>
{
try //{ return f.GetShape().Intersects(p); }
{
return(SqlTypesGeometryHelper.Intersects(f.GetShape(), p));
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
HandleExceptionFromInvalidFeature(feature.Id, ex.Message);
return(false);
}
}))
{
resultPoints.Points.Add(p);
}
});
if (resultPoints.Points.Count > 0)
{
results.Enqueue(new Feature(resultPoints.GetWellKnownBinary(), feature.Id, feature.ColumnValues));
}
}
});
}
return(results);
}
private IEnumerable <Feature> InverseClip(FeatureLayer featureLayer, IEnumerable <Feature> clippingFeatures)
{
lock (featureLayer)
{
if (!featureLayer.IsOpen)
{
featureLayer.Open();
}
Collection <Feature> results = featureLayer.FeatureSource.GetFeaturesOutsideBoundingBox(ExtentHelper.GetBoundingBoxOfItems(clippingFeatures), featureLayer.GetDistinctColumnNames());
Collection <Feature> sourceFeatures = new Collection <Feature>();
SimpleShapeType simpleShapeType = GisEditor.LayerManager.GetFeatureSimpleShapeType(featureLayer);
int index = 1;
if (simpleShapeType == SimpleShapeType.Point)
{
featureLayer.Open();
Collection <Feature> allFeatures = featureLayer.FeatureSource.GetAllFeatures(featureLayer.GetDistinctColumnNames());
featureLayer.Close();
foreach (Feature f in results)
{
allFeatures.Remove(f);
}
foreach (var f in InverseClipPoints(allFeatures, clippingFeatures, simpleShapeType))
{
results.Add(f);
}
}
else if (simpleShapeType == SimpleShapeType.Line)
{
bool isOpen = false;
Proj4ProjectionInfo projectionInfo = featureLayer.GetProj4ProjectionInfo();
//MultipolygonShape areaBaseShape = AreaBaseShape.Union(GetValidFeatures(clippingFeatures));
List <AreaBaseShape> clippingAreaShapes = GetValidFeatures(clippingFeatures)
.Select(f => f.GetShape())
.OfType <AreaBaseShape>()
.ToList();
MultipolygonShape areaBaseShape = AreaBaseShape.Union(clippingAreaShapes);
if (projectionInfo != null && projectionInfo.CanProject)
{
if (featureLayer.IsOpen)
{
featureLayer.Close();
projectionInfo.Close();
isOpen = true;
}
featureLayer.FeatureSource.Projection = null;
}
featureLayer.Open();
featureLayer.FeatureSource.GetFeaturesInsideBoundingBox(areaBaseShape.GetBoundingBox(), featureLayer.GetDistinctColumnNames()).ForEach(f => { if (!areaBaseShape.Contains(f))
{
sourceFeatures.Add(f);
}
});
int count = sourceFeatures.Count;
if (projectionInfo != null)
{
featureLayer.FeatureSource.Projection = projectionInfo.Projection;
if (isOpen)
{
featureLayer.Open();
}
}
if (featureLayer.IsOpen)
{
featureLayer.Close();
}
foreach (var feature in sourceFeatures)
{
isCanceled = ReportProgress(index, count);
if (isCanceled)
{
break;
}
index++;
try
{
//if (areaBaseShape.IsDisjointed(feature))
if (SqlTypesGeometryHelper.IsDisjointed(areaBaseShape, feature))
{
results.Add(feature);
}
else
{
MultilineShape multiLine = (MultilineShape)feature.GetShape();
MultilineShape resultShape = new MultilineShape();
foreach (LineShape lineShape in multiLine.Lines)
{
//if (areaBaseShape.IsDisjointed(lineShape))
if (SqlTypesGeometryHelper.IsDisjointed(areaBaseShape, lineShape))
{
resultShape.Lines.Add(lineShape);
}
else
{
var resultLine = lineShape.GetDifference(areaBaseShape);
foreach (var line in resultLine.Lines)
{
resultShape.Lines.Add(line);
}
}
}
if (resultShape != null && resultShape.Lines.Count > 0)
{
results.Add(new Feature(resultShape.GetWellKnownBinary(), feature.Id, feature.ColumnValues));
}
}
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
HandleExceptionFromInvalidFeature(feature.Id, ex.Message);
}
}
}
else if (simpleShapeType == SimpleShapeType.Area)
{
//MultipolygonShape areaBaseShape = AreaBaseShape.Union(GetValidFeatures(clippingFeatures));
List <AreaBaseShape> clippingAreaShapes = GetValidFeatures(clippingFeatures)
.Select(f => f.GetShape())
.OfType <AreaBaseShape>()
.ToList();
BaseShape unionResultShape = SqlTypesGeometryHelper.Union(clippingAreaShapes);
MultipolygonShape areaBaseShape = ConvertSqlQueryResultToMultiPolygonShape(unionResultShape);
bool isOpen = false;
Proj4ProjectionInfo projectionInfo = featureLayer.GetProj4ProjectionInfo();
if (projectionInfo != null && projectionInfo.CanProject)
{
if (featureLayer.IsOpen)
{
featureLayer.Close();
if (projectionInfo != null)
{
projectionInfo.Close();
}
isOpen = true;
}
featureLayer.FeatureSource.Projection = null;
}
if (!featureLayer.IsOpen)
{
featureLayer.Open();
}
featureLayer.FeatureSource.GetFeaturesInsideBoundingBox(areaBaseShape.GetBoundingBox(), featureLayer.GetDistinctColumnNames()).ForEach(f => sourceFeatures.Add(f));
if (featureLayer.IsOpen)
{
featureLayer.Close();
}
if (projectionInfo != null)
{
featureLayer.FeatureSource.Projection = projectionInfo.Projection;
if (isOpen)
{
featureLayer.Open();
}
}
int count = sourceFeatures.Count;
foreach (var feature in sourceFeatures)
{
isCanceled = ReportProgress(index, count);
if (isCanceled)
{
break;
}
index++;
try
{
//if (areaBaseShape.IsDisjointed(feature))
if (SqlTypesGeometryHelper.IsDisjointed(areaBaseShape, feature))
{
results.Add(feature);
}
else
{
//var clippedShape = ((AreaBaseShape)feature.GetShape()).GetDifference(areaBaseShape);
BaseShape differenceResultShape = SqlTypesGeometryHelper.GetDifference((AreaBaseShape)feature.GetShape(), areaBaseShape);
MultipolygonShape clippedShape = ConvertSqlQueryResultToMultiPolygonShape(differenceResultShape);
if (clippedShape != null && clippedShape.Polygons.Count > 0)
{
results.Add(new Feature(clippedShape.GetWellKnownBinary(), feature.Id, feature.ColumnValues));
}
}
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
HandleExceptionFromInvalidFeature(feature.Id, ex.Message);
}
}
}
else
{
throw new NotSupportedException("The ShapeFileType is not supported.");
}
return(results);
}
}
private void AutoGenerate()
{
if (string.IsNullOrEmpty(ColumnName))
{
System.Windows.Forms.MessageBox.Show(GisEditor.LanguageManager.GetStringResource("ValueStyleViewModelColumnCanntEmptyMessage"), "Column is Empty");
}
else
{
FeatureLayer featureLayer = RequiredValues.FeatureLayer;
FeatureLayerPlugin featureLayerPlugin = GisEditor.LayerManager.GetLayerPlugins(featureLayer.GetType()).FirstOrDefault() as FeatureLayerPlugin;
if (featureLayerPlugin == null)
{
return;
}
string selectedColumnName = ColumnName;
featureLayer.Open();
if (featureLayer.FeatureSource.CanGetCountQuickly())
{
int count = featureLayer.FeatureSource.GetCount();
if (count > 500000)
{
//MessageBoxResult result = MessageBox.Show(string.Format("{0} contains a large amount of records, it might spend too much time to process. Do you want to continue?", featureLayer.Name), "Info", MessageBoxButton.YesNo, MessageBoxImage.Information);
//if (result == MessageBoxResult.No)
//{
// return;
//}
}
}
//Collection<DistinctColumnValue> distinctColumnValues = null;
if (distinctColumnValues == null)
{
featureLayer.SafeProcess(() =>
{
distinctColumnValues = featureLayer.FeatureSource.GetDistinctColumnValues(selectedColumnName);
});
}
if (distinctColumnValues != null && distinctColumnValues.Count() > 0)
{
SimpleShapeType shpType = SimpleShapeType.Unknown;
featureLayer.SafeProcess(() =>
{
shpType = featureLayerPlugin.GetFeatureSimpleShapeType(featureLayer);
});
foreach (var columnValue in distinctColumnValues)
{
switch (shpType)
{
case SimpleShapeType.Point:
InitValueItem <PointStyle>(StyleCategories.Point, columnValue, selectedColumnName);
break;
case SimpleShapeType.Line:
InitValueItem <LineStyle>(StyleCategories.Line, columnValue, selectedColumnName);
break;
case SimpleShapeType.Area:
InitValueItem <AreaStyle>(StyleCategories.Area, columnValue, selectedColumnName);
break;
case SimpleShapeType.Unknown:
InitValueItem <Style>(StyleCategories.Composite, columnValue, selectedColumnName);
break;
}
}
var itemSourceList = ValueItems.OrderBy(itemValue => itemValue.ValueItem.Value).ToList();
ValueItems.Clear();
foreach (var item in itemSourceList.Where(i => !String.IsNullOrEmpty(i.MatchedValue)))
{
ValueItems.Add(item);
}
foreach (var item in itemSourceList.Where(i => String.IsNullOrEmpty(i.MatchedValue)))
{
ValueItems.Add(item);
}
SyncActualValueItems();
RaisePropertyChanged("ValueItems");
}
else
{
System.Windows.Forms.MessageBox.Show(GisEditor.LanguageManager.GetStringResource("ValueStyleViewModelColumnNoValueMatchedMessage"));
}
}
}
