# Source: src/ol/proj/proj.js

    goog.provide('ol.proj');
    goog.provide('ol.proj.METERS_PER_UNIT');
    goog.provide('ol.proj.Projection');
    goog.provide('ol.proj.ProjectionLike');
    goog.provide('ol.proj.Units');

    goog.require('goog.array');
    goog.require('goog.asserts');
    goog.require('goog.object');
    goog.require('ol');
    goog.require('ol.Extent');
    goog.require('ol.TransformFunction');
    goog.require('ol.sphere.NORMAL');

    /**
     * Have Proj4js.
     * @const
     * @type {boolean}
     */
    ol.HAVE_PROJ4JS = ol.ENABLE_PROJ4JS && typeof Proj4js == 'object';

    /**
     * A projection as {@link ol.proj.Projection}, SRS identifier string or
     * undefined.
     * @typedef {ol.proj.Projection|string|undefined} ol.proj.ProjectionLike
     * @todo api
     */
    ol.proj.ProjectionLike;

    /**
     * Projection units: `'degrees'`, `'ft'`, `'m'` or `'pixels'`.
     * @enum {string}
     * @todo api
     */
    ol.proj.Units = {
      DEGREES: 'degrees',
      FEET: 'ft',
      METERS: 'm',
      PIXELS: 'pixels'
    };

    /**
     * Meters per unit lookup table.
     * @const
     * @type {Object.<ol.proj.Units, number>}
     * @todo api
     */
    ol.proj.METERS_PER_UNIT[ol.proj.Units.DEGREES] =
        2 * Math.PI * ol.sphere.NORMAL.radius / 360;
    ol.proj.METERS_PER_UNIT[ol.proj.Units.FEET] = 0.3048;
    ol.proj.METERS_PER_UNIT[ol.proj.Units.METERS] = 1;

    /**
     * @classdesc
     * Class for coordinate transforms between coordinate systems. By default,
     * OpenLayers ships with the ability to transform coordinates between
     * geographic (EPSG:4326) and web or spherical mercator (EPSG:3857)
     * coordinate reference systems.
     *
     * Additional transforms may be added by using the
     * {@link http://proj4js.org/|proj4js} library. If the proj4js library is
     * included, the <transform> method will work between any two coordinate
     * reference systems with proj4js definitions.
     *
     * @constructor
     * @param {olx.ProjectionOptions} options Projection options.
     * @struct
     * @todo api
     */
    ol.proj.Projection = function(options) {

      /**
       * @private
       * @type {string}
       */
      this.code_ = options.code;

      /**
       * @private
       * @type {ol.proj.Units}
       */
      this.units_ = /** @type {ol.proj.Units} */ (options.units);

      /**
       * @private
       * @type {ol.Extent}
       */
      this.extent_ = goog.isDef(options.extent) ? options.extent : null;

      /**
       * @private
       * @type {string}
       */
      this.axisOrientation_ = goog.isDef(options.axisOrientation) ?
          options.axisOrientation : 'enu';

      /**
       * @private
       * @type {boolean}
       */
      this.global_ = goog.isDef(options.global) ? options.global : false;

      /**
       * @private
       * @type {ol.tilegrid.TileGrid}
       */
      this.defaultTileGrid_ = null;

    };

    /**
     * Get the code for this projection, e.g. 'EPSG:4326'.
     * @return {string} Code.
     * @todo api
     */
    ol.proj.Projection.prototype.getCode = function() {
      return this.code_;
    };

    /**
     * Get the validity extent for this projection.
     * @return {ol.Extent} Extent.
     * @todo api
     */
    ol.proj.Projection.prototype.getExtent = function() {
      return this.extent_;
    };

    /**
     * Get the resolution of the point in degrees. For projections with degrees as
     * the unit this will simply return the provided resolution. For other
     * projections the point resolution is estimated by transforming the center
     * pixel to EPSG:4326, measuring its width and height on the normal sphere,
     * and taking the average of the width and height.
     * @param {number} resolution Resolution.
     * @param {ol.Coordinate} point Point.
     * @return {number} Point resolution.
     */
    ol.proj.Projection.prototype.getPointResolution = goog.abstractMethod;

    /**
     * Get the units of this projection.
     * @return {ol.proj.Units} Units.
     * @todo api
     */
    ol.proj.Projection.prototype.getUnits = function() {
      return this.units_;
    };

    /**
     * Get the amount of meters per unit of this projection.  If the projection is
     * not configured with a units identifier, the return is `undefined`.
     * @return {number|undefined} Meters.
     */
    ol.proj.Projection.prototype.getMetersPerUnit = function() {
      return ol.proj.METERS_PER_UNIT[this.units_];
    };

    /**
     * Get the axis orientation of this projection.
     * Example values are:
     * enu - the default easting, northing, elevation.
     * neu - northing, easting, up - useful for "lat/long" geographic coordinates,
     *     or south orientated transverse mercator.
     * wnu - westing, northing, up - some planetary coordinate systems have
     *     "west positive" coordinate systems
     * @return {string} Axis orientation.
     */
    ol.proj.Projection.prototype.getAxisOrientation = function() {
      return this.axisOrientation_;
    };

    /**
     * Is this projection a global projection which spans the whole world?
     * @return {boolean} Wether the projection is global.
     */
    ol.proj.Projection.prototype.isGlobal = function() {
      return this.global_;
    };

    /**
     * @return {ol.tilegrid.TileGrid} The default tile grid.
     */
    ol.proj.Projection.prototype.getDefaultTileGrid = function() {
      return this.defaultTileGrid_;
    };

    /**
     * @param {ol.tilegrid.TileGrid} tileGrid The default tile grid.
     */
    ol.proj.Projection.prototype.setDefaultTileGrid = function(tileGrid) {
      this.defaultTileGrid_ = tileGrid;
    };

    /**
     * @constructor
     * @extends {ol.proj.Projection}
     * @param {Proj4js.Proj} proj4jsProj Proj4js projection.
     * @param {olx.Proj4jsProjectionOptions} options Proj4js projection options.
     * @private
     * @struct
     */
    ol.Proj4jsProjection_ = function(proj4jsProj, options) {

      var units = /** @type {ol.proj.Units} */ (proj4jsProj.units);

      var config = /** @type {olx.ProjectionOptions} */ ({
        units: units,
        axisOrientation: proj4jsProj.axis
      });
      goog.object.extend(config, options);

      goog.base(this, config);

      /**
       * @private
       * @type {Proj4js.Proj}
       */
      this.proj4jsProj_ = proj4jsProj;

      /**
       * @private
       * @type {?ol.TransformFunction}
       */
      this.toEPSG4326_ = null;

    };
    goog.inherits(ol.Proj4jsProjection_, ol.proj.Projection);

    /**
     * @inheritDoc
     */
    ol.Proj4jsProjection_.prototype.getMetersPerUnit = function() {
      var metersPerUnit = this.proj4jsProj_.to_meter;
      if (!goog.isDef(metersPerUnit)) {
        metersPerUnit = ol.proj.METERS_PER_UNIT[this.units_];
      }
      return metersPerUnit;
    };

    /**
     * @inheritDoc
     */
    ol.Proj4jsProjection_.prototype.getPointResolution =
        function(resolution, point) {
      if (this.getUnits() == ol.proj.Units.DEGREES) {
        return resolution;
      } else {
        // Estimate point resolution by transforming the center pixel to EPSG:4326,
        // measuring its width and height on the normal sphere, and taking the
        // average of the width and height.
        if (goog.isNull(this.toEPSG4326_)) {
          this.toEPSG4326_ = ol.proj.getTransformFromProjections(
              this, ol.proj.getProj4jsProjectionFromCode_({
                code: 'EPSG:4326',
                extent: null
              }));
        }
        var vertices = [
          point[0] - resolution / 2, point[1],
          point[0] + resolution / 2, point[1],
          point[0], point[1] - resolution / 2,
          point[0], point[1] + resolution / 2
        ];
        vertices = this.toEPSG4326_(vertices, vertices, 2);
        var width = ol.sphere.NORMAL.haversineDistance(
            vertices.slice(0, 2), vertices.slice(2, 4));
        var height = ol.sphere.NORMAL.haversineDistance(
            vertices.slice(4, 6), vertices.slice(6, 8));
        var pointResolution = (width + height) / 2;
        if (this.getUnits() == ol.proj.Units.FEET) {
          // The radius of the normal sphere is defined in meters, so we must
          // convert back to feet.
          pointResolution /= 0.3048;
        }
        return pointResolution;
      }
    };

    /**
     * @return {Proj4js.Proj} Proj4js projection.
     */
    ol.Proj4jsProjection_.prototype.getProj4jsProj = function() {
      return this.proj4jsProj_;
    };

    /**
     * @private
     * @type {Object.<string, ol.Proj4jsProjection_>}
     */
    ol.proj.proj4jsProjections_ = {};

    /**
     * @private
     * @type {Object.<string, ol.proj.Projection>}
     */
    ol.proj.projections_ = {};

    /**
     * @private
     * @type {Object.<string, Object.<string, ol.TransformFunction>>}
     */
    ol.proj.transforms_ = {};

    /**
     * Registers transformation functions that don't alter coordinates. Those allow
     * to transform between projections with equal meaning.
     *
     * @param {Array.<ol.proj.Projection>} projections Projections.
     */
    ol.proj.addEquivalentProjections = function(projections) {
      ol.proj.addProjections(projections);
      goog.array.forEach(projections, function(source) {
        goog.array.forEach(projections, function(destination) {
          if (source !== destination) {
            ol.proj.addTransform(source, destination, ol.proj.cloneTransform);
          }
        });
      });
    };

    /**
     * Registers transformation functions to convert coordinates in any projection
     * in projection1 to any projection in projection2.
     *
     * @param {Array.<ol.proj.Projection>} projections1 Projections with equal
     *     meaning.
     * @param {Array.<ol.proj.Projection>} projections2 Projections with equal
     *     meaning.
     * @param {ol.TransformFunction} forwardTransform Transformation from any
     *   projection in projection1 to any projection in projection2.
     * @param {ol.TransformFunction} inverseTransform Transform from any projection
     *   in projection2 to any projection in projection1..
     */
    ol.proj.addEquivalentTransforms =
        function(projections1, projections2, forwardTransform, inverseTransform) {
      goog.array.forEach(projections1, function(projection1) {
        goog.array.forEach(projections2, function(projection2) {
          ol.proj.addTransform(projection1, projection2, forwardTransform);
          ol.proj.addTransform(projection2, projection1, inverseTransform);
        });
      });
    };

    /**
     * @param {ol.Proj4jsProjection_} proj4jsProjection Proj4js projection.
     * @private
     */
    ol.proj.addProj4jsProjection_ = function(proj4jsProjection) {
      var proj4jsProjections = ol.proj.proj4jsProjections_;
      var code = proj4jsProjection.getCode();
      goog.asserts.assert(!goog.object.containsKey(proj4jsProjections, code));
      proj4jsProjections[code] = proj4jsProjection;
    };

    /**
     * @param {ol.proj.Projection} projection Projection.
     * @todo api
     */
    ol.proj.addProjection = function(projection) {
      var projections = ol.proj.projections_;
      var code = projection.getCode();
      projections[code] = projection;
      ol.proj.addTransform(projection, projection, ol.proj.cloneTransform);
    };

    /**
     * @param {Array.<ol.proj.Projection>} projections Projections.
     */
    ol.proj.addProjections = function(projections) {
      goog.array.forEach(projections, function(projection) {
        ol.proj.addProjection(projection);
      });
    };

    /**
     * FIXME empty description for jsdoc
     */
    ol.proj.clearAllProjections = function() {
      if (ol.ENABLE_PROJ4JS) {
        ol.proj.proj4jsProjections_ = {};
      }
      ol.proj.projections_ = {};
      ol.proj.transforms_ = {};
    };

    /**
     * @param {ol.proj.Projection|string|undefined} projection Projection.
     * @param {string} defaultCode Default code.
     * @return {ol.proj.Projection} Projection.
     */
    ol.proj.createProjection = function(projection, defaultCode) {
      if (!goog.isDefAndNotNull(projection)) {
        return ol.proj.get(defaultCode);
      } else if (goog.isString(projection)) {
        return ol.proj.get(projection);
      } else {
        goog.asserts.assertInstanceof(projection, ol.proj.Projection);
        return projection;
      }
    };

    /**
     * Registers a conversion function to convert coordinates from the source
     * projection to the destination projection.
     *
     * @param {ol.proj.Projection} source Source.
     * @param {ol.proj.Projection} destination Destination.
     * @param {ol.TransformFunction} transformFn Transform.
     */
    ol.proj.addTransform = function(source, destination, transformFn) {
      var sourceCode = source.getCode();
      var destinationCode = destination.getCode();
      var transforms = ol.proj.transforms_;
      if (!goog.object.containsKey(transforms, sourceCode)) {
        transforms[sourceCode] = {};
      }
      transforms[sourceCode][destinationCode] = transformFn;
    };

    /**
     * Unregisters the conversion function to convert coordinates from the source
     * projection to the destination projection.  This method is used to clean up
     * cached transforms during testing.
     *
     * @param {ol.proj.Projection} source Source projection.
     * @param {ol.proj.Projection} destination Destination projection.
     * @return {ol.TransformFunction} transformFn The unregistered transform.
     */
    ol.proj.removeTransform = function(source, destination) {
      var sourceCode = source.getCode();
      var destinationCode = destination.getCode();
      var transforms = ol.proj.transforms_;
      goog.asserts.assert(sourceCode in transforms);
      goog.asserts.assert(destinationCode in transforms[sourceCode]);
      var transform = transforms[sourceCode][destinationCode];
      delete transforms[sourceCode][destinationCode];
      var keys = goog.object.getKeys(transforms[sourceCode]);
      if (keys.length === 0) {
        delete transforms[sourceCode];
      }
      return transform;
    };

    /**
     * @param {ol.proj.ProjectionLike} projectionLike Either a code string which is
     *     a combination of authority and identifier such as "EPSG:4326", or an
     *     existing projection object, or undefined.
     * @return {ol.proj.Projection} Projection.
     * @todo api
     */
    ol.proj.get = function(projectionLike) {
      var projection;
      if (projectionLike instanceof ol.proj.Projection) {
        projection = projectionLike;
      } else if (goog.isString(projectionLike)) {
        var code = projectionLike;
        projection = ol.proj.projections_[code];
        if (ol.HAVE_PROJ4JS && !goog.isDef(projection)) {
          projection = ol.proj.getProj4jsProjectionFromCode_({
            code: code,
            extent: null
          });
        }
        if (!goog.isDef(projection)) {
          goog.asserts.assert(goog.isDef(projection));
          projection = null;
        }
      } else {
        projection = null;
      }
      return projection;
    };

    /**
     * @param {olx.Proj4jsProjectionOptions} options Proj4js projection options.
     * @private
     * @return {ol.Proj4jsProjection_} Proj4js projection.
     */
    ol.proj.getProj4jsProjectionFromCode_ = function(options) {
      var code = options.code;
      var proj4jsProjections = ol.proj.proj4jsProjections_;
      var proj4jsProjection = proj4jsProjections[code];
      if (!goog.isDef(proj4jsProjection)) {
        var proj4jsProj = new Proj4js.Proj(code);
        var srsCode = proj4jsProj.srsCode;
        proj4jsProjection = proj4jsProjections[srsCode];
        if (!goog.isDef(proj4jsProjection)) {
          var config = /** @type {olx.Proj4jsProjectionOptions} */
              (goog.object.clone(options));
          config.code = srsCode;
          proj4jsProjection = new ol.Proj4jsProjection_(proj4jsProj, config);
          proj4jsProjections[srsCode] = proj4jsProjection;
        }
        proj4jsProjections[code] = proj4jsProjection;
      }
      return proj4jsProjection;
    };

    /**
     * Checks if two projections are the same, that is every coordinate in one
     * projection does represent the same geographic point as the same coordinate in
     * the other projection.
     *
     * @param {ol.proj.Projection} projection1 Projection 1.
     * @param {ol.proj.Projection} projection2 Projection 2.
     * @return {boolean} Equivalent.
     */
    ol.proj.equivalent = function(projection1, projection2) {
      if (projection1 === projection2) {
        return true;
      } else if (projection1.getUnits() != projection2.getUnits()) {
        return false;
      } else {
        var transformFn = ol.proj.getTransformFromProjections(
            projection1, projection2);
        return transformFn === ol.proj.cloneTransform;
      }
    };

    /**
     * Given the projection-like objects this method searches for a transformation
     * function to convert a coordinates array from the source projection to the
     * destination projection.
     *
     * @param {ol.proj.ProjectionLike} source Source.
     * @param {ol.proj.ProjectionLike} destination Destination.
     * @return {ol.TransformFunction} Transform.
     * @todo api
     */
    ol.proj.getTransform = function(source, destination) {
      var sourceProjection = ol.proj.get(source);
      var destinationProjection = ol.proj.get(destination);
      return ol.proj.getTransformFromProjections(
          sourceProjection, destinationProjection);
    };

    /**
     * Searches a function that can be used to convert coordinates from the source
     * projection to the destination projection.
     *
     * @param {ol.proj.Projection} sourceProjection Source projection.
     * @param {ol.proj.Projection} destinationProjection Destination projection.
     * @return {ol.TransformFunction} Transform.
     * @todo api
     */
    ol.proj.getTransformFromProjections =
        function(sourceProjection, destinationProjection) {
      var transforms = ol.proj.transforms_;
      var sourceCode = sourceProjection.getCode();
      var destinationCode = destinationProjection.getCode();
      var transform;
      if (goog.object.containsKey(transforms, sourceCode) &&
          goog.object.containsKey(transforms[sourceCode], destinationCode)) {
        transform = transforms[sourceCode][destinationCode];
      }
      if (ol.HAVE_PROJ4JS && !goog.isDef(transform)) {
        var proj4jsSource;
        if (sourceProjection instanceof ol.Proj4jsProjection_) {
          proj4jsSource = sourceProjection;
        } else {
          proj4jsSource =
              ol.proj.getProj4jsProjectionFromCode_({
                code: sourceCode,
                extent: null
              });
        }
        var sourceProj4jsProj = proj4jsSource.getProj4jsProj();
        var proj4jsDestination;
        if (destinationProjection instanceof ol.Proj4jsProjection_) {
          proj4jsDestination = destinationProjection;
        } else {
          proj4jsDestination =
              ol.proj.getProj4jsProjectionFromCode_({
                code: destinationCode,
                extent: null
              });
        }
        var destinationProj4jsProj = proj4jsDestination.getProj4jsProj();
        transform =
            /**
             * @param {Array.<number>} input Input coordinate values.
             * @param {Array.<number>=} opt_output Output array of coordinates.
             * @param {number=} opt_dimension Dimension.
             * @return {Array.<number>} Output coordinate values.
             */
            function(input, opt_output, opt_dimension) {
          var length = input.length,
              dimension = opt_dimension > 1 ? opt_dimension : 2,
              output = opt_output;
          if (!goog.isDef(output)) {
            if (dimension > 2) {
              // preserve values beyond second dimension
              output = input.slice();
            } else {
              output = new Array(length);
            }
          }
          goog.asserts.assert(output.length % dimension === 0);
          var proj4jsPoint;
          for (var i = 0; i < length; i += dimension) {
            proj4jsPoint = new Proj4js.Point(input[i], input[i + 1]);
            proj4jsPoint = Proj4js.transform(
                sourceProj4jsProj, destinationProj4jsProj, proj4jsPoint);
            output[i] = proj4jsPoint.x;
            output[i + 1] = proj4jsPoint.y;
          }
          return output;
        };
        ol.proj.addTransform(sourceProjection, destinationProjection, transform);
      }
      if (!goog.isDef(transform)) {
        goog.asserts.assert(goog.isDef(transform));
        transform = ol.proj.identityTransform;
      }
      return transform;
    };

    /**
     * @param {Array.<number>} input Input coordinate array.
     * @param {Array.<number>=} opt_output Output array of coordinate values.
     * @param {number=} opt_dimension Dimension.
     * @return {Array.<number>} Input coordinate array (same array as input).
     */
    ol.proj.identityTransform = function(input, opt_output, opt_dimension) {
      if (goog.isDef(opt_output) && input !== opt_output) {
        // TODO: consider making this a warning instead
        goog.asserts.fail('This should not be used internally.');
        for (var i = 0, ii = input.length; i < ii; ++i) {
          opt_output[i] = input[i];
        }
        input = opt_output;
      }
      return input;
    };

    /**
     * @param {Array.<number>} input Input coordinate array.
     * @param {Array.<number>=} opt_output Output array of coordinate values.
     * @param {number=} opt_dimension Dimension.
     * @return {Array.<number>} Output coordinate array (new array, same coordinate
     *     values).
     */
    ol.proj.cloneTransform = function(input, opt_output, opt_dimension) {
      var output;
      if (goog.isDef(opt_output)) {
        for (var i = 0, ii = input.length; i < ii; ++i) {
          opt_output[i] = input[i];
        }
        output = opt_output;
      } else {
        output = input.slice();
      }
      return output;
    };

    /**
     * @param {ol.Coordinate} point Point.
     * @param {ol.proj.ProjectionLike} source Source.
     * @param {ol.proj.ProjectionLike} destination Destination.
     * @return {ol.Coordinate} Point.
     * @todo api
     */
    ol.proj.transform = function(point, source, destination) {
      var transformFn = ol.proj.getTransform(source, destination);
      return transformFn(point);
    };

    /**
     * Transforms the given point to the destination projection.
     *
     * @param {ol.Coordinate} point Point.
     * @param {ol.proj.Projection} sourceProjection Source projection.
     * @param {ol.proj.Projection} destinationProjection Destination projection.
     * @return {ol.Coordinate} Point.
     * @todo api
     */
    ol.proj.transformWithProjections =
        function(point, sourceProjection, destinationProjection) {
      var transformFn = ol.proj.getTransformFromProjections(
          sourceProjection, destinationProjection);
      return transformFn(point);
    };

    /**
     * @param {olx.Proj4jsProjectionOptions} options Proj4js projection options.
     * @return {ol.proj.Projection} Proj4js projection.
     * @todo api
     */
    ol.proj.configureProj4jsProjection = function(options) {
      goog.asserts.assert(!goog.object.containsKey(
          ol.proj.proj4jsProjections_, options.code));
      return ol.proj.getProj4jsProjectionFromCode_(options);
    };