arcgis中 wkt轉為json

string wkt = dataRow[“圖形”].ToString();

// wkt = “POLYGON ((104.1454742186583 30.575483353880582, 104.14546962059087 30.5753065293814, 104.1456933934586 30.57532500353443, 104.14568726261399 30.57548467351342, 104.1454742186583 30.575483353880582))”;

OSGeo.OGR.Geometry geomentry = OSGeo.OGR.Geometry.CreateFromWkt(wkt);

SHAPE = ShapeAreaHelper.GetPoints(geomentry);

JsonRings p = JsonRings.FromJson(SHAPE);

ESRI.ArcGIS.Client.Geometry.Polygon polygon = null;

if (p == null) continue;

polygon = new ESRI.ArcGIS.Client.Geometry.Polygon();

polygon.Rings = new System.Collections.ObjectModel.ObservableCollection<ESRI.ArcGIS.Client.Geometry.PointCollection>();

foreach (var ring in p.rings)

{

ESRI.ArcGIS.Client.Geometry.PointCollection r = new ESRI.ArcGIS.Client.Geometry.PointCollection();

foreach (var point in ring)

{

ESRI.ArcGIS.Client.Geometry.MapPoint mapPoint = new ESRI.ArcGIS.Client.Geometry.MapPoint(point[0], point[1]);

if (mapPoint.X < 360)

{

//資料存在部分球面坐标，先轉換成平面

mapPoint = CoordinateTrans.Wgs84ToXian80(mapPoint, null);

}

r.Add(mapPoint);

}

polygon.Rings.Add®;

}

SHAPE = polygon.ToJson();

///

/// 2000球面坐标轉西安80平面坐标

///

///

///

///

public static MapPoint Wgs84ToXian80(MapPoint sourcePoint, Param4 param = null, int ProjNo = 0)

{

if (sourcePoint == null)

{

throw new ArgumentNullException(“sourcePoint”);

}

MapPoint targetPoint = GaussProjCal(sourcePoint, EarthParam.WGS84, ProjNo);

if (param != null && param.PX != 0 && param.SX != 0)

{

return Tras4Param(targetPoint, param);

}

else

{

return targetPoint;

}

}

///

/// 高斯投影正算

///

///

///

///

public static MapPoint GaussProjCal(MapPoint sourcePoint, EarthParam param, int ProjNo = 0)

{

double x, y;

GaussProjCal(sourcePoint.X, sourcePoint.Y, param.A, param.F, out x, out y, ProjNo);

return new MapPoint(x, y);

}

//高斯投影正、反算

//3度帶寬

//高斯投影由經緯度(Unit:DD)反算大地坐标(含帶号，Unit:Metres)

private static void GaussProjCal(double longitude, double latitude, double a, double f, out double X, out double Y, int ProjNo = 0)

{

//int ProjNo = 0;

int ZoneWide; 帶寬

double longitude1, latitude1, longitude0, latitude0, X0, Y0, xval, yval;

double e2, ee, NN, T, C, A, M, iPI;

iPI = Math.PI / 180; 3.1415926535898/180.0;

ZoneWide = 3; 3度帶寬

//a = 6378245.0; f = 1.0 / 298.3; //54年北京坐标系參數

//a=6378140.0; f=1/298.257; //80年西安坐标系參數

//a=6378137m;f=1/298.257223563;//WGS-84坐标系

if (ProjNo == 0)

{

ProjNo = (int)Math.Round(longitude / ZoneWide);

}

longitude0 = ProjNo * ZoneWide;

longitude0 = longitude0 * iPI;

latitude0 = 0;

longitude1 = longitude * iPI; //經度轉換為弧度

latitude1 = latitude * iPI; //緯度轉換為弧度

e2 = 2 * f - f * f;

ee = e2 * (1.0 - e2);

NN = a / Math.Sqrt(1.0 - e2 * Math.Sin(latitude1) * Math.Sin(latitude1));

T = Math.Tan(latitude1) * Math.Tan(latitude1);

C = ee * Math.Cos(latitude1) * Math.Cos(latitude1);

A = (longitude1 - longitude0) * Math.Cos(latitude1);

M = a * ((1 - e2 / 4 - 3 * e2 * e2 / 64 - 5 * e2 * e2 * e2 / 256) * latitude1 - (3 * e2 / 8 + 3 * e2 * e2 / 32 + 45 * e2 * e2 * e2 / 1024) * Math.Sin(2 * latitude1)

+ (15 * e2 * e2 / 256 + 45 * e2 * e2 * e2 / 1024) * Math.Sin(4 * latitude1) - (35 * e2 * e2 * e2 / 3072) * Math.Sin(6 * latitude1));

xval = NN * (A + (1 - T + C) * A * A * A / 6 + (5 - 18 * T + T * T + 72 * C - 58 * ee) * A * A * A * A * A / 120);

yval = M + NN * Math.Tan(latitude1) * (A * A / 2 + (5 - T + 9 * C + 4 * C * C) * A * A * A * A / 24

+ (61 - 58 * T + T * T + 600 * C - 330 * ee) * A * A * A * A * A * A / 720);

X0 = 1000000L * (ProjNo) + 500000L;

Y0 = 0;

xval = xval + X0; yval = yval + Y0;

X = xval;

Y = yval;

}

///

/// 平面四參數轉換方法

///

///

///

///

public static MapPoint Tras4Param(MapPoint sourcePoint, Param4 param4)

{

return Tras4Param(new MapPoint[] { sourcePoint }, param4)[0];

}

public static MapPoint[] Tras4Param(MapPoint[] sourcePoints, Param4 param4)

{

if (sourcePoints == null || sourcePoints.Length == 0)

throw new ArgumentNullException(“sourcePoints”);

if (param4 == null)

throw new ArgumentNullException(“param4”);

double[][] parameter = new double[4][];

parameter[0] = new double[] { param4.PX };

parameter[1] = new double[] { param4.PY };

parameter[2] = new double[] { param4.SX };

parameter[3] = new double[] { param4.SY };

int m = sourcePoints.Length;

double[][] oldp = new double[m][];

for (int i = 0; i < m; i++)

{

oldp[i] = new double[] { sourcePoints[i].X, sourcePoints[i].Y };

}

double[][] newp = Tras4Param(oldp, parameter, m);

MapPoint[] targetPoints = new MapPoint[m];

for (int i = 0; i < m; i++)

{

targetPoints[i] = new MapPoint(newp[i][0], newp[i][1]);

}

return targetPoints;

}

public static string GetPoints(OSGeo.OGR.Geometry geometry)

{

StringBuilder sb = new StringBuilder("{");

switch (geometry.GetGeometryType())

{

case OSGeo.OGR.wkbGeometryType.wkbGeometryCollection:

break;

case OSGeo.OGR.wkbGeometryType.wkbGeometryCollection25D:

break;

case OSGeo.OGR.wkbGeometryType.wkbLineString:

break;

case OSGeo.OGR.wkbGeometryType.wkbLineString25D:

break;

case OSGeo.OGR.wkbGeometryType.wkbLinearRing:

break;

case OSGeo.OGR.wkbGeometryType.wkbMultiLineString:

break;

case OSGeo.OGR.wkbGeometryType.wkbMultiLineString25D:

break;

case OSGeo.OGR.wkbGeometryType.wkbMultiPoint:

break;

case OSGeo.OGR.wkbGeometryType.wkbMultiPoint25D:

break;

case OSGeo.OGR.wkbGeometryType.wkbMultiPolygon25D:

break;

case OSGeo.OGR.wkbGeometryType.wkbNone:

break;

case OSGeo.OGR.wkbGeometryType.wkbPoint:

string json = @"{"“x”":" + geometry.GetX(0) + @","“y”":" + geometry.GetY(0);

sb.Append(@""“point”":" + json);

break;

case OSGeo.OGR.wkbGeometryType.wkbPoint25D:

break;

case OSGeo.OGR.wkbGeometryType.wkbMultiPolygon:

case OSGeo.OGR.wkbGeometryType.wkbPolygon:

int geometryCount = geometry.GetGeometryCount();

if (geometryCount > 0)

{

sb.Append(@""“rings”":[");

for (int i = 0; i < geometryCount; i++)
                    {
                        OSGeo.OGR.Geometry ge = geometry.GetGeometryRef(i);
                        int subGeoCount = ge.GetGeometryCount();
                        if (subGeoCount > 0)
                        {
                            for (int j = 0; j < subGeoCount; j++)
                            {
                                sb.Append(GetSingleGeometry(ge.GetGeometryRef(j)));
                            }
                        }
                        else
                        {
                            sb.Append(GetSingleGeometry(ge));
                        }

                    }
                    sb.Replace(',', ']', sb.Length - 1, 1);

                }
                break;
            case OSGeo.OGR.wkbGeometryType.wkbPolygon25D:
                break;
            case OSGeo.OGR.wkbGeometryType.wkbUnknown:
                break;
            default:
                break;
        }
        sb.Append("}");
        return sb.ToString();
    }
           

private static string GetSingleGeometry(OSGeo.OGR.Geometry geo)

{

StringBuilder sb = new StringBuilder();

sb.Append("[");

int count = geo.GetPointCount();

for (int j = 0; j < count; j++)

{

sb.Append("[" + geo.GetX(j) + “,” + geo.GetY(j) + “],”);

}

sb.Remove(sb.Length - 1, 1);

sb.Append("],");

return sb.ToString();

}

public static JsonRings FromJson(string json)

{

try

{

if (string.IsNullOrWhiteSpace(json)) return null;

var serializer = new DataContractJsonSerializer(typeof(JsonRings));

var mStream = new MemoryStream(Encoding.Default.GetBytes(json));

return (JsonRings)serializer.ReadObject(mStream);

}

catch

{

return null;

}

}