public static int CalculateSpeceficValuesCount(string requireColumnName, string fieldValue, ShapeFileFeatureLayer featureLayer)
{
int count = 0;
if (!String.IsNullOrEmpty(requireColumnName))
{
featureLayer.SafeProcess(() =>
{
string dbfPath = Path.ChangeExtension(featureLayer.ShapePathFilename, ".dbf");
if (File.Exists(dbfPath))
{
using (GeoDbf dbf = new GeoDbf(dbfPath))
{
dbf.Open();
string orignalColumnName = requireColumnName;
for (int i = 1; i <= dbf.RecordCount; i++)
{
var currentFieldValue = dbf.ReadFieldAsString(i, orignalColumnName);
if (currentFieldValue.Equals(fieldValue, StringComparison.Ordinal))
{
count++;
}
}
dbf.Close();
}
}
});
}
return(count);
}
private void RebuildDbf(string path)
{
string dbfPath = Path.ChangeExtension(path, ".dbf");
if (File.Exists(dbfPath))
{
File.SetAttributes(dbfPath, FileAttributes.Normal);
using (GeoDbf geoDbf = new GeoDbf(dbfPath, GeoFileReadWriteMode.ReadWrite))
{
geoDbf.Open();
int columnNumber = -1;
for (int i = 1; i <= geoDbf.ColumnCount; i++)
{
string columnName = geoDbf.GetColumnName(i);
if (columnName.Equals("RECID", StringComparison.OrdinalIgnoreCase))
{
columnNumber = i;
break;
}
}
if (columnNumber > -1)
{
for (int i = 1; i <= geoDbf.RecordCount; i++)
{
geoDbf.WriteField(i, columnNumber, i);
}
}
}
}
}
public static IEnumerable <IGrouping <string, string> > GroupColumnValues(string requireColumnName
, ShapeFileFeatureLayer featureLayer)
{
Collection <string> fieldValues = new Collection <string>();
if (!String.IsNullOrEmpty(requireColumnName))
{
featureLayer.SafeProcess(() =>
{
string dbfPath = Path.ChangeExtension(featureLayer.ShapePathFilename, ".dbf");
if (File.Exists(dbfPath))
{
string orignalColumnName = requireColumnName;
using (GeoDbf dbf = new GeoDbf(dbfPath))
{
dbf.Open();
for (int i = 1; i <= dbf.RecordCount; i++)
{
fieldValues.Add(dbf.ReadFieldAsString(i, orignalColumnName));
}
dbf.Close();
}
}
});
}
return(fieldValues.GroupBy(fieldValue => fieldValue));
}
/// <summary>
/// Points to Draw Elapsed MS
/// 10000 605
/// 20000 998
/// 50000 2658
/// 100000 4980
/// </summary>
private static double GetRecommendPointToValueRatio(FeatureLayer layer, string columnName)
{
int pointsToDraw = 0;
// better performance.
if (layer is ShapeFileFeatureLayer)
{
var shpLayer = (ShapeFileFeatureLayer)layer;
var shpFName = shpLayer.ShapePathFilename;
var dbfFName = Path.ChangeExtension(shpFName, ".dbf");
if (File.Exists(dbfFName))
{
using (GeoDbf geoDbf = new GeoDbf(dbfFName, GeoFileReadWriteMode.Read))
{
geoDbf.Open();
for (int i = 1; i <= geoDbf.RecordCount; i++)
{
string fieldValue = geoDbf.ReadFieldAsString(i, columnName);
try
{
pointsToDraw += (int)Convert.ToDouble(fieldValue);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
}
}
geoDbf.Close();
}
}
}
else
{
IEnumerable <Feature> features = null;
layer.SafeProcess(() => { features = layer.QueryTools.GetAllFeatures(new string[] { columnName }); });
pointsToDraw = features.Sum(tmpFeature =>
{
try { return((int)Convert.ToDouble(tmpFeature.ColumnValues[columnName])); }
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
return(0);
}
});
}
double pointToValueRatio = 1d;
if (maxDotsToDraw < pointsToDraw)
{
pointToValueRatio = (double)maxDotsToDraw / (double)pointsToDraw;
}
return(pointToValueRatio);
}
public static Collection <DbfColumn> GetAllColumns(this GeoDbf geoDbf, bool includeNullColumnType = false)
{
Collection <DbfColumn> dbfColumns = new Collection <DbfColumn>();
for (int i = 1; i <= geoDbf.ColumnCount; i++)
{
DbfColumn column = geoDbf.GetColumn(i);
if (includeNullColumnType || column.ColumnType != DbfColumnType.Null)
{
dbfColumns.Add(column);
}
}
return(dbfColumns);
}
public override Collection <FeatureSourceColumn> GetColumnToAdd(string filePath, string customParameter)
{
Collection <FeatureSourceColumn> result = new Collection <FeatureSourceColumn>();
using (GeoDbf geoDbf = new GeoDbf(filePath, GeoFileReadWriteMode.Read))
{
geoDbf.Open();
var columns = geoDbf.GetAllColumns();
foreach (var item in columns)
{
DataJoinFeatureSourceColumn csvColumn = new DataJoinFeatureSourceColumn(item.ColumnName, item.TypeName, item.MaxLength);
result.Add(csvColumn);
}
geoDbf.Close();
}
return(result);
}
public override DataTable ReadDataToDataGrid(string filePath, string customParameter)
{
DataTable PreviewDataTable = new DataTable();
if (File.Exists(filePath))
{
DataTable dataTable = new DataTable();
using (GeoDbf geoDbf = new GeoDbf(filePath, GeoFileReadWriteMode.Read))
{
geoDbf.Open();
dataTable = new DataTable();
var columns = geoDbf.GetAllColumns();
foreach (var item in columns)
{
dataTable.Columns.Add(item.ColumnName);
}
for (int i = 1; i <= geoDbf.RecordCount; i++)
{
DataRow dr = dataTable.NewRow();
var dictionary = geoDbf.ReadRecordAsString(i);
for (int j = 1; j <= geoDbf.ColumnCount; j++)
{
string value;
dictionary.TryGetValue(geoDbf.GetColumnName(j), out value);
dr[j - 1] = value;
}
dataTable.Rows.Add(dr);
}
geoDbf.Close();
}
PreviewDataTable = dataTable;
}
return(PreviewDataTable);
}
private void Export(IGrouping <ShapeFileType, Feature> group, FileExportInfo info)
{
string path = info.Path;
if (File.Exists(path))
{
if (info.Overwrite)
{
string[] suffixes = { ".shp", ".shx", ".ids", ".idx", ".dbf", ".prj" };
foreach (var suffix in suffixes)
{
string fileToRemove = Path.ChangeExtension(path, suffix);
if (File.Exists(fileToRemove))
{
File.Delete(fileToRemove);
}
}
}
else
{
string dir = Path.GetDirectoryName(path);
string fileName = Path.GetFileNameWithoutExtension(path);
string extension = Path.GetExtension(path);
path = Path.Combine(dir, fileName + group.Key.ToString() + extension);
}
}
var dbfColumns = info.Columns.Select(column =>
{
DbfColumnType columnType = (DbfColumnType)Enum.Parse(typeof(DbfColumnType), column.TypeName);
DbfColumn dbfColumn = new DbfColumn(column.ColumnName, columnType, column.MaxLength, GetDecimalLength(columnType, column.MaxLength));
return(dbfColumn);
});
ShapeFileFeatureLayer.CreateShapeFile(group.Key, path, dbfColumns);
ShapeFileFeatureLayer layer = new ShapeFileFeatureLayer(path, GeoFileReadWriteMode.ReadWrite);
try
{
layer.Open();
layer.EditTools.BeginTransaction();
foreach (var feature in group)
{
bool isValid = true;
var newFeature = feature;
if (!feature.IsValid())
{
if (feature.CanMakeValid)
{
newFeature = feature.MakeValid();
}
else
{
isValid = false;
}
}
if (isValid)
{
var featureSourceColumns = layer.FeatureSource.GetColumns();
var tempColumnNames = featureSourceColumns.Select(column => column.ColumnName);
var validColumns = GeoDbf.GetValidColumnNames(tempColumnNames);
Dictionary <string, string> columnValues = new Dictionary <string, string>();
for (int i = 0; i < validColumns.Count(); i++)
{
var columnName = dbfColumns.ElementAt(i).ColumnName;
if (newFeature.ColumnValues.ContainsKey(columnName))
{
columnValues.Add(validColumns.ElementAt(i), newFeature.ColumnValues[columnName]);
}
}
Feature validFeature = new Feature(newFeature.GetWellKnownBinary(), newFeature.Id, columnValues);
layer.EditTools.Add(validFeature);
}
}
layer.EditTools.CommitTransaction();
layer.Close();
SavePrjFile(path, info.ProjectionWkt);
RebuildDbf(path);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
if (layer.EditTools.IsInTransaction)
{
layer.EditTools.CommitTransaction();
}
if (layer.IsOpen)
{
layer.Close();
}
string[] suffixes = { ".shp", ".shx", ".ids", ".idx", ".dbf", ".prj" };
foreach (var suffix in suffixes)
{
string fileToRemove = Path.ChangeExtension(path, suffix);
if (File.Exists(fileToRemove))
{
File.Delete(fileToRemove);
}
}
throw new OperationCanceledException("Shapefile generates failed.", ex);
}
}
private void GenerateExportConfig()
{
Collection <SplitFileModel> exportedModels = new Collection <SplitFileModel>();
SelectedLayerToSplit.SafeProcess(() =>
{
string selectedColumnName = SelectedFeatureSourceColumn.ColumnName;
Collection <Tuple <string, int> > distinctColumnValues = new Collection <Tuple <string, int> >();
if (UseSelectedFeaturesOnly)
{
var tmpColumnValues = HighlightFeatureLayer.InternalFeatures
.Where(tmpFeature => tmpFeature.Tag.Equals(SelectedLayerToSplit))
.Select(tmpFeature => tmpFeature.ColumnValues[selectedColumnName]);
foreach (var item in tmpColumnValues.GroupBy(tmpColumnValue => tmpColumnValue))
{
distinctColumnValues.Add(new Tuple <string, int>(item.Key, item.Count()));
}
}
else
{
var tmpShapeFileFeatureLayer = SelectedLayerToSplit as ShapeFileFeatureLayer;
Collection <string> values = new Collection <string>();
if (tmpShapeFileFeatureLayer != null)
{
string dbfPath = Path.ChangeExtension(tmpShapeFileFeatureLayer.ShapePathFilename, ".dbf");
GeoDbf geoDbf = new GeoDbf(dbfPath, GeoFileReadWriteMode.Read, tmpShapeFileFeatureLayer.Encoding);
geoDbf.Open();
for (int i = 1; i <= geoDbf.RecordCount; i++)
{
var columnValue = geoDbf.ReadRecordAsString(i)[selectedColumnName];
values.Add(columnValue);
}
geoDbf.Close();
}
else
{
foreach (var feature in SelectedLayerToSplit.QueryTools.GetAllFeatures(new string[] { selectedColumnName }))
{
values.Add(feature.ColumnValues[selectedColumnName]);
}
}
var groupedTmpColumnValues = values.GroupBy(tmpColumnValue => tmpColumnValue);
foreach (var item in groupedTmpColumnValues)
{
distinctColumnValues.Add(new Tuple <string, int>(item.Key, item.Count()));
}
}
foreach (var distinctValue in distinctColumnValues)
{
string columnValue = distinctValue.Item1;
if (!String.IsNullOrEmpty(columnValue))
{
Regex regex = new Regex(@"\w*");
var matches = regex.Matches(columnValue);
StringBuilder fileNameBuilder = new StringBuilder();
foreach (Match match in matches)
{
fileNameBuilder.Append(match.Value);
}
columnValue = fileNameBuilder.ToString();
}
SplitFileModel model = new SplitFileModel();
model.ColumnValue = String.IsNullOrEmpty(distinctValue.Item1) ? "<Blank>" : distinctValue.Item1;
model.FeatureCount = distinctValue.Item2;
model.OutputFileName = String.Format(CultureInfo.InvariantCulture
, "{0}_{1}"
, SelectedLayerToSplit.Name
, String.IsNullOrEmpty(columnValue) ? "unknown" : columnValue);
if (exportedModels
.Any(tmpModel => tmpModel.OutputFileName.Equals(model.OutputFileName, StringComparison.OrdinalIgnoreCase)))
{
var count = exportedModels.Count(tmpModel
=> tmpModel.OutputFileName.Equals(model.OutputFileName, StringComparison.OrdinalIgnoreCase));
model.OutputFileName += String.Format(CultureInfo.InvariantCulture, "_{0}", count);
//model.OutputFileName = model.OutputFileName.Replace(".shp"
//, String.Format(CultureInfo.InvariantCulture, "_{0}.shp", count));
}
exportedModels.Add(model);
}
});
#if GISEditorUnitTest
foreach (var model in exportedModels)
{
ExportConfiguration.Add(model);
}
#else
if (Application.Current != null)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
foreach (var model in exportedModels)
{
ExportConfiguration.Add(model);
}
}));
}
#endif
IsBusy = false;
BusyContent = String.Empty;
CurrentThread = null;
}
