jvectormap-rails4 1.0.0

data/vendor/assets/javascripts/jvectormap/lib/data-series.js

@@ -0,0 +1,139 @@
+/**
+ * Creates data series.
+ * @constructor
+ * @param {Object} params Parameters to initialize series with.
+ * @param {Array} params.values The data set to visualize.
+ * @param {String} params.attribute Numberic or color attribute to use for data visualization. This could be: <code>fill</code>, <code>stroke</code>, <code>fill-opacity</code>, <code>stroke-opacity</code> for markers and regions and <code>r</code> (radius) for markers only.
+ * @param {Array} params.scale Values used to map a dimension of data to a visual representation. The first value sets visualization for minimum value from the data set and the last value sets visualization for the maximum value. There also could be intermidiate values. Default value is <code>['#C8EEFF', '#0071A4']</code>
+ * @param {Function|String} params.normalizeFunction The function used to map input values to the provided scale. This parameter could be provided as function or one of the strings: <code>'linear'</code> or <code>'polynomial'</code>, while <code>'linear'</code> is used by default. The function provided takes value from the data set as an input and returns corresponding value from the scale.
+ * @param {Number} params.min Minimum value of the data set. Could be calculated automatically if not provided.
+ * @param {Number} params.min Maximum value of the data set. Could be calculated automatically if not provided.
+ */
+jvm.DataSeries = function(params, elements) {
+  var scaleConstructor;
+
+  params = params || {};
+  params.attribute = params.attribute || 'fill';
+
+  this.elements = elements;
+  this.params = params;
+
+  if (params.attributes) {
+    this.setAttributes(params.attributes);
+  }
+
+  if (jvm.$.isArray(params.scale)) {
+    scaleConstructor = (params.attribute === 'fill' || params.attribute === 'stroke') ? jvm.ColorScale : jvm.NumericScale;
+    this.scale = new scaleConstructor(params.scale, params.normalizeFunction, params.min, params.max);
+  } else if (params.scale) {
+    this.scale = new jvm.OrdinalScale(params.scale);
+  } else {
+    this.scale = new jvm.SimpleScale(params.scale);
+  }
+
+  this.values = params.values || {};
+  this.setValues(this.values);
+};
+
+jvm.DataSeries.prototype = {
+  setAttributes: function(key, attr){
+    var attrs = key,
+        code;
+
+    if (typeof key == 'string') {
+      if (this.elements[key]) {
+        this.elements[key].setStyle(this.params.attribute, attr);
+      }
+    } else {
+      for (code in attrs) {
+        if (this.elements[code]) {
+          this.elements[code].element.setStyle(this.params.attribute, attrs[code]);
+        }
+      }
+    }
+  },
+
+  /**
+   * Set values for the data set.
+   * @param {Object} values Object which maps codes of regions or markers to values.
+   */
+  setValues: function(values) {
+    var max = Number.MIN_VALUE,
+        min = Number.MAX_VALUE,
+        val,
+        cc,
+        attrs = {};
+
+    if (!(this.scale instanceof jvm.OrdinalScale) && !(this.scale instanceof jvm.SimpleScale)) {
+      if (!this.params.min || !this.params.max) {
+        for (cc in values) {
+          val = parseFloat(values[cc]);
+          if (val > max) max = values[cc];
+          if (val < min) min = val;
+        }
+        if (!this.params.min) {
+          this.scale.setMin(min);
+        }
+        if (!this.params.max) {
+          this.scale.setMax(max);
+        }
+        this.params.min = min;
+        this.params.max = max;
+      }
+      for (cc in values) {
+        val = parseFloat(values[cc]);
+        if (!isNaN(val)) {
+          attrs[cc] = this.scale.getValue(val);
+        } else {
+          attrs[cc] = this.elements[cc].element.style.initial[this.params.attribute];
+        }
+      }
+    } else {
+      for (cc in values) {
+        if (values[cc]) {
+          attrs[cc] = this.scale.getValue(values[cc]);
+        } else {
+          attrs[cc] = this.elements[cc].element.style.initial[this.params.attribute];
+        }
+      }
+    }
+
+    this.setAttributes(attrs);
+    jvm.$.extend(this.values, values);
+  },
+
+  clear: function(){
+    var key,
+        attrs = {};
+
+    for (key in this.values) {
+      if (this.elements[key]) {
+        attrs[key] = this.elements[key].element.style.initial[this.params.attribute];
+      }
+    }
+    this.setAttributes(attrs);
+    this.values = {};
+  },
+
+  /**
+   * Set scale of the data series.
+   * @param {Array} scale Values representing scale.
+   */
+  setScale: function(scale) {
+    this.scale.setScale(scale);
+    if (this.values) {
+      this.setValues(this.values);
+    }
+  },
+
+  /**
+   * Set normalize function of the data series.
+   * @param {Function|String} normilizeFunction.
+   */
+  setNormalizeFunction: function(f) {
+    this.scale.setNormalizeFunction(f);
+    if (this.values) {
+      this.setValues(this.values);
+    }
+  }
+};

data/vendor/assets/javascripts/jvectormap/lib/jvectormap.js

@@ -0,0 +1,99 @@
+/**
+ * @namespace jvm Holds core methods and classes used by jVectorMap.
+ */
+var jvm = {
+
+  /**
+   * Inherits child's prototype from the parent's one.
+   * @param {Function} child
+   * @param {Function} parent
+   */
+  inherits: function(child, parent) {
+    function temp() {}
+    temp.prototype = parent.prototype;
+    child.prototype = new temp();
+    child.prototype.constructor = child;
+    child.parentClass = parent;
+  },
+
+  /**
+   * Mixes in methods from the source constructor to the target one.
+   * @param {Function} target
+   * @param {Function} source
+   */
+  mixin: function(target, source){
+    var prop;
+
+    for (prop in source.prototype) {
+      if (source.prototype.hasOwnProperty(prop)) {
+        target.prototype[prop] = source.prototype[prop];
+      }
+    }
+  },
+
+  min: function(values){
+    var min = Number.MAX_VALUE,
+        i;
+
+    if (values instanceof Array) {
+      for (i = 0; i < values.length; i++) {
+        if (values[i] < min) {
+          min = values[i];
+        }
+      }
+    } else {
+      for (i in values) {
+        if (values[i] < min) {
+          min = values[i];
+        }
+      }
+    }
+    return min;
+  },
+
+  max: function(values){
+    var max = Number.MIN_VALUE,
+        i;
+
+    if (values instanceof Array) {
+      for (i = 0; i < values.length; i++) {
+        if (values[i] > max) {
+          max = values[i];
+        }
+      }
+    } else {
+      for (i in values) {
+        if (values[i] > max) {
+          max = values[i];
+        }
+      }
+    }
+    return max;
+  },
+
+  keys: function(object){
+    var keys = [],
+        key;
+
+    for (key in object) {
+      keys.push(key);
+    }
+    return keys;
+  },
+
+  values: function(object){
+    var values = [],
+        key,
+        i;
+
+    for (i = 0; i < arguments.length; i++) {
+      object = arguments[i];
+      for (key in object) {
+        values.push(object[key]);
+      }
+    }
+    return values;
+  }
+};
+
+jvm.$ = jQuery;

data/vendor/assets/javascripts/jvectormap/lib/numeric-scale.js

@@ -0,0 +1,147 @@
+jvm.NumericScale = function(scale, normalizeFunction, minValue, maxValue) {
+  this.scale = [];
+
+  normalizeFunction = normalizeFunction || 'linear';
+
+  if (scale) this.setScale(scale);
+  if (normalizeFunction) this.setNormalizeFunction(normalizeFunction);
+  if (minValue) this.setMin(minValue);
+  if (maxValue) this.setMax(maxValue);
+};
+
+jvm.NumericScale.prototype = {
+  setMin: function(min) {
+    this.clearMinValue = min;
+    if (typeof this.normalize === 'function') {
+      this.minValue = this.normalize(min);
+    } else {
+      this.minValue = min;
+    }
+  },
+
+  setMax: function(max) {
+    this.clearMaxValue = max;
+    if (typeof this.normalize === 'function') {
+      this.maxValue = this.normalize(max);
+    } else {
+      this.maxValue = max;
+    }
+  },
+
+  setScale: function(scale) {
+    var i;
+
+    for (i = 0; i < scale.length; i++) {
+      this.scale[i] = [scale[i]];
+    }
+  },
+
+  setNormalizeFunction: function(f) {
+    if (f === 'polynomial') {
+      this.normalize = function(value) {
+        return Math.pow(value, 0.2);
+      }
+    } else if (f === 'linear') {
+      delete this.normalize;
+    } else {
+      this.normalize = f;
+    }
+    this.setMin(this.clearMinValue);
+    this.setMax(this.clearMaxValue);
+  },
+
+  getValue: function(value) {
+    var lengthes = [],
+        fullLength = 0,
+        l,
+        i = 0,
+        c;
+
+    if (typeof this.normalize === 'function') {
+      value = this.normalize(value);
+    }
+    for (i = 0; i < this.scale.length-1; i++) {
+      l = this.vectorLength(this.vectorSubtract(this.scale[i+1], this.scale[i]));
+      lengthes.push(l);
+      fullLength += l;
+    }
+
+    c = (this.maxValue - this.minValue) / fullLength;
+    for (i=0; i<lengthes.length; i++) {
+      lengthes[i] *= c;
+    }
+
+    i = 0;
+    value -= this.minValue;
+    while (value - lengthes[i] >= 0) {
+      value -= lengthes[i];
+      i++;
+    }
+
+    if (i == this.scale.length - 1) {
+      value = this.vectorToNum(this.scale[i])
+    } else {
+      value = (
+        this.vectorToNum(
+          this.vectorAdd(this.scale[i],
+            this.vectorMult(
+              this.vectorSubtract(this.scale[i+1], this.scale[i]),
+              (value) / (lengthes[i])
+            )
+          )
+        )
+      );
+    }
+
+    return value;
+  },
+
+  vectorToNum: function(vector) {
+    var num = 0,
+        i;
+
+    for (i = 0; i < vector.length; i++) {
+      num += Math.round(vector[i])*Math.pow(256, vector.length-i-1);
+    }
+    return num;
+  },
+
+  vectorSubtract: function(vector1, vector2) {
+    var vector = [],
+        i;
+
+    for (i = 0; i < vector1.length; i++) {
+      vector[i] = vector1[i] - vector2[i];
+    }
+    return vector;
+  },
+
+  vectorAdd: function(vector1, vector2) {
+    var vector = [],
+        i;
+
+    for (i = 0; i < vector1.length; i++) {
+      vector[i] = vector1[i] + vector2[i];
+    }
+    return vector;
+  },
+
+  vectorMult: function(vector, num) {
+    var result = [],
+        i;
+
+    for (i = 0; i < vector.length; i++) {
+      result[i] = vector[i] * num;
+    }
+    return result;
+  },
+
+  vectorLength: function(vector) {
+    var result = 0,
+        i;
+    for (i = 0; i < vector.length; i++) {
+      result += vector[i] * vector[i];
+    }
+    return Math.sqrt(result);
+  }
+};

data/vendor/assets/javascripts/jvectormap/lib/ordinal-scale.js

@@ -0,0 +1,7 @@
+jvm.OrdinalScale = function(scale){
+  this.scale = scale;
+};
+
+jvm.OrdinalScale.prototype.getValue = function(value){
+  return this.scale[value];
+};

data/vendor/assets/javascripts/jvectormap/lib/proj.js

@@ -0,0 +1,181 @@
+/**
+ * Contains methods for transforming point on sphere to
+ * Cartesian coordinates using various projections.
+ * @class
+ */
+jvm.Proj = {
+  degRad: 180 / Math.PI,
+  radDeg: Math.PI / 180,
+  radius: 6381372,
+
+  sgn: function(n){
+    if (n > 0) {
+      return 1;
+    } else if (n < 0) {
+      return -1;
+    } else {
+      return n;
+    }
+  },
+
+  /**
+   * Converts point on sphere to the Cartesian coordinates using Miller projection
+   * @param {Number} lat Latitude in degrees
+   * @param {Number} lng Longitude in degrees
+   * @param {Number} c Central meridian in degrees
+   */
+  mill: function(lat, lng, c){
+    return {
+      x: this.radius * (lng - c) * this.radDeg,
+      y: - this.radius * Math.log(Math.tan((45 + 0.4 * lat) * this.radDeg)) / 0.8
+    };
+  },
+
+  /**
+   * Inverse function of mill()
+   * Converts Cartesian coordinates to point on sphere using Miller projection
+   * @param {Number} x X of point in Cartesian system as integer
+   * @param {Number} y Y of point in Cartesian system as integer
+   * @param {Number} c Central meridian in degrees
+   */
+  mill_inv: function(x, y, c){
+    return {
+      lat: (2.5 * Math.atan(Math.exp(0.8 * y / this.radius)) - 5 * Math.PI / 8) * this.degRad,
+      lng: (c * this.radDeg + x / this.radius) * this.degRad
+    };
+  },
+
+  /**
+   * Converts point on sphere to the Cartesian coordinates using Mercator projection
+   * @param {Number} lat Latitude in degrees
+   * @param {Number} lng Longitude in degrees
+   * @param {Number} c Central meridian in degrees
+   */
+  merc: function(lat, lng, c){
+    return {
+      x: this.radius * (lng - c) * this.radDeg,
+      y: - this.radius * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360))
+    };
+  },
+
+  /**
+   * Inverse function of merc()
+   * Converts Cartesian coordinates to point on sphere using Mercator projection
+   * @param {Number} x X of point in Cartesian system as integer
+   * @param {Number} y Y of point in Cartesian system as integer
+   * @param {Number} c Central meridian in degrees
+   */
+  merc_inv: function(x, y, c){
+    return {
+      lat: (2 * Math.atan(Math.exp(y / this.radius)) - Math.PI / 2) * this.degRad,
+      lng: (c * this.radDeg + x / this.radius) * this.degRad
+    };
+  },
+
+  /**
+   * Converts point on sphere to the Cartesian coordinates using Albers Equal-Area Conic
+   * projection
+   * @see <a href="http://mathworld.wolfram.com/AlbersEqual-AreaConicProjection.html">Albers Equal-Area Conic projection</a>
+   * @param {Number} lat Latitude in degrees
+   * @param {Number} lng Longitude in degrees
+   * @param {Number} c Central meridian in degrees
+   */
+  aea: function(lat, lng, c){
+    var fi0 = 0,
+        lambda0 = c * this.radDeg,
+        fi1 = 29.5 * this.radDeg,
+        fi2 = 45.5 * this.radDeg,
+        fi = lat * this.radDeg,
+        lambda = lng * this.radDeg,
+        n = (Math.sin(fi1)+Math.sin(fi2)) / 2,
+        C = Math.cos(fi1)*Math.cos(fi1)+2*n*Math.sin(fi1),
+        theta = n*(lambda-lambda0),
+        ro = Math.sqrt(C-2*n*Math.sin(fi))/n,
+        ro0 = Math.sqrt(C-2*n*Math.sin(fi0))/n;
+
+    return {
+      x: ro * Math.sin(theta) * this.radius,
+      y: - (ro0 - ro * Math.cos(theta)) * this.radius
+    };
+  },
+
+  /**
+   * Converts Cartesian coordinates to the point on sphere using Albers Equal-Area Conic
+   * projection
+   * @see <a href="http://mathworld.wolfram.com/AlbersEqual-AreaConicProjection.html">Albers Equal-Area Conic projection</a>
+   * @param {Number} x X of point in Cartesian system as integer
+   * @param {Number} y Y of point in Cartesian system as integer
+   * @param {Number} c Central meridian in degrees
+   */
+  aea_inv: function(xCoord, yCoord, c){
+    var x = xCoord / this.radius,
+        y = yCoord / this.radius,
+        fi0 = 0,
+        lambda0 = c * this.radDeg,
+        fi1 = 29.5 * this.radDeg,
+        fi2 = 45.5 * this.radDeg,
+        n = (Math.sin(fi1)+Math.sin(fi2)) / 2,
+        C = Math.cos(fi1)*Math.cos(fi1)+2*n*Math.sin(fi1),
+        ro0 = Math.sqrt(C-2*n*Math.sin(fi0))/n,
+        ro = Math.sqrt(x*x+(ro0-y)*(ro0-y)),
+        theta = Math.atan( x / (ro0 - y) );
+
+    return {
+      lat: (Math.asin((C - ro * ro * n * n) / (2 * n))) * this.degRad,
+      lng: (lambda0 + theta / n) * this.degRad
+    };
+  },
+
+  /**
+   * Converts point on sphere to the Cartesian coordinates using Lambert conformal
+   * conic projection
+   * @see <a href="http://mathworld.wolfram.com/LambertConformalConicProjection.html">Lambert Conformal Conic Projection</a>
+   * @param {Number} lat Latitude in degrees
+   * @param {Number} lng Longitude in degrees
+   * @param {Number} c Central meridian in degrees
+   */
+  lcc: function(lat, lng, c){
+    var fi0 = 0,
+        lambda0 = c * this.radDeg,
+        lambda = lng * this.radDeg,
+        fi1 = 33 * this.radDeg,
+        fi2 = 45 * this.radDeg,
+        fi = lat * this.radDeg,
+        n = Math.log( Math.cos(fi1) * (1 / Math.cos(fi2)) ) / Math.log( Math.tan( Math.PI / 4 + fi2 / 2) * (1 / Math.tan( Math.PI / 4 + fi1 / 2) ) ),
+        F = ( Math.cos(fi1) * Math.pow( Math.tan( Math.PI / 4 + fi1 / 2 ), n ) ) / n,
+        ro = F * Math.pow( 1 / Math.tan( Math.PI / 4 + fi / 2 ), n ),
+        ro0 = F * Math.pow( 1 / Math.tan( Math.PI / 4 + fi0 / 2 ), n );
+
+    return {
+      x: ro * Math.sin( n * (lambda - lambda0) ) * this.radius,
+      y: - (ro0 - ro * Math.cos( n * (lambda - lambda0) ) ) * this.radius
+    };
+  },
+
+  /**
+   * Converts Cartesian coordinates to the point on sphere using Lambert conformal conic
+   * projection
+   * @see <a href="http://mathworld.wolfram.com/LambertConformalConicProjection.html">Lambert Conformal Conic Projection</a>
+   * @param {Number} x X of point in Cartesian system as integer
+   * @param {Number} y Y of point in Cartesian system as integer
+   * @param {Number} c Central meridian in degrees
+   */
+  lcc_inv: function(xCoord, yCoord, c){
+    var x = xCoord / this.radius,
+        y = yCoord / this.radius,
+        fi0 = 0,
+        lambda0 = c * this.radDeg,
+        fi1 = 33 * this.radDeg,
+        fi2 = 45 * this.radDeg,
+        n = Math.log( Math.cos(fi1) * (1 / Math.cos(fi2)) ) / Math.log( Math.tan( Math.PI / 4 + fi2 / 2) * (1 / Math.tan( Math.PI / 4 + fi1 / 2) ) ),
+        F = ( Math.cos(fi1) * Math.pow( Math.tan( Math.PI / 4 + fi1 / 2 ), n ) ) / n,
+        ro0 = F * Math.pow( 1 / Math.tan( Math.PI / 4 + fi0 / 2 ), n ),
+        ro = this.sgn(n) * Math.sqrt(x*x+(ro0-y)*(ro0-y)),
+        theta = Math.atan( x / (ro0 - y) );
+
+    return {
+      lat: (2 * Math.atan(Math.pow(F/ro, 1/n)) - Math.PI / 2) * this.degRad,
+      lng: (lambda0 + theta / n) * this.degRad
+    };
+  }
+};

data/vendor/assets/javascripts/jvectormap/lib/simple-scale.js

@@ -0,0 +1,7 @@
+jvm.SimpleScale = function(scale){
+  this.scale = scale;
+};
+
+jvm.SimpleScale.prototype.getValue = function(value){
+  return value;
+};

data/vendor/assets/javascripts/jvectormap/lib/svg-canvas-element.js

@@ -0,0 +1,22 @@
+jvm.SVGCanvasElement = function(container, width, height){
+  this.classPrefix = 'SVG';
+  jvm.SVGCanvasElement.parentClass.call(this, 'svg');
+  jvm.AbstractCanvasElement.apply(this, arguments);
+}
+
+jvm.inherits(jvm.SVGCanvasElement, jvm.SVGElement);
+jvm.mixin(jvm.SVGCanvasElement, jvm.AbstractCanvasElement);
+
+jvm.SVGCanvasElement.prototype.setSize = function(width, height){
+  this.width = width;
+  this.height = height;
+  this.node.setAttribute('width', width);
+  this.node.setAttribute('height', height);
+};
+
+jvm.SVGCanvasElement.prototype.applyTransformParams = function(scale, transX, transY) {
+  this.scale = scale;
+  this.transX = transX;
+  this.transY = transY;
+  this.rootElement.node.setAttribute('transform', 'scale('+scale+') translate('+transX+', '+transY+')');
+};

data/vendor/assets/javascripts/jvectormap/lib/svg-circle-element.js

@@ -0,0 +1,5 @@
+jvm.SVGCircleElement = function(config, style){
+  jvm.SVGCircleElement.parentClass.call(this, 'circle', config, style);
+};
+
+jvm.inherits(jvm.SVGCircleElement, jvm.SVGShapeElement);

data/vendor/assets/javascripts/jvectormap/lib/svg-element.js

@@ -0,0 +1,48 @@
+/**
+ * Wrapper for SVG element.
+ * @constructor
+ * @extends jvm.AbstractElement
+ * @param {String} name Tag name of the element
+ * @param {Object} config Set of parameters to initialize element with
+ */
+
+jvm.SVGElement = function(name, config){
+  jvm.SVGElement.parentClass.apply(this, arguments);
+}
+
+jvm.inherits(jvm.SVGElement, jvm.AbstractElement);
+
+jvm.SVGElement.svgns = "http://www.w3.org/2000/svg";
+
+/**
+ * Creates DOM element.
+ * @param {String} tagName Name of element
+ * @private
+ * @returns DOMElement
+ */
+jvm.SVGElement.prototype.createElement = function( tagName ){
+  return document.createElementNS( jvm.SVGElement.svgns, tagName );
+};
+
+/**
+ * Adds CSS class for underlying DOM element.
+ * @param {String} className Name of CSS class name
+ */
+jvm.SVGElement.prototype.addClass = function( className ){
+  this.node.setAttribute('class', className);
+};
+
+/**
+ * Returns constructor for element by name prefixed with 'VML'.
+ * @param {String} ctr Name of basic constructor to return
+ * proper implementation for.
+ * @returns Function
+ * @private
+ */
+jvm.SVGElement.prototype.getElementCtr = function( ctr ){
+  return jvm['SVG'+ctr];
+};
+
+jvm.SVGElement.prototype.getBBox = function(){
+  return this.node.getBBox();
+};

data/vendor/assets/javascripts/jvectormap/lib/svg-group-element.js

@@ -0,0 +1,9 @@
+jvm.SVGGroupElement = function(){
+  jvm.SVGGroupElement.parentClass.call(this, 'g');
+}
+
+jvm.inherits(jvm.SVGGroupElement, jvm.SVGElement);
+
+jvm.SVGGroupElement.prototype.add = function(element){
+  this.node.appendChild( element.node );
+};

data/vendor/assets/javascripts/jvectormap/lib/svg-path-element.js

@@ -0,0 +1,6 @@
+jvm.SVGPathElement = function(config, style){
+  jvm.SVGPathElement.parentClass.call(this, 'path', config, style);
+  this.node.setAttribute('fill-rule', 'evenodd');
+}
+
+jvm.inherits(jvm.SVGPathElement, jvm.SVGShapeElement);

data/vendor/assets/javascripts/jvectormap/lib/svg-shape-element.js

@@ -0,0 +1,7 @@
+jvm.SVGShapeElement = function(name, config, style){
+  jvm.SVGShapeElement.parentClass.call(this, name, config);
+  jvm.AbstractShapeElement.apply(this, arguments);
+};
+
+jvm.inherits(jvm.SVGShapeElement, jvm.SVGElement);
+jvm.mixin(jvm.SVGShapeElement, jvm.AbstractShapeElement);