找到的一个读取shape数据的代码

其实在这里可以看到更多的：http://nettopologysuite.googlecode.com/svn/branches/GenericsWork/NetTopologySuite/IO/

using System;
using System.Collections;
using System.IO;

using GeoAPI.Geometries;

using GisSharpBlog.NetTopologySuite.Algorithm;
using GisSharpBlog.NetTopologySuite.Geometries;

namespace GisSharpBlog.NetTopologySuite.IO
{
/// <summary>
/// Contains methods for reading a single <c>Geometry</c> in binary ESRI shapefile format.
/// </summary>
public class ShapeReader
{
/// <summary>
/// Geometry creator.
/// </summary>
private GeometryFactory factory = null;

/// <summary>
///
/// </summary>
public GeometryFactory Factory
{
get { return factory; }
}

/// <summary>
/// Initialize reader with a standard <c>GeometryFactory</c>.
/// </summary>
public ShapeReader() : this(new GeometryFactory()) { }

/// <summary>
/// Initialize reader with the given <c>GeometryFactory</c>.
/// </summary>
/// <param name="factory"></param>
public ShapeReader(GeometryFactory factory)
{
this.factory = factory;
}

/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public IGeometry ReadPoint(BinaryReader reader)
{
ICoordinate coordinate = ReadCoordinate(reader);
IGeometry point = CreatePoint(coordinate);
return point;
}

/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public IGeometry ReadLineString(BinaryReader reader)
{
ReadBoundingBox(reader);  // Jump boundingbox

int numParts = ReadNumParts(reader);
int numPoints = ReadNumPoints(reader);

int[] indexParts = ReadIndexParts(reader, numParts);

ICoordinate[] coords = ReadCoordinates(reader, numPoints);

if (numParts == 1)
return CreateLineString(coords);
else return CreateMultiLineString(numPoints, indexParts, coords);
}

/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public IGeometry ReadPolygon(BinaryReader reader)
{
ReadBoundingBox(reader);  // Jump boundingbox

int numParts = ReadNumParts(reader);
int numPoints = ReadNumPoints(reader);

int[] indexParts = ReadIndexParts(reader, numParts);

ICoordinate[] coords = ReadCoordinates(reader, numPoints);

if (numParts == 1)
return CreateSimpleSinglePolygon(coords);
else return CreateSingleOrMultiPolygon(numPoints, indexParts, coords);
}

/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public IGeometry ReadMultiPoint(BinaryReader reader)
{
ReadBoundingBox(reader);  // Jump boundingbox

int numPoints = ReadNumPoints(reader);
ICoordinate[] coords = new ICoordinate[numPoints];
for (int i = 0; i < numPoints; i++)
coords[i] = ReadCoordinate(reader);
return CreateMultiPoint(coords);
}

/// <summary>
///
/// </summary>
/// <param name="coordinate"></param>
/// <returns></returns>
public IPoint CreatePoint(ICoordinate coordinate)
{
return Factory.CreatePoint(coordinate);
}

/// <summary>
/// Creates a single LineString.
/// </summary>
/// <param name="coords"></param>
/// <returns></returns>
public ILineString CreateLineString(ICoordinate[] coords)
{
return Factory.CreateLineString(coords);
}

/// <summary>
/// Creates a MultiLineString.
/// </summary>
/// <param name="numPoints"></param>
/// <param name="indexParts"></param>
/// <param name="coords"></param>
/// <returns></returns>
public IGeometry CreateMultiLineString(int numPoints, int[] indexParts, ICoordinate[] coords)
{
// Support vars
ILineString[] strings = new ILineString[indexParts.Length];
ICoordinate[] destCoords = null;
int index = 0;
int length = 0;
int partIndex = 1;

// Create parts
for (int i = 0; i < coords.Length - 1; i++)
{
if (partIndex == indexParts.Length)
break;  // Exit and add manually last part
if (i == indexParts[partIndex])
{
length = indexParts[partIndex] - indexParts[partIndex - 1];
destCoords = new ICoordinate[length];
Array.Copy(coords, indexParts[partIndex - 1], destCoords, 0, length);
partIndex++;
strings[index++] = Factory.CreateLineString(destCoords);
}
}

// Create last part
int lastIndex = indexParts.Length - 1;
length = numPoints - indexParts[lastIndex];
destCoords = new ICoordinate[length];
Array.Copy(coords, indexParts[lastIndex], destCoords, 0, length);
strings[index] = Factory.CreateLineString(destCoords);

// Create geometryString
return Factory.CreateMultiLineString(strings);
}

/// <summary>
/// Creates a single Polygon with holes.
/// </summary>
/// <param name="numPoints"></param>
/// <param name="indexParts"></param>
/// <param name="coords"></param>
/// <returns></returns>
public IGeometry CreateSingleOrMultiPolygon(int numPoints, int[] indexParts, ICoordinate[] coords)
{
// Support vars
int i = 0;
int index = 0;
int shellLength = 0;
ICoordinate[] shellCoords = null;
ILinearRing[] shells = new ILinearRing[indexParts.Length];
ArrayList polygonIndex = new ArrayList();

// Reading shells
for (i = 0; i < indexParts.Length - 1; i++)
{
// Init vars
shellLength = indexParts[i + 1] - indexParts[i];
shellCoords = new ICoordinate[shellLength];
Array.Copy(coords, indexParts[i], shellCoords, 0, shellLength);

// Verify polygon area
if (!CGAlgorithms.IsCCW(shellCoords))
polygonIndex.Add(i);

// Adding shell to array
shells[index++] = Factory.CreateLinearRing(shellCoords);
}

// Adding last shell
int lastIndex = indexParts.Length - 1;
shellLength = numPoints - indexParts[lastIndex];
shellCoords = new ICoordinate[shellLength];
Array.Copy(coords, indexParts[lastIndex], shellCoords, 0, shellLength);
if (!CGAlgorithms.IsCCW(shellCoords))
polygonIndex.Add(lastIndex);
shells[index] = Factory.CreateLinearRing(shellCoords);
// Create geometryString
if (polygonIndex.Count == 1)
{
// Single Polygon building
ILinearRing shell = shells[(int) polygonIndex[0]];
ILinearRing[] holes = new ILinearRing[shells.Length - 1];
Array.Copy(shells, 1, holes, 0, shells.Length - 1);

// Create Polygon point
return Factory.CreatePolygon(shell, holes);
}
else
{
// MultiPolygon building:   At this time i have all Linear Rings (shells and holes) undifferenceds into shells[] array,
//                          and in polygonIndex ArrayList i have all index for all shells (not holes!).

// Support vars
index = 0;
int start = 0;
int end = 0;
int length = 0;
ILinearRing shell = null;    // Contains Polygon Shell
ILinearRing[] holes = null;  // Contains Polygon Holes
IPolygon[] polygons = new IPolygon[polygonIndex.Count];   // Array containing all Polygons

// Building procedure
for (i = 0; i < polygonIndex.Count - 1; i++)
{
start = (int )polygonIndex[i];                       // First element of polygon (Shell)
end = ((int )polygonIndex[i + 1] - 1);               // Index of last Hole
length = end - start;                                // Holes
shell = shells[start];                               // Shell
holes = new ILinearRing[length];                     // Holes
Array.Copy(shells, start + 1, holes, 0, length);     // (start + 1) because i jump the Shell and keep only the Holes!
polygons[index++] = Factory.CreatePolygon(shell, holes);
}

// Add manually last polygon
start = (int) polygonIndex[polygonIndex.Count - 1];      // First element of polygon (Shell)
end = shells.Length - 1;                                 // Index of last Hole
length = end - start;                                    // Holes
shell = shells[start];                                   // Shell
holes = new ILinearRing[length];                         // Holes
Array.Copy(shells, start + 1, holes, 0, length);         // (start + 1) because i jump the Shell and keep only the Holes!
polygons[index++] = Factory.CreatePolygon(shell, holes);

// Create MultiPolygon point
return Factory.CreateMultiPolygon(polygons);
}
}

/// <summary>
/// Creates a single Polygon without holes.
/// </summary>
/// <param name="coords"></param>
/// <returns></returns>
public IPolygon CreateSimpleSinglePolygon(ICoordinate[] coords)
{
return Factory.CreatePolygon(Factory.CreateLinearRing(coords), null);
}

/// <summary>
/// Creates a MultiPoint.
/// </summary>
/// <param name="coords"></param>
/// <returns></returns>
public IMultiPoint CreateMultiPoint(ICoordinate[] coords)
{
return Factory.CreateMultiPoint(coords);
}

/// <summary>
/// Jump values for VeDEx BoundingBox
/// </summary>
/// <param name="reader"></param>
public void ReadBoundingBox(BinaryReader reader)
{
for (int i = 0; i < 4; i++)
reader.ReadDouble();
}

/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public int ReadNumParts(BinaryReader reader)
{
return reader.ReadInt32();
}

/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public int ReadNumPoints(BinaryReader reader)
{
return reader.ReadInt32();
}

/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="numParts"></param>
/// <returns></returns>
public int[] ReadIndexParts(BinaryReader reader, int numParts)
{
int[] indexParts = new int[numParts];
for (int i = 0; i < numParts; i++)
indexParts[i] = reader.ReadInt32();
return indexParts;
}

/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="numPoints"></param>
/// <returns></returns>
public ICoordinate[] ReadCoordinates(BinaryReader reader, int numPoints)
{
ICoordinate[] coords = new ICoordinate[numPoints];
for (int i = 0; i < numPoints; i++)
coords[i] = ReadCoordinate(reader);
return coords;
}

/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public ICoordinate ReadCoordinate(BinaryReader reader)
{
return new Coordinate(reader.ReadDouble(), reader.ReadDouble());
}

/// <summary>
///
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
public IGeometryCollection CreateGeometryCollection(IList list)
{
IGeometry[] geometries = (IGeometry[]) (new ArrayList(list).ToArray(typeof(IGeometry)));
return Factory.CreateGeometryCollection(geometries);
}
}
}