├── bower.json
├── changelog
├── lib
    ├── geostats.css
    ├── geostats.js
    └── geostats.min.js
├── package.json
├── readme.md
├── sample.html
├── sample_shp.html
└── tests
    ├── js-shapefile-to-geojson
        ├── dbf.js
        ├── readme.md
        ├── shapefile.js
        ├── stream.js
        └── testdata
        │   ├── world.dbf
        │   └── world.shp
    ├── openlayers_sample.js
    ├── qunit_test.html
    └── test.json


/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "geostats",
 3 |   "repo": "simogeo/geostats",
 4 |   "description": "a tiny and standalone javascript library for classification and basic statistics",
 5 |   "keywords": ["mapping", "map", "classification", "choropleth", "stats", "statistics", "math"],
 6 |   "dependencies": {},
 7 |   "development": {},
 8 |   "main": [
 9 |     "lib/geostats.min.js"
10 |   ]
11 | }


--------------------------------------------------------------------------------
/changelog:
--------------------------------------------------------------------------------
 1 | From version 1.8.0 to 2.0.0
 2 | ---------------------------
 3 | - Typescript compatibility | issue #51
 4 | - Prevent Jenks breaks error when data.length is less than nbClass | issue #57
 5 | - Switch from 1.8.0 to 2.0.0 because of npm error 
 6 | 
 7 | 
 8 | From version 1.7.0 to 1.8.0
 9 | ---------------------------
10 | - Fixing bug on counter when using using getClassUniqueValues() method | issue #50 
11 | - Ensure nbClass param is an integer | issue #45
12 | - Optimized getClassJenks() method | issue #49
13 | - Old Jenks method still available by calling getClassJenks2() method
14 | - Fix the default legend style, so items are aligned vertically | issue #48
15 | 
16 | 
17 | From version 1.6.0 to 1.7.0
18 | ---------------------------
19 | - Creating temporary variables instead of calling functions several times | issue #40
20 | - Fix minified version | issue #43
21 | - Updating NPM | issue #43
22 | 
23 | 
24 | From version 1.5.0 to 1.6.0
25 | ---------------------------
26 | - Typo bug converting string to float | issue #32
27 | - Force precision to 20 if user defined is superior - to prevent browser error | issue #34
28 | - Mean calculation outside loop | issue #35
29 | - Min / Max methods handled without using Math function | supposed to prevent issue #33
30 | - Cast values to Float on decimalFormat method | issue #36
31 | 
32 | 
33 | From version 1.4.0 to 1.5.0
34 | ---------------------------
35 | - Reset attributes after setting a new serie | issue #29
36 | 
37 | 
38 | From version 1.3.0 to 1.4.0
39 | ---------------------------
40 | - Return legend to wanted float format using decimals if needed - with 'distinct' mode | issue #26
41 | - Ability to match min / max bounds when calling getClassStdDeviation() | issue #27
42 | 
43 | 
44 | From version 1.2.0 to 1.3.0
45 | ---------------------------
46 | - Fixing decimalFormat() bug returned values | issue #19
47 | - Fixing Quantile classification bug | issue #18
48 | - Modularisation, for use with nodeJS or requireJS  | issue #16
49 | - Ability to reverse legend order | issue #24 
50 | - Introducing a silent mode on input errors | issue #25
51 | 
52 | 
53 | From version 1.1.0 to 1.2.0
54 | ---------------------------
55 | - Introducing geometric progression classification (getGeometricProgression() method)
56 | - Introducing user defined classification (setManualClassification() method)
57 | - Introducing CommonJS and NodeJS or RequireJS module formats
58 | - Use of indexOf native version
59 | 
60 | 
61 | From version 1.0.0 to 1.1.0
62 | ---------------------------
63 | - Removing useless lib/jenks.util.js file
64 | - Introducing changelog


--------------------------------------------------------------------------------
/lib/geostats.css:
--------------------------------------------------------------------------------
 1 | .geostats-legend div {
 2 |   margin:3px 10px 5px 10px;
 3 |   clear:left;
 4 | }
 5 | 
 6 | .geostats-legend-title {
 7 |   font-weight: bold;
 8 |   margin-bottom: 4px;
 9 | }
10 | 
11 | .geostats-legend-block {
12 |   border: 1px solid #555555;
13 |   display: block;
14 |   float: left;
15 |   height: 12px;
16 |   margin: 0 5px 0 20px;
17 |   width: 20px;
18 | }
19 | 
20 | .geostats-legend-counter { 
21 |   font-size: 0.8em;
22 |   color:#666;
23 |   font-style: italic;
24 | }
25 | 


--------------------------------------------------------------------------------
/lib/geostats.js:
--------------------------------------------------------------------------------
   1 | /**
   2 | * geostats() is a tiny and standalone javascript library for classification 
   3 | * Project page - https://github.com/simogeo/geostats
   4 | * Copyright (c) 2011 Simon Georget, http://www.intermezzo-coop.eu
   5 | * Licensed under the MIT license
   6 | */
   7 | 
   8 | 
   9 | (function (definition) {
  10 |     // This file will function properly as a <script> tag, or a module
  11 |     // using CommonJS and NodeJS or RequireJS module formats.
  12 | 
  13 |     // CommonJS
  14 |     if (typeof exports === "object") {
  15 |         module.exports = definition();
  16 | 
  17 |     // RequireJS
  18 |     } else if (typeof define === "function" && define.amd) {
  19 |         define(definition);
  20 | 
  21 |     // <script>
  22 |     } else {
  23 |         geostats = definition();
  24 |     }
  25 | 
  26 | })(function () {
  27 | 
  28 | var isInt = function(n) {
  29 |    return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
  30 | } // 6 characters
  31 | 
  32 | var _t = function(str) {
  33 | 	return str;
  34 | };
  35 | 
  36 | //taking from http://stackoverflow.com/questions/18082/validate-decimal-numbers-in-javascript-isnumeric
  37 | var isNumber = function(n) {
  38 | 	  return !isNaN(parseFloat(n)) && isFinite(n);
  39 | }
  40 | 
  41 | 
  42 | 
  43 | //indexOf polyfill
  44 | // from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf
  45 | if (!Array.prototype.indexOf) {
  46 |     Array.prototype.indexOf = function (searchElement, fromIndex) {
  47 |       if ( this === undefined || this === null ) {
  48 |         throw new TypeError( '"this" is null or not defined' );
  49 |       }
  50 | 
  51 |       var length = this.length >>> 0; // Hack to convert object.length to a UInt32
  52 | 
  53 |       fromIndex = +fromIndex || 0;
  54 | 
  55 |       if (Math.abs(fromIndex) === Infinity) {
  56 |         fromIndex = 0;
  57 |       }
  58 | 
  59 |       if (fromIndex < 0) {
  60 |         fromIndex += length;
  61 |         if (fromIndex < 0) {
  62 |           fromIndex = 0;
  63 |         }
  64 |       }
  65 | 
  66 |       for (;fromIndex < length; fromIndex++) {
  67 |         if (this[fromIndex] === searchElement) {
  68 |           return fromIndex;
  69 |         }
  70 |       }
  71 | 
  72 |       return -1;
  73 |     };
  74 |   }
  75 | 
  76 | var geostats = function(a) {
  77 | 
  78 | 	this.objectID = '';
  79 | 	this.separator = ' - ';
  80 | 	this.legendSeparator = this.separator;
  81 | 	this.method  = '';
  82 | 	this.precision = 0;
  83 | 	this.precisionflag = 'auto';
  84 | 	this.roundlength 	= 2; // Number of decimals, round values
  85 | 	this.is_uniqueValues = false;
  86 | 	this.debug =  false;
  87 | 	this.silent = false;
  88 | 	
  89 | 	this.bounds  = Array();
  90 | 	this.ranges  = Array();
  91 | 	this.inner_ranges  = null;
  92 | 	this.colors  = Array();
  93 | 	this.counter = Array();
  94 | 	
  95 | 	// statistics information
  96 | 	this.stat_sorted	= null;
  97 | 	this.stat_mean 		= null;
  98 | 	this.stat_median 	= null;
  99 | 	this.stat_sum 		= null;
 100 | 	this.stat_max 		= null;
 101 | 	this.stat_min 		= null;
 102 | 	this.stat_pop 		= null;
 103 | 	this.stat_variance	= null;
 104 | 	this.stat_stddev	= null;
 105 | 	this.stat_cov		= null;
 106 | 
 107 | 	
 108 | 	/**
 109 | 	 * logging method
 110 | 	 */
 111 | 	this.log = function(msg, force) {
 112 | 	
 113 | 		if(this.debug == true || force != null)
 114 | 			console.log(this.objectID + "(object id) :: " + msg);
 115 | 		
 116 | 	};
 117 | 	
 118 | 	/**
 119 | 	 * Set bounds
 120 | 	 */
 121 | 	this.setBounds = function(a) {
 122 | 		
 123 | 		this.log('Setting bounds (' + a.length + ') : ' + a.join());
 124 | 	
 125 | 		this.bounds = Array() // init empty array to prevent bug when calling classification after another with less items (sample getQuantile(6) and getQuantile(4))
 126 | 		
 127 | 		this.bounds = a;
 128 | 		//this.bounds = this.decimalFormat(a);
 129 | 		
 130 | 	};
 131 | 	
 132 | 	/**
 133 | 	 * Set a new serie
 134 | 	 */
 135 | 	this.setSerie = function(a) {
 136 | 		
 137 | 		this.log('Setting serie (' + a.length + ') : ' + a.join());
 138 | 	
 139 | 		this.serie = Array() // init empty array to prevent bug when calling classification after another with less items (sample getQuantile(6) and getQuantile(4))
 140 | 		this.serie = a;
 141 | 		
 142 | 		//reset statistics after changing serie
 143 | 	    this.resetStatistics();
 144 | 	    
 145 | 		this.setPrecision();
 146 | 		
 147 | 	};
 148 | 	
 149 | 	/**
 150 | 	 * Set colors
 151 | 	 */
 152 | 	this.setColors = function(colors) {
 153 | 		
 154 | 		this.log('Setting color ramp (' + colors.length + ') : '  + colors.join());
 155 | 		
 156 | 		this.colors = colors;
 157 | 		
 158 | 	};
 159 | 	
 160 | 	/**
 161 | 	 * Get feature count
 162 | 	 * With bounds array(0, 0.75, 1.5, 2.25, 3); 
 163 | 	 * should populate this.counter with 5 keys
 164 | 	 * and increment counters for each key
 165 | 	 */
 166 | 	this.doCount = function() {
 167 | 
 168 | 		if (this._nodata())
 169 | 			return;
 170 | 		
 171 | 
 172 | 		var tmp = this.sorted();
 173 | 		
 174 | 		this.counter = new Array();
 175 | 		
 176 | 		// we init counter with 0 value
 177 | 		if(this.is_uniqueValues == true) {
 178 | 			for (var i = 0; i < this.bounds.length; i++) {
 179 | 				this.counter[i]= 0;
 180 | 			}
 181 | 		} else {
 182 | 			for (var i = 0; i < this.bounds.length -1; i++) {
 183 | 				this.counter[i]= 0;
 184 | 			}
 185 | 		}
 186 | 		
 187 | 		for (var j=0; j < tmp.length; j++) {
 188 | 			
 189 | 			// get current class for value to increment the counter
 190 | 			var cclass = this.getClass(tmp[j]);
 191 | 			this.counter[cclass]++;
 192 | 
 193 | 		}		
 194 | 
 195 | 	};
 196 | 	
 197 | 	/**
 198 | 	 * Set decimal precision according to user input
 199 | 	 * or automatcally determined according
 200 | 	 * to the given serie.
 201 | 	 */
 202 | 	this.setPrecision = function(decimals) {
 203 | 		
 204 | 		// only when called from user
 205 | 		if(typeof decimals !== "undefined") {
 206 | 			this.precisionflag = 'manual';
 207 | 			this.precision = decimals;
 208 | 		}
 209 | 		
 210 | 		// we calculate the maximal decimal length on given serie
 211 | 		if(this.precisionflag == 'auto') {
 212 | 			
 213 | 			for (var i = 0; i < this.serie.length; i++) {
 214 | 				
 215 | 				// check if the given value is a number and a float
 216 | 				if (!isNaN((this.serie[i]+"")) && (this.serie[i]+"").toString().indexOf('.') != -1) {
 217 | 					var precision = (this.serie[i] + "").split(".")[1].length;
 218 | 				} else {
 219 | 					var precision = 0;
 220 | 				}
 221 | 				
 222 | 				if(precision > this.precision) {
 223 | 					this.precision = precision;
 224 | 				}
 225 | 				
 226 | 			}
 227 | 			
 228 | 		}
 229 | 		if(this.precision > 20) {
 230 | 			// prevent "Uncaught RangeError: toFixed() digits argument must be between 0 and 20" bug. See https://github.com/simogeo/geostats/issues/34
 231 | 			this.log('this.precision value (' + this.precision + ') is greater than max value. Automatic set-up to 20 to prevent "Uncaught RangeError: toFixed()" when calling decimalFormat() method.');
 232 | 			this.precision = 20;
 233 | 		}
 234 | 
 235 | 		this.log('Calling setPrecision(). Mode : ' + this.precisionflag + ' - Decimals : '+ this.precision);
 236 | 		
 237 | 		this.serie = this.decimalFormat(this.serie);
 238 | 		
 239 | 	};
 240 | 	
 241 | 	/**
 242 | 	 * Format array numbers regarding to precision
 243 | 	 */
 244 | 	this.decimalFormat = function(a) {
 245 | 		
 246 | 		var b = new Array();
 247 | 		
 248 | 		for (var i = 0; i < a.length; i++) {
 249 | 			// check if the given value is a number
 250 | 			if (isNumber(a[i])) {
 251 | 				b[i] = parseFloat(parseFloat(a[i]).toFixed(this.precision));
 252 | 			} else {
 253 | 				b[i] = a[i];
 254 | 			}
 255 | 		}
 256 | 		
 257 | 		return b;
 258 | 	}
 259 | 	
 260 | 	/**
 261 | 	 * Transform a bounds array to a range array the following array : array(0,
 262 | 	 * 0.75, 1.5, 2.25, 3); becomes : array('0-0.75', '0.75-1.5', '1.5-2.25',
 263 | 	 * '2.25-3');
 264 | 	 */
 265 | 	this.setRanges = function() {
 266 | 	
 267 | 		this.ranges = Array(); // init empty array to prevent bug when calling classification after another with less items (sample getQuantile(6) and getQuantile(4))
 268 | 		
 269 | 		for (var i = 0; i < (this.bounds.length - 1); i++) {
 270 | 			this.ranges[i] = this.bounds[i] + this.separator + this.bounds[i + 1];
 271 | 		}
 272 | 	};
 273 | 
 274 | 	/** return min value */
 275 | 	this.min = function(exclude = []) {
 276 | 		
 277 | 		if (this._nodata())
 278 | 			return;
 279 | 		
 280 | 		if(!exclude.includes(this.serie[0])) this.stat_min = this.serie[0];
 281 | 		else this.stat_min = 999999999999;
 282 | 		
 283 | 		
 284 | 		for (var i = 0; i < this.pop(); i++) {
 285 | 			if (this.serie[i] < this.stat_min && !exclude.includes(this.serie[i])) {
 286 | 				this.stat_min = this.serie[i];
 287 | 			}
 288 | 		}
 289 | 
 290 | 		return this.stat_min;
 291 | 	};
 292 | 
 293 | 	/** return max value */
 294 | 	this.max = function(exclude = []) {
 295 | 		
 296 | 		if (this._nodata())
 297 | 			return;
 298 | 		
 299 | 		if(!exclude.includes(this.serie[0])) this.stat_max = this.serie[0];
 300 | 		else this.stat_max = -999999999999;
 301 | 		
 302 | 		for (var i = 0; i < this.pop(); i++) {
 303 | 			if (this.serie[i] > this.stat_max && !exclude.includes(this.serie[i])) {
 304 | 				this.stat_max = this.serie[i];
 305 | 			}
 306 | 		}
 307 | 		
 308 | 		return this.stat_max;
 309 | 	};
 310 | 
 311 | 	/** return sum value */
 312 | 	this.sum = function() {
 313 | 		
 314 | 		if (this._nodata())
 315 | 			return;
 316 | 		
 317 | 		if (this.stat_sum  == null) {
 318 | 			
 319 | 			this.stat_sum = 0;
 320 | 			for (var i = 0; i < this.pop(); i++) {
 321 | 				this.stat_sum += parseFloat(this.serie[i]);
 322 | 			}
 323 | 			
 324 | 		}
 325 | 		
 326 | 		return this.stat_sum;
 327 | 	};
 328 | 
 329 | 	/** return population number */
 330 | 	this.pop = function() {
 331 | 		
 332 | 		if (this._nodata())
 333 | 			return;
 334 | 		
 335 | 		if (this.stat_pop  == null) {
 336 | 			
 337 | 			this.stat_pop = this.serie.length;
 338 | 			
 339 | 		}
 340 | 		
 341 | 		return this.stat_pop;
 342 | 	};
 343 | 
 344 | 	/** return mean value */
 345 | 	this.mean = function() {
 346 | 		
 347 | 		if (this._nodata())
 348 | 			return;
 349 | 
 350 | 		if (this.stat_mean  == null) {
 351 | 			
 352 | 			this.stat_mean = parseFloat(this.sum() / this.pop());
 353 | 			
 354 | 		}
 355 | 		
 356 | 		return this.stat_mean;
 357 | 	};
 358 | 
 359 | 	/** return median value */
 360 | 	this.median = function() {
 361 | 		
 362 | 		if (this._nodata())
 363 | 			return;
 364 | 		
 365 | 		if (this.stat_median  == null) {
 366 | 			
 367 | 			this.stat_median = 0;
 368 | 			var tmp = this.sorted();
 369 | 			
 370 | 			// serie pop is odd
 371 | 			if (tmp.length % 2) {
 372 | 				this.stat_median = parseFloat(tmp[(Math.ceil(tmp.length / 2) - 1)]);
 373 | 				
 374 | 			// serie pop is even
 375 | 			} else {
 376 | 				this.stat_median = ( parseFloat(tmp[((tmp.length / 2) - 1)]) + parseFloat(tmp[(tmp.length / 2)]) ) / 2;
 377 | 			}
 378 | 			
 379 | 		}
 380 | 		
 381 | 		return this.stat_median;
 382 | 	};
 383 | 
 384 | 	/** return variance value */
 385 | 	this.variance = function() {
 386 | 		
 387 | 		var round = (typeof round === "undefined") ? true : false;
 388 | 		
 389 | 		if (this._nodata())
 390 | 			return;
 391 | 		
 392 | 		if (this.stat_variance  == null) {
 393 | 
 394 | 			var tmp = 0, serie_mean = this.mean();
 395 | 			for (var i = 0; i < this.pop(); i++) {
 396 | 				tmp += Math.pow( (this.serie[i] - serie_mean), 2 );
 397 | 			}
 398 | 
 399 | 			this.stat_variance =  tmp / this.pop();
 400 | 			
 401 | 			if(round == true) {
 402 | 				this.stat_variance = Math.round(this.stat_variance * Math.pow(10,this.roundlength) )/ Math.pow(10,this.roundlength);
 403 | 			}
 404 | 			
 405 | 		}
 406 | 		
 407 | 		return this.stat_variance;
 408 | 	};
 409 | 	
 410 | 	/** return standard deviation value */
 411 | 	this.stddev = function(round) {
 412 | 		
 413 | 		var round = (typeof round === "undefined") ? true : false;
 414 | 		
 415 | 		if (this._nodata())
 416 | 			return;
 417 | 		
 418 | 		if (this.stat_stddev  == null) {
 419 | 			
 420 | 			this.stat_stddev = Math.sqrt(this.variance());
 421 | 			
 422 | 			if(round == true) {
 423 | 				this.stat_stddev = Math.round(this.stat_stddev * Math.pow(10,this.roundlength) )/ Math.pow(10,this.roundlength);
 424 | 			}
 425 | 			
 426 | 		}
 427 | 		
 428 | 		return this.stat_stddev;
 429 | 	};
 430 | 	
 431 | 	/** coefficient of variation - measure of dispersion */
 432 | 	this.cov = function(round) {
 433 | 		
 434 | 		var round = (typeof round === "undefined") ? true : false;
 435 | 		
 436 | 		if (this._nodata())
 437 | 			return;
 438 | 		
 439 | 		if (this.stat_cov  == null) {
 440 | 			
 441 | 			this.stat_cov = this.stddev() / this.mean();
 442 | 			
 443 | 			if(round == true) {
 444 | 				this.stat_cov = Math.round(this.stat_cov * Math.pow(10,this.roundlength) )/ Math.pow(10,this.roundlength);
 445 | 			}
 446 | 			
 447 | 		}
 448 | 		
 449 | 		return this.stat_cov;
 450 | 	};
 451 | 	
 452 | 	/** reset all attributes after setting a new serie */
 453 | 	this.resetStatistics = function() {
 454 | 	    this.stat_sorted    = null;
 455 | 	    this.stat_mean  = null;
 456 | 	    this.stat_median    = null;
 457 | 	    this.stat_sum       = null;
 458 | 	    this.stat_max       = null;
 459 | 	    this.stat_min       = null;
 460 | 	    this.stat_pop       = null;
 461 | 	    this.stat_variance  = null;
 462 | 	    this.stat_stddev    = null;
 463 | 	    this.stat_cov       = null;
 464 | 	}
 465 | 	
 466 | 	/** data test */
 467 | 	this._nodata = function() {
 468 | 		if (this.serie.length == 0) {
 469 | 			
 470 | 			if(this.silent) this.log("[silent mode] Error. You should first enter a serie!", true);
 471 | 			else throw new TypeError("Error. You should first enter a serie!");
 472 | 			return 1;
 473 | 		} else
 474 | 			return 0;
 475 | 		
 476 | 	};
 477 | 	
 478 | 	/** data test */
 479 | 	this._classificationCheck = function(nbClass) {
 480 | 
 481 | 		if(nbClass >= this.pop()) {
 482 | 			var errnum ='Error. ' + nbClass + ' classes are defined for only ' + this.pop() + ' values in serie ! For the current serie, no more than ' + (this.pop() - 1 ) + ' classes can be defined.';
 483 | 			
 484 | 			if(this.silent) this.log(errnum, true);
 485 | 			else {
 486 | 				alert(errnum);
 487 | 				throw new TypeError(errnum);
 488 | 			}
 489 | 			
 490 | 		}
 491 | 		
 492 | 	};
 493 | 	
 494 | 	/** ensure nbClass is an integer */
 495 | 	this._nbClassInt = function(nbClass) {
 496 | 		
 497 | 		var nbclassTmp = parseInt(nbClass, 10);
 498 | 		if (isNaN(nbclassTmp)) {
 499 | 			if(this.silent) this.log("[silent mode] '" + nbclassTmp + "' is not a valid integer. Enable to set class number.", true);
 500 | 			else throw new TypeError("'" + nbclassTmp + "' is not a valid integer. Enable to set class number.");
 501 | 		} else {
 502 | 			return nbclassTmp;
 503 | 		}
 504 | 		
 505 | 	};
 506 | 	
 507 | 	/** check if the serie contains negative value */
 508 | 	this._hasNegativeValue = function() {
 509 | 		
 510 | 		for (var i = 0; i < this.serie.length; i++) {
 511 | 	    	if(this.serie[i] < 0)
 512 | 	    		return true;
 513 | 	    }
 514 | 
 515 | 		return false;
 516 | 	};
 517 | 	
 518 | 	/** check if the serie contains zero value */
 519 | 	this._hasZeroValue = function() {
 520 | 		
 521 | 		for (var i = 0; i < this.serie.length; i++) {
 522 | 	    	if(parseFloat(this.serie[i]) === 0)
 523 | 	    		return true;
 524 | 	    }
 525 | 
 526 | 		return false;
 527 | 	};
 528 | 
 529 | 	/** return sorted values (as array) */
 530 | 	this.sorted = function() {
 531 | 		
 532 | 		if (this.stat_sorted  == null) {
 533 | 			
 534 | 			if(this.is_uniqueValues == false) {
 535 | 				this.stat_sorted = this.serie.sort(function(a, b) {
 536 | 					return a - b;
 537 | 				});
 538 | 			} else {
 539 | 				this.stat_sorted = this.serie.sort(function(a,b){
 540 | 					var nameA=a.toString().toLowerCase(), nameB=b.toString().toLowerCase();
 541 | 				    if(nameA < nameB) return -1;
 542 | 				    if(nameA > nameB) return 1;
 543 | 				    return 0;
 544 | 				})
 545 | 			}
 546 | 		}
 547 | 		
 548 | 		return this.stat_sorted;
 549 | 		
 550 | 	};
 551 | 
 552 | 	/** return all info */
 553 | 	this.info = function() {
 554 | 		
 555 | 		if (this._nodata())
 556 | 			return;
 557 | 		
 558 | 		var content = '';
 559 | 		content += _t('Population') + ' : ' + this.pop() + ' - [' + _t('Min')
 560 | 				+ ' : ' + this.min() + ' | ' + _t('Max') + ' : ' + this.max()
 561 | 				+ ']' + "\n";
 562 | 		content += _t('Mean') + ' : ' + this.mean() + ' - ' + _t('Median')	+ ' : ' + this.median() + "\n";
 563 | 		content += _t('Variance') + ' : ' + this.variance() + ' - ' + _t('Standard deviation')	+ ' : ' + this.stddev()  
 564 | 				+ ' - ' + _t('Coefficient of variation')	+ ' : ' + this.cov() + "\n";
 565 | 
 566 | 		return content;
 567 | 	};
 568 | 	
 569 | 	/**
 570 | 	 * Set Manual classification Return an array with bounds : ie array(0,
 571 | 	 * 0.75, 1.5, 2.25, 3);
 572 | 	 * Set ranges and prepare data for displaying legend
 573 | 	 * 
 574 | 	 */
 575 | 	this.setClassManually = function(array) {
 576 | 
 577 | 		if (this._nodata())
 578 | 	        return;
 579 | 
 580 | 	    if(array[0] !== this.min() || array[array.length-1] !== this.max()) {
 581 | 	    	if(this.silent) this.log("[silent mode] " + t('Given bounds may not be correct! please check your input.\nMin value : ' + this.min() + ' / Max value : ' + this.max()), true);
 582 | 			else throw new TypeError(_t('Given bounds may not be correct! please check your input.\nMin value : ' + this.min() + ' / Max value : ' + this.max()));
 583 | 	    	return; 
 584 | 	    }
 585 | 
 586 | 	    this.setBounds(array);
 587 | 	    this.setRanges();
 588 | 	    
 589 | 	    // we specify the classification method
 590 | 	    this.method = _t('manual classification') + ' (' + (array.length -1) + ' ' + _t('classes') + ')';
 591 | 
 592 | 	    return this.bounds;
 593 | 	};
 594 | 
 595 | 	/**
 596 | 	 * Equal intervals classification Return an array with bounds : ie array(0,
 597 | 	 * 0.75, 1.5, 2.25, 3);
 598 | 	 */
 599 | 	this.getClassEqInterval = function(nbClass, forceMin, forceMax) {
 600 | 
 601 | 		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
 602 | 		
 603 | 		if (this._nodata())
 604 | 	        return;
 605 | 		
 606 | 		var tmpMin = (typeof forceMin === "undefined") ? this.min() : forceMin;
 607 | 		var tmpMax = (typeof forceMax === "undefined") ? this.max() : forceMax;
 608 | 		
 609 | 	    var a = Array();
 610 | 	    var val = tmpMin;
 611 | 	    var interval = (tmpMax - tmpMin) / nbClass;
 612 | 
 613 | 	    for (var i = 0; i <= nbClass; i++) {
 614 | 	        a[i] = val;
 615 | 	        val += interval;
 616 | 	    }
 617 | 
 618 | 	    //-> Fix last bound to Max of values
 619 | 	    a[nbClass] = tmpMax;
 620 | 
 621 | 	    this.setBounds(a);
 622 | 	    this.setRanges();
 623 | 	    
 624 | 	    // we specify the classification method
 625 | 	    this.method = _t('eq. intervals') + ' (' + nbClass + ' ' + _t('classes') + ')';
 626 | 
 627 | 	    return this.bounds;
 628 | 	};
 629 | 	
 630 | 
 631 | 	this.getQuantiles = function(nbClass) {
 632 | 		
 633 | 		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
 634 | 		
 635 | 		var tmp = this.sorted();
 636 | 		var quantiles = [];
 637 | 
 638 | 		var step = this.pop() / nbClass;
 639 | 		for (var i = 1; i < nbClass; i++) {
 640 | 			var qidx = Math.round(i*step+0.49);
 641 | 			quantiles.push(tmp[qidx-1]); // zero-based
 642 | 		}
 643 | 
 644 | 		return quantiles;
 645 | 	};
 646 | 
 647 | 	/**
 648 | 	 * Quantile classification Return an array with bounds : ie array(0, 0.75,
 649 | 	 * 1.5, 2.25, 3);
 650 | 	 */
 651 | 	this.getClassQuantile = function(nbClass) {
 652 | 
 653 | 		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
 654 | 		
 655 | 		if (this._nodata())
 656 | 			return;
 657 | 		
 658 | 		this._classificationCheck(nbClass); // be sure number of classes is valid
 659 | 
 660 | 		var tmp = this.sorted();
 661 | 		var bounds = this.getQuantiles(nbClass);
 662 | 		bounds.unshift(tmp[0]);
 663 | 
 664 | 		if (bounds[tmp.length - 1] !== tmp[tmp.length - 1])
 665 | 			bounds.push(tmp[tmp.length - 1]);
 666 | 
 667 | 		this.setBounds(bounds);
 668 | 		this.setRanges();
 669 | 
 670 | 		// we specify the classification method
 671 | 		this.method = _t('quantile') + ' (' + nbClass + ' ' + _t('classes') + ')';
 672 | 
 673 | 		return this.bounds;
 674 | 
 675 | 	};
 676 | 	
 677 | 	/**
 678 | 	 * Standard Deviation classification
 679 | 	 * Return an array with bounds : ie array(0,
 680 | 	 * 0.75, 1.5, 2.25, 3);
 681 | 	 */
 682 | 	this.getClassStdDeviation = function(nbClass, matchBounds) {
 683 | 
 684 | 		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
 685 | 		
 686 | 		if (this._nodata())
 687 | 	        return;
 688 | 		
 689 | 	    var tmpMax = this.max();
 690 | 		var tmpMin = this.min();
 691 | 		var tmpStdDev = this.stddev();
 692 | 		var tmpMean = this.mean();
 693 | 	    
 694 | 	    var a = Array();
 695 | 	    
 696 | 	    // number of classes is odd
 697 | 	    if(nbClass % 2 == 1) {
 698 | 
 699 | 	    	// Euclidean division to get the inferior bound
 700 | 	    	var infBound = Math.floor(nbClass / 2);
 701 | 	    	
 702 | 	    	var supBound = infBound + 1;
 703 | 	    	
 704 | 	    	// we set the central bounds
 705 | 	    	a[infBound] = tmpMean - (tmpStdDev / 2);
 706 | 	    	a[supBound] = tmpMean + (tmpStdDev / 2);
 707 | 	    	
 708 | 	    	// Values < to infBound, except first one
 709 | 	    	for (var i = infBound - 1; i > 0; i--) {
 710 | 	    		var val = a[i+1] - tmpStdDev;
 711 | 		        a[i] = val;
 712 | 		    }
 713 | 	    	
 714 | 	    	// Values > to supBound, except last one
 715 | 	    	for (var i = supBound + 1; i < nbClass; i++) {
 716 | 	    		var val = a[i-1] + tmpStdDev;
 717 | 		        a[i] = val;
 718 | 		    }
 719 | 	    	
 720 | 	    	// number of classes is even
 721 | 	    } else {
 722 | 	    	
 723 | 	    	var meanBound = nbClass / 2;
 724 | 	    	
 725 | 	    	// we get the mean value
 726 | 	    	a[meanBound] = tmpMean;
 727 | 	    	
 728 | 	    	// Values < to the mean, except first one
 729 | 	    	for (var i = meanBound - 1; i > 0; i--) {
 730 | 	    		var val = a[i+1] - tmpStdDev;
 731 | 		        a[i] = val;
 732 | 		    }
 733 | 	    	
 734 | 	    	// Values > to the mean, except last one
 735 | 	    	for (var i = meanBound + 1; i < nbClass; i++) {
 736 | 	    		var val = a[i-1] + tmpStdDev;
 737 | 		        a[i] = val;
 738 | 		    }
 739 | 	    }
 740 | 	    
 741 | 	    
 742 | 	    // we finally set the first value
 743 | 	    // do we excatly match min value or not ? 
 744 | 	    a[0] = (typeof matchBounds === "undefined") ? a[1]- tmpStdDev : tmpMin;
 745 |     	
 746 |     	// we finally set the last value
 747 | 	    // do we excatly match max value or not ? 
 748 |     	a[nbClass] = (typeof matchBounds === "undefined") ? a[nbClass-1] + tmpStdDev : tmpMax;
 749 | 
 750 | 	    this.setBounds(a);
 751 | 	    this.setRanges();
 752 | 	    
 753 | 	    // we specify the classification method
 754 | 	    this.method = _t('std deviation') + ' (' + nbClass + ' ' + _t('classes')+ ')'; 
 755 | 	    
 756 | 	    return this.bounds;
 757 | 	};
 758 | 	
 759 | 	
 760 | 	/**
 761 | 	 * Geometric Progression classification 
 762 | 	 * http://en.wikipedia.org/wiki/Geometric_progression
 763 | 	 * Return an array with bounds : ie array(0,
 764 | 	 * 0.75, 1.5, 2.25, 3);
 765 | 	 */
 766 | 	this.getClassGeometricProgression = function(nbClass) {
 767 | 
 768 | 		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
 769 | 		
 770 | 		if (this._nodata())
 771 | 	        return;
 772 | 		
 773 | 	    if(this._hasNegativeValue() || this._hasZeroValue()) {
 774 | 	    	if(this.silent) this.log("[silent mode] " + _t('geometric progression can\'t be applied with a serie containing negative or zero values.'), true);
 775 | 			else throw new TypeError(_t('geometric progression can\'t be applied with a serie containing negative or zero values.'));
 776 | 	    	return;
 777 | 	    }
 778 | 	    
 779 | 	    var a = Array();
 780 | 	    var tmpMin = this.min();
 781 | 	    var tmpMax = this.max();
 782 | 	    
 783 | 	    var logMax = Math.log(tmpMax) / Math.LN10; // max decimal logarithm (or base 10)
 784 | 	    var logMin = Math.log(tmpMin) / Math.LN10;; // min decimal logarithm (or base 10)
 785 | 	    
 786 | 	    var interval = (logMax - logMin) / nbClass;
 787 | 	    
 788 | 	    // we compute log bounds
 789 | 	    for (var i = 0; i < nbClass; i++) {
 790 | 	    	if(i == 0) {
 791 | 	    		a[i] = logMin;
 792 | 	    	} else {
 793 | 	    		a[i] = a[i-1] + interval;
 794 | 	    	}
 795 | 	    }
 796 | 	    
 797 | 	    // we compute antilog
 798 | 	    a = a.map(function(x) { return Math.pow(10, x); });
 799 | 	    
 800 | 	    // and we finally add max value
 801 | 	    a.push(this.max());
 802 | 	    
 803 | 	    this.setBounds(a);
 804 | 	    this.setRanges();
 805 | 	    
 806 | 	    // we specify the classification method
 807 | 	    this.method = _t('geometric progression') + ' (' + nbClass + ' ' + _t('classes') + ')';
 808 | 
 809 | 	    return this.bounds;
 810 | 	};
 811 | 	
 812 | 	/**
 813 | 	 * Arithmetic Progression classification 
 814 | 	 * http://en.wikipedia.org/wiki/Arithmetic_progression
 815 | 	 * Return an array with bounds : ie array(0,
 816 | 	 * 0.75, 1.5, 2.25, 3);
 817 | 	 */
 818 | 	this.getClassArithmeticProgression = function(nbClass) {
 819 | 
 820 | 		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
 821 | 		
 822 | 		if (this._nodata())
 823 | 	        return;
 824 | 			    
 825 | 	    var denominator = 0;
 826 | 	    
 827 | 	    // we compute the (french) "Raison"
 828 | 	    for (var i = 1; i <= nbClass; i++) {
 829 | 	        denominator += i;
 830 | 	    }
 831 | 
 832 | 	    var a = Array();
 833 | 	    var tmpMin = this.min();
 834 | 	    var tmpMax = this.max();
 835 | 	    
 836 | 	    var interval = (tmpMax - tmpMin) / denominator;
 837 | 
 838 | 	    for (var i = 0; i <= nbClass; i++) {
 839 | 	    	if(i == 0) {
 840 | 	    		a[i] = tmpMin;
 841 | 			} else if(i == nbClass) {
 842 | 				a[i] = tmpMax;
 843 | 			} else {
 844 | 	    		a[i] = a[i-1] + (i * interval);
 845 | 	    	}
 846 | 	    }
 847 | 
 848 | 	    this.setBounds(a);
 849 | 	    this.setRanges();
 850 | 	    
 851 | 	    // we specify the classification method
 852 | 	    this.method = _t('arithmetic progression') + ' (' + nbClass + ' ' + _t('classes') + ')';
 853 | 
 854 | 	    return this.bounds;
 855 | 	};
 856 | 	
 857 | 	/**
 858 | 	 * Credits : Doug Curl (javascript) and Daniel J Lewis (python implementation)
 859 | 	 * http://www.arcgis.com/home/item.html?id=0b633ff2f40d412995b8be377211c47b
 860 | 	 * http://danieljlewis.org/2010/06/07/jenks-natural-breaks-algorithm-in-python/
 861 | 	 */
 862 | 	this.getClassJenks2 = function(nbClass) {
 863 | 	
 864 | 		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
 865 | 		
 866 | 		if (this._nodata())
 867 | 			return;
 868 | 		
 869 | 		this._classificationCheck(nbClass); // be sure number of classes is valid
 870 | 		
 871 | 		var dataList = this.sorted();
 872 | 
 873 | 		// now iterate through the datalist:
 874 | 		// determine mat1 and mat2
 875 | 		// really not sure how these 2 different arrays are set - the code for
 876 | 		// each seems the same!
 877 | 		// but the effect are 2 different arrays: mat1 and mat2
 878 | 		var mat1 = []
 879 | 		for ( var x = 0, xl = dataList.length + 1; x < xl; x++) {
 880 | 			var temp = []
 881 | 			for ( var j = 0, jl = nbClass + 1; j < jl; j++) {
 882 | 				temp.push(0)
 883 | 			}
 884 | 			mat1.push(temp)
 885 | 		}
 886 | 
 887 | 		var mat2 = []
 888 | 		for ( var i = 0, il = dataList.length + 1; i < il; i++) {
 889 | 			var temp2 = []
 890 | 			for ( var c = 0, cl = nbClass + 1; c < cl; c++) {
 891 | 				temp2.push(0)
 892 | 			}
 893 | 			mat2.push(temp2)
 894 | 		}
 895 | 
 896 | 		// absolutely no idea what this does - best I can tell, it sets the 1st
 897 | 		// group in the
 898 | 		// mat1 and mat2 arrays to 1 and 0 respectively
 899 | 		for ( var y = 1, yl = nbClass + 1; y < yl; y++) {
 900 | 			mat1[0][y] = 1
 901 | 			mat2[0][y] = 0
 902 | 			for ( var t = 1, tl = dataList.length + 1; t < tl; t++) {
 903 | 				mat2[t][y] = Infinity
 904 | 			}
 905 | 			var v = 0.0
 906 | 		}
 907 | 
 908 | 		// and this part - I'm a little clueless on - but it works
 909 | 		// pretty sure it iterates across the entire dataset and compares each
 910 | 		// value to
 911 | 		// one another to and adjust the indices until you meet the rules:
 912 | 		// minimum deviation
 913 | 		// within a class and maximum separation between classes
 914 | 		for ( var l = 2, ll = dataList.length + 1; l < ll; l++) {
 915 | 			var s1 = 0.0
 916 | 			var s2 = 0.0
 917 | 			var w = 0.0
 918 | 			for ( var m = 1, ml = l + 1; m < ml; m++) {
 919 | 				var i3 = l - m + 1
 920 | 				var val = parseFloat(dataList[i3 - 1])
 921 | 				s2 += val * val
 922 | 				s1 += val
 923 | 				w += 1
 924 | 				v = s2 - (s1 * s1) / w
 925 | 				var i4 = i3 - 1
 926 | 				if (i4 != 0) {
 927 | 					for ( var p = 2, pl = nbClass + 1; p < pl; p++) {
 928 | 						if (mat2[l][p] >= (v + mat2[i4][p - 1])) {
 929 | 							mat1[l][p] = i3
 930 | 							mat2[l][p] = v + mat2[i4][p - 1]
 931 | 						}
 932 | 					}
 933 | 				}
 934 | 			}
 935 | 			mat1[l][1] = 1
 936 | 			mat2[l][1] = v
 937 | 		}
 938 | 
 939 | 		var k = dataList.length
 940 | 		var kclass = []
 941 | 
 942 | 		// fill the kclass (classification) array with zeros:
 943 | 		for (var i = 0; i <= nbClass; i++) {
 944 | 			kclass.push(0);
 945 | 		}
 946 | 
 947 | 		// this is the last number in the array:
 948 | 		kclass[nbClass] = parseFloat(dataList[dataList.length - 1])
 949 | 		// this is the first number - can set to zero, but want to set to lowest
 950 | 		// to use for legend:
 951 | 		kclass[0] = parseFloat(dataList[0])
 952 | 		var countNum = nbClass
 953 | 		while (countNum >= 2) {
 954 | 			var id = parseInt((mat1[k][countNum]) - 2)
 955 | 			kclass[countNum - 1] = dataList[id]
 956 | 			k = parseInt((mat1[k][countNum] - 1))
 957 | 			// spits out the rank and value of the break values:
 958 | 			// console.log("id="+id,"rank = " + String(mat1[k][countNum]),"val =
 959 | 			// " + String(dataList[id]))
 960 | 			// count down:
 961 | 			countNum -= 1
 962 | 		}
 963 | 		// check to see if the 0 and 1 in the array are the same - if so, set 0
 964 | 		// to 0:
 965 | 		if (kclass[0] == kclass[1]) {
 966 | 			kclass[0] = 0
 967 | 		}
 968 | 
 969 | 		this.setBounds(kclass);
 970 | 		this.setRanges();
 971 | 
 972 | 		
 973 | 		this.method = _t('Jenks2') + ' (' + nbClass + ' ' + _t('classes') + ')';
 974 | 		
 975 | 		return this.bounds; //array of breaks
 976 | 	}
 977 | 	
 978 | 	/**
 979 | 	 * Credits from simple-statistics library
 980 | 	 * https://github.com/simple-statistics/simple-statistics
 981 | 	 * https://gist.githubusercontent.com/tmcw/4969184/raw/cfd9572d00db6bcdc34f07b088738fc3a47846b4/simple_statistics.js
 982 | 	 */
 983 | 	this.getClassJenks = function(nbClass) {
 984 | 	
 985 | 		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
 986 | 		
 987 | 		if (this._nodata())
 988 | 			return;
 989 | 		
 990 | 		this._classificationCheck(nbClass); // be sure number of classes is valid
 991 | 		
 992 | 		var dataList = this.sorted();
 993 | 		
 994 | 		// Compute the matrices required for Jenks breaks. These matrices
 995 | 		// can be used for any classing of data with `classes <= n_classes`
 996 | 		var jenksMatrices = function(data, n_classes) {
 997 | 
 998 | 			// in the original implementation, these matrices are referred to
 999 | 			// as `LC` and `OP`
1000 | 			//
1001 | 			// * lower_class_limits (LC): optimal lower class limits
1002 | 			// * variance_combinations (OP): optimal variance combinations for all classes
1003 | 			var lower_class_limits = [],
1004 | 				variance_combinations = [],
1005 | 				// loop counters
1006 | 				i, j,
1007 | 				// the variance, as computed at each step in the calculation
1008 | 				variance = 0;
1009 | 
1010 | 			// Initialize and fill each matrix with zeroes
1011 | 			for (var i = 0; i < data.length + 1; i++) {
1012 | 				var tmp1 = [], tmp2 = [];
1013 | 				for (var j = 0; j < n_classes + 1; j++) {
1014 | 					tmp1.push(0);
1015 | 					tmp2.push(0);
1016 | 				}
1017 | 				lower_class_limits.push(tmp1);
1018 | 				variance_combinations.push(tmp2);
1019 | 			}
1020 | 
1021 | 			for (var i = 1; i < n_classes + 1; i++) {
1022 | 				lower_class_limits[1][i] = 1;
1023 | 				variance_combinations[1][i] = 0;
1024 | 				// in the original implementation, 9999999 is used but
1025 | 				// since Javascript has `Infinity`, we use that.
1026 | 				for (var j = 2; j < data.length + 1; j++) {
1027 | 					variance_combinations[j][i] = Infinity;
1028 | 				}
1029 | 			}
1030 | 
1031 | 			for (var l = 2; l < data.length + 1; l++) {
1032 | 
1033 | 				// `SZ` originally. this is the sum of the values seen thus
1034 | 				// far when calculating variance.
1035 | 				var sum = 0, 
1036 | 					// `ZSQ` originally. the sum of squares of values seen
1037 | 					// thus far
1038 | 					sum_squares = 0,
1039 | 					// `WT` originally. This is the number of 
1040 | 					w = 0,
1041 | 					// `IV` originally
1042 | 					i4 = 0;
1043 | 
1044 | 				// in several instances, you could say `Math.pow(x, 2)`
1045 | 				// instead of `x * x`, but this is slower in some browsers
1046 | 				// introduces an unnecessary concept.
1047 | 				for (var m = 1; m < l + 1; m++) {
1048 | 
1049 | 					// `III` originally
1050 | 					var lower_class_limit = l - m + 1,
1051 | 						val = data[lower_class_limit - 1];
1052 | 
1053 | 					// here we're estimating variance for each potential classing
1054 | 					// of the data, for each potential number of classes. `w`
1055 | 					// is the number of data points considered so far.
1056 | 					w++;
1057 | 
1058 | 					// increase the current sum and sum-of-squares
1059 | 					sum += val;
1060 | 					sum_squares += val * val;
1061 | 
1062 | 					// the variance at this point in the sequence is the difference
1063 | 					// between the sum of squares and the total x 2, over the number
1064 | 					// of samples.
1065 | 					variance = sum_squares - (sum * sum) / w;
1066 | 
1067 | 					i4 = lower_class_limit - 1;
1068 | 
1069 | 					if (i4 !== 0) {
1070 | 						for (var j = 2; j < n_classes + 1; j++) {
1071 | 							if (variance_combinations[l][j] >=
1072 | 								(variance + variance_combinations[i4][j - 1])) {
1073 | 								lower_class_limits[l][j] = lower_class_limit;
1074 | 								variance_combinations[l][j] = variance +
1075 | 									variance_combinations[i4][j - 1];
1076 | 							}
1077 | 						}
1078 | 					}
1079 | 				}
1080 | 
1081 | 				lower_class_limits[l][1] = 1;
1082 | 				variance_combinations[l][1] = variance;
1083 | 			}
1084 | 
1085 | 			return {
1086 | 				lower_class_limits: lower_class_limits,
1087 | 				variance_combinations: variance_combinations
1088 | 			};
1089 | 		};
1090 | 
1091 |         // get our basic matrices
1092 |         var matrices = jenksMatrices(dataList, nbClass),
1093 |             // we only need lower class limits here
1094 |             lower_class_limits = matrices.lower_class_limits,
1095 |             k = dataList.length - 1,
1096 |             kclass = [],
1097 |             countNum = nbClass;
1098 | 
1099 |         // the calculation of classes will never include the upper and
1100 |         // lower bounds, so we need to explicitly set them
1101 |         kclass[nbClass] = dataList[dataList.length - 1];
1102 |         kclass[0] = dataList[0];
1103 | 
1104 |         // the lower_class_limits matrix is used as indexes into itself
1105 |         // here: the `k` variable is reused in each iteration.
1106 |         while (countNum > 1) {
1107 |             kclass[countNum - 1] = dataList[lower_class_limits[k][countNum] - 2];
1108 |             k = lower_class_limits[k][countNum] - 1;
1109 |             countNum--;
1110 |         }
1111 | 
1112 | 		this.setBounds(kclass);
1113 | 		this.setRanges();
1114 | 
1115 | 		
1116 | 		this.method = _t('Jenks') + ' (' + nbClass + ' ' + _t('classes') + ')';
1117 | 		
1118 | 		return this.bounds; //array of breaks
1119 | 	}
1120 | 
1121 | 	
1122 | 	/**
1123 | 	 * Unique classification Return as many entries as unique values : ie array('blue', 'red', yellow')
1124 | 	 * 1.5, 2.25, 3);
1125 | 	 */
1126 | 	this.getClassUniqueValues = function() {
1127 | 
1128 | 		if (this._nodata())
1129 | 			return;
1130 | 		
1131 | 		this.is_uniqueValues = true;
1132 | 		
1133 | 		var tmp = this.sorted(); // display in alphabetical order
1134 | 
1135 | 		var a = Array();
1136 | 
1137 | 		for (var i = 0; i < this.pop(); i++) {
1138 | 			if(a.indexOf(tmp[i]) === -1)
1139 | 				a.push(tmp[i]);
1140 | 		}
1141 | 		
1142 | 		this.bounds = a;
1143 | 		
1144 | 		// we specify the classification method
1145 | 		this.method = _t('unique values');
1146 | 		
1147 | 		return a;
1148 | 
1149 | 	};
1150 | 	
1151 | 	
1152 | 	/**
1153 | 	 * Return the class of a given value.
1154 | 	 * For example value : 6
1155 | 	 * and bounds array = (0, 4, 8, 12);
1156 | 	 * Return 2
1157 | 	 */
1158 | 	this.getClass = function(value) {
1159 | 
1160 | 		for (var i = 0; i < this.bounds.length; i++) {
1161 | 			
1162 | 			if(this.is_uniqueValues == true) {
1163 | 				
1164 | 				if(value == this.bounds[i]) {
1165 | 					// console.log(value + ' - ' + this.bounds[i] + ' returned value : ' + i);
1166 | 					return i;
1167 | 				}
1168 | 			} else {
1169 | 				// parseFloat() is necessary
1170 | 				if(parseFloat(value) <= this.bounds[i + 1]) {
1171 | 					return i;
1172 | 				}
1173 | 			}
1174 | 		}
1175 | 		
1176 | 		return _t("Unable to get value's class.");
1177 | 		
1178 | 	};
1179 | 
1180 | 	/**
1181 | 	 * Return the ranges array : array('0-0.75', '0.75-1.5', '1.5-2.25',
1182 | 	 * '2.25-3');
1183 | 	 */
1184 | 	this.getRanges = function() {
1185 | 		
1186 | 		return this.ranges;
1187 | 		
1188 | 	};
1189 | 
1190 | 	/**
1191 | 	 * Returns the number/index of this.ranges that value falls into
1192 | 	 */
1193 | 	this.getRangeNum = function(value) {
1194 | 		
1195 | 		var bounds, i;
1196 | 
1197 | 		for (var i = 0; i < this.ranges.length; i++) {
1198 | 			bounds = this.ranges[i].split(/ - /);
1199 | 			if (value <= parseFloat(bounds[1])) {
1200 | 				return i;
1201 | 			}
1202 | 		}
1203 | 	}
1204 | 	
1205 | 	/*
1206 | 	 * Compute inner ranges based on serie. 
1207 | 	 * Produce discontinous ranges used for legend - return an array similar to : 
1208 | 	 * array('0.00-0.74', '0.98-1.52', '1.78-2.25', '2.99-3.14');
1209 | 	 * If inner ranges already computed, return array values.
1210 | 	 */
1211 | 	this.getInnerRanges = function() {
1212 | 		
1213 | 		// if already computed, we return the result
1214 | 		if(this.inner_ranges != null)
1215 | 			return this.inner_ranges;
1216 | 
1217 | 		
1218 | 		var a = new Array();
1219 | 		var tmp = this.sorted();
1220 | 		
1221 | 		var cnt = 1; // bounds array counter
1222 | 		
1223 | 		for (var i = 0; i < tmp.length; i++) {
1224 | 			
1225 | 			if(i == 0) var range_firstvalue = tmp[i]; // we init first range value
1226 | 			
1227 | 			if(parseFloat(tmp[i]) > parseFloat(this.bounds[cnt])) {
1228 | 				
1229 | 				a[cnt - 1] = '' + range_firstvalue + this.separator + tmp[i-1];
1230 | 				
1231 | 				var range_firstvalue =  tmp[i];
1232 | 				
1233 | 				cnt++;
1234 | 
1235 | 			}
1236 | 			
1237 | 			// we reach the last range, we finally complete manually
1238 | 			// and return the array
1239 | 			if(cnt == (this.bounds.length - 1)) {
1240 | 				// we set the last value
1241 | 				a[cnt - 1] = '' + range_firstvalue + this.separator + tmp[tmp.length-1];
1242 | 				
1243 | 				this.inner_ranges = a;
1244 | 				return this.inner_ranges;
1245 | 			}
1246 | 			
1247 | 
1248 | 		}
1249 | 		
1250 | 	};
1251 | 	
1252 | 	this.getSortedlist = function() {
1253 | 		
1254 | 		return this.sorted().join(', ');
1255 | 		
1256 | 	};
1257 | 	
1258 | 	/**
1259 | 	 * Return an html legend
1260 | 	 * colors : specify an array of color (hexadecimal values)
1261 | 	 * legend :  specify a text input for the legend. By default, just displays 'legend'
1262 | 	 * counter : if not null, display counter value
1263 | 	 * callback : if not null, callback function applied on legend boundaries
1264 | 	 * mode : 	null, 'default', 'distinct', 'discontinuous' : 
1265 | 	 * 			- if mode is null, will display legend as 'default mode'
1266 | 	 * 			- 'default' : displays ranges like in ranges array (continuous values), sample :  29.26 - 378.80 / 378.80 - 2762.25 /  2762.25 - 6884.84
1267 | 	 * 			- 'distinct' : Add + 1 according to decimal precision to distinguish classes (discrete values), sample :  29.26 - 378.80 / 378.81 - 2762.25 /  2762.26 - 6884.84 
1268 | 	 * 			- 'discontinuous' : indicates the range of data actually falling in each class , sample :  29.26 - 225.43 / 852.12 - 2762.20 /  3001.25 - 6884.84 / not implemented yet
1269 | 	 * order : 	null, 'ASC', 'DESC'
1270 | 	 */
1271 | 	this.getHtmlLegend = function(colors, legend, counter, callback, mode, order) {
1272 | 		
1273 | 		var cnt= '';
1274 | 		var elements = new Array();
1275 | 		
1276 | 		this.doCount(); // we do count, even if not displayed
1277 | 		
1278 | 		if(colors != null) {
1279 | 			ccolors = colors;
1280 | 		}
1281 | 		else {
1282 | 			ccolors = this.colors;
1283 | 		}
1284 | 		
1285 | 		if(legend != null) {
1286 | 			lg = legend;
1287 | 		}
1288 | 		else {
1289 | 			lg =  'Legend';
1290 | 		}
1291 | 		
1292 | 		if(counter != null) {
1293 | 			getcounter = true;
1294 | 		}
1295 | 		else {
1296 | 			getcounter = false;
1297 | 		}
1298 | 		
1299 | 		if(callback != null) {
1300 | 			fn = callback;
1301 | 		}
1302 | 		else {
1303 | 			fn = function(o) {return o;};
1304 | 		}
1305 | 		if(mode == null) {
1306 | 			mode = 'default';
1307 | 		}
1308 | 		if(mode == 'discontinuous') {
1309 | 			this.getInnerRanges();
1310 | 			// check if some classes are not populated / equivalent of in_array function
1311 | 			if(this.counter.indexOf(0) !== -1) {
1312 | 		    	if(this.silent) this.log("[silent mode] " + _t("Geostats cannot apply 'discontinuous' mode to the getHtmlLegend() method because some classes are not populated.\nPlease switch to 'default' or 'distinct' modes. Exit!"), true);
1313 | 				else throw new TypeError(_t("Geostats cannot apply 'discontinuous' mode to the getHtmlLegend() method because some classes are not populated.\nPlease switch to 'default' or 'distinct' modes. Exit!"));
1314 | 				return;
1315 | 			}
1316 | 
1317 | 		}
1318 | 		if(order !== 'DESC') order = 'ASC';
1319 | 		
1320 | 		if(ccolors.length < this.ranges.length) {
1321 | 			if(this.silent) this.log("[silent mode] " + _t('The number of colors should fit the number of ranges. Exit!'), true);
1322 | 			else throw new TypeError(_t('The number of colors should fit the number of ranges. Exit!'));
1323 | 			return;
1324 | 		}
1325 | 		
1326 | 		if(this.is_uniqueValues == false) {
1327 | 			
1328 | 			for (var i = 0; i < (this.ranges.length); i++) {
1329 | 				if(getcounter===true) {
1330 | 					cnt = ' <span class="geostats-legend-counter">(' + this.counter[i] + ')</span>';
1331 | 				}
1332 | 				//console.log("Ranges : " + this.ranges[i]);
1333 | 				
1334 | 				// default mode 
1335 | 				var tmp = this.ranges[i].split(this.separator);
1336 | 					
1337 | 				var start_value = parseFloat(tmp[0]).toFixed(this.precision);
1338 | 				var end_value = parseFloat(tmp[1]).toFixed(this.precision);
1339 | 					
1340 | 				
1341 | 				// if mode == 'distinct' and we are not working on the first value
1342 | 				if(mode == 'distinct' && i != 0) {
1343 | 
1344 | 					if(isInt(start_value)) {
1345 | 						start_value = parseInt(start_value) + 1;
1346 | 						// format to float if necessary
1347 | 						if(this.precisionflag == 'manual' && this.precision != 0) start_value = parseFloat(start_value).toFixed(this.precision);
1348 | 					} else {
1349 | 
1350 | 						start_value = parseFloat(start_value) + (1 / Math.pow(10,this.precision));
1351 | 						// strangely the formula above return sometimes long decimal values, 
1352 | 						// the following instruction fix it
1353 | 						start_value = parseFloat(start_value).toFixed(this.precision);
1354 | 					}
1355 | 				}
1356 | 				
1357 | 				// if mode == 'discontinuous'
1358 | 				if(mode == 'discontinuous') {
1359 | 										
1360 | 					var tmp = this.inner_ranges[i].split(this.separator);
1361 | 					// console.log("Ranges : " + this.inner_ranges[i]);
1362 | 					
1363 | 					var start_value = parseFloat(tmp[0]).toFixed(this.precision);
1364 | 					var end_value = parseFloat(tmp[1]).toFixed(this.precision);
1365 | 					
1366 | 				}
1367 | 				
1368 | 				// we apply callback function
1369 | 				var el = fn(start_value) + this.legendSeparator + fn(end_value);
1370 | 					
1371 | 				var block = '<div><div class="geostats-legend-block" style="background-color:' + ccolors[i] + '"></div> ' + el + cnt + '</div>';
1372 | 				elements.push(block);
1373 | 			}
1374 | 			
1375 | 		} else {
1376 | 			
1377 | 			// only if classification is done on unique values
1378 | 			for (var i = 0; i < (this.bounds.length); i++) {
1379 | 				if(getcounter===true) {
1380 | 					cnt = ' <span class="geostats-legend-counter">(' + this.counter[i] + ')</span>';
1381 | 				}
1382 | 				var el = fn(this.bounds[i]);
1383 | 				var block = '<div><div class="geostats-legend-block" style="background-color:' + ccolors[i] + '"></div> ' + el + cnt + '</div>';
1384 | 
1385 | 				elements.push(block);
1386 | 			}
1387 | 			
1388 | 		}
1389 | 		
1390 | 		// do we reverse the return legend ?
1391 | 		if(order === 'DESC') elements.reverse(); 
1392 | 		
1393 | 		// finally we create HTML and return it
1394 | 		var content  = '<div class="geostats-legend"><div class="geostats-legend-title">' + _t(lg) + '</div>';
1395 | 		for (var i = 0; i < (elements.length); i++) {
1396 | 			content += elements[i];
1397 | 		}
1398 | 		content += '</div>';
1399 |     
1400 | 		return content;
1401 | 	};
1402 | 
1403 | 	
1404 | 	
1405 | 	// object constructor
1406 | 	// At the end of script. If not setPrecision() method is not known
1407 | 	
1408 | 	// we create an object identifier for debugging
1409 | 	this.objectID = new Date().getUTCMilliseconds();
1410 | 	this.log('Creating new geostats object');
1411 | 	
1412 | 	if(typeof a !== 'undefined' && a.length > 0) {
1413 | 		this.serie = a;
1414 | 		this.setPrecision();
1415 | 		this.log('Setting serie (' + a.length + ') : ' + a.join());
1416 | 	} else {
1417 | 		this.serie = Array();
1418 | 
1419 | 	};
1420 | 	
1421 | 	// creating aliases on classification function for backward compatibility
1422 | 	this.getJenks = this.getClassJenks;
1423 | 	this.getJenks2 = this.getClassJenks2;
1424 | 	this.getGeometricProgression = this.getClassGeometricProgression;
1425 | 	this.getEqInterval = this.getClassEqInterval;
1426 | 	this.getQuantile = this.getClassQuantile;
1427 | 	this.getStdDeviation = this.getClassStdDeviation;
1428 | 	this.getUniqueValues = this.getClassUniqueValues;
1429 | 	this.getArithmeticProgression = this.getClassArithmeticProgression;
1430 | 
1431 | };
1432 | 
1433 | 
1434 | return geostats;
1435 | });
1436 | 


--------------------------------------------------------------------------------
/lib/geostats.min.js:
--------------------------------------------------------------------------------
 1 | (function(v){"object"===typeof exports?module.exports=v():"function"===typeof define&&define.amd?define(v):geostats=v()})(function(){var v=function(m){return"number"===typeof m&&parseFloat(m)==parseInt(m,10)&&!isNaN(m)};Array.prototype.indexOf||(Array.prototype.indexOf=function(m,a){if(void 0===this||null===this)throw new TypeError('"this" is null or not defined');var b=this.length>>>0;a=+a||0;Infinity===Math.abs(a)&&(a=0);0>a&&(a+=b,0>a&&(a=0));for(;a<b;a++)if(this[a]===m)return a;return-1});return function(m){this.objectID=
 2 | "";this.legendSeparator=this.separator=" - ";this.method="";this.precision=0;this.precisionflag="auto";this.roundlength=2;this.silent=this.debug=this.is_uniqueValues=!1;this.bounds=[];this.ranges=[];this.inner_ranges=null;this.colors=[];this.counter=[];this.stat_cov=this.stat_stddev=this.stat_variance=this.stat_pop=this.stat_min=this.stat_max=this.stat_sum=this.stat_median=this.stat_mean=this.stat_sorted=null;this.log=function(a,b){1!=this.debug&&null==b||console.log(this.objectID+"(object id) :: "+
 3 | a)};this.setBounds=function(a){this.log("Setting bounds ("+a.length+") : "+a.join());this.bounds=a};this.setSerie=function(a){this.log("Setting serie ("+a.length+") : "+a.join());this.serie=a;this.resetStatistics();this.setPrecision()};this.setColors=function(a){this.log("Setting color ramp ("+a.length+") : "+a.join());this.colors=a};this.doCount=function(){if(!this._nodata()){var a=this.sorted();this.counter=[];if(1==this.is_uniqueValues)for(var b=0;b<this.bounds.length;b++)this.counter[b]=0;else for(b=
 4 | 0;b<this.bounds.length-1;b++)this.counter[b]=0;for(b=0;b<a.length;b++){var c=this.getClass(a[b]);this.counter[c]++}}};this.setPrecision=function(a){"undefined"!==typeof a&&(this.precisionflag="manual",this.precision=a);if("auto"==this.precisionflag)for(a=0;a<this.serie.length;a++){var b=isNaN(this.serie[a]+"")||-1==(this.serie[a]+"").toString().indexOf(".")?0:(this.serie[a]+"").split(".")[1].length;b>this.precision&&(this.precision=b)}20<this.precision&&(this.log("this.precision value ("+this.precision+
 5 | ') is greater than max value. Automatic set-up to 20 to prevent "Uncaught RangeError: toFixed()" when calling decimalFormat() method.'),this.precision=20);this.log("Calling setPrecision(). Mode : "+this.precisionflag+" - Decimals : "+this.precision);this.serie=this.decimalFormat(this.serie)};this.decimalFormat=function(a){for(var b=[],c=0;c<a.length;c++){var e=a[c];e=!isNaN(parseFloat(e))&&isFinite(e);b[c]=e?parseFloat(parseFloat(a[c]).toFixed(this.precision)):a[c]}return b};this.setRanges=function(){this.ranges=
 6 | [];for(var a=0;a<this.bounds.length-1;a++)this.ranges[a]=this.bounds[a]+this.separator+this.bounds[a+1]};this.min=function(a){a=void 0===a?[]:a;if(!this._nodata()){a.includes(this.serie[0])?this.stat_min=999999999999:this.stat_min=this.serie[0];for(var b=0;b<this.pop();b++)this.serie[b]<this.stat_min&&!a.includes(this.serie[b])&&(this.stat_min=this.serie[b]);return this.stat_min}};this.max=function(a){a=void 0===a?[]:a;if(!this._nodata()){a.includes(this.serie[0])?this.stat_max=-999999999999:this.stat_max=
 7 | this.serie[0];for(var b=0;b<this.pop();b++)this.serie[b]>this.stat_max&&!a.includes(this.serie[b])&&(this.stat_max=this.serie[b]);return this.stat_max}};this.sum=function(){if(!this._nodata()){if(null==this.stat_sum)for(var a=this.stat_sum=0;a<this.pop();a++)this.stat_sum+=parseFloat(this.serie[a]);return this.stat_sum}};this.pop=function(){if(!this._nodata())return null==this.stat_pop&&(this.stat_pop=this.serie.length),this.stat_pop};this.mean=function(){if(!this._nodata())return null==this.stat_mean&&
 8 | (this.stat_mean=parseFloat(this.sum()/this.pop())),this.stat_mean};this.median=function(){if(!this._nodata()){if(null==this.stat_median){this.stat_median=0;var a=this.sorted();this.stat_median=a.length%2?parseFloat(a[Math.ceil(a.length/2)-1]):(parseFloat(a[a.length/2-1])+parseFloat(a[a.length/2]))/2}return this.stat_median}};this.variance=function(){var a="undefined"===typeof a?!0:!1;if(!this._nodata()){if(null==this.stat_variance){for(var b=0,c=this.mean(),e=0;e<this.pop();e++)b+=Math.pow(this.serie[e]-
 9 | c,2);this.stat_variance=b/this.pop();1==a&&(this.stat_variance=Math.round(this.stat_variance*Math.pow(10,this.roundlength))/Math.pow(10,this.roundlength))}return this.stat_variance}};this.stddev=function(a){a="undefined"===typeof a?!0:!1;if(!this._nodata())return null==this.stat_stddev&&(this.stat_stddev=Math.sqrt(this.variance()),1==a&&(this.stat_stddev=Math.round(this.stat_stddev*Math.pow(10,this.roundlength))/Math.pow(10,this.roundlength))),this.stat_stddev};this.cov=function(a){a="undefined"===
10 | typeof a?!0:!1;if(!this._nodata())return null==this.stat_cov&&(this.stat_cov=this.stddev()/this.mean(),1==a&&(this.stat_cov=Math.round(this.stat_cov*Math.pow(10,this.roundlength))/Math.pow(10,this.roundlength))),this.stat_cov};this.resetStatistics=function(){this.stat_cov=this.stat_stddev=this.stat_variance=this.stat_pop=this.stat_min=this.stat_max=this.stat_sum=this.stat_median=this.stat_mean=this.stat_sorted=null};this._nodata=function(){if(0==this.serie.length){if(this.silent)this.log("[silent mode] Error. You should first enter a serie!",
11 | !0);else throw new TypeError("Error. You should first enter a serie!");return 1}return 0};this._classificationCheck=function(a){if(a>=this.pop())if(a="Error. "+a+" classes are defined for only "+this.pop()+" values in serie ! For the current serie, no more than "+(this.pop()-1)+" classes can be defined.",this.silent)this.log(a,!0);else throw alert(a),new TypeError(a);};this._nbClassInt=function(a){a=parseInt(a,10);if(isNaN(a))if(this.silent)this.log("[silent mode] '"+a+"' is not a valid integer. Enable to set class number.",
12 | !0);else throw new TypeError("'"+a+"' is not a valid integer. Enable to set class number.");else return a};this._hasNegativeValue=function(){for(var a=0;a<this.serie.length;a++)if(0>this.serie[a])return!0;return!1};this._hasZeroValue=function(){for(var a=0;a<this.serie.length;a++)if(0===parseFloat(this.serie[a]))return!0;return!1};this.sorted=function(){null==this.stat_sorted&&(this.stat_sorted=0==this.is_uniqueValues?this.serie.sort(function(a,b){return a-b}):this.serie.sort(function(a,b){var c=
13 | a.toString().toLowerCase(),e=b.toString().toLowerCase();return c<e?-1:c>e?1:0}));return this.stat_sorted};this.info=function(){if(!this._nodata()){var a="Population : "+this.pop()+" - [Min : "+this.min()+" | Max : "+this.max()+"]\n";a+="Mean : "+this.mean()+" - Median : "+this.median()+"\n";return a+="Variance : "+this.variance()+" - Standard deviation : "+this.stddev()+" - Coefficient of variation : "+this.cov()+"\n"}};this.setClassManually=function(a){if(!this._nodata())if(a[0]!==this.min()||a[a.length-
14 | 1]!==this.max())if(this.silent)this.log("[silent mode] "+t("Given bounds may not be correct! please check your input.\nMin value : "+this.min()+" / Max value : "+this.max()),!0);else throw new TypeError("Given bounds may not be correct! please check your input.\nMin value : "+this.min()+" / Max value : "+this.max());else return this.setBounds(a),this.setRanges(),this.method="manual classification ("+(a.length-1)+" classes)",this.bounds};this.getClassEqInterval=function(a,b,c){a=this._nbClassInt(a);
15 | if(!this._nodata()){var e="undefined"===typeof b?this.min():b;c="undefined"===typeof c?this.max():c;b=[];var d=e;e=(c-e)/a;for(var f=0;f<=a;f++)b[f]=d,d+=e;b[a]=c;this.setBounds(b);this.setRanges();this.method="eq. intervals ("+a+" classes)";return this.bounds}};this.getQuantiles=function(a){a=this._nbClassInt(a);for(var b=this.sorted(),c=[],e=this.pop()/a,d=1;d<a;d++)c.push(b[Math.round(d*e+.49)-1]);return c};this.getClassQuantile=function(a){a=this._nbClassInt(a);if(!this._nodata()){this._classificationCheck(a);
16 | var b=this.sorted(),c=this.getQuantiles(a);c.unshift(b[0]);c[b.length-1]!==b[b.length-1]&&c.push(b[b.length-1]);this.setBounds(c);this.setRanges();this.method="quantile ("+a+" classes)";return this.bounds}};this.getClassStdDeviation=function(a,b){a=this._nbClassInt(a);if(!this._nodata()){var c=this.max(),e=this.min(),d=this.stddev(),f=this.mean(),g=[];if(1==a%2){var h=Math.floor(a/2),l=h+1;g[h]=f-d/2;g[l]=f+d/2;for(f=h-1;0<f;f--)h=g[f+1]-d,g[f]=h;f=l+1}else{l=a/2;g[l]=f;for(f=l-1;0<f;f--)h=g[f+1]-
17 | d,g[f]=h;f=l+1}for(;f<a;f++)h=g[f-1]+d,g[f]=h;g[0]="undefined"===typeof b?g[1]-d:e;g[a]="undefined"===typeof b?g[a-1]+d:c;this.setBounds(g);this.setRanges();this.method="std deviation ("+a+" classes)";return this.bounds}};this.getClassGeometricProgression=function(a){a=this._nbClassInt(a);if(!this._nodata())if(this._hasNegativeValue()||this._hasZeroValue())if(this.silent)this.log("[silent mode] geometric progression can't be applied with a serie containing negative or zero values.",!0);else throw new TypeError("geometric progression can't be applied with a serie containing negative or zero values.");
18 | else{var b=[],c=this.min(),e=this.max();c=Math.log(c)/Math.LN10;e=(Math.log(e)/Math.LN10-c)/a;for(var d=0;d<a;d++)b[d]=0==d?c:b[d-1]+e;b=b.map(function(f){return Math.pow(10,f)});b.push(this.max());this.setBounds(b);this.setRanges();this.method="geometric progression ("+a+" classes)";return this.bounds}};this.getClassArithmeticProgression=function(a){a=this._nbClassInt(a);if(!this._nodata()){for(var b=0,c=1;c<=a;c++)b+=c;var e=[],d=this.min(),f=this.max();b=(f-d)/b;for(c=0;c<=a;c++)e[c]=0==c?d:c==
19 | a?f:e[c-1]+c*b;this.setBounds(e);this.setRanges();this.method="arithmetic progression ("+a+" classes)";return this.bounds}};this.getClassJenks2=function(a){a=this._nbClassInt(a);if(!this._nodata()){this._classificationCheck(a);for(var b=this.sorted(),c=[],e=0,d=b.length+1;e<d;e++){for(var f=[],g=0,h=a+1;g<h;g++)f.push(0);c.push(f)}e=[];d=0;for(f=b.length+1;d<f;d++){g=[];h=0;for(var l=a+1;h<l;h++)g.push(0);e.push(g)}d=1;for(f=a+1;d<f;d++){c[0][d]=1;e[0][d]=0;var k=1;for(g=b.length+1;k<g;k++)e[k][d]=
20 | Infinity;k=0}d=2;for(f=b.length+1;d<f;d++){l=h=g=0;for(var r=1,u=d+1;r<u;r++){var n=d-r+1;k=parseFloat(b[n-1]);h+=k*k;g+=k;l+=1;k=h-g*g/l;var p=n-1;if(0!=p)for(var q=2,w=a+1;q<w;q++)e[d][q]>=k+e[p][q-1]&&(c[d][q]=n,e[d][q]=k+e[p][q-1])}c[d][1]=1;e[d][1]=k}k=b.length;e=[];for(d=0;d<=a;d++)e.push(0);e[a]=parseFloat(b[b.length-1]);e[0]=parseFloat(b[0]);for(d=a;2<=d;)f=parseInt(c[k][d]-2),e[d-1]=b[f],k=parseInt(c[k][d]-1),--d;e[0]==e[1]&&(e[0]=0);this.setBounds(e);this.setRanges();this.method="Jenks2 ("+
21 | a+" classes)";return this.bounds}};this.getClassJenks=function(a){a=this._nbClassInt(a);if(!this._nodata()){this._classificationCheck(a);var b=this.sorted(),c=a,e=[],d=[],f,g,h=0;for(f=0;f<b.length+1;f++){var l=[],k=[];for(g=0;g<c+1;g++)l.push(0),k.push(0);e.push(l);d.push(k)}for(f=1;f<c+1;f++)for(e[1][f]=1,d[1][f]=0,g=2;g<b.length+1;g++)d[g][f]=Infinity;for(f=2;f<b.length+1;f++){for(var r=k=l=0,u,n=1;n<f+1;n++){var p=f-n+1;g=b[p-1];r++;l+=g;k+=g*g;h=k-l*l/r;u=p-1;if(0!==u)for(g=2;g<c+1;g++)d[f][g]>=
22 | h+d[u][g-1]&&(e[f][g]=p,d[f][g]=h+d[u][g-1])}e[f][1]=1;d[f][1]=h}c=b.length-1;d=[];g=a;d[a]=b[b.length-1];for(d[0]=b[0];1<g;)d[g-1]=b[e[c][g]-2],c=e[c][g]-1,g--;this.setBounds(d);this.setRanges();this.method="Jenks ("+a+" classes)";return this.bounds}};this.getClassUniqueValues=function(){if(!this._nodata()){this.is_uniqueValues=!0;for(var a=this.sorted(),b=[],c=0;c<this.pop();c++)-1===b.indexOf(a[c])&&b.push(a[c]);this.bounds=b;this.method="unique values";return b}};this.getClass=function(a){for(var b=
23 | 0;b<this.bounds.length;b++)if(1==this.is_uniqueValues){if(a==this.bounds[b])return b}else if(parseFloat(a)<=this.bounds[b+1])return b;return"Unable to get value's class."};this.getRanges=function(){return this.ranges};this.getRangeNum=function(a){var b;for(b=0;b<this.ranges.length;b++){var c=this.ranges[b].split(/ - /);if(a<=parseFloat(c[1]))return b}};this.getInnerRanges=function(){if(null!=this.inner_ranges)return this.inner_ranges;for(var a=[],b=this.sorted(),c=1,e=0;e<b.length;e++){if(0==e)var d=
24 | b[e];parseFloat(b[e])>parseFloat(this.bounds[c])&&(a[c-1]=""+d+this.separator+b[e-1],d=b[e],c++);if(c==this.bounds.length-1)return a[c-1]=""+d+this.separator+b[b.length-1],this.inner_ranges=a}};this.getSortedlist=function(){return this.sorted().join(", ")};this.getHtmlLegend=function(a,b,c,e,d,f){var g="",h=[];this.doCount();ccolors=null!=a?a:this.colors;lg=null!=b?b:"Legend";getcounter=null!=c?!0:!1;fn=null!=e?e:function(l){return l};null==d&&(d="default");if("discontinuous"==d&&(this.getInnerRanges(),
25 | -1!==this.counter.indexOf(0))){if(this.silent)this.log("[silent mode] Geostats cannot apply 'discontinuous' mode to the getHtmlLegend() method because some classes are not populated.\nPlease switch to 'default' or 'distinct' modes. Exit!",!0);else throw new TypeError("Geostats cannot apply 'discontinuous' mode to the getHtmlLegend() method because some classes are not populated.\nPlease switch to 'default' or 'distinct' modes. Exit!");return}"DESC"!==f&&(f="ASC");if(ccolors.length<this.ranges.length)if(this.silent)this.log("[silent mode] The number of colors should fit the number of ranges. Exit!",
26 | !0);else throw new TypeError("The number of colors should fit the number of ranges. Exit!");else{if(0==this.is_uniqueValues)for(a=0;a<this.ranges.length;a++)!0===getcounter&&(g=' <span class="geostats-legend-counter">('+this.counter[a]+")</span>"),c=this.ranges[a].split(this.separator),b=parseFloat(c[0]).toFixed(this.precision),c=parseFloat(c[1]).toFixed(this.precision),"distinct"==d&&0!=a&&(v(b)?(b=parseInt(b)+1,"manual"==this.precisionflag&&0!=this.precision&&(b=parseFloat(b).toFixed(this.precision))):
27 | (b=parseFloat(b)+1/Math.pow(10,this.precision),b=parseFloat(b).toFixed(this.precision))),"discontinuous"==d&&(c=this.inner_ranges[a].split(this.separator),b=parseFloat(c[0]).toFixed(this.precision),c=parseFloat(c[1]).toFixed(this.precision)),b=fn(b)+this.legendSeparator+fn(c),b='<div><div class="geostats-legend-block" style="background-color:'+ccolors[a]+'"></div> '+b+g+"</div>",h.push(b);else for(a=0;a<this.bounds.length;a++)!0===getcounter&&(g=' <span class="geostats-legend-counter">('+this.counter[a]+
28 | ")</span>"),b=fn(this.bounds[a]),b='<div><div class="geostats-legend-block" style="background-color:'+ccolors[a]+'"></div> '+b+g+"</div>",h.push(b);"DESC"===f&&h.reverse();d='<div class="geostats-legend"><div class="geostats-legend-title">'+lg+"</div>";for(a=0;a<h.length;a++)d+=h[a];return d+"</div>"}};this.objectID=(new Date).getUTCMilliseconds();this.log("Creating new geostats object");"undefined"!==typeof m&&0<m.length?(this.serie=m,this.setPrecision(),this.log("Setting serie ("+m.length+") : "+
29 | m.join())):this.serie=[];this.getJenks=this.getClassJenks;this.getJenks2=this.getClassJenks2;this.getGeometricProgression=this.getClassGeometricProgression;this.getEqInterval=this.getClassEqInterval;this.getQuantile=this.getClassQuantile;this.getStdDeviation=this.getClassStdDeviation;this.getUniqueValues=this.getClassUniqueValues;this.getArithmeticProgression=this.getClassArithmeticProgression}});


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "author": "Simon Georget <simon@intermezzo-coop.eu>",
 3 |   "contributors": [{
 4 |     "name": "dreamind",
 5 |     "email": "",
 6 |     "url": "https://github.com/dreamind"
 7 |   }],
 8 |   "name": "geostats",
 9 |   "description": "A tiny and standalone javascript library for classification and basic statistics",
10 |   "version": "2.1.0",
11 |   "homepage": "https://github.com/simogeo/geostats",
12 |   "keywords": [
13 |     "mapping",
14 |     "classification",
15 |     "choropleth",
16 |     "map",
17 |     "stats",
18 |     "statistics",
19 |     "math"
20 |   ],
21 |   "files": [
22 |     "lib/",
23 |     "tests/",
24 |     "bower.json",
25 |     "changelog",
26 |     "readme.md",
27 |     "sample.html",
28 |     "sample_shp.html"
29 |   ],
30 |   "bugs": {
31 |     "url": "https://github.com/simogeo/geostats/issues"
32 |   },
33 |   "repository": {
34 |     "type": "git",
35 |     "url": "git+https://github.com/simogeo/geostats.git"
36 |   },
37 | 
38 |   "main": "./lib/geostats.min.js",
39 |   "dependencies": {},
40 |   "devDependencies": {},
41 |   "engines": {
42 |     "node": "*"
43 |   },
44 |   "license": "MIT"
45 | }
46 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | geostats
  2 | ========================
  3 | 
  4 | 
  5 | [geostats](http://www.intermezzo-coop.eu/mapping/geostats/) is a tiny standalone JS library for classification released by [Simon Georget](http://www.intermezzo-coop.eu/)  under MIT license. 
  6 | 
  7 | Other contributors : [Doug Curl](http://kgs.uky.edu/kgsmap/ukengage/) (Jenks2 algorithm), [Casey Thomas](http://cpt.ph/), [Dreamind](https://github.com/dreamind), [cricri](https://github.com/cricri)
  8 | 
  9 | → If you are looking for a TypeScript implementation of *geostats*, go for 🪣 [GeoBuckets](https://github.com/mtralka/GeoBuckets) library.
 10 | 
 11 | 
 12 | It currently supports
 13 | --------------
 14 | 
 15 | - equal intervals
 16 | - quantiles
 17 | - standard deviation
 18 | - arithmetic progression
 19 | - geometric progression
 20 | - jenks (natural breaks) - 2 methods
 21 | - uniques values
 22 | - user defined classification
 23 | 
 24 | and **few statistical methods**
 25 | 
 26 | To use it, just download the geostats package and include the following line into your html page :
 27 | 
 28 | ```html
 29 |    <script type="text/javascript" src="path/to/lib/geostats.min.js"></script>
 30 | ```
 31 | 
 32 | **Please see the samples page to understand how it works!**
 33 | 
 34 | API
 35 | ========================
 36 | 
 37 | Attributes :
 38 | --------------
 39 | 
 40 | - *serie* : contains the statistic population. Default : empty.
 41 | - *separator* : used to separate ranges values, by default : ' - '
 42 | - *legendSeparator* : by default, equals to *separator* value
 43 | - *method* : give information regarding the classification method used. Default : empty.
 44 | - *bounds* : classification bounds
 45 | - *ranges* : classification ranges
 46 | - *colors* : classification colors
 47 | - *debug* : default value `false`. When set to `true` , provide useful debug message regarding objects and properties.
 48 | - *silent* :  default value `false`. If silent, do no trigger alert() message when inputs are incorrects but display console.log() messages
 49 | 
 50 | 
 51 | Methods :
 52 | ---------
 53 | 
 54 | 
 55 | **Statistics :**
 56 | 
 57 | - *min()* : return the min value
 58 | - *max()* : return the max value
 59 | - *sum()* : return the sum of the population
 60 | - *pop()* : return the number of individuals
 61 | - *mean()* : return the mean
 62 | - *median()* : return the median
 63 | - *variance()* : return the variance
 64 | - *stddev()* : return the standard deviation
 65 | - *cov()* : return the coefficient of variation
 66 | 
 67 | 
 68 | **Classification :**
 69 | 
 70 | - *getClassEqInterval(nbClass)* : Perform an equal interval classification and return bounds into an array. Alias : *getEqInterval(nbClass)*
 71 | - *getClassStdDeviation(nbClass)* : Perform a standard deviation classification and return bounds into an array. Alias : *getStdDeviation(nbClass)*
 72 | - *getClassArithmeticProgression(nbClass)* : Perform an arithmetic progression classification and return bounds into an array. Alias : *getArithmeticProgression(nbClass)*
 73 | - *getClassGeometricProgression(nbClass)* : Perform a geometric progression classification and return bounds into an array. Alias : *getGeometricProgression(nbClass)*
 74 | - *getClassQuantile(nbClass)* : Perform a quantile classification and return bounds into an array. Alias : *getQuantile(nbClass)*
 75 | - *getClassJenks(nbClass)* : Perform a Jenks classification and return bounds into an array. Alias : *getJenks(nbClass)* - optimised version / see #49
 76 | - *getClassJenks2(nbClass)* : Perform a Jenks classification and return bounds into an array. Alias : *getJenks2(nbClass)* - older version
 77 | - *getClassUniqueValues()* : Perform a unique values classification and return bounds (values) into an array. Alias : *getUniqueValues()*
 78 | - *setClassManually()* : Set a user defined classification based on passed array (Same array is returned). Useful to automatically set bounds/ranges and generate legend.
 79 | 
 80 | 
 81 | 
 82 | **Constructor methods :**
 83 | 
 84 | - *setSerie()* : fill up the *serie* attribute
 85 | - *setColors()* : fill up the *colors* attribute
 86 | - *setPrecision()* : set precision on serie - only useful for float series. Can take no value (for automatic precision), or an integer between 0-20. By default, the precision will be computed automatically by *geostats*.
 87 | 
 88 | 
 89 | **Getters methods :**
 90 | 
 91 | - *getRanges(array)* : return an array of classes range (*ranges* value)
 92 | - *getRangeNum()* : return the number/index of this.ranges that value falls into
 93 | - *getHtmlLegend(colors, legend, callback, mode, order)* : return a legend in html format.<br>`colors` defines an array of colors; `legend` is used for giving the legend a different title; with `counter`, a particular counter value can be displayed; a function which should be applied to the legend boundaries is used in place of `callback`; `mode` is for different display modes of the value ranges; `order` refers to the sort order of values. For further details, please refer [to the code comment](https://github.com/simogeo/geostats/blob/master/lib/geostats.js#L1054) which accompanies the getHtmlLegend method.
 94 | - *getSortedlist()* : return the sorted serie in text format
 95 | - *getClass()* : return a given value class
 96 | 
 97 | 
 98 | **Internals methods :**
 99 | 
100 | - *_nodata()* : check if *serie* attribute if not empty
101 | - *_hasNegativeValue()* : check if the serie contains any negative values
102 | - *_hasZeroValue()* : check if the serie contains zero values
103 | - *sorted()* : return the sorted (asc) serie
104 | - *info()* : return information about the population in text format
105 | - *setRanges()* : fill up the *ranges* attribute (array of classes range)
106 | - *doCount()* : perform count feature by classes, used to display count feature in legend
107 | 
108 | 
109 | *Note : If you are looking for a nice JS library to format numbers for displaying, just rely on [numeraljs](http://numeraljs.com/).*
110 | 
111 |  
112 | MIT LICENSE
113 | ========================
114 |  
115 |  Copyright (c) 2011 Simon Georget
116 | 
117 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
118 | 
119 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
120 | 
121 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
122 | 
123 |  
124 | 


--------------------------------------------------------------------------------
/sample.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
  2 | <html xmlns="http://www.w3.org/1999/xhtml">
  3 |  <head>
  4 |    <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
  5 |    <title>geostats.js (by simon georget)</title>
  6 |    <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js"></script>
  7 |    <script type="text/javascript" src="lib/geostats.js"></script>
  8 |    <script type="text/javascript" src="http://openlayers.org/api/2.11/OpenLayers.js"></script>
  9 |    <script type="text/javascript" src="https://raw.github.com/gka/chroma.js/master/chroma.min.js"></script>
 10 |    <script type="text/javascript" src="tests/openlayers_sample.js"></script>
 11 |    <link rel="stylesheet" href="lib/geostats.css" type="text/css" />
 12 |    <style type="text/css">
 13 | 	  <!--
 14 | 	  body {
 15 | 	    font-family: "Lucida Sans Unicode", "Lucida Grande", Verdana, Arial, Helvetica, sans-serif;
 16 | 	    color:#333;
 17 | 	    font-size: 0.8em;
 18 | 	    background-color: #F7F7F7;
 19 | 	  }
 20 | 	  #legend, #legend2, #legend3{float:left;width:28%;margin:0 2em 2em 2em;}
 21 | 
 22 | 	  .legend-block {
 23 | 		    border: 1px solid #555555;
 24 | 		    display: block;
 25 | 		    float: left;
 26 | 		    height: 12px;
 27 | 		    margin: 0.3em 0.8em 0 2em;
 28 | 		    width: 20px;
 29 | 		}
 30 | 	  .container {margin:0 auto;width:60%;}
 31 | 	  .serie strong {color:#333;}
 32 | 	  .serie {font-size: .9em;color:#555;}
 33 | 	  .classes {margin:0em 4em 2em;}
 34 | 	  .projectinfo {width:100%;text-align: center;margin:-3em 0 3em;}
 35 | 	  .legend p { height: 70px;color:#555;font-variant: small-caps;text-align: justify;border-top:1px dotted #ccc}
 36 | 	  a {color:#F47FE7;font-weight: bold;text-shadow: #fff 2px 2px 0px;text-decoration: none;}
 37 | 	  a:hover {color:#514F51;}
 38 | 	  #map, #map2, #map3 {width:100%;height:500px;border: 1px solid #ccc;background-color: #eee}
 39 | 	  h1 {color:#B5B1B1;text-shadow: #fff 2px 2px 0px;text-align: center;margin:2em 0;}
 40 | 	  h2 {color:#A2A3F2;text-shadow: #fff 2px 2px 0px;margin:2em 0 1em 0;}
 41 | 	  h3 {color:#555;font-size: .9em}
 42 | 	  hr {
 43 | 			height: 1px;
 44 | 			margin: -0.5em 0;
 45 | 			padding: 0;
 46 | 			color: #ddd;
 47 | 			background-color: #ddd;
 48 | 			border: 0;
 49 | 	  }
 50 | 	  pre {
 51 | 	  	-webkit-border-radius: 5px;
 52 | 			-moz-border-radius: 5px;
 53 | 			border-radius: 5px;
 54 | 			background-color: #D3E5FF;
 55 | 	  }
 56 | 	  #footer {font-size:0.8em;text-align: center;color:#777;margin:2em 0 1em;padding:.3em}
 57 | 	  -->
 58 |   </style>
 59 |    <script type="text/javascript">
 60 |    var callback_sample = function(c) {
 61 | 		return '<strong>' + c + '</strong>';
 62 | 	};
 63 | 	
 64 |    	$(document).ready(function() {
 65 |    		$.getJSON('tests/test.json',function(data) {
 66 |    			var items = []; // will store values
 67 |    			var uValues = []; // will store values
 68 |    			
 69 |    			// Don't forget to use firebug console to retrieve your data
 70 |    			// console.log(data.features);
 71 |    			
 72 |    			$.each(data.features, function(i,feature){
 73 |    				items.push(feature.properties.Pop_2006);
 74 |    			});
 75 |    			
 76 |    			$.each(data.features, function(i,feature){
 77 |    				uValues.push(feature.properties.value);
 78 |    			});
 79 | 
 80 |    			var dataJson = items;
 81 | 
 82 |    			
 83 |    			// Seventh serie
 84 |    			serie7 = new geostats(dataJson);
 85 |    			serie7.setPrecision(6);
 86 |    			
 87 |    			// we get Eq interval classification
 88 |    			var a = serie7.getClassQuantile(5);
 89 |    			//var a = serie7.getClassEqInterval(5);
 90 |    			//var a = serie7.getClassJenks(3);
 91 |    			var str  = '<strong>Classification Method : <\/strong>' + serie7.method + " :\n";
 92 |    				str += '<div class="classes">';
 93 |    			var ranges = serie7.ranges;
 94 |    			for(i = 0; i < ranges.length ; i++) {
 95 |    				str += ranges[i] + "\n";
 96 |    			}
 97 |    				str += '<\/div>';
 98 | 
 99 |    	   		var content   = '';
100 |    	   			content  += '<h2>Sample 7 - Loading data from JSON file (with jQuery)<\/h2>';
101 |    	   			content  += '<p>' + nl2br(serie7.info()) + '<\/p>';
102 |    				content  += '<p>' + nl2br(str) + '<\/p>';
103 | 				content  += '<p class="serie"><strong>Serie (sorted) : <\/strong>' + serie7.getSortedlist() + '<\/p>';
104 | 				content  += '<hr \/>';
105 | 
106 | 			jQuery('#sample-7').html(content);
107 | 
108 | 			// sample-8
109 | 			// for openlayers representation
110 |    			var color_x  = new Array('#e2dee6', '#c2abdd', '#9d87b6', '#735a8f', '#3d2e4e');
111 | 
112 |    			serie7.setColors(color_x);
113 |    			
114 |    			var class_x = ranges;
115 |    			var content = serie7.getHtmlLegend();
116 |    			serie7.legendSeparator = ' ⇔ ';
117 |    			serie7.setPrecision(2);
118 |    			var content_flare = serie7.getHtmlLegend(null, 'Customized legend, callback function (<em>here, values wrapped by strong tags<\/em>) and feature count', true, callback_sample, 'distinct');
119 | 
120 |    			var content_legend3 = serie7.getHtmlLegend(null, 'Legend (real values, breaking continuous serie)', true, null, 'discontinuous', 'DESC');
121 | 
122 |    			jQuery('#method').html('<p><strong>Classification Method : <\/strong>' + serie7.method + '<\/p>');
123 |    			jQuery('#legend p').before(content);
124 |    			
125 |    			jQuery('#legend2 p').before(content_flare);
126 |    			jQuery('#legend3 p').before(content_legend3);
127 |    			init(color_x, class_x);
128 |    			
129 |    			
130 | 			// sample-10
131 | 			// for openlayers representation
132 |    			
133 |    			serieUV = new geostats(uValues);
134 |    			var colors  = new Array('#2BCE72', '#FFC414', '#E069BC', '#4D8CEA');
135 |    			serieUV.setColors(colors);
136 |    			// we get Unique classification
137 |    			var values = serieUV.getClassUniqueValues();
138 |    			
139 |    			var legend = serieUV.getHtmlLegend(null, null, 1);
140 |    			
141 |    			jQuery('#legend4').html(legend);
142 |    			initUniqueValues(colors, values);
143 | 
144 |    		
145 |    		// sample-11
146 | 			// for openlayers representation
147 | 	
148 |    			var color_x = chroma.scale('RdYlGn').domain([serie7.min(),serie7.max()], 5).colors()
149 |    			console.log(color_x);
150 | 				serie7.setColors(color_x);
151 | 
152 | 				
153 | 				var legend = serie7.getHtmlLegend(null, null, 1);
154 | 				jQuery('#legend5').html(legend);
155 | 				initChromaSample(color_x, class_x);
156 |    			
157 |    		});
158 |    		
159 | 	 });
160 |  	</script>
161 |    <script type="text/javascript">
162 | 	// from https://raw.github.com/kvz/phpjs/master/functions/strings/nl2br.js
163 | 	function nl2br (str, is_xhtml) {
164 | 	    // http://kevin.vanzonneveld.net
165 | 	    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
166 | 	    // +   improved by: Philip Peterson
167 | 	    // +   improved by: Onno Marsman
168 | 	    // +   improved by: Atli Þór
169 | 	    // +   bugfixed by: Onno Marsman
170 | 	    // +      input by: Brett Zamir (http://brett-zamir.me)
171 | 	    // +   bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
172 | 	    // +   improved by: Brett Zamir (http://brett-zamir.me)
173 | 	    // +   improved by: Maximusya
174 | 	    // *     example 1: nl2br('Kevin\nvan\nZonneveld');
175 | 	    // *     returns 1: 'Kevin<br />\nvan<br />\nZonneveld'
176 | 	    // *     example 2: nl2br("\nOne\nTwo\n\nThree\n", false);
177 | 	    // *     returns 2: '<br>\nOne<br>\nTwo<br>\n<br>\nThree<br>\n'
178 | 	    // *     example 3: nl2br("\nOne\nTwo\n\nThree\n", true);
179 | 	    // *     returns 3: '<br />\nOne<br />\nTwo<br />\n<br />\nThree<br />\n'
180 | 	    var breakTag = (is_xhtml || typeof is_xhtml === 'undefined') ? '<br />' : '<br>';
181 | 
182 | 	    return (str + '').replace(/([^>\r\n]?)(\r\n|\n\r|\r|\n)/g, '$1' + breakTag + '$2');
183 | 	}
184 | 	</script>
185 | </head>
186 | <body>
187 | 
188 | <div class="container" id="top">
189 | 	<h1>geostats - Javascript classification library <em>samples</em></h1>
190 | 	<p class="projectinfo"><a href="https://github.com/simogeo/geostats" title="geostats Github page">Github page</a> - <a href="https://github.com/simogeo/geostats/archive/master.zip" title="geostats download">download (from github)</a></p>
191 | 	<script type="text/javascript"><!--
192 | 	
193 | 	// Samples datasets
194 | 	// test integer - 14 values
195 | 	var a1 = Array(12, 22, 5, 8, 43, 2, 34, 12, 34, 36, 5, 21, 23, 45);
196 | 	// test integer - 17 values
197 | 	var a2 = Array(12, 22, 5, 8, 43, 2, 34, 12, 34, 36, 5, 21, 23, 45, 12, 31, 38);
198 | 	// test float - 5 values
199 | 	var a3 = Array(1.54567, 0.7623122, 1.895432, 2.435357, 0.11143);
200 | 	// test integer - 10 values
201 | 	var a4 = Array(12, 22, 5, 8, 43, 2, 34, 12, 34, 36);
202 | 	// test float
203 | 	var a5 = Array(0.1, 1.2, 3, 2.5, 1.6, 2.2, 3.1, 2.8, 1.1, 2.7, 7.1);
204 | 	// test integer - 11 values
205 | 	//var a6 = Array(12, 22, 18, 5, 8, 43, 2, 34, 12, 34, 36);
206 | 	var a6 = Array(12, 22, 18, 5, 8, 43, 2, 34, 12, 34, 36, 4, 9, 35, 12, 42, 43, 56, 12, 23, 
207 | 				43, 19, 11, -1, 51, -6, 34, 33,41, 45, 23, -3, 3, 54, 1, 18, 44, 41,28, 16, 19, 
208 | 				35, 44, 21, 23, -3, 5, 64, 15, 17, 7, 93, 6, 16, 47, 13, 46, 53, 10, 30, 31, 32, 
209 | 				58, 28, 32, 46,53, 31, 2, 36, 41, 23, 3, 8, 15, 54, 35, 79, 15, 83, 6,-9, 78, 74, 
210 | 				56, 78, 45, 62, 19, 70, 23, 51, 73, 67, 78, 34, 52, 61, 60, 11, 26, 48, 15, 2);
211 | 
212 | 	// First serie
213 | 	serie1 = new geostats(a1);
214 | 	document.write('<h2>Sample 1 - basic statistics methods <\/h2>');
215 | 	document.write('<p>geostats.min() : ' + serie1.min() + '<\/p>');
216 | 	document.write('<p>geostats.max() : ' + serie1.max() + '<\/p>');
217 | 	document.write('<p>geostats.sum() : ' + serie1.sum() + '<\/p>');
218 | 	document.write('<p>geostats.pop() : ' + serie1.pop() + '<\/p>');
219 | 	document.write('<p>geostats.mean() : ' + serie1.mean() + '<\/p>');
220 | 	document.write('<p>geostats.median() : ' + serie1.median() + '<\/p>');
221 | 	document.write('<p class="serie"><strong>Serie (sorted) : <\/strong>' + serie1.getSortedlist() + '<\/p>');
222 | 	document.write('<hr \/>');
223 | 
224 | 	// Second serie
225 | 	serie2 = new geostats(a2);
226 | 	document.write('<h2>Sample 2 - geostats.info() <\/h2>');
227 | 	document.write('<p>' + nl2br(serie2.info()) + '<\/p>');
228 | 	document.write('<p class="serie"><strong>Serie (sorted) : <\/strong>' + serie2.getSortedlist() + '<\/p>');
229 | 	document.write('<hr \/>');
230 | 
231 | 	// Third serie
232 | 	serie3 = new geostats(a3);
233 | 	document.write('<h2>Sample 3 - handle both integer and float values <\/h2>');
234 | 	document.write('<p>' + nl2br(serie3.info()) + '<\/p>');
235 | 	document.write('<p class="serie"><strong>Serie (sorted) : <\/strong>' + serie3.getSortedlist() + '<\/p>');
236 | 	document.write('<hr \/>');
237 | 
238 | 	// Fourth serie
239 | 	serie4 = new geostats(a4);
240 | 
241 | 	// we get Eq interval classification 3 classes
242 | 	var a = serie4.getClassEqInterval(3);
243 | 	var str  = '<strong>Classification Method : <\/strong>' + serie4.method + " :\n";
244 | 		str += '<div class="classes">';
245 | 	
246 | 	var ranges = serie4.ranges;
247 | 	for(i = 0; i < ranges.length ; i++) {
248 | 		str += ranges[i] + "\n";
249 | 	}
250 | 		str += '<\/div>';
251 | 
252 | 	// we get Eq interval classification 4 classes
253 | 	var a = serie4.getClassEqInterval(4);
254 | 	str += '<strong>Classification Method : <\/strong>' + serie4.method + " :\n";
255 | 	str += '<div class="classes">';
256 | 	
257 | 	var ranges = serie4.ranges;
258 | 	for(i = 0; i < ranges.length ; i++) {
259 | 		str += ranges[i] + "\n";
260 | 	}
261 | 		str += '<\/div>';
262 | 		
263 | 	// we get Eq interval classification 5 classes
264 | 	var a = serie4.getClassEqInterval(5);
265 | 	str += '<strong>Classification Method : <\/strong>' + serie4.method + " :\n";
266 | 	str += '<div class="classes">';
267 | 	var ranges = serie4.ranges;
268 | 	
269 | 	for(i = 0; i < ranges.length ; i++) {
270 | 		str += ranges[i] + "\n";
271 | 	}
272 | 	str += '<\/div>';
273 | 
274 | 		
275 | 	document.write('<h2>Sample 4 - classification : choose classes number <\/h2>');
276 | 	document.write('<p>' + nl2br(serie4.info()) + '<\/p>');
277 | 	document.write('<p>' + nl2br(str) + '<\/p>');
278 | 	document.write('<p class="serie"><strong>Serie (sorted) : <\/strong>' + serie4.getSortedlist() + '<\/p>');
279 | 	document.write('<hr \/>');
280 | 	
281 | 	// Fifth serie
282 | 	var serie5 = new geostats();
283 | 	serie5.setSerie(a5);
284 | 
285 | 	// we get Eq interval classification
286 | 	var a = serie5.getClassEqInterval(4);
287 | 	var str  = '<strong>Classification Method : <\/strong>' + serie5.method + " :\n";
288 | 	str += '<div class="classes">';
289 | 	var ranges = serie5.ranges;
290 | 	for(i = 0; i < ranges.length ; i++) {
291 | 		str += ranges[i] + "\n";
292 | 	}
293 | 	str += '<\/div>';
294 | 
295 | 	// we get Quantile classification
296 | 	var a = serie5.getClassQuantile(4);
297 | 	str += '<strong>Classification Method : <\/strong>' + serie5.method + " :\n";
298 | 	str += '<div class="classes">';
299 | 	var ranges = serie5.ranges;
300 | 	
301 | 	for(i = 0; i < ranges.length ; i++) {
302 | 		str += ranges[i] + "\n";
303 | 	}
304 | 	str += '<\/div>';
305 | 	
306 | 	// we get Std Deviation classification
307 | 	var a = serie5.getClassStdDeviation(4);
308 | 	str += '<strong>Classification Method : <\/strong>' + serie5.method + " :\n";
309 | 	str += '<div class="classes">';
310 | 	var ranges = serie5.ranges;
311 | 	
312 | 	for(i = 0; i < ranges.length ; i++) {
313 | 		str += ranges[i] + "\n";
314 | 	}
315 | 	str += '<\/div>';
316 | 	
317 | 	// we get Arithmetic Progression classification
318 | 	var a = serie5.getClassArithmeticProgression(4);
319 | 	str += '<strong>Classification Method : <\/strong>' + serie5.method + " :\n";
320 | 	str += '<div class="classes">';
321 | 	var ranges = serie5.ranges;
322 | 	
323 | 	for(i = 0; i < ranges.length ; i++) {
324 | 		str += ranges[i] + "\n";
325 | 	}
326 | 	str += '<\/div>';
327 | 	
328 | 	// we get Arithmetic Progression classification
329 | 	var a = serie5.getClassGeometricProgression(4);
330 | 	str += '<strong>Classification Method : <\/strong>' + serie5.method + " :\n";
331 | 	str += '<div class="classes">';
332 | 	var ranges = serie5.ranges;
333 | 	
334 | 	for(i = 0; i < ranges.length ; i++) {
335 | 		str += ranges[i] + "\n";
336 | 	}
337 | 	str += '<\/div>';
338 | 
339 | 	// we get Jenks classification
340 | 	var a = serie5.getClassJenks(4);
341 | 	str += '<strong>Classification Method : <\/strong>' + serie5.method + " :\n";
342 | 	str += '<div class="classes">';
343 | 	var ranges = serie5.ranges;
344 | 	for(i = 0; i < ranges.length ; i++) {
345 | 		str += ranges[i] + "\n";
346 | 	}
347 | 	str += '<\/div>';
348 | 		
349 | 	document.write('<h2>Sample 5 - classification : choose classification method<\/h2>');
350 | 	document.write('<h3>Equal Interval, Quantile, Standard Deviation, Arithmetic Progression, Geometric Progression, Jenks<\/h3>');
351 | 	document.write('<div>6 methods: <\/div>');
352 | 	document.write('<ul>');
353 | 	document.write('<li><em>geostats.getClassEqInterval(nbClass);<\/em><\/<li>');
354 | 	document.write('<li><em>geostats.getClassQuantile(nbClass);<\/em><\/<li>');
355 | 	document.write('<li><em>geostats.getClassStdDeviation(nbClass);<\/em><\/<li>');
356 | 	document.write('<li><em>geostats.getClassArithmeticProgression(nbClass);<\/em><\/<li>');
357 | 	document.write('<li><em>geostats.getClassGeometricProgression(nbClass);<\/em><\/<li>');
358 | 	document.write('<li><em>geostats.getClassJenks(nbClass);<\/em><\/<li>');
359 | 	document.write('<\/ul>');
360 | 	document.write('<p>You can even use <em>geostats.setClassManually([0.1, 1.5, 2.2, 3.5, 7.1]);<\/em> method to classify manually your data. It will then be easy to render the legend.<\/p>');
361 | 	document.write('<p>' + nl2br(serie5.info()) + '<\/p>');
362 | 	document.write('<p>' + nl2br(str) + '<\/p>');
363 | 	document.write('<p class="serie"><strong>Serie (sorted) : <\/strong>' + serie5.getSortedlist() + '<\/p>');
364 | 	document.write('<hr \/>');
365 | 
366 | 	// Sixth serie
367 | 	var serie6 = new geostats(a6);
368 | 
369 | 	// we get Eq interval classification
370 | 	serie6.getClassEqInterval(3);
371 | 	var str  = '<strong>Classification Method : <\/strong>' + serie6.method + " :\n";
372 | 	str += '<div class="classes">';
373 | 	var ranges = serie6.getRanges();
374 | 	for(i = 0; i < ranges.length ; i++) {
375 | 		str += ranges[i] + "\n";
376 | 	}
377 | 	str += '<\/div>';
378 | 
379 | 	// we get Quantile classification
380 | 	serie6.getClassQuantile(5);
381 | 	str += '<strong>Classification Method : <\/strong>' + serie6.method + " :\n";
382 | 	str += '<div class="classes">';
383 | 	var ranges = serie6.getRanges();
384 | 	for(i = 0; i < ranges.length ; i++) {
385 | 		str += ranges[i] + "\n";
386 | 	}
387 | 	str += '<\/div>';
388 | 
389 | 	// we get Jenks classification
390 | 	serie6.getClassJenks(4);
391 | 	str += '<strong>Classification Method : <\/strong>' + serie6.method + " :\n";
392 | 	str += '<div class="classes">';
393 | 	var ranges = serie6.getRanges();
394 | 	for(i = 0; i < ranges.length ; i++) {
395 | 		str += ranges[i] + "\n";
396 | 	}
397 | 	str += '<\/div>';
398 | 	
399 | 		
400 | 	document.write('<h2>Sample 6 - choose the right classification<\/h2>');
401 | 	document.write('<p>' + nl2br(serie6.info()) + '<\/p>');
402 | 	document.write('<p>' + nl2br(str) + '<\/p>');
403 | 	document.write('<p class="serie"><strong>Serie (sorted) : <\/strong>' + serie6.getSortedlist() + '<\/p>');
404 | 	document.write('<hr \/>');
405 | 
406 | 	document.write('<div id="sample-7"><\/div>');
407 | 	--></script>
408 | 	<div id="sample-8">
409 | 		<h2>Sample 8 - a choropleth representation (using openlayers) with JSON input</h2>
410 | 		<div id="method"></div>
411 | 		<div id="map"></div>
412 | 	</div>
413 | 	<div id="sample-9">
414 | 		<h2>Sample 9 - dynamic HTML legend with user input, feature count, callback function and display mode option</h2>
415 | 		<div id="legend" class="legend">
416 | 			<p>Call to legend method with default options</p>
417 | 		</div>
418 | 		<div id="legend2" class="legend">
419 | 			<p>Call to legend method with options : customized text, callback function and 'distinct' mode. Decimal precision has been set to 2.</p>
420 | 		</div>
421 | 		<div id="legend3" class="legend">
422 | 			<p>Call to legend method with options : 'discontinuous' mode, and descending order.</p>
423 | 		</div>
424 | 	</div>
425 | 	<div style="clear:both"></div>
426 | 	<div id="sample-10">
427 | 		<h2>Sample 10 - Handle unique values</h2>
428 | 		<div id="map2"></div>
429 | 		<div id="legend4"></div>
430 | 	</div>
431 | 	<div id="sample-11">
432 | 		<h2>Sample 11 -  a choropleth representation (using openlayers) with JSON input and <a href="https://github.com/gka/chroma.js">Chroma.js</a></h2>
433 | 		<div id="chroma-code">
434 | 			<pre>
435 | 			<code>
436 | 				// getting the color ramp from chroma by passing min, max values and number of classes
437 | 				var color_x = chroma.scale('RdYlGn').domain([serie7.min(),serie7.max()], 5).colors();
438 | 				
439 | 				// setting colors into geostats
440 | 				serie7.setColors(color_x);
441 | 				
442 | 				// rendering the html legend with geostats
443 | 				jQuery('#legend5').html(serie7.getHtmlLegend(null, null, 1));
444 | 				
445 | 				// displaying map with openlayers
446 | 				initChromaSample(color_x, class_x);
447 | 			</code></pre>
448 | 		</div>
449 | 		<div id="map3"></div>
450 | 		<div id="legend5"></div>
451 | 	</div>
452 | 	<div id="sample-12">
453 | 		<h2>Sample 12 - Reading shapefile and creating choropleth map from attribute data</h2>
454 | 		<div>Using geostats and <a href="http://github.com/wavded/js-shapefile-to-geojson">js-shapefile-to-geojson</a> (by <a href="https://github.com/wavded">Marc Harter</a>) to create thematic maps. <a href="./sample_shp.html">Access demo page.</a></div>
455 | 	</div>
456 | 	
457 |   <div id="footer"><em>geostats.js</em> - Copyright (c) 2011 Simon Georget - released under MIT license - <a href="https://github.com/simogeo/geostats" title="geostats Github page">Github page</a> | <a href="#top">Go to top</a></div>
458 | </div>
459 | </body>
460 | </html>


--------------------------------------------------------------------------------
/sample_shp.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 |     <head>
  4 |         <title>geostats - js-shapefile-to-geojson integration sample</title>
  5 |         <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js"></script>
  6 |    			<script type="text/javascript" src="lib/geostats.js"></script>
  7 |    			<script type="text/javascript" src="http://openlayers.org/api/2.11/OpenLayers.js"></script>
  8 |    			<link rel="stylesheet" href="lib/geostats.css" type="text/css" />
  9 | 			   <style type="text/css">
 10 | 				  <!--
 11 | 				  body {
 12 | 				    font-family: "Lucida Sans Unicode", "Lucida Grande", Verdana, Arial, Helvetica, sans-serif;
 13 | 				    color:#333;
 14 | 				    font-size: 0.8em;
 15 | 				    background-color: #F7F7F7;
 16 | 				  }
 17 | 				  #legend {display:inline-block;width:20%;margin:0 1em 2em 0;font-size:0.85em;vertical-align: top}
 18 | 				  .legend-block {
 19 | 					    border: 1px solid #555555;
 20 | 					    display: block;
 21 | 					    float: left;
 22 | 					    height: 12px;
 23 | 					    margin: 0.3em 0.8em 0 2em;
 24 | 					    width: 20px;
 25 | 					}
 26 | 				  .container {margin:0 auto;width:90%;}
 27 | 				  .serie strong {color:#333;}
 28 | 				  .serie {font-size: .9em;color:#555;}
 29 | 				  .classes {margin:0em 4em 2em;}
 30 | 				  .projectinfo {width:100%;text-align: center;margin:-3em 0 3em;}
 31 | 				  a {color:#F47FE7;font-weight: bold;text-shadow: #fff 2px 2px 0px;text-decoration: none;}
 32 | 				  a:hover {color:#514F51;}
 33 | 				  #map {width:76%;height:500px;border: 1px solid #ccc;background-color: #eee;display:inline-block;}
 34 | 				  h1 {color:#B5B1B1;text-shadow: #fff 2px 2px 0px;text-align: center;margin:2em 0;}
 35 | 				  h2 {color:#A2A3F2;text-shadow: #fff 2px 2px 0px;margin:2em 0 1em 0;}
 36 | 				  h3 {color:#555;font-size: .9em}
 37 | 				  hr {
 38 | 						height: 1px;
 39 | 						margin: -0.5em 0;
 40 | 						padding: 0;
 41 | 						color: #ddd;
 42 | 						background-color: #ddd;
 43 | 						border: 0;
 44 | 				  }
 45 | 				  #footer {font-size:0.8em;text-align: center;color:#777;margin:2em 0 1em;padding:.3em}
 46 | 				  -->
 47 | 			  </style>
 48 |     </head>
 49 |     <body>
 50 |     <div class="container" id="top">
 51 | 		<h1>geostats - <a href="http://github.com/wavded/js-shapefile-to-geojson"><em>js-shapefile-to-geojson</em></a> integration sample</h1>
 52 |         <h2>Reading shapefile and creating choropleth map from attribute data</h2>
 53 |         <div id="map"></div>
 54 |         <script src="./tests/js-shapefile-to-geojson/stream.js"></script>
 55 |         <script src="./tests/js-shapefile-to-geojson/shapefile.js"></script>
 56 |         <script src="./tests/js-shapefile-to-geojson/dbf.js"></script>
 57 |         <script type="text/javascript">
 58 |         
 59 |         					var host = "http://"+window.location.hostname;
 60 |         					var am = document.location.pathname.substring(1, document.location.pathname.lastIndexOf('/') + 1);
 61 |         
 62 | 									//get user defined class
 63 | 									// if equals value
 64 | 									function getClass(val, a) {
 65 | 										// return 2;
 66 | 										for ( var i = 0; i < a.length; i++) {
 67 | 											var item = a[i].split(/ - /);
 68 | 											if (val <= parseFloat(item[1])) {
 69 | 												return i;
 70 | 											}
 71 | 										}
 72 | 									}
 73 | 
 74 | 									var populationValues = []; // will store values
 75 | 
 76 | 									OpenLayers.ImgPath = "http://js.mapbox.com/theme/dark/";
 77 | 
 78 | 									var options = {
 79 | 											scales: [130000000, 65000000, 32500000, 17000000, 8500000, 4200000],
 80 | 									        controls: [
 81 | 														new OpenLayers.Control.PanZoomBar(),
 82 | 														new OpenLayers.Control.ScaleLine({geodesic: true, maxWidth: 200, bottomOutUnits: "", bottomInUnits: ""}),
 83 | 														new OpenLayers.Control.MousePosition(),
 84 | 														new OpenLayers.Control.Navigation()
 85 | 													],
 86 | 													numZoomLevels: 1
 87 | 									    };
 88 | 									
 89 | 									// Create a new map with options defined above
 90 | 								  map = new OpenLayers.Map( 'map', options );
 91 | 									
 92 | 									parser = new OpenLayers.Format.GeoJSON();
 93 | 
 94 | 									shapefile = new Shapefile(
 95 | 											{
 96 | 												shp : host + '/' + am + "tests/js-shapefile-to-geojson/testdata/world.shp",
 97 | 												dbf : host + '/' + am + "tests/js-shapefile-to-geojson/testdata/world.dbf"
 98 | 											},
 99 | 											function(data) {
100 | 
101 | 												var features = parser.read(data.geojson);
102 | 												var origin = features;
103 | 
104 | 												// we get the desired attribute
105 | 												for (i = 0; i < features.length; i++) {
106 | 													populationValues.push(features[i].attributes.POP2005);
107 | 												}
108 | 
109 | 												// geostats settings
110 | 												serie = new geostats(populationValues);
111 | 												serie.getClassQuantile(5);
112 | 												var ranges = serie.ranges;
113 | 												console.log(ranges.join(', '));
114 | 
115 | 												var colors =new Array('#FEF0D9', '#FDCC8A','#FC8D59', '#E34A33','#B30000')
116 | 												serie.setColors(colors);
117 | 												
118 | 												var legend = serie.getHtmlLegend(null,'Population in 2005');
119 | 
120 | 												// openlayers settings
121 | 
122 | 												var context_x = {
123 | 													getColour : function(feature) {
124 | 														color = colors;
125 | 														return color[getClass(feature.attributes["POP2005"],ranges)];
126 | 													}
127 | 												};
128 | 
129 | 												var template = {
130 | 													fillOpacity : 0.9,
131 | 													strokeColor : "#ffffff",
132 | 													strokeWidth : 1,
133 | 													fillColor : "${getColour}"
134 | 												};
135 | 
136 | 												// Style
137 | 												var style_x = new OpenLayers.Style(template, {
138 | 															context : context_x
139 | 														});
140 | 												var styleMap_x = new OpenLayers.StyleMap(
141 | 														{
142 | 															'default' : style_x
143 | 														});
144 | 
145 | 												var vector = new OpenLayers.Layer.Vector('Countries',
146 | 														{
147 | 															styleMap : styleMap_x,
148 | 															isBaseLayer : true
149 | 														});
150 | 
151 | 												vector.addFeatures(features);
152 | 												map.addLayer(vector);
153 | 
154 | 												map.zoomToExtent(vector.getDataExtent());
155 | 
156 | 												// console.log(data);
157 | 												// console.log(features);
158 | 												$('#legend').html(legend);
159 | 
160 | 											})
161 | 								</script>
162 |         <div id="legend"></div>
163 |         <div id="footer"><em>geostats.js</em> - Copyright (c) 2011 Simon Georget - released under MIT license - <a href="https://github.com/simogeo/geostats" title="geostats Github page">Github page</a> | <a href="#top">Go to top</a></div>
164 |        </div>
165 |     </body>
166 | </html>
167 | 
168 | 


--------------------------------------------------------------------------------
/tests/js-shapefile-to-geojson/dbf.js:
--------------------------------------------------------------------------------
  1 | (function(window,undefined){
  2 | 
  3 |     if(window.document && window.Worker){
  4 |         var worker = new Worker("./tests/js-shapefile-to-geojson/dbf.js")
  5 | 
  6 |         var DBF = function(url, callback){
  7 |             var
  8 |                 w = this._worker = worker,
  9 |                 t = this
 10 | 
 11 |             w.onmessage = function(e){
 12 |                 t.data = e.data
 13 |                 if (callback) callback(e.data);
 14 |             };
 15 | 
 16 |             w.postMessage(url)
 17 |         }
 18 | 
 19 |         window["DBF"] = DBF
 20 |         return
 21 |     }
 22 | 
 23 |     var IN_WORKER = !window.document
 24 |     if (IN_WORKER) {
 25 |         importScripts('stream.js')
 26 |         onmessage = function(e){
 27 |             new DBF(e.data);
 28 |         };
 29 |     }
 30 | 
 31 |     var
 32 |         DBASE_LEVEL = {
 33 |             "3": "dBASE Level 5",
 34 |             "4": "dBase Level 7"
 35 |         },
 36 |         DBASE_FIELD_TYPE = {
 37 |             "N": "Number",
 38 |             "C": "Character", // binary
 39 |             "L": "Logical",
 40 |             "D": "Date",
 41 |             "M": "Memo", // binary
 42 |             "F": "Floating point",
 43 |             "B": "Binary",
 44 |             "G": "General",
 45 |             "P": "Picture",
 46 |             "Y": "Currency",
 47 |             "T": "DateTime",
 48 |             "I": "Integer",
 49 |             "V": "VariField",
 50 |             "X": "Variant",
 51 |             "@": "Timestamp",
 52 |             "O": "Double",
 53 |             "+": "Autoincrement", // (dBase Level 7)
 54 |             "O": "Double", // (dBase Level 7)
 55 |             "@": "Timestamp" // (dBase Level 7)
 56 |         }
 57 | 
 58 |     var DBF = function(url, callback){
 59 |         var xhr = new XMLHttpRequest();
 60 | 
 61 |         xhr.open("GET", url, false)
 62 |         xhr.overrideMimeType("text/plain; charset=x-user-defined")
 63 |         xhr.send()
 64 | 
 65 |         if(200 != xhr.status)
 66 |         	throw "Unable to load " + url + " status: " + xhr.status
 67 | 
 68 |         this.stream = new Gordon.Stream(xhr.responseText)
 69 |         this.callback = callback
 70 | 
 71 |         this.readFileHeader()
 72 |         this.readFieldDescriptions()
 73 |         this.readRecords()
 74 | 
 75 |         this._postMessage()
 76 |     }
 77 | 
 78 |     DBF.prototype = {
 79 |         constructor: DBF,
 80 |         _postMessage: function() {
 81 |             var data = {
 82 |                     header: this.header,
 83 |                     fields: this.fields,
 84 |                     records: this.records
 85 |                 }
 86 |             if (IN_WORKER) postMessage(data)
 87 |             else if (this.callback) this.callback(data)
 88 |         },
 89 |         readFileHeader: function(){
 90 |             var s = this.stream,
 91 |                 header = this.header = {},
 92 |                 date = new Date;
 93 | 
 94 |             header.version = DBASE_LEVEL[s.readSI8()]
 95 | 
 96 |             // Date of last update; in YYMMDD format.  Each byte contains the number as a binary.  YY is added to a base of 1900 decimal to determine the actual year. Therefore, YY has possible values from 0x00-0xFF, which allows for a range from 1900-2155.
 97 |             date.setUTCFullYear(1900 + s.readSI8())
 98 |             date.setUTCMonth(s.readSI8())
 99 |             date.setUTCDate(s.readSI8())
100 | 
101 |             header.lastUpdated = date
102 | 
103 |             // Number of records in file
104 |             header.numRecords = s.readSI32()
105 | 
106 |             // Position of first data record
107 |             header.firstRecordPosition = s.readSI16()
108 | 
109 |             // Length of one data record, including delete flag
110 |             header.recordLength = s.readSI16()
111 | 
112 |             // Reserved; filled with zeros
113 |             s.offset += 16
114 | 
115 |             /*
116 |             Table flags:
117 |             0x01   file has a structural .cdx
118 |             0x02   file has a Memo field
119 |             0x04   file is a database (.dbc)
120 |             This byte can contain the sum of any of the above values. For example, the value 0x03 indicates the table has a structural .cdx and a Memo field.
121 |             */
122 |             header.flags = s.readSI8()
123 | 
124 |             // Code page mark
125 |             header.codePageMark = s.readSI8()
126 | 
127 |             // Reserved; filled with zeros.
128 |             s.offset += 2
129 | 
130 |         },
131 |         readFieldDescriptions: function(){
132 |             var s = this.stream,
133 |                 fields = [],
134 |                 field
135 | 
136 |             while (s.readSI8() != 0x0D) {
137 |                 s.offset--
138 |                 field = {}
139 | 
140 |                 // Field name with a maximum of 10 characters. If less than 10, it is padded with null characters (0x00).
141 |                 field.name = s.readString(11).replace(/\u0000/g,"")
142 | 
143 |                 field.type = DBASE_FIELD_TYPE[s.readString(1)]
144 | 
145 |                 // Displacement of field in record
146 |                 field.fieldDisplacement = s.readSI32()
147 | 
148 |                 // Length of field (in bytes)
149 |                 field.fieldLength = s.readUI8()
150 | 
151 |                 // Number of decimal places
152 |                 field.decimals = s.readSI8()
153 | 
154 |                 /*
155 |                 Field flags:
156 |                 0x01   System Column (not visible to user)
157 |                 0x02   Column can store null values
158 |                 0x04   Binary column (for CHAR and MEMO only)
159 |                 0x06   (0x02+0x04) When a field is NULL and binary (Integer, Currency, and Character/Memo fields)
160 |                 0x0C   Column is autoincrementing
161 |                 */
162 |                 field.flags = s.readSI8()
163 | 
164 |                 // Value of autoincrement Next value
165 |                 field.autoincrementNextValue = s.readSI32()
166 | 
167 |                 // Value of autoincrement Step value
168 |                 field.autoincrementStepValue = s.readSI8()
169 | 
170 |                 // Reserved
171 |                 s.offset += 8
172 | 
173 |                 fields.push(field)
174 |             }
175 | 
176 |             this.fields = fields
177 | 
178 |         },
179 |         readRecords: function(){
180 |             var s = this.stream,
181 |                 numRecords = this.header.numRecords,
182 |                 recordsOffset = this.header.firstRecordPosition,
183 |                 recordSize = this.header.recordLength,
184 |                 fields = this.fields,
185 |                 numFields = fields.length,
186 |                 records = [],
187 |                 field, record
188 | 
189 |             for (var index = 0; index < numRecords; index++) {
190 |                 s.offset = recordsOffset + index * recordSize
191 | 
192 |                 record = {}
193 | 
194 |                 // Data records begin with a delete flag byte. If this byte is an ASCII space (0x20), the record is not deleted. If the first byte is an asterisk (0x2A), the record is deleted
195 |                 record._isDeleted = s.readSI8() == 42
196 | 
197 |                 for(var i = 0; i < numFields; i++){
198 |                     field = fields[i]
199 |                     record[field.name] = s.readString(field.fieldLength).trim();
200 |                 }
201 | 
202 |                 records.push(record);
203 |             }
204 | 
205 |             this.records = records
206 | 
207 |         }
208 |     }
209 | 
210 |     window["DBF"] = DBF;
211 | 
212 | })(self)
213 | 
214 | 


--------------------------------------------------------------------------------
/tests/js-shapefile-to-geojson/readme.md:
--------------------------------------------------------------------------------
 1 | This project allows a user to load Shapefiles and DBFs into the browser with JavaScript.
 2 | Outputs as [GeoJSON](http://geojson.org/) for use with other Mapping APIs such as [OpenLayers](http://openlayers.org).
 3 | 
 4 | Inspired by the excellent work by Tom Carden ([http://github.com/RandomEtc/shapefile-js/](http://github.com/RandomEtc/shapefile-js/)).
 5 | 
 6 | ### Overview
 7 | 
 8 | I just got this out there so nothing is minified.  See index.html for an example of order.  All files need to be in the same directory.  This will use Web Workers if the browser support exists.  Not recommended for large files, more of an experiment than anything.
 9 | 
10 | ### Usage
11 | 
12 | You can use it to parse shapefiles (.shp) or dBase files (.dbf) or both.  Here are some examples.
13 | 
14 | Load Shapefile Only
15 | 
16 |     var shapefile = new Shapefile("myshapefile.shp",function(data){
17 |         // data returned
18 |     };
19 | 
20 | Load DBF Only
21 | 
22 |     var dbf = new DBF("mydbf.dbf",function(data){
23 |         // data returned
24 |     };
25 | 
26 | Load Shapefile w/ DBF Attributes
27 | 
28 |     var shapefile = new Shapefile({
29 |         shp: "myshape.dbf",
30 |         dbf: "myshape.dbf"
31 |     }, function(data){
32 |         // data returned
33 |     };
34 | 
35 | Use with OpenLayers
36 | 
37 |     var
38 |         parser = new OpenLayer.Format.GeoJSON(),
39 |         features,
40 |         shapefile = new Shapefile({
41 |             shp: "myshape.dbf",
42 |             dbf: "myshape.dbf"
43 |         }, function(data){
44 |             features = parser.read(data.geojson);
45 |         };
46 | 
47 | ### Resources
48 | 
49 | I used the technical descriptions found here to parse the binary:
50 | 
51 | > [ESRI Shapefile Technical Description - PDF](http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf)
52 | 
53 | > [dBase (Xbase) File Format Description](http://www.dbf2002.com/dbf-file-format.html)
54 | 
55 | ### Future
56 | 
57 | I plan to implement (time permitting) some custom renderers like SVG or Canvas (besides using OpenLayers) to improve the speed.
58 | 
59 | Feel free to hack at this, submit bugs, pull requests, and make it better.  If you write a renderer, please push it back and I'll add it to the project.
60 | 
61 | ### License
62 | 
63 | (The MIT License)
64 | 
65 | Copyright (c) 2010 Marc Harter &lt;wavded@gmail.com&gt;
66 | 
67 | Permission is hereby granted, free of charge, to any person obtaining
68 | a copy of this software and associated documentation files (the
69 | 'Software'), to deal in the Software without restriction, including
70 | without limitation the rights to use, copy, modify, merge, publish,
71 | distribute, sublicense, and/or sell copies of the Software, and to
72 | permit persons to whom the Software is furnished to do so, subject to
73 | the following conditions:
74 | 
75 | The above copyright notice and this permission notice shall be
76 | included in all copies or substantial portions of the Software.
77 | 
78 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
79 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
80 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
81 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
82 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
83 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
84 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
85 | 


--------------------------------------------------------------------------------
/tests/js-shapefile-to-geojson/shapefile.js:
--------------------------------------------------------------------------------
  1 | (function(window,undefined){
  2 | 
  3 |     if(window.document && window.Worker){
  4 |         var worker = new Worker("./tests/js-shapefile-to-geojson/shapefile.js")
  5 | 
  6 |         var Shapefile = function(o, callback){
  7 |             var
  8 |                 w = this.worker = worker,
  9 |                 t = this,
 10 |                 o = typeof o == "string" ? {shp: o} : o
 11 | 
 12 |             w.onmessage = function(e){
 13 |                 t.data = e.date
 14 |                 if(callback) callback(e.data)
 15 |             }
 16 | 
 17 |             w.postMessage(["Load", o])
 18 | 
 19 |             if(o.dbf) this.dbf = new DBF(o.dbf,function(data){
 20 |                 w.postMessage(["Add DBF Attributes", data])
 21 |             })
 22 |         }
 23 | 
 24 |         window["Shapefile"] = Shapefile
 25 |         return
 26 |     }
 27 | 
 28 |     var IN_WORKER = !window.document
 29 |     if (IN_WORKER) {
 30 |         importScripts('stream.js')
 31 |         onmessage = function(e){
 32 |             switch (e.data[0]) {
 33 |                 case "Load":
 34 |                     window.shapefile = new Shapefile(e.data[1])
 35 |                     break
 36 |                 case "Add DBF Attributes":
 37 |                     window.shapefile.addDBFDataToGeoJSON(e.data[1])
 38 |                     window.shapefile._postMessage()
 39 |                     break
 40 |                 default:
 41 |             }
 42 |         };
 43 |     }
 44 | 
 45 |     var SHAPE_TYPES = {
 46 |         "0": "Null Shape",
 47 |         "1": "Point", // standard shapes
 48 |         "3": "PolyLine",
 49 |         "5": "Polygon",
 50 |         "8": "MultiPoint",
 51 |         "11": "PointZ", // 3d shapes
 52 |         "13": "PolyLineZ",
 53 |         "15": "PolygonZ",
 54 |         "18": "MultiPointZ",
 55 |         "21": "PointM", // user-defined measurement shapes
 56 |         "23": "PolyLineM",
 57 |         "25": "PolygonM",
 58 |         "28": "MultiPointM",
 59 |         "31": "MultiPatch"
 60 |     }
 61 | 
 62 |     var Shapefile = function(o,callback){
 63 |         var xhr = new XMLHttpRequest(),
 64 |             that = this,
 65 |             o = typeof o == "string" ? {shp: o} : o
 66 | 
 67 |         xhr.open("GET", o.shp, false)
 68 |         xhr.overrideMimeType("text/plain; charset=x-user-defined")
 69 |         xhr.send()
 70 | 
 71 |         if(200 != xhr.status)
 72 |         	throw "Unable to load " + o.shp + " status: " + xhr.status
 73 | 
 74 |         this.url = o.shp
 75 |         this.stream = new Gordon.Stream(xhr.responseText)
 76 |         this.callback = callback
 77 | 
 78 |         this.readFileHeader()
 79 |         this.readRecords()
 80 |         this.formatIntoGeoJson()
 81 | 
 82 |         if(o.dbf) this.dbf = IN_WORKER ?
 83 |             null :
 84 |             new DBF(o.dbf,function(data){
 85 |                 that.addDBFDataToGeoJSON(data)
 86 |                 that._postMessage()
 87 |             })
 88 |         else this._postMessage
 89 |     }
 90 | 
 91 |     Shapefile.prototype = {
 92 |         constructor: Shapefile,
 93 |         _postMessage: function() {
 94 |             var data = {
 95 |                     header: this.header,
 96 |                     records: this.records,
 97 |                     dbf: this.dbf,
 98 |                     geojson: this.geojson
 99 |                 }
100 |             if (IN_WORKER) postMessage(data)
101 |             else if (this.callback) this.callback(data)
102 |         },
103 |         readFileHeader: function(){
104 |             var s = this.stream,
105 |                 header = this.header = {}
106 | 
107 |             // The main file header is fixed at 100 bytes in length
108 |             if(s < 100) throw "Invalid Header Length"
109 | 
110 |             // File code (always hex value 0x0000270a)
111 |             header.fileCode = s.readSI32(true)
112 | 
113 |             if(header.fileCode != parseInt(0x0000270a))
114 |                 throw "Invalid File Code"
115 | 
116 |             // Unused; five uint32
117 |             s.offset += 4 * 5
118 | 
119 |             // File length (in 16-bit words, including the header)
120 |             header.fileLength = s.readSI32(true) * 2
121 | 
122 |             header.version = s.readSI32()
123 | 
124 |             header.shapeType = SHAPE_TYPES[s.readSI32()]
125 | 
126 |             // Minimum bounding rectangle (MBR) of all shapes contained within the shapefile; four doubles in the following order: min X, min Y, max X, max Y
127 |             this._readBounds(header)
128 | 
129 |             // Z axis range
130 |             header.rangeZ = {
131 |                 min: s.readDouble(),
132 |                 max: s.readDouble()
133 |             }
134 | 
135 |             // User defined measurement range
136 |             header.rangeM = {
137 |                 min: s.readDouble(),
138 |                 max: s.readDouble()
139 |             }
140 | 
141 |         },
142 |         readRecords: function(){
143 |             var s = this.stream,
144 |                 records = this.records = [],
145 |                 record
146 | 
147 |             do {
148 |                 record = {}
149 | 
150 |                 // Record number (1-based)
151 |                 record.id = s.readSI32(true)
152 | 
153 |                 if(record.id == 0) break //no more records
154 | 
155 |                 // Record length (in 16-bit words)
156 |                 record.length = s.readSI32(true) * 2
157 | 
158 |                 record.shapeType = SHAPE_TYPES[s.readSI32()]
159 | 
160 |                 // Read specific shape
161 |                 this["_read" + record.shapeType](record);
162 | 
163 |                 records.push(record);
164 | 
165 |             } while(true);
166 | 
167 |         },
168 |         _readBounds: function(object){
169 |             var s = this.stream
170 | 
171 |             object.bounds = {
172 |                 left: s.readDouble(),
173 |                 bottom: s.readDouble(),
174 |                 right: s.readDouble(),
175 |                 top: s.readDouble()
176 |             }
177 | 
178 |             return object
179 |         },
180 |         _readParts: function(record){
181 |             var s = this.stream,
182 |                 nparts,
183 |                 parts = []
184 | 
185 |             nparts = record.numParts = s.readSI32()
186 | 
187 |             // since number of points always proceeds number of parts, capture it now
188 |             record.numPoints = s.readSI32()
189 | 
190 |             // parts array indicates at which index the next part starts at
191 |             while(nparts--) parts.push(s.readSI32())
192 | 
193 |             record.parts = parts
194 | 
195 |             return record
196 |         },
197 |         _readPoint: function(record){
198 |             var s = this.stream
199 | 
200 |             record.x = s.readDouble()
201 |             record.y = s.readDouble()
202 | 
203 |             return record
204 |         },
205 |         _readPoints: function(record){
206 |             var s = this.stream,
207 |                 points = [],
208 |                 npoints = record.numPoints || (record.numPoints = s.readSI32())
209 | 
210 |             while(npoints--)
211 |                 points.push({
212 |                     x: s.readDouble(),
213 |                     y: s.readDouble()
214 |                 })
215 | 
216 |             record.points = points
217 | 
218 |             return record
219 |         },
220 |         _readMultiPoint: function(record){
221 |             var s = this.stream
222 | 
223 |             this._readBounds(record)
224 |             this._readPoints(record)
225 | 
226 |             return record
227 |         },
228 |         _readPolygon: function(record){
229 |             var s = this.stream
230 | 
231 |             this._readBounds(record)
232 |             this._readParts(record)
233 |             this._readPoints(record)
234 | 
235 |             return record
236 |         },
237 |         _readPolyLine: function(record){
238 |             return this._readPolygon(record);
239 |         },
240 |         formatIntoGeoJson: function(){
241 |             var bounds = this.header.bounds,
242 |                 records = this.records,
243 |                 features = [],
244 |                 feature, geometry, points, fbounds, gcoords, parts, point,
245 |                 geojson = {}
246 | 
247 |             geojson.type = "FeatureCollection"
248 |             geojson.bbox = [
249 |                     bounds.left,
250 |                     bounds.bottom,
251 |                     bounds.right,
252 |                     bounds.top
253 |                 ]
254 |             geojson.features = features
255 | 
256 |             for (var r = 0, record; record = records[r]; r++){
257 |                 feature = {}, fbounds = record.bounds, points = record.points, parts = record.parts
258 |                 feature.type = "Feature"
259 |                 feature.bbox = [
260 |                     fbounds.left,
261 |                     fbounds.bottom,
262 |                     fbounds.right,
263 |                     fbounds.top
264 |                 ]
265 |                 geometry = feature.geometry = {}
266 | 
267 |                 switch (record.shapeType) {
268 |                     case "Point":
269 |                         geometry.type = "Point"
270 |                         geometry.coordinates = [
271 |                             record.points.x,
272 |                             record.points,y ]
273 |                         break
274 |                     case "MultiPoint":
275 |                     case "PolyLine":
276 |                         geometry.type = (record.shapeType == "PolyLine" ? "LineString" : "MultiPoint")
277 |                         gcoords = geometry.coordinates = []
278 | 
279 |                         for (var p = 0; p < points.length; p++){
280 |                             var point = points[p]
281 |                             gcoords.push([point.x,point.y])
282 |                         }
283 |                         break
284 |                     case "Polygon":
285 |                         geometry.type = "Polygon"
286 |                         gcoords = geometry.coordinates = []
287 | 
288 |                         for (var pt = 0; pt < parts.length; pt++){
289 |                             var partIndex = parts[pt],
290 |                                 part = [],
291 |                                 point
292 | 
293 |                             // partIndex 0 == main poly, partIndex > 0 == holes in poly
294 |                             for (var p = partIndex; p < (parts[pt+1] || points.length); p++){
295 |                                 point = points[p]
296 |                                 part.push([point.x,point.y])
297 |                             }
298 |                             gcoords.push(part)
299 |                         }
300 |                         break
301 |                     default:
302 |                 }
303 |                 features.push(feature)
304 |             }
305 |             this.geojson = geojson
306 | 
307 |             if(this._addDataAfterLoad) this.addDBFDataToGeoJSON(this._addDataAfterLoad);
308 |         },
309 |         addDBFDataToGeoJSON: function(dbfData){
310 |             if(!this.geojson) return (this._addDataAfterLoad = dbfData)
311 | 
312 |             this.dbf = dbfData
313 | 
314 |             var features = this.geojson.features,
315 |                 len = features.length,
316 |                 records = dbfData.records
317 | 
318 |             while(len--) features[len].properties = records[len]
319 |         }
320 |     }
321 | 
322 |     window["Shapefile"] = Shapefile;
323 | })(self)
324 | 
325 | 


--------------------------------------------------------------------------------
/tests/js-shapefile-to-geojson/stream.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |     Stream Reader from Gordon.JS
  3 |     Copyright (c) 2010 Tobias Schneider
  4 | 
  5 |     Permission is hereby granted, free of charge, to any person obtaining a copy
  6 |     of this software and associated documentation files (the "Software"), to deal
  7 |     in the Software without restriction, including without limitation the rights
  8 |     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 |     copies of the Software, and to permit persons to whom the Software is
 10 |     furnished to do so, subject to the following conditions:
 11 | 
 12 |     The above copyright notice and this permission notice shall be included in
 13 |     all copies or substantial portions of the Software.
 14 | 
 15 |     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 |     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 |     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 |     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 |     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 |     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 21 |     THE SOFTWARE.
 22 | */
 23 | 
 24 | var win = self,
 25 |     doc = win.document,
 26 |     fromCharCode = String.fromCharCode,
 27 |     push = Array.prototype.push,
 28 |     min = Math.min,
 29 |     max = Math.max;
 30 | 
 31 | (function(window,undefined){
 32 | 
 33 |     window.Gordon = {};
 34 | 
 35 |     var DEFLATE_CODE_LENGTH_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
 36 |         DEFLATE_CODE_LENGHT_MAP = [
 37 |             [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [0, 8], [0, 9], [0, 10], [1, 11], [1, 13], [1, 15], [1, 17],
 38 |             [2, 19], [2, 23], [2, 27], [2, 31], [3, 35], [3, 43], [3, 51], [3, 59], [4, 67], [4, 83], [4, 99],
 39 |             [4, 115], [5, 131], [5, 163], [5, 195], [5, 227], [0, 258]
 40 |         ],
 41 |         DEFLATE_DISTANCE_MAP = [
 42 |             [0, 1], [0, 2], [0, 3], [0, 4], [1, 5], [1, 7], [2, 9], [2, 13], [3, 17], [3, 25], [4, 33], [4, 49],
 43 |             [5, 65], [5, 97], [6, 129], [6, 193], [7, 257], [7, 385], [8, 513], [8, 769], [9, 1025], [9, 1537],
 44 |             [10, 2049], [10, 3073], [11, 4097], [11, 6145], [12, 8193], [12, 12289], [13, 16385], [13, 24577]
 45 |         ];
 46 | 
 47 |     Gordon.Stream = function(data){
 48 |         var buff = [],
 49 |             t = this,
 50 |             i = t.length = data.length;
 51 |         t.offset = 0;
 52 |         for(var i = 0; data[i]; i++){ buff.push(fromCharCode(data.charCodeAt(i) & 0xff)); }
 53 |         t._buffer = buff.join('');
 54 |         t._bitBuffer = null;
 55 |         t._bitOffset = 8;
 56 |     };
 57 |     Gordon.Stream.prototype = {
 58 |         readByteAt: function(pos){
 59 |             return this._buffer.charCodeAt(pos);
 60 |         },
 61 | 
 62 |         readNumber: function(numBytes, bigEnd){
 63 |             var t = this,
 64 |                 val = 0;
 65 |             if(bigEnd){
 66 |                 while(numBytes--){ val = (val << 8) | t.readByteAt(t.offset++); }
 67 |             }else{
 68 |                 var o = t.offset,
 69 |                     i = o + numBytes;
 70 |                 while(i > o){ val = (val << 8) | t.readByteAt(--i); }
 71 |                 t.offset += numBytes;
 72 |             }
 73 |             t.align();
 74 |             return val;
 75 |         },
 76 | 
 77 |         readSNumber: function(numBytes, bigEnd){
 78 |             var val = this.readNumber(numBytes, bigEnd),
 79 |                 numBits = numBytes * 8;
 80 |             if(val >> (numBits - 1)){ val -= Math.pow(2, numBits); }
 81 |             return val;
 82 |         },
 83 | 
 84 |         readSI8: function(){
 85 |             return this.readSNumber(1);
 86 |         },
 87 | 
 88 |         readSI16: function(bigEnd){
 89 |             return this.readSNumber(2, bigEnd);
 90 |         },
 91 | 
 92 |         readSI32: function(bigEnd){
 93 |             return this.readSNumber(4, bigEnd);
 94 |         },
 95 | 
 96 |         readUI8: function(){
 97 |             return this.readNumber(1);
 98 |         },
 99 | 
100 |         readUI16: function(bigEnd){
101 |             return this.readNumber(2, bigEnd);
102 |         },
103 | 
104 |         readUI24: function(bigEnd){
105 |             return this.readNumber(3, bigEnd);
106 |         },
107 | 
108 |         readUI32: function(bigEnd){
109 |             return this.readNumber(4, bigEnd);
110 |         },
111 | 
112 |         readFixed: function(){
113 |             return this._readFixedPoint(32, 16);
114 |         },
115 | 
116 |         _readFixedPoint: function(numBits, precision){
117 |             return this.readSB(numBits) * Math.pow(2, -precision);
118 |         },
119 | 
120 |         readFixed8: function(){
121 |             return this._readFixedPoint(16, 8);
122 |         },
123 | 
124 |         readFloat: function(){
125 |             return this._readFloatingPoint(8, 23);
126 |         },
127 | 
128 |         _readFloatingPoint: function(numEBits, numSBits){
129 |             var numBits = 1 + numEBits + numSBits,
130 |                 numBytes = numBits / 8,
131 |                 t = this,
132 |                 val = 0.0;
133 |             if(numBytes > 4){
134 |                 var i = Math.ceil(numBytes / 4);
135 |                 while(i--){
136 |                     var buff = [],
137 |                         o = t.offset,
138 |                         j = o + (numBytes >= 4 ? 4 : numBytes % 4);
139 |                     while(j > o){
140 |                         buff.push(t.readByteAt(--j));
141 |                         numBytes--;
142 |                         t.offset++;
143 |                     }
144 |                 }
145 |                 var s = new Gordon.Stream(fromCharCode.apply(String, buff)),
146 |                     sign = s.readUB(1),
147 |                     expo = s.readUB(numEBits),
148 |                     mantis = 0,
149 |                     i = numSBits;
150 |                 while(i--){
151 |                     if(s.readBool()){ mantis += Math.pow(2, i); }
152 |                 }
153 |             }else{
154 |                 var sign = t.readUB(1),
155 |                     expo = t.readUB(numEBits),
156 |                     mantis = t.readUB(numSBits);
157 |             }
158 |             if(sign || expo || mantis){
159 |                 var maxExpo = Math.pow(2, numEBits),
160 |                     bias = ~~((maxExpo - 1) / 2),
161 |                     scale = Math.pow(2, numSBits),
162 |                     fract = mantis / scale;
163 |                 if(bias){
164 |                     if(bias < maxExpo){ val = Math.pow(2, expo - bias) * (1 + fract); }
165 |                     else if(fract){ val = NaN; }
166 |                     else{ val = Infinity; }
167 |                 }else if(fract){ val = Math.pow(2, 1 - bias) * fract; }
168 |                 if(NaN != val && sign){ val *= -1; }
169 |             }
170 |             return val;
171 |         },
172 | 
173 |         readFloat16: function(){
174 |             return this._readFloatingPoint(5, 10);
175 |         },
176 | 
177 |         readDouble: function(){
178 |             return this._readFloatingPoint(11, 52);
179 |         },
180 | 
181 |         readEncodedU32: function(){
182 |             var val = 0;
183 |             for(var i = 0; i < 5; i++){
184 |                 var num = this.readByteAt(this._offset++);
185 |                 val = val | ((num & 0x7f) << (7 * i));
186 |                 if(!(num & 0x80)){ break; }
187 |             }
188 |             return val;
189 |         },
190 | 
191 |         readSB: function(numBits){
192 |             var val = this.readUB(numBits);
193 |             if(val >> (numBits - 1)){ val -= Math.pow(2, numBits); }
194 |             return val;
195 |         },
196 | 
197 |         readUB: function(numBits, lsb){
198 |             var t = this,
199 |                 val = 0;
200 |             for(var i = 0; i < numBits; i++){
201 |                 if(8 == t._bitOffset){
202 |                     t._bitBuffer = t.readUI8();
203 |                     t._bitOffset = 0;
204 |                 }
205 |                 if(lsb){ val |= (t._bitBuffer & (0x01 << t._bitOffset++) ? 1 : 0) << i; }
206 |                 else{ val = (val << 1) | (t._bitBuffer & (0x80 >> t._bitOffset++) ? 1 : 0); }
207 |             }
208 |             return val;
209 |         },
210 | 
211 |         readFB: function(numBits){
212 |             return this._readFixedPoint(numBits, 16);
213 |         },
214 | 
215 |         readString: function(numChars){
216 |             var t = this,
217 |                 b = t._buffer;
218 |             if(undefined != numChars){
219 |                 var str = b.substr(t.offset, numChars);
220 |                 t.offset += numChars;
221 |             }else{
222 |                 var chars = [],
223 |                     i = t.length - t.offset;
224 |                 while(i--){
225 |                     var code = t.readByteAt(t.offset++);
226 |                     if(code){ chars.push(fromCharCode(code)); }
227 |                     else{ break; }
228 |                 }
229 |                 var str = chars.join('');
230 |             }
231 |             return str;
232 |         },
233 | 
234 |         readBool: function(numBits){
235 |             return !!this.readUB(numBits || 1);
236 |         },
237 | 
238 |         seek: function(offset, absolute){
239 |             var t = this;
240 |             t.offset = (absolute ? 0 : t.offset) + offset;
241 |             t.align();
242 |             return t;
243 |         },
244 | 
245 |         align: function(){
246 |             this._bitBuffer = null;
247 |             this._bitOffset = 8;
248 |             return this;
249 |         },
250 | 
251 |         readLanguageCode: function(){
252 |             return this.readUI8();
253 |         },
254 | 
255 |         readRGB: function(){
256 |             return {
257 |                 red: this.readUI8(),
258 |                 green: this.readUI8(),
259 |                 blue: this.readUI8()
260 |             }
261 |         },
262 | 
263 |         readRGBA: function(){
264 |             var rgba = this.readRGB();
265 |             rgba.alpha = this.readUI8() / 255;
266 |             return rgba;
267 |         },
268 | 
269 |         readARGB: function(){
270 |             var alpha = this.readUI8() / 255,
271 |                 rgba = this.readRGB();
272 |             rgba.alpha = alpha;
273 |             return rgba;
274 |         },
275 | 
276 |         readRect: function(){
277 |             var t = this;
278 |                 numBits = t.readUB(5),
279 |                 rect = {
280 |                     left: t.readSB(numBits),
281 |                     right: t.readSB(numBits),
282 |                     top: t.readSB(numBits),
283 |                     bottom: t.readSB(numBits)
284 |                 };
285 |             t.align();
286 |             return rect;
287 |         },
288 | 
289 |         readMatrix: function(){
290 |             var t = this,
291 |                 hasScale = t.readBool();
292 |             if(hasScale){
293 |                 var numBits = t.readUB(5),
294 |                     scaleX = t.readFB(numBits),
295 |                     scaleY = t.readFB(numBits);
296 |             }else{ var scaleX = scaleY = 1.0; }
297 |             var hasRotation = t.readBool();
298 |             if(hasRotation){
299 |                 var numBits = t.readUB(5),
300 |                     skewX = t.readFB(numBits),
301 |                     skewY = t.readFB(numBits);
302 |             }else{ var skewX =  skewY = 0.0; }
303 |             var numBits = t.readUB(5);
304 |                 matrix = {
305 |                     scaleX: scaleX, scaleY: scaleY,
306 |                     skewX: skewX, skewY: skewY,
307 |                     moveX: t.readSB(numBits), moveY: t.readSB(numBits)
308 |                 };
309 |             t.align();
310 |             return matrix;
311 |         },
312 | 
313 |         readCxform: function(){
314 |             return this._readCxf();
315 |         },
316 | 
317 |         readCxformA: function(){
318 |             return this._readCxf(true);
319 |         },
320 | 
321 |         _readCxf: function(withAlpha){
322 |             var t = this;
323 |                 hasAddTerms = t.readBool(),
324 |                 hasMultTerms = t.readBool(),
325 |                 numBits = t.readUB(4);
326 |             if(hasMultTerms){
327 |                 var multR = t.readSB(numBits) / 256,
328 |                     multG = t.readSB(numBits) / 256,
329 |                     multB = t.readSB(numBits) / 256,
330 |                     multA = withAlpha ? t.readSB(numBits) / 256 : 1;
331 |             }else{ var multR = multG = multB = multA = 1; }
332 |             if(hasAddTerms){
333 |                 var addR = t.readSB(numBits),
334 |                     addG = t.readSB(numBits),
335 |                     addB = t.readSB(numBits),
336 |                     addA = withAlpha ? t.readSB(numBits) / 256 : 0;
337 |             }else{ var addR = addG = addB = addA = 0; }
338 |             var cxform = {
339 |                 multR: multR, multG: multG, multB: multB, multA: multA,
340 |                 addR: addR, addG: addG, addB: addB, addA: addA
341 |             }
342 |             t.align();
343 |             return cxform;
344 |         },
345 | 
346 |         decompress: function(){
347 |             var t = this,
348 |                 b = t._buffer,
349 |                 o = t.offset,
350 |                 data = b.substr(0, o) + t.unzip();
351 |             t.length = data.length;
352 |             t.offset = o;
353 |             t._buffer = data;
354 |             return t;
355 |         },
356 | 
357 |         unzip: function uz(raw){
358 |             var t = this,
359 |                 buff = [],
360 |                 o = DEFLATE_CODE_LENGTH_ORDER,
361 |                 m = DEFLATE_CODE_LENGHT_MAP,
362 |                 d = DEFLATE_DISTANCE_MAP;
363 |             t.seek(2);
364 |             do{
365 |                 var isFinal = t.readUB(1, true),
366 |                     type = t.readUB(2, true);
367 |                 if(type){
368 |                     if(1 == type){
369 |                         var distTable = uz.fixedDistTable,
370 |                             litTable = uz.fixedLitTable;
371 |                         if(!distTable){
372 |                             var bitLengths = [];
373 |                             for(var i = 0; i < 32; i++){ bitLengths.push(5); }
374 |                             distTable = uz.fixedDistTable = buildHuffTable(bitLengths);
375 |                         }
376 |                         if(!litTable){
377 |                             var bitLengths = [];
378 |                             for(var i = 0; i <= 143; i++){ bitLengths.push(8); }
379 |                             for(; i <= 255; i++){ bitLengths.push(9); }
380 |                             for(; i <= 279; i++){ bitLengths.push(7); }
381 |                             for(; i <= 287; i++){ bitLengths.push(8); }
382 |                             litTable = uz.fixedLitTable = buildHuffTable(bitLengths);
383 |                         }
384 |                     }else{
385 |                         var numLitLengths = t.readUB(5, true) + 257,
386 |                             numDistLengths = t.readUB(5, true) + 1,
387 |                             numCodeLenghts = t.readUB(4, true) + 4,
388 |                             codeLengths = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
389 |                         for(var i = 0; i < numCodeLenghts; i++){ codeLengths[o[i]] = t.readUB(3, true); }
390 |                         var codeTable = buildHuffTable(codeLengths),
391 |                             litLengths = [],
392 |                             prevCodeLen = 0,
393 |                             maxLengths = numLitLengths + numDistLengths;
394 |                         while(litLengths.length < maxLengths){
395 |                             var sym = decodeSymbol(t, codeTable);
396 |                             switch(sym){
397 |                                 case 16:
398 |                                     var i = t.readUB(2, true) + 3;
399 |                                     while(i--){ litLengths.push(prevCodeLen); }
400 |                                     break;
401 |                                 case 17:
402 |                                     var i = t.readUB(3, true) + 3;
403 |                                     while(i--){ litLengths.push(0); }
404 |                                     break;
405 |                                 case 18:
406 |                                     var i = t.readUB(7, true) + 11;
407 |                                     while(i--){ litLengths.push(0); }
408 |                                     break;
409 |                                 default:
410 |                                     if(sym <= 15){
411 |                                         litLengths.push(sym);
412 |                                         prevCodeLen = sym;
413 |                                     }
414 |                             }
415 |                         }
416 |                         var distTable = buildHuffTable(litLengths.splice(numLitLengths, numDistLengths)),
417 |                             litTable = buildHuffTable(litLengths);
418 |                     }
419 |                     do{
420 |                         var sym = decodeSymbol(t, litTable);
421 |                         if(sym < 256){ buff.push(raw ? sym : fromCharCode(sym)); }
422 |                         else if(sym > 256){
423 |                             var lengthMap = m[sym - 257],
424 |                                 len = lengthMap[1] + t.readUB(lengthMap[0], true),
425 |                                 distMap = d[decodeSymbol(t, distTable)],
426 |                                 dist = distMap[1] + t.readUB(distMap[0], true),
427 |                                 i = buff.length - dist;
428 |                             while(len--){ buff.push(buff[i++]); }
429 |                         }
430 |                     }while(256 != sym);
431 |                 }else{
432 |                     t.align();
433 |                     var len = t.readUI16(),
434 |                         nlen = t.readUI16();
435 |                     if(raw){ while(len--){ buff.push(t.readUI8()); } }
436 |                     else{ buff.push(t.readString(len)); }
437 |                 }
438 |             }while(!isFinal);
439 |             t.seek(4);
440 |             return raw ? buff : buff.join('');
441 |         }
442 |     };
443 | 
444 |     function buildHuffTable(bitLengths){
445 |         var numLengths = bitLengths.length,
446 |             blCount = [],
447 |             maxBits = max.apply(Math, bitLengths),
448 |             nextCode = [],
449 |             code = 0,
450 |             table = {},
451 |             i = numLengths;
452 |         while(i--){
453 |             var len = bitLengths[i];
454 |             blCount[len] = (blCount[len] || 0) + (len > 0);
455 |         }
456 |         for(var i = 1; i <= maxBits; i++){
457 |             var len = i - 1;
458 |             if(undefined == blCount[len]){ blCount[len] = 0; }
459 |             code = (code + blCount[i - 1]) << 1;
460 |             nextCode[i] = code;
461 |         }
462 |         for(var i = 0; i < numLengths; i++){
463 |             var len = bitLengths[i];
464 |             if(len){
465 |                 table[nextCode[len]] = {
466 |                     length: len,
467 |                     symbol: i
468 |                 };
469 |                 nextCode[len]++;
470 |             }
471 |         }
472 |         return table;
473 |     }
474 | 
475 |     function decodeSymbol(s, table) {
476 |         var code = 0,
477 |             len = 0;
478 |         while(true){
479 |             code = (code << 1) | s.readUB(1, true);
480 |             len++;
481 |             var entry = table[code];
482 |             if(undefined != entry && entry.length == len){ return entry.symbol }
483 |         }
484 |     }
485 | })(this);
486 | 
487 | 


--------------------------------------------------------------------------------
/tests/js-shapefile-to-geojson/testdata/world.dbf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/simogeo/geostats/be8159073de1863bc4b52b05de3f63b2fc326ab6/tests/js-shapefile-to-geojson/testdata/world.dbf


--------------------------------------------------------------------------------
/tests/js-shapefile-to-geojson/testdata/world.shp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/simogeo/geostats/be8159073de1863bc4b52b05de3f63b2fc326ab6/tests/js-shapefile-to-geojson/testdata/world.shp


--------------------------------------------------------------------------------
/tests/openlayers_sample.js:
--------------------------------------------------------------------------------
  1 | // get user defined class
  2 | // if equals value
  3 | // handle both numeric and string (unique values classification)
  4 | function getClass(val, a) {
  5 | 	
  6 | 	var separator = ' - '
  7 | 	
  8 | 	// return 2;
  9 |     for(var i= 0; i < a.length; i++) {
 10 | 	    // all classification except uniqueValues
 11 | 		if(a[i].indexOf(separator) != -1) {
 12 | 			var item = a[i].split(separator);
 13 | 			if(val <= parseFloat(item[1])) {return i;}
 14 | 		} else {
 15 | 			// uniqueValues classification
 16 | 			if(val == a[i]) {
 17 | 				return i;
 18 | 			}
 19 | 		}
 20 |     }
 21 | }
 22 | 
 23 | // Function called from body tag
 24 | function init(color_x, class_x) {
 25 | 
 26 |     var lon = 6.3;
 27 |     var lat = 48.73;
 28 |     var zoom = 4;
 29 | 
 30 |     OpenLayers.ImgPath = "http://js.mapbox.com/theme/dark/";
 31 |     
 32 |     var context_x = {
 33 |         getColour: function(feature) {
 34 |     	color = color_x;
 35 |     	return color[getClass(feature.attributes["Pop_2006"], class_x)];
 36 |         }
 37 |     };    
 38 | 
 39 |     var template = {
 40 | 		fillOpacity: 0.9,
 41 |         strokeColor: "#ffffff",
 42 |         strokeWidth: 1,
 43 |         fillColor: "${getColour}"
 44 |     };
 45 | 
 46 |     // Style
 47 |     var style_x = new OpenLayers.Style(template, {context: context_x});
 48 |     var styleMap_x = new OpenLayers.StyleMap({'default': style_x});
 49 |     
 50 |     // options de la carte
 51 | 	var options = {
 52 | 		scales: [10000000, 5000000, 2500000, 1000000, 500000, 250000],
 53 |         controls: [],  // Remove all controls
 54 |         // allOverlays: true
 55 |     };
 56 | 
 57 |     // Create a new map with options defined above
 58 |     map = new OpenLayers.Map( 'map', options );
 59 |     
 60 | 
 61 |     // Create polygon layer as vector features
 62 |     // http://dev.openlayers.org/docs/files/OpenLayers/Layer/Vector-js.html
 63 | 
 64 |     layer_x = new OpenLayers.Layer.GML("choropleth", "tests/test.json",
 65 |                 { format: OpenLayers.Format.GeoJSON,
 66 |     			styleMap: styleMap_x,
 67 | 	            isBaseLayer: true,
 68 | 	            projection: new OpenLayers.Projection("EPSG:4326")
 69 | 	           });
 70 | 
 71 |     map.addLayers([layer_x]);
 72 |     map.setCenter(new OpenLayers.LonLat(lon, lat), zoom);
 73 |     
 74 |     // Add map controls:
 75 | 	// http://dev.openlayers.org/docs/files/OpenLayers/Control-js.html
 76 |     map.addControl(new OpenLayers.Control.MousePosition());
 77 |     map.addControl(new OpenLayers.Control.Navigation());
 78 |     map.addControl(new OpenLayers.Control.PanZoomBar());
 79 |     map.addControl(new OpenLayers.Control.ScaleLine({geodesic: true, maxWidth: 200, bottomOutUnits: "", bottomInUnits: ""}));
 80 | 
 81 | }
 82 | 
 83 | //Function called from body tag
 84 | function initChromaSample(color_x, class_x) {
 85 | 
 86 |     var lon = 6.3;
 87 |     var lat = 48.73;
 88 |     var zoom = 4;
 89 | 
 90 |     OpenLayers.ImgPath = "http://js.mapbox.com/theme/dark/";
 91 |     
 92 |     var context_x = {
 93 |         getColour: function(feature) {
 94 |     	color = color_x;
 95 |     	return color[getClass(feature.attributes["Pop_2006"], class_x)];
 96 |         }
 97 |     };    
 98 | 
 99 |     var template = {
100 | 		fillOpacity: 0.9,
101 |         strokeColor: "#ffffff",
102 |         strokeWidth: 1,
103 |         fillColor: "${getColour}"
104 |     };
105 | 
106 |     // Style
107 |     var style_x = new OpenLayers.Style(template, {context: context_x});
108 |     var styleMap_x = new OpenLayers.StyleMap({'default': style_x});
109 |     
110 |     // options de la carte
111 | 	var options = {
112 | 		scales: [10000000, 5000000, 2500000, 1000000, 500000, 250000],
113 |         controls: [],  // Remove all controls
114 |         // allOverlays: true
115 |     };
116 | 
117 |     // Create a new map with options defined above
118 |     map = new OpenLayers.Map( 'map3', options );
119 |     
120 | 
121 |     // Create polygon layer as vector features
122 |     // http://dev.openlayers.org/docs/files/OpenLayers/Layer/Vector-js.html
123 | 
124 |     layer_x = new OpenLayers.Layer.GML("choropleth", "tests/test.json",
125 |                 { format: OpenLayers.Format.GeoJSON,
126 |     			styleMap: styleMap_x,
127 | 	            isBaseLayer: true,
128 | 	            projection: new OpenLayers.Projection("EPSG:4326")
129 | 	           });
130 | 
131 |     map.addLayers([layer_x]);
132 |     map.setCenter(new OpenLayers.LonLat(lon, lat), zoom);
133 |     
134 |     // Add map controls:
135 | 	// http://dev.openlayers.org/docs/files/OpenLayers/Control-js.html
136 |     map.addControl(new OpenLayers.Control.MousePosition());
137 |     map.addControl(new OpenLayers.Control.Navigation());
138 |     map.addControl(new OpenLayers.Control.PanZoomBar());
139 |     map.addControl(new OpenLayers.Control.ScaleLine({geodesic: true, maxWidth: 200, bottomOutUnits: "", bottomInUnits: ""}));
140 | 
141 | }
142 | 
143 | //Function called from body tag
144 | function initUniqueValues(color_x, class_x) {
145 | 
146 |     var lon = 6.3;
147 |     var lat = 48.73;
148 |     var zoom = 4;
149 | 
150 |     OpenLayers.ImgPath = "http://js.mapbox.com/theme/dark/";
151 |     
152 |     var context_x = {
153 |         getColour: function(feature) {
154 |     	color = color_x;
155 |     	return color[getClass(feature.attributes["value"], class_x)];
156 |         }
157 |     };    
158 | 
159 |     var template = {
160 | 		fillOpacity: 0.9,
161 |         strokeColor: "#ffffff",
162 |         strokeWidth: 1,
163 |         fillColor: "${getColour}"
164 |     };
165 | 
166 |     // Style
167 |     var style_x = new OpenLayers.Style(template, {context: context_x});
168 |     var styleMap_x = new OpenLayers.StyleMap({'default': style_x});
169 |     
170 |     // options de la carte
171 | 	var options = {
172 | 		scales: [10000000, 5000000, 2500000, 1000000, 500000, 250000],
173 |         controls: [],  // Remove all controls
174 |         // allOverlays: true
175 |     };
176 | 
177 |     // Create a new map with options defined above
178 |     map2 = new OpenLayers.Map( 'map2', options );
179 |     
180 | 
181 |     // Create polygon layer as vector features
182 |     // http://dev.openlayers.org/docs/files/OpenLayers/Layer/Vector-js.html
183 | 
184 |     layer_x = new OpenLayers.Layer.GML("choropleth", "tests/test.json",
185 |                 { format: OpenLayers.Format.GeoJSON,
186 |     			styleMap: styleMap_x,
187 | 	            isBaseLayer: true,
188 | 	            projection: new OpenLayers.Projection("EPSG:4326")
189 | 	           });
190 | 
191 |     map2.addLayers([layer_x]);
192 |     map2.setCenter(new OpenLayers.LonLat(lon, lat), zoom);
193 |     
194 |     // Add map controls:
195 | 	// http://dev.openlayers.org/docs/files/OpenLayers/Control-js.html
196 |     map2.addControl(new OpenLayers.Control.MousePosition());
197 |     map2.addControl(new OpenLayers.Control.Navigation());
198 |     map2.addControl(new OpenLayers.Control.PanZoomBar());
199 |     map2.addControl(new OpenLayers.Control.ScaleLine({geodesic: true, maxWidth: 200, bottomOutUnits: "", bottomInUnits: ""}));
200 | 
201 | }


--------------------------------------------------------------------------------
/tests/qunit_test.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>QUnit for geostats</title>
 6 |   <link rel="stylesheet" href="http://code.jquery.com/qunit/qunit-1.10.0.css">
 7 |   <link rel="stylesheet" href="../lib/geostats.css">
 8 | 
 9 |   <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js"></script>
10 |   <script src="http://code.jquery.com/qunit/qunit-1.10.0.js"></script>
11 |   <script src="../lib/jenks.util.js"></script>
12 |   <script src="../lib/geostats.js"></script>
13 | </head>
14 | <body>
15 |   <div id="qunit"></div>
16 |   <script>
17 |   $(document).ready(function() {
18 | 
19 |     module("geostats");
20 |   
21 |     // test for fixing getJenks bug
22 |     test("geostats: getJenks", function() {
23 |       var values = [30.3, 35.1, 54.4, 45.9, 40.3, 34.4, 45, 38.2]
24 |         , classifier = new geostats(values)
25 |         , jenksResult = classifier.getJenks(5);
26 | 
27 |       console.log(jenksResult);
28 |       // [30.3, 35.1, 40.3, 54.4, undefined, 54.4]
29 |       $.each(jenksResult, function(index, value) { 
30 |         notEqual(typeof value, 'undefined'); 
31 |       });
32 |     });
33 | 
34 |   });
35 |   </script>
36 | </body>
37 | </html>


--------------------------------------------------------------------------------