public void TestReadingAaaShapeFile()
{
Assert.Catch <FileNotFoundException>(() =>
{
using (ShapefileDataReader reader = new ShapefileDataReader("aaa", Factory))
{
int length = reader.DbaseHeader.NumFields;
while (reader.Read())
{
Debug.WriteLine(reader.GetValue(length - 1));
}
}
Assert.Fail();
});
}
public void TestReadingShapeFileWithNulls()
{
using (ShapefileDataReader reader = new ShapefileDataReader("AllNulls", Factory))
{
while (reader.Read())
{
IGeometry geom = reader.Geometry;
Assert.IsNotNull(geom);
object[] values = new object[5];
int result = reader.GetValues(values);
Assert.IsNotNull(values);
}
}
}
public void TestLoadShapeFileWithEncoding()
{
ShapefileDataReader reader = new ShapefileDataReader("encoding_sample.shp", GeometryFactory.Default);
DbaseFileHeader header = reader.DbaseHeader;
Assert.AreEqual(header.Encoding.WindowsCodePage, 1252, "Invalid encoding!");
Assert.AreEqual(header.Fields[1].Name, "Test");
Assert.AreEqual(header.Fields[2].Name, "Ålder");
Assert.AreEqual(header.Fields[3].Name, "Ödestext");
Assert.IsTrue(reader.Read(), "Error reading file");
Assert.AreEqual(reader["Test"], "Testar");
Assert.AreEqual(reader["Ödestext"], "Lång text med åäö etc");
}
private void SetColumns(string file)
{
cmbParentItem.Items.Add("");
cmbFieldCodeName.Items.Add("");
cmbChildren.Items.Add("");
cmbFieldCaptionName.Items.Add("");
cmbHousehold.Items.Add("");
cmbPopulation.Items.Add("");
cmbUrbanity.Items.Add("");
using (ShapefileDataReader dr = new ShapefileDataReader(file, new GeometryFactory()))
{
ShapefileHeader shpHeader = dr.ShapeHeader;
var header = dr.DbaseHeader;
lblShapeType.Visible = true;
lblShapeType.Text = "Tipo de shp: " + shpHeader.ShapeType.ToString();
lblRecords.Visible = true;
lblRecords.Text = "Registros dbf: " + header.NumRecords;
for (int i = 0; i < header.NumFields; i++)
{
var fld = header.Fields[i];
cmbParentItem.Items.Add(fld.Name);
cmbFieldCodeName.Items.Add(fld.Name);
cmbChildren.Items.Add(fld.Name);
cmbFieldCaptionName.Items.Add(fld.Name);
cmbHousehold.Items.Add(fld.Name);
cmbPopulation.Items.Add(fld.Name);
cmbUrbanity.Items.Add(fld.Name);
}
}
cmbParentItem.SelectedIndex = 0;
cmbFieldCodeName.SelectedIndex = 0;
cmbChildren.SelectedIndex = 0;
cmbFieldCaptionName.SelectedIndex = 0;
cmbHousehold.SelectedIndex = 0;
cmbPopulation.SelectedIndex = 0;
cmbUrbanity.SelectedIndex = 0;
cmbParentItem.SetDropDownWidth();
cmbFieldCodeName.SetDropDownWidth();
cmbChildren.SetDropDownWidth();
cmbFieldCaptionName.SetDropDownWidth();
cmbHousehold.SetDropDownWidth();
cmbPopulation.SetDropDownWidth();
}
/// <summary>
/// Adds the attributes in the current record in the shapefile reader to the given attribute collection.
/// </summary>
public static void AddToAttributeCollection(this ShapefileDataReader reader, IAttributeCollection collection)
{
var valueString = string.Empty;
for (var i = 1; i < reader.FieldCount; i++)
{
var name = reader.GetName(i);
var value = reader.GetValue(i - 1);
valueString = string.Empty;
if (value != null)
{
valueString = value.ToInvariantString();
}
collection.AddOrReplace(name, valueString);
}
}
internal static ShapeDataReadIterator CreateIterator(string path, int index, Encoding encoding)
{
var factory = new GeometryFactory();
ShapefileDataReader reader;
if (encoding == null)
{
reader = new ShapefileDataReader(path, factory);
}
else
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
reader = new ShapefileDataReader(path, factory, encoding);
}
return(CreateIterator(path, index, reader));
}
public void Test_TestRead()
{
PrecisionModel pm = new PrecisionModel(100000, 0, 0);
GeometryFactory geometryFactory = new GeometryFactory(pm, -1);
//DataSets can be enumerated thru, or you can use Read(). This one tests the read;
string filename = Global.GetUnitTestRootDirectory() + @"\IO\Shapefile\Testfiles\statepop";
ShapefileDataReader shpDataReader = Geotools.IO.Shapefile.CreateDataReader(filename, geometryFactory);
int i = 0;
while (shpDataReader.Read())
{
i++;
}
Assertion.AssertEquals("Read using Read()", 49, i);
}
public static int FindIndex(string shapeFilePath, string filedName)
{
var factory = new GeometryFactory();
ShapefileDataReader reader = new ShapefileDataReader(shapeFilePath, factory);
int length = reader.DbaseHeader.NumFields;
for (var i = 0; i < length; i++)
{
if (reader.DbaseHeader.Fields[i].Name.Equals(filedName, StringComparison.InvariantCultureIgnoreCase))
{
return(i + 1);
}
}
return(0);
}
private static ShapefileDataReader TryShapefileDataReader(string filename)
{
var factory = new GeometryFactory();
ShapefileDataReader reader;
try
{
reader = new ShapefileDataReader(filename, factory);
}
catch (Exception e)
{
Console.WriteLine("The file " + filename + " did not load correctly: " + e.Message);
return(null);
}
reader.Reset();
return(reader);
}
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
if (_reader != null)
{
_reader.Dispose();
}
}
}
finally
{
_reader = null;
base.Dispose(disposing);
}
}
public void GeometryTransformTest()
{
#region Init ICoordinateTransformation
// RGF93_Lambert_93
const string coordSysRGF93_Lambert_93 = "PROJCS[\"RGF93_Lambert_93\",GEOGCS[\"GCS_RGF_1993\",DATUM[\"D_RGF_1993\",SPHEROID[\"GRS_1980\",6378137.0,298.257222101]],PRIMEM[\"Greenwich\",0.0],UNIT[\"Degree\",0.0174532925199433]],PROJECTION[\"Lambert_Conformal_Conic\"],PARAMETER[\"False_Easting\",700000.0],PARAMETER[\"False_Northing\",6600000.0],PARAMETER[\"Central_Meridian\",3.0],PARAMETER[\"Standard_Parallel_1\",44.0],PARAMETER[\"Standard_Parallel_2\",49.0],PARAMETER[\"Latitude_Of_Origin\",46.5],UNIT[\"Meter\",1.0]]";
// SRID 4326
const string coordSys4326 = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]";
var csSource = ProjNet.Converters.WellKnownText.CoordinateSystemWktReader.Parse(coordSysRGF93_Lambert_93) as GeoAPI.CoordinateSystems.ICoordinateSystem;
var csTarget = ProjNet.Converters.WellKnownText.CoordinateSystemWktReader.Parse(coordSys4326) as GeoAPI.CoordinateSystems.ICoordinateSystem;
var transform = new ProjNet.CoordinateSystems.Transformations.CoordinateTransformationFactory().CreateFromCoordinateSystems(csSource, csTarget);
var piSource = ProjectionInfo.FromEsriString(coordSysRGF93_Lambert_93);
var piTarget = ProjectionInfo.FromEsriString(coordSys4326);
var dsTransform = new DotSpatialMathTransform(piSource, piTarget);
#endregion Init ICoordinateTransformation
using (var shapeDataReader = new ShapefileDataReader(@"..\..\..\NetTopologySuite.Samples.Shapefiles\DEPARTEMENT.SHP", GeometryFactory.Default))
{
while (shapeDataReader.Read())
{
var outGeomDotSpatial =
CoordinateSystems.Transformations.GeometryTransform.TransformGeometry(GeometryFactory.Default,
shapeDataReader.Geometry,
dsTransform);
Assert.IsFalse(outGeomDotSpatial.IsEmpty);
Console.WriteLine(outGeomDotSpatial.AsText());
var outGeomProjNet =
CoordinateSystems.Transformations.GeometryTransform.TransformGeometry(GeometryFactory.Default,
shapeDataReader.Geometry,
transform.MathTransform);
Assert.IsFalse(outGeomProjNet.IsEmpty);
Console.WriteLine(outGeomProjNet.AsText());
var hd = Algorithm.Distance.DiscreteHausdorffDistance.Distance(outGeomProjNet, outGeomDotSpatial);
Console.WriteLine(string.Format("\nHaussdorffDistance: {0}", hd));
Console.WriteLine();
}
}
}
public ShapeFile(string fileName)
{
if (String.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException();
}
m_MapName = fileName;
IEditSpatialIndex index = new SpatialIndex();
ShapefileDataReader sfdr = Shapefile.CreateDataReader(fileName, new GeometryFactory());
ShapefileHeader hdr = sfdr.ShapeHeader;
Envelope ex = hdr.Bounds;
m_Extent = new Window(ex.MinX, ex.MinY, ex.MaxX, ex.MaxY);
foreach (object o in sfdr)
{
// You get back an instance of GisSharpBlog.NetTopologySuite.IO.RowStructure, but
// that's internal, so cast to the interface it implements (we'll attach this to
// the geometry we wrap).
//ICustomTypeDescriptor row = (ICustomTypeDescriptor)o;
AdhocPropertyList row = CreatePropertyList(sfdr);
NTS.Geometry geom = sfdr.Geometry;
geom.UserData = row;
List <NTS.Geometry> geoms = GetBasicGeometries(geom);
foreach (NTS.Geometry g in geoms)
{
g.UserData = row;
if (g is NTS.Point)
{
index.Add(new PointWrapper((NTS.Point)g));
}
else
{
index.Add(new GeometryWrapper(g));
}
}
}
// Don't permit any further additions
m_Index = index;
}
public Collection <IFeature> ReadAll()
{
IGeometryFactory factory = GeometryFactory.Default;
ShapefileDataReader reader = new ShapefileDataReader(shpFile, factory);
Collection <IFeature> features = new Collection <IFeature>();
while (reader.Read())
{
Feature feature = new Feature();
feature.Geometry = reader.Geometry;
feature.Attributes = new AttributesTable();
for (int i = 0; i < reader.DbaseHeader.NumFields; i++)
{
feature.Attributes.AddAttribute(reader.GetName(i), reader.GetValue(i));
}
features.Add(feature);
}
return(features);
}
private void fieldValues(string filename, int fieldIndex)
{
try
{
GeometryFactory f = new GeometryFactory(new PrecisionModel(), 23030);
using (ShapefileDataReader dr = new ShapefileDataReader(filename, f))
{
while (dr.Read())
{
//obtenemos todos los valores del campo seleccionado
_fieldValues.Add(dr.GetValue(fieldIndex).ToString());
}
}
}
catch (Exception ex)
{
throw ex;
}
}
private List <Feature> ReadShapefile(string shpFilename)
{
var features = new List <Feature>();
using (ShapefileDataReader dr = new ShapefileDataReader(shpFilename, new GeometryFactory()))
{
DbaseFileHeader header = dr.DbaseHeader;
while (dr.Read())
{
AttributesTable attributesTable = new AttributesTable();
for (int i = 0; i < header.NumFields; i++)
{
attributesTable.AddAttribute(header.Fields[i].Name, dr.GetValue(i));
}
features.Add(new Feature(dr.Geometry, attributesTable));
}
}
return(features);
}
public static void ImportShapeFileIntoDatabase(string filePath)
{
ShapeDataReader reader = new ShapeDataReader(filePath);
GeometryFactory factory = new GeometryFactory();
ShapefileDataReader shapeFileData = new ShapefileDataReader("", factory);
DbaseFieldDescriptor[] fieldsInformation = shapeFileData.DbaseHeader.Fields;
Envelope mb = reader.ShapefileBounds;
IEnumerable <IShapefileFeature> result = reader.ReadByMBRFilter(mb);
IAttributesTable columnAttributes = result.First().Attributes;
IShapefileFeature[] rowInformation = result.ToArray();
//CREATE TABLE COLUMNS
RunSqlQuery(CreateTableColumns(columnAttributes, fieldsInformation));
//INSERTING TABLE VALUES
InsertTableValues(result.Count(), rowInformation).ForEach(x => RunSqlQuery(x));
}
public static List <Feature> ReadFeatures(string filename)
{
if (!File.Exists(filename))
{
Console.WriteLine("The file " + filename + " does not exist.");
return(new List <Feature>());
}
var result = new List <Feature>();
ShapefileDataReader reader = TryShapefileDataReader(filename);
if (reader == null)
{
return(new List <Feature>());
}
try
{
while (reader.Read())
{
var feature = new Feature();
var attr = new AttributesTable();
var geometry = (Geometry)reader.Geometry;
for (int i = 0; i < reader.DbaseHeader.NumFields; ++i)
{
attr.Add(reader.DbaseHeader.Fields[i].Name, reader.GetValue(i + 1));
}
feature.Geometry = geometry;
feature.Attributes = attr;
result.Add(feature);
}
}
catch (Exception ex)
{
Console.WriteLine("Exception in feature read: " + ex.ToString() + ", filename: " + filename);
}
reader.Close();
reader.Dispose();
return(result);
}
public void TestReadingCrustalTestShapeFile()
{
// Original file with characters '°' in NAME field.
using (ShapefileDataReader reader = new ShapefileDataReader("crustal_test_bugged", Factory))
{
int length = reader.DbaseHeader.NumFields;
while (reader.Read())
{
Debug.WriteLine(reader.GetValue(length - 1));
}
}
// Removed NAME field characters
using (ShapefileDataReader reader = new ShapefileDataReader("crustal_test", Factory))
{
int length = reader.DbaseHeader.NumFields;
while (reader.Read())
{
Debug.WriteLine(reader.GetValue(length - 1));
}
}
}
public void TestSeptPolygones()
{
const string wktGeom9 =
"MULTIPOLYGON ( " +
"((-73.8706030450129 45.425307895968558, -73.8691180248536 45.425712901466682, -73.862907940551338 45.425949154673731, -73.862739188260548 45.423181617104319, -73.864662964375952 45.423384119853267, -73.8654729753718 45.42220285381751, -73.865979232244342 45.421730347403241, -73.866822993698463 45.42088658594912, -73.866485489116826 45.420481580450996, -73.865202971706537 45.42041407953468, -73.864629213917681 45.421325341905117, -73.864156707503412 45.422236604275611, -73.863481698340081 45.422405356566514, -73.863414197423765 45.421899099693974, -73.863414197423765 45.421190340072485, -73.8635491992564 45.4200765749531, -73.864122957045254 45.419165312582606, -73.864797966208585 45.419064061208076, -73.866316736825922 45.419030310749974, -73.867092997363727 45.419266563957194, -73.867295500112789 45.419536567622515, -73.867396751487263 45.420751584116317, -73.867092997363727 45.421527844654122, -73.866384237742238 45.422506607941045, -73.866046733160658 45.423215367562364, -73.8669579955311 45.423721624434904, -73.868881771646556 45.423485371227684, -73.8694555294353 45.423417870311312, -73.8700630376822 45.423991628100168, -73.870434292722109 45.424497884972709, -73.8706030450129 45.425307895968558), " +
"(-73.86921927622808 45.425139143677825, -73.868983023020974 45.424464134514437, -73.868544267064863 45.423991628100168, -73.86813926156691 45.423991628100168, -73.867092997363727 45.423991628100168, -73.86533797353917 45.423620373060317, -73.864966718499375 45.424059129016484, -73.864966718499375 45.424497884972709, -73.865304223081068 45.42534164642683, -73.866451738658668 45.425409147343146, -73.86756550377811 45.425274145510514, -73.86921927622808 45.425139143677825), " +
"(-73.865937695291677 45.419884197388171, -73.865599517078863 45.419585804847259, -73.86432637557175 45.4198046260438, -73.864167232883347 45.4205605538138, -73.864565089604355 45.420500875305606, -73.865937695291677 45.419884197388171)), " +
"((-73.868038010192436 45.424869140012561, -73.866620490949458 45.424869140012561, -73.865844230411653 45.424970391386921, -73.865742979037179 45.42436288314002, -73.865979232244342 45.42402537855844, -73.866687991865717 45.424295382223704, -73.867869257901532 45.424396633598121, -73.868038010192436 45.424869140012561), " +
"(-73.86744733356926 45.424703767127937, -73.867371896498639 45.42446991220919, -73.867002254852821 45.424454824795021, -73.866232796733016 45.424432193673908, -73.866345952338861 45.4246509611786, -73.86744733356926 45.424703767127937)), " +
"((-73.86512208901371 45.419923983060187, -73.864604875276427 45.420301946945074, -73.8644059469159 45.420043340076518, -73.86512208901371 45.419923983060187)))";
IGeometryFactory factory = GeometryFactory.Default; //new GeometryFactory(new PrecisionModel(Math.Pow(10, 13)));
WKTReader wktReader = new WKTReader(factory);
List <IGeometry> polys = new List <IGeometry>();
using (ShapefileDataReader reader = new ShapefileDataReader("sept_polygones", factory))
{
int index = 0;
while (reader.Read())
{
IGeometry geom = reader.Geometry;
Assert.IsNotNull(geom);
Assert.IsTrue(geom.IsValid);
geom.Normalize();
Debug.WriteLine(String.Format("Geom {0}: {1}", ++index, geom));
polys.Add(geom);
}
}
IGeometry expected = wktReader.Read(wktGeom9);
expected.Normalize();
Envelope e1 = expected.EnvelopeInternal;
Envelope e2 = polys[8].EnvelopeInternal;
Assert.IsTrue(e1.Equals(e2), string.Format("{0}\ndoes not match\n{1}", e1, e2));
Assert.IsTrue(expected.EqualsTopologically(polys[8]), string.Format("{0}\ndoes not match\n{1}", expected, polys[8]));
}
public void TestIssue161()
{
//SETUP
var filePath = Path.Combine(CommonHelpers.TestShapefilesDirectory, "LSOA_2011_EW_BGC.shp");
if (!File.Exists(filePath))
{
Assert.Ignore("File '{0}' not present", filePath);
}
//ATTEMPT
using (var reader = new ShapefileDataReader(filePath, GeometryFactory.Default))
{
var header = reader.ShapeHeader;
while (reader.Read())//&& count++ < 3)
{
object val;
Assert.DoesNotThrow(() => val = reader["LSOA11CD"]);
}
}
}
public void Test_DataGrid()
{
PrecisionModel pm = new PrecisionModel(100000, 0, 0);
GeometryFactory geometryFactory = new GeometryFactory(pm, -1);
string filename = Global.GetUnitTestRootDirectory() + @"\IO\Shapefile\Testfiles\statepop";
ShapefileDataReader shpDataReader = Geotools.IO.Shapefile.CreateDataReader(filename, geometryFactory);
// make sure the datagrid gets the column headings.
DataGrid grid = new DataGrid();
grid.DataSource = shpDataReader;
grid.DataBind();
TextWriter tempWriter = new StringWriter();
grid.RenderControl(new HtmlTextWriter(tempWriter));
string html = tempWriter.ToString();
bool same = Compare.CompareAgainstString(Global.GetUnitTestRootDirectory() + @"\IO\Shapefile\Testfiles\ExpectedDataGridDataReader.txt", html);
Assertion.AssertEquals("Datagrid properties", true, same);
}
public void TestReadingShapeFileAfvalbakken()
{
IGeometryFactory factory = GeometryFactory.Default;
List <IPolygon> polys = new List <IPolygon>();
const int distance = 500;
using (ShapefileDataReader reader = new ShapefileDataReader("afvalbakken", factory))
{
int index = 0;
while (reader.Read())
{
IGeometry geom = reader.Geometry;
Assert.IsNotNull(geom);
Assert.IsTrue(geom.IsValid);
Debug.WriteLine(String.Format("Geom {0}: {1}", index++, geom));
IGeometry buff = geom.Buffer(distance);
Assert.IsNotNull(buff);
polys.Add((IPolygon)geom);
}
}
IMultiPolygon multiPolygon = factory.CreateMultiPolygon(polys.ToArray());
Assert.IsNotNull(multiPolygon);
Assert.IsTrue(multiPolygon.IsValid);
IMultiPolygon multiBuffer = (IMultiPolygon)multiPolygon.Buffer(distance);
Assert.IsNotNull(multiBuffer);
Assert.IsTrue(multiBuffer.IsValid);
ShapefileWriter writer = new ShapefileWriter(factory);
writer.Write(@"test_buffer", multiBuffer);
ShapefileWriter.WriteDummyDbf(@"test_buffer.dbf", multiBuffer.NumGeometries);
}
private GeoData ConvertReaderToGeoData(ShapefileDataReader reader)
{
var geoData = new GeoData
{
Values = new Dictionary <string, object>(StringComparer.InvariantCultureIgnoreCase)
};
var(points, dataType) = ConvertGeometryToPointXY(reader.Geometry);
geoData.Points = points;
geoData.DataType = dataType;
var header = reader.DbaseHeader;
for (var i = 0; i < header.NumFields; i++)
{
var field = header.Fields[i];
geoData.Values[field.Name] = reader.GetValue(i + 1);
}
return(geoData);
}
public void Test_TestGets()
{
PrecisionModel pm = new PrecisionModel(1, 0, 0);
GeometryFactory geometryFactory = new GeometryFactory(pm, -1);
string filename = Global.GetUnitTestRootDirectory() + @"\IO\Shapefile\Testfiles\statepop";
ShapefileDataReader shpDataReader = Geotools.IO.Shapefile.CreateDataReader(filename, geometryFactory);
// note alaska and hawaii are missing - hence 48 states not 50.
// tests GetValues().
object[] values = new object[shpDataReader.FieldCount];
foreach (object columnValues in shpDataReader)
{
if (columnValues == null)
{
Assertion.Fail("columnValues should have data.");
}
// get values using GetValue()
for (int i = 0; i < shpDataReader.FieldCount; i++)
{
values[i] = shpDataReader.GetValue(i);
}
// get values using GetValues()
object[] values2 = new object[shpDataReader.FieldCount];
shpDataReader.GetValues(values2);
// ensure they are both the same.
for (int i = 0; i < shpDataReader.FieldCount; i++)
{
Assertion.AssertEquals("Values " + i, values[i], values2[i]);
}
}
}
public void Test()
{
var features = new List <IFeature>();
var seq = DotSpatialAffineCoordinateSequenceFactory.Instance.Create(1, Ordinates.XY);
seq.SetOrdinate(0, Ordinate.X, -91.0454);
seq.SetOrdinate(0, Ordinate.Y, 32.5907);
var pt = new GeometryFactory(DotSpatialAffineCoordinateSequenceFactory.Instance).CreatePoint(seq);
var attr = new AttributesTable();
attr.Add("FirstName", "John");
attr.Add("LastName", "Doe");
features.Add(new Feature(pt, attr));
string fileName = Path.GetTempFileName();
fileName = fileName.Substring(0, fileName.Length - 4);
var shpWriter = new ShapefileDataWriter(fileName, features[0].Geometry.Factory)
{
Header = ShapefileDataWriter.GetHeader(features[0], features.Count)
};
shpWriter.Write(features);
bool isTrue;
using (var reader = new ShapefileDataReader(fileName, pt.Factory))
@isTrue = reader.ShapeHeader.ShapeType.ToString() == "Point";
foreach (string file in Directory.GetFiles(Path.GetTempPath(), Path.GetFileName(fileName) + ".*"))
{
File.Delete(file);
}
Assert.IsTrue(@isTrue);
}
private void TestWriteZMValuesShapeFile(bool testM)
{
var points = new Coordinate[3];
points[0] = new Coordinate(0, 0);
points[1] = new Coordinate(1, 0);
points[2] = new Coordinate(1, 1);
var csFactory = DotSpatialAffineCoordinateSequenceFactory.Instance;
var sequence = csFactory.Create(3, Ordinates.XYZM);
for (int i = 0; i < 3; i++)
{
sequence.SetOrdinate(i, Ordinate.X, points[i].X);
sequence.SetOrdinate(i, Ordinate.Y, points[i].Y);
sequence.SetOrdinate(i, Ordinate.Z, 1 + i);
if (testM)
{
sequence.SetOrdinate(i, Ordinate.M, 11 + i);
}
}
var lineString = Factory.CreateLineString(sequence);
var attributes = new AttributesTable();
attributes.Add("FOO", "Trond");
var feature = new Feature(Factory.CreateMultiLineString(new[] { lineString }), attributes);
var features = new Feature[1];
features[0] = feature;
var shpWriter = new ShapefileDataWriter("ZMtest", Factory)
{
Header = ShapefileDataWriter.GetHeader(features[0], features.Length)
};
shpWriter.Write(features);
// Now let's read the file and verify that we got Z and M back
var factory = new GeometryFactory(DotSpatialAffineCoordinateSequenceFactory.Instance);
using (var reader = new ShapefileDataReader("ZMtest", factory))
{
reader.Read();
var geom = reader.Geometry;
for (int i = 0; i < 3; i++)
{
var c = geom.Coordinates[i];
Assert.AreEqual(i + 1, c.Z);
}
if (testM)
{
sequence = ((ILineString)geom).CoordinateSequence;
for (int i = 0; i < 3; i++)
{
Assert.AreEqual(sequence.GetOrdinate(i, Ordinate.M), 11 + i);
}
}
// Run a simple attribute test too
string v = reader.GetString(1);
Assert.AreEqual(v, "Trond");
}
}
public static void Compress(string shapeFilePath, int gridFieldIndex, string encoding = null, string outputShapeFileName = "")
{
var factory = new GeometryFactory();
if (!File.Exists(shapeFilePath))
{
Console.WriteLine("文件不存在。");
return;
}
string filePath = Path.GetDirectoryName(shapeFilePath);
string outputShapeFilePath = "";
var outputFilePath = Path.ChangeExtension(shapeFilePath, ".text");
if (!string.IsNullOrEmpty(outputShapeFileName))
{
outputShapeFilePath = Path.Combine(filePath, outputShapeFileName);
outputFilePath = Path.ChangeExtension(outputShapeFileName, ".txt");
}
var nFile = new FileStream(outputFilePath, FileMode.Create);
Encoding fileEncoding = Encoding.UTF8;
nFile.Position = nFile.Length;
var fts = new List <IFeature>();
ShapefileDataReader reader;
if (string.IsNullOrEmpty(encoding))
{
reader = new ShapefileDataReader(shapeFilePath, factory);
}
else
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
reader = new ShapefileDataReader(shapeFilePath, factory, Encoding.GetEncoding(encoding));
}
using (reader)
{
var dict = new Dictionary <string, IGeometry>();
int count = 0;
long recordCount = 0;
try {
while (reader.Read())
{
recordCount++;
var gridId = reader.GetString(gridFieldIndex);
if (dict.ContainsKey(gridId))
{
continue;
}
count++;
if (count % 1000 == 0)
{
Console.WriteLine($"{count}");
nFile.Flush();
}
dict.Add(gridId, reader.Geometry);
string text = $"{gridId},{reader.Geometry.ToString()}\n";
var bytes = fileEncoding.GetBytes(text);
nFile.Write(bytes, 0, bytes.Length);
var attrs = new AttributesTable();
attrs.Add("GRIDID", gridId);
var feature = new Feature(reader.Geometry, attrs);
fts.Add(feature);
}
}
catch (Exception)
{
Console.WriteLine($"第{recordCount}条记录读取错误！");
throw;
}
Console.WriteLine($"共处理{reader.RecordCount}条数据，压缩生成{count}条数据");
nFile.Close();
};
if (!string.IsNullOrEmpty(outputShapeFilePath))
{
var writer = new ShapefileDataWriter(outputShapeFilePath, factory);
writer.Header = ShapefileDataWriter.GetHeader(fts[0], fts.Count);
writer.Write(fts);
}
Console.WriteLine("成功结束！");
}
/// <summary>
/// Convert shape-file to geojson-file stream
/// </summary>
/// <param name="shapeFilePath"></param>
public static Stream ConvertToGeoJsonStream(string shapeFilePath)
{
var factory = new GeometryFactory();
//Create a feature collection
var featureCollection = new FeatureCollection();
//Try to get crs from .prj file
var crs = TryToGetCrs(shapeFilePath);
//Set crs if we found it
if (crs != CoordinateSystemId.None)
{
featureCollection.CRS = new NamedCRS(new CoordinateSystem(crs).Id.EpsgCode());
}
using (var shapeFileDataReader = new ShapefileDataReader(shapeFilePath, factory))
{
//Get shape file dbase header
var header = shapeFileDataReader.DbaseHeader;
//Loop throw all geometries
while (shapeFileDataReader.Read())
{
var attributesTable = new AttributesTable();
var geometry = (Geometry)shapeFileDataReader.Geometry;
//Get header fields
for (var i = 0; i < header.NumFields; i++)
{
var fldDescriptor = header.Fields[i];
attributesTable.AddAttribute(fldDescriptor.Name, shapeFileDataReader.GetValue(i));
}
//Create feature using geometry and attributes
var feature = new Feature()
{
Geometry = geometry,
Attributes = attributesTable
};
//Add feature to collection
featureCollection.Features.Add(feature);
}
//Close and free up any resources
shapeFileDataReader.Close();
}
// Create a stream to write to.
var outputStream = new MemoryStream();
var sw = new StreamWriter(outputStream);
var jsonSerializer = new GeoJsonSerializer(factory);
//Serialize feature collection to json
jsonSerializer.Serialize(sw, featureCollection);
//Flush stream writer and reset stream position
sw.Flush();
outputStream.Position = 0;
return(outputStream);
}
private void ReadFromShapeFile()
{
var featureCollection = new List <IFeature>();
const string filename = @"country";
if (!File.Exists(filename + ".dbf"))
{
throw new FileNotFoundException(filename + " not found at " + Environment.CurrentDirectory);
}
var dataReader = new ShapefileDataReader(filename, new GeometryFactory());
while (dataReader.Read())
{
var feature = new Feature {
Geometry = dataReader.Geometry
};
var length = dataReader.DbaseHeader.NumFields;
var keys = new string[length];
for (var i = 0; i < length; i++)
{
keys[i] = dataReader.DbaseHeader.Fields[i].Name;
}
feature.Attributes = new AttributesTable();
for (var i = 0; i < length; i++)
{
var val = dataReader.GetValue(i);
feature.Attributes.AddAttribute(keys[i], val);
}
featureCollection.Add(feature);
}
var index = 0;
Console.WriteLine("Elements = " + featureCollection.Count);
foreach (IFeature feature in featureCollection)
{
Console.WriteLine("Feature " + index++);
var table = feature.Attributes as AttributesTable;
foreach (var name in table.GetNames())
{
Console.WriteLine(name + ": " + table[name]);
}
}
//Directory
var dir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
string.Format(@"..{0}..{0}..{0}NetTopologySuite.Samples.Shapefiles{0}",
Path.DirectorySeparatorChar));
// Test write with stub header
var file = dir + "testWriteStubHeader";
if (File.Exists(file + ".shp"))
{
File.Delete(file + ".shp");
}
if (File.Exists(file + ".shx"))
{
File.Delete(file + ".shx");
}
if (File.Exists(file + ".dbf"))
{
File.Delete(file + ".dbf");
}
var dataWriter = new ShapefileDataWriter(file);
dataWriter.Header = ShapefileDataWriter.GetHeader(featureCollection[0] as IFeature, featureCollection.Count);
dataWriter.Write(featureCollection);
// Test write with header from a existing shapefile
file = dir + "testWriteShapefileHeader";
if (File.Exists(file + ".shp"))
{
File.Delete(file + ".shp");
}
if (File.Exists(file + ".shx"))
{
File.Delete(file + ".shx");
}
if (File.Exists(file + ".dbf"))
{
File.Delete(file + ".dbf");
}
dataWriter = new ShapefileDataWriter(file)
{
Header =
ShapefileDataWriter.GetHeader(dir + "country.dbf")
};
dataWriter.Write(featureCollection);
}
public void ImportShapeFile(string connectionString,
string targetCoordSystem,
bool recreateTable,
enSpatialType spatialType,
int SRID,
string tableName,
string schema,
string IdColName,
string geomcolName,
List <string> fieldsToImport)
{
_worker = new BackgroundWorker();
_worker.WorkerSupportsCancellation = true;
_worker.WorkerReportsProgress = true;
_worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(_worker_RunWorkerCompleted);
_worker.ProgressChanged += new ProgressChangedEventHandler(_worker_ProgressChanged);
_worker.DoWork += new DoWorkEventHandler(delegate(object sender, DoWorkEventArgs e)
{
try
{
#region Work
MapBindTrace.Source.TraceEvent(TraceEventType.Information, 1, "Worker started");
_worker.ReportProgress(0, "Starting...");
#region Init ICoordinateTransformation
_transform = null;
if (!string.IsNullOrWhiteSpace(targetCoordSystem))
{
//string v_targetCoordSys = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]";
ICoordinateSystem csSource = ProjNet.Converters.WellKnownText.CoordinateSystemWktReader.Parse(this.CoordinateSystem) as ICoordinateSystem;
ICoordinateSystem csTarget = ProjNet.Converters.WellKnownText.CoordinateSystemWktReader.Parse(targetCoordSystem) as ICoordinateSystem;
_transform = new CoordinateTransformationFactory().CreateFromCoordinateSystems(csSource, csTarget);
}
#endregion Init ICoordinateTransformation
using (ShapefileDataReader shapeDataReader = new ShapefileDataReader(_shapeFile, GeometryFactory.Default))
{
using (SqlConnection db = new SqlConnection(connectionString))
{
MapBindTrace.Source.TraceEvent(TraceEventType.Information, 1, "Opening SQL connection");
db.Open();
SqlTransaction transaction = db.BeginTransaction(IsolationLevel.Serializable);
try
{
#region Create destination table
DbaseFieldDescriptor[] fields = (from field in shapeDataReader.DbaseHeader.Fields
where fieldsToImport.Contains(field.Name)
select field).ToArray();
List <SqlColumnDescriptor> sqlFields = ShapeFileHelper.TranslateDbfTypesToSql(fields);
MapBindTrace.Source.TraceEvent(TraceEventType.Information, 1, "Create SQL table " + tableName);
string sqlScriptCreateTable = SqlServerModel.GenerateCreateTableScript(tableName, schema, sqlFields, spatialType, recreateTable, geomcolName, IdColName);
DataTable dataTable = SqlServerModel.GenerateDataTable(tableName, sqlFields, spatialType, recreateTable, geomcolName, IdColName);
new SqlCommand(sqlScriptCreateTable, db, transaction).ExecuteNonQuery();
#endregion
#region Read shape file
int numRecord = 0;
while (shapeDataReader.Read())
{
numRecord++;
try
{
#region Shape feature import
if (_worker.CancellationPending)
{
break;
}
IGeometry geom = shapeDataReader.Geometry;
IGeometry geomOut = null; // BUGGY GeometryTransform.TransformGeometry(GeometryFactory.Default, geom, trans.MathTransform);
if (_transform == null)
{
geomOut = geom;
}
else
{
geomOut = ShapeFileHelper.ReprojectGeometry(geom, _transform);
}
#region Prepare insert
// Set geom SRID
geomOut.SRID = SRID;
List <object> SqlNativeGeomList = new List <object>();
List <object> properties = new List <object>();
switch (spatialType)
{
#region geography
case enSpatialType.geography:
try
{
SqlNativeGeomList.Add(SqlServerHelper.ConvertToSqlType(geomOut, SRID, true, numRecord));
}
catch (Exception exGeomConvert)
{
MapBindTrace.Source.TraceData(TraceEventType.Error, 1, "Error Converting geography : ", exGeomConvert);
var args = new ShapeImportExceptionEventArgs(exGeomConvert, false, shapeDataReader.DumpCurrentRecord(), shapeDataReader.Geometry, numRecord);
if (this.Raise_Error(args))
{
if (args.Ignore)
{
SqlNativeGeomList = new List <object>();
}
else
{
break;
}
}
else
{
break;
}
}
break;
#endregion
#region geometry
case enSpatialType.geometry:
try
{
SqlNativeGeomList.Add(SqlServerHelper.ConvertToSqlType(geomOut, SRID, false, numRecord));
}
catch (Exception exGeomConvert)
{
MapBindTrace.Source.TraceData(TraceEventType.Error, 1, "Error Converting geometry : ", exGeomConvert);
var args = new ShapeImportExceptionEventArgs(exGeomConvert, false, shapeDataReader.DumpCurrentRecord(), shapeDataReader.Geometry, numRecord);
if (this.Raise_Error(args))
{
if (args.Ignore)
{
SqlNativeGeomList = new List <object>();
}
else
{
break;
}
}
else
{
break;
}
}
break;
#endregion
#region both
case enSpatialType.both:
bool geomConverted = false;
try
{
SqlNativeGeomList.Add(SqlServerHelper.ConvertToSqlType(geomOut, SRID, false, numRecord));
geomConverted = true;
SqlNativeGeomList.Add(SqlServerHelper.ConvertToSqlType(geomOut, SRID, true, numRecord));
}
catch (Exception exGeomConvert)
{
MapBindTrace.Source.TraceData(TraceEventType.Error, 1, "Error Converting geometry or geography : ", exGeomConvert);
var args = new ShapeImportExceptionEventArgs(exGeomConvert, false, shapeDataReader.DumpCurrentRecord(), shapeDataReader.Geometry, numRecord);
if (this.Raise_Error(args))
{
if (args.Ignore)
{
if (geomConverted)
{
SqlNativeGeomList.Add(null);
}
else
{
SqlNativeGeomList.AddRange(new object[] { null, null });
}
}
else
{
break;
}
}
else
{
break;
}
}
break;
#endregion
}
// Get Attributes
for (int i = 0; i < fields.Length; i++)
{
properties.Add(shapeDataReader[fields[i].Name]);
}
// Fill in-memory datatable
DataRow row = SqlServerModel.GetNewDataTableRow(dataTable, tableName, SqlNativeGeomList, properties);
dataTable.Rows.Add(row);
#endregion
//if (numRecord % 10 == 0)
_worker.ReportProgress((int)((numRecord * 100f) / this.RecordCount), string.Format("Reading {0} records", numRecord));
#endregion
}
catch (Exception exGeom)
{
MapBindTrace.Source.TraceData(TraceEventType.Error, 1, "Error Converting geometry : ", exGeom);
this.Raise_Error(new ShapeImportExceptionEventArgs(exGeom, true, shapeDataReader.DumpCurrentRecord(), shapeDataReader.Geometry, numRecord));
}
}
#endregion Read shape file
#region Bulk insert
if (!_worker.CancellationPending)
{
using (SqlBulkCopy bulk = new SqlBulkCopy(db, SqlBulkCopyOptions.Default, transaction))
{
try
{
bulk.DestinationTableName = SqlServerModel.GenerateFullTableName(tableName, schema);
bulk.BulkCopyTimeout = 3600; // 1 hour timeout
bulk.NotifyAfter = 10;
bulk.SqlRowsCopied += (o, args) =>
{
if (_worker.CancellationPending)
{
args.Abort = true;
}
else
{
_worker.ReportProgress((int)((args.RowsCopied * 100f) / this.RecordCount), string.Format("Writing {0} records", args.RowsCopied));
}
};
_worker.ReportProgress(0, string.Format("Writing {0} records", 0));
bulk.WriteToServer(dataTable);
bulk.Close();
}
catch (OperationAbortedException ex)
{
MapBindTrace.Source.TraceData(TraceEventType.Error, 1, "Error inserting: ", ex);
bulk.Close();
}
}
}
#endregion
if (_worker.CancellationPending)
{
MapBindTrace.Source.TraceEvent(TraceEventType.Warning, 1, "Rolling back transaction");
transaction.Rollback();
}
else
{
#region Create spatial index
MapBindTrace.Source.TraceEvent(TraceEventType.Information, 1, "Create spatial index");
_worker.ReportProgress(100, "Creating index...");
// Create spatial index
string sqlScriptCreateIndex = SqlServerModel.GenerateCreateSpatialIndexScript(tableName, schema, geomcolName, SqlServerHelper.GetBoundingBox(this.Bounds), spatialType, enSpatialIndexGridDensity.MEDIUM);
SqlCommand v_createdIndexcmd = new SqlCommand(sqlScriptCreateIndex, db, transaction);
v_createdIndexcmd.CommandTimeout = 3600;
v_createdIndexcmd.ExecuteNonQuery();
#endregion
MapBindTrace.Source.TraceEvent(TraceEventType.Information, 1, "Commit transaction");
transaction.Commit();
}
}
catch (Exception ex)
{
MapBindTrace.Source.TraceData(TraceEventType.Error, 2, "Error: ", ex);
MapBindTrace.Source.TraceEvent(TraceEventType.Warning, 2, "Rolling back transaction");
transaction.Rollback();
if (!this.Raise_Error(new ShapeImportExceptionEventArgs(ex, true)))
{
throw;
}
}
MapBindTrace.Source.TraceEvent(TraceEventType.Verbose, 2, "closing DB");
db.Close();
}
}
#endregion
}
catch (Exception ex)
{
MapBindTrace.Source.TraceData(TraceEventType.Error, 3, "Error: ", ex);
this.Raise_Error(new ShapeImportExceptionEventArgs(ex, true));
}
});
Trace.CorrelationManager.StartLogicalOperation("ImportShapeFile Worker");
_worker.RunWorkerAsync();
Trace.CorrelationManager.StopLogicalOperation();
}
