public ShapefileDataReader(IStreamProviderRegistry streamProviderRegistry, IGeometryFactory geometryFactory)
{
if (streamProviderRegistry==null)
throw new ArgumentNullException("streamProviderRegistry");
if (geometryFactory == null)
throw new ArgumentNullException("geometryFactory");
_open = true;
_dbfReader = new DbaseFileReader(streamProviderRegistry);
_shpReader = new ShapefileReader(streamProviderRegistry, geometryFactory);
_dbfHeader = _dbfReader.GetHeader();
_recordCount = _dbfHeader.NumRecords;
// copy dbase fields to our own array. Insert into the first position, the shape column
_dbaseFields = new DbaseFieldDescriptor[_dbfHeader.Fields.Length + 1];
_dbaseFields[0] = DbaseFieldDescriptor.ShapeField();
for (int i = 0; i < _dbfHeader.Fields.Length; i++)
_dbaseFields[i + 1] = _dbfHeader.Fields[i];
_shpHeader = _shpReader.Header;
_dbfEnumerator = _dbfReader.GetEnumerator();
_shpEnumerator = _shpReader.GetEnumerator();
_moreRecords = true;
}
private void TestBugMultipolygonHShuntao()
{
IGeometryCollection gc1 = null;
IGeometryCollection gc2 = null;
string file = "BJmultipolygon.shp";
if (!File.Exists(file))
throw new FileNotFoundException();
// Test with Default ShapefileReader
try
{
ShapefileReader sfr = new ShapefileReader(file);
gc1 = sfr.ReadAll();
}
catch (Exception ex)
{
throw ex;
}
//// Test with MyShapefileReader (only for debug purpose!)
//try
//{
// MyShapeFileReader reader = new MyShapeFileReader();
// gc2 = reader.Read(file);
//}
//catch (Exception ex)
//{
// throw ex;
//}
//// Check for equality
//if (!gc1.EqualsExact(gc2))
// throw new TopologyException("Both geometries must be equals!");
}
public ShapefileDataReader(IStreamProviderRegistry streamProviderRegistry, IGeometryFactory geometryFactory)
{
if (streamProviderRegistry == null)
{
throw new ArgumentNullException("streamProviderRegistry");
}
if (geometryFactory == null)
{
throw new ArgumentNullException("geometryFactory");
}
_open = true;
_dbfReader = new DbaseFileReader(streamProviderRegistry);
_shpReader = new ShapefileReader(streamProviderRegistry, geometryFactory);
_dbfHeader = _dbfReader.GetHeader();
_recordCount = _dbfHeader.NumRecords;
// copy dbase fields to our own array. Insert into the first position, the shape column
_dbaseFields = new DbaseFieldDescriptor[_dbfHeader.Fields.Length + 1];
_dbaseFields[0] = DbaseFieldDescriptor.ShapeField();
for (int i = 0; i < _dbfHeader.Fields.Length; i++)
{
_dbaseFields[i + 1] = _dbfHeader.Fields[i];
}
_shpHeader = _shpReader.Header;
_dbfEnumerator = _dbfReader.GetEnumerator();
_shpEnumerator = _shpReader.GetEnumerator();
_moreRecords = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="ShapefileEnumerator"/> class.
/// </summary>
/// <param name="shapefile"></param>
public ShapefileEnumerator(ShapefileReader shapefile)
{
_parent = shapefile;
_isolatedStorageFile = IsolatedStorageFile.GetUserStoreForApplication();
// create a file stream for each enumerator that is given out. This allows the same file
// to have one or more enumerator. If we used the parents stream - than only one IEnumerator
// could be given out.
var stream = new IsolatedStorageFileStream(_parent._filename,
FileMode.Open, FileAccess.Read,
FileShare.Read, _isolatedStorageFile);
_shpBinaryReader = new BigEndianBinaryReader(stream);
// skip header - since parent has already read this.
_shpBinaryReader.ReadBytes(100);
ShapeGeometryType type = _parent._mainHeader.ShapeType;
_handler = Shapefile.GetShapeHandler(type);
if (_handler == null)
{
throw new NotSupportedException("Unsuported shape type:" + type);
}
}
public void TestCorruptedShapeFile()
{
IGeometryFactory factory = GeometryFactory.Default;
const string filename = "christchurch-canterbury-h.shp";
Assert.Throws<ShapefileException>(() =>
{
var reader = new ShapefileReader(filename, factory);
Assert.Fail("Invalid file: code should be unreachable");
});
// ensure file isn't locked
string path = Path.Combine(Environment.CurrentDirectory, filename);
bool ok;
using (FileStream file = File.OpenRead(path))
{
using (BinaryReader reader = new BinaryReader(file))
{
// read a value
int val = reader.Read();
Console.WriteLine("read a value: " + val);
ok = true;
}
}
Assert.That(ok, Is.True);
}
public void CascadedUnionError2()
{
var sf = new ShapefileReader(@"..\..\..\NetTopologySuite.Samples.Shapefiles\error_union.shp");
var geoms = sf.ReadAll();
//var i = 0;
//using (var f = new StreamWriter(new FileStream(@"..\..\..\NetTopologySuite.Samples.Shapefiles\error_union.txt", FileMode.Create)))
//{
// foreach (var geom in geoms)
// {
// if (i++ == 0) continue;
// f.WriteLine(geom.AsText());
// }
//}
var u1 = geoms.Union();
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
var u2 = geoms.Union();
sw.Stop();
Console.WriteLine("Unioning {0} geometries in {1}ms", geoms.Count, sw.ElapsedMilliseconds);
Assert.IsNotNull(u2);
//These number are from JTS-TestBuilder
Assert.AreEqual(320, u2.NumGeometries);
Assert.AreEqual(37699, u2.NumPoints);
}
/// <summary>
/// Initializes a new instance of the ShapefileDataReader class.
/// </summary>
/// <param name="filename">The shapefile to read (minus the .shp extension)</param>
///<param name="geometryFactory">The GeometryFactory to use.</param>
public ShapefileDataReader(string filename, IGeometryFactory geometryFactory)
{
if (String.IsNullOrEmpty(filename))
{
throw new ArgumentNullException("filename");
}
if (geometryFactory == null)
{
throw new ArgumentNullException("geometryFactory");
}
_open = true;
string dbfFile = Path.ChangeExtension(filename, "dbf");
_dbfReader = new DbaseFileReader(dbfFile);
string shpFile = Path.ChangeExtension(filename, "shp");
_shpReader = new ShapefileReader(shpFile, geometryFactory);
_dbfHeader = _dbfReader.GetHeader();
_recordCount = _dbfHeader.NumRecords;
// copy dbase fields to our own array. Insert into the first position, the shape column
_dbaseFields = new DbaseFieldDescriptor[_dbfHeader.Fields.Length + 1];
_dbaseFields[0] = DbaseFieldDescriptor.ShapeField();
for (int i = 0; i < _dbfHeader.Fields.Length; i++)
{
_dbaseFields[i + 1] = _dbfHeader.Fields[i];
}
_shpHeader = _shpReader.Header;
_dbfEnumerator = _dbfReader.GetEnumerator();
_shpEnumerator = _shpReader.GetEnumerator();
_moreRecords = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="ShapefileEnumerator" /> class.
/// </summary>
/// <param name="shapefile"></param>
public ShapefileEnumerator(ShapefileReader shapefile)
{
_parent = shapefile;
// create a file stream for each enumerator that is given out. This allows the same file
// to have one or more enumerator. If we used the parents stream - than only one IEnumerator
// could be given out.
var stream = shapefile._shapeStreamProviderRegistry[StreamTypes.Shape].OpenRead();
var indexStream = shapefile._shapeStreamProviderRegistry[StreamTypes.Index].OpenRead();
_shpBinaryReader = new BigEndianBinaryReader(stream);
if (indexStream != null)
{
_idxBinaryReader = new BigEndianBinaryReader(indexStream);
}
// skip header - since parent has already read this.
_shpBinaryReader.ReadBytes(100);
if (_idxBinaryReader != null)
{
_idxBinaryReader.ReadBytes(100);
}
var type = _parent._mainHeader.ShapeType;
_handler = Shapefile.GetShapeHandler(type);
if (_handler == null)
{
throw new NotSupportedException("Unsuported shape type:" + type);
}
}
/// <summary>
/// Initializes a new instance of the ShapefileDataReader class.
/// </summary>
/// <param name="filename">The shapefile to read (minus the .shp extension)</param>
///<param name="geometryFactory">The GeometryFactory to use.</param>
public ShapefileDataReader(string filename, IGeometryFactory geometryFactory)
{
if (String.IsNullOrEmpty(filename))
throw new ArgumentNullException("filename");
if (geometryFactory == null)
throw new ArgumentNullException("geometryFactory");
_open = true;
string dbfFile = Path.ChangeExtension(filename, "dbf");
_dbfReader = new DbaseFileReader(dbfFile);
string shpFile = Path.ChangeExtension(filename, "shp");
_shpReader = new ShapefileReader(shpFile, geometryFactory);
_dbfHeader = _dbfReader.GetHeader();
_recordCount = _dbfHeader.NumRecords;
// copy dbase fields to our own array. Insert into the first position, the shape column
_dbaseFields = new DbaseFieldDescriptor[_dbfHeader.Fields.Length + 1];
_dbaseFields[0] = DbaseFieldDescriptor.ShapeField();
for (int i = 0; i < _dbfHeader.Fields.Length; i++)
_dbaseFields[i + 1] = _dbfHeader.Fields[i];
_shpHeader = _shpReader.Header;
_dbfEnumerator = _dbfReader.GetEnumerator();
_shpEnumerator = _shpReader.GetEnumerator();
_moreRecords = true;
}
private static IGeometryCollection ReadShape(string shapepath)
{
if (!File.Exists(shapepath))
throw new ArgumentException("File " + shapepath + " not found!");
var reader = new ShapefileReader(shapepath);
var geometries = reader.ReadAll();
return geometries;
}
public override void Open()
{
if (IsOpened)
throw new Exception(string.Format("Cannot open before to close the resource {0}", Path));
if (string.IsNullOrEmpty(Path))
throw new Exception("Cannot open a null or empty path");
#if USE_SFDR
reader = Shapefile.CreateDataReader(Path, new GeometryFactory());
var s1 = reader.ShapeHeader;
var h = reader.DbaseHeader;
#else
var shpReader = new ShapefileReader(Path);
shpProvider = shpReader.GetEnumerator();
var dbfReader = new DbaseFileReader(IoManager.File.ChangeExtension(Path, ".dbf"));
var h = dbfReader.GetHeader();
dbfProvider = dbfReader.GetEnumerator();
#endif
foreach (var f in h.Fields)
{
var lf = new LayerField();
lf.Name = f.Name;
switch (f.DbaseType)
{
case 'L': // logical data type, one character (T,t,F,f,Y,y,N,n)
lf.FieldType = GisFieldType.GisFieldTypeBoolean;
break;
case 'C': // char or string
lf.FieldType = GisFieldType.GisFieldTypeString;
break;
case 'D': // date
lf.FieldType = GisFieldType.GisFieldTypeDate;
break;
case 'N': // numeric
if (f.DecimalCount > 0)
lf.FieldType = GisFieldType.GisFieldTypeFloat;
else
lf.FieldType = GisFieldType.GisFieldTypeNumber;
break;
case 'F': // double
lf.FieldType = GisFieldType.GisFieldTypeNumber;
break;
default:
throw new NotSupportedException("Do not know how to parse Field type " + f.DbaseType);
}
Fields.Add(lf);
}
}
public void PerformCascadedPolygonUnion()
{
var reader = new ShapefileReader("tnp_pol.shp");
var collection = reader.ReadAll().Where(e => e is IPolygon).ToList();
var u1 = collection[0];
for (var i = 1; i < collection.Count; i++)
u1 = SnapIfNeededOverlayOp.Overlay(u1, collection[i], SpatialFunction.Union);
var u2 = CascadedPolygonUnion.Union(collection);
if (!u1.Equals(u2))
Assert.Fail("failure");
}
private IGeometry LoadGraphResult()
{
var path = "graphresult.shp";
Assert.IsTrue(Path.GetExtension(path) == shp);
var reader = new ShapefileReader(path);
var coll = reader.ReadAll();
Assert.AreEqual(1, coll.Count);
var geom = coll.GetGeometryN(0);
Assert.IsInstanceOf(typeof(IMultiLineString), geom);
var str = geom.GetGeometryN(0);
Assert.IsInstanceOf(typeof(ILineString), str);
return str;
}
/// <summary>
/// Initializes a new instance of the <see cref="ShapefileEnumerator"/> class.
/// </summary>
/// <param name="shapefile"></param>
public ShapefileEnumerator(ShapefileReader shapefile)
{
_parent = shapefile;
// create a file stream for each enumerator that is given out. This allows the same file
// to have one or more enumerator. If we used the parents stream - than only one IEnumerator
// could be given out.
var stream = new FileStream(_parent._filename, FileMode.Open, FileAccess.Read, FileShare.Read);
_shpBinaryReader = new BigEndianBinaryReader(stream);
// skip header - since parent has already read this.
_shpBinaryReader.ReadBytes(100);
ShapeGeometryType type = _parent._mainHeader.ShapeType;
_handler = Shapefile.GetShapeHandler(type);
if (_handler == null)
throw new NotSupportedException("Unsuported shape type:" + type);
}
/// <summary>
/// Initializes a new instance of the ShapefileDataReader class.
/// </summary>
/// <param name="filename">The shapefile to read (minus the .shp extension)</param>
///<param name="geometryFactory">The GeometryFactory to use.</param>
public ShapefileDataReader(string filename, IGeometryFactory geometryFactory)
{
if (filename == null)
{
throw new ArgumentNullException("filename");
}
if (geometryFactory == null)
{
throw new ArgumentNullException("geometryFactory");
}
_open = true;
if (filename.ToLower().EndsWith(".shp"))
{
filename = filename.ToLower().Replace(".shp", String.Empty);
}
_dbfReader = new DbaseFileReader(filename + ".dbf");
_shpReader = new ShapefileReader(filename + ".shp", geometryFactory);
_dbfHeader = _dbfReader.GetHeader();
_recordCount = _dbfHeader.NumRecords;
// copy dbase fields to our own array. Insert into the first position, the shape column
_dbaseFields = new DbaseFieldDescriptor[_dbfHeader.Fields.Length + 1];
_dbaseFields[0] = DbaseFieldDescriptor.ShapeField();
for (int i = 0; i < _dbfHeader.Fields.Length; i++)
{
_dbaseFields[i + 1] = _dbfHeader.Fields[i];
}
_shpHeader = _shpReader.Header;
_dbfEnumerator = _dbfReader.GetEnumerator();
_shpEnumerator = _shpReader.GetEnumerator();
_moreRecords = true;
}
/// <summary>
/// Loads the shapefile as a graph allowing SP analysis to be carried out
/// </summary>
/// <param name="fileName">The name of the shape file we want to load</param>
/// <param name="src"></param>
/// <param name="dst"></param>
public ILineString TestGraphBuilder2WithSampleGeometries(string fileName, Coordinate src, Coordinate dst)
{
var reader = new ShapefileReader(fileName);
var edges = reader.ReadAll();
return TestGraphBuilder2WithSampleGeometries(edges, src, dst);
}
private static void DoTest(IGeometryCollection geomsWrite, Ordinates ordinates, bool testGetOrdinate = true)
{
string fileName = string.Empty;
try
{
fileName = Path.GetTempFileName();
fileName = Path.ChangeExtension(fileName, "shp");
ShapefileWriter.WriteGeometryCollection(fileName, geomsWrite);
var reader = new ShapefileReader(fileName, ShapeFileShapeFactory.FactoryRead);
var geomsRead = reader.ReadAll();
// This tests x- and y- values
if (!geomsWrite.EqualsExact(geomsRead))
{
Assert.AreEqual(geomsWrite.NumGeometries, geomsRead.NumGeometries);
//
// This akward test is necessary since EqualsTopologically throws currently exceptions
var equal = true;
for (var i = 0; i < geomsRead.NumGeometries; i++)
{
var gw = geomsWrite.GetGeometryN(i);
var gr = geomsRead.GetGeometryN(i);
if (gw.IsEmpty && gr.IsEmpty)
{
if ((gw is ILineal && gr is ILineal) ||
(gw is IPolygonal && gr is IPolygonal))
{
// suppose these are equal
}
else
{
Console.WriteLine(string.Format("Geometries don't match at index {0}", i));
Console.WriteLine(string.Format(" written: {0}", gw.AsText()));
Console.WriteLine(string.Format(" read : {0}", gr.AsText()));
equal = false;
Assert.IsTrue(equal, "Differenced found in geometries written and read!");
}
}
else if (!gw.EqualsExact(gr))
{
var hsm = new HausdorffSimilarityMeasure().Measure(gw, gr);
var asm = new AreaSimilarityMeasure().Measure(gw, gr);
var smc = SimilarityMeasureCombiner.Combine(hsm, asm);
if (!gw.EqualsNormalized(gr) || (1d - smc) > 1e-7)
{
Console.WriteLine(string.Format("Geometries don't match at index {0}", i));
Console.WriteLine(string.Format(" written: {0}", gw.AsText()));
Console.WriteLine(string.Format(" read : {0}", gr.AsText()));
equal = false;
Assert.IsTrue(equal, "Differenced found in geometries written and read!");
}
}
}
//For polygons this has a tendency to fail, since the polygonhandler might rearrange the whole thing
if (testGetOrdinate)
{
if ((ordinates & Ordinates.Z) == Ordinates.Z)
{
var writeZ = geomsWrite.GetOrdinates(Ordinate.Z);
var readZ = geomsRead.GetOrdinates(Ordinate.Z);
Assert.IsTrue(ArraysEqual(writeZ, readZ));
}
if ((ordinates & Ordinates.M) == Ordinates.M)
{
var writeM = geomsWrite.GetOrdinates(Ordinate.M);
var readM = geomsRead.GetOrdinates(Ordinate.M);
Assert.IsTrue(ArraysEqual(writeM, readM));
}
}
}
// delete sample files
File.Delete(fileName);
File.Delete(Path.ChangeExtension(fileName, "shx"));
File.Delete(Path.ChangeExtension(fileName, "dbf"));
}
catch (AssertionException ex)
{
Console.WriteLine("Failed test with {0}", ordinates);
Console.WriteLine(ex.Message);
Console.WriteLine(" Testfile '{0}' not deleted!", fileName);
throw;
}
}
public void Test()
{
ShapefileReader.ReadShapefile(@"C:\Users\Joe\src\NetTopologySuite\NetTopologySuite.Samples.Shapefiles\CA_Cable_region.shp", Mock.Of <ShapefileVisitorBase>());
}
// see https://code.google.com/p/nettopologysuite/issues/detail?id=167
public void Issue167_EnsureAllBinaryContentIsReaded()
{
int i = 0;
ShapefileReader reader = new ShapefileReader("Issue167.shp");
foreach (IGeometry geom in reader)
{
Assert.That(geom, Is.Not.Null, "geom null");
Console.WriteLine("geom {0}: {1}", ++i, geom);
}
Assert.That(i, Is.EqualTo(201));
}
public void BuildGraphFromCompleteGraphShapefile()
{
const string shapepath = "graph.shp";
const int count = 1179;
Assert.IsTrue(File.Exists(shapepath));
var reader = new ShapefileReader(shapepath);
var edges = reader.ReadAll();
Assert.IsNotNull(edges);
Assert.IsInstanceOf(typeof (GeometryCollection), edges);
Assert.AreEqual(count, edges.NumGeometries);
var startls = edges.GetGeometryN(515).GetGeometryN(0) as ILineString;
Assert.IsNotNull(startls);
var startPoint = startls.EndPoint;
Assert.AreEqual(2317300d, startPoint.X);
Assert.AreEqual(4843961d, startPoint.Y);
var endls = edges.GetGeometryN(141).GetGeometryN(0) as ILineString;
;
Assert.IsNotNull(endls);
var endPoint = endls.StartPoint;
Assert.AreEqual(2322739d, endPoint.X);
Assert.AreEqual(4844539d, endPoint.Y);
var builder = new GraphBuilder2(true);
foreach (IMultiLineString mlstr in edges.Geometries)
{
Assert.AreEqual(1, mlstr.NumGeometries);
var str = mlstr.GetGeometryN(0) as ILineString;
Assert.IsNotNull(str);
Assert.IsTrue(builder.Add(str));
}
builder.Initialize();
var path = builder.Perform(startPoint, endPoint);
Assert.IsNotNull(path);
SaveGraphResult(path);
var reverse = builder.Perform(endPoint, startPoint);
Assert.IsNotNull(reverse);
Assert.AreEqual(path, reverse.Reverse());
}
public void BuildGraphFromCompleteGraphShapefile()
{
var shapepath = "graph.shp";
var count = 1179;
Assert.IsTrue(File.Exists(shapepath), string.Format("File not found: '{0}'", shapepath));
var reader = new ShapefileReader(shapepath);
var edges = reader.ReadAll();
Assert.IsNotNull(edges);
Assert.IsInstanceOf(typeof(GeometryCollection), edges);
Assert.AreEqual(count, edges.NumGeometries);
// Insert arbitrary userdata
for (var i = 0; i < count; i++)
{
var g = edges.GetGeometryN(i) as IMultiLineString;
Assert.IsNotNull(g);
var ls = g.GetGeometryN(0) as ILineString;
Assert.IsNotNull(ls);
Assert.IsNull(ls.UserData);
ls.UserData = i;
Assert.IsNotNull(ls.UserData);
}
var startls = edges.GetGeometryN(515).GetGeometryN(0) as ILineString;
Assert.IsNotNull(startls);
var startPoint = startls.EndPoint;
Assert.AreEqual(2317300d, startPoint.X);
Assert.AreEqual(4843961d, startPoint.Y);
var endls = edges.GetGeometryN(141).GetGeometryN(0) as ILineString; ;
Assert.IsNotNull(endls);
var endPoint = endls.StartPoint;
Assert.AreEqual(2322739d, endPoint.X);
Assert.AreEqual(4844539d, endPoint.Y);
var finder = new PathFinder(true);
foreach (IMultiLineString mlstr in edges.Geometries)
{
Assert.AreEqual(1, mlstr.NumGeometries);
var str = mlstr.GetGeometryN(0) as ILineString;
Assert.IsNotNull(str);
Assert.IsNotNull(str.UserData);
Assert.IsTrue(finder.Add(str));
}
finder.Initialize();
var expectedResultCount = 8;
var path = finder.Find(startPoint, endPoint);
Assert.IsNotNull(path);
Assert.IsInstanceOf(typeof (IMultiLineString), path);
var strings = (IMultiLineString) path;
Assert.AreEqual(expectedResultCount, strings.NumGeometries);
foreach (var g in strings.Geometries)
{
Assert.IsNotNull(g.UserData);
Console.WriteLine("{0} : {1}", g.UserData, g);
}
var reversedPath = finder.Find(endPoint, startPoint);
Assert.IsNotNull(reversedPath);
Assert.IsInstanceOf(typeof(IMultiLineString), reversedPath);
var reversedStrings = (IMultiLineString) reversedPath;
Assert.AreEqual(expectedResultCount, reversedStrings.NumGeometries);
foreach (var g in reversedStrings.Geometries)
{
Assert.IsNotNull(g.UserData);
Console.WriteLine("{0} : {1}", g.UserData, g);
}
for (var i = 0; i < expectedResultCount; i++)
{
var item = strings.GetGeometryN(i);
var itemReversed = strings.GetGeometryN(expectedResultCount - 1 - i);
Assert.AreNotEqual(item.UserData, itemReversed.UserData);
Assert.AreNotEqual(item, itemReversed);
}
}
public void BuildGraphFromMinimalGraphShapefile()
{
const string shapepath = "minimalgraph.shp";
const int count = 15;
Assert.IsTrue(File.Exists(shapepath));
var reader = new ShapefileReader(shapepath);
var edges = reader.ReadAll();
Assert.IsNotNull(edges);
Assert.IsInstanceOf(typeof (GeometryCollection), edges);
Assert.AreEqual(count, edges.NumGeometries);
var startls = edges.GetGeometryN(0).GetGeometryN(0) as ILineString;
Assert.IsNotNull(startls);
var endls = edges.GetGeometryN(5).GetGeometryN(0) as ILineString;
;
Assert.IsNotNull(endls);
var builder = new GraphBuilder2(true);
foreach (IMultiLineString mlstr in edges.Geometries)
{
Assert.AreEqual(1, mlstr.NumGeometries);
var str = mlstr.GetGeometryN(0) as ILineString;
Assert.IsNotNull(str);
Assert.IsTrue(builder.Add(str));
}
builder.Initialize();
var path = builder.Perform(startls.StartPoint, endls.EndPoint);
Assert.IsNotNull(path);
}
private void TestBugCimino()
{
try
{
string file = "countryCopy.shp";
if (!File.Exists(file))
throw new FileNotFoundException();
ShapefileReader sfr = new ShapefileReader(file);
IGeometryCollection gc = sfr.ReadAll();
for (int i = 0; i < gc.NumGeometries; i++)
Console.WriteLine(i + " " + gc.Geometries[i].Envelope);
// IsValidOp.CheckShellsNotNested molto lento nell'analisi di J == 7 (Poligono con 11600 punti)
var write = Path.Combine(Path.GetTempPath(), "copy_countryCopy");
var sfw = new ShapefileWriter(gc.Factory);
sfw.Write(write, gc);
Console.WriteLine("Write Complete!");
}
catch (Exception ex)
{
throw ex;
}
}
public void BuildGraphFromStradeShapefile()
{
var shapepath = "strade_fixed.shp";
var count = 703;
Assert.IsTrue(File.Exists(shapepath));
var reader = new ShapefileReader(shapepath);
var edges = reader.ReadAll();
Assert.IsNotNull(edges);
Assert.IsInstanceOf(typeof (GeometryCollection), edges);
Assert.AreEqual(count, edges.NumGeometries);
Coordinate startCoord = new Coordinate(2317300d, 4843961d);
Coordinate endCoord = new Coordinate(2322739d, 4844539d);
var startFound = false;
var endFound = false;
var builder = new GraphBuilder2(true);
foreach (IMultiLineString mlstr in edges.Geometries)
{
Assert.AreEqual(1, mlstr.NumGeometries);
var str = mlstr.GetGeometryN(0) as ILineString;
Assert.IsNotNull(str);
Assert.IsTrue(builder.Add(str));
if (!startFound)
{
var coords = new List<Coordinate>(str.Coordinates);
if (coords.Contains(startCoord))
startFound = true;
}
if (!endFound)
{
var coords = new List<Coordinate>(str.Coordinates);
if (coords.Contains(endCoord))
endFound = true;
}
}
builder.Initialize();
Assert.IsTrue(startFound);
Assert.IsTrue(endFound);
var path = builder.Perform(startCoord, endCoord);
Assert.IsNotNull(path);
SaveGraphResult(path);
var reverse = builder.Perform(startCoord, endCoord);
Assert.IsNotNull(reverse);
Assert.AreEqual(path, reverse.Reverse());
}
private static IGeometry ReadGeometriesFromShapefile(String filename, IGeometryFactory geomFact)
{
var shpfile = new ShapefileReader(filename, geomFact);
var result = shpfile.ReadAll();
return result;
}
