Subversion Repositories Projects

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2498 - 1

2
namespace GMap.NET.Projections
3
{
4
   using System;
5
using System.Collections.Generic;
6
 
7
   /// <summary>
8
   /// GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]
9
   /// PROJCS["LKS94 / Lithuania TM",GEOGCS["LKS94",DATUM["Lithuania_1994_ETRS89",SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6126"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4669"]],UNIT["metre",1,AUTHORITY["EPSG","9001"]],PROJECTION["Transverse_Mercator"],PARAMETER["latitude_of_origin",0],PARAMETER["central_meridian",24],PARAMETER["scale_factor",0.9998],PARAMETER["false_easting",500000],PARAMETER["false_northing",0],AUTHORITY["EPSG","3346"],AXIS["Y",EAST],AXIS["X",NORTH]]
10
   /// </summary>
11
   public class LKS94rProjection : PureProjection
12
   {
13
      public static readonly LKS94rProjection Instance = new LKS94rProjection();
14
 
15
      static readonly double MinLatitude = 53.33;
16
      static readonly double MaxLatitude = 56.55;
17
      static readonly double MinLongitude = 20.22;
18
      static readonly double MaxLongitude = 27.11;
19
 
20
      static readonly double orignX = -5122000;
21
      static readonly double orignY = 10325013.240285;
22
 
23
      static readonly double scaleFactor = 0.9998;                      // scale factor                         
24
      static readonly double centralMeridian = 0.41887902047863912;// Center longitude (projection center) 
25
      static readonly double latOrigin = 0.0;                      // center latitude                   
26
      static readonly double falseNorthing = 0.0;                 // y offset in meters                 
27
      static readonly double falseEasting = 500000.0;          // x offset in meters                    
28
      static readonly double semiMajor = 6378137.0;                 // major axis
29
      static readonly double semiMinor = 6356752.3141403561; // minor axis
30
      static readonly double semiMinor2 = 6356752.3142451793;           // minor axis
31
      static readonly double metersPerUnit = 1.0;
32
      static readonly double COS_67P5 = 0.38268343236508977; // cosine of 67.5 degrees
33
      static readonly double AD_C = 1.0026000;               // Toms region 1 constant
34
 
35
      public override RectLatLng Bounds
36
      {
37
         get
38
         {
39
            return RectLatLng.FromLTRB(MinLongitude, MaxLatitude, MaxLongitude, MinLatitude);
40
         }
41
      }
42
 
43
      GSize tileSize = new GSize(256, 256);
44
      public override GSize TileSize
45
      {
46
         get
47
         {
48
            return tileSize;
49
         }
50
      }
51
 
52
      public override double Axis
53
      {
54
         get
55
         {
56
            return 6378137;
57
         }
58
      }
59
 
60
      public override double Flattening
61
      {
62
         get
63
         {
64
            return (1.0 / 298.257222101);
65
         }
66
      }
67
 
68
      public override GPoint FromLatLngToPixel(double lat, double lng, int zoom)
69
      {
70
         lat = Clip(lat, MinLatitude, MaxLatitude);
71
         lng = Clip(lng, MinLongitude, MaxLongitude);
72
 
73
         double[] lks = new double[] { lng, lat };
74
         lks = DTM10(lks);
75
         lks = MTD10(lks);
76
         lks = DTM00(lks);
77
 
78
         double res = GetTileMatrixResolution(zoom);
79
         return LksToPixel(lks, res);
80
      }
81
 
82
      static GPoint LksToPixel(double[] lks, double res)
83
      {
84
         return new GPoint((long)Math.Floor((lks[0] - orignX) / res), (long)Math.Floor((orignY - lks[1]) / res));
85
      }
86
 
87
      public override PointLatLng FromPixelToLatLng(long x, long y, int zoom)
88
      {
89
         PointLatLng ret = PointLatLng.Empty;
90
 
91
         double res = GetTileMatrixResolution(zoom);
92
 
93
         double[] lks = new double[] { (x * res) + orignX, orignY - (y * res) };
94
         lks = MTD11(lks);
95
         lks = DTM10(lks);
96
         lks = MTD10(lks);
97
 
98
         ret.Lat = Clip(lks[1], MinLatitude, MaxLatitude);
99
         ret.Lng = Clip(lks[0], MinLongitude, MaxLongitude);
100
 
101
         return ret;
102
      }
103
 
104
      double[] DTM10(double[] lonlat)
105
      {
106
         // Eccentricity squared : (a^2 - b^2)/a^2
107
         double es = 1.0 - (semiMinor2 * semiMinor2) / (semiMajor * semiMajor); // e^2
108
 
109
         // Second eccentricity squared : (a^2 - b^2)/b^2
110
         double ses = (Math.Pow(semiMajor, 2) - Math.Pow(semiMinor2, 2)) / Math.Pow(semiMinor2, 2);
111
 
112
         double ba = semiMinor2 / semiMajor;
113
         double ab = semiMajor / semiMinor2;
114
 
115
         double lon = DegreesToRadians(lonlat[0]);
116
         double lat = DegreesToRadians(lonlat[1]);
117
         double h = lonlat.Length < 3 ? 0 : lonlat[2].Equals(Double.NaN) ? 0 : lonlat[2];
118
         double v = semiMajor / Math.Sqrt(1 - es * Math.Pow(Math.Sin(lat), 2));
119
         double x = (v + h) * Math.Cos(lat) * Math.Cos(lon);
120
         double y = (v + h) * Math.Cos(lat) * Math.Sin(lon);
121
         double z = ((1 - es) * v + h) * Math.Sin(lat);
122
         return new double[] { x, y, z, };
123
      }
124
 
125
      double[] MTD10(double[] pnt)
126
      {
127
         // Eccentricity squared : (a^2 - b^2)/a^2
128
         double es = 1.0 - (semiMinor * semiMinor) / (semiMajor * semiMajor); // e^2
129
 
130
         // Second eccentricity squared : (a^2 - b^2)/b^2
131
         double ses = (Math.Pow(semiMajor, 2) - Math.Pow(semiMinor, 2)) / Math.Pow(semiMinor, 2);
132
 
133
         double ba = semiMinor / semiMajor;
134
         double ab = semiMajor / semiMinor;
135
 
136
         bool AtPole = false; // is location in polar region
137
         double Z = pnt.Length < 3 ? 0 : pnt[2].Equals(Double.NaN) ? 0 : pnt[2];
138
 
139
         double lon = 0;
140
         double lat = 0;
141
         double Height = 0;
142
         if(pnt[0] != 0.0)
143
         {
144
            lon = Math.Atan2(pnt[1], pnt[0]);
145
         }
146
         else
147
         {
148
            if(pnt[1] > 0)
149
            {
150
               lon = Math.PI / 2;
151
            }
152
            else
153
               if(pnt[1] < 0)
154
               {
155
                  lon = -Math.PI * 0.5;
156
               }
157
               else
158
               {
159
                  AtPole = true;
160
                  lon = 0.0;
161
                  if(Z > 0.0) // north pole
162
                  {
163
                     lat = Math.PI * 0.5;
164
                  }
165
                  else
166
                     if(Z < 0.0) // south pole
167
                     {
168
                        lat = -Math.PI * 0.5;
169
                     }
170
                     else // center of earth
171
                     {
172
                        return new double[] { RadiansToDegrees(lon), RadiansToDegrees(Math.PI * 0.5), -semiMinor, };
173
                     }
174
               }
175
         }
176
         double W2 = pnt[0] * pnt[0] + pnt[1] * pnt[1]; // Square of distance from Z axis
177
         double W = Math.Sqrt(W2); // distance from Z axis
178
         double T0 = Z * AD_C; // initial estimate of vertical component
179
         double S0 = Math.Sqrt(T0 * T0 + W2); // initial estimate of horizontal component
180
         double Sin_B0 = T0 / S0; // sin(B0), B0 is estimate of Bowring aux variable
181
         double Cos_B0 = W / S0; // cos(B0)
182
         double Sin3_B0 = Math.Pow(Sin_B0, 3);
183
         double T1 = Z + semiMinor * ses * Sin3_B0; // corrected estimate of vertical component
184
         double Sum = W - semiMajor * es * Cos_B0 * Cos_B0 * Cos_B0; // numerator of cos(phi1)
185
         double S1 = Math.Sqrt(T1 * T1 + Sum * Sum); // corrected estimate of horizontal component
186
         double Sin_p1 = T1 / S1; // sin(phi1), phi1 is estimated latitude
187
         double Cos_p1 = Sum / S1; // cos(phi1)
188
         double Rn = semiMajor / Math.Sqrt(1.0 - es * Sin_p1 * Sin_p1); // Earth radius at location
189
         if(Cos_p1 >= COS_67P5)
190
         {
191
            Height = W / Cos_p1 - Rn;
192
         }
193
         else
194
            if(Cos_p1 <= -COS_67P5)
195
            {
196
               Height = W / -Cos_p1 - Rn;
197
            }
198
            else
199
            {
200
               Height = Z / Sin_p1 + Rn * (es - 1.0);
201
            }
202
 
203
         if(!AtPole)
204
         {
205
            lat = Math.Atan(Sin_p1 / Cos_p1);
206
         }
207
         return new double[] { RadiansToDegrees(lon), RadiansToDegrees(lat), Height, };
208
      }
209
 
210
      double[] DTM00(double[] lonlat)
211
      {
212
         double e0, e1, e2, e3; // eccentricity constants               
213
         double e, es, esp;             // eccentricity constants               
214
         double ml0;                     // small value m                       
215
 
216
         es = 1.0 - Math.Pow(semiMinor / semiMajor, 2);
217
         e = Math.Sqrt(es);
218
         e0 = e0fn(es);
219
         e1 = e1fn(es);
220
         e2 = e2fn(es);
221
         e3 = e3fn(es);
222
         ml0 = semiMajor * mlfn(e0, e1, e2, e3, latOrigin);
223
         esp = es / (1.0 - es);
224
 
225
         // ...         
226
 
227
         double lon = DegreesToRadians(lonlat[0]);
228
         double lat = DegreesToRadians(lonlat[1]);
229
 
230
         double delta_lon = 0.0;  // Delta longitude (Given longitude - center)
231
         double sin_phi, cos_phi; // sin and cos value                          
232
         double al, als;                    // temporary values                         
233
         double c, t, tq;              // temporary values                              
234
         double con, n, ml;         // cone constant, small m                   
235
 
236
         delta_lon = AdjustLongitude(lon - centralMeridian);
237
         SinCos(lat, out sin_phi, out cos_phi);
238
 
239
         al = cos_phi * delta_lon;
240
         als = Math.Pow(al, 2);
241
         c = esp * Math.Pow(cos_phi, 2);
242
         tq = Math.Tan(lat);
243
         t = Math.Pow(tq, 2);
244
         con = 1.0 - es * Math.Pow(sin_phi, 2);
245
         n = semiMajor / Math.Sqrt(con);
246
         ml = semiMajor * mlfn(e0, e1, e2, e3, lat);
247
 
248
         double x = scaleFactor * n * al * (1.0 + als / 6.0 * (1.0 - t + c + als / 20.0 *
249
             (5.0 - 18.0 * t + Math.Pow(t, 2) + 72.0 * c - 58.0 * esp))) + falseEasting;
250
 
251
         double y = scaleFactor * (ml - ml0 + n * tq * (als * (0.5 + als / 24.0 *
252
             (5.0 - t + 9.0 * c + 4.0 * Math.Pow(c, 2) + als / 30.0 * (61.0 - 58.0 * t
253
             + Math.Pow(t, 2) + 600.0 * c - 330.0 * esp))))) + falseNorthing;
254
 
255
         if(lonlat.Length < 3)
256
            return new double[] { x / metersPerUnit, y / metersPerUnit };
257
         else
258
            return new double[] { x / metersPerUnit, y / metersPerUnit, lonlat[2] };
259
      }
260
 
261
      double[] DTM01(double[] lonlat)
262
      {
263
         // Eccentricity squared : (a^2 - b^2)/a^2
264
         double es = 1.0 - (semiMinor * semiMinor) / (semiMajor * semiMajor);
265
 
266
         // Second eccentricity squared : (a^2 - b^2)/b^2
267
         double ses = (Math.Pow(semiMajor, 2) - Math.Pow(semiMinor, 2)) / Math.Pow(semiMinor, 2);
268
 
269
         double ba = semiMinor / semiMajor;
270
         double ab = semiMajor / semiMinor;
271
 
272
         double lon = DegreesToRadians(lonlat[0]);
273
         double lat = DegreesToRadians(lonlat[1]);
274
         double h = lonlat.Length < 3 ? 0 : lonlat[2].Equals(Double.NaN) ? 0 : lonlat[2];
275
         double v = semiMajor / Math.Sqrt(1 - es * Math.Pow(Math.Sin(lat), 2));
276
         double x = (v + h) * Math.Cos(lat) * Math.Cos(lon);
277
         double y = (v + h) * Math.Cos(lat) * Math.Sin(lon);
278
         double z = ((1 - es) * v + h) * Math.Sin(lat);
279
         return new double[] { x, y, z, };
280
      }
281
 
282
      double[] MTD01(double[] pnt)
283
      {
284
         // Eccentricity squared : (a^2 - b^2)/a^2
285
         double es = 1.0 - (semiMinor2 * semiMinor2) / (semiMajor * semiMajor);
286
 
287
         // Second eccentricity squared : (a^2 - b^2)/b^2
288
         double ses = (Math.Pow(semiMajor, 2) - Math.Pow(semiMinor2, 2)) / Math.Pow(semiMinor2, 2);
289
 
290
         double ba = semiMinor2 / semiMajor;
291
         double ab = semiMajor / semiMinor2;
292
 
293
         bool At_Pole = false; // is location in polar region
294
         double Z = pnt.Length < 3 ? 0 : pnt[2].Equals(Double.NaN) ? 0 : pnt[2];
295
 
296
         double lon = 0;
297
         double lat = 0;
298
         double Height = 0;
299
         if(pnt[0] != 0.0)
300
         {
301
            lon = Math.Atan2(pnt[1], pnt[0]);
302
         }
303
         else
304
         {
305
            if(pnt[1] > 0)
306
            {
307
               lon = Math.PI / 2;
308
            }
309
            else
310
               if(pnt[1] < 0)
311
               {
312
                  lon = -Math.PI * 0.5;
313
               }
314
               else
315
               {
316
                  At_Pole = true;
317
                  lon = 0.0;
318
                  if(Z > 0.0) // north pole
319
                  {
320
                     lat = Math.PI * 0.5;
321
                  }
322
                  else
323
                     if(Z < 0.0) // south pole
324
                     {
325
                        lat = -Math.PI * 0.5;
326
                     }
327
                     else // center of earth
328
                     {
329
                        return new double[] { RadiansToDegrees(lon), RadiansToDegrees(Math.PI * 0.5), -semiMinor2, };
330
                     }
331
               }
332
         }
333
 
334
         double W2 = pnt[0] * pnt[0] + pnt[1] * pnt[1]; // Square of distance from Z axis
335
         double W = Math.Sqrt(W2);                      // distance from Z axis
336
         double T0 = Z * AD_C;                // initial estimate of vertical component
337
         double S0 = Math.Sqrt(T0 * T0 + W2); //initial estimate of horizontal component
338
         double Sin_B0 = T0 / S0;             // sin(B0), B0 is estimate of Bowring aux variable
339
         double Cos_B0 = W / S0;              // cos(B0)
340
         double Sin3_B0 = Math.Pow(Sin_B0, 3);
341
         double T1 = Z + semiMinor2 * ses * Sin3_B0; //corrected estimate of vertical component
342
         double Sum = W - semiMajor * es * Cos_B0 * Cos_B0 * Cos_B0; // numerator of cos(phi1)
343
         double S1 = Math.Sqrt(T1 * T1 + Sum * Sum); // corrected estimate of horizontal component
344
         double Sin_p1 = T1 / S1;  // sin(phi1), phi1 is estimated latitude
345
         double Cos_p1 = Sum / S1; // cos(phi1)
346
         double Rn = semiMajor / Math.Sqrt(1.0 - es * Sin_p1 * Sin_p1); // Earth radius at location
347
 
348
         if(Cos_p1 >= COS_67P5)
349
         {
350
            Height = W / Cos_p1 - Rn;
351
         }
352
         else
353
            if(Cos_p1 <= -COS_67P5)
354
            {
355
               Height = W / -Cos_p1 - Rn;
356
            }
357
            else
358
            {
359
               Height = Z / Sin_p1 + Rn * (es - 1.0);
360
            }
361
 
362
         if(!At_Pole)
363
         {
364
            lat = Math.Atan(Sin_p1 / Cos_p1);
365
         }
366
         return new double[] { RadiansToDegrees(lon), RadiansToDegrees(lat), Height, };
367
      }
368
 
369
      double[] MTD11(double[] p)
370
      {
371
         double e0, e1, e2, e3; // eccentricity constants               
372
         double e, es, esp;             // eccentricity constants               
373
         double ml0;                // small value m
374
 
375
         es = 1.0 - Math.Pow(semiMinor / semiMajor, 2);
376
         e = Math.Sqrt(es);
377
         e0 = e0fn(es);
378
         e1 = e1fn(es);
379
         e2 = e2fn(es);
380
         e3 = e3fn(es);
381
         ml0 = semiMajor * mlfn(e0, e1, e2, e3, latOrigin);
382
         esp = es / (1.0 - es);
383
 
384
         // ...
385
 
386
         double con, phi;
387
         double delta_phi;
388
         long i;
389
         double sin_phi, cos_phi, tan_phi;
390
         double c, cs, t, ts, n, r, d, ds;
391
         long max_iter = 6;
392
 
393
         double x = p[0] * metersPerUnit - falseEasting;
394
         double y = p[1] * metersPerUnit - falseNorthing;
395
 
396
         con = (ml0 + y / scaleFactor) / semiMajor;
397
         phi = con;
398
         for(i = 0; ; i++)
399
         {
400
            delta_phi = ((con + e1 * Math.Sin(2.0 * phi) - e2 * Math.Sin(4.0 * phi) + e3 * Math.Sin(6.0 * phi)) / e0) - phi;
401
            phi += delta_phi;
402
 
403
            if(Math.Abs(delta_phi) <= EPSLoN)
404
               break;
405
 
406
            if(i >= max_iter)
407
               throw new ArgumentException("Latitude failed to converge");
408
         }
409
 
410
         if(Math.Abs(phi) < HALF_PI)
411
         {
412
            SinCos(phi, out sin_phi, out cos_phi);
413
            tan_phi = Math.Tan(phi);
414
            c = esp * Math.Pow(cos_phi, 2);
415
            cs = Math.Pow(c, 2);
416
            t = Math.Pow(tan_phi, 2);
417
            ts = Math.Pow(t, 2);
418
            con = 1.0 - es * Math.Pow(sin_phi, 2);
419
            n = semiMajor / Math.Sqrt(con);
420
            r = n * (1.0 - es) / con;
421
            d = x / (n * scaleFactor);
422
            ds = Math.Pow(d, 2);
423
 
424
            double lat = phi - (n * tan_phi * ds / r) * (0.5 - ds / 24.0 * (5.0 + 3.0 * t +
425
                10.0 * c - 4.0 * cs - 9.0 * esp - ds / 30.0 * (61.0 + 90.0 * t +
426
                298.0 * c + 45.0 * ts - 252.0 * esp - 3.0 * cs)));
427
 
428
            double lon = AdjustLongitude(centralMeridian + (d * (1.0 - ds / 6.0 * (1.0 + 2.0 * t +
429
                c - ds / 20.0 * (5.0 - 2.0 * c + 28.0 * t - 3.0 * cs + 8.0 * esp +
430
                24.0 * ts))) / cos_phi));
431
 
432
            if(p.Length < 3)
433
               return new double[] { RadiansToDegrees(lon), RadiansToDegrees(lat) };
434
            else
435
               return new double[] { RadiansToDegrees(lon), RadiansToDegrees(lat), p[2] };
436
         }
437
         else
438
         {
439
            if(p.Length < 3)
440
               return new double[] { RadiansToDegrees(HALF_PI * Sign(y)), RadiansToDegrees(centralMeridian) };
441
            else
442
               return new double[] { RadiansToDegrees(HALF_PI * Sign(y)), RadiansToDegrees(centralMeridian), p[2] };
443
         }
444
      }
445
 
446
      #region -- levels info --
447
            /*
448
         * "layers":[
449
         * {"id":0,"name":"Lietuva","parentLayerId":-1,"defaultVisibility":true,
450
         * "subLayerIds":null,
451
         *
452
         * "minScale":10000000,"maxScale":900}],
453
         * "tables":[],"spatialReference":{"wkid":2600,"latestWkid":3346},
454
         * "singleFusedMapCache":true,"tileInfo":{"rows":256,"cols":256,"dpi":96,"format":"MIXED","compressionQuality":90,
455
         *
456
         * "origin":{"x":-5122000,"y":1.0325013240285E7},
457
         * "spatialReference":{"wkid":2600,"latestWkid":3346},
458
         *
459
         * "lods":[
460
         * {"level":0,"resolution":1587.5031750063501,"scale":6000000},
461
         * {"level":1,"resolution":793.7515875031751,"scale":3000000},
462
         * {"level":2,"resolution":529.1677250021168,"scale":2000000},
463
         * {"level":3,"resolution":264.5838625010584,"scale":1000000},
464
         * {"level":4,"resolution":132.2919312505292,"scale":500000},
465
         * {"level":5,"resolution":52.91677250021167,"scale":200000},
466
         * {"level":6,"resolution":26.458386250105836,"scale":100000},
467
         * {"level":7,"resolution":13.229193125052918,"scale":50000},
468
         * {"level":8,"resolution":6.614596562526459,"scale":25000},
469
         * {"level":9,"resolution":2.6458386250105836,"scale":10000},
470
         * {"level":10,"resolution":1.3229193125052918,"scale":5000},
471
         * {"level":11,"resolution":0.5291677250021167,"scale":2000},
472
         * {"level":12,"resolution":0.26458386250105836,"scale":1000}]},
473
         *
474
         * "initialExtent":
475
         * {"xmin":219818.60040028347,"ymin":5826291.964691277,
476
         * "xmax":747927.9899523959,"ymax":6407318.126743601,
477
         * "spatialReference":{"wkid":2600,"latestWkid":3346}},
478
         *
479
         * * "fullExtent":
480
         * {"xmin":38843.23844955949,"ymin":5663308.305390623,
481
         * "xmax":907736.6429030352,"ymax":6555485.089744193,
482
         *
483
         * "spatialReference":{"wkid":2600,"latestWkid":3346}},
484
         * "minScale":6000000,"maxScale":5000,"units":"esriMeters","supportedImageFormatTypes":"PNG32,PNG24,PNG,JPG,DIB,TIFF,EMF,PS,PDF,GIF,SVG,SVGZ,BMP",
485
         * "documentInfo":{"Title":"Lietuvos reljefinis žemėlapis","Author":"","Comments":"","Subject":"","Category":"","AntialiasingMode":"None","TextAntialiasingMode":"Force","Keywords":""},"capabilities":"Map","supportedQueryFormats":"JSON, AMF","exportTilesAllowed":false,"maxRecordCount":1000,"maxImageHeight":4096,"maxImageWidth":4096,"supportedExtensions":""});*/
486
      #endregion
487
 
488
      public static double GetTileMatrixResolution(int zoom)
489
      {
490
         double ret = 0;
491
 
492
         switch(zoom)
493
         {
494
            #region -- sizes --
495
            case 0:
496
            {
497
               ret = 1587.5031750063501;
498
            }    
499
            break;
500
 
501
            case 1:
502
            {
503
               ret = 793.7515875031751;
504
            }
505
            break;
506
 
507
            case 2:
508
            {
509
               ret = 529.1677250021168;
510
            }
511
            break;
512
 
513
            case 3:
514
            {
515
               ret = 264.5838625010584;
516
            }
517
            break;
518
 
519
            case 4:
520
            {
521
               ret = 132.2919312505292;
522
            }
523
            break;
524
 
525
            case 5:
526
            {
527
               ret = 52.91677250021167;
528
            }
529
            break;
530
 
531
            case 6:
532
            {
533
               ret = 26.458386250105836;
534
            }
535
            break;
536
 
537
            case 7:
538
            {
539
               ret = 13.229193125052918;
540
            }
541
            break;
542
 
543
            case 8:
544
            {
545
               ret = 6.614596562526459;
546
            }
547
            break;
548
 
549
            case 9:
550
            {
551
               ret = 2.6458386250105836;
552
            }
553
            break;
554
 
555
            case 10:
556
            {
557
               ret = 1.3229193125052918;
558
            }
559
            break;
560
 
561
            case 11:
562
            {
563
               ret = 0.5291677250021167;
564
            }
565
            break;
566
 
567
            case 12:
568
            {
569
               ret = 0.26458386250105836;
570
            }
571
            break;
572
            #endregion
573
         }
574
 
575
         return ret;
576
      }
577
 
578
      public override double GetGroundResolution(int zoom, double latitude)
579
      {
580
         return GetTileMatrixResolution(zoom);
581
      }
582
 
583
      Dictionary<int, GSize> extentMatrixMin;
584
      Dictionary<int, GSize> extentMatrixMax;                                  
585
 
586
      public override GSize GetTileMatrixMinXY(int zoom)
587
      {
588
         if(extentMatrixMin == null)
589
         {
590
            GenerateExtents();
591
         }  
592
         return extentMatrixMin[zoom];
593
      }
594
 
595
      public override GSize GetTileMatrixMaxXY(int zoom)
596
      {
597
         if(extentMatrixMax == null)
598
         {
599
            GenerateExtents();
600
         }
601
         return extentMatrixMax[zoom];
602
      }
603
 
604
      void GenerateExtents()
605
      {
606
         extentMatrixMin = new Dictionary<int, GSize>();
607
         extentMatrixMax = new Dictionary<int, GSize>();
608
         //RectLatLng Extent = RectLatLng.FromLTRB(219818.60040028347, 6407318.126743601, 747927.9899523959, 5826291.964691277);
609
 
610
         for(int i = 0; i <= 12; i++)
611
         {
612
            double res = GetTileMatrixResolution(i);
613
            //extentMatrixMin.Add(i, new GSize(FromPixelToTileXY(LksToPixel(new double[]{ Extent.Left, Extent.Top }, res))));
614
            //extentMatrixMax.Add(i, new GSize(FromPixelToTileXY(LksToPixel(new double[] { Extent.Right, Extent.Bottom }, res))));
615
 
616
            extentMatrixMin.Add(i, new GSize(FromPixelToTileXY(FromLatLngToPixel(Bounds.LocationTopLeft, i))));
617
            extentMatrixMax.Add(i, new GSize(FromPixelToTileXY(FromLatLngToPixel(Bounds.LocationRightBottom, i))));
618
         }
619
      }
620
   }
621
}