PageRenderTime 50ms CodeModel.GetById 14ms RepoModel.GetById 0ms app.codeStats 1ms

/trunk/source/Common/EWKBtoGDO.cpp

#
C++ | 2274 lines | 1934 code | 279 blank | 61 comment | 171 complexity | 6b2812684c318001f2bee8be1bdb96e5 MD5 | raw file
Possible License(s): Apache-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. // Copyright 2011 Intergraph Corporation

    2. 

  2. //

    3. 

  3. // Licensed under the Apache License, Version 2.0 (the "License");

    4. 

  4. // you may not use this file except in compliance with the License.

    5. 

  5. // You may obtain a copy of the License at

    6. 

  6. //

    7. 

  7. //     http://www.apache.org/licenses/LICENSE-2.0

    8. 

  8. //

    9. 

  9. // Unless required by applicable law or agreed to in writing, software

    10. 

  10. // distributed under the License is distributed on an "AS IS" BASIS,

    11. 

  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    12. 

  12. // See the License for the specific language governing permissions and

    13. 

  13. // limitations under the License.

    14. 

  14. 

    15. 

  15. #include "EWKBtoGDO.hpp"

    16. 

  16. #include <math.h>

    17. 

  17. #include "PGSTypes.hpp"

    18. 

  18. #include "../Common/LogFiles.hpp"

    19. 

  19. #include <stdio.h>

    20. 

  20. 

    21. 

  21. unsigned char GetByte(unsigned char **psBuf, int *piCurLen)

    22. 

  22. {

    23. 

  23.     unsigned char ucRes = **psBuf;

    24. 

  24.     (*psBuf)++;

    25. 

  25.     (*piCurLen)++;

    26. 

  26.     return(ucRes);

    27. 

  27. }

    28. 

  28. 

    29. 

  29. unsigned long GetGeomType(unsigned char **psBuf, unsigned char uiByteOrder,

    30. 

  30.     int *piCurLen)

    31. 

  31. {

    32. 

  32.     unsigned long ulRes = 0;

    33. 

  33.     unsigned char *pbyte = (unsigned char*)&ulRes;

    34. 

  34.     if(uiByteOrder)

    35. 

  35.     {

    36. 

  36.         for(int i = 0; i < 4; i++) pbyte[i] = GetByte(psBuf, piCurLen);

    37. 

  37.     }

    38. 

  38.     else

    39. 

  39.     {

    40. 

  40.         for(int i = 0; i < 4; i++) pbyte[3 - i] = GetByte(psBuf, piCurLen);

    41. 

  41.     }

    42. 

  42.     // EWKB has a strange last byte, containing what? Dimension?

    43. 

  43.     pbyte[3] = 0;

    44. 

  44.     return(ulRes);

    45. 

  45. }

    46. 

  46. 

    47. 

  47. unsigned long GetLong(unsigned char **psBuf, unsigned char uiByteOrder,

    48. 

  48.     int *piCurLen)

    49. 

  49. {

    50. 

  50.     unsigned long ulRes = 0;

    51. 

  51.     unsigned char *pbyte = (unsigned char*)&ulRes;

    52. 

  52.     if(uiByteOrder)

    53. 

  53.     {

    54. 

  54.         for(int i = 0; i < 4; i++) pbyte[i] = GetByte(psBuf, piCurLen);

    55. 

  55.     }

    56. 

  56.     else

    57. 

  57.     {

    58. 

  58.         for(int i = 0; i < 4; i++) pbyte[3 - i] = GetByte(psBuf, piCurLen);

    59. 

  59.     }

    60. 

  60.     return(ulRes);

    61. 

  61. }

    62. 

  62. 

    63. 

  63. double GetDouble(unsigned char **psBuf, unsigned char uiByteOrder, int *piCurLen)

    64. 

  64. {

    65. 

  65.     double dblRes = 0;

    66. 

  66.     unsigned char *pbyte = (unsigned char*)&dblRes;

    67. 

  67.     if(uiByteOrder)

    68. 

  68.     {

    69. 

  69.         for(int i = 0; i < 8; i++) pbyte[i] = GetByte(psBuf, piCurLen);

    70. 

  70.     }

    71. 

  71.     else

    72. 

  72.     {

    73. 

  73.         for(int i = 0; i < 8; i++) pbyte[7 - i] = GetByte(psBuf, piCurLen);

    74. 

  74.     }

    75. 

  75.     return(dblRes);

    76. 

  76. }

    77. 

  77. 

    78. 

  78. void GetTriple(unsigned char **psBuf, unsigned char ucByteOrder, int iDim,

    79. 

  79.     int *piCurLen, double *px)

    80. 

  80. {

    81. 

  81.     px[0] = GetDouble(psBuf, ucByteOrder, piCurLen);

    82. 

  82.     px[1] = GetDouble(psBuf, ucByteOrder, piCurLen);

    83. 

  83.     if(iDim > 2)

    84. 

  84.     {

    85. 

  85.         px[2] = GetDouble(psBuf, ucByteOrder, piCurLen);

    86. 

  86.         if(_isnan(px[2])) px[2] = -9999.0;

    87. 

  87.     }

    88. 

  88.     else px[2] = 0.0;

    89. 

  89.     if(iDim > 3)

    90. 

  90.     {

    91. 

  91.         *psBuf += 8;

    92. 

  92.         *piCurLen += 8;

    93. 

  93.     }

    94. 

  94.     return;

    95. 

  95. }

    96. 

  96. 

    97. 

  97. int GetArcGeomSize(double *dStart, double *dMiddle, double *dEnd)

    98. 

  98. {

    99. 

  99.     double dMag = (dEnd[0] - dStart[0])*(dEnd[0] - dStart[0]) +

    100. 

  100.         (dEnd[1] - dStart[1])*(dEnd[1] - dStart[1]) +

    101. 

  101.         (dEnd[2] - dStart[2])*(dEnd[2] - dStart[2]);

    102. 

  102.     double dPrec = gdPrecLim*sqrt(dMag);

    103. 

  103. 

    104. 

  104.     double alpha[3];

    105. 

  105.     alpha[0] = (dEnd[1] - dStart[1])*(dMiddle[2] - dStart[2]) -

    106. 

  106.         (dEnd[2] - dStart[2])*(dMiddle[1] - dStart[1]);

    107. 

  107.     alpha[1] = (dEnd[2] - dStart[2])*(dMiddle[0] - dStart[0]) -

    108. 

  108.         (dEnd[0] - dStart[0])*(dMiddle[2] - dStart[2]);

    109. 

  109.     alpha[2] = (dEnd[0] - dStart[0])*(dMiddle[1] - dStart[1]) -

    110. 

  110.         (dEnd[1] - dStart[1])*(dMiddle[0] - dStart[0]);

    111. 

  111.     if((fabs(alpha[0]) < dPrec) && (fabs(alpha[1]) < dPrec) &&

    112. 

  112.         (fabs(alpha[2]) < dPrec))

    113. 

  113.     {

    114. 

  114.         return(64);

    115. 

  115.     }

    116. 

  116. 

    117. 

  117.     double A[2][2];

    118. 

  118.     A[0][0] = 0.0;

    119. 

  119.     A[0][1] = 0.0;

    120. 

  120.     A[1][0] = 0.0;

    121. 

  121.     A[1][1] = 0.0;

    122. 

  122.     for(int i = 0; i < 3; i++)

    123. 

  123.     {

    124. 

  124.         A[0][0] += (dMiddle[i] - dStart[i])*(dMiddle[i] - dStart[i]);

    125. 

  125.         A[0][1] += (dMiddle[i] - dStart[i])*(dMiddle[i] - dEnd[i]);

    126. 

  126.         A[1][0] += (dMiddle[i] - dEnd[i])*(dMiddle[i] - dStart[i]);

    127. 

  127.         A[1][1] += (dMiddle[i] - dEnd[i])*(dMiddle[i] - dEnd[i]);

    128. 

  128.     }

    129. 

  129.     double D = A[0][0]*A[1][1] - A[0][1]*A[1][0];

    130. 

  130. 

    131. 

  131.     if(fabs(D) > dPrec) return(96); // arc geometry

    132. 

  132.     else return(64); // line geometry

    133. 

  133. }

    134. 

  134. 

    135. 

  135. unsigned char* WriteArcGeometry(unsigned char *pBuf, double *dStart,

    136. 

  136.     double *dMiddle, double *dEnd)

    137. 

  137. {

    138. 

  138.     double dMag = (dEnd[0] - dStart[0])*(dEnd[0] - dStart[0]) +

    139. 

  139.         (dEnd[1] - dStart[1])*(dEnd[1] - dStart[1]) +

    140. 

  140.         (dEnd[2] - dStart[2])*(dEnd[2] - dStart[2]);

    141. 

  141.     double dPrec = gdPrecLim*sqrt(dMag);

    142. 

  142. 

    143. 

  143.     double alpha[3];

    144. 

  144.     alpha[0] = (dEnd[1] - dStart[1])*(dMiddle[2] - dStart[2]) -

    145. 

  145.         (dEnd[2] - dStart[2])*(dMiddle[1] - dStart[1]);

    146. 

  146.     alpha[1] = (dEnd[2] - dStart[2])*(dMiddle[0] - dStart[0]) -

    147. 

  147.         (dEnd[0] - dStart[0])*(dMiddle[2] - dStart[2]);

    148. 

  148.     alpha[2] = (dEnd[0] - dStart[0])*(dMiddle[1] - dStart[1]) -

    149. 

  149.         (dEnd[1] - dStart[1])*(dMiddle[0] - dStart[0]);

    150. 

  150.     if((fabs(alpha[0]) < dPrec) && (fabs(alpha[1]) < dPrec) &&

    151. 

  151.         (fabs(alpha[2]) < dPrec))

    152. 

  152.     {

    153. 

  153.         memcpy(pBuf, &GID_LineGeometry, 16);

    154. 

  154.         pBuf += 16;

    155. 

  155.         *(double*)pBuf = dStart[0];

    156. 

  156.         pBuf += 8;

    157. 

  157.         *(double*)pBuf = dStart[1];

    158. 

  158.         pBuf += 8;

    159. 

  159.         *(double*)pBuf = dStart[2];

    160. 

  160.         pBuf += 8;

    161. 

  161.         *(double*)pBuf = dEnd[0];

    162. 

  162.         pBuf += 8;

    163. 

  163.         *(double*)pBuf = dEnd[1];

    164. 

  164.         pBuf += 8;

    165. 

  165.         *(double*)pBuf = dEnd[2];

    166. 

  166.         pBuf += 8;

    167. 

  167.         return(pBuf);

    168. 

  168.     }

    169. 

  169. 

    170. 

  170.     double A[2][2], B[2];

    171. 

  171.     A[0][0] = 0.0;

    172. 

  172.     A[0][1] = 0.0;

    173. 

  173.     A[1][0] = 0.0;

    174. 

  174.     A[1][1] = 0.0;

    175. 

  175.     B[0] = 0.0;

    176. 

  176.     B[1] = 0.0;

    177. 

  177.     for(int i = 0; i < 3; i++)

    178. 

  178.     {

    179. 

  179.         A[0][0] += (dMiddle[i] - dStart[i])*(dMiddle[i] - dStart[i]);

    180. 

  180.         A[0][1] += (dMiddle[i] - dStart[i])*(dMiddle[i] - dEnd[i]);

    181. 

  181.         A[1][0] += (dMiddle[i] - dEnd[i])*(dMiddle[i] - dStart[i]);

    182. 

  182.         A[1][1] += (dMiddle[i] - dEnd[i])*(dMiddle[i] - dEnd[i]);

    183. 

  183.         B[0] += (dMiddle[i]*dMiddle[i] + dStart[i]*dStart[i])/2.0 -

    184. 

  184.             dMiddle[i]*dStart[i];

    185. 

  185.         B[1] += (dMiddle[i]*dMiddle[i] + dEnd[i]*dEnd[i])/2.0 -

    186. 

  186.             dMiddle[i]*dEnd[i];

    187. 

  187.     }

    188. 

  188.     double D = A[0][0]*A[1][1] - A[0][1]*A[1][0];

    189. 

  189. 

    190. 

  190.     if(fabs(D) > dPrec)

    191. 

  191.     {

    192. 

  192.         memcpy(pBuf, &GID_ArcGeometry, 16);

    193. 

  193.         pBuf += 16;

    194. 

  194.         *(double*)pBuf = dStart[0];

    195. 

  195.         pBuf += 8;

    196. 

  196.         *(double*)pBuf = dStart[1];

    197. 

  197.         pBuf += 8;

    198. 

  198.         *(double*)pBuf = dStart[2];

    199. 

  199.         pBuf += 8;

    200. 

  200.         *(double*)pBuf = dEnd[0];

    201. 

  201.         pBuf += 8;

    202. 

  202.         *(double*)pBuf = dEnd[1];

    203. 

  203.         pBuf += 8;

    204. 

  204.         *(double*)pBuf = dEnd[2];

    205. 

  205.         pBuf += 8;

    206. 

  206. 

    207. 

  207.         double gamma[2];

    208. 

  208.         gamma[0] = (A[1][1]*B[0] - A[0][1]*B[1])/D;

    209. 

  209.         gamma[1] = (A[0][0]*B[1] - A[1][0]*B[0])/D;

    210. 

  210.         double S[3];

    211. 

  211.         double r = 0.0;

    212. 

  212.         for(int i = 0; i < 3; i++)

    213. 

  213.         {

    214. 

  214.             //S[i] = sMiddle[i] + gamma[0]*(xStart[i] - xMiddle[i]) +

    215. 

  215.             //    gamma[1]*(xEnd[i] - xMiddle[i]);

    216. 

  216.             //r += (sMiddle[i] - S[i])*(sMiddle[i] - S[i]);

    217. 

  217.             S[i] = gamma[0]*(dStart[i] - dMiddle[i]) +

    218. 

  218.                 gamma[1]*(dEnd[i] - dMiddle[i]);

    219. 

  219.             r += S[i]*S[i];

    220. 

  220.             S[i] += dMiddle[i];

    221. 

  221.         }

    222. 

  222.         r = sqrt(r);

    223. 

  223.         double normal1[3], normal2[3], normal3[3];

    224. 

  224.         normal1[0] = (dStart[1] - S[1])*(dMiddle[2] - S[2]) -

    225. 

  225.             (dStart[2] - S[2])*(dMiddle[1] - S[1]);

    226. 

  226.         normal1[1] = (dStart[2] - S[2])*(dMiddle[0] - S[0]) -

    227. 

  227.             (dStart[0] - S[0])*(dMiddle[2] - S[2]);

    228. 

  228.         normal1[2] = (dStart[0] - S[0])*(dMiddle[1] - S[1]) -

    229. 

  229.             (dStart[1] - S[1])*(dMiddle[0] - S[0]);

    230. 

  230. 

    231. 

  231.         normal2[0] = (dMiddle[1] - S[1])*(dEnd[2] - S[2]) -

    232. 

  232.             (dMiddle[2] - S[2])*(dEnd[1] - S[1]);

    233. 

  233.         normal2[1] = (dMiddle[2] - S[2])*(dEnd[0] - S[0]) -

    234. 

  234.             (dMiddle[0] - S[0])*(dEnd[2] - S[2]);

    235. 

  235.         normal2[2] = (dMiddle[0] - S[0])*(dEnd[1] - S[1]) -

    236. 

  236.             (dMiddle[1] - S[1])*(dEnd[0] - S[0]);

    237. 

  237. 

    238. 

  238.         normal3[0] = (dStart[1] - S[1])*(dEnd[2] - S[2]) -

    239. 

  239.             (dStart[2] - S[2])*(dEnd[1] - S[1]);

    240. 

  240.         normal3[1] = (dStart[2] - S[2])*(dEnd[0] - S[0]) -

    241. 

  241.             (dStart[0] - S[0])*(dEnd[2] - S[2]);

    242. 

  242.         normal3[2] = (dStart[0] - S[0])*(dEnd[1] - S[1]) -

    243. 

  243.             (dStart[1] - S[1])*(dEnd[0] - S[0]);

    244. 

  244. 

    245. 

  245.         double norms[3];

    246. 

  246.         norms[0] = normal1[0]*normal1[0] + normal1[1]*normal1[1]

    247. 

  247.             + normal1[2]*normal1[2];

    248. 

  248.         norms[1] = normal2[0]*normal2[0] + normal2[1]*normal2[1]

    249. 

  249.             + normal2[2]*normal2[2];

    250. 

  250.         norms[2] = normal3[0]*normal3[0] + normal3[1]*normal3[1]

    251. 

  251.             + normal3[2]*normal3[2];

    252. 

  252. 

    253. 

  253.         int ori1 = GetOrient(normal1, normal2);

    254. 

  254.         if(ori1 > 0)

    255. 

  255.         {

    256. 

  256.             if(fabs(norms[1]) > fabs(norms[0]))

    257. 

  257.             {

    258. 

  258.                 norms[1] = sqrt(norms[1]);

    259. 

  259.                 *(double*)pBuf = normal2[0]/norms[1];

    260. 

  260.                 pBuf += 8;

    261. 

  261.                 *(double*)pBuf = normal2[1]/norms[1];

    262. 

  262.                 pBuf += 8;

    263. 

  263.                 *(double*)pBuf = normal2[2]/norms[1];

    264. 

  264.                 pBuf += 8;

    265. 

  265.             }

    266. 

  266.             else

    267. 

  267.             {

    268. 

  268.                 norms[0] = sqrt(norms[0]);

    269. 

  269.                 *(double*)pBuf = normal1[0]/norms[0];

    270. 

  270.                 pBuf += 8;

    271. 

  271.                 *(double*)pBuf = normal1[1]/norms[0];

    272. 

  272.                 pBuf += 8;

    273. 

  273.                 *(double*)pBuf = normal1[2]/norms[0];

    274. 

  274.                 pBuf += 8;

    275. 

  275.             }

    276. 

  276.             if((GetOrient(normal1, normal3) >= 0) &&

    277. 

  277.                 (GetOrient(normal2, normal3) >= 0)) r = -r;

    278. 

  278.         }

    279. 

  279.         else

    280. 

  280.         {

    281. 

  281.             if(GetOrient(normal1, normal3) > 0)

    282. 

  282.             {

    283. 

  283.                 norms[1] = sqrt(norms[1]);

    284. 

  284.                 *(double*)pBuf = normal2[0]/norms[1];

    285. 

  285.                 pBuf += 8;

    286. 

  286.                 *(double*)pBuf = normal2[1]/norms[1];

    287. 

  287.                 pBuf += 8;

    288. 

  288.                 *(double*)pBuf = normal2[2]/norms[1];

    289. 

  289.                 pBuf += 8;

    290. 

  290.             }

    291. 

  291.             else

    292. 

  292.             {

    293. 

  293.                 norms[0] = sqrt(norms[0]);

    294. 

  294.                 *(double*)pBuf = normal1[0]/norms[0];

    295. 

  295.                 pBuf += 8;

    296. 

  296.                 *(double*)pBuf = normal1[1]/norms[0];

    297. 

  297.                 pBuf += 8;

    298. 

  298.                 *(double*)pBuf = normal1[2]/norms[0];

    299. 

  299.                 pBuf += 8;

    300. 

  300.             }

    301. 

  301.         }

    302. 

  302.         *(double*)pBuf = r;

    303. 

  303.         pBuf += 8;

    304. 

  304.     }

    305. 

  305.     else

    306. 

  306.     {

    307. 

  307.         memcpy(pBuf, &GID_LineGeometry, 16);

    308. 

  308.         pBuf += 16;

    309. 

  309.         *(double*)pBuf = dStart[0];

    310. 

  310.         pBuf += 8;

    311. 

  311.         *(double*)pBuf = dStart[1];

    312. 

  312.         pBuf += 8;

    313. 

  313.         *(double*)pBuf = dStart[2];

    314. 

  314.         pBuf += 8;

    315. 

  315.         *(double*)pBuf = dEnd[0];

    316. 

  316.         pBuf += 8;

    317. 

  317.         *(double*)pBuf = dEnd[1];

    318. 

  318.         pBuf += 8;

    319. 

  319.         *(double*)pBuf = dEnd[2];

    320. 

  320.         pBuf += 8;

    321. 

  321.     }

    322. 

  322. 

    323. 

  323.     return(pBuf);

    324. 

  324. }

    325. 

  325. 

    326. 

  326. int GetEWKBtoPointLen(unsigned char *sBuf, int iDim, long *plen,

    327. 

  327.     unsigned char ucByteOrder)

    328. 

  328. {

    329. 

  329.     (*plen) += 16; // 16 bytes for Geom GUID

    330. 

  330. 

    331. 

  331.     (*plen) += 48; // 24 bytes for location, 24 bytes for orientation

    332. 

  332.     int iRes = 8*iDim;

    333. 

  333. 

    334. 

  334.     return(iRes);

    335. 

  335. }

    336. 

  336. 

    337. 

  337. int EWKBtoPoint(unsigned char *sBuf, unsigned char *pBuf, int iDim, long *plen,

    338. 

  338.     unsigned char ucByteOrder)

    339. 

  339. {

    340. 

  340.     memcpy(pBuf, &GID_OrientedPointGeometry, 16);

    341. 

  341.     (*plen) += 16; // 16 bytes for Geom GUID

    342. 

  342.     pBuf += 16;

    343. 

  343. 

    344. 

  344.     (*plen) += 48; // 24 bytes for location, 24 bytes for orientation

    345. 

  345.     int iRes = 0;

    346. 

  346. 

    347. 

  347.     GetTriple(&sBuf, ucByteOrder, iDim, &iRes, (double*)pBuf);

    348. 

  348.     pBuf += 24;

    349. 

  349.     *(double*)pBuf = 1.0;

    350. 

  350.     pBuf += 8;

    351. 

  351.     *(double*)pBuf = 0.0;

    352. 

  352.     pBuf += 8;

    353. 

  353.     *(double*)pBuf = 0.0;

    354. 

  354.     pBuf += 8;

    355. 

  355. 

    356. 

  356.     return(iRes);

    357. 

  357. }

    358. 

  358. 

    359. 

  359. int GetEWKBtoLineStringLen(unsigned char *sBuf, int iDim, long *plen,

    360. 

  360.     unsigned char ucByteOrder, bool bWriteGUID)

    361. 

  361. {

    362. 

  362.     int iRes = 0;

    363. 

  363.     unsigned long ulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    364. 

  364. 

    365. 

  365.     if(bWriteGUID)

    366. 

  366.         (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for num points

    367. 

  367. 

    368. 

  368.     (*plen) += ulLen*24; // 24 bytes for each 3 doubles

    369. 

  369.     iRes += ulLen*8*iDim;

    370. 

  370. 

    371. 

  371.     return(iRes);

    372. 

  372. }

    373. 

  373. 

    374. 

  374. int EWKBtoLineString(unsigned char *sBuf, unsigned char *pBuf, int iDim, long *plen,

    375. 

  375.     unsigned char ucByteOrder, unsigned long *plItemCount)

    376. 

  376. {

    377. 

  377. #if DBGLEVEL > 2

    378. 

  378.     WriteLogFile("EWKBtoLineString\r\n", true);

    379. 

  379. #endif // DBGLEVEL

    380. 

  380. 

    381. 

  381.     int iRes = 0;

    382. 

  382.     unsigned long ulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    383. 

  383. 

    384. 

  384.     if(plItemCount) (*plItemCount) += ulLen;

    385. 

  385.     else

    386. 

  386.     {

    387. 

  387.         memcpy(pBuf, &GID_PolylineGeometry, 16);

    388. 

  388.         pBuf += 16;

    389. 

  389.         *(unsigned long*)pBuf = ulLen;

    390. 

  390.         pBuf += 4;

    391. 

  391.         (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for num points

    392. 

  392.     }

    393. 

  393. 

    394. 

  394.     (*plen) += ulLen*24; // 24 bytes for each 3 doubles

    395. 

  395. 

    396. 

  396.     for(int i = 0; i < (int)ulLen; i++)

    397. 

  397.     {

    398. 

  398.         GetTriple(&sBuf, ucByteOrder, iDim, &iRes, (double*)pBuf);

    399. 

  399.         pBuf += 24;

    400. 

  400.     }

    401. 

  401. 

    402. 

  402.     return(iRes);

    403. 

  403. }

    404. 

  404. 

    405. 

  405. int GetEWKBtoPolygonLen(unsigned char *sBuf, int iDim, long *plen,

    406. 

  406.     unsigned char ucByteOrder)

    407. 

  407. {

    408. 

  408.     int iRes = 0;

    409. 

  409.     unsigned long ulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    410. 

  410. 

    411. 

  411.     if(ulLen > 1) // boundary geometry

    412. 

  412.     {

    413. 

  413.         (*plen) += 16; // 16 bytes for Geom GUID

    414. 

  414. 

    415. 

  415.         unsigned long lulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    416. 

  416.         int ilen = lulLen*8*iDim;

    417. 

  417. 

    418. 

  418.         // 4 bytes for boundary size, 16 bytes for polgon GUID,

    419. 

  419.         // 4 bytes for points count

    420. 

  420.         (*plen) += (24 + 24*lulLen);

    421. 

  421.         iRes += ilen;

    422. 

  422.         sBuf += ilen;

    423. 

  423. 

    424. 

  424.         // 4 bytes for collection size, 16 bytes for collection GUID,

    425. 

  425.         // 4 bytes for collection count

    426. 

  426.         (*plen) += 24;

    427. 

  427.         int i = 1;

    428. 

  428.         while(i < (int)ulLen)

    429. 

  429.         {

    430. 

  430.             lulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    431. 

  431.             ilen = lulLen*8*iDim;

    432. 

  432. 

    433. 

  433.             // 4 bytes for polygon size, 16 bytes for polgon GUID,

    434. 

  434.             // 4 bytes for points count

    435. 

  435.             (*plen) += (24 + 24*lulLen);

    436. 

  436.             iRes += ilen;

    437. 

  437.             sBuf += ilen;

    438. 

  438.             i++;

    439. 

  439.         }

    440. 

  440.     }

    441. 

  441.     else if(ulLen == 1) // polygon geometry

    442. 

  442.     {

    443. 

  443.         (*plen) += 16; // 16 bytes for Geom GUID

    444. 

  444. 

    445. 

  445.         ulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    446. 

  446. 

    447. 

  447.         (*plen) += (4 + ulLen*24); // 4 bytes for num points, 24 bytes for each 3 doubles

    448. 

  448.         iRes += ulLen*8*iDim;

    449. 

  449.     }

    450. 

  450. 

    451. 

  451.     return(iRes);

    452. 

  452. }

    453. 

  453. 

    454. 

  454. int EWKBtoPolygon(unsigned char *sBuf, unsigned char *pBuf, int iDim, long *plen,

    455. 

  455.     unsigned char ucByteOrder)

    456. 

  456. {

    457. 

  457.     int iRes = 0;

    458. 

  458.     unsigned long ulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    459. 

  459. 

    460. 

  460.     if(ulLen > 1) // boundary geometry

    461. 

  461.     {

    462. 

  462.         memcpy(pBuf, &GID_BoundaryGeometry, 16);

    463. 

  463.         pBuf += 16;

    464. 

  464.         (*plen) += 16; // 16 bytes for Geom GUID

    465. 

  465. 

    466. 

  466.         unsigned long lulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    467. 

  467. 

    468. 

  468.         // 4 bytes for boundary size, 16 bytes for polgon GUID,

    469. 

  469.         // 4 bytes for points count

    470. 

  470.         *(unsigned long*)pBuf = (20 + 24*lulLen);

    471. 

  471.         pBuf += 4;

    472. 

  472.         (*plen) += (24 + 24*lulLen);

    473. 

  473. 

    474. 

  474.         memcpy(pBuf, &GID_PolygonGeometry, 16);

    475. 

  475.         pBuf += 16;

    476. 

  476.         *(unsigned long*)pBuf = lulLen;

    477. 

  477.         pBuf += 4;

    478. 

  478. 

    479. 

  479.         for(int j = 0; j < (int)lulLen; j++)

    480. 

  480.         {

    481. 

  481.             GetTriple(&sBuf, ucByteOrder, iDim, &iRes, (double*)pBuf);

    482. 

  482.             pBuf += 24;

    483. 

  483.         }

    484. 

  484. 

    485. 

  485.         unsigned char *pSaveBuf = pBuf;

    486. 

  486.         pBuf += 4;

    487. 

  487. 

    488. 

  488.         memcpy(pBuf, &GID_GeometryCollection, 16);

    489. 

  489.         pBuf += 16;

    490. 

  490.         *(unsigned long*)pBuf = (ulLen - 1);

    491. 

  491.         pBuf += 4;

    492. 

  492. 

    493. 

  493.         unsigned long llsize = 20; // 16 bytes GUID, 4 bztes col count

    494. 

  494. 

    495. 

  495.         // 4 bytes for collection size, 16 bytes for collection GUID,

    496. 

  496.         // 4 bytes for collection count

    497. 

  497.         (*plen) += 24;

    498. 

  498.         int i = 1;

    499. 

  499.         while(i < (int)ulLen)

    500. 

  500.         {

    501. 

  501.             lulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    502. 

  502. 

    503. 

  503.             // 4 bytes for polygon size, 16 bytes for polgon GUID,

    504. 

  504.             // 4 bytes for points count

    505. 

  505.             llsize += (24 + 24*lulLen);

    506. 

  506.             (*plen) += (24 + 24*lulLen);

    507. 

  507. 

    508. 

  508.             *(unsigned long*)pBuf = (20 + 24*lulLen);

    509. 

  509.             pBuf += 4;

    510. 

  510.             memcpy(pBuf, &GID_PolygonGeometry, 16);

    511. 

  511.             pBuf += 16;

    512. 

  512.             *(unsigned long*)pBuf = lulLen;

    513. 

  513.             pBuf += 4;

    514. 

  514. 

    515. 

  515.             for(int j = 0; j < (int)lulLen; j++)

    516. 

  516.             {

    517. 

  517.                 GetTriple(&sBuf, ucByteOrder, iDim, &iRes, (double*)pBuf);

    518. 

  518.                 pBuf += 24;

    519. 

  519.             }

    520. 

  520. 

    521. 

  521.             i++;

    522. 

  522.         }

    523. 

  523. 

    524. 

  524.         *(unsigned long*)pSaveBuf = llsize;

    525. 

  525.     }

    526. 

  526.     else if(ulLen == 1) // polygon geometry

    527. 

  527.     {

    528. 

  528.         memcpy(pBuf, &GID_PolygonGeometry, 16);

    529. 

  529.         (*plen) += 16; // 16 bytes for Geom GUID

    530. 

  530.         pBuf += 16;

    531. 

  531. 

    532. 

  532.         ulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    533. 

  533.         *(unsigned long*)pBuf = ulLen;

    534. 

  534.         pBuf += 4;

    535. 

  535. 

    536. 

  536.         (*plen) += (4 + ulLen*24); // 4 bytes for num points, 24 bytes for each 3 doubles

    537. 

  537. 

    538. 

  538.         for(int i = 0; i < (int)ulLen; i++)

    539. 

  539.         {

    540. 

  540.             GetTriple(&sBuf, ucByteOrder, iDim, &iRes, (double*)pBuf);

    541. 

  541.             pBuf += 24;

    542. 

  542.         }

    543. 

  543.     }

    544. 

  544. 

    545. 

  545.     return(iRes);

    546. 

  546. }

    547. 

  547. 

    548. 

  548. int GetEWKBtoMultiPointLen(unsigned char *sBuf, int iDim, long *plen,

    549. 

  549.     unsigned char ucByteOrder)

    550. 

  550. {

    551. 

  551.     int iRes = 0;

    552. 

  552.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    553. 

  553. 

    554. 

  554.     unsigned char byteorder;

    555. 

  555.     long lsize = 0;

    556. 

  556.     unsigned long ulType;

    557. 

  557.     int ilocDim;

    558. 

  558.     int iType;

    559. 

  559. 

    560. 

  560.     if(lcnt > 1) // geometry collection

    561. 

  561.     {

    562. 

  562.         (*plen) += 20; // 16 bytes for geometry GUID and 4 bytes for collection count

    563. 

  563.         int i = 0;

    564. 

  564.         int ilen = 1;

    565. 

  565.         while((i < (int)lcnt) && (ilen > 0))

    566. 

  566.         {

    567. 

  567.             byteorder = GetByte(&sBuf, &iRes);

    568. 

  568.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    569. 

  569. 

    570. 

  570.             ilocDim = ulType / 1000;

    571. 

  571.             iType = ulType - 1000*ilocDim;

    572. 

  572.             ilocDim += 2;

    573. 

  573. 

    574. 

  574.             lsize = 0;

    575. 

  575. 

    576. 

  576.             if(iType == 1)

    577. 

  577.             {

    578. 

  578.                 ilen = GetEWKBtoPointLen(sBuf, iDim, &lsize, byteorder);

    579. 

  579.                 sBuf += ilen;

    580. 

  580.                 iRes += ilen;

    581. 

  581.                 (*plen) += (4 + lsize); // 4 bytes for collection item size

    582. 

  582.             }

    583. 

  583.             else ilen = 0;

    584. 

  584.             i++;

    585. 

  585.         }

    586. 

  586.     }

    587. 

  587.     else if(lcnt == 1) // polyline geometry

    588. 

  588.     {

    589. 

  589.         byteorder = GetByte(&sBuf, &iRes);

    590. 

  590.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    591. 

  591. 

    592. 

  592.         ilocDim = ulType / 1000;

    593. 

  593.         iType = ulType - 1000*ilocDim;

    594. 

  594.         ilocDim += 2;

    595. 

  595. 

    596. 

  596.         lsize = 0;

    597. 

  597. 

    598. 

  598.         if(iType == 1)

    599. 

  599.         {

    600. 

  600.             iRes += GetEWKBtoPointLen(sBuf, iDim, &lsize, byteorder);

    601. 

  601.             (*plen) += lsize;

    602. 

  602.         }

    603. 

  603.     }

    604. 

  604.     return(iRes);

    605. 

  605. }

    606. 

  606. 

    607. 

  607. int EWKBtoMultiPoint(unsigned char *sBuf, unsigned char *pBuf, int iDim,

    608. 

  608.     long *plen, unsigned char ucByteOrder)

    609. 

  609. {

    610. 

  610.     int iRes = 0;

    611. 

  611.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    612. 

  612. 

    613. 

  613.     unsigned char byteorder;

    614. 

  614.     long lsize = 0;

    615. 

  615.     unsigned long ulType;

    616. 

  616.     int ilocDim;

    617. 

  617.     int iType;

    618. 

  618. 

    619. 

  619.     if(lcnt > 1) // geometry collection

    620. 

  620.     {

    621. 

  621.         memcpy(pBuf, &GID_GeometryCollection, 16);

    622. 

  622.         pBuf += 16;

    623. 

  623.         *(unsigned long*)pBuf = lcnt;

    624. 

  624.         pBuf += 4;

    625. 

  625.         (*plen) += 20; // 16 vytes for geometry GUID amd 4 bytes for collection count

    626. 

  626. 

    627. 

  627.         int i = 0;

    628. 

  628.         int ilen = 1;

    629. 

  629.         while((i < (int)lcnt) && (ilen > 0))

    630. 

  630.         {

    631. 

  631.             byteorder = GetByte(&sBuf, &iRes);

    632. 

  632.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    633. 

  633. 

    634. 

  634.             ilocDim = ulType / 1000;

    635. 

  635.             iType = ulType - 1000*ilocDim;

    636. 

  636.             ilocDim += 2;

    637. 

  637. 

    638. 

  638.             lsize = 0;

    639. 

  639.             if(iType == 1)

    640. 

  640.             {

    641. 

  641.                 ilen = EWKBtoPoint(sBuf, &pBuf[4], iDim, &lsize, byteorder);

    642. 

  642.                 *(unsigned long*)pBuf = lsize;

    643. 

  643.                 sBuf += ilen;

    644. 

  644.                 iRes += ilen;

    645. 

  645.                 pBuf += (4 + lsize);

    646. 

  646.                 (*plen) += (4 + lsize); // 4 bytes for collection item size

    647. 

  647.             }

    648. 

  648.             else ilen = 0;

    649. 

  649.             i++;

    650. 

  650.         }

    651. 

  651.     }

    652. 

  652.     else if(lcnt == 1) // point geometry

    653. 

  653.     {

    654. 

  654.         byteorder = GetByte(&sBuf, &iRes);

    655. 

  655.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    656. 

  656. 

    657. 

  657.         ilocDim = ulType / 1000;

    658. 

  658.         iType = ulType - 1000*ilocDim;

    659. 

  659.         ilocDim += 2;

    660. 

  660. 

    661. 

  661.         if(iType == 1)

    662. 

  662.         {

    663. 

  663.             iRes += EWKBtoPoint(sBuf, pBuf, iDim, &lsize, byteorder);

    664. 

  664.             (*plen) += lsize;

    665. 

  665.         }

    666. 

  666.     }

    667. 

  667.     return(iRes);

    668. 

  668. }

    669. 

  669. 

    670. 

  670. int GetEWKBtoMultiLineStringLen(unsigned char *sBuf, int iDim, long *plen,

    671. 

  671.     unsigned char ucByteOrder)

    672. 

  672. {

    673. 

  673.     int iRes = 0;

    674. 

  674.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    675. 

  675. 

    676. 

  676.     unsigned char byteorder;

    677. 

  677.     long lsize = 0;

    678. 

  678.     unsigned long ulType;

    679. 

  679.     int ilocDim;

    680. 

  680.     int iType;

    681. 

  681. 

    682. 

  682.     if(lcnt > 1) // geometry collection

    683. 

  683.     {

    684. 

  684.         (*plen) += 20; // 16 bytes for geometry GUID and 4 bytes for collection count

    685. 

  685.         int i = 0;

    686. 

  686.         int ilen = 1;

    687. 

  687.         while((i < (int)lcnt) && (ilen > 0))

    688. 

  688.         {

    689. 

  689.             byteorder = GetByte(&sBuf, &iRes);

    690. 

  690.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    691. 

  691. 

    692. 

  692.             ilocDim = ulType / 1000;

    693. 

  693.             iType = ulType - 1000*ilocDim;

    694. 

  694.             ilocDim += 2;

    695. 

  695. 

    696. 

  696.             lsize = 0;

    697. 

  697. 

    698. 

  698.             if(iType == 2)

    699. 

  699.             {

    700. 

  700.                 ilen = GetEWKBtoLineStringLen(sBuf, iDim, &lsize, byteorder,

    701. 

  701.                     true);

    702. 

  702.                 sBuf += ilen;

    703. 

  703.                 iRes += ilen;

    704. 

  704.                 (*plen) += (4 + lsize); // 4 bytes for collection item size

    705. 

  705.             }

    706. 

  706.             else ilen = 0;

    707. 

  707.             i++;

    708. 

  708.         }

    709. 

  709.     }

    710. 

  710.     else if(lcnt == 1) // polyline geometry

    711. 

  711.     {

    712. 

  712.         byteorder = GetByte(&sBuf, &iRes);

    713. 

  713.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    714. 

  714. 

    715. 

  715.         ilocDim = ulType / 1000;

    716. 

  716.         iType = ulType - 1000*ilocDim;

    717. 

  717.         ilocDim += 2;

    718. 

  718. 

    719. 

  719.         lsize = 0;

    720. 

  720. 

    721. 

  721.         if(iType == 2)

    722. 

  722.         {

    723. 

  723.             iRes += GetEWKBtoLineStringLen(sBuf, iDim, &lsize, byteorder,

    724. 

  724.                 true);

    725. 

  725.             (*plen) += lsize;

    726. 

  726.         }

    727. 

  727.     }

    728. 

  728.     return(iRes);

    729. 

  729. }

    730. 

  730. 

    731. 

  731. int EWKBtoMultiLineString(unsigned char *sBuf, unsigned char *pBuf, int iDim,

    732. 

  732.     long *plen, unsigned char ucByteOrder)

    733. 

  733. {

    734. 

  734.     int iRes = 0;

    735. 

  735.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    736. 

  736. 

    737. 

  737.     unsigned char byteorder;

    738. 

  738.     long lsize = 0;

    739. 

  739.     unsigned long ulType;

    740. 

  740.     int ilocDim;

    741. 

  741.     int iType;

    742. 

  742. 

    743. 

  743.     if(lcnt > 1) // geometry collection

    744. 

  744.     {

    745. 

  745.         memcpy(pBuf, &GID_GeometryCollection, 16);

    746. 

  746.         pBuf += 16;

    747. 

  747.         *(unsigned long*)pBuf = lcnt;

    748. 

  748.         pBuf += 4;

    749. 

  749.         (*plen) += 20; // 16 vytes for geometry GUID amd 4 bytes for collection count

    750. 

  750. 

    751. 

  751.         int i = 0;

    752. 

  752.         int ilen = 1;

    753. 

  753.         while((i < (int)lcnt) && (ilen > 0))

    754. 

  754.         {

    755. 

  755.             byteorder = GetByte(&sBuf, &iRes);

    756. 

  756.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    757. 

  757. 

    758. 

  758.             ilocDim = ulType / 1000;

    759. 

  759.             iType = ulType - 1000*ilocDim;

    760. 

  760.             ilocDim += 2;

    761. 

  761. 

    762. 

  762.             lsize = 0;

    763. 

  763.             if(iType == 2)

    764. 

  764.             {

    765. 

  765.                 ilen = EWKBtoLineString(sBuf, &pBuf[4], iDim, &lsize, byteorder,

    766. 

  766.                     NULL);

    767. 

  767.                 *(unsigned long*)pBuf = lsize;

    768. 

  768.                 sBuf += ilen;

    769. 

  769.                 iRes += ilen;

    770. 

  770.                 pBuf += (4 + lsize);

    771. 

  771.                 (*plen) += (4 + lsize); // 4 bytes for collection item size

    772. 

  772.             }

    773. 

  773.             else ilen = 0;

    774. 

  774.             i++;

    775. 

  775.         }

    776. 

  776.     }

    777. 

  777.     else if(lcnt == 1) // polyline geometry

    778. 

  778.     {

    779. 

  779.         byteorder = GetByte(&sBuf, &iRes);

    780. 

  780.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    781. 

  781. 

    782. 

  782.         ilocDim = ulType / 1000;

    783. 

  783.         iType = ulType - 1000*ilocDim;

    784. 

  784.         ilocDim += 2;

    785. 

  785. 

    786. 

  786.         if(iType == 2)

    787. 

  787.         {

    788. 

  788.             iRes += EWKBtoLineString(sBuf, pBuf, iDim, &lsize, byteorder,

    789. 

  789.                 NULL);

    790. 

  790.             (*plen) += lsize;

    791. 

  791.         }

    792. 

  792.     }

    793. 

  793.     return(iRes);

    794. 

  794. }

    795. 

  795. 

    796. 

  796. int GetEWKBtoMultiPolygonLen(unsigned char *sBuf, int iDim, long *plen,

    797. 

  797.     unsigned char ucByteOrder)

    798. 

  798. {

    799. 

  799.     int iRes = 0;

    800. 

  800.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    801. 

  801. 

    802. 

  802.     unsigned char byteorder;

    803. 

  803.     long lsize = 0;

    804. 

  804.     unsigned long ulType;

    805. 

  805.     int ilocDim;

    806. 

  806.     int iType;

    807. 

  807. 

    808. 

  808.     if(lcnt > 1) // geometry collection

    809. 

  809.     {

    810. 

  810.         (*plen) += 20; // 16 bytes for geometry GUID and 4 bytes for collection count

    811. 

  811.         int i = 0;

    812. 

  812.         int ilen = 1;

    813. 

  813.         while((i < (int)lcnt) && (ilen > 0))

    814. 

  814.         {

    815. 

  815.             byteorder = GetByte(&sBuf, &iRes);

    816. 

  816.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    817. 

  817. 

    818. 

  818.             ilocDim = ulType / 1000;

    819. 

  819.             iType = ulType - 1000*ilocDim;

    820. 

  820.             ilocDim += 2;

    821. 

  821. 

    822. 

  822.             lsize = 0;

    823. 

  823. 

    824. 

  824.             if(iType == 3)

    825. 

  825.             {

    826. 

  826.                 ilen = GetEWKBtoPolygonLen(sBuf, iDim, &lsize, byteorder);

    827. 

  827.                 sBuf += ilen;

    828. 

  828.                 iRes += ilen;

    829. 

  829.                 (*plen) += (4 + lsize); // 4 bytes for collection item size

    830. 

  830.             }

    831. 

  831.             else ilen = 0;

    832. 

  832.             i++;

    833. 

  833.         }

    834. 

  834.     }

    835. 

  835.     else if(lcnt == 1) // boundary or polygon geometry

    836. 

  836.     {

    837. 

  837.         byteorder = GetByte(&sBuf, &iRes);

    838. 

  838.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    839. 

  839. 

    840. 

  840.         ilocDim = ulType / 1000;

    841. 

  841.         iType = ulType - 1000*ilocDim;

    842. 

  842.         ilocDim += 2;

    843. 

  843. 

    844. 

  844.         lsize = 0;

    845. 

  845. 

    846. 

  846.         if(iType == 3)

    847. 

  847.         {

    848. 

  848.             iRes += GetEWKBtoPolygonLen(sBuf, iDim, &lsize, byteorder);

    849. 

  849.             (*plen) += lsize;

    850. 

  850.         }

    851. 

  851.     }

    852. 

  852.     return(iRes);

    853. 

  853. }

    854. 

  854. 

    855. 

  855. int EWKBtoMultiPolygon(unsigned char *sBuf, unsigned char *pBuf, int iDim,

    856. 

  856.     long *plen, unsigned char ucByteOrder)

    857. 

  857. {

    858. 

  858.     int iRes = 0;

    859. 

  859.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    860. 

  860. 

    861. 

  861.     unsigned char byteorder;

    862. 

  862.     long lsize = 0;

    863. 

  863.     unsigned long ulType;

    864. 

  864.     int ilocDim;

    865. 

  865.     int iType;

    866. 

  866. 

    867. 

  867.     if(lcnt > 1) // geometry collection

    868. 

  868.     {

    869. 

  869.         memcpy(pBuf, &GID_GeometryCollection, 16);

    870. 

  870.         pBuf += 16;

    871. 

  871.         *(unsigned long*)pBuf = lcnt;

    872. 

  872.         pBuf += 4;

    873. 

  873.         (*plen) += 20; // 16 vytes for geometry GUID amd 4 bytes for collection count

    874. 

  874. 

    875. 

  875.         int i = 0;

    876. 

  876.         int ilen = 1;

    877. 

  877.         while((i < (int)lcnt) && (ilen > 0))

    878. 

  878.         {

    879. 

  879.             byteorder = GetByte(&sBuf, &iRes);

    880. 

  880.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    881. 

  881. 

    882. 

  882.             ilocDim = ulType / 1000;

    883. 

  883.             iType = ulType - 1000*ilocDim;

    884. 

  884.             ilocDim += 2;

    885. 

  885. 

    886. 

  886.             lsize = 0;

    887. 

  887. 

    888. 

  888.             if(iType == 3)

    889. 

  889.             {

    890. 

  890.                 ilen = EWKBtoPolygon(sBuf, &pBuf[4], iDim, &lsize, byteorder);

    891. 

  891.                 *(unsigned long*)pBuf = lsize;

    892. 

  892.                 sBuf += ilen;

    893. 

  893.                 iRes += ilen;

    894. 

  894.                 pBuf += (4 + lsize);

    895. 

  895.                 (*plen) += (4 + lsize); // 4 bytes for collection item size

    896. 

  896.             }

    897. 

  897.             else ilen = 0;

    898. 

  898.             i++;

    899. 

  899.         }

    900. 

  900.     }

    901. 

  901.     else if(lcnt == 1) // boundary or polygon geometry

    902. 

  902.     {

    903. 

  903.         byteorder = GetByte(&sBuf, &iRes);

    904. 

  904.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    905. 

  905. 

    906. 

  906.         ilocDim = ulType / 1000;

    907. 

  907.         iType = ulType - 1000*ilocDim;

    908. 

  908.         ilocDim += 2;

    909. 

  909. 

    910. 

  910.         if(iType == 3)

    911. 

  911.         {

    912. 

  912.             iRes += EWKBtoPolygon(sBuf, pBuf, iDim, &lsize, byteorder);

    913. 

  913.             (*plen) += lsize;

    914. 

  914.         }

    915. 

  915.     }

    916. 

  916.     return(iRes);

    917. 

  917. }

    918. 

  918. 

    919. 

  919. int GetEWKBtoCircularStringLen(unsigned char *sBuf, int iDim, long *plen,

    920. 

  920.     unsigned char ucByteOrder, bool bWriteGUID)

    921. 

  921. {

    922. 

  922.     int iRes = 0;

    923. 

  923.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    924. 

  924. 

    925. 

  925.     double xStart[3], xMiddle[3], xEnd[3];

    926. 

  926. 

    927. 

  927.     if(lcnt > 3) // composite polyline geometry

    928. 

  928.     {

    929. 

  929.         int k = lcnt/2;

    930. 

  930.         if(bWriteGUID)

    931. 

  931.         {

    932. 

  932.             (*plen) += 16; // 16 bytes for geometry GUID

    933. 

  933.             (*plen) += 4; // 4 bytes for count

    934. 

  934.         }

    935. 

  935. 

    936. 

  936.         GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xEnd);

    937. 

  937. 

    938. 

  938.         for(int i = 0; i < k; i++)

    939. 

  939.         {

    940. 

  940.             xStart[0] = xEnd[0];

    941. 

  941.             xStart[1] = xEnd[1];

    942. 

  942.             xStart[2] = xEnd[2];

    943. 

  943. 

    944. 

  944.             GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xMiddle);

    945. 

  945.             GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xEnd);

    946. 

  946. 

    947. 

  947.             (*plen) += (4 + GetArcGeomSize(xStart, xMiddle, xEnd));

    948. 

  948.         }

    949. 

  949.     }

    950. 

  950.     else if(lcnt == 3) // arc geometry or composite polyline, if it is a circle

    951. 

  951.         // or can be also line geometry

    952. 

  952.     {

    953. 

  953.         GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xStart);

    954. 

  954.         GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xMiddle);

    955. 

  955.         GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xEnd);

    956. 

  956. 

    957. 

  957.         if((fabs(xEnd[0] - xStart[0]) < gdPrecLim) &&

    958. 

  958.             (fabs(xEnd[1] - xStart[1]) < gdPrecLim))

    959. 

  959.         {

    960. 

  960.             if(bWriteGUID)

    961. 

  961.             {

    962. 

  962.                 (*plen) += 16; // 16 bytes for geometry GUID

    963. 

  963.                 (*plen) += 4; // 4 bytes for count

    964. 

  964.             }

    965. 

  965. 

    966. 

  966.             // the geometry is whole circle, so we must represent it as

    967. 

  967.             // composite polyline geometry with two arcs

    968. 

  968.             (*plen) += 200; // 2x4 bytes for item size and 2x96 for two arcs

    969. 

  969.         }

    970. 

  970.         else

    971. 

  971.         {

    972. 

  972.             // the geometry is a pure arc

    973. 

  973.             (*plen) += GetArcGeomSize(xStart, xMiddle, xEnd);

    974. 

  974.         }

    975. 

  975.     }

    976. 

  976.     return(iRes);

    977. 

  977. }

    978. 

  978. 

    979. 

  979. // if plItemCount is NULL, then we are not interested in it, which in turn

    980. 

  980. // means that we want to write also the base GUID

    981. 

  981. int EWKBtoCircularString(unsigned char *sBuf, unsigned char *pBuf, int iDim,

    982. 

  982.     long *plen, unsigned char ucByteOrder, unsigned long *plItemCount)

    983. 

  983. {

    984. 

  984. #if DBGLEVEL > 2

    985. 

  985.     WriteLogFile("EWKBtoCircularString\r\n", true);

    986. 

  986. #endif // DBGLEVEL

    987. 

  987. 

    988. 

  988.     int iRes = 0;

    989. 

  989.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    990. 

  990.     unsigned char *tmpBuf;

    991. 

  991. 

    992. 

  992.     double xStart[3], xMiddle[3], xEnd[3];

    993. 

  993. 

    994. 

  994.     if(lcnt > 3) // composite polyline geometry

    995. 

  995.     {

    996. 

  996.         int k = lcnt/2;

    997. 

  997. 

    998. 

  998.         if(plItemCount) (*plItemCount) += k;

    999. 

  999.         else

    1000. 

  1000.         {

    1001. 

  1001.             memcpy(pBuf, &GID_CompositePolylineGeometry, 16);

    1002. 

  1002.             pBuf += 16;

    1003. 

  1003.             (*plen) += 16; // 16 bytes for geometry GUID

    1004. 

  1004.             *(long*)pBuf = k;

    1005. 

  1005.             pBuf += 4;

    1006. 

  1006.             (*plen) += 4; // 4 bytes for count

    1007. 

  1007.         }

    1008. 

  1008. 

    1009. 

  1009.         GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xEnd);

    1010. 

  1010. 

    1011. 

  1011.         long llen;

    1012. 

  1012. 

    1013. 

  1013.         for(int i = 0; i < k; i++)

    1014. 

  1014.         {

    1015. 

  1015.             xStart[0] = xEnd[0];

    1016. 

  1016.             xStart[1] = xEnd[1];

    1017. 

  1017.             xStart[2] = xEnd[2];

    1018. 

  1018. 

    1019. 

  1019.             GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xMiddle);

    1020. 

  1020.             GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xEnd);

    1021. 

  1021. 

    1022. 

  1022.             tmpBuf = WriteArcGeometry(&pBuf[4], xStart, xMiddle, xEnd);

    1023. 

  1023.             llen = (tmpBuf - &pBuf[4]);

    1024. 

  1024.             *(long*)pBuf = llen;

    1025. 

  1025.             (*plen) += (4 + llen);

    1026. 

  1026.             pBuf = tmpBuf;

    1027. 

  1027.         }

    1028. 

  1028.     }

    1029. 

  1029.     else if(lcnt == 3) // arc geometry or composite polyline, if it is a circle

    1030. 

  1030.         // or can be also line geometry

    1031. 

  1031.     {

    1032. 

  1032.         GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xStart);

    1033. 

  1033.         GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xMiddle);

    1034. 

  1034.         GetTriple(&sBuf, ucByteOrder, iDim, &iRes, xEnd);

    1035. 

  1035. 

    1036. 

  1036.         if((fabs(xEnd[0] - xStart[0]) < gdPrecLim) &&

    1037. 

  1037.             (fabs(xEnd[1] - xStart[1]) < gdPrecLim))

    1038. 

  1038.         {

    1039. 

  1039.             // the geometry is whole circle, so we must represent it as

    1040. 

  1040.             // composite polyline geometry with two arcs

    1041. 

  1041.             if(plItemCount) (*plItemCount) += 2;

    1042. 

  1042.             else

    1043. 

  1043.             {

    1044. 

  1044.                 memcpy(pBuf, &GID_CompositePolylineGeometry, 16);

    1045. 

  1045.                 pBuf += 16;

    1046. 

  1046.                 (*plen) += 16; // 16 bytes for geometry GUID

    1047. 

  1047.                 *(unsigned long*)pBuf = 2;

    1048. 

  1048.                 pBuf += 4;

    1049. 

  1049.                 (*plen) += 4; // 4 bytes for count

    1050. 

  1050.             }

    1051. 

  1051. 

    1052. 

  1052.             (*plen) += 200; // 2x4 bytes for item size and 2x96 for two arcs

    1053. 

  1053. 

    1054. 

  1054.             *(unsigned long*)pBuf = 96;

    1055. 

  1055.             pBuf += 4;

    1056. 

  1056. 

    1057. 

  1057.             memcpy(pBuf, &GID_ArcGeometry, 16);

    1058. 

  1058.             pBuf += 16;

    1059. 

  1059.             *(double*)pBuf = xStart[0];

    1060. 

  1060.             pBuf += 8;

    1061. 

  1061.             *(double*)pBuf = xStart[1];

    1062. 

  1062.             pBuf += 8;

    1063. 

  1063.             *(double*)pBuf = xStart[2];

    1064. 

  1064.             pBuf += 8;

    1065. 

  1065.             *(double*)pBuf = xMiddle[0];

    1066. 

  1066.             pBuf += 8;

    1067. 

  1067.             *(double*)pBuf = xMiddle[1];

    1068. 

  1068.             pBuf += 8;

    1069. 

  1069.             *(double*)pBuf = xMiddle[2];

    1070. 

  1070.             pBuf += 8;

    1071. 

  1071. 

    1072. 

  1072.             double D = (xMiddle[0] - xStart[0])*(xMiddle[0] - xStart[0]) +

    1073. 

  1073.                 (xMiddle[1] - xStart[1])*(xMiddle[1] - xStart[1]);

    1074. 

  1074.             double dnorm[3];

    1075. 

  1075.             double r = D;

    1076. 

  1076.             if(D > gdPrecLim)

    1077. 

  1077.             {

    1078. 

  1078.                 r = sqrt(D);

    1079. 

  1079.                 double vtmp[3];

    1080. 

  1080.                 vtmp[0] = (xMiddle[0] - xStart[0])/r;

    1081. 

  1081.                 vtmp[1] = (xStart[1] - xMiddle[1])/r;

    1082. 

  1082.                 vtmp[2] = 0.0;

    1083. 

  1083. 

    1084. 

  1084.                 dnorm[0] = vtmp[1]*(xMiddle[2] - xStart[2]);

    1085. 

  1085.                     // - vtmp[2]*(xMiddle[1] - xStart[1]) = 0

    1086. 

  1086.                 dnorm[1] = // vtmp[2]*(xMiddle[0] - xStart[0]) = 0

    1087. 

  1087.                      -vtmp[0]*(xMiddle[2] - xStart[2]);

    1088. 

  1088.                 dnorm[2] = vtmp[0]*(xMiddle[1] - xStart[1]) -

    1089. 

  1089.                      vtmp[1]*(xMiddle[0] - xStart[0]);

    1090. 

  1090.                 D = dnorm[0]*dnorm[0] + dnorm[1]*dnorm[1] + dnorm[2]*dnorm[2];

    1091. 

  1091.                 D = sqrt(D);

    1092. 

  1092.                 dnorm[0] /= D;

    1093. 

  1093.                 dnorm[1] /= D;

    1094. 

  1094.                 dnorm[2] /= D;

    1095. 

  1095.             }

    1096. 

  1096.             else

    1097. 

  1097.             {

    1098. 

  1098.                 dnorm[0] = 0.0;

    1099. 

  1099.                 dnorm[1] = 0.0;

    1100. 

  1100.                 dnorm[2] = 1.0;

    1101. 

  1101.             }

    1102. 

  1102. 

    1103. 

  1103.             r /= 2.0;

    1104. 

  1104. 

    1105. 

  1105.             *(double*)pBuf = dnorm[0];

    1106. 

  1106.             pBuf += 8;

    1107. 

  1107.             *(double*)pBuf = dnorm[1];

    1108. 

  1108.             pBuf += 8;

    1109. 

  1109.             *(double*)pBuf = dnorm[2];

    1110. 

  1110.             pBuf += 8;

    1111. 

  1111. 

    1112. 

  1112.             *(double*)pBuf = r;

    1113. 

  1113.             pBuf += 8;

    1114. 

  1114. 

    1115. 

  1115.             *(unsigned long*)pBuf = 96;

    1116. 

  1116.             pBuf += 4;

    1117. 

  1117. 

    1118. 

  1118.             memcpy(pBuf, &GID_ArcGeometry, 16);

    1119. 

  1119.             pBuf += 16;

    1120. 

  1120. 

    1121. 

  1121.             *(double*)pBuf = xMiddle[0];

    1122. 

  1122.             pBuf += 8;

    1123. 

  1123.             *(double*)pBuf = xMiddle[1];

    1124. 

  1124.             pBuf += 8;

    1125. 

  1125.             *(double*)pBuf = xMiddle[2];

    1126. 

  1126.             pBuf += 8;

    1127. 

  1127.             *(double*)pBuf = xStart[0];

    1128. 

  1128.             pBuf += 8;

    1129. 

  1129.             *(double*)pBuf = xStart[1];

    1130. 

  1130.             pBuf += 8;

    1131. 

  1131.             *(double*)pBuf = xStart[2];

    1132. 

  1132.             pBuf += 8;

    1133. 

  1133. 

    1134. 

  1134.             *(double*)pBuf = dnorm[0];

    1135. 

  1135.             pBuf += 8;

    1136. 

  1136.             *(double*)pBuf = dnorm[1];

    1137. 

  1137.             pBuf += 8;

    1138. 

  1138.             *(double*)pBuf = dnorm[2];

    1139. 

  1139.             pBuf += 8;

    1140. 

  1140. 

    1141. 

  1141.             *(double*)pBuf = r;

    1142. 

  1142.             pBuf += 8;

    1143. 

  1143.         }

    1144. 

  1144.         else

    1145. 

  1145.         {

    1146. 

  1146.             if(plItemCount) (*plItemCount) += 1;

    1147. 

  1147.             tmpBuf = WriteArcGeometry(pBuf, xStart, xMiddle, xEnd);

    1148. 

  1148.             (*plen) += (tmpBuf - pBuf);

    1149. 

  1149.             pBuf = tmpBuf;

    1150. 

  1150.         }

    1151. 

  1151.     }

    1152. 

  1152.     return(iRes);

    1153. 

  1153. }

    1154. 

  1154. 

    1155. 

  1155. int GetEWKBtoCompoundCurveLen(unsigned char *sBuf, int iDim, long *plen,

    1156. 

  1156.     unsigned char ucByteOrder, bool bWriteGUID)

    1157. 

  1157. {

    1158. 

  1158.     int iRes = 0;

    1159. 

  1159.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    1160. 

  1160. 

    1161. 

  1161.     unsigned char byteorder;

    1162. 

  1162.     long lsize = 0;

    1163. 

  1163.     unsigned long ulType;

    1164. 

  1164.     int ilocDim;

    1165. 

  1165.     int iType;

    1166. 

  1166. 

    1167. 

  1167.     if(lcnt > 1) // composite polyline

    1168. 

  1168.     {

    1169. 

  1169.         if(bWriteGUID)

    1170. 

  1170.             (*plen) += 20; // 16 bytes for geometry GUID and 4 bytes for collection count

    1171. 

  1171.         int i = 0;

    1172. 

  1172.         int ilen = 1;

    1173. 

  1173.         while((i < (int)lcnt) && (ilen > 0))

    1174. 

  1174.         {

    1175. 

  1175.             byteorder = GetByte(&sBuf, &iRes);

    1176. 

  1176.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1177. 

  1177. 

    1178. 

  1178.             ilocDim = ulType / 1000;

    1179. 

  1179.             iType = ulType - 1000*ilocDim;

    1180. 

  1180.             ilocDim += 2;

    1181. 

  1181. 

    1182. 

  1182.             lsize = 0;

    1183. 

  1183. 

    1184. 

  1184.             switch(iType)

    1185. 

  1185.             {

    1186. 

  1186.             case 2:

    1187. 

  1187.                 ilen = GetEWKBtoLineStringLen(sBuf, iDim, &lsize, byteorder,

    1188. 

  1188.                     true);

    1189. 

  1189.                 sBuf += ilen;

    1190. 

  1190.                 iRes += ilen;

    1191. 

  1191.                 (*plen) += (4 + lsize); // 4 bytes for collection item size

    1192. 

  1192.                 break;

    1193. 

  1193.             case 8:

    1194. 

  1194.                 ilen = GetEWKBtoCircularStringLen(sBuf, iDim, &lsize, byteorder,

    1195. 

  1195.                     false);

    1196. 

  1196.                 sBuf += ilen;

    1197. 

  1197.                 iRes += ilen;

    1198. 

  1198.                 (*plen) += (4 + lsize);

    1199. 

  1199.                 break;

    1200. 

  1200.             default:

    1201. 

  1201.                 ilen = 0;

    1202. 

  1202.             }

    1203. 

  1203.             i++;

    1204. 

  1204.         }

    1205. 

  1205.     }

    1206. 

  1206.     else if(lcnt == 1) // polyline geometry

    1207. 

  1207.     {

    1208. 

  1208.         byteorder = GetByte(&sBuf, &iRes);

    1209. 

  1209.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1210. 

  1210. 

    1211. 

  1211.         ilocDim = ulType / 1000;

    1212. 

  1212.         iType = ulType - 1000*ilocDim;

    1213. 

  1213.         ilocDim += 2;

    1214. 

  1214. 

    1215. 

  1215.         lsize = 0;

    1216. 

  1216. 

    1217. 

  1217.         switch(iType)

    1218. 

  1218.         {

    1219. 

  1219.         case 2:

    1220. 

  1220.             iRes += GetEWKBtoLineStringLen(sBuf, iDim, &lsize, byteorder, true);

    1221. 

  1221.             break;

    1222. 

  1222.         case 8:

    1223. 

  1223.             iRes += GetEWKBtoCircularStringLen(sBuf, iDim, &lsize, byteorder,

    1224. 

  1224.                 bWriteGUID);

    1225. 

  1225.             break;

    1226. 

  1226.         }

    1227. 

  1227. 

    1228. 

  1228.         (*plen) += lsize;

    1229. 

  1229.     }

    1230. 

  1230.     return(iRes);

    1231. 

  1231. }

    1232. 

  1232. 

    1233. 

  1233. // if plItemCount is NULL, then we are not interested in it, which in turn

    1234. 

  1234. // means that we want to write also the base GUID

    1235. 

  1235. int EWKBtoCompoundCurve(unsigned char *sBuf, unsigned char *pBuf, int iDim,

    1236. 

  1236.     long *plen, unsigned char ucByteOrder, unsigned long *plItemCount)

    1237. 

  1237. {

    1238. 

  1238. #if DBGLEVEL > 2

    1239. 

  1239.     WriteLogFile("EWKBtoCompoundCurve\r\n", true);

    1240. 

  1240. #endif // DBGLEVEL

    1241. 

  1241. 

    1242. 

  1242.     int iRes = 0;

    1243. 

  1243.     unsigned long lcnt = GetLong(&sBuf, ucByteOrder, &iRes);

    1244. 

  1244. 

    1245. 

  1245.     unsigned char byteorder;

    1246. 

  1246.     long lsize = 0;

    1247. 

  1247.     unsigned long ulType, ltruecount;

    1248. 

  1248.     int ilocDim;

    1249. 

  1249.     int iType;

    1250. 

  1250.     unsigned char *pSaveBuf = NULL;

    1251. 

  1251. 

    1252. 

  1252.     if(lcnt > 1) // composite polyline

    1253. 

  1253.     {

    1254. 

  1254.         if(!plItemCount)

    1255. 

  1255.         {

    1256. 

  1256.             memcpy(pBuf, &GID_CompositePolylineGeometry, 16);

    1257. 

  1257.             pBuf += 16;

    1258. 

  1258. 

    1259. 

  1259.             pSaveBuf = pBuf;

    1260. 

  1260.             ltruecount = 0;

    1261. 

  1261.             //*(unsigned long*)pBuf = lcnt;

    1262. 

  1262.             pBuf += 4;

    1263. 

  1263.             (*plen) += 20; // 16 bytes for geometry GUID amd 4 bytes for collection count

    1264. 

  1264.         }

    1265. 

  1265. 

    1266. 

  1266.         int i = 0;

    1267. 

  1267.         int ilen = 1;

    1268. 

  1268.         while((i < (int)lcnt) && (ilen > 0))

    1269. 

  1269.         {

    1270. 

  1270.             byteorder = GetByte(&sBuf, &iRes);

    1271. 

  1271.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1272. 

  1272. 

    1273. 

  1273.             ilocDim = ulType / 1000;

    1274. 

  1274.             iType = ulType - 1000*ilocDim;

    1275. 

  1275.             ilocDim += 2;

    1276. 

  1276. 

    1277. 

  1277.             lsize = 0;

    1278. 

  1278.             switch(iType)

    1279. 

  1279.             {

    1280. 

  1280.             case 2:

    1281. 

  1281.                 ilen = EWKBtoLineString(sBuf, &pBuf[4], iDim, &lsize, byteorder,

    1282. 

  1282.                     NULL);

    1283. 

  1283.                 *(unsigned long*)pBuf = lsize;

    1284. 

  1284.                 sBuf += ilen;

    1285. 

  1285.                 iRes += ilen;

    1286. 

  1286.                 pBuf += (4 + lsize);

    1287. 

  1287.                 (*plen) += (4 + lsize); // 4 bytes for collection item size

    1288. 

  1288.                 ltruecount += 1;

    1289. 

  1289.                 break;

    1290. 

  1290.             case 8:

    1291. 

  1291.                 ilen = EWKBtoCircularString(sBuf, &pBuf[4], iDim, &lsize,

    1292. 

  1292.                     byteorder, &ltruecount);

    1293. 

  1293.                 *(unsigned long*)pBuf = lsize;

    1294. 

  1294.                 sBuf += ilen;

    1295. 

  1295.                 iRes += ilen;

    1296. 

  1296.                 pBuf += (4 + lsize);

    1297. 

  1297.                 (*plen) += (4 + lsize);

    1298. 

  1298.                 break;

    1299. 

  1299.             default:

    1300. 

  1300.                 ilen = 0;

    1301. 

  1301.             }

    1302. 

  1302.             i++;

    1303. 

  1303.         }

    1304. 

  1304.         if(plItemCount) (*plItemCount) += ltruecount;

    1305. 

  1305.         else *(unsigned long*)pSaveBuf = ltruecount;

    1306. 

  1306.     }

    1307. 

  1307.     else if(lcnt == 1) // polyline geometry or arc

    1308. 

  1308.     {

    1309. 

  1309.         byteorder = GetByte(&sBuf, &iRes);

    1310. 

  1310.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1311. 

  1311. 

    1312. 

  1312.         ilocDim = ulType / 1000;

    1313. 

  1313.         iType = ulType - 1000*ilocDim;

    1314. 

  1314.         ilocDim += 2;

    1315. 

  1315. 

    1316. 

  1316.         lsize = 0;

    1317. 

  1317. 

    1318. 

  1318.         switch(iType)

    1319. 

  1319.         {

    1320. 

  1320.         case 2:

    1321. 

  1321.             iRes += EWKBtoLineString(sBuf, pBuf, iDim, &lsize, byteorder,

    1322. 

  1322.                 NULL);

    1323. 

  1323.             if(plItemCount) (*plItemCount) += 1;

    1324. 

  1324.             break;

    1325. 

  1325.         case 8:

    1326. 

  1326.             iRes += EWKBtoCircularString(sBuf, pBuf, iDim, &lsize, byteorder,

    1327. 

  1327.                 plItemCount);

    1328. 

  1328.             break;

    1329. 

  1329.         }

    1330. 

  1330. 

    1331. 

  1331.         (*plen) += lsize;

    1332. 

  1332.     }

    1333. 

  1333.     return(iRes);

    1334. 

  1334. }

    1335. 

  1335. 

    1336. 

  1336. int GetEWKBtoCurvePolygonLen(unsigned char *sBuf, int iDim, long *plen,

    1337. 

  1337.     unsigned char ucByteOrder)

    1338. 

  1338. {

    1339. 

  1339.     int iRes = 0;

    1340. 

  1340.     unsigned long ulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    1341. 

  1341. 

    1342. 

  1342.     unsigned char byteorder;

    1343. 

  1343.     long lsize = 0;

    1344. 

  1344.     unsigned long ulType;

    1345. 

  1345.     int ilocDim;

    1346. 

  1346.     int iType;

    1347. 

  1347. 

    1348. 

  1348.     if(ulLen > 1) // boundary geometry

    1349. 

  1349.     {

    1350. 

  1350.         (*plen) += 20; // 16 bytes for geometry GUID and 4 bytes for boundary

    1351. 

  1351.             // size, 4 bytes for holes size are covered in the while loop

    1352. 

  1352. 

    1353. 

  1353.         // 16 bytes for collection GUID, 4 bytes for collection count

    1354. 

  1354.         (*plen) += 20;

    1355. 

  1355. 

    1356. 

  1356.         int i = 0;

    1357. 

  1357.         int ilen = 1;

    1358. 

  1358.         while((i < (int)ulLen) && (ilen > 0))

    1359. 

  1359.         {

    1360. 

  1360.             (*plen) += 4; // 4 bytes for collection item size

    1361. 

  1361. 

    1362. 

  1362.             byteorder = GetByte(&sBuf, &iRes);

    1363. 

  1363.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1364. 

  1364. 

    1365. 

  1365.             ilocDim = ulType / 1000;

    1366. 

  1366.             iType = ulType - 1000*ilocDim;

    1367. 

  1367.             ilocDim += 2;

    1368. 

  1368. 

    1369. 

  1369.             lsize = 0;

    1370. 

  1370. 

    1371. 

  1371.             switch(iType)

    1372. 

  1372.             {

    1373. 

  1373.             case 2:

    1374. 

  1374.                 ilen = GetEWKBtoLineStringLen(sBuf, iDim, &lsize, byteorder,

    1375. 

  1375.                     false);

    1376. 

  1376.                 break;

    1377. 

  1377.             case 8:

    1378. 

  1378.                 ilen = GetEWKBtoCircularStringLen(sBuf, iDim, &lsize, byteorder,

    1379. 

  1379.                     false);

    1380. 

  1380.                 break;

    1381. 

  1381.             case 9:

    1382. 

  1382.                 ilen = GetEWKBtoCompoundCurveLen(sBuf, iDim, &lsize, byteorder,

    1383. 

  1383.                     false);

    1384. 

  1384.                 break;

    1385. 

  1385.             default:

    1386. 

  1386.                 ilen = 0;

    1387. 

  1387.             }

    1388. 

  1388.             sBuf += ilen;

    1389. 

  1389.             iRes += ilen;

    1390. 

  1390.             (*plen) += (20 + lsize); // 4 bytes for collection item count

    1391. 

  1391.             i++;

    1392. 

  1392.         }

    1393. 

  1393.     }

    1394. 

  1394.     else if(ulLen == 1) // composite polygon geometry or polygon geometry

    1395. 

  1395.     {

    1396. 

  1396.         byteorder = GetByte(&sBuf, &iRes);

    1397. 

  1397.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1398. 

  1398. 

    1399. 

  1399.         ilocDim = ulType / 1000;

    1400. 

  1400.         iType = ulType - 1000*ilocDim;

    1401. 

  1401.         ilocDim += 2;

    1402. 

  1402. 

    1403. 

  1403.         switch(iType)

    1404. 

  1404.         {

    1405. 

  1405.         case 2:

    1406. 

  1406.             (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for count

    1407. 

  1407.             iRes += GetEWKBtoLineStringLen(sBuf, iDim, plen, byteorder, false);

    1408. 

  1408.             break;

    1409. 

  1409.         case 8:

    1410. 

  1410.             (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for count

    1411. 

  1411.             iRes += GetEWKBtoCircularStringLen(sBuf, iDim, plen, byteorder,

    1412. 

  1412.                 false);

    1413. 

  1413.             break;

    1414. 

  1414.         case 9:

    1415. 

  1415.             (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for count

    1416. 

  1416.             iRes += GetEWKBtoCompoundCurveLen(sBuf, iDim, plen, byteorder,

    1417. 

  1417.                 false);

    1418. 

  1418.             break;

    1419. 

  1419.         }

    1420. 

  1420.     }

    1421. 

  1421. 

    1422. 

  1422.     return(iRes);

    1423. 

  1423. }

    1424. 

  1424. 

    1425. 

  1425. int EWKBtoCurvePolygon(unsigned char *sBuf, unsigned char *pBuf, int iDim,

    1426. 

  1426.     long *plen, unsigned char ucByteOrder)

    1427. 

  1427. {

    1428. 

  1428. #if DBGLEVEL > 2

    1429. 

  1429.     WriteLogFile("EWKBtoCurvePolygon\r\n", true);

    1430. 

  1430. #endif // DBGLEVEL

    1431. 

  1431. 

    1432. 

  1432.     int iRes = 0;

    1433. 

  1433.     unsigned long ulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    1434. 

  1434. 

    1435. 

  1435.     unsigned char byteorder;

    1436. 

  1436.     long lsize = 0;

    1437. 

  1437.     unsigned long ulType;

    1438. 

  1438.     int ilocDim;

    1439. 

  1439.     int iType;

    1440. 

  1440. 

    1441. 

  1441.     unsigned char *pSaveBuf = NULL, *pSaveBuf2 = NULL;

    1442. 

  1442.     unsigned long ltruecount = 0;

    1443. 

  1443. 

    1444. 

  1444.     if(ulLen > 1) // boundary geometry

    1445. 

  1445.     {

    1446. 

  1446.         memcpy(pBuf, &GID_BoundaryGeometry, 16);

    1447. 

  1447.         pBuf += 16;

    1448. 

  1448.         (*plen) += 16; // 16 bytes for Geom GUID

    1449. 

  1449. 

    1450. 

  1450.         pSaveBuf = pBuf;

    1451. 

  1451.         pBuf += 4;

    1452. 

  1452.         (*plen) += 4; // 4 bytes for boundary size

    1453. 

  1453. 

    1454. 

  1454.         byteorder = GetByte(&sBuf, &iRes);

    1455. 

  1455.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1456. 

  1456. 

    1457. 

  1457.         ilocDim = ulType / 1000;

    1458. 

  1458.         iType = ulType - 1000*ilocDim;

    1459. 

  1459.         ilocDim += 2;

    1460. 

  1460. 

    1461. 

  1461.         lsize = 0;

    1462. 

  1462.         int ilen = 1;

    1463. 

  1463.         ltruecount = 0;

    1464. 

  1464. 

    1465. 

  1465.         switch(iType)

    1466. 

  1466.         {

    1467. 

  1467.         case 2:

    1468. 

  1468.             memcpy(pBuf, &GID_PolygonGeometry, 16);

    1469. 

  1469.             pBuf += 16;

    1470. 

  1470.             pSaveBuf2 = pBuf;

    1471. 

  1471.             pBuf += 4;

    1472. 

  1472.             (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for count

    1473. 

  1473.             ilen = EWKBtoLineString(sBuf, pBuf, iDim, &lsize, byteorder,

    1474. 

  1474.                 &ltruecount);

    1475. 

  1475.             *(unsigned long*)pSaveBuf2 = ltruecount;

    1476. 

  1476.             break;

    1477. 

  1477.         case 8:

    1478. 

  1478.             memcpy(pBuf, &GID_CompositePolygonGeometry, 16);

    1479. 

  1479.             pBuf += 16;

    1480. 

  1480.             pSaveBuf2 = pBuf;

    1481. 

  1481.             pBuf += 4;

    1482. 

  1482.             (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for item count

    1483. 

  1483.             ilen = EWKBtoCircularString(sBuf, pBuf, iDim, &lsize, byteorder,

    1484. 

  1484.                 &ltruecount);

    1485. 

  1485.             *(unsigned long*)pSaveBuf2 = ltruecount;

    1486. 

  1486.             break;

    1487. 

  1487.         case 9:

    1488. 

  1488.             memcpy(pBuf, &GID_CompositePolygonGeometry, 16);

    1489. 

  1489.             pBuf += 16;

    1490. 

  1490.             pSaveBuf2 = pBuf;

    1491. 

  1491.             pBuf += 4;

    1492. 

  1492.             (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for item count

    1493. 

  1493.             ilen = EWKBtoCompoundCurve(sBuf, pBuf, iDim, &lsize, byteorder,

    1494. 

  1494.                 &ltruecount);

    1495. 

  1495.             *(unsigned long*)pSaveBuf2 = ltruecount;

    1496. 

  1496.             break;

    1497. 

  1497.         default:

    1498. 

  1498.             ilen = 0;

    1499. 

  1499.         }

    1500. 

  1500.         *(unsigned long*)pSaveBuf = (20 + lsize);

    1501. 

  1501.         sBuf += ilen;

    1502. 

  1502.         iRes += ilen;

    1503. 

  1503.         pBuf += lsize;

    1504. 

  1504.         (*plen) += lsize;

    1505. 

  1505. 

    1506. 

  1506.         pSaveBuf = pBuf;

    1507. 

  1507.         pBuf += 4;

    1508. 

  1508.         (*plen) += 4;

    1509. 

  1509. 

    1510. 

  1510.         memcpy(pBuf, &GID_GeometryCollection, 16);

    1511. 

  1511.         pBuf += 16;

    1512. 

  1512.         *(unsigned long*)pBuf = ulLen - 1;

    1513. 

  1513.         pBuf += 4;

    1514. 

  1514.         (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for item count

    1515. 

  1515.         int ltotsize = 20;

    1516. 

  1516. 

    1517. 

  1517.         int i = 1;

    1518. 

  1518.         while((i < (int)ulLen) && (ilen > 0))

    1519. 

  1519.         {

    1520. 

  1520.             pSaveBuf2 = pBuf;

    1521. 

  1521.             pBuf += 4;

    1522. 

  1522.             (*plen) += 4;

    1523. 

  1523. 

    1524. 

  1524.             byteorder = GetByte(&sBuf, &iRes);

    1525. 

  1525.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1526. 

  1526. 

    1527. 

  1527.             ilocDim = ulType / 1000;

    1528. 

  1528.             iType = ulType - 1000*ilocDim;

    1529. 

  1529.             ilocDim += 2;

    1530. 

  1530. 

    1531. 

  1531.             lsize = 0;

    1532. 

  1532.             ltruecount = 0;

    1533. 

  1533. 

    1534. 

  1534.             switch(iType)

    1535. 

  1535.             {

    1536. 

  1536.             case 2:

    1537. 

  1537.                 memcpy(pBuf, &GID_PolygonGeometry, 16);

    1538. 

  1538.                 pBuf += 16;

    1539. 

  1539.                 (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for count

    1540. 

  1540.                 ilen = EWKBtoLineString(sBuf, &pBuf[4], iDim, &lsize, byteorder,

    1541. 

  1541.                     &ltruecount);

    1542. 

  1542.                 *(unsigned long*)pBuf = ltruecount;

    1543. 

  1543.                 break;

    1544. 

  1544.             case 8:

    1545. 

  1545.                 memcpy(pBuf, &GID_CompositePolygonGeometry, 16);

    1546. 

  1546.                 pBuf += 16;

    1547. 

  1547.                 (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for item count

    1548. 

  1548.                 ilen = EWKBtoCircularString(sBuf, &pBuf[4], iDim, &lsize,

    1549. 

  1549.                     byteorder, &ltruecount);

    1550. 

  1550.                 *(unsigned long*)pBuf = ltruecount;

    1551. 

  1551.                 break;

    1552. 

  1552.             case 9:

    1553. 

  1553.                 memcpy(pBuf, &GID_CompositePolygonGeometry, 16);

    1554. 

  1554.                 pBuf += 16;

    1555. 

  1555.                 (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for item count

    1556. 

  1556.                 ilen = EWKBtoCompoundCurve(sBuf, pBuf, iDim, &lsize, byteorder,

    1557. 

  1557.                     &ltruecount);

    1558. 

  1558.                 *(unsigned long*)pBuf = ltruecount;

    1559. 

  1559.                 break;

    1560. 

  1560.             default:

    1561. 

  1561.                 ilen = 0;

    1562. 

  1562.             }

    1563. 

  1563.             *(unsigned long*)pSaveBuf2 = (20 + lsize);

    1564. 

  1564.             sBuf += ilen;

    1565. 

  1565.             iRes += ilen;

    1566. 

  1566.             pBuf += (4 + lsize);

    1567. 

  1567.             (*plen) += lsize;

    1568. 

  1568.             ltotsize += (24 + lsize);

    1569. 

  1569.             i++;

    1570. 

  1570.         }

    1571. 

  1571. 

    1572. 

  1572.         *(unsigned long*)pSaveBuf = ltotsize;

    1573. 

  1573.     }

    1574. 

  1574.     else if(ulLen == 1) // composite polygon geometry or polygon geometry

    1575. 

  1575.     {

    1576. 

  1576.         byteorder = GetByte(&sBuf, &iRes);

    1577. 

  1577.         ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1578. 

  1578. 

    1579. 

  1579.         ilocDim = ulType / 1000;

    1580. 

  1580.         iType = ulType - 1000*ilocDim;

    1581. 

  1581.         ilocDim += 2;

    1582. 

  1582. 

    1583. 

  1583.         switch(iType)

    1584. 

  1584.         {

    1585. 

  1585.         case 2:

    1586. 

  1586.             memcpy(pBuf, &GID_PolygonGeometry, 16);

    1587. 

  1587.             pBuf += 16;

    1588. 

  1588.             pSaveBuf = pBuf;

    1589. 

  1589.             pBuf += 4;

    1590. 

  1590.             (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for point count

    1591. 

  1591. 

    1592. 

  1592.             ltruecount = 0;

    1593. 

  1593.             iRes += EWKBtoLineString(sBuf, pBuf, iDim, plen, byteorder,

    1594. 

  1594.                 &ltruecount);

    1595. 

  1595.             *(unsigned long*)pSaveBuf = ltruecount;

    1596. 

  1596.             break;

    1597. 

  1597.         case 8:

    1598. 

  1598.             memcpy(pBuf, &GID_CompositePolygonGeometry, 16);

    1599. 

  1599.             pBuf += 16;

    1600. 

  1600.             pSaveBuf = pBuf;

    1601. 

  1601.             pBuf += 4;

    1602. 

  1602.             (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for item count

    1603. 

  1603. 

    1604. 

  1604.             ltruecount = 0;

    1605. 

  1605.             iRes += EWKBtoCircularString(sBuf, pBuf, iDim, plen, byteorder,

    1606. 

  1606.                 &ltruecount);

    1607. 

  1607.             *(unsigned long*)pSaveBuf = ltruecount;

    1608. 

  1608.             break;

    1609. 

  1609.         case 9:

    1610. 

  1610.             memcpy(pBuf, &GID_CompositePolygonGeometry, 16);

    1611. 

  1611.             pBuf += 16;

    1612. 

  1612.             pSaveBuf = pBuf;

    1613. 

  1613.             pBuf += 4;

    1614. 

  1614.             (*plen) += 20; // 16 bytes for Geom GUID, 4 bytes for item count

    1615. 

  1615. 

    1616. 

  1616.             ltruecount = 0;

    1617. 

  1617.             iRes += EWKBtoCompoundCurve(sBuf, pBuf, iDim, plen, byteorder,

    1618. 

  1618.                 &ltruecount);

    1619. 

  1619.             *(unsigned long*)pSaveBuf = ltruecount;

    1620. 

  1620.             break;

    1621. 

  1621.         }

    1622. 

  1622.     }

    1623. 

  1623. 

    1624. 

  1624.     return(iRes);

    1625. 

  1625. }

    1626. 

  1626. 

    1627. 

  1627. int GetEWKBtoMultiCurveLen(unsigned char *sBuf, int iDim, long *plen,

    1628. 

  1628.     unsigned char ucByteOrder)

    1629. 

  1629. {

    1630. 

  1630.     int iRes = 0;

    1631. 

  1631.     unsigned long ulLen = GetLong(&sBuf, ucByteOrder, &iRes);

    1632. 

  1632. 

    1633. 

  1633.     unsigned char byteorder;

    1634. 

  1634.     long lsize = 0;

    1635. 

  1635.     unsigned long ulType;

    1636. 

  1636.     int ilocDim;

    1637. 

  1637.     int iType;

    1638. 

  1638. 

    1639. 

  1639.     if(ulLen > 1) // geometry collection

    1640. 

  1640.     {

    1641. 

  1641.         // 16 bytes for collection GUID, 4 bytes for collection count

    1642. 

  1642.         (*plen) += 20;

    1643. 

  1643. 

    1644. 

  1644.         int i = 0;

    1645. 

  1645.         int ilen = 1;

    1646. 

  1646.         while((i < (int)ulLen) && (ilen > 0))

    1647. 

  1647.         {

    1648. 

  1648.             byteorder = GetByte(&sBuf, &iRes);

    1649. 

  1649.             ulType = GetGeomType(&sBuf, byteorder, &iRes);

    1650. 

  1650. 

    1651. 

  1651.             ilocDim = ulType / 1000;

    1652. 

  1652.             iTyp…
    1653.

Large files files are truncated, but you can click here to view the full file