开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
CoordinateSystemWktReader.cs
资源名称：SharpMap-20976.zip　[点击查看]
上传用户：sex100000
上传日期：2013-11-09
资源大小：1377k
文件大小：22k
源码类别：

GIS编程

开发平台：

C#

CoordinateSystemWktReader.cs：源码内容
  1. // Copyright 2005, 2006 - Morten Nielsen (www.iter.dk)
  2. //
  3. // This file is part of SharpMap.
  4. // SharpMap is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU Lesser General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // (at your option) any later version.
  8. // 
  9. // SharpMap is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU Lesser General Public License for more details.
  14. // You should have received a copy of the GNU Lesser General Public License
  15. // along with SharpMap; if not, write to the Free Software
  16. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
  18. // SOURCECODE IS MODIFIED FROM ANOTHER WORK AND IS ORIGINALLY BASED ON GeoTools.NET:
  19. /*
  20.  *  Copyright (C) 2002 Urban Science Applications, Inc. 
  21.  *
  22.  *  This library is free software; you can redistribute it and/or
  23.  *  modify it under the terms of the GNU Lesser General Public
  24.  *  License as published by the Free Software Foundation; either
  25.  *  version 2.1 of the License, or (at your option) any later version.
  26.  *
  27.  *  This library is distributed in the hope that it will be useful,
  28.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  29.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  30.  *  Lesser General Public License for more details.
  31.  *
  32.  *  You should have received a copy of the GNU Lesser General Public
  33.  *  License along with this library; if not, write to the Free Software
  34.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  35.  *
  36.  */
  38. using System;
  39. using System.IO;
  40. using System.Collections.Generic;
  41. using System.Collections.ObjectModel;
  42. using SharpMap.CoordinateSystems;
  44. namespace SharpMap.Converters.WellKnownText
  45. {
  46. /// <summary>
  47. /// Creates an object based on the supplied Well Known Text (WKT).
  48. /// </summary>
  49. public class CoordinateSystemWktReader
  50. {
  51. /// <summary>
  52. /// Reads and parses a WKT-formatted projection string.
  53. /// </summary>
  54. /// <param name="wkt">String containing WKT.</param>
  55. /// <returns>Object representation of the WKT.</returns>
  56. /// <exception cref="System.ArgumentException">If a token is not recognised.</exception>
  57. public static IInfo Parse(string wkt)
  58. {
  59. IInfo returnObject = null;
  60. StringReader reader = new StringReader(wkt);
  61. WktStreamTokenizer tokenizer = new WktStreamTokenizer(reader);
  62. tokenizer.NextToken();
  63. string objectName = tokenizer.GetStringValue();
  64. switch (objectName)
  65. {
  66. case "UNIT":
  67. returnObject = ReadUnit(tokenizer);
  68. break;
  69. //case "VERT_DATUM":
  70. //    IVerticalDatum verticalDatum = ReadVerticalDatum(tokenizer);
  71. //    returnObject = verticalDatum;
  72. //    break;
  73. case "SPHEROID":
  74. returnObject = ReadEllipsoid(tokenizer);
  75. break;
  76. case "DATUM":
  77. returnObject = ReadHorizontalDatum(tokenizer); ;
  78. break;
  79. case "PRIMEM":
  80. returnObject = ReadPrimeMeridian(tokenizer);
  81. break;
  82. case "VERT_CS":
  83. case "GEOGCS":
  84. case "PROJCS":
  85. case "COMPD_CS":
  86. case "GEOCCS":
  87. case "FITTED_CS":
  88. case "LOCAL_CS":
  89. returnObject = ReadCoordinateSystem(wkt, tokenizer);
  90. break;
  91. default:
  92. throw new ArgumentException(String.Format("'{0'} is not recongnized.", objectName));
  94. }
  95. reader.Close();
  96. return returnObject;
  97. }
  99. /// <summary>
  100. /// Returns a IUnit given a piece of WKT.
  101. /// </summary>
  102. /// <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
  103. /// <returns>An object that implements the IUnit interface.</returns>
  104. private static IUnit ReadUnit(WktStreamTokenizer tokenizer)
  105. {
  106. tokenizer.ReadToken("[");
  107. string unitName = tokenizer.ReadDoubleQuotedWord();
  108. tokenizer.ReadToken(",");
  109. tokenizer.NextToken();
  110. double unitsPerUnit = tokenizer.GetNumericValue();
  111. string authority = String.Empty;
  112. long authorityCode = -1;
  113. tokenizer.NextToken();
  114. if (tokenizer.GetStringValue() == ",")
  115. {
  116. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  117. tokenizer.ReadToken("]");
  118. }
  119. return new Unit(unitsPerUnit, unitName, authority, authorityCode, String.Empty, String.Empty, String.Empty);
  120. }
  121. /// <summary>
  122. /// Returns a <see cref="LinearUnit"/> given a piece of WKT.
  123. /// </summary>
  124. /// <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
  125. /// <returns>An object that implements the IUnit interface.</returns>
  126. private static ILinearUnit ReadLinearUnit(WktStreamTokenizer tokenizer)
  127. {
  128. tokenizer.ReadToken("[");
  129. string unitName = tokenizer.ReadDoubleQuotedWord();
  130. tokenizer.ReadToken(",");
  131. tokenizer.NextToken();
  132. double unitsPerUnit = tokenizer.GetNumericValue();
  133. string authority = String.Empty;
  134. long authorityCode = -1;
  135. tokenizer.NextToken();
  136. if (tokenizer.GetStringValue() == ",")
  137. {
  138. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  139. tokenizer.ReadToken("]");
  140. }
  141. return new LinearUnit(unitsPerUnit, unitName, authority, authorityCode, String.Empty, String.Empty, String.Empty);
  142. }
  143. /// <summary>
  144. /// Returns a <see cref="AngularUnit"/> given a piece of WKT.
  145. /// </summary>
  146. /// <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
  147. /// <returns>An object that implements the IUnit interface.</returns>
  148. private static IAngularUnit ReadAngularUnit(WktStreamTokenizer tokenizer)
  149. {
  150. tokenizer.ReadToken("[");
  151. string unitName = tokenizer.ReadDoubleQuotedWord();
  152. tokenizer.ReadToken(",");
  153. tokenizer.NextToken();
  154. double unitsPerUnit = tokenizer.GetNumericValue();
  155. string authority = String.Empty;
  156. long authorityCode = -1;
  157. tokenizer.NextToken();
  158. if (tokenizer.GetStringValue() == ",")
  159. {
  160. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  161. tokenizer.ReadToken("]");
  162. }
  163. return new AngularUnit(unitsPerUnit, unitName, authority, authorityCode, String.Empty, String.Empty, String.Empty);
  164. }
  166. /// <summary>
  167. /// Returns a <see cref="AxisInfo"/> given a piece of WKT.
  168. /// </summary>
  169. /// <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
  170. /// <returns>An AxisInfo object.</returns>
  171. private static AxisInfo ReadAxis(WktStreamTokenizer tokenizer)
  172. {
  173. if (tokenizer.GetStringValue() != "AXIS")
  174. tokenizer.ReadToken("AXIS");
  175. tokenizer.ReadToken("[");
  176. string axisName = tokenizer.ReadDoubleQuotedWord();
  177. tokenizer.ReadToken(",");
  178. tokenizer.NextToken();
  179. string unitname = tokenizer.GetStringValue();
  180. tokenizer.ReadToken("]");
  181. switch (unitname.ToUpper())
  182. {
  183. case "DOWN": return new AxisInfo(axisName, AxisOrientationEnum.Down);
  184. case "EAST": return new AxisInfo(axisName, AxisOrientationEnum.East);
  185. case "NORTH": return new AxisInfo(axisName, AxisOrientationEnum.North);
  186. case "OTHER": return new AxisInfo(axisName, AxisOrientationEnum.Other);
  187. case "SOUTH": return new AxisInfo(axisName, AxisOrientationEnum.South);
  188. case "UP": return new AxisInfo(axisName, AxisOrientationEnum.Up);
  189. case "WEST": return new AxisInfo(axisName, AxisOrientationEnum.West);
  190. default:
  191. throw new ArgumentException("Invalid axis name '" + unitname + "' in WKT");
  192. }
  193. }
  196. /// <summary>
  197. /// 
  198. /// </summary>
  199. /// <param name="coordinateSystem"></param>
  200. /// <param name="tokenizer"></param>
  201. /// <returns></returns>
  202. private static ICoordinateSystem ReadCoordinateSystem(string coordinateSystem, WktStreamTokenizer tokenizer)
  203. {
  204. switch (tokenizer.GetStringValue())
  205. {
  206. case "GEOGCS":
  207. return ReadGeographicCoordinateSystem(tokenizer);
  208. case "PROJCS":
  209. return ReadProjectedCoordinateSystem(tokenizer);
  210. case "COMPD_CS":
  211. /* ICompoundCoordinateSystem compoundCS = ReadCompoundCoordinateSystem(tokenizer);
  212. returnCS = compoundCS;
  213. break;*/
  214. case "VERT_CS":
  215. /* IVerticalCoordinateSystem verticalCS = ReadVerticalCoordinateSystem(tokenizer);
  216. returnCS = verticalCS;
  217. break;*/
  218. case "GEOCCS":
  219. case "FITTED_CS":
  220. case "LOCAL_CS":
  221. throw new NotSupportedException(String.Format("{0} coordinate system is not supported.", coordinateSystem));
  222. default:
  223. throw new InvalidOperationException(String.Format("{0} coordinate system is not recognized.", coordinateSystem));
  224. }
  225. }
  227. /// <summary>
  228. /// Reads either 3, 6 or 7 parameter Bursa-Wolf values from TOWGS84 token
  229. /// </summary>
  230. /// <param name="tokenizer"></param>
  231. /// <returns></returns>
  232. private static Wgs84ConversionInfo ReadWGS84ConversionInfo(WktStreamTokenizer tokenizer)
  233. {
  234. //TOWGS84[0,0,0,0,0,0,0]
  235. tokenizer.ReadToken("[");
  236. Wgs84ConversionInfo info = new Wgs84ConversionInfo();
  237. tokenizer.NextToken();
  238. info.Dx = tokenizer.GetNumericValue();
  239. tokenizer.ReadToken(",");
  241. tokenizer.NextToken();
  242. info.Dy = tokenizer.GetNumericValue();
  243. tokenizer.ReadToken(",");
  245. tokenizer.NextToken();
  246. info.Dz = tokenizer.GetNumericValue();
  247. tokenizer.NextToken();
  248. if (tokenizer.GetStringValue() == ",")
  249. {
  250. tokenizer.NextToken();
  251. info.Ex = tokenizer.GetNumericValue();
  253. tokenizer.ReadToken(",");
  254. tokenizer.NextToken();
  255. info.Ey = tokenizer.GetNumericValue();
  257. tokenizer.ReadToken(",");
  258. tokenizer.NextToken();
  259. info.Ez = tokenizer.GetNumericValue();
  261. tokenizer.NextToken();
  262. if (tokenizer.GetStringValue() == ",")
  263. {
  264. tokenizer.NextToken();
  265. info.Ppm = tokenizer.GetNumericValue();
  266. }
  267. }
  268. if (tokenizer.GetStringValue() != "]")
  269. tokenizer.ReadToken("]");
  270. return info;
  271. }
  274. /*
  275. /// <summary>
  276. /// 
  277. /// </summary>
  278. /// <param name="tokenizer"></param>
  279. /// <returns></returns>
  280. private static ICompoundCoordinateSystem ReadCompoundCoordinateSystem(WktStreamTokenizer tokenizer)
  281. {
  283. //COMPD_CS[
  284. //"OSGB36 / British National Grid + ODN",
  285. //PROJCS[]
  286. //VERT_CS[]
  287. //AUTHORITY["EPSG","7405"]
  288. //]
  290. tokenizer.ReadToken("[");
  291. string name=tokenizer.ReadDoubleQuotedWord();
  292. tokenizer.ReadToken(",");
  293. tokenizer.NextToken();
  294. string headCSCode =  tokenizer.GetStringValue();
  295. ICoordinateSystem headCS = ReadCoordinateSystem(headCSCode,tokenizer);
  296. tokenizer.ReadToken(",");
  297. tokenizer.NextToken();
  298. string tailCSCode =  tokenizer.GetStringValue();
  299. ICoordinateSystem tailCS = ReadCoordinateSystem(tailCSCode,tokenizer);
  300. tokenizer.ReadToken(",");
  301. string authority=String.Empty;
  302. string authorityCode=String.Empty; 
  303. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  304. tokenizer.ReadToken("]");
  305. ICompoundCoordinateSystem compoundCS = new CompoundCoordinateSystem(headCS,tailCS,String.Empty,authority,authorityCode,name,String.Empty,String.Empty); 
  306. return compoundCS;
  308. }*/
  310. /// <summary>
  311. /// 
  312. /// </summary>
  313. /// <param name="tokenizer"></param>
  314. /// <returns></returns>
  315. private static IEllipsoid ReadEllipsoid(WktStreamTokenizer tokenizer)
  316. {
  317. //SPHEROID["Airy 1830",6377563.396,299.3249646,AUTHORITY["EPSG","7001"]]
  318. tokenizer.ReadToken("[");
  319. string name = tokenizer.ReadDoubleQuotedWord();
  320. tokenizer.ReadToken(",");
  321. tokenizer.NextToken();
  322. double majorAxis = tokenizer.GetNumericValue();
  323. tokenizer.ReadToken(",");
  324. tokenizer.NextToken();
  325. double e = tokenizer.GetNumericValue();
  326. //
  328. //tokenizer.ReadToken(",");
  329. tokenizer.NextToken();
  330. string authority = String.Empty;
  331. long authorityCode = -1;
  332. if (tokenizer.GetStringValue() == ",") //Read authority
  333. {
  334. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  335. tokenizer.ReadToken("]");
  336. }
  337. IEllipsoid ellipsoid = new Ellipsoid(majorAxis, 0.0, e, true, LinearUnit.Metre, name, authority, authorityCode, String.Empty, string.Empty, string.Empty);
  338. return ellipsoid;
  339. }
  341. /// <summary>
  342. /// 
  343. /// </summary>
  344. /// <param name="tokenizer"></param>
  345. /// <returns></returns>
  346. private static IProjection ReadProjection(WktStreamTokenizer tokenizer)
  347. {
  348. //tokenizer.NextToken();// PROJECTION
  349. tokenizer.ReadToken("PROJECTION");
  350. tokenizer.ReadToken("[");//[
  351. string projectionName = tokenizer.ReadDoubleQuotedWord();
  352. tokenizer.ReadToken("]");//]
  353. tokenizer.ReadToken(",");//,
  354. tokenizer.ReadToken("PARAMETER");
  355. Collection<ProjectionParameter> paramList = new Collection<ProjectionParameter>();
  356. while (tokenizer.GetStringValue() == "PARAMETER")
  357. {
  358. tokenizer.ReadToken("[");
  359. string paramName = tokenizer.ReadDoubleQuotedWord();
  360. tokenizer.ReadToken(",");
  361. tokenizer.NextToken();
  362. double paramValue = tokenizer.GetNumericValue();
  363. tokenizer.ReadToken("]");
  364. tokenizer.ReadToken(",");
  365. paramList.Add(new ProjectionParameter(paramName, paramValue));
  366. tokenizer.NextToken();
  367. }
  368. string authority = String.Empty;
  369. long authorityCode = -1;
  370. IProjection projection = new Projection(projectionName, paramList, projectionName, authority, authorityCode, String.Empty, String.Empty, string.Empty);
  371. return projection;
  372. }
  374. /// <summary>
  375. /// 
  376. /// </summary>
  377. /// <param name="tokenizer"></param>
  378. /// <returns></returns>
  379. private static IProjectedCoordinateSystem ReadProjectedCoordinateSystem(WktStreamTokenizer tokenizer)
  380. {
  381. /*PROJCS[
  382. "OSGB 1936 / British National Grid",
  383. GEOGCS[
  384. "OSGB 1936",
  385. DATUM[...]
  386. PRIMEM[...]
  387. AXIS["Geodetic latitude","NORTH"]
  388. AXIS["Geodetic longitude","EAST"]
  389. AUTHORITY["EPSG","4277"]
  390. ],
  391. PROJECTION["Transverse Mercator"],
  392. PARAMETER["latitude_of_natural_origin",49],
  393. PARAMETER["longitude_of_natural_origin",-2],
  394. PARAMETER["scale_factor_at_natural_origin",0.999601272],
  395. PARAMETER["false_easting",400000],
  396. PARAMETER["false_northing",-100000],
  397. AXIS["Easting","EAST"],
  398. AXIS["Northing","NORTH"],
  399. AUTHORITY["EPSG","27700"]
  400. ]
  401. */
  402. tokenizer.ReadToken("[");
  403. string name = tokenizer.ReadDoubleQuotedWord();
  404. tokenizer.ReadToken(",");
  405. tokenizer.ReadToken("GEOGCS");
  406. IGeographicCoordinateSystem geographicCS = ReadGeographicCoordinateSystem(tokenizer);
  407. tokenizer.ReadToken(",");
  408. IProjection projection = ReadProjection(tokenizer);
  409. IUnit unit = ReadLinearUnit(tokenizer);
  411. string authority = String.Empty;
  412. long authorityCode = -1;
  413. tokenizer.NextToken();
  414.             //Collection<AxisInfo> axes = new Collection<AxisInfo>(2);
  415.             Collection<AxisInfo> axes = new Collection<AxisInfo>();
  416. if (tokenizer.GetStringValue() == ",")
  417. {
  418. tokenizer.NextToken();
  419. while (tokenizer.GetStringValue() == "AXIS")
  420. {
  421. axes.Add(ReadAxis(tokenizer));
  422. tokenizer.NextToken();
  423. }
  424. if (tokenizer.GetStringValue() == "AUTHORITY")
  425. {
  426. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  427. tokenizer.ReadToken("]");
  428. }
  429. }
  430. //This is default axis values if not specified.
  431. if (axes.Count == 0)
  432. {
  433. axes.Add(new AxisInfo("X", AxisOrientationEnum.East));
  434. axes.Add(new AxisInfo("Y", AxisOrientationEnum.North));
  435. }
  436. IProjectedCoordinateSystem projectedCS = new ProjectedCoordinateSystem(geographicCS.HorizontalDatum, geographicCS, unit as LinearUnit, projection, axes, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
  437. return projectedCS;
  438. }
  440. /// <summary>
  441. /// 
  442. /// </summary>
  443. /// <param name="tokenizer"></param>
  444. /// <returns></returns>
  445. private static IGeographicCoordinateSystem ReadGeographicCoordinateSystem(WktStreamTokenizer tokenizer)
  446. {
  447. /*
  448. GEOGCS["OSGB 1936",
  449. DATUM["OSGB 1936",SPHEROID["Airy 1830",6377563.396,299.3249646,AUTHORITY["EPSG","7001"]]TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6277"]]
  450. PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]]
  451. AXIS["Geodetic latitude","NORTH"]
  452. AXIS["Geodetic longitude","EAST"]
  453. AUTHORITY["EPSG","4277"]
  454. ]
  455. */
  456. tokenizer.ReadToken("[");
  457. string name = tokenizer.ReadDoubleQuotedWord();
  458. tokenizer.ReadToken(",");
  459. tokenizer.ReadToken("DATUM");
  460. IHorizontalDatum horizontalDatum = ReadHorizontalDatum(tokenizer);
  461. tokenizer.ReadToken(",");
  462. tokenizer.ReadToken("PRIMEM");
  463. IPrimeMeridian primeMeridian = ReadPrimeMeridian(tokenizer);
  464. tokenizer.ReadToken(",");
  465. tokenizer.ReadToken("UNIT");
  466. IAngularUnit angularUnit = ReadAngularUnit(tokenizer);
  468. string authority = String.Empty;
  469. long authorityCode = -1;
  470. tokenizer.NextToken();
  471.             //Collection<AxisInfo> info = new Collection<AxisInfo>(2);
  472.             Collection<AxisInfo> info = new Collection<AxisInfo>();
  473. if (tokenizer.GetStringValue() == ",")
  474. {
  475. tokenizer.NextToken();
  476. while (tokenizer.GetStringValue() == "AXIS")
  477. {
  478. info.Add(ReadAxis(tokenizer));
  479. tokenizer.NextToken();
  480. }
  481. if (tokenizer.GetStringValue() == "AUTHORITY")
  482. {
  483. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  484. tokenizer.ReadToken("]");
  485. }
  486. }
  487. //This is default axis values if not specified.
  488. if (info.Count == 0)
  489. {
  490. info.Add(new AxisInfo("Lon", AxisOrientationEnum.East));
  491. info.Add(new AxisInfo("Lat", AxisOrientationEnum.North));
  492. }
  493. IGeographicCoordinateSystem geographicCS = new GeographicCoordinateSystem(angularUnit, horizontalDatum,
  494. primeMeridian, info, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
  495. return geographicCS;
  496. }
  498. /// <summary>
  499. /// 
  500. /// </summary>
  501. /// <param name="tokenizer"></param>
  502. /// <returns></returns>
  503. private static IHorizontalDatum ReadHorizontalDatum(WktStreamTokenizer tokenizer)
  504. {
  505. //DATUM["OSGB 1936",SPHEROID["Airy 1830",6377563.396,299.3249646,AUTHORITY["EPSG","7001"]]TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6277"]]
  506. Wgs84ConversionInfo wgsInfo = null;
  507. string authority = String.Empty;
  508. long authorityCode = -1;
  510. tokenizer.ReadToken("[");
  511. string name = tokenizer.ReadDoubleQuotedWord();
  512. tokenizer.ReadToken(",");
  513. tokenizer.ReadToken("SPHEROID");
  514. IEllipsoid ellipsoid = ReadEllipsoid(tokenizer);
  515. tokenizer.NextToken();
  516. while (tokenizer.GetStringValue() == ",")
  517. {
  518. tokenizer.NextToken();
  519. if (tokenizer.GetStringValue() == "TOWGS84")
  520. {
  521. wgsInfo = ReadWGS84ConversionInfo(tokenizer);
  522. tokenizer.NextToken();
  523. }
  524. else if (tokenizer.GetStringValue() == "AUTHORITY")
  525. {
  526. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  527. tokenizer.ReadToken("]");
  528. }
  529. }
  530. // make an assumption about the datum type.
  531. IHorizontalDatum horizontalDatum = new HorizontalDatum(ellipsoid, wgsInfo, DatumType.HD_Geocentric, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
  533. return horizontalDatum;
  534. }
  536. /// <summary>
  537. /// 
  538. /// </summary>
  539. /// <param name="tokenizer"></param>
  540. /// <returns></returns>
  541. private static IPrimeMeridian ReadPrimeMeridian(WktStreamTokenizer tokenizer)
  542. {
  543. //PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]]
  544. tokenizer.ReadToken("[");
  545. string name = tokenizer.ReadDoubleQuotedWord();
  546. tokenizer.ReadToken(",");
  547. tokenizer.NextToken();
  548. double longitude = tokenizer.GetNumericValue();
  550. tokenizer.NextToken();
  551. string authority = String.Empty;
  552. long authorityCode = -1;
  553. if (tokenizer.GetStringValue() == ",")
  554. {
  555. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  556. tokenizer.ReadToken("]");
  557. }
  558. // make an assumption about the Angular units - degrees.
  559. IPrimeMeridian primeMeridian = new PrimeMeridian(longitude, AngularUnit.Degrees, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
  561. return primeMeridian;
  562. }
  563. /*
  564. /// <summary>
  565. /// 
  566. /// </summary>
  567. /// <param name="tokenizer"></param>
  568. /// <returns></returns>
  569. private static IVerticalCoordinateSystem ReadVerticalCoordinateSystem(WktStreamTokenizer tokenizer)
  570. {
  571. //VERT_CS["Newlyn",
  572. //VERT_DATUM["Ordnance Datum Newlyn",2005,AUTHORITY["EPSG","5101"]]
  573. //UNIT["metre",1,AUTHORITY["EPSG","9001"]]
  574. //AUTHORITY["EPSG","5701"]
  576. tokenizer.ReadToken("[");
  577. string name=tokenizer.ReadDoubleQuotedWord();
  578. tokenizer.ReadToken(",");
  579. tokenizer.ReadToken("VERT_DATUM");
  580. IVerticalDatum verticalDatum = ReadVerticalDatum(tokenizer);
  581. tokenizer.ReadToken("UNIT");
  582. IUnit unit = ReadUnit(tokenizer);
  583. string authority=String.Empty;
  584. string authorityCode=String.Empty; 
  585. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  586. tokenizer.ReadToken("]");
  588. IVerticalCoordinateSystem verticalCS = new VerticalCoordinateSystem(name,verticalDatum,String.Empty,authority,authorityCode,String.Empty,String.Empty);
  589. return verticalCS;
  590. }*/
  592. /*
  593. /// <summary>
  594. /// 
  595. /// </summary>
  596. /// <param name="tokenizer"></param>
  597. /// <returns></returns>
  598. private static IVerticalDatum  ReadVerticalDatum(WktStreamTokenizer tokenizer)
  599. {
  600. //VERT_DATUM["Ordnance Datum Newlyn",2005,AUTHORITY["5101","EPSG"]]
  601. tokenizer.ReadToken("[");
  602. string datumName=tokenizer.ReadDoubleQuotedWord();
  603. tokenizer.ReadToken(",");
  604. tokenizer.NextToken();
  605. string datumTypeNumber = tokenizer.GetStringValue();
  606. tokenizer.ReadToken(",");
  607. string authority=String.Empty;
  608. string authorityCode=String.Empty; 
  609. tokenizer.ReadAuthority(ref authority, ref authorityCode);
  610. DatumType datumType = (DatumType)Enum.Parse(typeof(DatumType),datumTypeNumber);
  611. IVerticalDatum verticalDatum = new VerticalDatum(datumType,String.Empty,authorityCode,authority,datumName,String.Empty,String.Empty);
  612. tokenizer.ReadToken("]");
  613. return verticalDatum;
  614. }*/
  617. /*
  618. /// <summary>
  619. /// 
  620. /// </summary>
  621. /// <param name="tokenizer"></param>
  622. /// <returns></returns>
  623. [Obsolete("Since the related objects have not been implemented")]
  624. private static IGeocentricCoordinateSystem ReadGeocentricCoordinateSystem(WktStreamTokenizer tokenizer)
  625. {
  626. throw new NotImplementedException("IGeocentricCoordinateSystem is not implemented");
  627. }*/
  628. }
  629. }