public ShapeReader(IStreamProviderRegistry streamProviderRegistry) { if (streamProviderRegistry == null) throw new ArgumentNullException("streamProviderRegistry"); m_StreamProviderRegistry = streamProviderRegistry; m_ShapeFileHeader = new ShapefileHeader(ShapeReaderStream); m_ShapeHandler = Shapefile.GetShapeHandler(ShapefileHeader.ShapeType); m_ShapeOffsetCache = new Lazy<long[]>(BuildOffsetCache, LazyThreadSafetyMode.ExecutionAndPublication); }
/// <summary> /// This tests the specified file in order to determine what type of vector the file contains. /// This returns unspecified if the file format is not supported by this provider. /// </summary> /// <param name="fileName">The string fileName to test</param> /// <returns>A FeatureType clarifying what sort of features are stored on the data type.</returns> public virtual FeatureType GetFeatureType(string fileName) { ShapefileHeader sh = new ShapefileHeader(fileName); if (sh.ShapeType == ShapeType.Polygon || sh.ShapeType == ShapeType.PolygonM || sh.ShapeType == ShapeType.PolygonZ) { return(FeatureType.Polygon); } if (sh.ShapeType == ShapeType.PolyLine || sh.ShapeType == ShapeType.PolyLineM || sh.ShapeType == ShapeType.PolyLineZ) { return(FeatureType.Line); } if (sh.ShapeType == ShapeType.Point || sh.ShapeType == ShapeType.PointM || sh.ShapeType == ShapeType.PointZ) { return(FeatureType.Point); } if (sh.ShapeType == ShapeType.MultiPoint || sh.ShapeType == ShapeType.MultiPointM || sh.ShapeType == ShapeType.MultiPointZ) { return(FeatureType.MultiPoint); } return(FeatureType.Unspecified); }
public static void Convert(ShapefileGeometryType type, SqlDataReader reader, string shapefile) { if (!reader.Read()) { throw new Exception("No Results found"); } int geomOrdinal, colCount; ShapefileHeader shapeHeader = ShapefileHeader.CreateEmpty(type); DbfHeader dbfHeader = BuildHeader(reader, out geomOrdinal, out colCount); GeometryFactory factory = new GeometryFactory(); Envelope env = shapeHeader.Bounds; using (ShapefileDataWriter writer = ShapefileDataWriter.Create(shapefile, dbfHeader, shapeHeader)) { do { SqlGeometry geom = reader[geomOrdinal] as SqlGeometry; if (!geom.STIsValid()) { geom = geom.MakeValid(); } for (int i = 0, offset = 0; i < colCount; i++) { if (i == geomOrdinal) { offset++; } writer.Record.SetRaw(i, reader[i + offset]); } ExpandEnv(env, geom.STBoundary()); writer.Write(ConvertToGeometry.SqlGeometryToGeometry(geom, factory)); }while (reader.Read()); } }
public ShapeReader(string shapeFilePath) { if (shapeFilePath == null) { throw new ArgumentNullException("shapeFilePath"); } if (string.IsNullOrWhiteSpace(shapeFilePath)) { throw new ArgumentException("shapeFilePath", "Path to shapefile can't be empty"); } if (!File.Exists(shapeFilePath)) { throw new FileNotFoundException("Given shapefile doesn't exist", shapeFilePath); } m_ShapeFilePath = shapeFilePath; m_ShapeFileHeader = new ShapefileHeader(ShapeReaderStream); m_ShapeHandler = Shapefile.GetShapeHandler(ShapefileHeader.ShapeType); m_ShapeOffsetCache = new Lazy <long[]>(BuildOffsetCache, LazyThreadSafetyMode.ExecutionAndPublication); }
public ShapeReader(string shapeFilePath) { if (shapeFilePath == null) { throw new ArgumentNullException("shapeFilePath"); } if (string.IsNullOrWhiteSpace(shapeFilePath)) { throw new ArgumentException("shapeFilePath", "Path to shapefile can't be empty"); } if (!File.Exists(shapeFilePath)) { throw new FileNotFoundException("Given shapefile doesn't exist", shapeFilePath); } m_ShapeFilePath = shapeFilePath; m_ShapeFileHeader = new ShapefileHeader(ShapeReaderStream); m_ShapeHandler = Shapefile.GetShapeHandler(ShapefileHeader.ShapeType); m_ShapeOffsetCache = new Lazy<long[]>(BuildOffsetCache, LazyThreadSafetyMode.ExecutionAndPublication); }
public static void Reproject(string destinationFolder, string projection, params ReprojectShapefile[] shapes) { ProjectionInfo targetProjection = ProjectionInfo.FromEsriString(projection); foreach (ReprojectShapefile shape in shapes) { string shapePath = Path.Combine(destinationFolder, shape.DestinationName); ShapefileHeader shapeHeader = ShapefileHeader.CreateEmpty(ShapefileGeometryType.Polygon); DbfHeader dbfHeader = new DbfHeader(); dbfHeader.AddCharacter("Label", 80); GeometryFactory gf = new GeometryFactory(); using (ShapefileDataWriter writer = ShapefileDataWriter.Create(shapePath + ".shp", dbfHeader, shapeHeader)) { GeometryTransform transform = null; if (File.Exists(Path.ChangeExtension(shape.Source, ".prj"))) { transform = GeometryTransform.GetTransform(shape.Source, projection); if (transform != null) { File.WriteAllText(shapePath + ".prj", projection); } else { File.Copy(Path.ChangeExtension(shape.Source, ".prj"), shapePath + ".prj"); } } using (ShapefileIndexReader index = new ShapefileIndexReader(Path.ChangeExtension(shape.Source, ".shx"))) { if (transform != null) { writer.Header.Bounds.ExpandToInclude(transform.Apply(index.Header.Bounds)); } else { writer.Header.Bounds.ExpandToInclude(index.Header.Bounds); } Task[] tasks = new Task[Environment.ProcessorCount]; for (int i = 0; i < tasks.Length; i++) { tasks[i] = Task.Factory.StartNew(() => { using (ShapefileBlockReader reader = new ShapefileBlockReader(shape.Source, index, gf, transform)) { while (reader.Read()) { writer.Write(reader.Geometry, reader.Record.GetString(shape.Label)); } } }); } Task.WaitAll(tasks); writer.Flush(); } } } }
/// <summary> /// Writes an entire shapefile to disk in one call using a geometryCollection. /// </summary> /// <remarks> /// Assumes the type given for the first geometry is the same for all subsequent geometries. /// For example, is, if the first Geometry is a Multi-polygon/ Polygon, the subsequent geometies are /// Muli-polygon/ polygon and not lines or points. /// The dbase file for the corresponding shapefile contains one column called row. It contains /// the row number. /// </remarks> /// <param name="filename">The filename to write to (minus the .shp extension).</param> /// <param name="geometryCollection">The GeometryCollection to write.</param> public virtual void Write(string filename, GeometryCollection geometryCollection) { System.IO.FileStream shpStream = new System.IO.FileStream(filename + ".shp", System.IO.FileMode.Create); System.IO.FileStream shxStream = new System.IO.FileStream(filename + ".shx", System.IO.FileMode.Create); BigEndianBinaryWriter shpBinaryWriter = new BigEndianBinaryWriter(shpStream); BigEndianBinaryWriter shxBinaryWriter = new BigEndianBinaryWriter(shxStream); // assumes ShapeHandler handler = Shapefile.GetShapeHandler(Shapefile.GetShapeType(geometryCollection.Geometries[0])); IGeometry body; int numShapes = geometryCollection.NumGeometries; // calc the length of the shp file, so it can put in the header. int shpLength = 50; for (int i = 0; i < numShapes; i++) { body = geometryCollection.Geometries[i]; shpLength += 4; // length of header in WORDS shpLength += handler.GetLength(body); // length of shape in WORDS } int shxLength = 50 + (4 * numShapes); // write the .shp header ShapefileHeader ShapeHeader = new ShapefileHeader(); ShapeHeader.FileLength = shpLength; // get envelope in external coordinates IEnvelope env = geometryCollection.EnvelopeInternal; IEnvelope bounds = ShapeHandler.GetEnvelopeExternal(new PrecisionModel(geometryFactory.PrecisionModel), env); ShapeHeader.Bounds = bounds; // assumes Geometry type of the first item will the same for all other items // in the collection. ShapeHeader.ShapeType = Shapefile.GetShapeType(geometryCollection.Geometries[0]); ShapeHeader.Write(shpBinaryWriter); // write the .shx header ShapefileHeader shxHeader = new ShapefileHeader(); shxHeader.FileLength = shxLength; shxHeader.Bounds = ShapeHeader.Bounds; // assumes Geometry type of the first item will the same for all other items in the collection. shxHeader.ShapeType = Shapefile.GetShapeType(geometryCollection.Geometries[0]); shxHeader.Write(shxBinaryWriter); // write the individual records. int _pos = 50; // header length in WORDS for (int i = 0; i < numShapes; i++) { body = geometryCollection.Geometries[i]; int recordLength = handler.GetLength(body); shpBinaryWriter.WriteIntBE(i + 1); shpBinaryWriter.WriteIntBE(recordLength); shxBinaryWriter.WriteIntBE(_pos); shxBinaryWriter.WriteIntBE(recordLength); _pos += 4; // length of header in WORDS handler.Write(body, shpBinaryWriter, geometryFactory); _pos += recordLength; // length of shape in WORDS } shxBinaryWriter.Flush(); shxBinaryWriter.Close(); shpBinaryWriter.Flush(); shpBinaryWriter.Close(); // WriteDummyDbf(filename + ".dbf", numShapes); }
/// <summary> /// Writes the geometry information from the specified IFeatureLayer to the file /// </summary> /// <param name="filename">A filename</param> /// <param name="Layer">An IFeatureLayer to save</param> public virtual void Write(string filename, IFeatureSet Layer) { if (Layer == null) return; if (Layer.Features == null) return; if (Layer.Features.Count == 0) return; string rootname, shpFile, shxFile; rootname = System.IO.Path.GetDirectoryName(filename) + "\\" + System.IO.Path.GetFileNameWithoutExtension(filename); shpFile = rootname + ".shp"; shxFile = rootname + ".shx"; System.IO.FileStream shpStream = new System.IO.FileStream(shpFile, System.IO.FileMode.Create); System.IO.FileStream shxStream = new System.IO.FileStream(shxFile, System.IO.FileMode.Create); BigEndianBinaryWriter shpBinaryWriter = new BigEndianBinaryWriter(shpStream); BigEndianBinaryWriter shxBinaryWriter = new BigEndianBinaryWriter(shxStream); // assumes // ShapeHandler handler = Shapefile.GetShapeHandler(Shapefile.GetShapeType(geometryCollection.Geometries[0])); ShapeHandler handler = null; switch (Layer.Features[0].FeatureType) { case FeatureTypes.Unspecified: return; case FeatureTypes.Line: handler = new MultiLineHandler(); break; case FeatureTypes.Point: handler = new PointHandler(); break; case FeatureTypes.Polygon: handler = new PolygonHandler(); break; } IBasicGeometry body; int numShapes = Layer.Features.Count; // calc the length of the shp file, so it can put in the header. int shpLength = 50; for (int i = 0; i < numShapes; i++) { body = Layer.Features[i].BasicGeometry; shpLength += 4; // length of header in WORDS shpLength += handler.GetLength(body); // length of shape in WORDS } int shxLength = 50 + (4 * numShapes); // write the .shp header ShapefileHeader ShapeHeader = new ShapefileHeader(); ShapeHeader.FileLength = shpLength; // get envelope in external coordinates IEnvelope env = Layer.Envelope; //IEnvelope bounds = ShapeHandler.GetEnvelopeExternal(new PrecisionModel(geometryFactory.PrecisionModel), env); ShapeHeader.Bounds = env; // write the .shx header ShapefileHeader shxHeader = new ShapefileHeader(); shxHeader.FileLength = shxLength; shxHeader.Bounds = ShapeHeader.Bounds; // assumes Geometry type of the first item will the same for all other items // in the collection. switch(Layer.FeatureType) { case FeatureTypes.Polygon: ShapeHeader.ShapeType = ShapeGeometryTypes.Polygon; shxHeader.ShapeType = ShapeGeometryTypes.Polygon; break; case FeatureTypes.Point: ShapeHeader.ShapeType = ShapeGeometryTypes.Point; shxHeader.ShapeType = ShapeGeometryTypes.Point; break; case FeatureTypes.Line: ShapeHeader.ShapeType = ShapeGeometryTypes.LineString; shxHeader.ShapeType = ShapeGeometryTypes.LineString; break; } ShapeHeader.Write(shpBinaryWriter); // assumes Geometry type of the first item will the same for all other items in the collection. shxHeader.Write(shxBinaryWriter); // write the individual records. int _pos = 50; // header length in WORDS for (int i = 0; i < numShapes; i++) { body = Layer.Features[i].BasicGeometry; int recordLength = handler.GetLength(body); shpBinaryWriter.WriteIntBE(i + 1); shpBinaryWriter.WriteIntBE(recordLength); shxBinaryWriter.WriteIntBE(_pos); shxBinaryWriter.WriteIntBE(recordLength); _pos += 4; // length of header in WORDS handler.Write(body, shpBinaryWriter, geometryFactory); _pos += recordLength; // length of shape in WORDS } shxBinaryWriter.Flush(); shxBinaryWriter.Close(); shpBinaryWriter.Flush(); shpBinaryWriter.Close(); }
//[InlineData(@"LPC_Individual_Landmark_and_Historic_Building_Database\LPC_Individual_Landmark_and_Historic_Building_Database")] public void Shape_OutputFeatures_Borough_Boundaries(string shapeFilePath) { string shapeDirectory = $"../../../../../Files/{shapeFilePath}"; string shapePath = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), shapeDirectory)); GeometryFactory factory = new(); ShapefileDataReader shapeFileDataReader = new(shapePath, factory); ShapefileHeader shpHeader = shapeFileDataReader.ShapeHeader; _testOutputHelper.WriteLine($"Shape type: {shpHeader.ShapeType}"); //Display the min and max bounds of the shapefile var bounds = shpHeader.Bounds; _testOutputHelper.WriteLine($"Min bounds: ({bounds.MinX},{bounds.MinY})"); _testOutputHelper.WriteLine($"Max bounds: ({bounds.MaxX},{bounds.MaxY})"); //Display summary information about the Dbase file DbaseFileHeader header = shapeFileDataReader.DbaseHeader; _testOutputHelper.WriteLine("Dbase info"); _testOutputHelper.WriteLine($"{header.Fields.Length} Columns, {header.NumRecords} Records"); for (int i = 0; i < header.NumFields; i++) { DbaseFieldDescriptor fldDescriptor = header.Fields[i]; _testOutputHelper.WriteLine($" {fldDescriptor.Name} {fldDescriptor.DbaseType}"); } // Read through all records of the shapefile (geometry and attributes) into a feature collection var features = new List <Feature>(); while (shapeFileDataReader.Read()) { Feature feature = new(); AttributesTable attributesTable = new(); string[] keys = new string[header.NumFields]; var geometry = shapeFileDataReader.Geometry; for (int i = 0; i < header.NumFields; i++) { DbaseFieldDescriptor fldDescriptor = header.Fields[i]; keys[i] = fldDescriptor.Name; // First Field Geometry var value = shapeFileDataReader.GetValue(i + 1); attributesTable.Add(fldDescriptor.Name, value); } feature.Geometry = geometry; feature.Attributes = attributesTable; features.Add(feature); } var result = features; foreach (var f in features) { var z = f.Geometry.Contains(new Point(1032999, 217570)); if (z) { var z1 = f.Attributes["pct"]; //var z2 = f.Attributes["patrol_bor"]; //var z3 = f.Attributes["sector"]; } } }
public ShapefileHeader GetShapeProperties() { ShapefileHeader shpHeader = ShapeFileDataReader.ShapeHeader; return(shpHeader); }
/// <summary> /// Writes a shapefile to disk. /// </summary> /// <remarks> /// Assumes the type given for the first geometry is the same for all subsequent geometries. /// For example, is, if the first Geometry is a Multi-polygon/ Polygon, the subsequent geometies are /// Muli-polygon/ polygon and not lines or points. /// The dbase file for the corresponding shapefile contains one column called row. It contains /// the row number. /// </remarks> /// <param name="filename">The filename to write to (minus the .shp extension).</param> /// <param name="geometryCollection">The GeometryCollection to write.</param> public void Write(IGeometryCollection geometryCollection) { //FileStream shpStream = new FileStream(filename + ".shp", FileMode.Create); //FileStream shxStream = new FileStream(filename + ".shx", FileMode.Create); shpStream = new MemoryStream(); shxStream = new MemoryStream(); BigEndianBinaryWriter shpBinaryWriter = new BigEndianBinaryWriter(shpStream); BigEndianBinaryWriter shxBinaryWriter = new BigEndianBinaryWriter(shxStream); // assumes ShapeHandler handler = Shapefile.GetShapeHandler(GetShapeType(geometryCollection.Geometries[0])); IGeometry body; int numShapes = geometryCollection.NumGeometries; // calc the length of the shp file, so it can put in the header. int shpLength = 50; for (int i = 0; i < numShapes; i++) { body = (IGeometry)geometryCollection.Geometries[i]; shpLength += 4; // length of header in WORDS shpLength += handler.ComputeRequiredLengthInWords(body); // length of shape in WORDS } int shxLength = 50 + (4 * numShapes); // write the .shp header ShapefileHeader shpHeader = new ShapefileHeader(); shpHeader.FileLength = shpLength; // get envelope in external coordinates Envelope env = geometryCollection.EnvelopeInternal as Envelope; Envelope bounds = ShapeHandler.GetEnvelopeExternal(geometryFactory.PrecisionModel, env); shpHeader.Bounds = bounds; // assumes Geometry type of the first item will the same for all other items // in the collection. shpHeader.ShapeType = GetShapeType(geometryCollection.Geometries[0]); shpHeader.Write(shpBinaryWriter); // write the .shx header ShapefileHeader shxHeader = new ShapefileHeader(); shxHeader.FileLength = shxLength; shxHeader.Bounds = shpHeader.Bounds; // assumes Geometry type of the first item will the same for all other items in the collection. shxHeader.ShapeType = GetShapeType(geometryCollection.Geometries[0]); shxHeader.Write(shxBinaryWriter); // write the individual records. int _pos = 50; // header length in WORDS for (int i = 0; i < numShapes; i++) { body = geometryCollection.Geometries[i]; int recordLength = handler.ComputeRequiredLengthInWords(body); shpBinaryWriter.WriteIntBE(i + 1); shpBinaryWriter.WriteIntBE(recordLength); shxBinaryWriter.WriteIntBE(_pos); shxBinaryWriter.WriteIntBE(recordLength); _pos += 4; // length of header in WORDS handler.Write(body, shpBinaryWriter, geometryFactory); _pos += recordLength; // length of shape in WORDS } shxBinaryWriter.Flush(); //shxStream.Seek(0, SeekOrigin.Begin); ////shxBinaryWriter.Close(); shpBinaryWriter.Flush(); //shpStream.Seek(0, SeekOrigin.Begin); //shpBinaryWriter.Close(); // WriteDummyDbf(filename + ".dbf", numShapes); }