/// <summary> /// Writes a <b>Geometry</b> to the file. /// </summary> /// <param name="geometry">The <b>Geometry</b> to write to the file.</param> /// <exception cref="ArgumentNullException">The geometry is a null reference (Nothing in Visual Basic).</exception> public void WriteGeometry(Geometry geometry) { if (geometry == null) { throw new ArgumentNullException("geometry"); } //// if (typeof(geometry == GeometryCollection) //// { //// this.WriteGeometryCollection((GeometryCollection)geometry); //// } // Make sure we have the same shape type - if not the file is invalid if (_type == ShapeType.Undefined) { _type = Shapefile.GetShapeType(geometry); } else if (_type != Shapefile.GetShapeType(geometry)) { throw new ArgumentException(String.Format(System.Globalization.CultureInfo.InvariantCulture, "An invalid shapet type has been encountered - expected '{0}' but got '{1}.", _type, Shapefile.GetShapeType(geometry)), "geometry"); } // Get handler ShapeHandler handler = Shapefile.GetShapeHandler(_type); // Get the length of the geometry in bytes int length = handler.GetLength(geometry); // Write record number _shpWriter.WriteIntBE(_count + 1); // Write record length _shpWriter.WriteIntBE(length); // Write geometry handler.Write(geometry, _shpWriter, _factory); // Increase bounds to include geometry if needed _bounds.expandToInclude(geometry.getEnvelopeInternal()); // Every time we write a geometry we need to increment the count _count++; // Write index information _shxWriter.WriteIntBE(_shpLength); _shxWriter.WriteIntBE(length); // Every time we write a geometry we need to increment the byte length _shpLength += HEADER_shpLength + length; }
public DataTable Query(Envelope extents) { DataTable table = this.GetDataTable(); ArrayList indexes = new ArrayList(_spatialIndex.query(extents).toArray()); // Sort the results so we can go through the files sequentially indexes.Sort(); ShapeHandler handler = null; switch (_type) { case ShapeType.Point: handler = new PointHandler(); break; case ShapeType.Arc: handler = new MultiLineHandler(); break; case ShapeType.Polygon: handler = new PolygonHandler(); break; } using (BinaryReader dbfReader = new BinaryReader(File.OpenRead(Path.Combine(Path.GetDirectoryName(_path), Path.GetFileNameWithoutExtension(_path) + ".dbf")))) using (BigEndianBinaryReader shpReader = new BigEndianBinaryReader(File.OpenRead(_path))) { foreach (ShapefileRecordPointer pointer in indexes) { ArrayList record = new ArrayList(); // Step 1: Get the geometry // NOTE: We add 8 here to skip the content length and record numer - we // already have that information in the pointer object. shpReader.BaseStream.Position = pointer.GeometryOffset + 8; record.Add(handler.Read(shpReader, _factory)); // Step 2: Get the attributes dbfReader.BaseStream.Position = pointer.AttributesOffset; record.AddRange(DbaseFileReader.ReadRecord(dbfReader, _dbfHeader)); table.Rows.Add(record.ToArray()); } } return(table); }
/// <summary> /// Reads the shapefile and returns a <b>GeometryCollection</b> representing all the records in the shapefile. /// </summary> /// <returns>A <b>GeometryCollection</b> representing every record in the shapefile.</returns> public GeometryCollection ReadAll() { java.util.ArrayList list = new java.util.ArrayList(); ShapeHandler handler = Shapefile.GetShapeHandler(_mainHeader.ShapeType); if (handler == null) { throw new NotSupportedException("Unsupported shape type:" + _mainHeader.ShapeType); } foreach (Geometry geometry in this) { list.add(geometry); } Geometry[] geomArray = GeometryFactory.toGeometryArray(list); return(_geometryFactory.createGeometryCollection(geomArray)); }
/// <summary> /// Initializes a new instance of the ShapefileEnumerator class. /// </summary> 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. FileStream stream = new FileStream(_parent._filename, System.IO.FileMode.Open, FileAccess.Read, FileShare.Read); _shpBinaryReader = new BigEndianBinaryReader(stream); // skip header - since parent has already read this. _shpBinaryReader.ReadBytes(100); ShapeType 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 <see cref="ShapefileEnumerator">ShapefileEnumerator</see> class. /// </summary> 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 only one IEnumerator // could be given out. _shpBinaryReader = new BigEndianBinaryReader(new FileStream(_parent._filename, System.IO.FileMode.Open, FileAccess.Read, FileShare.Read)); // skip header - since parent has already read this. _shpBinaryReader.ReadBytes(100); ShapeType type = _parent._mainHeader.ShapeType; _handler = Shapefile.GetShapeHandler(type); if (_handler == null) { throw new NotSupportedException("Unsuported shape type:" + type); } }
/// <summary> /// Reads the shapefile and returns a GeometryCollection representing all the records in the shapefile. /// </summary> /// <returns>GeometryCollection representing every record in the shapefile.</returns> public GeometryCollection ReadAll() { ArrayList list = new ArrayList(); ShapeType type = _mainHeader.ShapeType; ShapeHandler handler = Shapefile.GetShapeHandler(type); if (handler == null) { throw new NotSupportedException("Unsupported shape type:" + type); } int i = 0; foreach (Geometry geometry in this) { list.Add(geometry); i++; } Geometry[] geomArray = GeometryFactory.ToGeometryArray(list); return(_geometryFactory.CreateGeometryCollection(geomArray)); //return geometryCollection; }
/// <summary> /// Writes a shapefile to disk. /// </summary> /// <remarks> /// <para>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.</para> /// <para>The dbase file for the corresponding shapefile contains one column called row. It contains /// the row number.</para> /// </remarks> /// <param name="filename">The filename to write to (minus the .shp extension).</param> /// <param name="geometryCollection">The GeometryCollection to write.</param> /// <param name="geometryFactory">The geometry factory to use.</param> public static void Write(string filename, GeometryCollection geometryCollection, GeometryFactory geometryFactory) { 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[0])); Geometry body; int numShapes = geometryCollection.GetNumGeometries(); // 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[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 shpHeader = new ShapefileHeader(); shpHeader.FileLength = shpLength; // get envelopse in external coordinates Envelope env = geometryCollection.GetEnvelopeInternal(); 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 = Shapefile.GetShapeType(geometryCollection[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 = Shapefile.GetShapeType(geometryCollection[0]); shxHeader.Write(shxBinaryWriter); // write the individual records. int _pos = 50; // header length in WORDS for (int i = 0; i < numShapes; i++) { body = geometryCollection[i]; int recordLength = handler.GetLength(body); Debug.Assert(Shapefile.GetShapeType(body) != shpHeader.ShapeType, String.Format("Item {0} in the GeometryCollection is not the same Shapetype as Item 0.", i)); 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(); Debug.Assert(_pos != shpLength, "File length in header and actual file length do not match."); //stream.Close(); //Trace.WriteLineIf(Shapefile.TraceSwitch.Enabled,"File length pos:"+_pos*2+" bytes"); //Trace.WriteLineIf(Shapefile.TraceSwitch.Enabled,"File length pos "+_pos+ " words"); WriteDummyDbf(filename + ".dbf", numShapes); }
/// <summary> /// Writes a <b>Geometry</b> to the given binary wirter. /// </summary> /// <param name="geometry">The geometry to write.</param> /// <param name="writer">The file stream to write to.</param> /// <param name="factory">The geometry factory to use.</param> public override void Write(Geometry geometry, BinaryWriter writer, GeometryFactory factory) { /* This makes exporting really slow for complex polygons * if (geometry.isValid() == false) * { * Trace.WriteLine("Invalid polygon being written."); * }*/ GeometryCollection multi; if (geometry is GeometryCollection) { multi = (GeometryCollection)geometry; } else { GeometryFactory gf = new GeometryFactory(geometry.getPrecisionModel()); //multi = new MultiPolygon(new Polygon[]{(Polygon) geometry}, geometry.PrecisionModel, geometry.GetSRID()); multi = gf.createMultiPolygon(new Polygon[] { (Polygon)geometry }); } //file.setLittleEndianMode(true); writer.Write(int.Parse(Enum.Format(typeof(ShapeType), this.ShapeType, "d"))); Envelope box = multi.getEnvelopeInternal(); Envelope bounds = ShapeHandler.GetEnvelopeExternal(factory.getPrecisionModel(), box); writer.Write(bounds.getMinX()); writer.Write(bounds.getMinY()); writer.Write(bounds.getMaxX()); writer.Write(bounds.getMaxY()); int numParts = GetNumParts(multi); int numPoints = multi.getNumPoints(); writer.Write(numParts); writer.Write(numPoints); // write the offsets to the points int offset = 0; for (int part = 0; part < multi.getNumGeometries(); part++) { // offset to the shell points Polygon polygon = (Polygon)multi.getGeometryN(part); writer.Write(offset); offset = offset + polygon.getExteriorRing().getNumPoints(); // offstes to the holes for (int i = 0; i < polygon.getNumInteriorRing(); i++) { writer.Write(offset); offset = offset + polygon.getInteriorRingN(i).getNumPoints(); } } // write the points for (int part = 0; part < multi.getNumGeometries(); part++) { Polygon poly = (Polygon)multi.getGeometryN(part); Coordinate[] coords = poly.getExteriorRing().getCoordinates(); if (com.vividsolutions.jts.algorithm.RobustCGAlgorithms.isCCW(coords) == true) { Array.Reverse(coords); //coords = coords.ReverseCoordinateOrder(); } WriteCoords(coords, writer, factory); for (int i = 0; i < poly.getNumInteriorRing(); i++) { Coordinate[] coords2 = poly.getInteriorRingN(i).getCoordinates(); if (com.vividsolutions.jts.algorithm.RobustCGAlgorithms.isCCW(coords2) == false) { Array.Reverse(coords2); //coords = coords.ReverseCoordinateOrder(); } WriteCoords(coords2, writer, factory); } } }
/// <summary> /// Writes a Geometry to the given binary wirter. /// </summary> /// <param name="geometry">The geometry to write.</param> /// <param name="file">The file stream to write to.</param> /// <param name="geometryFactory">The geometry factory to use.</param> public override void Write(Geometry geometry, System.IO.BinaryWriter file, GeometryFactory geometryFactory) { if (geometry.IsValid() == false) { Trace.WriteLine("Invalid polygon being written."); } GeometryCollection multi; if (geometry is GeometryCollection) { multi = (GeometryCollection)geometry; } else { GeometryFactory gf = new GeometryFactory(geometry.PrecisionModel, geometry.GetSRID()); //multi = new MultiPolygon(new Polygon[]{(Polygon) geometry}, geometry.PrecisionModel, geometry.GetSRID()); multi = gf.CreateMultiPolygon(new Polygon[] { (Polygon)geometry }); } //file.setLittleEndianMode(true); file.Write(int.Parse(Enum.Format(typeof(ShapeType), this.ShapeType, "d"))); Envelope box = multi.GetEnvelopeInternal(); Envelope bounds = ShapeHandler.GetEnvelopeExternal(geometryFactory.PrecisionModel, box); file.Write(bounds.MinX); file.Write(bounds.MinY); file.Write(bounds.MaxX); file.Write(bounds.MaxY); int numParts = GetNumParts(multi); int numPoints = multi.GetNumPoints(); file.Write(numParts); file.Write(numPoints); // write the offsets to the points int offset = 0; for (int part = 0; part < multi.Count; part++) { // offset to the shell points Polygon polygon = (Polygon)multi[part]; file.Write(offset); offset = offset + polygon.Shell.GetNumPoints(); // offstes to the holes foreach (LinearRing ring in polygon.Holes) { file.Write(offset); offset = offset + ring.GetNumPoints(); } } // write the points for (int part = 0; part < multi.Count; part++) { Polygon poly = (Polygon)multi[part]; Coordinates points = poly.Shell.GetCoordinates(); if (_cga.IsCCW(points) == true) { //points = points.ReverseCoordinateOrder(); } WriteCoords(points, file, geometryFactory); foreach (LinearRing ring in poly.Holes) { Coordinates points2 = ring.GetCoordinates(); if (_cga.IsCCW(points2) == false) { //points2 = points2.ReverseCoordinateOrder(); } WriteCoords(points2, file, geometryFactory); } } }