public IHttpActionResult PostFile()
{
try
{
ShapeFile shapeFile = null;
DbfReader dbfFile = null;
FileMapper fileMapper = null;
string[] shpFileStr = Directory.GetFiles(@"C:\testFile", "*.shp");
string[] dbfFilesStr = Directory.GetFiles(@"C:\testFile", "*.dbf");
if (shpFileStr != null && dbfFilesStr != null)
{
if (shpFileStr.Length == 1 && dbfFilesStr.Length == 1)
{
shapeFile = new ShapeFile(shpFileStr[0]);
dbfFile = new DbfReader(dbfFilesStr[0]);
fileMapper = new FileMapper(shapeFile, dbfFile);
fileMapper.StartFilter();
}
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
/// <summary>
/// 从shapefile生成FeatureSet
/// </summary>
/// <param name="shpFilePath"></param>
/// <returns></returns>
public static FeatureSet CreateFeatureSet(string shpFilePath)
{
if (!ShpUtil.VerificationShp(shpFilePath, out var subFiles))
{
throw new IOException("该shapefile文件不存在或者主文件缺失！");
}
//else
using var dbfReader = new DbfReader(subFiles.Item2);
var shxIndexs = new ShxReader().ReadShx(subFiles.Item1);
var recordNum = shxIndexs.Count;
using var shpReader = new ShpReader(shpFilePath, shxIndexs);
var fs = CreateFeatureSet(shpReader, dbfReader, recordNum);
if (File.Exists(subFiles.Item3))
{
string prjWkt = "";
using (var sr = new StreamReader(subFiles.Item3, Encoding.UTF8))
{
prjWkt = sr.ReadToEnd();
}
var proj = Crs.CreateFromWkt(prjWkt);
fs.Crs = proj;
}
return(fs);
}
public IFormatReader <IFileOptionsSet> CreateReader(ReaderType type, string path, IOptionsSet baseOptions = null)
{
IFormatReader <IFileOptionsSet> result = null;
FileOptionsSet options = new FileOptionsSet(baseOptions ?? OptionsSet.Empty)
{
FilePath = path
};
switch (type)
{
case ReaderType.Ascii:
result = new AsciiReader(options);
break;
case ReaderType.Excel:
case ReaderType.Excel2007:
result = new XlsReader(options);
break;
case ReaderType.Dbf:
result = new DbfReader(options);
break;
case ReaderType.Db:
throw new InvalidOperationException("use CreateDbReader()");
default:
throw new UnimplementedReaderTypeException(type);
}
return(result);
}
/// <summary>
/// 根据文件流创建shapefile
/// </summary>
/// <param name="shpFileStream"></param>
/// <param name="shxFileStream"></param>
/// <param name="dbfFileStream"></param>
/// <param name="prjFileStream"></param>
/// <returns></returns>
public static FeatureSet CreateFeatureSet
(Stream shpFileStream, Stream shxFileStream,
Stream dbfFileStream, Stream prjFileStream = null)
{
using var dbfReader = new DbfReader(dbfFileStream);
var shxIndexs = new ShxReader().ReadShx(shxFileStream);
var recordNum = shxIndexs.Count;
using var shpReader = new ShpReader(shpFileStream, shxIndexs);
var fs = CreateFeatureSet(shpReader, dbfReader, recordNum);
if (prjFileStream != null)
{
string prjWkt = "";
using (var sr = new StreamReader(prjFileStream, dbfReader.Encoding))
{
prjWkt = sr.ReadToEnd();
}
var proj = Crs.CreateFromWkt(prjWkt);
fs.Crs = proj;
}
return(fs);
}
private DataTable CreateDataTable(string tableName, DbfReader reader)
{
DataTable dataTable = new DataTable(tableName);
DbfFieldDesc[] fieldDescriptions = reader.DbfRecordHeader.GetFieldDescriptions();
//create the columns
dataTable.Columns.Add(ShapeFileRecordIndexColumnName, typeof(Int32));
dataTable.Columns.AddRange(DataColumnsFromDbfFields(fieldDescriptions));
//add the data
object[] rowValues = new object[fieldDescriptions.Length + 1];
for (int n = 0; n < reader.DbfRecordHeader.RecordCount; ++n)
{
string[] values = reader.GetFields(n);
TrimArrayValues(values);
rowValues[0] = n;
GetDataValues(fieldDescriptions, values, rowValues, 1);
DataRow row = dataTable.NewRow();
row.ItemArray = rowValues;
dataTable.Rows.Add(row);
}
return(dataTable);
}
public void ReadNullTbl_Large()
{
var dbf = new Dbf(Path.Combine(testDir, "_largenullable.dbf"));
var reader = new DbfReader(dbf);
var header = dbf.GetHeader();
var row2 = reader.ReadRow(0);
var rows = reader.ReadRows().ToList();
}
public FileMapper(ShapeFile i_ShapeFile, DbfReader i_DbfReader)
{
r_ShapeFile = i_ShapeFile;
r_DbfReader = i_DbfReader;
r_SitesNames = r_DbfReader.GetRecords(i_DbfReader.IndexOfFieldName("Hel_Name")).ToList();
r_Regions = r_DbfReader.GetRecords(i_DbfReader.IndexOfFieldName("Ezor")).ToList();
r_Dunams = r_DbfReader.GetRecords(i_DbfReader.IndexOfFieldName("Dunam")).ToList();
}
public void TestPJX()
{
var dbf = new Dbf(Path.Combine(testDir, "testproj.PJX"), Path.Combine(testDir, "testproj.PJT"));
var reader = new DbfReader(dbf);
var rows = reader.ReadRows(includeMemo: true);
var project = Project.FromRows(rows);
}
private Layer(
string name,
BinaryReader shpReader,
DbfReader dbfReader)
{
this.Name = name;
this.shpReader = shpReader;
this.dbfReader = dbfReader;
}
public void TestMethod1()
{
var path = Folder + @"DB.DBF";
var version = DbfVersion.dBASE_IV_SQL_Table;
var w0 = new object[] { true, DateTime.Today, "HELLO!!!", 20001000.34, 345.780 };
var w1 = new object[] { false, DateTime.Today.AddDays(-51), "BYE!!!", 10002000.34, 780.345 };
IReadOnlyList <DbfField> fields;
{
using var writer = new DbfWriter(path, version);
Assert.AreEqual(version, writer.Version);
//dbf.AddField(new DbfField("INTFIELD", DbfFieldType.Integer));
writer.AddField(new DbfField("LGCFIELD", DbfFieldType.Logical));
writer.AddField(new DbfField("DATFIELD", DbfFieldType.Date));
writer.AddField(new DbfField("CHRFIELD", DbfFieldType.Character, 10));
writer.AddField(new DbfField("NUMFIELD", DbfFieldType.Numeric, 10, 2));
writer.AddField(new DbfField("FLTFIELD", DbfFieldType.Float));
Assert.AreEqual(5, writer.Fields.Count);
writer.AddRecord(w0);
writer.AddRecord(w1);
fields = writer.Fields;
}
{
using var reader = new DbfReader(path);
// Header
Assert.AreEqual(version, reader.Version);
Assert.AreEqual(fields.Count, reader.Fields.Count);
Assert.IsTrue(fields.Select(x => x.Name).Zip(reader.Fields.Select(x => x.Name)).All(x => x.First.Equals(x.Second)));
Assert.IsTrue(fields.Select(x => x.Type).Zip(reader.Fields.Select(x => x.Type)).All(x => x.First.Equals(x.Second)));
Assert.IsTrue(fields.Select(x => x.Length).Zip(reader.Fields.Select(x => x.Length)).All(x => x.First.Equals(x.Second)));
Assert.IsTrue(fields.Select(x => x.Precision).Zip(reader.Fields.Select(x => x.Precision)).All(x => x.First.Equals(x.Second)));
Assert.IsTrue(fields.Zip(reader.Fields).All(x => x.First.Equals(x.Second)));
// Records
Assert.AreEqual(2, reader.RecordCount);
var r0 = reader.Read();
Assert.IsNotNull(r0);
var r1 = reader.Read();
Assert.IsNotNull(r1);
CollectionAssert.AreEqual(w0, r0);
CollectionAssert.AreEqual(w1, r1);
}
}
public void NameFirstColumnByNumber()
{
string name;
using (var dbf = DbfReader.Open(PathToDbf))
{
name = dbf.GetColumns[0].Name;
}
Assert.AreEqual(name, FirstColumn);
}
public void TestRecordCount()
{
var rdr = new DbfReader(GetDbfStream());
uint count = 0;
while (rdr.Read())
{
count++;
}
Assert.AreEqual(rdr.RecordCount, count);
}
public void TestDBC()
{
var dbf = new Dbf(Path.Combine(testDir, "largedb.dbc"), Path.Combine(testDir, "largedb.dct"));
var reader = new DbfReader(dbf);
var rows = reader.ReadRows(includeMemo: true);
var db = Database.FromDbf(dbf);
//Assert.Equal(6, reader.ReadRow(1)[1].ToString().Length);
//Assert.Equal(254, reader.ReadRow(0)[1].ToString().Length);
Assert.Equal(254, reader.ReadRow(2)[1].ToString().Length);
}
public void WriteHeadOnly()
{
int count;
var item = new List <KLF_NAMESDBF>();
DbfWriter.Save(Tmp, item);
using (var dbf = DbfReader.Open(Tmp))
{
count = dbf.Count;
}
Assert.AreEqual(0, count);
}
public void TestFields()
{
var rdr = new DbfReader(GetDbfStream());
Assert.AreEqual(6, rdr.Fields.Length);
CheckField(rdr.Fields[0], "NAME1", DbfType.Character, 128, 0);
CheckField(rdr.Fields[1], "SCALERANK", DbfType.Numeric, 10, 0);
CheckField(rdr.Fields[2], "COUNTRYNAM", DbfType.Character, 50, 0);
CheckField(rdr.Fields[3], "FeatureCla", DbfType.Character, 30, 0);
CheckField(rdr.Fields[4], "ADM0_A3", DbfType.Character, 3, 0);
CheckField(rdr.Fields[5], "MAP_COLOR", DbfType.Numeric, 4, 0);
}
/// <summary>
/// Constructs a new RenderSettings
/// </summary>
/// <param name="dbfStream">stream opened from the shapefile dbf file</param>
/// <param name="fieldName">The name of the DBF field to use when labelling shapes</param>
/// <param name="renderFont">The Font to use when labelling shapes in the shape file</param>
public RenderSettings(System.IO.Stream dbfStream, string fieldName, Font renderFont)
{
if (fieldName == null)
{
throw new ArgumentException("fieldName can not be null");
}
dbfReader = new DbfReader(dbfStream);
fieldIndex = FindFieldIndex(fieldName);
FieldName = fieldName;
this.renderFont = renderFont;
}
public static Database FromDbf(Dbf dbf)
{
var header = dbf.GetHeader();
if ((header.Flags & DbfHeaderFlags.DBC) == 0)
{
throw new InvalidCastException("Not a Database(DBC)");
}
var reader = new DbfReader(dbf);
var rows = reader.ReadRows(includeMemo: true);
var db = ParseDatabaseFromRows(rows);
return(db);
}
public void TestRecords()
{
var rdr = new DbfReader(GetDbfStream());
Assert.AreEqual(6, rdr.Fields.Length);
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(true, rdr.Read());
for (int j = 0; j < 6; j++)
{
Assert.AreEqual(testData[j][i], rdr[j]);
}
}
}
/// <summary>
/// 根据ShpReader和DbfReader创建FeatureSet
/// </summary>
/// <param name="shpReader"></param>
/// <param name="dbfReader"></param>
/// <param name="recordNum"></param>
/// <returns></returns>
private static FeatureSet CreateFeatureSet(ShpReader shpReader, DbfReader dbfReader, int recordNum)
{
GeometryType geometryType = (GeometryType)shpReader.ShpHeader.ShapeType;
var featureType = ShpUtil
.GeometryType2FeatureType(geometryType);
FeatureSet fs = new FeatureSet(featureType);
IFeatureList features = new FeatureList(fs);
for (int i = 0; i < recordNum; i++)
{
var spatialBytes = shpReader.GetNextRecord();
dbfReader.GetNextRow();
IGeometry geometry;
switch (geometryType)
{
case GeometryType.Point:
geometry = BytesToGeometry.CreatePoint(spatialBytes);
break;
case GeometryType.MultiPoint:
geometry = BytesToGeometry.CreateMultipoint(spatialBytes);
break;
case GeometryType.PolyLine:
geometry = BytesToGeometry.CreatePolyLine(spatialBytes);
break;
case GeometryType.Polygon:
geometry = BytesToGeometry.CreatePolygon(spatialBytes);
break;
default:
geometry = null;
break;
}
IFeature feature = new Feature(geometry);
features.Add(feature);
}
fs.Features.Set(features);
fs.AttrTable = dbfReader.DbfTable;
var header = shpReader.ShpHeader;
//fs.Envelope = new Envelope(header.XMin, header.YMin,
// header.XMax, header.YMax,
// header.ZMin, header.ZMax);
return(fs);
}
public async Task ReadDbfRowsAsync()
{
var dbf = new Dbf(Path.Combine(testDir, "poshistorie.dbf"));
var reader = new DbfReader(dbf);
int count = 0;
await foreach (var r in reader.ReadRowsAsync((i, x) => true, includeMemo: false, includeDeleted: true))
{
count++;
//if (count > 50) break;
}
output.WriteLine("Count: {0} ({1})", count, dbf.GetHeader().RecordCount);
Assert.Equal(dbf.GetHeader().RecordCount, count);
}
public void CountRecordByRead()
{
var items = 0;
using (var dbf = DbfReader.Open(PathToDbf))
{
#pragma warning disable 612,618
while (dbf.Read())
#pragma warning restore 612,618
{
items++;
}
}
Assert.AreEqual(Count, items, "Количество записей");
}
/// <summary>
/// Constructs a ShapeFile using a path to a .shp shape file
/// </summary>
/// <param name="shapeFilePath">The path to the ".shp" shape file</param>
private Shape(string shapeFilePath)
{
using (var file = new ShapeFile(shapeFilePath))
{
RecordCount = file.RecordCount;
ShapeData = new IEnumerable<PointXYZ[]>[RecordCount];
for (int i = 0; i < RecordCount; ++i)
{
var shapeData = file.GetShapeDataD(i);
ShapeData[i] = shapeData.Select(x => x.Select(p => new PointXYZ() { X = p.X, Y = p.Y, Z = 0 }).ToArray());
}
}
string dbfFilePath = Path.ChangeExtension(shapeFilePath, "dbf");
Database = new DbfReader(dbfFilePath);
}
public void ReadToDataTable()
{
var dt = new DataTable();
int columns;
using (var dbf = DbfReader.Open(PathToDbf))
{
columns = dbf.GetColumns.Count;
#pragma warning disable 612,618
dbf.Fill(dt);
#pragma warning restore 612,618
}
Assert.AreEqual(columns, dt.Columns.Count, "Колонок");
Assert.AreEqual(Count, dt.Rows.Count, "Строк");
}
public static ILayer Create(
string name,
Stream shpStream,
Stream dbfStream)
{
var shpReader = new BinaryReader(shpStream, Encoding.UTF8, leaveOpen: true);
var dbfReader = DbfReader.Create(dbfStream);
var layer = new Layer(
name,
shpReader,
dbfReader);
layer.Reset();
return(layer);
}
public void NumberOfColumnByName()
{
var index = -1;
using (var dbf = DbfReader.Open(PathToDbf))
{
for (var i = 0; i < dbf.GetColumns.Count; i++)
{
if (dbf.GetColumns[i].Name == FirstColumn)
{
index = i;
}
}
}
Assert.AreEqual(index, 0);
}
public void PosHistorieAusgebenTable()
{
var dbf = new Dbf(Path.Combine(testDir, "poshistorie.dbf"));
var reader = new DbfReader(dbf);
var header = dbf.GetHeader();
using (var sw = new StreamWriter(Path.Combine(testDir, $"Fact_{nameof(PosHistorieAusgebenTable)}.md")))
{
//reader.ReadRows((i, v) => i > (header.CalculatedRecordCount - 10), true).Count();
//OutputHelper.MarkdownTable(header.Fields, reader.ReadRows(true).Take(50), h => h, sw.WriteLine);
OutputHelper.MarkdownTable(
new[] { "RAW CONTENT" },
reader.ReadRowsRaw().Select(x => new[] { OutputHelper.ByteArrayToX2(x) }).Take(50).ToList(),
h => h,
sw.WriteLine);
}
}
/// <summary>
/// Constructs a new RenderSettings object
/// </summary>
/// <param name="shapeFilePath">The path to the shape file without the .shp file extension</param>
/// <param name="fieldName">The name of the DBF field to use when labelling shapes</param>
/// <param name="renderFont">The Font to use when labelling shapes in the shape file</param>
public RenderSettings(string shapeFilePath, string fieldName, Font renderFont)
{
if (shapeFilePath == null)
{
throw new ArgumentException("shapeFileName can not be null");
}
if (fieldName == null)
{
throw new ArgumentException("fieldName can not be null");
}
dbfReader = new DbfReader(shapeFilePath);
fieldIndex = FindFieldIndex(fieldName);
FieldName = fieldName;
this.renderFont = renderFont;
}
/// <summary>
/// Constructs a ShapeFile using a path to a .shp shape file
/// </summary>
/// <param name="shapeFilePath">The path to the ".shp" shape file</param>
private Shape(string shapeFilePath)
{
using (var file = new ShapeFile(shapeFilePath))
{
RecordCount = file.RecordCount;
ShapeData = new IEnumerable <PointXYZ[]> [RecordCount];
for (int i = 0; i < RecordCount; ++i)
{
var shapeData = file.GetShapeDataD(i);
ShapeData[i] = shapeData.Select(x => x.Select(p => new PointXYZ()
{
X = p.X, Y = p.Y, Z = 0
}).ToArray());
}
}
string dbfFilePath = Path.ChangeExtension(shapeFilePath, "dbf");
Database = new DbfReader(dbfFilePath);
}
public void Test1()
{
var dbf = new Dbf(Path.Combine(testDir, "dbTable2.dbf"));
//var dbf = new Dbf(Path.Combine(@"C:\vfp projects\WindowsShell", "varchr.dbf"));
var reader = new DbfReader(dbf);
var row = reader.ReadRow(0);
var header = dbf.GetHeader();
OutputHelper.MarkdownTable(header.Fields, reader.ReadRows(), h => h, output.WriteLine);
var row2 = reader.ReadRow(1);
var row3 = reader.ReadRow(2);
//var rows = reader.ReadRows(includeMemo: true).ToList();
//Assert.Equal(6, reader.ReadRow(1)[1].ToString().Length);
//Assert.Equal(254, reader.ReadRow(0)[1].ToString().Length);
//Assert.Equal(254, reader.ReadRow(2)[1].ToString().Length);
}
public void DbfReadSimpleFile()
{
var f = new DataFile()
{
Encoding = Encoding.GetEncoding(866)
};
var rdr = new DbfReader(f);
using (var file = File.Open("../../testfiles/simple.dbf", FileMode.Open))
{
rdr.Read(file);
}
var wrt = new DbfWriter(f);
using (var file = File.Open("../../testfiles/output.dbf", FileMode.OpenOrCreate | FileMode.Truncate))
{
wrt.Write(file);
}
ProviderTools.CompareFiles("../../testfiles/simple.dbf", "../../testfiles/output.dbf");
}
public void DbfReadAutoEncoding()
{
var f = new DataFile()
{
Encoding = null // AUTO
};
var rdr = new DbfReader(f);
using (var file = File.Open("../../testfiles/ENCODING.dbf", FileMode.Open))
{
rdr.Read(file);
}
var wrt = new DbfWriter(f);
using (var file = File.Open("../../testfiles/output.dbf", FileMode.OpenOrCreate | FileMode.Truncate))
{
wrt.Write(file);
}
ProviderTools.CompareFiles("../../testfiles/ENCODING.dbf", "../../testfiles/output.dbf");
}
internal RenderSettings(string shapeFileName)
{
dbfReader = new DbfReader(shapeFileName);
}
/// <summary>
/// Constructs a new RenderSettings object
/// </summary>
/// <param name="shapeFilePath">The path to the shape file without the .shp file extension</param>
/// <param name="fieldName">The name of the DBF field to use when labelling shapes</param>
/// <param name="renderFont">The Font to use when labelling shapes in the shape file</param>
public RenderSettings(string shapeFilePath, string fieldName, Font renderFont)
{
if (shapeFilePath == null)
{
throw new ArgumentException("shapeFileName can not be null");
}
if (fieldName == null)
{
throw new ArgumentException("fieldName can not be null");
}
dbfReader = new DbfReader(shapeFilePath);
fieldIndex = FindFieldIndex(fieldName);
FieldName = fieldName;
this.renderFont = renderFont;
}
