Beispiel #1
0
        /// <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));
        }
Beispiel #2
0
            /// <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);
                }
            }
Beispiel #3
0
        /// <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;
        }
Beispiel #4
0
        /// <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);
        }
Beispiel #5
0
        /// <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;
        }