lambert_ruby 1.0.1 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: f6d21e2b9e2e9f9adc7d68c49b8b7815d5e79d46
4
- data.tar.gz: ead3cb60d5d7fe04da12c7365e00af6340a27bba
3
+ metadata.gz: 900b0dd2218561188f32fd7f9395b3aa3c410af8
4
+ data.tar.gz: 0d7cd916c3805017fe7487daf9ce18a2c3e3cc25
5
5
  SHA512:
6
- metadata.gz: a885864daeb46f4bc2dbb4e28cef5619f64694724e59f81fcf489c251de4bb67a450bc057f87ad8ce3d31c919075a592b392a392e401db3c0aaa5282b3ce3d50
7
- data.tar.gz: 93b944cb36c7078d73438e8edb4578680cde8b159c8fe475834e9ab950a7ede8d993462d92581e1f5e6ed11b627fede29e4e24b0b462cbe8d6e28369512855dd
6
+ metadata.gz: b8c387e9da5afad324b67d74769afa5a1fbfada0da0d275d9b9ae950db9152098c5f2207061407fbb3d4db5f9ba305676a0b91aab62f39fc1e6bd382a43bf335
7
+ data.tar.gz: 9e0250d316f5fece7acdcb243fb96b7d3cb0684ca29266cdbeff5ce33898b52db81c3467e014822b41b32ec7ac864c895ff3d7ed1e2254ad2b9d894f8c84dce8
@@ -7,36 +7,167 @@
7
7
  #include <math.h>
8
8
  #include <stdio.h>
9
9
 
10
- #define RAD_TO_DEG(x) x*180/M_PI
11
-
12
- #define DISPLAY_YGLambertPoint(YGLambertPoint) printf(#YGLambertPoint" X:%f | Y:%f | Z:%f\n",YGLambertPoint.x,YGLambertPoint.y,YGLambertPoint.z);
13
- #define DISPLAY_YGLambertPoint_REF(YGLambertPoint) printf(#YGLambertPoint" X:%f | Y:%f | Z:%f\n",YGLambertPoint->x,YGLambertPoint->y,YGLambertPoint->z);
14
10
 
15
11
  static double lambert_n[6] = {0.7604059656, 0.7289686274, 0.6959127966, 0.6712679322, 0.7289686274, 0.7256077650};
16
12
  static double lambert_c[6] = {11603796.98, 11745793.39, 11947992.52, 12136281.99, 11745793.39, 11754255.426};
17
13
  static double lambert_xs[6]= {600000.0, 600000.0, 600000.0, 234.358, 600000.0, 700000.0};
18
14
  static double lambert_ys[6]= {5657616.674, 6199695.768, 6791905.085, 7239161.542, 8199695.768, 12655612.050};
19
15
 
20
- YGPoint pointToDegree(YGPoint p)
16
+ YGPoint __YGDegreeToRadian(YGPoint pt)
17
+ {
18
+ pt.x = pt.x * M_PI / 180.0;
19
+ pt.y = pt.y * M_PI / 180.0;
20
+ pt.z = pt.z * M_PI / 180.0;
21
+
22
+ pt.unit = RADIAN;
23
+
24
+ return pt;
25
+ }
26
+
27
+ YGPoint __YGRadianToDegree(YGPoint pt)
28
+ {
29
+ pt.x = pt.x * 180/ M_PI;
30
+ pt.y = pt.y * 180/ M_PI;
31
+ pt.z = pt.z * 180/ M_PI;
32
+
33
+ pt.unit = DEGREE;
34
+
35
+ return pt;
36
+ }
37
+
38
+ YGPoint __YGGradToRadian(YGPoint pt)
39
+ {
40
+ pt.x = pt.x * M_PI/200.0;
41
+ pt.y = pt.y * M_PI/200.0;
42
+ pt.z = pt.z * M_PI/200.0;
43
+
44
+ pt.unit = RADIAN;
45
+
46
+ return pt;
47
+ }
48
+ YGPoint __YGRadianToGrad(YGPoint pt)
49
+ {
50
+ pt.x = pt.x * 200.0/M_PI;
51
+ pt.y = pt.y * 200.0/M_PI;
52
+ pt.z = pt.z * 200.0/M_PI;
53
+
54
+ pt.unit = GRAD;
55
+
56
+ return pt;
57
+ }
58
+
59
+ YGPoint __YGGradToDegree(YGPoint pt)
60
+ {
61
+ pt.x = pt.x * 180.0/200.0;
62
+ pt.y = pt.y * 180.0/200.0;
63
+ pt.z = pt.z * 180.0/200.0;
64
+
65
+ pt.unit = DEGREE;
66
+
67
+ return pt;
68
+
69
+ }
70
+
71
+ YGPoint __YGDegreeToGrad(YGPoint pt)
72
+ {
73
+ pt.x = pt.x * 200.0/180.0;
74
+ pt.y = pt.y * 200.0/180.0;
75
+ pt.z = pt.z * 200.0/180.0;
76
+
77
+ pt.unit = GRAD;
78
+
79
+ return pt;
80
+ }
81
+
82
+
83
+ YGPoint YGPointToDegree(YGPoint pt)
21
84
  {
22
-
23
- p.x = p.x * 180/M_PI;
24
- p.y = p.y * 180/M_PI;
25
- p.z = p.z * 180/M_PI;
26
85
 
27
- return p;
86
+ switch (pt.unit)
87
+ {
88
+ case RADIAN :
89
+ {
90
+ pt = __YGRadianToDegree(pt);
91
+ }
92
+ break;
93
+ case GRAD :
94
+ {
95
+ pt = __YGGradToDegree(pt);
96
+ }
97
+ break;
98
+ default:
99
+ break;
100
+ }
101
+
102
+ return pt;
103
+
28
104
  }
29
105
 
30
- YGPoint pointToRadian(YGPoint p)
106
+
107
+ YGPoint YGPointToRadian(YGPoint pt)
31
108
  {
32
- p.x = p.x * M_PI/180;
33
- p.y = p.y * M_PI/180;
34
- p.z = p.z * M_PI/180;
109
+ switch (pt.unit)
110
+ {
111
+ case DEGREE :
112
+ {
113
+ pt = __YGDegreeToRadian(pt);
114
+ }
115
+ break;
116
+ case GRAD :
117
+ {
118
+ pt = __YGGradToRadian(pt);
119
+ }
120
+ break;
121
+ default:
122
+ break;
123
+ }
35
124
 
36
- return p;
125
+ return pt;
37
126
  }
38
127
 
39
- double latitude_iso_from_lat(double lat, double e)
128
+ YGPoint YGPointToGrad(YGPoint pt)
129
+ {
130
+ switch (pt.unit)
131
+ {
132
+ case RADIAN :
133
+ {
134
+ pt = __YGRadianToGrad(pt);
135
+ }
136
+ break;
137
+ case DEGREE :
138
+ {
139
+ pt = __YGDegreeToGrad(pt);
140
+ }
141
+ break;
142
+ default:
143
+ break;
144
+ }
145
+
146
+ return pt;
147
+ }
148
+
149
+ YGPoint YGPointToUnit(YGPoint point, CoordUnit unit)
150
+ {
151
+ switch (unit) {
152
+ case DEGREE:
153
+ return YGPointToDegree(point);
154
+ break;
155
+ case GRAD:
156
+ return YGPointToGrad(point);
157
+ case RADIAN :
158
+ return YGPointToDegree(point);
159
+ break;
160
+ default:
161
+ return point;
162
+ break;
163
+ }
164
+ }
165
+
166
+ /*****************
167
+ ** IGN algorithms
168
+ *****************/
169
+
170
+ double __YGLatitudeISOFromLatitude(double lat, double e)
40
171
  {
41
172
  return log(tan(M_PI_4+lat/2)*pow((1-e*sin(lat))/(1+e*sin(lat)),e/2));
42
173
  }
@@ -45,7 +176,7 @@ double latitude_iso_from_lat(double lat, double e)
45
176
  * ALGO0002
46
177
  */
47
178
 
48
- double lat_from_lat_iso(double lat_iso, double e,double eps)
179
+ double __YGLatitudeFromLatitudeISO(double lat_iso, double e,double eps)
49
180
  {
50
181
 
51
182
  double phi_0 = 2*atan(exp(lat_iso)) - M_PI_2;
@@ -64,15 +195,15 @@ double lat_from_lat_iso(double lat_iso, double e,double eps)
64
195
  * ALGO0004 - Lambert vers geographiques
65
196
  */
66
197
 
67
- void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone, double lon_merid, double e, double eps)
198
+ YGPoint __YGLambertToGeographic(YGPoint org, YGLambertZone zone, double lon_merid, double e, double eps)
68
199
  {
69
200
  double n = lambert_n[zone];
70
201
  double C = lambert_c[zone];
71
202
  double x_s = lambert_xs[zone];
72
203
  double y_s = lambert_ys[zone];
73
204
 
74
- double x = org->x;
75
- double y = org->y;
205
+ double x = org.x;
206
+ double y = org.y;
76
207
 
77
208
  double lon, gamma, R, lat_iso;
78
209
 
@@ -84,10 +215,12 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
84
215
 
85
216
  lat_iso = -1/n*log(fabs(R/C));
86
217
 
87
- double lat = lat_from_lat_iso(lat_iso,e,eps);
218
+ double lat = __YGLatitudeFromLatitudeISO(lat_iso,e,eps);
88
219
 
89
- dest->x = lon;
90
- dest->y = lat;
220
+ org.x = lon;
221
+ org.y = lat;
222
+
223
+ return org;
91
224
  }
92
225
 
93
226
 
@@ -96,7 +229,7 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
96
229
  *
97
230
  */
98
231
 
99
- double lambert_normal(double lat, double a, double e)
232
+ double __YGLambertNormal(double lat, double a, double e)
100
233
  {
101
234
 
102
235
  return a/sqrt(1-e*e*sin(lat)*sin(lat));
@@ -108,9 +241,9 @@ double lambert_normal(double lat, double a, double e)
108
241
  *
109
242
  */
110
243
 
111
- YGPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e)
244
+ YGPoint __YGGeographicToCartesian(double lon, double lat, double he, double a, double e)
112
245
  {
113
- double N = lambert_normal(lat,a,e);
246
+ double N = __YGLambertNormal(lat,a,e);
114
247
 
115
248
  YGPoint pt = {0,0,0};
116
249
  pt.x = (N+he)*cos(lat)*cos(lon);
@@ -127,7 +260,7 @@ double lambert_normal(double lat, double a, double e)
127
260
  * ALGO0012 - Passage des coordonnées cartésiennes aux coordonnées géographiques
128
261
  */
129
262
 
130
- YGPoint cartesian_to_geographic(YGPoint org, double meridien, double a, double e , double eps)
263
+ YGPoint __YGCartesianToGeographic(YGPoint org, double meridien, double a, double e , double eps)
131
264
  {
132
265
  double x = org.x, y = org.y, z = org.z;
133
266
 
@@ -150,7 +283,8 @@ double lambert_normal(double lat, double a, double e)
150
283
  YGPoint pt;
151
284
  pt.x = lon;
152
285
  pt.y = phi_i;
153
- pt.z = he;
286
+ pt.z = he;
287
+ pt.unit = RADIAN;
154
288
 
155
289
  return pt;
156
290
  }
@@ -161,50 +295,48 @@ double lambert_normal(double lat, double a, double e)
161
295
  *
162
296
  */
163
297
 
164
- void lambert_to_wgs84(const YGPoint * org, YGPoint *dest,YGLambertZone zone){
298
+ YGPoint YGPointConvertWGS84(YGPoint point, YGLambertZone zone){
165
299
 
300
+ if(point.unit != METER)
301
+ {
302
+ perror("Could not operate on a non METER based point!\n The points returned will be the same!\n");
303
+ return point;
304
+ }
166
305
 
167
-
168
306
  if(LAMBERT_93 == zone)
169
307
  {
170
- lambert_to_geographic(org,dest,zone,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
308
+ point = __YGLambertToGeographic(point,zone,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
309
+
171
310
  }
172
311
  else
173
312
  {
174
- lambert_to_geographic(org,dest,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
175
- YGPoint temp = geographic_to_cartesian(dest->x,dest->y,dest->z,A_CLARK_IGN,E_CLARK_IGN);
313
+ point = __YGLambertToGeographic(point,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
314
+ point = __YGGeographicToCartesian(point.x,point.y,point.z,A_CLARK_IGN,E_CLARK_IGN);
176
315
 
177
- temp.x= temp.x - 168;
178
- temp.y= temp.y - 60;
179
- temp.z= temp.z + 320;
316
+ point.x-= 168;
317
+ point.y-= 60;
318
+ point.z+= 320;
180
319
 
181
320
  //WGS84 refers to greenwich
182
- temp = cartesian_to_geographic(temp, LON_MERID_IERS, A_WGS84,E_WGS84,DEFAULT_EPS);
183
-
184
- dest->x = temp.x;
185
- dest->y = temp.y;
321
+ point = __YGCartesianToGeographic(point, LON_MERID_GREENWICH, A_WGS84,E_WGS84,DEFAULT_EPS);
186
322
  }
323
+
324
+ point.unit = RADIAN;
325
+ return point;
187
326
  }
188
327
 
189
328
 
190
- void lambert_to_wgs84_deg(const YGPoint * org, YGPoint *dest, YGLambertZone zone)
191
- {
192
- YGPoint temp = {0,0,0};
193
-
194
- lambert_to_wgs84(org,&temp,zone);
195
- *dest = pointToDegree(temp);
196
- }
197
329
 
198
- double lat_iso(double lat, double e)
330
+ double __YGLatitudeISO(double lat, double e)
199
331
  {
200
332
  return log(tan(M_PI_4 + lat/2)*pow((1-e*sin(lat))/(1+e*sin(lat)),e/2));
201
333
  }
202
334
 
203
- YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat)
335
+ YGPoint __YGCoordinatesTransform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat)
204
336
  {
205
337
  YGPoint dest = {0,0,0};
206
338
 
207
- double latiso = lat_iso(lat,e);
339
+ double latiso = __YGLatitudeISO(lat,e);
208
340
  dest.x = x_s + e*exp(-n*latiso)*sin(n*(lon-lambda_c));
209
341
  dest.y = y_s + e*exp(n*latiso)*cos(n*(lon-lambda_c));
210
342
 
@@ -212,7 +344,7 @@ YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_
212
344
 
213
345
  }
214
346
 
215
- YGPoint switch_geodesic_system(YGPoint u, Vector t, double d, Vector r)
347
+ YGPoint __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r)
216
348
  {
217
349
  YGPoint v = {0,0,0};
218
350
 
@@ -18,8 +18,6 @@
18
18
  #define ct_x0 700000.0
19
19
  #define ct_y0 6600000.0
20
20
 
21
- #define DISPLAY_YGPoint(YGPoint) printf(#YGPoint" X:%f | Y:%f | Z:%f\n",YGPoint.x,YGPoint.y,YGPoint.z);
22
- #define DISPLAY_YGPoint_REF(YGPoint) printf(#YGPoint" X:%f | Y:%f | Z:%f\n",YGPoint->x,YGPoint->y,YGPoint->z);
23
21
 
24
22
  typedef enum {
25
23
  LAMBERT_I=0,
@@ -33,7 +31,8 @@ typedef enum {
33
31
  typedef enum {
34
32
  DEGREE,
35
33
  GRAD,
36
- RADIAN
34
+ RADIAN,
35
+ METER
37
36
  } CoordUnit;
38
37
 
39
38
  typedef struct {
@@ -52,43 +51,49 @@ typedef struct
52
51
 
53
52
  typedef YGPoint Vector;
54
53
 
55
- YGPoint pointToRadian(YGPoint p);
56
- YGPoint pointToDegree(YGPoint p);
54
+ #define __YGPointWithUnit(_x,_y,_z,_unit) {.x=_x, .y=_y,.z=_z,.unit=_unit};
55
+
56
+ #define YGDegreePoint(x,y,z) __YGPointWithUnit(x,y,z,DEGREE)
57
+ #define YGRadianPoint(x,y,z) __YGPointWithUnit(x,y,z,RADIAN)
58
+ #define YGGradPoint(x,y,z) __YGPointWithUnit(x,y,z,GRAD)
59
+ #define YGMeterPoint(x,y,z) __YGPointWithUnit(x,y,z,METER)
60
+
61
+
62
+ YGPoint YGPointToRadian(YGPoint p);
63
+ YGPoint YGPointToDegree(YGPoint p);
64
+ YGPoint YGPointToGrad(YGPoint p);
65
+ YGPoint YGPointToUnit(YGPoint point, CoordUnit unit);
57
66
 
58
67
  /*
59
68
  * ALGO0021 - Calcul de la grande Normale
60
69
  *
61
70
  */
62
- double lambert_normal(double lat, double a, double e);
71
+ double __YGLambertNormal(double lat, double a, double e);
63
72
 
64
73
  /*
65
74
  * Convert a YGPoint struct from one lambert zone to WGS84 (Rad)
66
75
  *
67
76
  */
68
- void lambert_to_wgs84(const YGPoint * org, YGPoint *dest, YGLambertZone zone);
69
77
 
70
- /*
71
- * Convert a YGPoint struct from one lambert zone to WGS84 (Deg)
72
- *
73
- */
74
- void lambert_to_wgs84_deg(const YGPoint * org, YGPoint *dest, YGLambertZone zone);
78
+
79
+ YGPoint YGPointConvertWGS84(YGPoint point, YGLambertZone zone);
75
80
 
76
81
  /*
77
82
  * ALGO0002
78
83
  */
79
84
 
80
- double lat_from_lat_iso(double lat_iso, double e, double eps);
85
+ double __YGLatitudeFromLatitudeISO(double lat_iso, double e, double eps);
81
86
 
82
87
  /*
83
88
  * ALGO0012
84
89
  */
85
90
 
86
- YGPoint cartesian_to_geographic(YGPoint org, double meridien, double a, double e , double eps);
91
+ YGPoint __YGCartesianToGeographic(YGPoint org, double meridien, double a, double e , double eps);
87
92
 
88
93
  /*
89
94
  * ALGO004
90
95
  */
91
- void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone, double lon_merid, double e, double eps);
96
+ YGPoint __YGLambertToGeographic(YGPoint org, YGLambertZone zone, double lon_merid, double e, double eps);
92
97
 
93
98
  /**
94
99
  * ALGO0009 - Transformations geographiques -> cartésiennes
@@ -96,26 +101,26 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
96
101
  *
97
102
  */
98
103
 
99
- YGPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e);
104
+ YGPoint __YGGeographicToCartesian(double lon, double lat, double he, double a, double e);
100
105
 
101
106
  /**
102
107
  * ALGO13 Transformation de Coordonnées à 7 paramètres entre deux systèmes géodésiques
103
108
  */
104
109
 
105
- YGPoint switch_geodesic_system(YGPoint u, Vector t, double d, Vector r);
110
+ YGPoint __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r);
106
111
 
107
112
  /**
108
113
  * Algo0001 Calcul de la latitude isomérique
109
114
  */
110
- double lat_iso(double lat, double e);
115
+ double __YGLatitudeISO(double lat, double e);
111
116
 
112
117
  /**
113
118
  * Algo003
114
119
  */
115
- YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat);
120
+ YGPoint __YGCoordinatesTransform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat);
116
121
 
117
122
  /**
118
123
  * Algo 01
119
124
  */
120
- double latitude_iso_from_lat(double lat, double e);
125
+ double __YGLatitudeISOFromLatitude(double lat, double e);
121
126
  #endif
@@ -7,36 +7,167 @@
7
7
  #include <math.h>
8
8
  #include <stdio.h>
9
9
 
10
- #define RAD_TO_DEG(x) x*180/M_PI
11
-
12
- #define DISPLAY_YGLambertPoint(YGLambertPoint) printf(#YGLambertPoint" X:%f | Y:%f | Z:%f\n",YGLambertPoint.x,YGLambertPoint.y,YGLambertPoint.z);
13
- #define DISPLAY_YGLambertPoint_REF(YGLambertPoint) printf(#YGLambertPoint" X:%f | Y:%f | Z:%f\n",YGLambertPoint->x,YGLambertPoint->y,YGLambertPoint->z);
14
10
 
15
11
  static double lambert_n[6] = {0.7604059656, 0.7289686274, 0.6959127966, 0.6712679322, 0.7289686274, 0.7256077650};
16
12
  static double lambert_c[6] = {11603796.98, 11745793.39, 11947992.52, 12136281.99, 11745793.39, 11754255.426};
17
13
  static double lambert_xs[6]= {600000.0, 600000.0, 600000.0, 234.358, 600000.0, 700000.0};
18
14
  static double lambert_ys[6]= {5657616.674, 6199695.768, 6791905.085, 7239161.542, 8199695.768, 12655612.050};
19
15
 
20
- YGPoint pointToDegree(YGPoint p)
16
+ YGPoint __YGDegreeToRadian(YGPoint pt)
17
+ {
18
+ pt.x = pt.x * M_PI / 180.0;
19
+ pt.y = pt.y * M_PI / 180.0;
20
+ pt.z = pt.z * M_PI / 180.0;
21
+
22
+ pt.unit = RADIAN;
23
+
24
+ return pt;
25
+ }
26
+
27
+ YGPoint __YGRadianToDegree(YGPoint pt)
28
+ {
29
+ pt.x = pt.x * 180/ M_PI;
30
+ pt.y = pt.y * 180/ M_PI;
31
+ pt.z = pt.z * 180/ M_PI;
32
+
33
+ pt.unit = DEGREE;
34
+
35
+ return pt;
36
+ }
37
+
38
+ YGPoint __YGGradToRadian(YGPoint pt)
39
+ {
40
+ pt.x = pt.x * M_PI/200.0;
41
+ pt.y = pt.y * M_PI/200.0;
42
+ pt.z = pt.z * M_PI/200.0;
43
+
44
+ pt.unit = RADIAN;
45
+
46
+ return pt;
47
+ }
48
+ YGPoint __YGRadianToGrad(YGPoint pt)
49
+ {
50
+ pt.x = pt.x * 200.0/M_PI;
51
+ pt.y = pt.y * 200.0/M_PI;
52
+ pt.z = pt.z * 200.0/M_PI;
53
+
54
+ pt.unit = GRAD;
55
+
56
+ return pt;
57
+ }
58
+
59
+ YGPoint __YGGradToDegree(YGPoint pt)
60
+ {
61
+ pt.x = pt.x * 180.0/200.0;
62
+ pt.y = pt.y * 180.0/200.0;
63
+ pt.z = pt.z * 180.0/200.0;
64
+
65
+ pt.unit = DEGREE;
66
+
67
+ return pt;
68
+
69
+ }
70
+
71
+ YGPoint __YGDegreeToGrad(YGPoint pt)
72
+ {
73
+ pt.x = pt.x * 200.0/180.0;
74
+ pt.y = pt.y * 200.0/180.0;
75
+ pt.z = pt.z * 200.0/180.0;
76
+
77
+ pt.unit = GRAD;
78
+
79
+ return pt;
80
+ }
81
+
82
+
83
+ YGPoint YGPointToDegree(YGPoint pt)
21
84
  {
22
-
23
- p.x = p.x * 180/M_PI;
24
- p.y = p.y * 180/M_PI;
25
- p.z = p.z * 180/M_PI;
26
85
 
27
- return p;
86
+ switch (pt.unit)
87
+ {
88
+ case RADIAN :
89
+ {
90
+ pt = __YGRadianToDegree(pt);
91
+ }
92
+ break;
93
+ case GRAD :
94
+ {
95
+ pt = __YGGradToDegree(pt);
96
+ }
97
+ break;
98
+ default:
99
+ break;
100
+ }
101
+
102
+ return pt;
103
+
28
104
  }
29
105
 
30
- YGPoint pointToRadian(YGPoint p)
106
+
107
+ YGPoint YGPointToRadian(YGPoint pt)
31
108
  {
32
- p.x = p.x * M_PI/180;
33
- p.y = p.y * M_PI/180;
34
- p.z = p.z * M_PI/180;
109
+ switch (pt.unit)
110
+ {
111
+ case DEGREE :
112
+ {
113
+ pt = __YGDegreeToRadian(pt);
114
+ }
115
+ break;
116
+ case GRAD :
117
+ {
118
+ pt = __YGGradToRadian(pt);
119
+ }
120
+ break;
121
+ default:
122
+ break;
123
+ }
35
124
 
36
- return p;
125
+ return pt;
37
126
  }
38
127
 
39
- double latitude_iso_from_lat(double lat, double e)
128
+ YGPoint YGPointToGrad(YGPoint pt)
129
+ {
130
+ switch (pt.unit)
131
+ {
132
+ case RADIAN :
133
+ {
134
+ pt = __YGRadianToGrad(pt);
135
+ }
136
+ break;
137
+ case DEGREE :
138
+ {
139
+ pt = __YGDegreeToGrad(pt);
140
+ }
141
+ break;
142
+ default:
143
+ break;
144
+ }
145
+
146
+ return pt;
147
+ }
148
+
149
+ YGPoint YGPointToUnit(YGPoint point, CoordUnit unit)
150
+ {
151
+ switch (unit) {
152
+ case DEGREE:
153
+ return YGPointToDegree(point);
154
+ break;
155
+ case GRAD:
156
+ return YGPointToGrad(point);
157
+ case RADIAN :
158
+ return YGPointToDegree(point);
159
+ break;
160
+ default:
161
+ return point;
162
+ break;
163
+ }
164
+ }
165
+
166
+ /*****************
167
+ ** IGN algorithms
168
+ *****************/
169
+
170
+ double __YGLatitudeISOFromLatitude(double lat, double e)
40
171
  {
41
172
  return log(tan(M_PI_4+lat/2)*pow((1-e*sin(lat))/(1+e*sin(lat)),e/2));
42
173
  }
@@ -45,7 +176,7 @@ double latitude_iso_from_lat(double lat, double e)
45
176
  * ALGO0002
46
177
  */
47
178
 
48
- double lat_from_lat_iso(double lat_iso, double e,double eps)
179
+ double __YGLatitudeFromLatitudeISO(double lat_iso, double e,double eps)
49
180
  {
50
181
 
51
182
  double phi_0 = 2*atan(exp(lat_iso)) - M_PI_2;
@@ -64,15 +195,15 @@ double lat_from_lat_iso(double lat_iso, double e,double eps)
64
195
  * ALGO0004 - Lambert vers geographiques
65
196
  */
66
197
 
67
- void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone, double lon_merid, double e, double eps)
198
+ YGPoint __YGLambertToGeographic(YGPoint org, YGLambertZone zone, double lon_merid, double e, double eps)
68
199
  {
69
200
  double n = lambert_n[zone];
70
201
  double C = lambert_c[zone];
71
202
  double x_s = lambert_xs[zone];
72
203
  double y_s = lambert_ys[zone];
73
204
 
74
- double x = org->x;
75
- double y = org->y;
205
+ double x = org.x;
206
+ double y = org.y;
76
207
 
77
208
  double lon, gamma, R, lat_iso;
78
209
 
@@ -84,10 +215,12 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
84
215
 
85
216
  lat_iso = -1/n*log(fabs(R/C));
86
217
 
87
- double lat = lat_from_lat_iso(lat_iso,e,eps);
218
+ double lat = __YGLatitudeFromLatitudeISO(lat_iso,e,eps);
88
219
 
89
- dest->x = lon;
90
- dest->y = lat;
220
+ org.x = lon;
221
+ org.y = lat;
222
+
223
+ return org;
91
224
  }
92
225
 
93
226
 
@@ -96,7 +229,7 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
96
229
  *
97
230
  */
98
231
 
99
- double lambert_normal(double lat, double a, double e)
232
+ double __YGLambertNormal(double lat, double a, double e)
100
233
  {
101
234
 
102
235
  return a/sqrt(1-e*e*sin(lat)*sin(lat));
@@ -108,9 +241,9 @@ double lambert_normal(double lat, double a, double e)
108
241
  *
109
242
  */
110
243
 
111
- YGPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e)
244
+ YGPoint __YGGeographicToCartesian(double lon, double lat, double he, double a, double e)
112
245
  {
113
- double N = lambert_normal(lat,a,e);
246
+ double N = __YGLambertNormal(lat,a,e);
114
247
 
115
248
  YGPoint pt = {0,0,0};
116
249
  pt.x = (N+he)*cos(lat)*cos(lon);
@@ -127,7 +260,7 @@ double lambert_normal(double lat, double a, double e)
127
260
  * ALGO0012 - Passage des coordonnées cartésiennes aux coordonnées géographiques
128
261
  */
129
262
 
130
- YGPoint cartesian_to_geographic(YGPoint org, double meridien, double a, double e , double eps)
263
+ YGPoint __YGCartesianToGeographic(YGPoint org, double meridien, double a, double e , double eps)
131
264
  {
132
265
  double x = org.x, y = org.y, z = org.z;
133
266
 
@@ -150,7 +283,8 @@ double lambert_normal(double lat, double a, double e)
150
283
  YGPoint pt;
151
284
  pt.x = lon;
152
285
  pt.y = phi_i;
153
- pt.z = he;
286
+ pt.z = he;
287
+ pt.unit = RADIAN;
154
288
 
155
289
  return pt;
156
290
  }
@@ -161,50 +295,48 @@ double lambert_normal(double lat, double a, double e)
161
295
  *
162
296
  */
163
297
 
164
- void lambert_to_wgs84(const YGPoint * org, YGPoint *dest,YGLambertZone zone){
298
+ YGPoint YGPointConvertWGS84(YGPoint point, YGLambertZone zone){
165
299
 
300
+ if(point.unit != METER)
301
+ {
302
+ perror("Could not operate on a non METER based point!\n The points returned will be the same!\n");
303
+ return point;
304
+ }
166
305
 
167
-
168
306
  if(LAMBERT_93 == zone)
169
307
  {
170
- lambert_to_geographic(org,dest,zone,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
308
+ point = __YGLambertToGeographic(point,zone,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
309
+
171
310
  }
172
311
  else
173
312
  {
174
- lambert_to_geographic(org,dest,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
175
- YGPoint temp = geographic_to_cartesian(dest->x,dest->y,dest->z,A_CLARK_IGN,E_CLARK_IGN);
313
+ point = __YGLambertToGeographic(point,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
314
+ point = __YGGeographicToCartesian(point.x,point.y,point.z,A_CLARK_IGN,E_CLARK_IGN);
176
315
 
177
- temp.x= temp.x - 168;
178
- temp.y= temp.y - 60;
179
- temp.z= temp.z + 320;
316
+ point.x-= 168;
317
+ point.y-= 60;
318
+ point.z+= 320;
180
319
 
181
320
  //WGS84 refers to greenwich
182
- temp = cartesian_to_geographic(temp, LON_MERID_IERS, A_WGS84,E_WGS84,DEFAULT_EPS);
183
-
184
- dest->x = temp.x;
185
- dest->y = temp.y;
321
+ point = __YGCartesianToGeographic(point, LON_MERID_GREENWICH, A_WGS84,E_WGS84,DEFAULT_EPS);
186
322
  }
323
+
324
+ point.unit = RADIAN;
325
+ return point;
187
326
  }
188
327
 
189
328
 
190
- void lambert_to_wgs84_deg(const YGPoint * org, YGPoint *dest, YGLambertZone zone)
191
- {
192
- YGPoint temp = {0,0,0};
193
-
194
- lambert_to_wgs84(org,&temp,zone);
195
- *dest = pointToDegree(temp);
196
- }
197
329
 
198
- double lat_iso(double lat, double e)
330
+ double __YGLatitudeISO(double lat, double e)
199
331
  {
200
332
  return log(tan(M_PI_4 + lat/2)*pow((1-e*sin(lat))/(1+e*sin(lat)),e/2));
201
333
  }
202
334
 
203
- YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat)
335
+ YGPoint __YGCoordinatesTransform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat)
204
336
  {
205
337
  YGPoint dest = {0,0,0};
206
338
 
207
- double latiso = lat_iso(lat,e);
339
+ double latiso = __YGLatitudeISO(lat,e);
208
340
  dest.x = x_s + e*exp(-n*latiso)*sin(n*(lon-lambda_c));
209
341
  dest.y = y_s + e*exp(n*latiso)*cos(n*(lon-lambda_c));
210
342
 
@@ -212,7 +344,7 @@ YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_
212
344
 
213
345
  }
214
346
 
215
- YGPoint switch_geodesic_system(YGPoint u, Vector t, double d, Vector r)
347
+ YGPoint __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r)
216
348
  {
217
349
  YGPoint v = {0,0,0};
218
350
 
@@ -18,8 +18,6 @@
18
18
  #define ct_x0 700000.0
19
19
  #define ct_y0 6600000.0
20
20
 
21
- #define DISPLAY_YGPoint(YGPoint) printf(#YGPoint" X:%f | Y:%f | Z:%f\n",YGPoint.x,YGPoint.y,YGPoint.z);
22
- #define DISPLAY_YGPoint_REF(YGPoint) printf(#YGPoint" X:%f | Y:%f | Z:%f\n",YGPoint->x,YGPoint->y,YGPoint->z);
23
21
 
24
22
  typedef enum {
25
23
  LAMBERT_I=0,
@@ -33,7 +31,8 @@ typedef enum {
33
31
  typedef enum {
34
32
  DEGREE,
35
33
  GRAD,
36
- RADIAN
34
+ RADIAN,
35
+ METER
37
36
  } CoordUnit;
38
37
 
39
38
  typedef struct {
@@ -52,43 +51,49 @@ typedef struct
52
51
 
53
52
  typedef YGPoint Vector;
54
53
 
55
- YGPoint pointToRadian(YGPoint p);
56
- YGPoint pointToDegree(YGPoint p);
54
+ #define __YGPointWithUnit(_x,_y,_z,_unit) {.x=_x, .y=_y,.z=_z,.unit=_unit};
55
+
56
+ #define YGDegreePoint(x,y,z) __YGPointWithUnit(x,y,z,DEGREE)
57
+ #define YGRadianPoint(x,y,z) __YGPointWithUnit(x,y,z,RADIAN)
58
+ #define YGGradPoint(x,y,z) __YGPointWithUnit(x,y,z,GRAD)
59
+ #define YGMeterPoint(x,y,z) __YGPointWithUnit(x,y,z,METER)
60
+
61
+
62
+ YGPoint YGPointToRadian(YGPoint p);
63
+ YGPoint YGPointToDegree(YGPoint p);
64
+ YGPoint YGPointToGrad(YGPoint p);
65
+ YGPoint YGPointToUnit(YGPoint point, CoordUnit unit);
57
66
 
58
67
  /*
59
68
  * ALGO0021 - Calcul de la grande Normale
60
69
  *
61
70
  */
62
- double lambert_normal(double lat, double a, double e);
71
+ double __YGLambertNormal(double lat, double a, double e);
63
72
 
64
73
  /*
65
74
  * Convert a YGPoint struct from one lambert zone to WGS84 (Rad)
66
75
  *
67
76
  */
68
- void lambert_to_wgs84(const YGPoint * org, YGPoint *dest, YGLambertZone zone);
69
77
 
70
- /*
71
- * Convert a YGPoint struct from one lambert zone to WGS84 (Deg)
72
- *
73
- */
74
- void lambert_to_wgs84_deg(const YGPoint * org, YGPoint *dest, YGLambertZone zone);
78
+
79
+ YGPoint YGPointConvertWGS84(YGPoint point, YGLambertZone zone);
75
80
 
76
81
  /*
77
82
  * ALGO0002
78
83
  */
79
84
 
80
- double lat_from_lat_iso(double lat_iso, double e, double eps);
85
+ double __YGLatitudeFromLatitudeISO(double lat_iso, double e, double eps);
81
86
 
82
87
  /*
83
88
  * ALGO0012
84
89
  */
85
90
 
86
- YGPoint cartesian_to_geographic(YGPoint org, double meridien, double a, double e , double eps);
91
+ YGPoint __YGCartesianToGeographic(YGPoint org, double meridien, double a, double e , double eps);
87
92
 
88
93
  /*
89
94
  * ALGO004
90
95
  */
91
- void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone, double lon_merid, double e, double eps);
96
+ YGPoint __YGLambertToGeographic(YGPoint org, YGLambertZone zone, double lon_merid, double e, double eps);
92
97
 
93
98
  /**
94
99
  * ALGO0009 - Transformations geographiques -> cartésiennes
@@ -96,26 +101,26 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
96
101
  *
97
102
  */
98
103
 
99
- YGPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e);
104
+ YGPoint __YGGeographicToCartesian(double lon, double lat, double he, double a, double e);
100
105
 
101
106
  /**
102
107
  * ALGO13 Transformation de Coordonnées à 7 paramètres entre deux systèmes géodésiques
103
108
  */
104
109
 
105
- YGPoint switch_geodesic_system(YGPoint u, Vector t, double d, Vector r);
110
+ YGPoint __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r);
106
111
 
107
112
  /**
108
113
  * Algo0001 Calcul de la latitude isomérique
109
114
  */
110
- double lat_iso(double lat, double e);
115
+ double __YGLatitudeISO(double lat, double e);
111
116
 
112
117
  /**
113
118
  * Algo003
114
119
  */
115
- YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat);
120
+ YGPoint __YGCoordinatesTransform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat);
116
121
 
117
122
  /**
118
123
  * Algo 01
119
124
  */
120
- double latitude_iso_from_lat(double lat, double e);
125
+ double __YGLatitudeISOFromLatitude(double lat, double e);
121
126
  #endif
@@ -12,6 +12,9 @@
12
12
  #define MAX_PATH_SIZE 1024
13
13
  #define DELTA_REALLOCATION 10
14
14
 
15
+ #ifndef OPEN_MAX
16
+ #define OPEN_MAX 256
17
+ #endif
15
18
 
16
19
  typedef struct {
17
20
 
@@ -25,7 +28,6 @@ typedef struct {
25
28
 
26
29
  static char currentNTVPath[OPEN_MAX];
27
30
  static FILE * gridFD = NULL;
28
- static char grd3dparams[4][MAX_LINE_BUFFER] = {{0}};
29
31
 
30
32
  static NTV2Reg *regcache = NULL;
31
33
  static int lastRegPos = 0;
@@ -108,21 +110,6 @@ int loadGrid()
108
110
  return 0;
109
111
  }
110
112
 
111
-
112
- void printParameters()
113
- {
114
- printf("===== Parameters =====\n");
115
- printf("%s\n", grd3dparams[0]);
116
- printf("%s\n", grd3dparams[1]);
117
- printf("%s\n", grd3dparams[2]);
118
- printf("%s\n", grd3dparams[3]);
119
-
120
- }
121
-
122
- void printReg(NTV2Reg reg)
123
- {
124
- printf("LON:%f - LAT:%f - TX:%f - TY:%f - TZ:%f - PRE:%f\n",reg.lon,reg.lat,reg.tx,reg.ty,reg.tz,reg.precision);
125
- }
126
113
  void unloadGrid()
127
114
  {
128
115
  fclose(gridFD);
@@ -168,7 +155,7 @@ void ntvreg_around_point(const YGPoint pt, NTV2Reg *t1, NTV2Reg *t2, NTV2Reg * t
168
155
  *t3 = *(--searchReg);
169
156
 
170
157
  }
171
- YGTransform ntf_to_rgf93(YGPoint pt)
158
+ YGTransform __YGTransformNTFoRGF93(YGPoint pt)
172
159
  {
173
160
  if(!gridFD)
174
161
  loadGrid();
@@ -189,7 +176,8 @@ YGTransform ntf_to_rgf93(YGPoint pt)
189
176
  regToBuff(t3Buf,t3);
190
177
  regToBuff(t4Buf,t4);
191
178
 
192
- for(int i = 0; i< 3; ++i)
179
+ int i;
180
+ for(i = 0; i< 3; ++i)
193
181
  {
194
182
  d[i] = (1-x)*(1-y)*t1Buf[i] + (1-x)*y*t2Buf[i] + (1-y)*x*t3Buf[i] + x*y*t4Buf[i];
195
183
  }
@@ -198,9 +186,36 @@ YGTransform ntf_to_rgf93(YGPoint pt)
198
186
  return tm;
199
187
  }
200
188
 
201
- YGTransform rgf93_to_ntf(YGPoint pt)
189
+ YGTransform __YGTransformRGF93ToNTF(YGPoint pt)
202
190
  {
203
- YGTransform tm = ntf_to_rgf93(pt);
191
+ YGTransform tm = __YGTransformNTFoRGF93(pt);
204
192
  YGTransform val = {-1*tm.tx,-1*tm.ty,-1*tm.tz};
205
193
  return val;
206
- }
194
+ }
195
+
196
+
197
+ YGPoint YGPointConvertRGF93_NTF(YGPoint point)
198
+ {
199
+ CoordUnit oldUnit = point.unit;
200
+
201
+ YGTransform tr = __YGTransformRGF93ToNTF(point);
202
+
203
+ YGPoint t = {tr.tx,tr.ty,tr.tz};
204
+ YGPoint null= {0,0,0};
205
+
206
+ point = YGPointToRadian(point);
207
+ point = __YGGeographicToCartesian(point.x,point.y,point.z,A_WGS84,E_WGS84);
208
+
209
+ point = __YGSwitchGeodesicSystem(point, t, 0, null);
210
+ point = __YGCartesianToGeographic(point, LON_MERID_PARIS, A_CLARK_IGN, E_CLARK_IGN, DEFAULT_EPS);
211
+
212
+ point = YGPointToUnit(point, oldUnit);
213
+
214
+ return point;
215
+
216
+ }
217
+
218
+ YGPoint YGPointConvertNTF_RGF93(YGPoint point)
219
+ {
220
+ return (YGPoint){0,0,0,0};
221
+ }
@@ -2,6 +2,13 @@
2
2
  #define __NTV2_H
3
3
  #include "lambert.h"
4
4
 
5
- YGTransform ntf_to_rgf93(YGPoint pt);
6
- YGTransform rgf93_to_ntf(YGPoint pt);
5
+ YGTransform __YGTransformNTFToRGF93(YGPoint pt);
6
+ YGTransform __YGTransformRGF93ToNTF(YGPoint pt);
7
+
8
+ YGPoint YGPointConvertRGF93_NTF(YGPoint point);
9
+
10
+ YGPoint YGPointConvertNTF_RGF93(YGPoint point);
11
+
12
+
13
+
7
14
  #endif
@@ -6,7 +6,6 @@
6
6
  #include "../src/lambert.h"
7
7
  #include "../src/rgf93.h"
8
8
 
9
- #define DISPLAY_POINT(point) printf(#point" X:%f | Y:%f | Z:%f\n",point.x,point.y,point.z);
10
9
 
11
10
  int init_suite_success(void) { return 0; }
12
11
  int init_suite_failure(void) { return -1; }
@@ -29,26 +28,6 @@ double rounded_down(double val,int n){
29
28
  return floorf(val*p)/p;
30
29
  }
31
30
 
32
- void test_lambert_deg(void)
33
- {
34
- YGPoint org = {994300.623,113409.981,0};
35
- YGPoint dest = {0,0,0};
36
- YGLambertZone zone = LAMBERT_I;
37
-
38
- lambert_to_wgs84_deg(&org, &dest, zone);
39
- printf("(Deg)Lon:%.11f - Lat:%.11f - H:%.11f\n",dest.x,dest.y,dest.z);
40
- }
41
-
42
- void test_lambert(void)
43
- {
44
-
45
- YGPoint org = {999534.581,112186.569,0};
46
- YGPoint dest = {0,0,0};
47
- YGLambertZone zone = LAMBERT_I;
48
-
49
- lambert_to_wgs84(&org, &dest, zone);
50
- }
51
-
52
31
  void test_algo009(void)
53
32
  {
54
33
  double lon[3] = {0.01745329248 ,0.00290888212 ,0.00581776423};
@@ -56,13 +35,22 @@ void test_algo009(void)
56
35
  double he[3] = {100.0000,10.0000 ,2000.0000};
57
36
  double a[3] = {6378249.2000 ,6378249.2000 ,6378249.2000};
58
37
  double e[3] = {0.08248325679 ,0.08248325679 ,0.08248325679};
38
+
39
+ YGPoint expected[3] = {
40
+ {6376064.6955,111294.6230,128984.7250, METER },
41
+ {6378232.2149,18553.5780,0, METER },
42
+ {6376897.5369,37099.7050,-202730.9070, METER }
43
+ };
59
44
 
60
45
 
61
46
  unsigned int i;
62
47
  for (i =0; i < 3;++i)
63
48
  {
64
- YGPoint pt = geographic_to_cartesian(lon[i],lat[i],he[i],a[i],e[i]);
65
- DISPLAY_POINT(pt);
49
+ YGPoint pt = __YGGeographicToCartesian(lon[i],lat[i],he[i],a[i],e[i]);
50
+ CU_ASSERT(fabs(pt.x - expected[i].x) <= 1e-4);
51
+ CU_ASSERT(fabs(pt.y - expected[i].y) <= 1e-4);
52
+ CU_ASSERT(fabs(pt.z - expected[i].z) <= 1e-4);
53
+
66
54
  }
67
55
 
68
56
  }
@@ -75,8 +63,7 @@ void test_algo0021 (void)
75
63
  double a = 6378388.0000;
76
64
  double e = 0.081991890;
77
65
 
78
- double calc = lambert_normal(lat,a,e);
79
- printf("Expected:%.4f | Computed:%.4f\n",n,calc);
66
+ double calc = __YGLambertNormal(lat,a,e);
80
67
  CU_ASSERT(n == truncate(calc,4));
81
68
 
82
69
  }
@@ -97,7 +84,7 @@ void test_algo0002(void)
97
84
 
98
85
  for(index = 0;index < 3;index++)
99
86
  {
100
- double result = lat_from_lat_iso(lat_iso[index], e[index], eps[index]);
87
+ double result = __YGLatitudeFromLatitudeISO(lat_iso[index], e[index], eps[index]);
101
88
  result = truncate(result,11);
102
89
  CU_ASSERT(result == phi[index]);
103
90
  }
@@ -124,7 +111,7 @@ void test_algo0012(void)
124
111
  {
125
112
  YGPoint sample = {x[i],y[i],z[i]};
126
113
  YGPoint val ;
127
- val = cartesian_to_geographic(sample,LON_MERID_PARIS,a[i],e[i],eps[i]);
114
+ val = __YGCartesianToGeographic(sample,LON_MERID_PARIS,a[i],e[i],eps[i]);
128
115
 
129
116
  // printf("X Computed:%.11f - Expected:%.11f\n",val.x,lon[i]);
130
117
  CU_ASSERT(fabs(val.x - lon[i]) <= ign_eps);
@@ -144,39 +131,98 @@ void test_algo004(void)
144
131
  YGPoint expected = {0.145512099,0.872664626};
145
132
 
146
133
 
147
- lambert_to_geographic(&org,&dest, LAMBERT_I, LON_MERID_GREENWICH,E_CLARK_IGN,1e-9);
148
- printf("Lat:%.9f - Lon:%.9f - Expected:Lat:%.9f - Lon:%.9f\n",dest.x,dest.y,expected.x,expected.y);
134
+ dest = __YGLambertToGeographic(org, LAMBERT_I, LON_MERID_GREENWICH,E_CLARK_IGN,1e-9);
135
+
149
136
  CU_ASSERT(fabs(dest.x - expected.x) <= 1e-9);
150
137
  CU_ASSERT(fabs(dest.y - expected.y) <= 1e-9);
151
138
  }
152
139
 
153
-
154
- void testBug2(void)
140
+ void testBugLambert93(void)
155
141
  {
156
- YGPoint org = {668832.5384,6950138.7285,0};
157
- YGPoint dest = {0,0,0};
158
- YGLambertZone zone= LAMBERT_93;
142
+ YGPoint org = YGMeterPoint(668832.5384,6950138.7285,0);
143
+ YGPoint expected = YGDegreePoint(2.56865, 49.64961, 0);
144
+ YGPoint dest;
145
+ YGLambertZone zone = LAMBERT_93;
159
146
 
160
- lambert_to_wgs84_deg(&org,&dest,zone);
161
- printf("Lat:%.9f - Lon:%.9f",dest.y,dest.x);
147
+ dest = YGPointConvertWGS84(org,zone);
148
+ dest = YGPointToDegree(dest);
149
+
150
+ CU_ASSERT(fabs(dest.x - expected.x) <= 1e-5);
151
+ CU_ASSERT(fabs(dest.y - expected.y) <= 1e-5);
162
152
 
163
153
  }
154
+
155
+
156
+ void testZenithStrasbourg(void)
157
+ {
158
+ YGPoint org = YGMeterPoint(994300.623,113409.981,0);
159
+ YGPoint expected = YGDegreePoint(7.68639475277068, 48.5953456709144, 0);
160
+ YGPoint dest;
161
+ YGLambertZone zone = LAMBERT_I;
162
+
163
+ dest = YGPointConvertWGS84(org,zone);
164
+ dest = YGPointToDegree(dest);
165
+
166
+ CU_ASSERT(fabs(dest.x - expected.x) <= 1e-5);
167
+ CU_ASSERT(fabs(dest.y - expected.y) <= 1e-5);
168
+ }
169
+ void testBugLambertIIE(void)
170
+ {
171
+ YGPoint org = YGMeterPoint(369419,1986498,0);
172
+ YGPoint expected = YGDegreePoint( -0.579117201473994,44.84071560809383, 0);
173
+ YGPoint dest;
174
+ YGLambertZone zone = LAMBERT_II_E;
175
+
176
+ dest = YGPointConvertWGS84(org,zone);
177
+ dest = YGPointToDegree(dest);
178
+
179
+ CU_ASSERT(fabs(dest.x - expected.x) <= 1e-4);
180
+ CU_ASSERT(fabs(dest.y - expected.y) <= 1e-4);
181
+ }
164
182
  void testOpenGrid(void)
165
183
  {
166
- YGPoint org = {.x=2.424971108, .y=48.844445839,.z=0,.unit=DEGREE};
167
-
168
- YGTransform tr = rgf93_to_ntf(org);
184
+ YGPoint org = YGDegreePoint(2.424971108, 48.844445839,0);
185
+
186
+ YGTransform tr = __YGTransformRGF93ToNTF(org);
169
187
 
170
188
  YGPoint t = {tr.tx,tr.ty,tr.tz};
171
- YGPoint null= {0,0,0};
189
+ YGPoint null= {0,0,0,RADIAN};
190
+
191
+ org = YGPointToRadian(org);
192
+ org = __YGGeographicToCartesian(org.x,org.y,org.z,A_WGS84,E_WGS84);
193
+
194
+ org = __YGSwitchGeodesicSystem(org, t, 0, null);
195
+ org = __YGCartesianToGeographic(org, LON_MERID_PARIS, A_CLARK_IGN, E_CLARK_IGN, DEFAULT_EPS);
172
196
 
173
- org = pointToRadian(org);
174
- org = geographic_to_cartesian(org.x,org.y,org.z,A_WGS84,E_WGS84);
197
+ org = YGPointToDegree(org);
175
198
 
176
- org = switch_geodesic_system(org, t, 0, null);
177
- org = cartesian_to_geographic(org, LON_MERID_PARIS, A_CLARK_IGN, E_CLARK_IGN, DEFAULT_EPS);
199
+ printf("Point value :\n");
200
+ }
201
+
202
+ void test_RGF93_NTF_degree(void)
203
+ {
204
+ YGPoint org = YGDegreePoint(2.424971108, 48.844445839,0);
205
+ YGPoint expected = YGDegreePoint(2.42567186, 48.84451225, 0);
206
+
207
+
208
+ YGPoint dest = YGPointConvertRGF93_NTF(org);
209
+ CU_ASSERT(fabs(expected.x - dest.x) <= 1e-8);
210
+ CU_ASSERT(fabs(expected.y - dest.y) <= 1e-8);
211
+ }
212
+
213
+ void test_RGF93_NTF_degree_to_cartesian(void)
214
+ {
215
+ YGPoint org = YGDegreePoint(2.424971108, 48.844445839,0);
216
+ YGPoint expected = YGDegreePoint(606491.571, 127112.233, 0);
217
+
218
+
219
+ YGPoint dest = YGPointConvertRGF93_NTF(org);
220
+ dest = YGPointToRadian(dest);
221
+
222
+
178
223
 
179
- org = pointToDegree(org);
224
+ CU_ASSERT(fabs(expected.x - dest.x) <= 1e-3);
225
+ CU_ASSERT(fabs(expected.y - dest.y) <= 1e-3);
180
226
  }
181
227
 
182
228
  int main(int argc, char **argv){
@@ -194,17 +240,19 @@ int main(int argc, char **argv){
194
240
  return CU_get_error();
195
241
  }
196
242
 
197
- /* add the tests to the suite */
243
+ /* add the tests to the suite testProjectionsecant*/
198
244
  if ( NULL == CU_add_test(pSuite, "Test Algo0002", test_algo0002) ||
199
245
  NULL == CU_add_test(pSuite, "Test Algo0012", test_algo0012) ||
200
246
  NULL == CU_add_test(pSuite,"Test Algo004",test_algo004) ||
201
247
  NULL == CU_add_test(pSuite,"Test algo0021",test_algo0021) ||
202
248
  NULL == CU_add_test(pSuite,"test_algo009",test_algo009) ||
203
- NULL == CU_add_test(pSuite,"test_lambert_deg",test_lambert_deg) ||
204
- NULL == CU_add_test(pSuite,"testBug2",testBug2) ||
249
+ NULL == CU_add_test(pSuite,"Test Zenith Strasbourg",testZenithStrasbourg) ||
250
+ NULL == CU_add_test(pSuite,"Test Bug Lambert 93",testBugLambert93) ||
251
+ NULL == CU_add_test(pSuite,"Test Bug Lambert II E",testBugLambertIIE) ||
205
252
  NULL == CU_add_test(pSuite,"testNTFRGF93",testOpenGrid) ||
206
- NULL == CU_add_test(pSuite, "Test lambert", test_lambert)
207
- )
253
+ NULL == CU_add_test(pSuite, "Test (Degree)RGF93 ->NTF (Degree)", test_RGF93_NTF_degree) ||
254
+ NULL == CU_add_test(pSuite, "Test (Degree)RGF93 ->NTF (Meter)", test_RGF93_NTF_degree_to_cartesian)
255
+ )
208
256
  {
209
257
  CU_cleanup_registry();
210
258
  return CU_get_error();
@@ -36,14 +36,13 @@ static VALUE p_convert(VALUE self,VALUE zone){
36
36
  y = NUM2DBL(rb_iv_get(self,"@y"));
37
37
  z = NUM2DBL(rb_iv_get(self,"@z"));
38
38
 
39
- YGPoint org = {x,y,z};
40
- YGPoint dest = {0,0,0};
39
+ YGPoint org = YGMeterPoint(x,y,z);
40
+ org = YGPointConvertWGS84(org,cZone);
41
+ org = YGPointToDegree(org);
41
42
 
42
- lambert_to_wgs84_deg(&org,&dest,cZone);
43
-
44
- rb_iv_set(self, "@x", rb_float_new(dest.x));
45
- rb_iv_set(self, "@y", rb_float_new(dest.y));
46
- rb_iv_set(self, "@z", rb_float_new(dest.z));
43
+ rb_iv_set(self, "@x", rb_float_new(org.x));
44
+ rb_iv_set(self, "@y", rb_float_new(org.y));
45
+ rb_iv_set(self, "@z", rb_float_new(org.z));
47
46
 
48
47
 
49
48
  return Qnil;
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: lambert_ruby
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.0.1
4
+ version: 1.0.2
5
5
  platform: ruby
6
6
  authors:
7
7
  - Yannick Heinrich
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2013-10-14 00:00:00.000000000 Z
11
+ date: 2014-01-14 00:00:00.000000000 Z
12
12
  dependencies: []
13
13
  description: Ruby wrapper for the lambert library
14
14
  email: yannick.heinrich@gmail.com
@@ -36,17 +36,17 @@ require_paths:
36
36
  - lib
37
37
  required_ruby_version: !ruby/object:Gem::Requirement
38
38
  requirements:
39
- - - ">="
39
+ - - '>='
40
40
  - !ruby/object:Gem::Version
41
41
  version: '0'
42
42
  required_rubygems_version: !ruby/object:Gem::Requirement
43
43
  requirements:
44
- - - ">="
44
+ - - '>='
45
45
  - !ruby/object:Gem::Version
46
46
  version: '0'
47
47
  requirements: []
48
48
  rubyforge_project:
49
- rubygems_version: 2.0.3
49
+ rubygems_version: 2.0.14
50
50
  signing_key:
51
51
  specification_version: 4
52
52
  summary: Ruby wrapper for the lambert library