Ticket #857: proj.patch

lib/OpenLayers/Projection.js

@@ +1 @@
+/**
+ * Copyright (c) 2006 MetaCarta, Inc., published under a modified BSD license.
+ * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt 
+ * for the full text of the license.
+ */
+
+
+/**
+ * Namespace: Projection
+ * Contains methods for transforming coordinates between spatial reference
+ *     systems.  
+ */
+OpenLayers.Projection = {
+    
+    /**
+     * Property: alias
+     * {Object} Aliases can be added for a spatial reference system by adding a
+     *     name-value pair to the alias object.  This object represents the
+     *     many to one mapping between aliases and spatial references.  Note
+     *     that all SRS keys are assumed to be case insensitive.  Use all caps
+     *     for alias keys here.
+     */
+    alias: {
+        "WGS84": "EPSG:4326"
+    },
+    
+    /**
+     * APIFunction: transform
+     * Transform coordinates of the passed in feature, geometry, array of
+     *     features, or array of geometries from on spatial reference system
+     *     to another.
+     *
+     * Parameters:
+     * obj - {<OpenLayers.Geometry> | <OpenLayers.Vector.Feature> |
+     *     Array(<OpenLayers.Geometry>) | Array(OpenLayers.Vector.Feature)}
+     *     A geometry, feature, array of geometries, or array of features
+     *     to be transformed.
+     * to - {String} A string representing the input spatial reference system.
+     * from - {String} A string representing the output spatial reference
+     *     system.
+     *
+     * Returns:
+     * {<OpenLayers.Geometry> | <OpenLayers.Vector.Feature> |
+     *     Array(<OpenLayers.Geometry>) | Array(OpenLayers.Vector.Feature)}
+     *     A clone of the input object with transformed coordinates.
+     */
+    transform: function(obj, from, to) {
+        from = from.toUpperCase();
+        if(this.alias[from]) {
+            from = this.alias[from].toUpperCase();
+        }
+        to = to.toUpperCase();
+        if(this.alias[to]) {
+            to = this.alias[to].toUpperCase();
+        }
+        var clone;
+        if(obj instanceof Array) {
+            // deal with arrays of features or geometries
+            var item;
+            clone = new Array();
+            for(var i=0; i<obj.length; ++i) {
+                item = obj[i];
+                clone.push(OpenLayers.Projection.transform(item, from, to));
+            }
+        }
+        if(obj.CLASS_NAME) {
+            if(obj.CLASS_NAME.indexOf("OpenLayers.Geometry") == 0) {
+                // transform a geometry
+                if(obj instanceof OpenLayers.Geometry.Point) {
+                    clone = obj.clone();
+                    OpenLayers.Projection[from].inverse(clone);
+                    OpenLayers.Projection[to].forward(clone);
+                } else {
+                    var component;
+                    clone = eval("new " + obj.CLASS_NAME + "()");
+                    for(var j=0; j<obj.components.length; ++j) {
+                        component = obj.components[j];
+                        clone.addComponent(
+                            OpenLayers.Projection.transform(component, from, to)
+                        );
+                    }
+                }
+            } else if(obj.CLASS_NAME.indexOf("OpenLayers.Feature.Vector") == 0) {
+                // transform a vector feature
+                clone = new OpenLayers.Feature.Vector(null,
+                                                      obj.attributes,
+                                                      obj.style);
+                clone.geometry = OpenLayers.Projection.transform(obj.geometry,
+                                                                 from,
+                                                                 to);
+            }
+        }
+        return clone;
+    },
+    
+    /**
+     * Various constants used by the forward and inverse transoforms.
+     *     To be organized.
+     */
+    rad2deg: 180 / Math.PI,
+    deg2rad:  Math.PI / 180,
+    halfPi: Math.PI / 2,
+    rMajor: 6378137.0,
+    rMinor: 6356752.31424518,
+    eccent: Math.sqrt(1.0 - Math.pow(6356752.31424518 / 6378137.0, 2))
+    
+};
+

lib/OpenLayers/Projection/EPSG54004.js

@@ +1 @@
+/**
+ * Copyright (c) 2006 MetaCarta, Inc., published under a modified BSD license.
+ * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt 
+ * for the full text of the license.
+ */
+
+/**
+ * Namespace: OpenLayers.Projection["EPSG:54004"]
+ * Contains functions to transform points to and from the spatial reference
+ *     system represented by the EPSG code 54004.
+ *
+ * Proj4 text:
+ *     +proj=merc +lon_0=0 +k=1.000000 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84
+ *     +units=m +no_defs
+ */
+OpenLayers.Projection["EPSG:54004"] = {
+    
+    /**
+     * APIFunction: forward
+     * Transform a point from Geographic/WGS84 to the spatial reference system
+     *     represented here (EPSG:54004).  The x & y properties of the passed
+     *     in point are modified.
+     *
+     * Parameters:
+     * point - {<OpenLayers.Geometry.Point>} The point to be transformed.  This
+     *     point should have coordinates in Geographic/WGS84.  The passed in
+     *     point will be modified.
+     *
+     *
+     * Returns:
+     * {<OpenLayers.Geometry.Point>} The passed in point with transformed
+     *     coordinates.
+     */
+    forward: function(point) {
+        var x = point.x;
+        var y = point.y;
+        
+        // convert to radians
+        if(y <= 90.0 && y >= -90.0 && x <= 180.0 && x >= -180.0) {
+            y *= OpenLayers.Projection.deg2rad;
+            x *= OpenLayers.Projection.deg2rad;
+            // force latitude away from the poles
+            y = Math.min(OpenLayers.Projection.halfPi - 1.0e-9, y);
+            y = Math.max(-OpenLayers.Projection.halfPi + 1.0e-9, y);
+        } else {
+            // OpenLayers.Console.error("nice error message");
+            return null;
+        }
+
+        // force latitude away from the poles
+        y = Math.min(OpenLayers.Projection.halfPi - 1.0e-9, y);
+        y = Math.max(-OpenLayers.Projection.halfPi + 1.0e-9, y);
+
+        var con = OpenLayers.Projection.eccent * Math.sin(y);
+        var com = .5 * OpenLayers.Projection.eccent;
+        con = Math.pow(((1.0 - con) / (1.0 + con)), com);
+        var ts = (Math.tan(.5 * (OpenLayers.Projection.halfPi - y))/con);
+        var x = OpenLayers.Projection.rMajor * x;
+        var y = -OpenLayers.Projection.rMajor * Math.log(ts);
+        
+        // modify the point
+        point.x = x;
+        point.y = y;
+        return point;
+    },
+
+    /**
+     * APIFunction: inverse
+     * Transform a point from the spatial reference system represented here
+     *     (EPSG:54004) to Geographic/WGS84 .  The x & y properties of the
+     *     passed in point are modified.
+     *
+     * Parameters:
+     * point - {<OpenLayers.Geometry.Point>} The point to be transformed.  This
+     *     point should have coordinates in EPSG:54004.  The passed in
+     *     point will be modified.
+     *
+     *
+     * Returns:
+     * {<OpenLayers.Geometry.Point>} The passed in point with transformed
+     *     coordinates.
+     */
+    inverse: function(point) {
+
+        // calculate latitude
+        var temp = OpenLayers.Projection.rMinor / OpenLayers.Projection.rMajor;
+        var ts = Math.exp(-point.y / OpenLayers.Projection.rMajor);
+
+        // phi2z: compute the latitude angle, phi2, for the inverse
+        // of the Lambert Conformal Conic and Polar Stereographic projections.
+        var y = null;
+        var eccnth = .5 * OpenLayers.Projection.eccent;
+        var con, dphi;
+        var phi = OpenLayers.Projection.halfPi - 2 * Math.atan(ts);
+        for(var i=0; i<=15; i++) {
+            con = OpenLayers.Projection.eccent * Math.sin(phi);
+            dphi = OpenLayers.Projection.halfPi - 2 * Math.atan(ts *
+                        (Math.pow(((1.0 - con)/(1.0 + con)),eccnth))) - phi;
+            phi += dphi;
+            if (Math.abs(dphi) <= .0000000001) {
+                y = phi;
+                break;
+            }
+        }
+        if(y == null) {
+            throw "Convergence error - phi2z";
+        }
+
+        // calculate longitude
+        var x = point.x / OpenLayers.Projection.rMajor;
+        if(Math.abs(x) >= Math.PI) {
+            var sign = (x < 0) ? -1 : 1;
+            x = x - (sign * 2 * Math.PI);
+        }
+
+        // convert to degrees
+        x *= OpenLayers.Projection.rad2deg;
+        y *= OpenLayers.Projection.rad2deg;
+        
+        // modify the point
+        point.x = x;
+        point.y = y;
+        return point;
+    }
+};

lib/OpenLayers/Projection/EPSG4326.js

@@ +1 @@
+/**
+ * Copyright (c) 2006 MetaCarta, Inc., published under a modified BSD license.
+ * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt 
+ * for the full text of the license.
+ */
+
+/**
+ * Namespace: OpenLayers.Projection["EPSG:4326"]
+ * Contains functions to transform points to and from the spatial reference
+ *     system represented by the EPSG code 4326.
+ *
+ * Proj4 text:
+ *    +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs
+ */
+OpenLayers.Projection["EPSG:4326"] = {
+    
+    /**
+     * APIFunction: forward
+     * Transform a point from Geographic/WGS84 to the spatial reference system
+     *     represented here (EPSG:4326).  The x & y properties of the passed
+     *     in point are modified.
+     *
+     * Parameters:
+     * point - {<OpenLayers.Geometry.Point>} The point to be transformed.  This
+     *     point should have coordinates in Geographic/WGS84.  The passed in
+     *     point will be modified.
+     *
+     *
+     * Returns:
+     * {<OpenLayers.Geometry.Point>} The passed in point with transformed
+     *     coordinates.
+     */
+    forward: function(point) {
+        return point;
+    },
+
+    /**
+     * APIFunction: inverse
+     * Transform a point from the spatial reference system represented here
+     *     (EPSG:4326) to Geographic/WGS84 .  The x & y properties of the
+     *     passed in point are modified.
+     *
+     * Parameters:
+     * point - {<OpenLayers.Geometry.Point>} The point to be transformed.  This
+     *     point should have coordinates in EPSG:4326.  The passed in
+     *     point will be modified.
+     *
+     *
+     * Returns:
+     * {<OpenLayers.Geometry.Point>} The passed in point with transformed
+     *     coordinates.
+     */
+    inverse: function(point) {
+        return point;
+    }
+};

lib/OpenLayers.js

@@ -167 +167 @@
-            "OpenLayers/Layer/WFS.js",
-            "OpenLayers/Control/MouseToolbar.js",
-            "OpenLayers/Control/NavToolbar.js",
-
+
+
+
+
-        ); // etc.
-
-