lambert_ruby 1.0.2-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9fb6c2ea302dfac3ec209ad6a6ccc05a9ff8eb82
+  data.tar.gz: b905b80807d1f4ef9334e8d403446a746eb3dfbd
+SHA512:
+  metadata.gz: c8687464d66c2d32e96e95dc8dbfc7181a7745217a7e976234e1923706885ff9598766c07dbf37fa08cf68c56015d0bb61eddbefdab79f847eabe345437f4d36
+  data.tar.gz: f48c7314cf8acce07fcc9790cac5cdb65eaacec995f9015414af79f80d78e8bdc73fec392da734d101f2e30e5de882c9272b5a9c01e5f6e5cfece6fdfcf9c83d

data/ext/lambert_ruby/Lambert.java

@@ -0,0 +1,158 @@
+package net.yageek.lambert;
+
+
+import static java.lang.Math.*;
+import static net.yageek.lambert.LambertZone.*;
+
+public class Lambert {
+
+ /*
+ *   ALGO0002
+ */
+ private static double latitudeFromLatitudeISO(double latISo, double e, double eps)
+    {
+
+        double phi0 =  2* atan(exp(latISo)) - M_PI_2;
+        double phiI = 2*atan(pow((1+e*sin(phi0))/(1-e*sin(phi0)),e/2.0)*exp(latISo)) - M_PI_2;
+        double delta = abs(phiI - phi0);
+
+        while(delta > eps)
+        {
+            phi0 = phiI;
+            phiI = 2*atan(pow((1+e*sin(phi0))/(1-e*sin(phi0)),e/2.0)*exp(latISo)) - M_PI_2;
+            delta = abs(phiI - phi0);
+        }
+
+        return phiI;
+
+    }
+
+/*
+*	ALGO0004 - Lambert vers geographiques
+*/
+
+    private static LambertPoint lambertToGeographic(LambertPoint org, LambertZone zone, double lonMeridian, double e, double eps)
+    {
+        double n = zone.n();
+        double C = zone.c();
+        double xs = zone.xs();
+        double ys = zone.ys();
+
+        double x = org.getX();
+        double y = org.getY();
+
+
+        double lon, gamma, R, latIso;
+
+        R = sqrt((x - xs) * (x - xs) + (y - ys) * (y - ys));
+
+        gamma = atan((x-xs)/(ys-y));
+
+        lon = lonMeridian + gamma/n;
+
+        latIso = -1/n*log(abs(R/C));
+
+        double lat = latitudeFromLatitudeISO(latIso, e, eps);
+
+        LambertPoint dest = new LambertPoint(lon,lat,0);
+        return dest;
+    }
+
+ /*
+ * ALGO0021 - Calcul de la grande Normale
+ *
+*/
+
+    private static double lambertNormal(double lat, double a, double e)
+    {
+
+        return a/sqrt(1-e*e*sin(lat)*sin(lat));
+    }
+
+    /*
+     * ALGO0009 - Transformations geographiques -> cartésiennes
+     *
+     */
+
+    private static LambertPoint geographicToCartesian(double lon, double lat, double he, double a, double e)
+    {
+        double N = lambertNormal(lat, a, e);
+
+        LambertPoint pt = new LambertPoint(0,0,0);
+
+        pt.setX((N+he)*cos(lat)*cos(lon));
+        pt.setY((N+he)*cos(lat)*sin(lon));
+        pt.setZ((N*(1-e*e)+he)*sin(lat));
+
+        return pt;
+
+    }
+
+    /*
+ * ALGO0012 - Passage des coordonnées cartésiennes aux coordonnées géographiques
+ */
+
+    private static LambertPoint cartesianToGeographic(LambertPoint org, double meridien, double a, double e, double eps)
+    {
+        double x = org.getX(), y = org.getY(), z = org.getZ();
+
+        double lon = meridien + atan(y/x);
+
+        double module = sqrt(x*x + y*y);
+
+        double phi0 = atan(z/(module*(1-(a*e*e)/sqrt(x*x+y*y+z*z))));
+        double phiI = atan(z/module/(1-a*e*e*cos(phi0)/(module * sqrt(1-e*e*sin(phi0)*sin(phi0)))));
+        double delta= abs(phiI - phi0);
+        while(delta > eps)
+        {
+            phi0 = phiI;
+            phiI = atan(z/module/(1-a*e*e*cos(phi0)/(module * sqrt(1-e*e*sin(phi0)*sin(phi0)))));
+            delta= abs(phiI - phi0);
+
+        }
+
+        double he = module/cos(phiI) - a/sqrt(1-e*e*sin(phiI)*sin(phiI));
+
+        LambertPoint pt = new LambertPoint(lon,phiI,he);
+
+        return pt;
+    }
+     /*
+ * Convert Lambert -> WGS84
+ * http://geodesie.ign.fr/contenu/fichiers/documentation/pedagogiques/transfo.pdf
+ *
+ */
+
+    public static LambertPoint convertToWGS84(LambertPoint org, LambertZone zone){
+
+        if(zone == Lambert93)
+        {
+         return lambertToGeographic(org,Lambert93,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
+        }
+        else {
+            LambertPoint pt1 =  lambertToGeographic(org, zone, LON_MERID_PARIS, E_CLARK_IGN, DEFAULT_EPS);
+
+            LambertPoint pt2 = geographicToCartesian(pt1.getX(), pt1.getY(), pt1.getZ(), A_CLARK_IGN, E_CLARK_IGN);
+
+            pt2.translate(-168,-60,320);
+
+            //WGS84 refers to greenwich
+            return cartesianToGeographic(pt2, LON_MERID_GREENWICH, A_WGS84, E_WGS84, DEFAULT_EPS);
+        }
+    }
+
+    public static LambertPoint convertToWGS84(double x, double y, LambertZone zone){
+
+        LambertPoint pt = new LambertPoint(x,y,0);
+        return convertToWGS84(pt, zone);
+    }
+
+    public static LambertPoint convertToWGS84Deg(double x, double y, LambertZone zone){
+
+        LambertPoint pt = new LambertPoint(x,y,0);
+        return convertToWGS84(pt, zone).toDegree();
+    }
+
+}
+
+

data/ext/lambert_ruby/LambertPoint.java

@@ -0,0 +1,52 @@
+package net.yageek.lambert;
+
+public class LambertPoint {
+
+    private double x;
+    private double y;
+    private double z;
+
+    public LambertPoint(double x, double y , double z){
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    public double getX() {
+        return x;
+    }
+
+    public void setX(double x) {
+        this.x = x;
+    }
+
+   public double getY() {
+        return y;
+    }
+
+   public void setY(double y) {
+        this.y = y;
+    }
+
+    public double getZ() {
+        return z;
+    }
+
+    public void setZ(double z) {
+        this.z = z;
+    }
+
+    public void translate(double x , double y, double z){
+
+        this.x+= x;
+        this.y+= y;
+        this.z+= z;
+    }
+
+    public LambertPoint toDegree(){
+        this.x = this.x * 180/Math.PI;
+        this.y = this.y * 180/Math.PI;
+        this.z = this.z * 180/Math.PI;
+
+        return this;
+    }
+}

data/ext/lambert_ruby/LambertRubyService.java

@@ -0,0 +1,101 @@
+package com.yageek.lambertruby;
+
+
+import java.lang.Long;
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyClass;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class LambertRubyService implements BasicLibraryService {
+
+  private Ruby runtime;
+
+  public boolean basicLoad(Ruby runtime) throws IOException {
+    this.runtime = runtime;
+
+    RubyModule lambert = runtime.defineModule("Lambert");
+
+    lambert.defineConstant("LambertI", runtime.newFixnum(0));
+    lambert.defineConstant("LambertII", runtime.newFixnum(1));
+    lambert.defineConstant("LambertIII", runtime.newFixnum(2));
+    lambert.defineConstant("LambertIV", runtime.newFixnum(3));
+    lambert.defineConstant("LambertIIExtended", runtime.newFixnum(4));
+    lambert.defineConstant("Lambert93", runtime.newFixnum(5));
+
+    RubyClass lambertPoint = lambert.defineClassUnder("LambertPoint",runtime.getObject(), new ObjectAllocator() {
+
+      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass){
+
+        return new LambertPointRuby(runtime, rubyClass);
+  }
+
+    });
+
+    lambertPoint.defineAnnotatedMethods(LambertPointRuby.class);
+    lambertPoint.addReadAttribute(runtime.getCurrentContext(), "x");
+    lambertPoint.addReadAttribute(runtime.getCurrentContext(), "y");
+    lambertPoint.addReadAttribute(runtime.getCurrentContext(), "z");
+
+       return true;
+  }
+
+  @JRubyClass(name = "Lambert::LambertPoint")
+  public class LambertPointRuby extends RubyObject{
+
+    public LambertPointRuby(final Ruby runtime, RubyClass rubyClass){
+      super(runtime, rubyClass);
+
+    }
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context, IRubyObject x, IRubyObject y, IRubyObject z){
+
+      setInstanceVariable("@x", x);
+      setInstanceVariable("@y", y);
+      setInstanceVariable("@z", z);
+
+        return context.nil;
+    }
+
+    @JRubyMethod
+    public void wgs84(ThreadContext context, IRubyObject zone){
+
+      int zoneInt = (int) zone.convertToInteger().getLongValue();
+
+      net.yageek.lambert.LambertZone jZone = net.yageek.lambert.LambertZone.Lambert93;
+      switch(((int) zoneInt)){
+        case 0: jZone = net.yageek.lambert.LambertZone.LambertI; break;
+        case 1: jZone = net.yageek.lambert.LambertZone.LambertII; break;
+        case 2: jZone = net.yageek.lambert.LambertZone.LambertIII; break;
+        case 3: jZone = net.yageek.lambert.LambertZone.LambertIV; break;
+        case 4: jZone = net.yageek.lambert.LambertZone.LambertIIExtended; break;
+        case 5: jZone = net.yageek.lambert.LambertZone.Lambert93; break;
+        default:
+      }
+
+      double x = getInstanceVariable("@x").convertToFloat().getDoubleValue();
+      double y = getInstanceVariable("@y").convertToFloat().getDoubleValue();
+      double z = getInstanceVariable("@z").convertToFloat().getDoubleValue();
+
+      net.yageek.lambert.LambertPoint val = new net.yageek.lambert.LambertPoint(x, y, z);
+      net.yageek.lambert.LambertPoint convertedVal = net.yageek.lambert.Lambert.convertToWGS84(val, jZone);
+      convertedVal.toDegree();
+
+      setInstanceVariable("@x",runtime.newFloat(convertedVal.getX()));
+      setInstanceVariable("@y",runtime.newFloat(convertedVal.getY()));
+      setInstanceVariable("@z",runtime.newFloat(convertedVal.getZ()));
+
+    }
+
+  }
+  }

data/ext/lambert_ruby/LambertZone.java

@@ -0,0 +1,45 @@
+
+package net.yageek.lambert;
+
+public enum LambertZone{
+	
+	LambertI(0),LambertII(1),	LambertIII(2),	LambertIV(3),	LambertIIExtended(4),Lambert93(5);
+	private final int lambertZone;
+
+	private final static double[] LAMBERT_N = {0.7604059656, 0.7289686274, 0.6959127966, 0.6712679322, 0.7289686274, 0.7256077650};
+	private final static double[] LAMBERT_C = {11603796.98, 11745793.39, 11947992.52, 12136281.99, 11745793.39, 11754255.426};
+	private final static double[] LAMBERT_XS = {600000.0, 600000.0, 600000.0, 234.358, 600000.0, 700000.0};
+	private final static double[] LAMBERT_YS = {5657616.674, 6199695.768, 6791905.085, 7239161.542, 8199695.768, 12655612.050};
+
+    public final static double M_PI_2 = Math.PI/2.0;
+    public final static double DEFAULT_EPS = 1e-10 ;
+    public final static double E_CLARK_IGN =  0.08248325676  ;
+    public final static double E_WGS84 =  0.08181919106  ;
+
+    public final static double A_CLARK_IGN = 6378249.2 ;
+    public final static double A_WGS84 =  6378137.0  ;
+    public final static double LON_MERID_PARIS = 0  ;
+    public final static double LON_MERID_GREENWICH =0.04079234433 ;
+    public final static double LON_MERID_IERS = 3.0*Math.PI/180.0;
+
+
+
+	private LambertZone(int value){
+		this.lambertZone = value;
+	}
+
+	public double n(){
+		return this.LAMBERT_N[this.lambertZone];
+	}
+
+	public  double c(){
+		return this.LAMBERT_C[this.lambertZone];
+	}
+	public  double xs(){
+		return this.LAMBERT_XS[this.lambertZone];
+	}
+	public  double ys(){
+		return this.LAMBERT_YS[this.lambertZone];
+	}
+
+}

data/ext/lambert_ruby/extconf.rb

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

data/ext/lambert_ruby/lambert.c

@@ -0,0 +1,357 @@
+/*
+ *	Source des algorithmes : http://geodesie.ign.fr/contenu/fichiers/documentation/algorithmes/notice/NTG_71.pdf
+ *  
+*/
+
+#include "lambert.h"
+#include <math.h>
+#include <stdio.h>
+
+
+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 __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)
+{
+    
+    switch (pt.unit)
+    {
+        case RADIAN :
+        {
+            pt = __YGRadianToDegree(pt);
+        }
+            break;
+        case GRAD :
+        {
+            pt = __YGGradToDegree(pt);
+        }
+            break;
+       default:
+            break;
+    }
+        
+            return  pt;
+    
+}
+
+
+YGPoint YGPointToRadian(YGPoint pt)
+{
+    switch (pt.unit)
+    {
+        case DEGREE :
+        {
+            pt = __YGDegreeToRadian(pt);
+        }
+            break;
+        case GRAD :
+        {
+            pt = __YGGradToRadian(pt);
+        }
+            break;
+        default:
+            break;
+    }
+    
+    return  pt;
+}
+
+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));
+}
+
+/*
+ * ALGO0002
+ */
+
+double __YGLatitudeFromLatitudeISO(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
+*/
+
+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 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 = __YGLatitudeFromLatitudeISO(lat_iso,e,eps);
+
+	org.x = lon;
+	org.y = lat;
+    
+    return org;
+}
+
+
+/*
+ * ALGO0021 - Calcul de la grande Normale 
+ *
+*/
+
+double __YGLambertNormal(double lat, double a, double e)
+{
+
+	return a/sqrt(1-e*e*sin(lat)*sin(lat));
+}
+
+/**
+ * ALGO0009 - Transformations geographiques -> cartésiennes
+ *
+ *
+ */
+
+ YGPoint __YGGeographicToCartesian(double lon, double lat, double he, double a, double e)
+ {
+ 	double N = __YGLambertNormal(lat,a,e);
+ 	
+ 	YGPoint 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
+ */
+
+ YGPoint __YGCartesianToGeographic(YGPoint 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));
+ 	
+ 	YGPoint pt;
+ 	pt.x = lon;
+ 	pt.y = phi_i;
+ 	pt.z = he;     
+    pt.unit = RADIAN;
+
+ 	return pt;
+ }
+
+/*
+ * Convert Lambert -> WGS84
+ * http://geodesie.ign.fr/contenu/fichiers/documentation/pedagogiques/transfo.pdf
+ *
+ */
+
+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)
+    {
+       point =  __YGLambertToGeographic(point,zone,LON_MERID_IERS,E_WGS84,DEFAULT_EPS);
+    
+    }
+    else
+    {
+        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);
+    
+        point.x-= 168;
+        point.y-= 60;
+        point.z+= 320;
+    
+        //WGS84 refers to greenwich
+        point = __YGCartesianToGeographic(point, LON_MERID_GREENWICH, A_WGS84,E_WGS84,DEFAULT_EPS);
+    }
+    
+    point.unit = RADIAN;
+    return point;
+}
+
+
+
+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 __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 = __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));
+
+	return dest;
+
+}
+
+YGPoint __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r)
+{
+	YGPoint v = {0,0,0};
+
+	v.x = t.x + u.x*(1+d) + u.z * r.y - u.y * r.z;
+	v.y = t.y + u.y*(1+d) + u.x * r.z - u.y * r.z;
+	v.z = t.z +u.z*(1+d) + u.y*r.x -u.x*r.y;
+
+	return v;
+
+}

data/ext/lambert_ruby/lambert.h

@@ -0,0 +1,126 @@
+#ifndef __LAMBERT_H
+#define __LAMBERT_H
+
+
+#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 LON_MERID_IERS (3*M_PI/180)
+#define AUTOCOMEIQUE_FIRST 44*M_PI/180
+#define AUTOCOMEIQUE_SECOND 49*M_PI/180
+#define LAT_ORIG 46.5*M_PI/180
+#define ct_x0 700000.0
+#define ct_y0 6600000.0
+
+
+typedef enum {
+	LAMBERT_I=0,
+	LAMBERT_II=1,
+	LAMBERT_III=2,
+	LAMBERT_IV=3,
+	LAMBERT_II_E=4,
+	LAMBERT_93= 5
+} YGLambertZone;
+
+typedef enum {
+    DEGREE,
+    GRAD,
+    RADIAN,
+    METER
+} CoordUnit;
+
+typedef struct {
+	double x;
+	double y;
+	double z;
+    CoordUnit unit;
+} YGPoint;
+
+typedef struct
+{
+    double tx;
+    double ty;
+    double tz;
+} YGTransform;
+
+typedef YGPoint Vector;
+
+#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 __YGLambertNormal(double lat, double a, double e);
+
+/*
+ * Convert a YGPoint struct from one lambert zone to WGS84 (Rad)
+ *
+ */
+
+
+YGPoint YGPointConvertWGS84(YGPoint point, YGLambertZone zone);
+
+/*
+ * ALGO0002
+ */
+
+double __YGLatitudeFromLatitudeISO(double lat_iso, double e, double eps);
+
+/*
+* ALGO0012
+*/
+
+YGPoint __YGCartesianToGeographic(YGPoint org, double meridien, double a, double e , double eps);
+
+/*
+ * ALGO004
+ */
+YGPoint __YGLambertToGeographic(YGPoint org, YGLambertZone zone, double lon_merid, double e, double eps);
+
+/**
+ * ALGO0009 - Transformations geographiques -> cartésiennes
+ *
+ *
+ */
+
+ 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 __YGSwitchGeodesicSystem(YGPoint u, Vector t, double d, Vector r);
+ 
+ /**
+ * Algo0001  Calcul de la latitude isomérique
+ */
+double __YGLatitudeISO(double lat, double e);
+
+/** 
+* Algo003 
+*/
+YGPoint __YGCoordinatesTransform(double e, double n, double c, double lambda_c, double x_s, double y_s , double lon, double lat);
+
+/**
+ * Algo 01
+ */
+double __YGLatitudeISOFromLatitude(double lat, double e);
+ #endif

data/ext/lambert_ruby/lambert_ruby.c

@@ -0,0 +1,68 @@
+#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;
+	YGLambertZone cZone = NUM2INT(zone);
+
+	x = NUM2DBL(rb_iv_get(self,"@x"));
+	y = NUM2DBL(rb_iv_get(self,"@y"));
+	z = NUM2DBL(rb_iv_get(self,"@z"));
+
+	YGPoint org = YGMeterPoint(x,y,z);
+	org = YGPointConvertWGS84(org,cZone);
+	org = YGPointToDegree(org);
+
+   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;
+}
+
+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,7 @@
+if RUBY_PLATFORM =~/java/
+  require 'java'
+  require_relative 'lambert_ruby.jar'
+  com.yageek.lambertruby.LambertRubyService.new.basicLoad(JRuby.runtime)
+else
+  require 'lambert_ruby/lambert_ruby'
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: lambert_ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: java
+authors:
+- Yannick Heinrich
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake-compiler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby wrapper for the lambert library
+email: yannick.heinrich@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ext/lambert_ruby/Lambert.java
+- ext/lambert_ruby/LambertPoint.java
+- ext/lambert_ruby/LambertRubyService.java
+- ext/lambert_ruby/LambertZone.java
+- ext/lambert_ruby/extconf.rb
+- ext/lambert_ruby/lambert.c
+- ext/lambert_ruby/lambert.h
+- ext/lambert_ruby/lambert_ruby.c
+- lib/lambert_ruby.jar
+- lib/lambert_ruby.rb
+homepage: http://rubygems.org/gems/lambert_ruby
+licenses: []
+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.4.8
+signing_key:
+specification_version: 4
+summary: Ruby wrapper for the lambert library
+test_files: []