lambert_ruby 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzM5YmI2MWY2OWFhZTVlZmE4ODQ1NGU5YWYzZmU3NGYwNjljYzY3ZQ==
+  data.tar.gz: !binary |-
+    YWM1NWNiNTBlOWIyMGMzZDFjNGYyZmIyZGVjZTEwMjZmYmE1NDk3MA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YmI2ZmIwNDkxMjk2YjMwYTQzY2I3OTY0MTE0MmI1NWNjNjVhMjg3M2QyYmVh
+    MmY5ODVkNjQ0M2IwMzE0ZmQzYjcxZDJhNjU2ZDQzNGI3NTA5YTNiODE1MTc4
+    YzA5YzQ3MGY5YTI0ZGViZWEzNjBiZTg1YmNkNDU3OGVhYWQxOWE=
+  data.tar.gz: !binary |-
+    NTUzODYwZmQyYzQ2YTMwY2I4MDE2ZjRjOThlOTVhN2YxYzQwYWQyMDUwZjIw
+    YmU5MzRkN2EzNWU1N2VkNzBhMjU3ZGY0ZTE4MmY4M2IxM2IyOGFhY2ZjMDJi
+    ODVjMTg4NjM4Zjk3YWUyOWYwOTgxOTJlOTgwZWNhNzYzMzM0MWE=

data/ext/lambert_ruby/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('lambert_ruby/lambert_ruby')

data/ext/lambert_ruby/lambert.c

@@ -0,0 +1,171 @@
+/*
+ *	Source des algorithmes : http://geodesie.ign.fr/contenu/fichiers/documentation/algorithmes/notice/NTG_71.pdf
+ *  
+*/
+
+#include "lambert.h"
+#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};
+
+
+/* 
+ * ALGO0002
+ */
+
+double lat_from_lat_iso(double lat_iso, double e,double eps)
+{
+
+	double phi_0 =  2*atan(exp(lat_iso)) - M_PI_2;
+	double phi_i = 2*atan(pow((1+e*sin(phi_0))/(1-e*sin(phi_0)),e/2.0)*exp(lat_iso)) - M_PI_2;
+	double delta ; 
+	while(delta = fabs(phi_i - phi_0),delta > eps)
+	{	
+		phi_0 = phi_i;
+		phi_i = 2*atan(pow((1+e*sin(phi_0))/(1-e*sin(phi_0)),e/2.0)*exp(lat_iso)) - M_PI_2;
+	}
+
+	return phi_i;
+
+}
+/*
+*	ALGO0004 - Lambert vers geographiques
+*/
+
+void lambert_to_geographic(const YGLambertPoint * org,YGLambertPoint *dest, LambertZone 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 lon, gamma, R, lat_iso;
+
+	R = sqrt((x-x_s)*(x-x_s)+(y-y_s)*(y-y_s));
+
+	gamma = atan((x-x_s)/(y_s-y));
+
+	lon = lon_merid + gamma/n;
+
+	lat_iso = -1/n*log(fabs(R/C));
+
+	double lat = lat_from_lat_iso(lat_iso,e,eps);
+
+	dest->x = lon;
+	dest->y = lat;
+}
+
+
+/*
+ * ALGO0021 - Calcul de la grande Normale 
+ *
+*/
+
+double lambert_normal(double lat, double a, double e)
+{
+
+	return a/sqrt(1-e*e*sin(lat)*sin(lat));
+}
+
+/**
+ * ALGO0009 - Transformations geographiques -> cartésiennes
+ *
+ *
+ */
+
+ YGLambertPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e)
+ {
+ 	double N = lambert_normal(lat,a,e);
+ 	
+ 	YGLambertPoint pt = {0,0,0};
+ 	pt.x = (N+he)*cos(lat)*cos(lon);
+
+ 	pt.y = (N+he)*cos(lat)*sin(lon);
+
+ 	pt.z = (N*(1-e*e)+he)*sin(lat);
+
+ 	return pt;
+
+ }
+
+/*
+ * ALGO0012 - Passage des coordonnées cartésiennes aux coordonnées géographiques
+ */
+
+ YGLambertPoint cartesian_to_geographic(YGLambertPoint org, double meridien, double a, double e , double eps)
+ {
+ 	double x = org.x, y = org.y, z = org.z;
+
+ 	double lon = meridien + atan(y/x);
+
+ 	double module = sqrt(x*x + y*y);
+
+ 	double phi_0 = atan(z/(module*(1-(a*e*e)/sqrt(x*x+y*y+z*z))));
+ 	double phi_i = atan(z/module/(1-a*e*e*cos(phi_0)/(module * sqrt(1-e*e*sin(phi_0)*sin(phi_0)))));
+ 	double delta;
+ 	while(delta = fabs(phi_i - phi_0),delta > eps)
+ 	{
+ 		phi_0 = phi_i;
+ 		phi_i = atan(z/module/(1-a*e*e*cos(phi_0)/(module * sqrt(1-e*e*sin(phi_0)*sin(phi_0)))));
+
+ 	}
+ 	
+ 	double he = module/cos(phi_i) - a/sqrt(1-e*e*sin(phi_i)*sin(phi_i));
+ 	
+ 	YGLambertPoint pt;
+ 	pt.x = lon;
+ 	pt.y = phi_i;
+ 	pt.z = he;
+
+ 	return pt;
+ }
+
+
+
+/*
+ * Convert Lambert -> WGS84
+ * http://geodesie.ign.fr/contenu/fichiers/documentation/pedagogiques/transfo.pdf
+ *
+ */
+
+void lambert_to_wgs84(const YGLambertPoint * org, YGLambertPoint *dest,LambertZone zone){
+
+	lambert_to_geographic(org,dest,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
+
+	 YGLambertPoint temp = geographic_to_cartesian(dest->x,dest->y,dest->z,A_CLARK_IGN,E_CLARK_IGN);
+
+	 temp.x= temp.x - 168;
+	 temp.y= temp.y - 60;
+	 temp.z= temp.z + 320;
+
+	 //WGS84 refers to greenwich
+	 temp = cartesian_to_geographic(temp, LON_MERID_GREENWICH, A_WGS84,E_WGS84,DEFAULT_EPS);
+
+	 dest->x = temp.x;
+	 dest->y = temp.y;
+
+}
+
+
+void lambert_to_wgs84_deg(const YGLambertPoint * org, YGLambertPoint *dest, LambertZone zone)
+{
+	YGLambertPoint temp = {0,0,0};
+	
+	lambert_to_wgs84(org,&temp,zone);
+
+	dest->x = temp.x * 180/M_PI;
+	dest->y = temp.y * 180/M_PI;
+	dest->z = temp.z * 180/M_PI;
+}

data/ext/lambert_ruby/lambert.h

@@ -0,0 +1,71 @@
+#define DEFAULT_EPS 1e-10
+#define E_CLARK_IGN 0.08248325676
+#define E_WGS84 0.08181919106
+
+#define A_CLARK_IGN 6378249.2
+#define A_WGS84 6378137.0
+
+#define LON_MERID_PARIS 0
+#define LON_MERID_GREENWICH 0.04079234433
+
+#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);
+
+typedef enum {
+	LAMBERT_I=0,
+	LAMBERT_II=1,
+	LAMBERT_III=2,
+	LAMBERT_IV=3,
+	LAMBERT_II_E=4,
+	LAMBERT_93= 5
+} LambertZone;
+
+typedef struct {
+	double x;
+	double y;
+	double z;
+} YGLambertPoint;
+
+
+/*
+ * ALGO0021 - Calcul de la grande Normale 
+ *
+*/
+double lambert_normal(double lat, double a, double e);
+
+/*
+ * Convert a YGLambertPoint struct from one lambert zone to WGS84 (Rad)
+ *
+ */
+void lambert_to_wgs84(const YGLambertPoint * org, YGLambertPoint *dest, LambertZone zone);
+
+/*
+ * Convert a YGLambertPoint struct from one lambert zone to WGS84 (Deg)
+ *
+ */
+void lambert_to_wgs84_deg(const YGLambertPoint * org, YGLambertPoint *dest, LambertZone zone);
+
+/*
+ * ALGO0002
+ */
+
+double lat_from_lat_iso(double lat_iso, double e, double eps);
+
+/*
+* ALGO0012
+*/
+
+YGLambertPoint cartesian_to_geographic(YGLambertPoint org, double meridien, double a, double e , double eps);
+
+/*
+ * ALGO004
+ */
+void lambert_to_geographic(const YGLambertPoint * org,YGLambertPoint *dest, LambertZone zone, double lon_merid, double e, double eps);
+
+/**
+ * ALGO0009 - Transformations geographiques -> cartésiennes
+ *
+ *
+ */
+
+ YGLambertPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e);

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

@@ -0,0 +1,171 @@
+/*
+ *	Source des algorithmes : http://geodesie.ign.fr/contenu/fichiers/documentation/algorithmes/notice/NTG_71.pdf
+ *  
+*/
+
+#include "lambert.h"
+#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};
+
+
+/* 
+ * ALGO0002
+ */
+
+double lat_from_lat_iso(double lat_iso, double e,double eps)
+{
+
+	double phi_0 =  2*atan(exp(lat_iso)) - M_PI_2;
+	double phi_i = 2*atan(pow((1+e*sin(phi_0))/(1-e*sin(phi_0)),e/2.0)*exp(lat_iso)) - M_PI_2;
+	double delta ; 
+	while(delta = fabs(phi_i - phi_0),delta > eps)
+	{	
+		phi_0 = phi_i;
+		phi_i = 2*atan(pow((1+e*sin(phi_0))/(1-e*sin(phi_0)),e/2.0)*exp(lat_iso)) - M_PI_2;
+	}
+
+	return phi_i;
+
+}
+/*
+*	ALGO0004 - Lambert vers geographiques
+*/
+
+void lambert_to_geographic(const YGLambertPoint * org,YGLambertPoint *dest, LambertZone 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 lon, gamma, R, lat_iso;
+
+	R = sqrt((x-x_s)*(x-x_s)+(y-y_s)*(y-y_s));
+
+	gamma = atan((x-x_s)/(y_s-y));
+
+	lon = lon_merid + gamma/n;
+
+	lat_iso = -1/n*log(fabs(R/C));
+
+	double lat = lat_from_lat_iso(lat_iso,e,eps);
+
+	dest->x = lon;
+	dest->y = lat;
+}
+
+
+/*
+ * ALGO0021 - Calcul de la grande Normale 
+ *
+*/
+
+double lambert_normal(double lat, double a, double e)
+{
+
+	return a/sqrt(1-e*e*sin(lat)*sin(lat));
+}
+
+/**
+ * ALGO0009 - Transformations geographiques -> cartésiennes
+ *
+ *
+ */
+
+ YGLambertPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e)
+ {
+ 	double N = lambert_normal(lat,a,e);
+ 	
+ 	YGLambertPoint pt = {0,0,0};
+ 	pt.x = (N+he)*cos(lat)*cos(lon);
+
+ 	pt.y = (N+he)*cos(lat)*sin(lon);
+
+ 	pt.z = (N*(1-e*e)+he)*sin(lat);
+
+ 	return pt;
+
+ }
+
+/*
+ * ALGO0012 - Passage des coordonnées cartésiennes aux coordonnées géographiques
+ */
+
+ YGLambertPoint cartesian_to_geographic(YGLambertPoint org, double meridien, double a, double e , double eps)
+ {
+ 	double x = org.x, y = org.y, z = org.z;
+
+ 	double lon = meridien + atan(y/x);
+
+ 	double module = sqrt(x*x + y*y);
+
+ 	double phi_0 = atan(z/(module*(1-(a*e*e)/sqrt(x*x+y*y+z*z))));
+ 	double phi_i = atan(z/module/(1-a*e*e*cos(phi_0)/(module * sqrt(1-e*e*sin(phi_0)*sin(phi_0)))));
+ 	double delta;
+ 	while(delta = fabs(phi_i - phi_0),delta > eps)
+ 	{
+ 		phi_0 = phi_i;
+ 		phi_i = atan(z/module/(1-a*e*e*cos(phi_0)/(module * sqrt(1-e*e*sin(phi_0)*sin(phi_0)))));
+
+ 	}
+ 	
+ 	double he = module/cos(phi_i) - a/sqrt(1-e*e*sin(phi_i)*sin(phi_i));
+ 	
+ 	YGLambertPoint pt;
+ 	pt.x = lon;
+ 	pt.y = phi_i;
+ 	pt.z = he;
+
+ 	return pt;
+ }
+
+
+
+/*
+ * Convert Lambert -> WGS84
+ * http://geodesie.ign.fr/contenu/fichiers/documentation/pedagogiques/transfo.pdf
+ *
+ */
+
+void lambert_to_wgs84(const YGLambertPoint * org, YGLambertPoint *dest,LambertZone zone){
+
+	lambert_to_geographic(org,dest,zone,LON_MERID_PARIS,E_CLARK_IGN,DEFAULT_EPS);
+
+	 YGLambertPoint temp = geographic_to_cartesian(dest->x,dest->y,dest->z,A_CLARK_IGN,E_CLARK_IGN);
+
+	 temp.x= temp.x - 168;
+	 temp.y= temp.y - 60;
+	 temp.z= temp.z + 320;
+
+	 //WGS84 refers to greenwich
+	 temp = cartesian_to_geographic(temp, LON_MERID_GREENWICH, A_WGS84,E_WGS84,DEFAULT_EPS);
+
+	 dest->x = temp.x;
+	 dest->y = temp.y;
+
+}
+
+
+void lambert_to_wgs84_deg(const YGLambertPoint * org, YGLambertPoint *dest, LambertZone zone)
+{
+	YGLambertPoint temp = {0,0,0};
+	
+	lambert_to_wgs84(org,&temp,zone);
+
+	dest->x = temp.x * 180/M_PI;
+	dest->y = temp.y * 180/M_PI;
+	dest->z = temp.z * 180/M_PI;
+}

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

@@ -0,0 +1,71 @@
+#define DEFAULT_EPS 1e-10
+#define E_CLARK_IGN 0.08248325676
+#define E_WGS84 0.08181919106
+
+#define A_CLARK_IGN 6378249.2
+#define A_WGS84 6378137.0
+
+#define LON_MERID_PARIS 0
+#define LON_MERID_GREENWICH 0.04079234433
+
+#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);
+
+typedef enum {
+	LAMBERT_I=0,
+	LAMBERT_II=1,
+	LAMBERT_III=2,
+	LAMBERT_IV=3,
+	LAMBERT_II_E=4,
+	LAMBERT_93= 5
+} LambertZone;
+
+typedef struct {
+	double x;
+	double y;
+	double z;
+} YGLambertPoint;
+
+
+/*
+ * ALGO0021 - Calcul de la grande Normale 
+ *
+*/
+double lambert_normal(double lat, double a, double e);
+
+/*
+ * Convert a YGLambertPoint struct from one lambert zone to WGS84 (Rad)
+ *
+ */
+void lambert_to_wgs84(const YGLambertPoint * org, YGLambertPoint *dest, LambertZone zone);
+
+/*
+ * Convert a YGLambertPoint struct from one lambert zone to WGS84 (Deg)
+ *
+ */
+void lambert_to_wgs84_deg(const YGLambertPoint * org, YGLambertPoint *dest, LambertZone zone);
+
+/*
+ * ALGO0002
+ */
+
+double lat_from_lat_iso(double lat_iso, double e, double eps);
+
+/*
+* ALGO0012
+*/
+
+YGLambertPoint cartesian_to_geographic(YGLambertPoint org, double meridien, double a, double e , double eps);
+
+/*
+ * ALGO004
+ */
+void lambert_to_geographic(const YGLambertPoint * org,YGLambertPoint *dest, LambertZone zone, double lon_merid, double e, double eps);
+
+/**
+ * ALGO0009 - Transformations geographiques -> cartésiennes
+ *
+ *
+ */
+
+ YGLambertPoint geographic_to_cartesian(double lon, double lat, double he, double a, double e);

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

@@ -0,0 +1,195 @@
+#include <CUnit/Basic.h>
+#include <CUnit/Console.h>
+#include <CUnit/Automated.h>
+#include <math.h>
+#include <stdlib.h>
+#include "../src/lambert.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; }
+int clean_suite_success(void) { return 0; }
+int clean_suite_failure(void) { return -1; }
+
+char buffer[20];
+char format[20];
+
+double truncate(double val, int n)
+{
+	sprintf(format,"%%.%df",n);
+	sprintf(buffer,format,val);
+	return atof(buffer);
+
+}
+
+double rounded_down(double val,int n){
+	double p = pow(10,n);
+	return floorf(val*p)/p;
+}
+
+void test_lambert_deg(void)
+{
+	YGLambertPoint org = {999534.581,112186.569,0};
+	YGLambertPoint dest = {0,0,0};
+	LambertZone 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)
+{
+
+	YGLambertPoint org = {999534.581,112186.569,0};
+	YGLambertPoint dest = {0,0,0};
+	LambertZone zone = LAMBERT_I;
+
+	lambert_to_wgs84(&org, &dest, zone);
+
+}
+
+void test_algo009(void)
+{	
+	double lon[3] = {0.01745329248 ,0.00290888212 ,0.00581776423};
+	double lat[3] = {0.02036217457,0.00000000000 ,-0.03199770300};
+	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};
+
+
+	unsigned int i;
+	for (i =0; i < 3;++i)
+	{
+		YGLambertPoint pt  = geographic_to_cartesian(lon[i],lat[i],he[i],a[i],e[i]);
+		DISPLAY_POINT(pt);
+	}
+
+}
+
+void test_algo0021 (void)
+
+{
+	double n = 6393174.9755;
+	double lat = 0.97738438100;
+	double a = 6378388.0000;
+	double e = 0.081991890;
+
+	double calc = lambert_normal(lat,a,e);
+	printf("Expected:%.4f | Computed:%.4f\n",n,calc);
+	CU_ASSERT(n == truncate(calc,4));
+
+}
+void test_algo0002(void)
+{
+
+	/*
+	* See IGN "Jeux d'essai"
+	*/
+
+	double lat_iso[3] = {1.00552653648,-0.30261690060 ,0.2000000000};
+	double e[3] = {0.08199188998,0.08199188998,0.08199188998};
+	double eps[3] = {1.0e-11,1.0e-11,1.0e-11};
+
+	double phi[3] = {0.87266462600, -0.29999999997 ,0.19998903369};
+
+	unsigned int index;
+
+		for(index = 0;index < 3;index++)
+		{
+			double result = lat_from_lat_iso(lat_iso[index], e[index], eps[index]);
+			result = truncate(result,11);
+			CU_ASSERT(result == phi[index]);
+		}
+}
+
+
+void test_algo0012(void)
+{
+
+	double a[3] = {6378249.2000, 6378249.2000 ,6378249.2000};
+	double e[3] = {0.08248325679, 0.08248325679, 0.08248325679};
+	double x[3] = {6376064.6950, 6378232.2150, 6376897.5370};
+	double y[3] = {111294.6230, 18553.5780, 37099.7050};
+	double z[3] = {128984.7250, 0.0000, -202730.9070};
+	double eps[3] = {1e-11,1e-11,1e-11};
+
+	double lon[3] = {0.01745329248, 0.00290888212, 0.00581776423};
+	double lat[3] = {0.02036217457, 0.00000000000, -0.03199770301};
+	double he[3] = {99.9995, 10.0001, 2000.0001};
+
+	unsigned int i;
+	 double ign_eps = 1e-11;
+	for(i=0; i < 3;++i)
+	{
+		YGLambertPoint sample = {x[i],y[i],z[i]};
+		YGLambertPoint val ;
+		val = cartesian_to_geographic(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);
+		// printf("Y Computed:%.11f - Expected:%.11f\n",val.y,lat[i]);
+		CU_ASSERT(fabs(val.y - lat[i]) <= ign_eps);
+		// printf("Z Computed:%.11f - Expected:%.11f\n",val.z,he[i]);
+		CU_ASSERT(truncate(val.z,4) == he[i] ) ;
+	}
+
+
+}
+void test_algo004(void)
+{
+
+	YGLambertPoint org = {1029705.083,272723.849,0};
+	YGLambertPoint dest = {0,0,0};
+	YGLambertPoint 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);
+	CU_ASSERT(fabs(dest.x - expected.x) <= 1e-9);
+	CU_ASSERT(fabs(dest.y - expected.y) <= 1e-9);
+}
+
+int main(int argc, char **argv){
+
+	CU_pSuite pSuite = NULL;
+
+   /* initialize the CUnit test registry */
+   if (CUE_SUCCESS != CU_initialize_registry())
+      return CU_get_error();
+
+  /* add a suite to the registry */
+   pSuite = CU_add_suite("Suite_success", init_suite_success, clean_suite_success);
+   if (NULL == pSuite) {
+      CU_cleanup_registry();
+      return CU_get_error();
+   }
+
+   /* add the tests to the suite */
+   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_algo009",test_lambert_deg)     ||
+        NULL == CU_add_test(pSuite, "Test lambert", test_lambert)
+      ) 
+   {
+      CU_cleanup_registry();
+      return CU_get_error();
+   }
+
+     CU_basic_set_mode(CU_BRM_VERBOSE);
+ 	 CU_basic_run_tests();
+     // CU_automated_run_tests();
+  
+     CU_list_tests_to_file();
+
+
+      /* Clean up registry and return */
+   CU_cleanup_registry();
+   return CU_get_error();
+	
+        return 0;
+
+}

data/ext/lambert_ruby/lambert_ruby.c

@@ -0,0 +1,69 @@
+#include <ruby.h>
+#include "lambert.h"
+
+static VALUE rb_mLambert;
+static VALUE rb_cPoint;
+
+static VALUE p_init(int argc, VALUE* argv, VALUE self)
+{
+
+  VALUE x, y, z;
+
+  rb_scan_args(argc,argv, "21",&x, &y, &z);
+
+  if(NIL_P(z))
+  {
+  	z = rb_float_new(0.0);
+  }
+
+  Check_Type(x,T_FLOAT);
+  Check_Type(y,T_FLOAT);
+  Check_Type(z,T_FLOAT);
+
+  rb_iv_set(self, "@x", x);
+  rb_iv_set(self, "@y", y);
+  rb_iv_set(self, "@z", z);
+
+  return self;
+}
+
+static VALUE p_convert(VALUE self,VALUE zone){
+
+	double x, y, z;
+	LambertZone cZone = NUM2INT(zone);
+
+	x = NUM2DBL(rb_iv_get(self,"@x"));
+	y = NUM2DBL(rb_iv_get(self,"@y"));
+	z = NUM2DBL(rb_iv_get(self,"@z"));
+
+	YGLambertPoint org = {x,y,z};
+	YGLambertPoint dest = {0,0,0};
+
+	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));
+
+
+	return Qnil;
+}
+
+void Init_lambert_ruby(void) {
+
+	rb_mLambert = rb_define_module("Lambert");
+	rb_cPoint = rb_define_class_under(rb_mLambert,"LambertPoint",rb_cObject);
+	rb_define_attr(rb_cPoint,"x",1,1);
+	rb_define_attr(rb_cPoint,"y",1,1);
+	rb_define_attr(rb_cPoint,"z",1,1);
+
+	rb_define_method(rb_cPoint,"initialize",p_init,-1);
+	rb_define_method(rb_cPoint,"wgs84",p_convert,1);
+
+	rb_define_const(rb_mLambert,"LambertI",INT2NUM(LAMBERT_I));
+	rb_define_const(rb_mLambert,"LambertII",INT2NUM(LAMBERT_II));
+	rb_define_const(rb_mLambert,"LambertIII",INT2NUM(LAMBERT_III));
+	rb_define_const(rb_mLambert,"LambertIV",INT2NUM(LAMBERT_IV));
+	rb_define_const(rb_mLambert,"LambertIIExtended",INT2NUM(LAMBERT_II_E));
+	rb_define_const(rb_mLambert,"Lambert93",INT2NUM(LAMBERT_93));
+}

data/lib/lambert_ruby.rb

@@ -0,0 +1 @@
+require 'lambert_ruby/lambert_ruby'

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: lambert_ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yannick Heinrich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-24 00:00:00.000000000 Z
+dependencies: []
+description: Ruby wrapper for the lambert library that converts Lambert coordinates
+  to WGS84. It wraps the original C files with a basic Ruby interface.
+email: yannick.heinrich@gmail.com
+executables: []
+extensions:
+- ext/lambert_ruby/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/lambert_ruby.rb
+- ext/lambert_ruby/lambert/src/lambert.c
+- ext/lambert_ruby/lambert/tests/test_lambert_cunit.c
+- ext/lambert_ruby/lambert.c
+- ext/lambert_ruby/lambert_ruby.c
+- ext/lambert_ruby/lambert/src/lambert.h
+- ext/lambert_ruby/lambert.h
+- ext/lambert_ruby/extconf.rb
+homepage: https://github.com/YaGeek/lambert-ruby
+licenses:
+- GPL-2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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
+signing_key: 
+specification_version: 4
+summary: Ruby wrapper for the lambert library that converts Lambert coordinates to
+  WGS84
+test_files: []