lambert_ruby 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6d21e2b9e2e9f9adc7d68c49b8b7815d5e79d46
-  data.tar.gz: ead3cb60d5d7fe04da12c7365e00af6340a27bba
+  metadata.gz: 900b0dd2218561188f32fd7f9395b3aa3c410af8
+  data.tar.gz: 0d7cd916c3805017fe7487daf9ce18a2c3e3cc25
 SHA512:
-  metadata.gz: a885864daeb46f4bc2dbb4e28cef5619f64694724e59f81fcf489c251de4bb67a450bc057f87ad8ce3d31c919075a592b392a392e401db3c0aaa5282b3ce3d50
-  data.tar.gz: 93b944cb36c7078d73438e8edb4578680cde8b159c8fe475834e9ab950a7ede8d993462d92581e1f5e6ed11b627fede29e4e24b0b462cbe8d6e28369512855dd
+  metadata.gz: b8c387e9da5afad324b67d74769afa5a1fbfada0da0d275d9b9ae950db9152098c5f2207061407fbb3d4db5f9ba305676a0b91aab62f39fc1e6bd382a43bf335
+  data.tar.gz: 9e0250d316f5fece7acdcb243fb96b7d3cb0684ca29266cdbeff5ce33898b52db81c3467e014822b41b32ec7ac864c895ff3d7ed1e2254ad2b9d894f8c84dce8

data/ext/lambert_ruby/lambert.c

@@ -7,36 +7,167 @@
 #include <math.h>
 #include <stdio.h>
 
-#define RAD_TO_DEG(x) x*180/M_PI
-
-#define DISPLAY_YGLambertPoint(YGLambertPoint) printf(#YGLambertPoint" X:%f | Y:%f | Z:%f\n",YGLambertPoint.x,YGLambertPoint.y,YGLambertPoint.z);
-#define DISPLAY_YGLambertPoint_REF(YGLambertPoint) printf(#YGLambertPoint" X:%f | Y:%f | Z:%f\n",YGLambertPoint->x,YGLambertPoint->y,YGLambertPoint->z);
 
 static double lambert_n[6] = {0.7604059656, 0.7289686274, 0.6959127966, 0.6712679322, 0.7289686274, 0.7256077650};
 static double lambert_c[6] = {11603796.98, 11745793.39, 11947992.52, 12136281.99, 11745793.39, 11754255.426};
 static double lambert_xs[6]= {600000.0, 600000.0, 600000.0, 234.358, 600000.0, 700000.0};
 static double lambert_ys[6]= {5657616.674, 6199695.768, 6791905.085, 7239161.542, 8199695.768, 12655612.050};
 
-YGPoint pointToDegree(YGPoint p)
+YGPoint __YGDegreeToRadian(YGPoint pt)
+{
+    pt.x = pt.x * M_PI / 180.0;
+    pt.y = pt.y * M_PI / 180.0;
+    pt.z = pt.z * M_PI / 180.0;
+    
+    pt.unit = RADIAN;
+    
+    return pt;
+}
+
+YGPoint __YGRadianToDegree(YGPoint pt)
+{
+        pt.x = pt.x * 180/ M_PI;
+        pt.y = pt.y * 180/ M_PI;
+        pt.z = pt.z * 180/ M_PI;
+    
+        pt.unit = DEGREE;
+    
+        return pt;
+}
+
+YGPoint __YGGradToRadian(YGPoint pt)
+{
+        pt.x = pt.x * M_PI/200.0;
+        pt.y = pt.y * M_PI/200.0;
+        pt.z = pt.z * M_PI/200.0;
+    
+        pt.unit = RADIAN;
+    
+        return pt;
+}
+YGPoint __YGRadianToGrad(YGPoint pt)
+{
+    pt.x = pt.x * 200.0/M_PI;
+    pt.y = pt.y * 200.0/M_PI;
+    pt.z = pt.z * 200.0/M_PI;
+    
+    pt.unit = GRAD;
+    
+    return pt;
+}
+
+YGPoint __YGGradToDegree(YGPoint pt)
+{
+    pt.x = pt.x * 180.0/200.0;
+    pt.y = pt.y * 180.0/200.0;
+    pt.z = pt.z * 180.0/200.0;
+    
+    pt.unit = DEGREE;
+    
+    return pt;
+    
+}
+
+YGPoint __YGDegreeToGrad(YGPoint pt)
+{
+    pt.x = pt.x * 200.0/180.0;
+    pt.y = pt.y * 200.0/180.0;
+    pt.z = pt.z * 200.0/180.0;
+    
+    pt.unit = GRAD;
+    
+    return pt;
+}
+
+
+YGPoint YGPointToDegree(YGPoint pt)
 {
-   
-        p.x = p.x * 180/M_PI;
-        p.y = p.y * 180/M_PI;
-        p.z = p.z * 180/M_PI;
     
-        return p;
+    switch (pt.unit)
+    {
+        case RADIAN :
+        {
+            pt = __YGRadianToDegree(pt);
+        }
+            break;
+        case GRAD :
+        {
+            pt = __YGGradToDegree(pt);
+        }
+            break;
+       default:
+            break;
+    }
+        
+            return  pt;
+    
 }
 
-YGPoint pointToRadian(YGPoint p)
+
+YGPoint YGPointToRadian(YGPoint pt)
 {
-        p.x = p.x * M_PI/180;
-        p.y = p.y * M_PI/180;
-        p.z = p.z * M_PI/180;
+    switch (pt.unit)
+    {
+        case DEGREE :
+        {
+            pt = __YGDegreeToRadian(pt);
+        }
+            break;
+        case GRAD :
+        {
+            pt = __YGGradToRadian(pt);
+        }
+            break;
+        default:
+            break;
+    }
     
-    return p;
+    return  pt;
 }
 
-double latitude_iso_from_lat(double lat, double e)
+YGPoint YGPointToGrad(YGPoint pt)
+{
+    switch (pt.unit)
+    {
+        case RADIAN :
+        {
+            pt = __YGRadianToGrad(pt);
+        }
+            break;
+        case DEGREE :
+        {
+            pt = __YGDegreeToGrad(pt);
+        }
+            break;
+        default:
+            break;
+    }
+
+    return  pt;
+}
+
+YGPoint YGPointToUnit(YGPoint point, CoordUnit unit)
+{
+    switch (unit) {
+        case DEGREE:
+            return YGPointToDegree(point);
+            break;
+        case GRAD:
+            return YGPointToGrad(point);
+        case RADIAN :
+            return YGPointToDegree(point);
+            break;
+        default:
+            return point;
+            break;
+    }
+}
+
+/*****************
+ ** IGN algorithms
+*****************/
+
+double __YGLatitudeISOFromLatitude(double lat, double e)
 {
     return log(tan(M_PI_4+lat/2)*pow((1-e*sin(lat))/(1+e*sin(lat)),e/2));
 }
@@ -45,7 +176,7 @@ double latitude_iso_from_lat(double lat, double e)
  * ALGO0002
  */
 
-double lat_from_lat_iso(double lat_iso, double e,double eps)
+double __YGLatitudeFromLatitudeISO(double lat_iso, double e,double eps)
 {
 
 	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)
 *	ALGO0004 - Lambert vers geographiques
 */
 
-void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone, double lon_merid, double e, double eps)
+YGPoint __YGLambertToGeographic(YGPoint org, YGLambertZone zone, double lon_merid, double e, double eps)
 {
 	double n = lambert_n[zone];
 	double C = lambert_c[zone];
 	double x_s = lambert_xs[zone];
 	double y_s = lambert_ys[zone];
 
-	double x = org->x;
-	double y = org->y;
+	double x = org.x;
+	double y = org.y;
 
 	double lon, gamma, R, lat_iso;
 
@@ -84,10 +215,12 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
 
 	lat_iso = -1/n*log(fabs(R/C));
 
-	double lat = lat_from_lat_iso(lat_iso,e,eps);
+	double lat = __YGLatitudeFromLatitudeISO(lat_iso,e,eps);
 
-	dest->x = lon;
-	dest->y = lat;
+	org.x = lon;
+	org.y = lat;
+    
+    return org;
 }
 
 
@@ -96,7 +229,7 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
  *
 */
 
-double lambert_normal(double lat, double a, double e)
+double __YGLambertNormal(double lat, double a, double e)
 {
 
 	return a/sqrt(1-e*e*sin(lat)*sin(lat));
@@ -108,9 +241,9 @@ double lambert_normal(double lat, double a, double e)
  *
  */
 
- YGPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e)
+ YGPoint __YGGeographicToCartesian(double lon, double lat, double he, double a, double e)
  {
- 	double N = lambert_normal(lat,a,e);
+ 	double N = __YGLambertNormal(lat,a,e);
  	
  	YGPoint pt = {0,0,0};
  	pt.x = (N+he)*cos(lat)*cos(lon);
@@ -127,7 +260,7 @@ double lambert_normal(double lat, double a, double e)
  * ALGO0012 - Passage des coordonnées cartésiennes aux coordonnées géographiques
  */
 
- YGPoint cartesian_to_geographic(YGPoint org, double meridien, double a, double e , double eps)
+ YGPoint __YGCartesianToGeographic(YGPoint org, double meridien, double a, double e , double eps)
  {
  	double x = org.x, y = org.y, z = org.z;
 
@@ -150,7 +283,8 @@ double lambert_normal(double lat, double a, double e)
  	YGPoint pt;
  	pt.x = lon;
  	pt.y = phi_i;
- 	pt.z = he;
+ 	pt.z = he;     
+    pt.unit = RADIAN;
 
  	return pt;
  }
@@ -161,50 +295,48 @@ double lambert_normal(double lat, double a, double e)
  *
  */
 
-void lambert_to_wgs84(const YGPoint * org, YGPoint *dest,YGLambertZone zone){
+YGPoint YGPointConvertWGS84(YGPoint point, YGLambertZone zone){
     
+    if(point.unit != METER)
+    {
+            perror("Could not operate on a non METER based point!\n The points returned will be the same!\n");
+            return  point;
+    }
     
-  
     if(LAMBERT_93 == zone)
     {
-        lambert_to_geographic(org,dest,zone,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
+       point =  __YGLambertToGeographic(point,zone,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
+    
     }
     else
     {
-        lambert_to_geographic(org,dest,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
-        YGPoint temp = geographic_to_cartesian(dest->x,dest->y,dest->z,A_CLARK_IGN,E_CLARK_IGN);
+        point  = __YGLambertToGeographic(point,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
+        point = __YGGeographicToCartesian(point.x,point.y,point.z,A_CLARK_IGN,E_CLARK_IGN);
     
-        temp.x= temp.x - 168;
-        temp.y= temp.y - 60;
-        temp.z= temp.z + 320;
+        point.x-= 168;
+        point.y-= 60;
+        point.z+= 320;
     
         //WGS84 refers to greenwich
-        temp = cartesian_to_geographic(temp, LON_MERID_IERS, A_WGS84,E_WGS84,DEFAULT_EPS);
-        
-        dest->x = temp.x;
-        dest->y = temp.y;
+        point = __YGCartesianToGeographic(point, LON_MERID_GREENWICH, A_WGS84,E_WGS84,DEFAULT_EPS);
     }
+    
+    point.unit = RADIAN;
+    return point;
 }
 
 
-void lambert_to_wgs84_deg(const YGPoint * org, YGPoint *dest, YGLambertZone zone)
-{
-	YGPoint temp = {0,0,0};
-	
-	lambert_to_wgs84(org,&temp,zone);
-    *dest = pointToDegree(temp);
-}
 
-double lat_iso(double lat, double e)
+double __YGLatitudeISO(double lat, double e)
 {
 	return log(tan(M_PI_4 + lat/2)*pow((1-e*sin(lat))/(1+e*sin(lat)),e/2));
 }
 
-YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat)
+YGPoint __YGCoordinatesTransform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat)
 {
 	YGPoint dest = {0,0,0};
 
-	double latiso = lat_iso(lat,e);
+	double latiso = __YGLatitudeISO(lat,e);
 	dest.x = x_s + e*exp(-n*latiso)*sin(n*(lon-lambda_c));
 	dest.y = y_s + e*exp(n*latiso)*cos(n*(lon-lambda_c));
 
@@ -212,7 +344,7 @@ YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_
 
 }
 
-YGPoint switch_geodesic_system(YGPoint u, Vector t, double d, Vector r)
+YGPoint __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r)
 {
 	YGPoint v = {0,0,0};
 

data/ext/lambert_ruby/lambert.h

@@ -18,8 +18,6 @@
 #define ct_x0 700000.0
 #define ct_y0 6600000.0
 
-#define DISPLAY_YGPoint(YGPoint) printf(#YGPoint" X:%f | Y:%f | Z:%f\n",YGPoint.x,YGPoint.y,YGPoint.z);
-#define DISPLAY_YGPoint_REF(YGPoint) printf(#YGPoint" X:%f | Y:%f | Z:%f\n",YGPoint->x,YGPoint->y,YGPoint->z);
 
 typedef enum {
 	LAMBERT_I=0,
@@ -33,7 +31,8 @@ typedef enum {
 typedef enum {
     DEGREE,
     GRAD,
-    RADIAN
+    RADIAN,
+    METER
 } CoordUnit;
 
 typedef struct {
@@ -52,43 +51,49 @@ typedef struct
 
 typedef YGPoint Vector;
 
-YGPoint pointToRadian(YGPoint p);
-YGPoint pointToDegree(YGPoint p);
+#define __YGPointWithUnit(_x,_y,_z,_unit) {.x=_x, .y=_y,.z=_z,.unit=_unit};
+
+#define YGDegreePoint(x,y,z) __YGPointWithUnit(x,y,z,DEGREE)
+#define YGRadianPoint(x,y,z) __YGPointWithUnit(x,y,z,RADIAN)
+#define YGGradPoint(x,y,z) __YGPointWithUnit(x,y,z,GRAD)
+#define YGMeterPoint(x,y,z) __YGPointWithUnit(x,y,z,METER)
+ 
+
+YGPoint YGPointToRadian(YGPoint p);
+YGPoint YGPointToDegree(YGPoint p);
+YGPoint YGPointToGrad(YGPoint p);
+YGPoint YGPointToUnit(YGPoint point, CoordUnit unit);
 
 /*
  * ALGO0021 - Calcul de la grande Normale 
  *
 */
-double lambert_normal(double lat, double a, double e);
+double __YGLambertNormal(double lat, double a, double e);
 
 /*
  * Convert a YGPoint struct from one lambert zone to WGS84 (Rad)
  *
  */
-void lambert_to_wgs84(const YGPoint * org, YGPoint *dest, YGLambertZone zone);
 
-/*
- * Convert a YGPoint struct from one lambert zone to WGS84 (Deg)
- *
- */
-void lambert_to_wgs84_deg(const YGPoint * org, YGPoint *dest, YGLambertZone zone);
+
+YGPoint YGPointConvertWGS84(YGPoint point, YGLambertZone zone);
 
 /*
  * ALGO0002
  */
 
-double lat_from_lat_iso(double lat_iso, double e, double eps);
+double __YGLatitudeFromLatitudeISO(double lat_iso, double e, double eps);
 
 /*
 * ALGO0012
 */
 
-YGPoint cartesian_to_geographic(YGPoint org, double meridien, double a, double e , double eps);
+YGPoint __YGCartesianToGeographic(YGPoint org, double meridien, double a, double e , double eps);
 
 /*
  * ALGO004
  */
-void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone, double lon_merid, double e, double eps);
+YGPoint __YGLambertToGeographic(YGPoint org, YGLambertZone zone, double lon_merid, double e, double eps);
 
 /**
  * ALGO0009 - Transformations geographiques -> cartésiennes
@@ -96,26 +101,26 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
  *
  */
 
- YGPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e);
+ YGPoint __YGGeographicToCartesian(double lon, double lat, double he, double a, double e);
 
  /**
  * ALGO13 Transformation de Coordonnées à 7 paramètres entre deux systèmes géodésiques
  */
  
- YGPoint switch_geodesic_system(YGPoint u, Vector t, double d, Vector r);
+ YGPoint __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r);
  
  /**
  * Algo0001  Calcul de la latitude isomérique
  */
-double lat_iso(double lat, double e);
+double __YGLatitudeISO(double lat, double e);
 
 /** 
 * Algo003 
 */
-YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat);
+YGPoint __YGCoordinatesTransform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat);
 
 /**
  * Algo 01
  */
-double latitude_iso_from_lat(double lat, double e);
+double __YGLatitudeISOFromLatitude(double lat, double e);
  #endif

data/ext/lambert_ruby/lambert/src/lambert.c

@@ -7,36 +7,167 @@
 #include <math.h>
 #include <stdio.h>
 
-#define RAD_TO_DEG(x) x*180/M_PI
-
-#define DISPLAY_YGLambertPoint(YGLambertPoint) printf(#YGLambertPoint" X:%f | Y:%f | Z:%f\n",YGLambertPoint.x,YGLambertPoint.y,YGLambertPoint.z);
-#define DISPLAY_YGLambertPoint_REF(YGLambertPoint) printf(#YGLambertPoint" X:%f | Y:%f | Z:%f\n",YGLambertPoint->x,YGLambertPoint->y,YGLambertPoint->z);
 
 static double lambert_n[6] = {0.7604059656, 0.7289686274, 0.6959127966, 0.6712679322, 0.7289686274, 0.7256077650};
 static double lambert_c[6] = {11603796.98, 11745793.39, 11947992.52, 12136281.99, 11745793.39, 11754255.426};
 static double lambert_xs[6]= {600000.0, 600000.0, 600000.0, 234.358, 600000.0, 700000.0};
 static double lambert_ys[6]= {5657616.674, 6199695.768, 6791905.085, 7239161.542, 8199695.768, 12655612.050};
 
-YGPoint pointToDegree(YGPoint p)
+YGPoint __YGDegreeToRadian(YGPoint pt)
+{
+    pt.x = pt.x * M_PI / 180.0;
+    pt.y = pt.y * M_PI / 180.0;
+    pt.z = pt.z * M_PI / 180.0;
+    
+    pt.unit = RADIAN;
+    
+    return pt;
+}
+
+YGPoint __YGRadianToDegree(YGPoint pt)
+{
+        pt.x = pt.x * 180/ M_PI;
+        pt.y = pt.y * 180/ M_PI;
+        pt.z = pt.z * 180/ M_PI;
+    
+        pt.unit = DEGREE;
+    
+        return pt;
+}
+
+YGPoint __YGGradToRadian(YGPoint pt)
+{
+        pt.x = pt.x * M_PI/200.0;
+        pt.y = pt.y * M_PI/200.0;
+        pt.z = pt.z * M_PI/200.0;
+    
+        pt.unit = RADIAN;
+    
+        return pt;
+}
+YGPoint __YGRadianToGrad(YGPoint pt)
+{
+    pt.x = pt.x * 200.0/M_PI;
+    pt.y = pt.y * 200.0/M_PI;
+    pt.z = pt.z * 200.0/M_PI;
+    
+    pt.unit = GRAD;
+    
+    return pt;
+}
+
+YGPoint __YGGradToDegree(YGPoint pt)
+{
+    pt.x = pt.x * 180.0/200.0;
+    pt.y = pt.y * 180.0/200.0;
+    pt.z = pt.z * 180.0/200.0;
+    
+    pt.unit = DEGREE;
+    
+    return pt;
+    
+}
+
+YGPoint __YGDegreeToGrad(YGPoint pt)
+{
+    pt.x = pt.x * 200.0/180.0;
+    pt.y = pt.y * 200.0/180.0;
+    pt.z = pt.z * 200.0/180.0;
+    
+    pt.unit = GRAD;
+    
+    return pt;
+}
+
+
+YGPoint YGPointToDegree(YGPoint pt)
 {
-   
-        p.x = p.x * 180/M_PI;
-        p.y = p.y * 180/M_PI;
-        p.z = p.z * 180/M_PI;
     
-        return p;
+    switch (pt.unit)
+    {
+        case RADIAN :
+        {
+            pt = __YGRadianToDegree(pt);
+        }
+            break;
+        case GRAD :
+        {
+            pt = __YGGradToDegree(pt);
+        }
+            break;
+       default:
+            break;
+    }
+        
+            return  pt;
+    
 }
 
-YGPoint pointToRadian(YGPoint p)
+
+YGPoint YGPointToRadian(YGPoint pt)
 {
-        p.x = p.x * M_PI/180;
-        p.y = p.y * M_PI/180;
-        p.z = p.z * M_PI/180;
+    switch (pt.unit)
+    {
+        case DEGREE :
+        {
+            pt = __YGDegreeToRadian(pt);
+        }
+            break;
+        case GRAD :
+        {
+            pt = __YGGradToRadian(pt);
+        }
+            break;
+        default:
+            break;
+    }
     
-    return p;
+    return  pt;
 }
 
-double latitude_iso_from_lat(double lat, double e)
+YGPoint YGPointToGrad(YGPoint pt)
+{
+    switch (pt.unit)
+    {
+        case RADIAN :
+        {
+            pt = __YGRadianToGrad(pt);
+        }
+            break;
+        case DEGREE :
+        {
+            pt = __YGDegreeToGrad(pt);
+        }
+            break;
+        default:
+            break;
+    }
+
+    return  pt;
+}
+
+YGPoint YGPointToUnit(YGPoint point, CoordUnit unit)
+{
+    switch (unit) {
+        case DEGREE:
+            return YGPointToDegree(point);
+            break;
+        case GRAD:
+            return YGPointToGrad(point);
+        case RADIAN :
+            return YGPointToDegree(point);
+            break;
+        default:
+            return point;
+            break;
+    }
+}
+
+/*****************
+ ** IGN algorithms
+*****************/
+
+double __YGLatitudeISOFromLatitude(double lat, double e)
 {
     return log(tan(M_PI_4+lat/2)*pow((1-e*sin(lat))/(1+e*sin(lat)),e/2));
 }
@@ -45,7 +176,7 @@ double latitude_iso_from_lat(double lat, double e)
  * ALGO0002
  */
 
-double lat_from_lat_iso(double lat_iso, double e,double eps)
+double __YGLatitudeFromLatitudeISO(double lat_iso, double e,double eps)
 {
 
 	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)
 *	ALGO0004 - Lambert vers geographiques
 */
 
-void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone, double lon_merid, double e, double eps)
+YGPoint __YGLambertToGeographic(YGPoint org, YGLambertZone zone, double lon_merid, double e, double eps)
 {
 	double n = lambert_n[zone];
 	double C = lambert_c[zone];
 	double x_s = lambert_xs[zone];
 	double y_s = lambert_ys[zone];
 
-	double x = org->x;
-	double y = org->y;
+	double x = org.x;
+	double y = org.y;
 
 	double lon, gamma, R, lat_iso;
 
@@ -84,10 +215,12 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
 
 	lat_iso = -1/n*log(fabs(R/C));
 
-	double lat = lat_from_lat_iso(lat_iso,e,eps);
+	double lat = __YGLatitudeFromLatitudeISO(lat_iso,e,eps);
 
-	dest->x = lon;
-	dest->y = lat;
+	org.x = lon;
+	org.y = lat;
+    
+    return org;
 }
 
 
@@ -96,7 +229,7 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
  *
 */
 
-double lambert_normal(double lat, double a, double e)
+double __YGLambertNormal(double lat, double a, double e)
 {
 
 	return a/sqrt(1-e*e*sin(lat)*sin(lat));
@@ -108,9 +241,9 @@ double lambert_normal(double lat, double a, double e)
  *
  */
 
- YGPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e)
+ YGPoint __YGGeographicToCartesian(double lon, double lat, double he, double a, double e)
  {
- 	double N = lambert_normal(lat,a,e);
+ 	double N = __YGLambertNormal(lat,a,e);
  	
  	YGPoint pt = {0,0,0};
  	pt.x = (N+he)*cos(lat)*cos(lon);
@@ -127,7 +260,7 @@ double lambert_normal(double lat, double a, double e)
  * ALGO0012 - Passage des coordonnées cartésiennes aux coordonnées géographiques
  */
 
- YGPoint cartesian_to_geographic(YGPoint org, double meridien, double a, double e , double eps)
+ YGPoint __YGCartesianToGeographic(YGPoint org, double meridien, double a, double e , double eps)
  {
  	double x = org.x, y = org.y, z = org.z;
 
@@ -150,7 +283,8 @@ double lambert_normal(double lat, double a, double e)
  	YGPoint pt;
  	pt.x = lon;
  	pt.y = phi_i;
- 	pt.z = he;
+ 	pt.z = he;     
+    pt.unit = RADIAN;
 
  	return pt;
  }
@@ -161,50 +295,48 @@ double lambert_normal(double lat, double a, double e)
  *
  */
 
-void lambert_to_wgs84(const YGPoint * org, YGPoint *dest,YGLambertZone zone){
+YGPoint YGPointConvertWGS84(YGPoint point, YGLambertZone zone){
     
+    if(point.unit != METER)
+    {
+            perror("Could not operate on a non METER based point!\n The points returned will be the same!\n");
+            return  point;
+    }
     
-  
     if(LAMBERT_93 == zone)
     {
-        lambert_to_geographic(org,dest,zone,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
+       point =  __YGLambertToGeographic(point,zone,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
+    
     }
     else
     {
-        lambert_to_geographic(org,dest,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
-        YGPoint temp = geographic_to_cartesian(dest->x,dest->y,dest->z,A_CLARK_IGN,E_CLARK_IGN);
+        point  = __YGLambertToGeographic(point,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
+        point = __YGGeographicToCartesian(point.x,point.y,point.z,A_CLARK_IGN,E_CLARK_IGN);
     
-        temp.x= temp.x - 168;
-        temp.y= temp.y - 60;
-        temp.z= temp.z + 320;
+        point.x-= 168;
+        point.y-= 60;
+        point.z+= 320;
     
         //WGS84 refers to greenwich
-        temp = cartesian_to_geographic(temp, LON_MERID_IERS, A_WGS84,E_WGS84,DEFAULT_EPS);
-        
-        dest->x = temp.x;
-        dest->y = temp.y;
+        point = __YGCartesianToGeographic(point, LON_MERID_GREENWICH, A_WGS84,E_WGS84,DEFAULT_EPS);
     }
+    
+    point.unit = RADIAN;
+    return point;
 }
 
 
-void lambert_to_wgs84_deg(const YGPoint * org, YGPoint *dest, YGLambertZone zone)
-{
-	YGPoint temp = {0,0,0};
-	
-	lambert_to_wgs84(org,&temp,zone);
-    *dest = pointToDegree(temp);
-}
 
-double lat_iso(double lat, double e)
+double __YGLatitudeISO(double lat, double e)
 {
 	return log(tan(M_PI_4 + lat/2)*pow((1-e*sin(lat))/(1+e*sin(lat)),e/2));
 }
 
-YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat)
+YGPoint __YGCoordinatesTransform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat)
 {
 	YGPoint dest = {0,0,0};
 
-	double latiso = lat_iso(lat,e);
+	double latiso = __YGLatitudeISO(lat,e);
 	dest.x = x_s + e*exp(-n*latiso)*sin(n*(lon-lambda_c));
 	dest.y = y_s + e*exp(n*latiso)*cos(n*(lon-lambda_c));
 
@@ -212,7 +344,7 @@ YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_
 
 }
 
-YGPoint switch_geodesic_system(YGPoint u, Vector t, double d, Vector r)
+YGPoint __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r)
 {
 	YGPoint v = {0,0,0};
 

data/ext/lambert_ruby/lambert/src/lambert.h

@@ -18,8 +18,6 @@
 #define ct_x0 700000.0
 #define ct_y0 6600000.0
 
-#define DISPLAY_YGPoint(YGPoint) printf(#YGPoint" X:%f | Y:%f | Z:%f\n",YGPoint.x,YGPoint.y,YGPoint.z);
-#define DISPLAY_YGPoint_REF(YGPoint) printf(#YGPoint" X:%f | Y:%f | Z:%f\n",YGPoint->x,YGPoint->y,YGPoint->z);
 
 typedef enum {
 	LAMBERT_I=0,
@@ -33,7 +31,8 @@ typedef enum {
 typedef enum {
     DEGREE,
     GRAD,
-    RADIAN
+    RADIAN,
+    METER
 } CoordUnit;
 
 typedef struct {
@@ -52,43 +51,49 @@ typedef struct
 
 typedef YGPoint Vector;
 
-YGPoint pointToRadian(YGPoint p);
-YGPoint pointToDegree(YGPoint p);
+#define __YGPointWithUnit(_x,_y,_z,_unit) {.x=_x, .y=_y,.z=_z,.unit=_unit};
+
+#define YGDegreePoint(x,y,z) __YGPointWithUnit(x,y,z,DEGREE)
+#define YGRadianPoint(x,y,z) __YGPointWithUnit(x,y,z,RADIAN)
+#define YGGradPoint(x,y,z) __YGPointWithUnit(x,y,z,GRAD)
+#define YGMeterPoint(x,y,z) __YGPointWithUnit(x,y,z,METER)
+ 
+
+YGPoint YGPointToRadian(YGPoint p);
+YGPoint YGPointToDegree(YGPoint p);
+YGPoint YGPointToGrad(YGPoint p);
+YGPoint YGPointToUnit(YGPoint point, CoordUnit unit);
 
 /*
  * ALGO0021 - Calcul de la grande Normale 
  *
 */
-double lambert_normal(double lat, double a, double e);
+double __YGLambertNormal(double lat, double a, double e);
 
 /*
  * Convert a YGPoint struct from one lambert zone to WGS84 (Rad)
  *
  */
-void lambert_to_wgs84(const YGPoint * org, YGPoint *dest, YGLambertZone zone);
 
-/*
- * Convert a YGPoint struct from one lambert zone to WGS84 (Deg)
- *
- */
-void lambert_to_wgs84_deg(const YGPoint * org, YGPoint *dest, YGLambertZone zone);
+
+YGPoint YGPointConvertWGS84(YGPoint point, YGLambertZone zone);
 
 /*
  * ALGO0002
  */
 
-double lat_from_lat_iso(double lat_iso, double e, double eps);
+double __YGLatitudeFromLatitudeISO(double lat_iso, double e, double eps);
 
 /*
 * ALGO0012
 */
 
-YGPoint cartesian_to_geographic(YGPoint org, double meridien, double a, double e , double eps);
+YGPoint __YGCartesianToGeographic(YGPoint org, double meridien, double a, double e , double eps);
 
 /*
  * ALGO004
  */
-void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone, double lon_merid, double e, double eps);
+YGPoint __YGLambertToGeographic(YGPoint org, YGLambertZone zone, double lon_merid, double e, double eps);
 
 /**
  * ALGO0009 - Transformations geographiques -> cartésiennes
@@ -96,26 +101,26 @@ void lambert_to_geographic(const YGPoint * org,YGPoint *dest, YGLambertZone zone
  *
  */
 
- YGPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e);
+ YGPoint __YGGeographicToCartesian(double lon, double lat, double he, double a, double e);
 
  /**
  * ALGO13 Transformation de Coordonnées à 7 paramètres entre deux systèmes géodésiques
  */
  
- YGPoint switch_geodesic_system(YGPoint u, Vector t, double d, Vector r);
+ YGPoint __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r);
  
  /**
  * Algo0001  Calcul de la latitude isomérique
  */
-double lat_iso(double lat, double e);
+double __YGLatitudeISO(double lat, double e);
 
 /** 
 * Algo003 
 */
-YGPoint coord_transform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat);
+YGPoint __YGCoordinatesTransform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat);
 
 /**
  * Algo 01
  */
-double latitude_iso_from_lat(double lat, double e);
+double __YGLatitudeISOFromLatitude(double lat, double e);
  #endif

data/ext/lambert_ruby/lambert/src/rgf93.c

@@ -12,6 +12,9 @@
 #define MAX_PATH_SIZE 1024
 #define DELTA_REALLOCATION 10
 
+#ifndef OPEN_MAX
+#define OPEN_MAX 256
+#endif
 
 typedef struct {
     
@@ -25,7 +28,6 @@ typedef struct {
 
 static char currentNTVPath[OPEN_MAX];
 static FILE * gridFD = NULL;
-static char grd3dparams[4][MAX_LINE_BUFFER] = {{0}};
 
 static NTV2Reg *regcache = NULL;
 static int lastRegPos = 0;
@@ -108,21 +110,6 @@ int loadGrid()
     return 0;
 }
 
-
-void printParameters()
-{
-	printf("===== Parameters =====\n");
-	printf("%s\n", grd3dparams[0]);
-	printf("%s\n", grd3dparams[1]);
-	printf("%s\n", grd3dparams[2]);
-	printf("%s\n", grd3dparams[3]);
-    
-}
-
-void printReg(NTV2Reg reg)
-{
-    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);
-}
 void unloadGrid()
 {
     fclose(gridFD);
@@ -168,7 +155,7 @@ void ntvreg_around_point(const YGPoint pt, NTV2Reg *t1, NTV2Reg *t2, NTV2Reg * t
     *t3 = *(--searchReg);
 
 }
-YGTransform ntf_to_rgf93(YGPoint pt)
+YGTransform __YGTransformNTFoRGF93(YGPoint pt)
 {
     if(!gridFD)
         loadGrid();
@@ -189,7 +176,8 @@ YGTransform ntf_to_rgf93(YGPoint pt)
     regToBuff(t3Buf,t3);
     regToBuff(t4Buf,t4);
     
-    for(int i = 0; i< 3; ++i)
+	int i;
+    for(i = 0; i< 3; ++i)
     {
         d[i] =  (1-x)*(1-y)*t1Buf[i] + (1-x)*y*t2Buf[i] + (1-y)*x*t3Buf[i] + x*y*t4Buf[i];
     }
@@ -198,9 +186,36 @@ YGTransform ntf_to_rgf93(YGPoint pt)
     return tm;
 }
 
-YGTransform rgf93_to_ntf(YGPoint pt)
+YGTransform __YGTransformRGF93ToNTF(YGPoint pt)
 {
-    YGTransform tm = ntf_to_rgf93(pt);
+    YGTransform tm = __YGTransformNTFoRGF93(pt);
     YGTransform val = {-1*tm.tx,-1*tm.ty,-1*tm.tz};
     return val;
-}
+}
+
+
+YGPoint YGPointConvertRGF93_NTF(YGPoint point)
+{
+    CoordUnit oldUnit = point.unit;
+    
+    YGTransform tr = __YGTransformRGF93ToNTF(point);
+    
+    YGPoint t = {tr.tx,tr.ty,tr.tz};
+    YGPoint null= {0,0,0};
+    
+    point = YGPointToRadian(point);
+    point =  __YGGeographicToCartesian(point.x,point.y,point.z,A_WGS84,E_WGS84);
+    
+    point =  __YGSwitchGeodesicSystem(point, t, 0, null);
+    point = __YGCartesianToGeographic(point, LON_MERID_PARIS, A_CLARK_IGN, E_CLARK_IGN, DEFAULT_EPS);
+    
+    point = YGPointToUnit(point, oldUnit);
+    
+    return point;
+
+}
+
+YGPoint YGPointConvertNTF_RGF93(YGPoint point)
+{
+    return (YGPoint){0,0,0,0};
+}

data/ext/lambert_ruby/lambert/src/rgf93.h

@@ -2,6 +2,13 @@
 #define __NTV2_H
 #include "lambert.h"
 
-YGTransform ntf_to_rgf93(YGPoint pt);
-YGTransform rgf93_to_ntf(YGPoint pt);
+YGTransform __YGTransformNTFToRGF93(YGPoint pt);
+YGTransform __YGTransformRGF93ToNTF(YGPoint pt);
+
+YGPoint YGPointConvertRGF93_NTF(YGPoint point);
+
+YGPoint YGPointConvertNTF_RGF93(YGPoint point);
+
+
+
 #endif

data/ext/lambert_ruby/lambert/tests/test_lambert_cunit.c

@@ -6,7 +6,6 @@
 #include "../src/lambert.h"
 #include "../src/rgf93.h"
 
-#define DISPLAY_POINT(point) printf(#point" X:%f | Y:%f | Z:%f\n",point.x,point.y,point.z);
 
 int init_suite_success(void) { return 0; }
 int init_suite_failure(void) { return -1; }
@@ -29,26 +28,6 @@ double rounded_down(double val,int n){
 	return floorf(val*p)/p;
 }
 
-void test_lambert_deg(void)
-{
-	YGPoint org = {994300.623,113409.981,0};
-	YGPoint dest = {0,0,0};
-	YGLambertZone zone = LAMBERT_I;
-
-	lambert_to_wgs84_deg(&org, &dest, zone);
-	printf("(Deg)Lon:%.11f - Lat:%.11f - H:%.11f\n",dest.x,dest.y,dest.z);
-}
-
-void test_lambert(void)
-{
-
-	YGPoint org = {999534.581,112186.569,0};
-	YGPoint dest = {0,0,0};
-	YGLambertZone zone = LAMBERT_I;
-
-	lambert_to_wgs84(&org, &dest, zone);
-}
-
 void test_algo009(void)
 {	
 	double lon[3] = {0.01745329248 ,0.00290888212 ,0.00581776423};
@@ -56,13 +35,22 @@ void test_algo009(void)
 	double he[3] = {100.0000,10.0000 ,2000.0000};
 	double a[3] = {6378249.2000 ,6378249.2000 ,6378249.2000};
 	double e[3] = {0.08248325679 ,0.08248325679 ,0.08248325679};
+    
+    YGPoint expected[3] = {
+        {6376064.6955,111294.6230,128984.7250, METER },
+        {6378232.2149,18553.5780,0, METER },
+        {6376897.5369,37099.7050,-202730.9070, METER }
+    };
 
 
 	unsigned int i;
 	for (i =0; i < 3;++i)
 	{
-		YGPoint pt  = geographic_to_cartesian(lon[i],lat[i],he[i],a[i],e[i]);
-		DISPLAY_POINT(pt);
+		YGPoint pt  = __YGGeographicToCartesian(lon[i],lat[i],he[i],a[i],e[i]);
+        CU_ASSERT(fabs(pt.x - expected[i].x) <= 1e-4);
+        CU_ASSERT(fabs(pt.y - expected[i].y) <= 1e-4);
+        CU_ASSERT(fabs(pt.z - expected[i].z) <= 1e-4);
+        
 	}
 
 }
@@ -75,8 +63,7 @@ void test_algo0021 (void)
 	double a = 6378388.0000;
 	double e = 0.081991890;
 
-	double calc = lambert_normal(lat,a,e);
-	printf("Expected:%.4f | Computed:%.4f\n",n,calc);
+	double calc = __YGLambertNormal(lat,a,e);
 	CU_ASSERT(n == truncate(calc,4));
 
 }
@@ -97,7 +84,7 @@ void test_algo0002(void)
 
 		for(index = 0;index < 3;index++)
 		{
-			double result = lat_from_lat_iso(lat_iso[index], e[index], eps[index]);
+			double result = __YGLatitudeFromLatitudeISO(lat_iso[index], e[index], eps[index]);
 			result = truncate(result,11);
 			CU_ASSERT(result == phi[index]);
 		}
@@ -124,7 +111,7 @@ void test_algo0012(void)
 	{
 		YGPoint sample = {x[i],y[i],z[i]};
 		YGPoint val ;
-		val = cartesian_to_geographic(sample,LON_MERID_PARIS,a[i],e[i],eps[i]);
+		val = __YGCartesianToGeographic(sample,LON_MERID_PARIS,a[i],e[i],eps[i]);
 		
 		// printf("X Computed:%.11f - Expected:%.11f\n",val.x,lon[i]);
 		CU_ASSERT(fabs(val.x - lon[i]) <= ign_eps);
@@ -144,39 +131,98 @@ void test_algo004(void)
 	YGPoint expected = {0.145512099,0.872664626};
 
 
-	lambert_to_geographic(&org,&dest, LAMBERT_I, LON_MERID_GREENWICH,E_CLARK_IGN,1e-9);
-	printf("Lat:%.9f - Lon:%.9f - Expected:Lat:%.9f - Lon:%.9f\n",dest.x,dest.y,expected.x,expected.y);
+	dest = __YGLambertToGeographic(org, LAMBERT_I, LON_MERID_GREENWICH,E_CLARK_IGN,1e-9);
+ 
 	CU_ASSERT(fabs(dest.x - expected.x) <= 1e-9);
 	CU_ASSERT(fabs(dest.y - expected.y) <= 1e-9);
 }
 
-
-void testBug2(void)
+void testBugLambert93(void)
 {
-	YGPoint org = {668832.5384,6950138.7285,0};
-	YGPoint dest = {0,0,0};
-	YGLambertZone zone= LAMBERT_93;
+	YGPoint org = YGMeterPoint(668832.5384,6950138.7285,0);
+    YGPoint expected = YGDegreePoint(2.56865, 49.64961, 0);
+	YGPoint dest;
+	YGLambertZone zone = LAMBERT_93;
 
-	lambert_to_wgs84_deg(&org,&dest,zone);
-	printf("Lat:%.9f - Lon:%.9f",dest.y,dest.x);
+	dest = YGPointConvertWGS84(org,zone);
+    dest = YGPointToDegree(dest);
+    
+	CU_ASSERT(fabs(dest.x - expected.x) <= 1e-5);
+  	CU_ASSERT(fabs(dest.y - expected.y) <= 1e-5);
 
 }
+
+
+void testZenithStrasbourg(void)
+{
+    YGPoint org = YGMeterPoint(994300.623,113409.981,0);
+    YGPoint expected = YGDegreePoint(7.68639475277068, 48.5953456709144, 0);
+	YGPoint dest;
+	YGLambertZone zone = LAMBERT_I;
+    
+	dest = YGPointConvertWGS84(org,zone);
+    dest = YGPointToDegree(dest);
+    
+	CU_ASSERT(fabs(dest.x - expected.x) <= 1e-5);
+  	CU_ASSERT(fabs(dest.y - expected.y) <= 1e-5);
+}
+void testBugLambertIIE(void)
+{
+    YGPoint org = YGMeterPoint(369419,1986498,0);
+    YGPoint expected = YGDegreePoint( -0.579117201473994,44.84071560809383, 0);
+	YGPoint dest;
+	YGLambertZone zone = LAMBERT_II_E;
+    
+	dest = YGPointConvertWGS84(org,zone);
+    dest = YGPointToDegree(dest);
+    
+	CU_ASSERT(fabs(dest.x - expected.x) <= 1e-4);
+  	CU_ASSERT(fabs(dest.y - expected.y) <= 1e-4);
+}
 void testOpenGrid(void)
 {	
-	YGPoint org = {.x=2.424971108, .y=48.844445839,.z=0,.unit=DEGREE};
-   
-    YGTransform tr = rgf93_to_ntf(org);
+	YGPoint org =  YGDegreePoint(2.424971108, 48.844445839,0);
+    
+    YGTransform tr = __YGTransformRGF93ToNTF(org);
     
     YGPoint t = {tr.tx,tr.ty,tr.tz};
-    YGPoint null= {0,0,0};
+    YGPoint null= {0,0,0,RADIAN};
+    
+    org = YGPointToRadian(org);
+    org =  __YGGeographicToCartesian(org.x,org.y,org.z,A_WGS84,E_WGS84);
+    
+    org =  __YGSwitchGeodesicSystem(org, t, 0, null);
+    org = __YGCartesianToGeographic(org, LON_MERID_PARIS, A_CLARK_IGN, E_CLARK_IGN, DEFAULT_EPS);
     
-    org = pointToRadian(org);
-    org =  geographic_to_cartesian(org.x,org.y,org.z,A_WGS84,E_WGS84);
+    org = YGPointToDegree(org);
     
-    org =  switch_geodesic_system(org, t, 0, null);
-    org = cartesian_to_geographic(org, LON_MERID_PARIS, A_CLARK_IGN, E_CLARK_IGN, DEFAULT_EPS);
+    printf("Point value :\n");
+}
+
+void test_RGF93_NTF_degree(void)
+{
+    YGPoint org =  YGDegreePoint(2.424971108, 48.844445839,0);
+    YGPoint expected = YGDegreePoint(2.42567186, 48.84451225, 0);
+    
+    
+    YGPoint dest = YGPointConvertRGF93_NTF(org);
+    CU_ASSERT(fabs(expected.x - dest.x) <= 1e-8);
+    CU_ASSERT(fabs(expected.y - dest.y) <= 1e-8);
+}
+
+void test_RGF93_NTF_degree_to_cartesian(void)
+{
+    YGPoint org =  YGDegreePoint(2.424971108, 48.844445839,0);
+    YGPoint expected = YGDegreePoint(606491.571, 127112.233, 0);
+    
+    
+    YGPoint dest = YGPointConvertRGF93_NTF(org);
+    dest = YGPointToRadian(dest);
+    
+
     
-    org = pointToDegree(org);
+    CU_ASSERT(fabs(expected.x - dest.x) <= 1e-3);
+    CU_ASSERT(fabs(expected.y - dest.y) <= 1e-3);
 }
 
 int main(int argc, char **argv){
@@ -194,17 +240,19 @@ int main(int argc, char **argv){
       return CU_get_error();
    }
 
-   /* add the tests to the suite */
+   /* add the tests to the suite testProjectionsecant*/
    if ( NULL == CU_add_test(pSuite, "Test Algo0002", test_algo0002) ||
         NULL == CU_add_test(pSuite, "Test Algo0012", test_algo0012) ||
         NULL == CU_add_test(pSuite,"Test Algo004",test_algo004)     ||
         NULL == CU_add_test(pSuite,"Test algo0021",test_algo0021)   ||
         NULL == CU_add_test(pSuite,"test_algo009",test_algo009)     ||
-        NULL == CU_add_test(pSuite,"test_lambert_deg",test_lambert_deg)     ||
-        NULL == CU_add_test(pSuite,"testBug2",testBug2)     ||
+       NULL == CU_add_test(pSuite,"Test Zenith Strasbourg",testZenithStrasbourg)             ||
+        NULL == CU_add_test(pSuite,"Test Bug Lambert 93",testBugLambert93)             ||
+       NULL == CU_add_test(pSuite,"Test Bug Lambert II E",testBugLambertIIE)             ||
         NULL == CU_add_test(pSuite,"testNTFRGF93",testOpenGrid)     ||
-        NULL == CU_add_test(pSuite, "Test lambert", test_lambert)
-      ) 
+        NULL == CU_add_test(pSuite, "Test  (Degree)RGF93 ->NTF (Degree)", test_RGF93_NTF_degree) ||
+        NULL == CU_add_test(pSuite, "Test  (Degree)RGF93 ->NTF (Meter)", test_RGF93_NTF_degree_to_cartesian)
+      )
    {
       CU_cleanup_registry();
       return CU_get_error();

data/ext/lambert_ruby/lambert_ruby.c

@@ -36,14 +36,13 @@ static VALUE p_convert(VALUE self,VALUE zone){
 	y = NUM2DBL(rb_iv_get(self,"@y"));
 	z = NUM2DBL(rb_iv_get(self,"@z"));
 
-	YGPoint org = {x,y,z};
-	YGPoint dest = {0,0,0};
+	YGPoint org = YGMeterPoint(x,y,z);
+	org = YGPointConvertWGS84(org,cZone);
+	org = YGPointToDegree(org);
 
-	lambert_to_wgs84_deg(&org,&dest,cZone);
-
-   rb_iv_set(self, "@x", rb_float_new(dest.x));
-   rb_iv_set(self, "@y", rb_float_new(dest.y));
-   rb_iv_set(self, "@z", rb_float_new(dest.z));
+   rb_iv_set(self, "@x", rb_float_new(org.x));
+   rb_iv_set(self, "@y", rb_float_new(org.y));
+   rb_iv_set(self, "@z", rb_float_new(org.z));
 
 
 	return Qnil;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lambert_ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Yannick Heinrich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-14 00:00:00.000000000 Z
+date: 2014-01-14 00:00:00.000000000 Z
 dependencies: []
 description: Ruby wrapper for the lambert library
 email: yannick.heinrich@gmail.com
@@ -36,17 +36,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper for the lambert library