Esempio n. 1
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ShapefileReader">ShapefileReader</see> class with the given parameters.
        /// </summary>
        /// <param name="filename">The filename of the shape file to read (with .shp).</param>
        /// <param name="factory">The <b>GeometryFactory</b> to use when creating Geometry objects.</param>
        public ShapefileReader(string filename, GeometryFactory factory)
        {
            if (filename == null)
            {
                throw new ArgumentNullException("filename");
            }

            if (factory == null)
            {
                throw new ArgumentNullException("geometryFactory");
            }

            _filename = filename;
            Trace.WriteLineIf(Shapefile.TraceSwitch.Enabled,"Reading filename:"+filename);

            _geometryFactory = factory;

            // read header information. note, we open the file, read the header information and then
            // close the file. This means the file is not opened again until GetEnumerator() is requested.
            // For each call to GetEnumerator() a new BinaryReader is created.
            using (BigEndianBinaryReader shpBinaryReader = new BigEndianBinaryReader(File.OpenRead(filename)))
            {
                _mainHeader = new ShapefileHeader(shpBinaryReader);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Initializes a new instance of the Shapefile class with the given parameters.
        /// </summary>
        /// <param name="filename">The filename of the shape file to read (with .shp).</param>
        /// <param name="geometryFactory">The GeometryFactory to use when creating Geometry objects.</param>
        public ShapefileReader(string filename, GeometryFactory geometryFactory)
        {
            if (filename == null)
            {
                throw new ArgumentNullException("filename");
            }
            if (geometryFactory == null)
            {
                throw new ArgumentNullException("geometryFactory");
            }
            _filename = filename;
            Trace.WriteLineIf(Shapefile.TraceSwitch.Enabled, "Reading filename:" + filename);

            _geometryFactory = geometryFactory;

            // read header information. note, we open the file, read the header information and then
            // close the file. This means the file is not opened again until GetEnumerator() is requested.
            // For each call to GetEnumerator() a new BinaryReader is created.
            FileStream            stream          = new FileStream(filename, System.IO.FileMode.Open, FileAccess.Read, FileShare.Read);
            BigEndianBinaryReader shpBinaryReader = new BigEndianBinaryReader(stream);

            _mainHeader = new ShapefileHeader(shpBinaryReader);
            shpBinaryReader.Close();
        }
Esempio n. 3
0
 public ShapefileIndexReader(string path)
 {
     _reader = new BigEndianBinaryReader(File.OpenRead(path));
     _header = new ShapefileHeader(_reader);
 }
Esempio n. 4
0
		/// <summary>
		/// Initializes a new instance of the Shapefile class with the given parameters.
		/// </summary>
		/// <param name="filename">The filename of the shape file to read (with .shp).</param>
		/// <param name="geometryFactory">The GeometryFactory to use when creating Geometry objects.</param>
		public ShapefileReader(string filename, GeometryFactory geometryFactory)
		{
			if (filename==null)
			{
				throw new ArgumentNullException("filename");
			}
			if (geometryFactory==null)
			{
				throw new ArgumentNullException("geometryFactory");
			}
			_filename = filename;
			Trace.WriteLineIf(Shapefile.TraceSwitch.Enabled,"Reading filename:"+filename);
			
			_geometryFactory = geometryFactory;

			// read header information. note, we open the file, read the header information and then
			// close the file. This means the file is not opened again until GetEnumerator() is requested.
			// For each call to GetEnumerator() a new BinaryReader is created.
			FileStream stream = new FileStream(filename, System.IO.FileMode.Open, FileAccess.Read, FileShare.Read);
			BigEndianBinaryReader shpBinaryReader = new BigEndianBinaryReader(stream);
			_mainHeader = new ShapefileHeader(shpBinaryReader);
			shpBinaryReader.Close();
		}
Esempio n. 5
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);
        }
Esempio n. 6
0
        /// <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, GeometryFactory geometryFactory)
        {
            if (filename==null)
            {
                throw new ArgumentNullException("filename");
            }
            if (geometryFactory==null)
            {
                throw new ArgumentNullException("geometryFactory");
            }
            _geometryFactory = geometryFactory;
            _open=true;

            if (filename.ToLower().EndsWith(".shp"))
            {
                filename = filename.ToLower().Replace(".shp","");
            }

             _dbfReader = new DbaseFileReader(filename+".dbf");
             _shpReader = new ShapefileReader(filename+".shp", geometryFactory);

            _dbfHeader =  _dbfReader.GetHeader();
            _recordCount = _dbfHeader.NumRecords;

            //			_wkbWriter = new GeometryWKBWriter(_geometryFactory);

            // 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();
            //_dbaseFields[1] = DbaseFieldDescriptor.IdField();
            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;
        }
Esempio n. 7
0
 public ShapefileIndexReader(string path)
 {
     _reader = new BigEndianBinaryReader(File.OpenRead(path));
     _header = new ShapefileHeader(_reader);
 }
Esempio n. 8
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);	
		}
Esempio n. 9
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ShapefileWriter">ShapefileWriter</see> class with the specified filename and factory .
        /// </summary>
        /// <param name="filename">The name of the file to write.</param>
        /// <param name="factory">The <b>GeometryFactory</b> to use.</param>
        /// <param name="append"></param>
        /// <exception cref="ArgumentNullException">The factory is a null reference (Nothing in Visual Basic).</exception>
        public ShapefileWriter(string filename, GeometryFactory factory, bool append)
        {
            if (factory == null)
            {
                throw new ArgumentNullException("factory");
            }

            _factory = factory;
            string shxFilename = Path.Combine(Path.GetDirectoryName(filename), Path.GetFileNameWithoutExtension(filename) + ".shx");

            if (append)
            {
                if (File.Exists(filename)==false || File.Exists(shxFilename)==false)
                {
                    throw new ArgumentException("Cannot append to a file that does not exist.");
                }

                ShapefileHeader shpHeader = null;
                ShapefileHeader shxHeader = null;
                using (Stream stream = File.Open(filename, FileMode.Open))
                {
                    using (BigEndianBinaryReader beBinaryReader = new BigEndianBinaryReader(stream))
                    {
                        shpHeader = new ShapefileHeader(beBinaryReader);
                    }
                }
                using (Stream stream = File.Open(shxFilename, FileMode.Open))
                {
                    using (BigEndianBinaryReader beBinaryReader = new BigEndianBinaryReader(stream))
                    {
                        shxHeader = new ShapefileHeader(beBinaryReader);
                    }
                }
                this._type = shpHeader.ShapeType;
                this._shpLength = shpHeader.FileLength;
                this._bounds = shpHeader.Bounds;
                this._count = (shxHeader.FileLength-50)/4;

                _shpWriter = new BigEndianBinaryWriter(File.Open(filename, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite));
                _shxWriter = new BigEndianBinaryWriter(File.Open(shxFilename, FileMode.Open,FileAccess.ReadWrite, FileShare.ReadWrite));

                // Write dummy headers as place holders
                this.WriteHeader(_shpWriter,0);
                this.WriteHeader(_shxWriter,0);
                _shpWriter.BaseStream.Position = _shpWriter.BaseStream.Length;
                _shxWriter.BaseStream.Position = _shxWriter.BaseStream.Length;

            }
            else
            {
                _shpWriter = new BigEndianBinaryWriter(File.Open(filename, FileMode.CreateNew));
                _shxWriter = new BigEndianBinaryWriter(File.Open(shxFilename, FileMode.CreateNew));

                // Write dummy headers as place holders
                this.WriteHeader(_shpWriter,0);
                this.WriteHeader(_shxWriter,0);
            }
        }
Esempio n. 10
0
        public void WriteHeader(BigEndianBinaryWriter writer, int length)
        {
            ShapefileHeader header = new ShapefileHeader();

            // Go to the start of the stream (if we're not already there)
            writer.BaseStream.Position = 0;

            // Set current header properties
            header.Bounds = _bounds;
            header.FileLength = length;
            header.ShapeType = _type;
            header.Write(writer);
        }