Add vectortile branch
This commit is contained in:
Andreas Hocevar
@@ -0,0 +1,692 @@
|
||||
goog.provide('ol.ext.pbf');
|
||||
/** @typedef {function(*)} */
|
||||
ol.ext.pbf;
|
||||
(function() {
|
||||
var exports = {};
|
||||
var module = {exports: exports};
|
||||
var define;
|
||||
/**
|
||||
* @fileoverview
|
||||
* @suppress {accessControls, ambiguousFunctionDecl, checkDebuggerStatement, checkRegExp, checkTypes, checkVars, const, constantProperty, deprecated, duplicate, es5Strict, fileoverviewTags, missingProperties, nonStandardJsDocs, strictModuleDepCheck, suspiciousCode, undefinedNames, undefinedVars, unknownDefines, uselessCode, visibility}
|
||||
*/
|
||||
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.pbf = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
||||
'use strict';
|
||||
|
||||
// lightweight Buffer shim for pbf browser build
|
||||
// based on code from github.com/feross/buffer (MIT-licensed)
|
||||
|
||||
module.exports = Buffer;
|
||||
|
||||
var ieee754 = require('ieee754');
|
||||
|
||||
var BufferMethods;
|
||||
|
||||
function Buffer(length) {
|
||||
var arr;
|
||||
if (length && length.length) {
|
||||
arr = length;
|
||||
length = arr.length;
|
||||
}
|
||||
var buf = new Uint8Array(length || 0);
|
||||
if (arr) buf.set(arr);
|
||||
|
||||
buf.readUInt32LE = BufferMethods.readUInt32LE;
|
||||
buf.writeUInt32LE = BufferMethods.writeUInt32LE;
|
||||
buf.readInt32LE = BufferMethods.readInt32LE;
|
||||
buf.writeInt32LE = BufferMethods.writeInt32LE;
|
||||
buf.readFloatLE = BufferMethods.readFloatLE;
|
||||
buf.writeFloatLE = BufferMethods.writeFloatLE;
|
||||
buf.readDoubleLE = BufferMethods.readDoubleLE;
|
||||
buf.writeDoubleLE = BufferMethods.writeDoubleLE;
|
||||
buf.toString = BufferMethods.toString;
|
||||
buf.write = BufferMethods.write;
|
||||
buf.slice = BufferMethods.slice;
|
||||
buf.copy = BufferMethods.copy;
|
||||
|
||||
buf._isBuffer = true;
|
||||
return buf;
|
||||
}
|
||||
|
||||
var lastStr, lastStrEncoded;
|
||||
|
||||
BufferMethods = {
|
||||
readUInt32LE: function(pos) {
|
||||
return ((this[pos]) |
|
||||
(this[pos + 1] << 8) |
|
||||
(this[pos + 2] << 16)) +
|
||||
(this[pos + 3] * 0x1000000);
|
||||
},
|
||||
|
||||
writeUInt32LE: function(val, pos) {
|
||||
this[pos] = val;
|
||||
this[pos + 1] = (val >>> 8);
|
||||
this[pos + 2] = (val >>> 16);
|
||||
this[pos + 3] = (val >>> 24);
|
||||
},
|
||||
|
||||
readInt32LE: function(pos) {
|
||||
return ((this[pos]) |
|
||||
(this[pos + 1] << 8) |
|
||||
(this[pos + 2] << 16)) +
|
||||
(this[pos + 3] << 24);
|
||||
},
|
||||
|
||||
readFloatLE: function(pos) { return ieee754.read(this, pos, true, 23, 4); },
|
||||
readDoubleLE: function(pos) { return ieee754.read(this, pos, true, 52, 8); },
|
||||
|
||||
writeFloatLE: function(val, pos) { return ieee754.write(this, val, pos, true, 23, 4); },
|
||||
writeDoubleLE: function(val, pos) { return ieee754.write(this, val, pos, true, 52, 8); },
|
||||
|
||||
toString: function(encoding, start, end) {
|
||||
var str = '',
|
||||
tmp = '';
|
||||
|
||||
start = start || 0;
|
||||
end = Math.min(this.length, end || this.length);
|
||||
|
||||
for (var i = start; i < end; i++) {
|
||||
var ch = this[i];
|
||||
if (ch <= 0x7F) {
|
||||
str += decodeURIComponent(tmp) + String.fromCharCode(ch);
|
||||
tmp = '';
|
||||
} else {
|
||||
tmp += '%' + ch.toString(16);
|
||||
}
|
||||
}
|
||||
|
||||
str += decodeURIComponent(tmp);
|
||||
|
||||
return str;
|
||||
},
|
||||
|
||||
write: function(str, pos) {
|
||||
var bytes = str === lastStr ? lastStrEncoded : encodeString(str);
|
||||
for (var i = 0; i < bytes.length; i++) {
|
||||
this[pos + i] = bytes[i];
|
||||
}
|
||||
},
|
||||
|
||||
slice: function(start, end) {
|
||||
return this.subarray(start, end);
|
||||
},
|
||||
|
||||
copy: function(buf, pos) {
|
||||
pos = pos || 0;
|
||||
for (var i = 0; i < this.length; i++) {
|
||||
buf[pos + i] = this[i];
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
BufferMethods.writeInt32LE = BufferMethods.writeUInt32LE;
|
||||
|
||||
Buffer.byteLength = function(str) {
|
||||
lastStr = str;
|
||||
lastStrEncoded = encodeString(str);
|
||||
return lastStrEncoded.length;
|
||||
};
|
||||
|
||||
Buffer.isBuffer = function(buf) {
|
||||
return !!(buf && buf._isBuffer);
|
||||
};
|
||||
|
||||
function encodeString(str) {
|
||||
var length = str.length,
|
||||
bytes = [];
|
||||
|
||||
for (var i = 0, c, lead; i < length; i++) {
|
||||
c = str.charCodeAt(i); // code point
|
||||
|
||||
if (c > 0xD7FF && c < 0xE000) {
|
||||
|
||||
if (lead) {
|
||||
if (c < 0xDC00) {
|
||||
bytes.push(0xEF, 0xBF, 0xBD);
|
||||
lead = c;
|
||||
continue;
|
||||
|
||||
} else {
|
||||
c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000;
|
||||
lead = null;
|
||||
}
|
||||
|
||||
} else {
|
||||
if (c > 0xDBFF || (i + 1 === length)) bytes.push(0xEF, 0xBF, 0xBD);
|
||||
else lead = c;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
} else if (lead) {
|
||||
bytes.push(0xEF, 0xBF, 0xBD);
|
||||
lead = null;
|
||||
}
|
||||
|
||||
if (c < 0x80) bytes.push(c);
|
||||
else if (c < 0x800) bytes.push(c >> 0x6 | 0xC0, c & 0x3F | 0x80);
|
||||
else if (c < 0x10000) bytes.push(c >> 0xC | 0xE0, c >> 0x6 & 0x3F | 0x80, c & 0x3F | 0x80);
|
||||
else bytes.push(c >> 0x12 | 0xF0, c >> 0xC & 0x3F | 0x80, c >> 0x6 & 0x3F | 0x80, c & 0x3F | 0x80);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
|
||||
},{"ieee754":3}],2:[function(require,module,exports){
|
||||
(function (global){
|
||||
'use strict';
|
||||
|
||||
module.exports = Pbf;
|
||||
|
||||
var Buffer = global.Buffer || require('./buffer');
|
||||
|
||||
function Pbf(buf) {
|
||||
this.buf = !Buffer.isBuffer(buf) ? new Buffer(buf || 0) : buf;
|
||||
this.pos = 0;
|
||||
this.length = this.buf.length;
|
||||
}
|
||||
|
||||
Pbf.Varint = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum
|
||||
Pbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64
|
||||
Pbf.Bytes = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields
|
||||
Pbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32
|
||||
|
||||
var SHIFT_LEFT_32 = (1 << 16) * (1 << 16),
|
||||
SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32,
|
||||
POW_2_63 = Math.pow(2, 63);
|
||||
|
||||
Pbf.prototype = {
|
||||
|
||||
destroy: function() {
|
||||
this.buf = null;
|
||||
},
|
||||
|
||||
// === READING =================================================================
|
||||
|
||||
readFields: function(readField, result, end) {
|
||||
end = end || this.length;
|
||||
|
||||
while (this.pos < end) {
|
||||
var val = this.readVarint(),
|
||||
tag = val >> 3,
|
||||
startPos = this.pos;
|
||||
|
||||
readField(tag, result, this);
|
||||
|
||||
if (this.pos === startPos) this.skip(val);
|
||||
}
|
||||
return result;
|
||||
},
|
||||
|
||||
readMessage: function(readField, result) {
|
||||
return this.readFields(readField, result, this.readVarint() + this.pos);
|
||||
},
|
||||
|
||||
readFixed32: function() {
|
||||
var val = this.buf.readUInt32LE(this.pos);
|
||||
this.pos += 4;
|
||||
return val;
|
||||
},
|
||||
|
||||
readSFixed32: function() {
|
||||
var val = this.buf.readInt32LE(this.pos);
|
||||
this.pos += 4;
|
||||
return val;
|
||||
},
|
||||
|
||||
// 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)
|
||||
|
||||
readFixed64: function() {
|
||||
var val = this.buf.readUInt32LE(this.pos) + this.buf.readUInt32LE(this.pos + 4) * SHIFT_LEFT_32;
|
||||
this.pos += 8;
|
||||
return val;
|
||||
},
|
||||
|
||||
readSFixed64: function() {
|
||||
var val = this.buf.readUInt32LE(this.pos) + this.buf.readInt32LE(this.pos + 4) * SHIFT_LEFT_32;
|
||||
this.pos += 8;
|
||||
return val;
|
||||
},
|
||||
|
||||
readFloat: function() {
|
||||
var val = this.buf.readFloatLE(this.pos);
|
||||
this.pos += 4;
|
||||
return val;
|
||||
},
|
||||
|
||||
readDouble: function() {
|
||||
var val = this.buf.readDoubleLE(this.pos);
|
||||
this.pos += 8;
|
||||
return val;
|
||||
},
|
||||
|
||||
readVarint: function() {
|
||||
var buf = this.buf,
|
||||
val, b, b0, b1, b2, b3;
|
||||
|
||||
b0 = buf[this.pos++]; if (b0 < 0x80) return b0; b0 = b0 & 0x7f;
|
||||
b1 = buf[this.pos++]; if (b1 < 0x80) return b0 | b1 << 7; b1 = (b1 & 0x7f) << 7;
|
||||
b2 = buf[this.pos++]; if (b2 < 0x80) return b0 | b1 | b2 << 14; b2 = (b2 & 0x7f) << 14;
|
||||
b3 = buf[this.pos++]; if (b3 < 0x80) return b0 | b1 | b2 | b3 << 21;
|
||||
|
||||
val = b0 | b1 | b2 | (b3 & 0x7f) << 21;
|
||||
|
||||
b = buf[this.pos++]; val += (b & 0x7f) * 0x10000000; if (b < 0x80) return val;
|
||||
b = buf[this.pos++]; val += (b & 0x7f) * 0x800000000; if (b < 0x80) return val;
|
||||
b = buf[this.pos++]; val += (b & 0x7f) * 0x40000000000; if (b < 0x80) return val;
|
||||
b = buf[this.pos++]; val += (b & 0x7f) * 0x2000000000000; if (b < 0x80) return val;
|
||||
b = buf[this.pos++]; val += (b & 0x7f) * 0x100000000000000; if (b < 0x80) return val;
|
||||
b = buf[this.pos++]; val += (b & 0x7f) * 0x8000000000000000; if (b < 0x80) return val;
|
||||
|
||||
throw new Error('Expected varint not more than 10 bytes');
|
||||
},
|
||||
|
||||
readVarint64: function() {
|
||||
var startPos = this.pos,
|
||||
val = this.readVarint();
|
||||
|
||||
if (val < POW_2_63) return val;
|
||||
|
||||
var pos = this.pos - 2;
|
||||
while (this.buf[pos] === 0xff) pos--;
|
||||
if (pos < startPos) pos = startPos;
|
||||
|
||||
val = 0;
|
||||
for (var i = 0; i < pos - startPos + 1; i++) {
|
||||
var b = ~this.buf[startPos + i] & 0x7f;
|
||||
val += i < 4 ? b << i * 7 : b * Math.pow(2, i * 7);
|
||||
}
|
||||
|
||||
return -val - 1;
|
||||
},
|
||||
|
||||
readSVarint: function() {
|
||||
var num = this.readVarint();
|
||||
return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding
|
||||
},
|
||||
|
||||
readBoolean: function() {
|
||||
return Boolean(this.readVarint());
|
||||
},
|
||||
|
||||
readString: function() {
|
||||
var end = this.readVarint() + this.pos,
|
||||
str = this.buf.toString('utf8', this.pos, end);
|
||||
this.pos = end;
|
||||
return str;
|
||||
},
|
||||
|
||||
readBytes: function() {
|
||||
var end = this.readVarint() + this.pos,
|
||||
buffer = this.buf.slice(this.pos, end);
|
||||
this.pos = end;
|
||||
return buffer;
|
||||
},
|
||||
|
||||
// verbose for performance reasons; doesn't affect gzipped size
|
||||
|
||||
readPackedVarint: function() {
|
||||
var end = this.readVarint() + this.pos, arr = [];
|
||||
while (this.pos < end) arr.push(this.readVarint());
|
||||
return arr;
|
||||
},
|
||||
readPackedSVarint: function() {
|
||||
var end = this.readVarint() + this.pos, arr = [];
|
||||
while (this.pos < end) arr.push(this.readSVarint());
|
||||
return arr;
|
||||
},
|
||||
readPackedBoolean: function() {
|
||||
var end = this.readVarint() + this.pos, arr = [];
|
||||
while (this.pos < end) arr.push(this.readBoolean());
|
||||
return arr;
|
||||
},
|
||||
readPackedFloat: function() {
|
||||
var end = this.readVarint() + this.pos, arr = [];
|
||||
while (this.pos < end) arr.push(this.readFloat());
|
||||
return arr;
|
||||
},
|
||||
readPackedDouble: function() {
|
||||
var end = this.readVarint() + this.pos, arr = [];
|
||||
while (this.pos < end) arr.push(this.readDouble());
|
||||
return arr;
|
||||
},
|
||||
readPackedFixed32: function() {
|
||||
var end = this.readVarint() + this.pos, arr = [];
|
||||
while (this.pos < end) arr.push(this.readFixed32());
|
||||
return arr;
|
||||
},
|
||||
readPackedSFixed32: function() {
|
||||
var end = this.readVarint() + this.pos, arr = [];
|
||||
while (this.pos < end) arr.push(this.readSFixed32());
|
||||
return arr;
|
||||
},
|
||||
readPackedFixed64: function() {
|
||||
var end = this.readVarint() + this.pos, arr = [];
|
||||
while (this.pos < end) arr.push(this.readFixed64());
|
||||
return arr;
|
||||
},
|
||||
readPackedSFixed64: function() {
|
||||
var end = this.readVarint() + this.pos, arr = [];
|
||||
while (this.pos < end) arr.push(this.readSFixed64());
|
||||
return arr;
|
||||
},
|
||||
|
||||
skip: function(val) {
|
||||
var type = val & 0x7;
|
||||
if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {}
|
||||
else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;
|
||||
else if (type === Pbf.Fixed32) this.pos += 4;
|
||||
else if (type === Pbf.Fixed64) this.pos += 8;
|
||||
else throw new Error('Unimplemented type: ' + type);
|
||||
},
|
||||
|
||||
// === WRITING =================================================================
|
||||
|
||||
writeTag: function(tag, type) {
|
||||
this.writeVarint((tag << 3) | type);
|
||||
},
|
||||
|
||||
realloc: function(min) {
|
||||
var length = this.length || 16;
|
||||
|
||||
while (length < this.pos + min) length *= 2;
|
||||
|
||||
if (length !== this.length) {
|
||||
var buf = new Buffer(length);
|
||||
this.buf.copy(buf);
|
||||
this.buf = buf;
|
||||
this.length = length;
|
||||
}
|
||||
},
|
||||
|
||||
finish: function() {
|
||||
this.length = this.pos;
|
||||
this.pos = 0;
|
||||
return this.buf.slice(0, this.length);
|
||||
},
|
||||
|
||||
writeFixed32: function(val) {
|
||||
this.realloc(4);
|
||||
this.buf.writeUInt32LE(val, this.pos);
|
||||
this.pos += 4;
|
||||
},
|
||||
|
||||
writeSFixed32: function(val) {
|
||||
this.realloc(4);
|
||||
this.buf.writeInt32LE(val, this.pos);
|
||||
this.pos += 4;
|
||||
},
|
||||
|
||||
writeFixed64: function(val) {
|
||||
this.realloc(8);
|
||||
this.buf.writeInt32LE(val & -1, this.pos);
|
||||
this.buf.writeUInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
|
||||
this.pos += 8;
|
||||
},
|
||||
|
||||
writeSFixed64: function(val) {
|
||||
this.realloc(8);
|
||||
this.buf.writeInt32LE(val & -1, this.pos);
|
||||
this.buf.writeInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
|
||||
this.pos += 8;
|
||||
},
|
||||
|
||||
writeVarint: function(val) {
|
||||
val = +val;
|
||||
|
||||
if (val <= 0x7f) {
|
||||
this.realloc(1);
|
||||
this.buf[this.pos++] = val;
|
||||
|
||||
} else if (val <= 0x3fff) {
|
||||
this.realloc(2);
|
||||
this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;
|
||||
this.buf[this.pos++] = ((val >>> 7) & 0x7f);
|
||||
|
||||
} else if (val <= 0x1fffff) {
|
||||
this.realloc(3);
|
||||
this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;
|
||||
this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80;
|
||||
this.buf[this.pos++] = ((val >>> 14) & 0x7f);
|
||||
|
||||
} else if (val <= 0xfffffff) {
|
||||
this.realloc(4);
|
||||
this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;
|
||||
this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80;
|
||||
this.buf[this.pos++] = ((val >>> 14) & 0x7f) | 0x80;
|
||||
this.buf[this.pos++] = ((val >>> 21) & 0x7f);
|
||||
|
||||
} else {
|
||||
var pos = this.pos;
|
||||
while (val >= 0x80) {
|
||||
this.realloc(1);
|
||||
this.buf[this.pos++] = (val & 0xff) | 0x80;
|
||||
val /= 0x80;
|
||||
}
|
||||
this.realloc(1);
|
||||
this.buf[this.pos++] = val | 0;
|
||||
if (this.pos - pos > 10) throw new Error('Given varint doesn\'t fit into 10 bytes');
|
||||
}
|
||||
},
|
||||
|
||||
writeSVarint: function(val) {
|
||||
this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
|
||||
},
|
||||
|
||||
writeBoolean: function(val) {
|
||||
this.writeVarint(Boolean(val));
|
||||
},
|
||||
|
||||
writeString: function(str) {
|
||||
str = String(str);
|
||||
var bytes = Buffer.byteLength(str);
|
||||
this.writeVarint(bytes);
|
||||
this.realloc(bytes);
|
||||
this.buf.write(str, this.pos);
|
||||
this.pos += bytes;
|
||||
},
|
||||
|
||||
writeFloat: function(val) {
|
||||
this.realloc(4);
|
||||
this.buf.writeFloatLE(val, this.pos);
|
||||
this.pos += 4;
|
||||
},
|
||||
|
||||
writeDouble: function(val) {
|
||||
this.realloc(8);
|
||||
this.buf.writeDoubleLE(val, this.pos);
|
||||
this.pos += 8;
|
||||
},
|
||||
|
||||
writeBytes: function(buffer) {
|
||||
var len = buffer.length;
|
||||
this.writeVarint(len);
|
||||
this.realloc(len);
|
||||
for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];
|
||||
},
|
||||
|
||||
writeRawMessage: function(fn, obj) {
|
||||
this.pos++; // reserve 1 byte for short message length
|
||||
|
||||
// write the message directly to the buffer and see how much was written
|
||||
var startPos = this.pos;
|
||||
fn(obj, this);
|
||||
var len = this.pos - startPos;
|
||||
|
||||
var varintLen =
|
||||
len <= 0x7f ? 1 :
|
||||
len <= 0x3fff ? 2 :
|
||||
len <= 0x1fffff ? 3 :
|
||||
len <= 0xfffffff ? 4 : Math.ceil(Math.log(len) / (Math.LN2 * 7));
|
||||
|
||||
// if 1 byte isn't enough for encoding message length, shift the data to the right
|
||||
if (varintLen > 1) {
|
||||
this.realloc(varintLen - 1);
|
||||
for (var i = this.pos - 1; i >= startPos; i--) this.buf[i + varintLen - 1] = this.buf[i];
|
||||
}
|
||||
|
||||
// finally, write the message length in the reserved place and restore the position
|
||||
this.pos = startPos - 1;
|
||||
this.writeVarint(len);
|
||||
this.pos += len;
|
||||
},
|
||||
|
||||
writeMessage: function(tag, fn, obj) {
|
||||
this.writeTag(tag, Pbf.Bytes);
|
||||
this.writeRawMessage(fn, obj);
|
||||
},
|
||||
|
||||
writePackedVarint: function(tag, arr) { this.writeMessage(tag, writePackedVarint, arr); },
|
||||
writePackedSVarint: function(tag, arr) { this.writeMessage(tag, writePackedSVarint, arr); },
|
||||
writePackedBoolean: function(tag, arr) { this.writeMessage(tag, writePackedBoolean, arr); },
|
||||
writePackedFloat: function(tag, arr) { this.writeMessage(tag, writePackedFloat, arr); },
|
||||
writePackedDouble: function(tag, arr) { this.writeMessage(tag, writePackedDouble, arr); },
|
||||
writePackedFixed32: function(tag, arr) { this.writeMessage(tag, writePackedFixed32, arr); },
|
||||
writePackedSFixed32: function(tag, arr) { this.writeMessage(tag, writePackedSFixed32, arr); },
|
||||
writePackedFixed64: function(tag, arr) { this.writeMessage(tag, writePackedFixed64, arr); },
|
||||
writePackedSFixed64: function(tag, arr) { this.writeMessage(tag, writePackedSFixed64, arr); },
|
||||
|
||||
writeBytesField: function(tag, buffer) {
|
||||
this.writeTag(tag, Pbf.Bytes);
|
||||
this.writeBytes(buffer);
|
||||
},
|
||||
writeFixed32Field: function(tag, val) {
|
||||
this.writeTag(tag, Pbf.Fixed32);
|
||||
this.writeFixed32(val);
|
||||
},
|
||||
writeSFixed32Field: function(tag, val) {
|
||||
this.writeTag(tag, Pbf.Fixed32);
|
||||
this.writeSFixed32(val);
|
||||
},
|
||||
writeFixed64Field: function(tag, val) {
|
||||
this.writeTag(tag, Pbf.Fixed64);
|
||||
this.writeFixed64(val);
|
||||
},
|
||||
writeSFixed64Field: function(tag, val) {
|
||||
this.writeTag(tag, Pbf.Fixed64);
|
||||
this.writeSFixed64(val);
|
||||
},
|
||||
writeVarintField: function(tag, val) {
|
||||
this.writeTag(tag, Pbf.Varint);
|
||||
this.writeVarint(val);
|
||||
},
|
||||
writeSVarintField: function(tag, val) {
|
||||
this.writeTag(tag, Pbf.Varint);
|
||||
this.writeSVarint(val);
|
||||
},
|
||||
writeStringField: function(tag, str) {
|
||||
this.writeTag(tag, Pbf.Bytes);
|
||||
this.writeString(str);
|
||||
},
|
||||
writeFloatField: function(tag, val) {
|
||||
this.writeTag(tag, Pbf.Fixed32);
|
||||
this.writeFloat(val);
|
||||
},
|
||||
writeDoubleField: function(tag, val) {
|
||||
this.writeTag(tag, Pbf.Fixed64);
|
||||
this.writeDouble(val);
|
||||
},
|
||||
writeBooleanField: function(tag, val) {
|
||||
this.writeVarintField(tag, Boolean(val));
|
||||
}
|
||||
};
|
||||
|
||||
function writePackedVarint(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]); }
|
||||
function writePackedSVarint(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]); }
|
||||
function writePackedFloat(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]); }
|
||||
function writePackedDouble(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]); }
|
||||
function writePackedBoolean(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]); }
|
||||
function writePackedFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]); }
|
||||
function writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }
|
||||
function writePackedFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]); }
|
||||
function writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }
|
||||
|
||||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||||
},{"./buffer":1}],3:[function(require,module,exports){
|
||||
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
|
||||
var e, m
|
||||
var eLen = nBytes * 8 - mLen - 1
|
||||
var eMax = (1 << eLen) - 1
|
||||
var eBias = eMax >> 1
|
||||
var nBits = -7
|
||||
var i = isLE ? (nBytes - 1) : 0
|
||||
var d = isLE ? -1 : 1
|
||||
var s = buffer[offset + i]
|
||||
|
||||
i += d
|
||||
|
||||
e = s & ((1 << (-nBits)) - 1)
|
||||
s >>= (-nBits)
|
||||
nBits += eLen
|
||||
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
||||
|
||||
m = e & ((1 << (-nBits)) - 1)
|
||||
e >>= (-nBits)
|
||||
nBits += mLen
|
||||
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
||||
|
||||
if (e === 0) {
|
||||
e = 1 - eBias
|
||||
} else if (e === eMax) {
|
||||
return m ? NaN : ((s ? -1 : 1) * Infinity)
|
||||
} else {
|
||||
m = m + Math.pow(2, mLen)
|
||||
e = e - eBias
|
||||
}
|
||||
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
|
||||
}
|
||||
|
||||
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
|
||||
var e, m, c
|
||||
var eLen = nBytes * 8 - mLen - 1
|
||||
var eMax = (1 << eLen) - 1
|
||||
var eBias = eMax >> 1
|
||||
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
|
||||
var i = isLE ? 0 : (nBytes - 1)
|
||||
var d = isLE ? 1 : -1
|
||||
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
|
||||
|
||||
value = Math.abs(value)
|
||||
|
||||
if (isNaN(value) || value === Infinity) {
|
||||
m = isNaN(value) ? 1 : 0
|
||||
e = eMax
|
||||
} else {
|
||||
e = Math.floor(Math.log(value) / Math.LN2)
|
||||
if (value * (c = Math.pow(2, -e)) < 1) {
|
||||
e--
|
||||
c *= 2
|
||||
}
|
||||
if (e + eBias >= 1) {
|
||||
value += rt / c
|
||||
} else {
|
||||
value += rt * Math.pow(2, 1 - eBias)
|
||||
}
|
||||
if (value * c >= 2) {
|
||||
e++
|
||||
c /= 2
|
||||
}
|
||||
|
||||
if (e + eBias >= eMax) {
|
||||
m = 0
|
||||
e = eMax
|
||||
} else if (e + eBias >= 1) {
|
||||
m = (value * c - 1) * Math.pow(2, mLen)
|
||||
e = e + eBias
|
||||
} else {
|
||||
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
|
||||
e = 0
|
||||
}
|
||||
}
|
||||
|
||||
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
|
||||
|
||||
e = (e << mLen) | m
|
||||
eLen += mLen
|
||||
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
|
||||
|
||||
buffer[offset + i - d] |= s * 128
|
||||
}
|
||||
|
||||
},{}]},{},[2])(2)
|
||||
});
|
||||
ol.ext.pbf = module.exports;
|
||||
})();
|
||||
@@ -0,0 +1,282 @@
|
||||
goog.provide('ol.ext.pixelworks');
|
||||
/** @typedef {function(*)} */
|
||||
ol.ext.pixelworks;
|
||||
(function() {
|
||||
var exports = {};
|
||||
var module = {exports: exports};
|
||||
var define;
|
||||
/**
|
||||
* @fileoverview
|
||||
* @suppress {accessControls, ambiguousFunctionDecl, checkDebuggerStatement, checkRegExp, checkTypes, checkVars, const, constantProperty, deprecated, duplicate, es5Strict, fileoverviewTags, missingProperties, nonStandardJsDocs, strictModuleDepCheck, suspiciousCode, undefinedNames, undefinedVars, unknownDefines, uselessCode, visibility}
|
||||
*/
|
||||
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.pixelworks = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
||||
var Processor = require('./processor');
|
||||
|
||||
exports.Processor = Processor;
|
||||
|
||||
},{"./processor":2}],2:[function(require,module,exports){
|
||||
/* eslint-disable dot-notation */
|
||||
|
||||
/**
|
||||
* Create a function for running operations.
|
||||
* @param {function(Array, Object):*} operation The operation.
|
||||
* @return {function(Object):ArrayBuffer} A function that takes an object with
|
||||
* buffers, meta, imageOps, width, and height properties and returns an array
|
||||
* buffer.
|
||||
*/
|
||||
function createMinion(operation) {
|
||||
return function(data) {
|
||||
// bracket notation for minification support
|
||||
var buffers = data['buffers'];
|
||||
var meta = data['meta'];
|
||||
var imageOps = data['imageOps'];
|
||||
var width = data['width'];
|
||||
var height = data['height'];
|
||||
|
||||
var numBuffers = buffers.length;
|
||||
var numBytes = buffers[0].byteLength;
|
||||
var output, b;
|
||||
|
||||
if (imageOps) {
|
||||
var images = new Array(numBuffers);
|
||||
for (b = 0; b < numBuffers; ++b) {
|
||||
images[b] = new ImageData(
|
||||
new Uint8ClampedArray(buffers[b]), width, height);
|
||||
}
|
||||
output = operation(images, meta).data;
|
||||
} else {
|
||||
output = new Uint8ClampedArray(numBytes);
|
||||
var arrays = new Array(numBuffers);
|
||||
var pixels = new Array(numBuffers);
|
||||
for (b = 0; b < numBuffers; ++b) {
|
||||
arrays[b] = new Uint8ClampedArray(buffers[b]);
|
||||
pixels[b] = [0, 0, 0, 0];
|
||||
}
|
||||
for (var i = 0; i < numBytes; i += 4) {
|
||||
for (var j = 0; j < numBuffers; ++j) {
|
||||
var array = arrays[j];
|
||||
pixels[j][0] = array[i];
|
||||
pixels[j][1] = array[i + 1];
|
||||
pixels[j][2] = array[i + 2];
|
||||
pixels[j][3] = array[i + 3];
|
||||
}
|
||||
var pixel = operation(pixels, meta);
|
||||
output[i] = pixel[0];
|
||||
output[i + 1] = pixel[1];
|
||||
output[i + 2] = pixel[2];
|
||||
output[i + 3] = pixel[3];
|
||||
}
|
||||
}
|
||||
return output.buffer;
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a worker for running operations.
|
||||
* @param {Object} config Configuration.
|
||||
* @param {function(Object)} onMessage Called with a message event.
|
||||
* @return {Worker} The worker.
|
||||
*/
|
||||
function createWorker(config, onMessage) {
|
||||
var lib = Object.keys(config.lib || {}).map(function(name) {
|
||||
return 'var ' + name + ' = ' + config.lib[name].toString() + ';';
|
||||
});
|
||||
|
||||
var lines = lib.concat([
|
||||
'var __minion__ = (' + createMinion.toString() + ')(',
|
||||
config.operation.toString(),
|
||||
');',
|
||||
'self.addEventListener("message", function(__event__) {',
|
||||
'var buffer = __minion__(__event__.data);',
|
||||
'self.postMessage({buffer: buffer, meta: __event__.data.meta}, [buffer]);',
|
||||
'});'
|
||||
]);
|
||||
|
||||
var blob = new Blob(lines, {type: 'text/javascript'});
|
||||
var source = URL.createObjectURL(blob);
|
||||
var worker = new Worker(source);
|
||||
worker.addEventListener('message', onMessage);
|
||||
return worker;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a faux worker for running operations.
|
||||
* @param {Object} config Configuration.
|
||||
* @param {function(Object)} onMessage Called with a message event.
|
||||
* @return {Object} The faux worker.
|
||||
*/
|
||||
function createFauxWorker(config, onMessage) {
|
||||
var minion = createMinion(config.operation);
|
||||
return {
|
||||
postMessage: function(data) {
|
||||
setTimeout(function() {
|
||||
onMessage({data: {buffer: minion(data), meta: data.meta}});
|
||||
}, 0);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* A processor runs pixel or image operations in workers.
|
||||
* @param {Object} config Configuration.
|
||||
*/
|
||||
function Processor(config) {
|
||||
this._imageOps = !!config.imageOps;
|
||||
var threads;
|
||||
if (config.threads === 0) {
|
||||
threads = 0;
|
||||
} else if (this._imageOps) {
|
||||
threads = 1;
|
||||
} else {
|
||||
threads = config.threads || 1;
|
||||
}
|
||||
var workers = [];
|
||||
if (threads) {
|
||||
for (var i = 0; i < threads; ++i) {
|
||||
workers[i] = createWorker(config, this._onWorkerMessage.bind(this, i));
|
||||
}
|
||||
} else {
|
||||
workers[0] = createFauxWorker(config, this._onWorkerMessage.bind(this, 0));
|
||||
}
|
||||
this._workers = workers;
|
||||
this._queue = [];
|
||||
this._maxQueueLength = config.queue || Infinity;
|
||||
this._running = 0;
|
||||
this._dataLookup = {};
|
||||
this._job = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run operation on input data.
|
||||
* @param {Array.<Array|ImageData>} inputs Array of pixels or image data
|
||||
* (depending on the operation type).
|
||||
* @param {Object} meta A user data object. This is passed to all operations
|
||||
* and must be serializable.
|
||||
* @param {function(Error, ImageData, Object)} callback Called when work
|
||||
* completes. The first argument is any error. The second is the ImageData
|
||||
* generated by operations. The third is the user data object.
|
||||
*/
|
||||
Processor.prototype.process = function(inputs, meta, callback) {
|
||||
this._enqueue({
|
||||
inputs: inputs,
|
||||
meta: meta,
|
||||
callback: callback
|
||||
});
|
||||
this._dispatch();
|
||||
};
|
||||
|
||||
/**
|
||||
* Stop responding to any completed work and destroy the processor.
|
||||
*/
|
||||
Processor.prototype.destroy = function() {
|
||||
for (var key in this) {
|
||||
this[key] = null;
|
||||
}
|
||||
this._destroyed = true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Add a job to the queue.
|
||||
* @param {Object} job The job.
|
||||
*/
|
||||
Processor.prototype._enqueue = function(job) {
|
||||
this._queue.push(job);
|
||||
while (this._queue.length > this._maxQueueLength) {
|
||||
this._queue.shift().callback(null, null);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Dispatch a job.
|
||||
*/
|
||||
Processor.prototype._dispatch = function() {
|
||||
if (this._running === 0 && this._queue.length > 0) {
|
||||
var job = this._job = this._queue.shift();
|
||||
var width = job.inputs[0].width;
|
||||
var height = job.inputs[0].height;
|
||||
var buffers = job.inputs.map(function(input) {
|
||||
return input.data.buffer;
|
||||
});
|
||||
var threads = this._workers.length;
|
||||
this._running = threads;
|
||||
if (threads === 1) {
|
||||
this._workers[0].postMessage({
|
||||
'buffers': buffers,
|
||||
'meta': job.meta,
|
||||
'imageOps': this._imageOps,
|
||||
'width': width,
|
||||
'height': height
|
||||
}, buffers);
|
||||
} else {
|
||||
var length = job.inputs[0].data.length;
|
||||
var segmentLength = 4 * Math.ceil(length / 4 / threads);
|
||||
for (var i = 0; i < threads; ++i) {
|
||||
var offset = i * segmentLength;
|
||||
var slices = [];
|
||||
for (var j = 0, jj = buffers.length; j < jj; ++j) {
|
||||
slices.push(buffers[i].slice(offset, offset + segmentLength));
|
||||
}
|
||||
this._workers[i].postMessage({
|
||||
'buffers': slices,
|
||||
'meta': job.meta,
|
||||
'imageOps': this._imageOps,
|
||||
'width': width,
|
||||
'height': height
|
||||
}, slices);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Handle messages from the worker.
|
||||
* @param {number} index The worker index.
|
||||
* @param {Object} event The message event.
|
||||
*/
|
||||
Processor.prototype._onWorkerMessage = function(index, event) {
|
||||
if (this._destroyed) {
|
||||
return;
|
||||
}
|
||||
this._dataLookup[index] = event.data;
|
||||
--this._running;
|
||||
if (this._running === 0) {
|
||||
this._resolveJob();
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Resolve a job. If there are no more worker threads, the processor callback
|
||||
* will be called.
|
||||
*/
|
||||
Processor.prototype._resolveJob = function() {
|
||||
var job = this._job;
|
||||
var threads = this._workers.length;
|
||||
var data, meta;
|
||||
if (threads === 1) {
|
||||
data = new Uint8ClampedArray(this._dataLookup[0]['buffer']);
|
||||
meta = this._dataLookup[0]['meta'];
|
||||
} else {
|
||||
var length = job.inputs[0].data.length;
|
||||
data = new Uint8ClampedArray(length);
|
||||
meta = new Array(length);
|
||||
var segmentLength = 4 * Math.ceil(length / 4 / threads);
|
||||
for (var i = 0; i < threads; ++i) {
|
||||
var buffer = this._dataLookup[i]['buffer'];
|
||||
var offset = i * segmentLength;
|
||||
data.set(new Uint8ClampedArray(buffer), offset);
|
||||
meta[i] = this._dataLookup[i]['meta'];
|
||||
}
|
||||
}
|
||||
this._job = null;
|
||||
this._dataLookup = {};
|
||||
job.callback(null,
|
||||
new ImageData(data, job.inputs[0].width, job.inputs[0].height), meta);
|
||||
this._dispatch();
|
||||
};
|
||||
|
||||
module.exports = Processor;
|
||||
|
||||
},{}]},{},[1])(1)
|
||||
});
|
||||
ol.ext.pixelworks = module.exports;
|
||||
})();
|
||||
@@ -0,0 +1,601 @@
|
||||
goog.provide('ol.ext.rbush');
|
||||
/** @typedef {function(*)} */
|
||||
ol.ext.rbush;
|
||||
(function() {
|
||||
var exports = {};
|
||||
var module = {exports: exports};
|
||||
var define;
|
||||
/**
|
||||
* @fileoverview
|
||||
* @suppress {accessControls, ambiguousFunctionDecl, checkDebuggerStatement, checkRegExp, checkTypes, checkVars, const, constantProperty, deprecated, duplicate, es5Strict, fileoverviewTags, missingProperties, nonStandardJsDocs, strictModuleDepCheck, suspiciousCode, undefinedNames, undefinedVars, unknownDefines, uselessCode, visibility}
|
||||
*/
|
||||
/*
|
||||
(c) 2013, Vladimir Agafonkin
|
||||
RBush, a JavaScript library for high-performance 2D spatial indexing of points and rectangles.
|
||||
https://github.com/mourner/rbush
|
||||
*/
|
||||
|
||||
(function () { 'use strict';
|
||||
|
||||
function rbush(maxEntries, format) {
|
||||
|
||||
// jshint newcap: false, validthis: true
|
||||
if (!(this instanceof rbush)) return new rbush(maxEntries, format);
|
||||
|
||||
// max entries in a node is 9 by default; min node fill is 40% for best performance
|
||||
this._maxEntries = Math.max(4, maxEntries || 9);
|
||||
this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
|
||||
|
||||
if (format) {
|
||||
this._initFormat(format);
|
||||
}
|
||||
|
||||
this.clear();
|
||||
}
|
||||
|
||||
rbush.prototype = {
|
||||
|
||||
all: function () {
|
||||
return this._all(this.data, []);
|
||||
},
|
||||
|
||||
search: function (bbox) {
|
||||
|
||||
var node = this.data,
|
||||
result = [],
|
||||
toBBox = this.toBBox;
|
||||
|
||||
if (!intersects(bbox, node.bbox)) return result;
|
||||
|
||||
var nodesToSearch = [],
|
||||
i, len, child, childBBox;
|
||||
|
||||
while (node) {
|
||||
for (i = 0, len = node.children.length; i < len; i++) {
|
||||
|
||||
child = node.children[i];
|
||||
childBBox = node.leaf ? toBBox(child) : child.bbox;
|
||||
|
||||
if (intersects(bbox, childBBox)) {
|
||||
if (node.leaf) result.push(child);
|
||||
else if (contains(bbox, childBBox)) this._all(child, result);
|
||||
else nodesToSearch.push(child);
|
||||
}
|
||||
}
|
||||
node = nodesToSearch.pop();
|
||||
}
|
||||
|
||||
return result;
|
||||
},
|
||||
|
||||
load: function (data) {
|
||||
if (!(data && data.length)) return this;
|
||||
|
||||
if (data.length < this._minEntries) {
|
||||
for (var i = 0, len = data.length; i < len; i++) {
|
||||
this.insert(data[i]);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
// recursively build the tree with the given data from stratch using OMT algorithm
|
||||
var node = this._build(data.slice(), 0, data.length - 1, 0);
|
||||
|
||||
if (!this.data.children.length) {
|
||||
// save as is if tree is empty
|
||||
this.data = node;
|
||||
|
||||
} else if (this.data.height === node.height) {
|
||||
// split root if trees have the same height
|
||||
this._splitRoot(this.data, node);
|
||||
|
||||
} else {
|
||||
if (this.data.height < node.height) {
|
||||
// swap trees if inserted one is bigger
|
||||
var tmpNode = this.data;
|
||||
this.data = node;
|
||||
node = tmpNode;
|
||||
}
|
||||
|
||||
// insert the small tree into the large tree at appropriate level
|
||||
this._insert(node, this.data.height - node.height - 1, true);
|
||||
}
|
||||
|
||||
return this;
|
||||
},
|
||||
|
||||
insert: function (item) {
|
||||
if (item) this._insert(item, this.data.height - 1);
|
||||
return this;
|
||||
},
|
||||
|
||||
clear: function () {
|
||||
this.data = {
|
||||
children: [],
|
||||
height: 1,
|
||||
bbox: empty(),
|
||||
leaf: true
|
||||
};
|
||||
return this;
|
||||
},
|
||||
|
||||
remove: function (item) {
|
||||
if (!item) return this;
|
||||
|
||||
var node = this.data,
|
||||
bbox = this.toBBox(item),
|
||||
path = [],
|
||||
indexes = [],
|
||||
i, parent, index, goingUp;
|
||||
|
||||
// depth-first iterative tree traversal
|
||||
while (node || path.length) {
|
||||
|
||||
if (!node) { // go up
|
||||
node = path.pop();
|
||||
parent = path[path.length - 1];
|
||||
i = indexes.pop();
|
||||
goingUp = true;
|
||||
}
|
||||
|
||||
if (node.leaf) { // check current node
|
||||
index = node.children.indexOf(item);
|
||||
|
||||
if (index !== -1) {
|
||||
// item found, remove the item and condense tree upwards
|
||||
node.children.splice(index, 1);
|
||||
path.push(node);
|
||||
this._condense(path);
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
if (!goingUp && !node.leaf && contains(node.bbox, bbox)) { // go down
|
||||
path.push(node);
|
||||
indexes.push(i);
|
||||
i = 0;
|
||||
parent = node;
|
||||
node = node.children[0];
|
||||
|
||||
} else if (parent) { // go right
|
||||
i++;
|
||||
node = parent.children[i];
|
||||
goingUp = false;
|
||||
|
||||
} else node = null; // nothing found
|
||||
}
|
||||
|
||||
return this;
|
||||
},
|
||||
|
||||
toBBox: function (item) { return item; },
|
||||
|
||||
compareMinX: function (a, b) { return a[0] - b[0]; },
|
||||
compareMinY: function (a, b) { return a[1] - b[1]; },
|
||||
|
||||
toJSON: function () { return this.data; },
|
||||
|
||||
fromJSON: function (data) {
|
||||
this.data = data;
|
||||
return this;
|
||||
},
|
||||
|
||||
_all: function (node, result) {
|
||||
var nodesToSearch = [];
|
||||
while (node) {
|
||||
if (node.leaf) result.push.apply(result, node.children);
|
||||
else nodesToSearch.push.apply(nodesToSearch, node.children);
|
||||
|
||||
node = nodesToSearch.pop();
|
||||
}
|
||||
return result;
|
||||
},
|
||||
|
||||
_build: function (items, left, right, height) {
|
||||
|
||||
var N = right - left + 1,
|
||||
M = this._maxEntries,
|
||||
node;
|
||||
|
||||
if (N <= M) {
|
||||
// reached leaf level; return leaf
|
||||
node = {
|
||||
children: items.slice(left, right + 1),
|
||||
height: 1,
|
||||
bbox: null,
|
||||
leaf: true
|
||||
};
|
||||
calcBBox(node, this.toBBox);
|
||||
return node;
|
||||
}
|
||||
|
||||
if (!height) {
|
||||
// target height of the bulk-loaded tree
|
||||
height = Math.ceil(Math.log(N) / Math.log(M));
|
||||
|
||||
// target number of root entries to maximize storage utilization
|
||||
M = Math.ceil(N / Math.pow(M, height - 1));
|
||||
}
|
||||
|
||||
// TODO eliminate recursion?
|
||||
|
||||
node = {
|
||||
children: [],
|
||||
height: height,
|
||||
bbox: null
|
||||
};
|
||||
|
||||
// split the items into M mostly square tiles
|
||||
|
||||
var N2 = Math.ceil(N / M),
|
||||
N1 = N2 * Math.ceil(Math.sqrt(M)),
|
||||
i, j, right2, right3;
|
||||
|
||||
multiSelect(items, left, right, N1, this.compareMinX);
|
||||
|
||||
for (i = left; i <= right; i += N1) {
|
||||
|
||||
right2 = Math.min(i + N1 - 1, right);
|
||||
|
||||
multiSelect(items, i, right2, N2, this.compareMinY);
|
||||
|
||||
for (j = i; j <= right2; j += N2) {
|
||||
|
||||
right3 = Math.min(j + N2 - 1, right2);
|
||||
|
||||
// pack each entry recursively
|
||||
node.children.push(this._build(items, j, right3, height - 1));
|
||||
}
|
||||
}
|
||||
|
||||
calcBBox(node, this.toBBox);
|
||||
|
||||
return node;
|
||||
},
|
||||
|
||||
_chooseSubtree: function (bbox, node, level, path) {
|
||||
|
||||
var i, len, child, targetNode, area, enlargement, minArea, minEnlargement;
|
||||
|
||||
while (true) {
|
||||
path.push(node);
|
||||
|
||||
if (node.leaf || path.length - 1 === level) break;
|
||||
|
||||
minArea = minEnlargement = Infinity;
|
||||
|
||||
for (i = 0, len = node.children.length; i < len; i++) {
|
||||
child = node.children[i];
|
||||
area = bboxArea(child.bbox);
|
||||
enlargement = enlargedArea(bbox, child.bbox) - area;
|
||||
|
||||
// choose entry with the least area enlargement
|
||||
if (enlargement < minEnlargement) {
|
||||
minEnlargement = enlargement;
|
||||
minArea = area < minArea ? area : minArea;
|
||||
targetNode = child;
|
||||
|
||||
} else if (enlargement === minEnlargement) {
|
||||
// otherwise choose one with the smallest area
|
||||
if (area < minArea) {
|
||||
minArea = area;
|
||||
targetNode = child;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
node = targetNode;
|
||||
}
|
||||
|
||||
return node;
|
||||
},
|
||||
|
||||
_insert: function (item, level, isNode) {
|
||||
|
||||
var toBBox = this.toBBox,
|
||||
bbox = isNode ? item.bbox : toBBox(item),
|
||||
insertPath = [];
|
||||
|
||||
// find the best node for accommodating the item, saving all nodes along the path too
|
||||
var node = this._chooseSubtree(bbox, this.data, level, insertPath);
|
||||
|
||||
// put the item into the node
|
||||
node.children.push(item);
|
||||
extend(node.bbox, bbox);
|
||||
|
||||
// split on node overflow; propagate upwards if necessary
|
||||
while (level >= 0) {
|
||||
if (insertPath[level].children.length > this._maxEntries) {
|
||||
this._split(insertPath, level);
|
||||
level--;
|
||||
} else break;
|
||||
}
|
||||
|
||||
// adjust bboxes along the insertion path
|
||||
this._adjustParentBBoxes(bbox, insertPath, level);
|
||||
},
|
||||
|
||||
// split overflowed node into two
|
||||
_split: function (insertPath, level) {
|
||||
|
||||
var node = insertPath[level],
|
||||
M = node.children.length,
|
||||
m = this._minEntries;
|
||||
|
||||
this._chooseSplitAxis(node, m, M);
|
||||
|
||||
var newNode = {
|
||||
children: node.children.splice(this._chooseSplitIndex(node, m, M)),
|
||||
height: node.height
|
||||
};
|
||||
|
||||
if (node.leaf) newNode.leaf = true;
|
||||
|
||||
calcBBox(node, this.toBBox);
|
||||
calcBBox(newNode, this.toBBox);
|
||||
|
||||
if (level) insertPath[level - 1].children.push(newNode);
|
||||
else this._splitRoot(node, newNode);
|
||||
},
|
||||
|
||||
_splitRoot: function (node, newNode) {
|
||||
// split root node
|
||||
this.data = {
|
||||
children: [node, newNode],
|
||||
height: node.height + 1
|
||||
};
|
||||
calcBBox(this.data, this.toBBox);
|
||||
},
|
||||
|
||||
_chooseSplitIndex: function (node, m, M) {
|
||||
|
||||
var i, bbox1, bbox2, overlap, area, minOverlap, minArea, index;
|
||||
|
||||
minOverlap = minArea = Infinity;
|
||||
|
||||
for (i = m; i <= M - m; i++) {
|
||||
bbox1 = distBBox(node, 0, i, this.toBBox);
|
||||
bbox2 = distBBox(node, i, M, this.toBBox);
|
||||
|
||||
overlap = intersectionArea(bbox1, bbox2);
|
||||
area = bboxArea(bbox1) + bboxArea(bbox2);
|
||||
|
||||
// choose distribution with minimum overlap
|
||||
if (overlap < minOverlap) {
|
||||
minOverlap = overlap;
|
||||
index = i;
|
||||
|
||||
minArea = area < minArea ? area : minArea;
|
||||
|
||||
} else if (overlap === minOverlap) {
|
||||
// otherwise choose distribution with minimum area
|
||||
if (area < minArea) {
|
||||
minArea = area;
|
||||
index = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return index;
|
||||
},
|
||||
|
||||
// sorts node children by the best axis for split
|
||||
_chooseSplitAxis: function (node, m, M) {
|
||||
|
||||
var compareMinX = node.leaf ? this.compareMinX : compareNodeMinX,
|
||||
compareMinY = node.leaf ? this.compareMinY : compareNodeMinY,
|
||||
xMargin = this._allDistMargin(node, m, M, compareMinX),
|
||||
yMargin = this._allDistMargin(node, m, M, compareMinY);
|
||||
|
||||
// if total distributions margin value is minimal for x, sort by minX,
|
||||
// otherwise it's already sorted by minY
|
||||
if (xMargin < yMargin) node.children.sort(compareMinX);
|
||||
},
|
||||
|
||||
// total margin of all possible split distributions where each node is at least m full
|
||||
_allDistMargin: function (node, m, M, compare) {
|
||||
|
||||
node.children.sort(compare);
|
||||
|
||||
var toBBox = this.toBBox,
|
||||
leftBBox = distBBox(node, 0, m, toBBox),
|
||||
rightBBox = distBBox(node, M - m, M, toBBox),
|
||||
margin = bboxMargin(leftBBox) + bboxMargin(rightBBox),
|
||||
i, child;
|
||||
|
||||
for (i = m; i < M - m; i++) {
|
||||
child = node.children[i];
|
||||
extend(leftBBox, node.leaf ? toBBox(child) : child.bbox);
|
||||
margin += bboxMargin(leftBBox);
|
||||
}
|
||||
|
||||
for (i = M - m - 1; i >= m; i--) {
|
||||
child = node.children[i];
|
||||
extend(rightBBox, node.leaf ? toBBox(child) : child.bbox);
|
||||
margin += bboxMargin(rightBBox);
|
||||
}
|
||||
|
||||
return margin;
|
||||
},
|
||||
|
||||
_adjustParentBBoxes: function (bbox, path, level) {
|
||||
// adjust bboxes along the given tree path
|
||||
for (var i = level; i >= 0; i--) {
|
||||
extend(path[i].bbox, bbox);
|
||||
}
|
||||
},
|
||||
|
||||
_condense: function (path) {
|
||||
// go through the path, removing empty nodes and updating bboxes
|
||||
for (var i = path.length - 1, siblings; i >= 0; i--) {
|
||||
if (path[i].children.length === 0) {
|
||||
if (i > 0) {
|
||||
siblings = path[i - 1].children;
|
||||
siblings.splice(siblings.indexOf(path[i]), 1);
|
||||
|
||||
} else this.clear();
|
||||
|
||||
} else calcBBox(path[i], this.toBBox);
|
||||
}
|
||||
},
|
||||
|
||||
_initFormat: function (format) {
|
||||
// data format (minX, minY, maxX, maxY accessors)
|
||||
|
||||
// uses eval-type function compilation instead of just accepting a toBBox function
|
||||
// because the algorithms are very sensitive to sorting functions performance,
|
||||
// so they should be dead simple and without inner calls
|
||||
|
||||
// jshint evil: true
|
||||
|
||||
var compareArr = ['return a', ' - b', ';'];
|
||||
|
||||
this.compareMinX = new Function('a', 'b', compareArr.join(format[0]));
|
||||
this.compareMinY = new Function('a', 'b', compareArr.join(format[1]));
|
||||
|
||||
this.toBBox = new Function('a', 'return [a' + format.join(', a') + '];');
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// calculate node's bbox from bboxes of its children
|
||||
function calcBBox(node, toBBox) {
|
||||
node.bbox = distBBox(node, 0, node.children.length, toBBox);
|
||||
}
|
||||
|
||||
// min bounding rectangle of node children from k to p-1
|
||||
function distBBox(node, k, p, toBBox) {
|
||||
var bbox = empty();
|
||||
|
||||
for (var i = k, child; i < p; i++) {
|
||||
child = node.children[i];
|
||||
extend(bbox, node.leaf ? toBBox(child) : child.bbox);
|
||||
}
|
||||
|
||||
return bbox;
|
||||
}
|
||||
|
||||
function empty() { return [Infinity, Infinity, -Infinity, -Infinity]; }
|
||||
|
||||
function extend(a, b) {
|
||||
a[0] = Math.min(a[0], b[0]);
|
||||
a[1] = Math.min(a[1], b[1]);
|
||||
a[2] = Math.max(a[2], b[2]);
|
||||
a[3] = Math.max(a[3], b[3]);
|
||||
return a;
|
||||
}
|
||||
|
||||
function compareNodeMinX(a, b) { return a.bbox[0] - b.bbox[0]; }
|
||||
function compareNodeMinY(a, b) { return a.bbox[1] - b.bbox[1]; }
|
||||
|
||||
function bboxArea(a) { return (a[2] - a[0]) * (a[3] - a[1]); }
|
||||
function bboxMargin(a) { return (a[2] - a[0]) + (a[3] - a[1]); }
|
||||
|
||||
function enlargedArea(a, b) {
|
||||
return (Math.max(b[2], a[2]) - Math.min(b[0], a[0])) *
|
||||
(Math.max(b[3], a[3]) - Math.min(b[1], a[1]));
|
||||
}
|
||||
|
||||
function intersectionArea(a, b) {
|
||||
var minX = Math.max(a[0], b[0]),
|
||||
minY = Math.max(a[1], b[1]),
|
||||
maxX = Math.min(a[2], b[2]),
|
||||
maxY = Math.min(a[3], b[3]);
|
||||
|
||||
return Math.max(0, maxX - minX) *
|
||||
Math.max(0, maxY - minY);
|
||||
}
|
||||
|
||||
function contains(a, b) {
|
||||
return a[0] <= b[0] &&
|
||||
a[1] <= b[1] &&
|
||||
b[2] <= a[2] &&
|
||||
b[3] <= a[3];
|
||||
}
|
||||
|
||||
function intersects(a, b) {
|
||||
return b[0] <= a[2] &&
|
||||
b[1] <= a[3] &&
|
||||
b[2] >= a[0] &&
|
||||
b[3] >= a[1];
|
||||
}
|
||||
|
||||
// sort an array so that items come in groups of n unsorted items, with groups sorted between each other;
|
||||
// combines selection algorithm with binary divide & conquer approach
|
||||
|
||||
function multiSelect(arr, left, right, n, compare) {
|
||||
var stack = [left, right],
|
||||
mid;
|
||||
|
||||
while (stack.length) {
|
||||
right = stack.pop();
|
||||
left = stack.pop();
|
||||
|
||||
if (right - left <= n) continue;
|
||||
|
||||
mid = left + Math.ceil((right - left) / n / 2) * n;
|
||||
select(arr, left, right, mid, compare);
|
||||
|
||||
stack.push(left, mid, mid, right);
|
||||
}
|
||||
}
|
||||
|
||||
// sort array between left and right (inclusive) so that the smallest k elements come first (unordered)
|
||||
function select(arr, left, right, k, compare) {
|
||||
var n, i, z, s, sd, newLeft, newRight, t, j;
|
||||
|
||||
while (right > left) {
|
||||
if (right - left > 600) {
|
||||
n = right - left + 1;
|
||||
i = k - left + 1;
|
||||
z = Math.log(n);
|
||||
s = 0.5 * Math.exp(2 * z / 3);
|
||||
sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (i - n / 2 < 0 ? -1 : 1);
|
||||
newLeft = Math.max(left, Math.floor(k - i * s / n + sd));
|
||||
newRight = Math.min(right, Math.floor(k + (n - i) * s / n + sd));
|
||||
select(arr, newLeft, newRight, k, compare);
|
||||
}
|
||||
|
||||
t = arr[k];
|
||||
i = left;
|
||||
j = right;
|
||||
|
||||
swap(arr, left, k);
|
||||
if (compare(arr[right], t) > 0) swap(arr, left, right);
|
||||
|
||||
while (i < j) {
|
||||
swap(arr, i, j);
|
||||
i++;
|
||||
j--;
|
||||
while (compare(arr[i], t) < 0) i++;
|
||||
while (compare(arr[j], t) > 0) j--;
|
||||
}
|
||||
|
||||
if (compare(arr[left], t) === 0) swap(arr, left, j);
|
||||
else {
|
||||
j++;
|
||||
swap(arr, j, right);
|
||||
}
|
||||
|
||||
if (j <= k) left = j + 1;
|
||||
if (k <= j) right = j - 1;
|
||||
}
|
||||
}
|
||||
|
||||
function swap(arr, i, j) {
|
||||
var tmp = arr[i];
|
||||
arr[i] = arr[j];
|
||||
arr[j] = tmp;
|
||||
}
|
||||
|
||||
|
||||
// export as AMD/CommonJS module or global variable
|
||||
if (typeof define === 'function' && define.amd) define('rbush', function() { return rbush; });
|
||||
else if (typeof module !== 'undefined') module.exports = rbush;
|
||||
else if (typeof self !== 'undefined') self.rbush = rbush;
|
||||
else window.rbush = rbush;
|
||||
|
||||
})();
|
||||
|
||||
ol.ext.rbush = module.exports;
|
||||
})();
|
||||
@@ -0,0 +1,403 @@
|
||||
goog.provide('ol.ext.vectortile');
|
||||
/** @typedef {function(*)} */
|
||||
ol.ext.vectortile;
|
||||
(function() {
|
||||
var exports = {};
|
||||
var module = {exports: exports};
|
||||
var define;
|
||||
/**
|
||||
* @fileoverview
|
||||
* @suppress {accessControls, ambiguousFunctionDecl, checkDebuggerStatement, checkRegExp, checkTypes, checkVars, const, constantProperty, deprecated, duplicate, es5Strict, fileoverviewTags, missingProperties, nonStandardJsDocs, strictModuleDepCheck, suspiciousCode, undefinedNames, undefinedVars, unknownDefines, uselessCode, visibility}
|
||||
*/
|
||||
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.vectortile = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
||||
module.exports.VectorTile = require('./lib/vectortile.js');
|
||||
module.exports.VectorTileFeature = require('./lib/vectortilefeature.js');
|
||||
module.exports.VectorTileLayer = require('./lib/vectortilelayer.js');
|
||||
|
||||
},{"./lib/vectortile.js":2,"./lib/vectortilefeature.js":3,"./lib/vectortilelayer.js":4}],2:[function(require,module,exports){
|
||||
'use strict';
|
||||
|
||||
var VectorTileLayer = require('./vectortilelayer');
|
||||
|
||||
module.exports = VectorTile;
|
||||
|
||||
function VectorTile(pbf, end) {
|
||||
this.layers = pbf.readFields(readTile, {}, end);
|
||||
}
|
||||
|
||||
function readTile(tag, layers, pbf) {
|
||||
if (tag === 3) {
|
||||
var layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
|
||||
if (layer.length) layers[layer.name] = layer;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
},{"./vectortilelayer":4}],3:[function(require,module,exports){
|
||||
'use strict';
|
||||
|
||||
var Point = require('point-geometry');
|
||||
|
||||
module.exports = VectorTileFeature;
|
||||
|
||||
function VectorTileFeature(pbf, end, extent, keys, values) {
|
||||
// Public
|
||||
this.properties = {};
|
||||
this.extent = extent;
|
||||
this.type = 0;
|
||||
|
||||
// Private
|
||||
this._pbf = pbf;
|
||||
this._geometry = -1;
|
||||
this._keys = keys;
|
||||
this._values = values;
|
||||
|
||||
pbf.readFields(readFeature, this, end);
|
||||
}
|
||||
|
||||
function readFeature(tag, feature, pbf) {
|
||||
if (tag == 1) feature._id = pbf.readVarint();
|
||||
else if (tag == 2) readTag(pbf, feature);
|
||||
else if (tag == 3) feature.type = pbf.readVarint();
|
||||
else if (tag == 4) feature._geometry = pbf.pos;
|
||||
}
|
||||
|
||||
function readTag(pbf, feature) {
|
||||
var end = pbf.readVarint() + pbf.pos;
|
||||
|
||||
while (pbf.pos < end) {
|
||||
var key = feature._keys[pbf.readVarint()],
|
||||
value = feature._values[pbf.readVarint()];
|
||||
feature.properties[key] = value;
|
||||
}
|
||||
}
|
||||
|
||||
VectorTileFeature.types = ['Unknown', 'Point', 'LineString', 'Polygon'];
|
||||
|
||||
VectorTileFeature.prototype.loadGeometry = function() {
|
||||
var pbf = this._pbf;
|
||||
pbf.pos = this._geometry;
|
||||
|
||||
var end = pbf.readVarint() + pbf.pos,
|
||||
cmd = 1,
|
||||
length = 0,
|
||||
x = 0,
|
||||
y = 0,
|
||||
lines = [],
|
||||
line;
|
||||
|
||||
while (pbf.pos < end) {
|
||||
if (!length) {
|
||||
var cmdLen = pbf.readVarint();
|
||||
cmd = cmdLen & 0x7;
|
||||
length = cmdLen >> 3;
|
||||
}
|
||||
|
||||
length--;
|
||||
|
||||
if (cmd === 1 || cmd === 2) {
|
||||
x += pbf.readSVarint();
|
||||
y += pbf.readSVarint();
|
||||
|
||||
if (cmd === 1) { // moveTo
|
||||
if (line) lines.push(line);
|
||||
line = [];
|
||||
}
|
||||
|
||||
line.push(new Point(x, y));
|
||||
|
||||
} else if (cmd === 7) {
|
||||
|
||||
// Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
|
||||
if (line) {
|
||||
line.push(line[0].clone()); // closePolygon
|
||||
}
|
||||
|
||||
} else {
|
||||
throw new Error('unknown command ' + cmd);
|
||||
}
|
||||
}
|
||||
|
||||
if (line) lines.push(line);
|
||||
|
||||
return lines;
|
||||
};
|
||||
|
||||
VectorTileFeature.prototype.bbox = function() {
|
||||
var pbf = this._pbf;
|
||||
pbf.pos = this._geometry;
|
||||
|
||||
var end = pbf.readVarint() + pbf.pos,
|
||||
cmd = 1,
|
||||
length = 0,
|
||||
x = 0,
|
||||
y = 0,
|
||||
x1 = Infinity,
|
||||
x2 = -Infinity,
|
||||
y1 = Infinity,
|
||||
y2 = -Infinity;
|
||||
|
||||
while (pbf.pos < end) {
|
||||
if (!length) {
|
||||
var cmdLen = pbf.readVarint();
|
||||
cmd = cmdLen & 0x7;
|
||||
length = cmdLen >> 3;
|
||||
}
|
||||
|
||||
length--;
|
||||
|
||||
if (cmd === 1 || cmd === 2) {
|
||||
x += pbf.readSVarint();
|
||||
y += pbf.readSVarint();
|
||||
if (x < x1) x1 = x;
|
||||
if (x > x2) x2 = x;
|
||||
if (y < y1) y1 = y;
|
||||
if (y > y2) y2 = y;
|
||||
|
||||
} else if (cmd !== 7) {
|
||||
throw new Error('unknown command ' + cmd);
|
||||
}
|
||||
}
|
||||
|
||||
return [x1, y1, x2, y2];
|
||||
};
|
||||
|
||||
VectorTileFeature.prototype.toGeoJSON = function(x, y, z) {
|
||||
var size = this.extent * Math.pow(2, z),
|
||||
x0 = this.extent * x,
|
||||
y0 = this.extent * y,
|
||||
coords = this.loadGeometry(),
|
||||
type = VectorTileFeature.types[this.type];
|
||||
|
||||
for (var i = 0; i < coords.length; i++) {
|
||||
var line = coords[i];
|
||||
for (var j = 0; j < line.length; j++) {
|
||||
var p = line[j], y2 = 180 - (p.y + y0) * 360 / size;
|
||||
line[j] = [
|
||||
(p.x + x0) * 360 / size - 180,
|
||||
360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
if (type === 'Point' && coords.length === 1) {
|
||||
coords = coords[0][0];
|
||||
} else if (type === 'Point') {
|
||||
coords = coords[0];
|
||||
type = 'MultiPoint';
|
||||
} else if (type === 'LineString' && coords.length === 1) {
|
||||
coords = coords[0];
|
||||
} else if (type === 'LineString') {
|
||||
type = 'MultiLineString';
|
||||
}
|
||||
|
||||
return {
|
||||
type: "Feature",
|
||||
geometry: {
|
||||
type: type,
|
||||
coordinates: coords
|
||||
},
|
||||
properties: this.properties
|
||||
};
|
||||
};
|
||||
|
||||
},{"point-geometry":5}],4:[function(require,module,exports){
|
||||
'use strict';
|
||||
|
||||
var VectorTileFeature = require('./vectortilefeature.js');
|
||||
|
||||
module.exports = VectorTileLayer;
|
||||
|
||||
function VectorTileLayer(pbf, end) {
|
||||
// Public
|
||||
this.version = 1;
|
||||
this.name = null;
|
||||
this.extent = 4096;
|
||||
this.length = 0;
|
||||
|
||||
// Private
|
||||
this._pbf = pbf;
|
||||
this._keys = [];
|
||||
this._values = [];
|
||||
this._features = [];
|
||||
|
||||
pbf.readFields(readLayer, this, end);
|
||||
|
||||
this.length = this._features.length;
|
||||
}
|
||||
|
||||
function readLayer(tag, layer, pbf) {
|
||||
if (tag === 15) layer.version = pbf.readVarint();
|
||||
else if (tag === 1) layer.name = pbf.readString();
|
||||
else if (tag === 5) layer.extent = pbf.readVarint();
|
||||
else if (tag === 2) layer._features.push(pbf.pos);
|
||||
else if (tag === 3) layer._keys.push(pbf.readString());
|
||||
else if (tag === 4) layer._values.push(readValueMessage(pbf));
|
||||
}
|
||||
|
||||
function readValueMessage(pbf) {
|
||||
var value = null,
|
||||
end = pbf.readVarint() + pbf.pos;
|
||||
|
||||
while (pbf.pos < end) {
|
||||
var tag = pbf.readVarint() >> 3;
|
||||
|
||||
value = tag === 1 ? pbf.readString() :
|
||||
tag === 2 ? pbf.readFloat() :
|
||||
tag === 3 ? pbf.readDouble() :
|
||||
tag === 4 ? pbf.readVarint64() :
|
||||
tag === 5 ? pbf.readVarint() :
|
||||
tag === 6 ? pbf.readSVarint() :
|
||||
tag === 7 ? pbf.readBoolean() : null;
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
// return feature `i` from this layer as a `VectorTileFeature`
|
||||
VectorTileLayer.prototype.feature = function(i) {
|
||||
if (i < 0 || i >= this._features.length) throw new Error('feature index out of bounds');
|
||||
|
||||
this._pbf.pos = this._features[i];
|
||||
|
||||
var end = this._pbf.readVarint() + this._pbf.pos;
|
||||
return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
|
||||
};
|
||||
|
||||
},{"./vectortilefeature.js":3}],5:[function(require,module,exports){
|
||||
'use strict';
|
||||
|
||||
module.exports = Point;
|
||||
|
||||
function Point(x, y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
|
||||
Point.prototype = {
|
||||
clone: function() { return new Point(this.x, this.y); },
|
||||
|
||||
add: function(p) { return this.clone()._add(p); },
|
||||
sub: function(p) { return this.clone()._sub(p); },
|
||||
mult: function(k) { return this.clone()._mult(k); },
|
||||
div: function(k) { return this.clone()._div(k); },
|
||||
rotate: function(a) { return this.clone()._rotate(a); },
|
||||
matMult: function(m) { return this.clone()._matMult(m); },
|
||||
unit: function() { return this.clone()._unit(); },
|
||||
perp: function() { return this.clone()._perp(); },
|
||||
round: function() { return this.clone()._round(); },
|
||||
|
||||
mag: function() {
|
||||
return Math.sqrt(this.x * this.x + this.y * this.y);
|
||||
},
|
||||
|
||||
equals: function(p) {
|
||||
return this.x === p.x &&
|
||||
this.y === p.y;
|
||||
},
|
||||
|
||||
dist: function(p) {
|
||||
return Math.sqrt(this.distSqr(p));
|
||||
},
|
||||
|
||||
distSqr: function(p) {
|
||||
var dx = p.x - this.x,
|
||||
dy = p.y - this.y;
|
||||
return dx * dx + dy * dy;
|
||||
},
|
||||
|
||||
angle: function() {
|
||||
return Math.atan2(this.y, this.x);
|
||||
},
|
||||
|
||||
angleTo: function(b) {
|
||||
return Math.atan2(this.y - b.y, this.x - b.x);
|
||||
},
|
||||
|
||||
angleWith: function(b) {
|
||||
return this.angleWithSep(b.x, b.y);
|
||||
},
|
||||
|
||||
// Find the angle of the two vectors, solving the formula for the cross product a x b = |a||b|sin(θ) for θ.
|
||||
angleWithSep: function(x, y) {
|
||||
return Math.atan2(
|
||||
this.x * y - this.y * x,
|
||||
this.x * x + this.y * y);
|
||||
},
|
||||
|
||||
_matMult: function(m) {
|
||||
var x = m[0] * this.x + m[1] * this.y,
|
||||
y = m[2] * this.x + m[3] * this.y;
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
return this;
|
||||
},
|
||||
|
||||
_add: function(p) {
|
||||
this.x += p.x;
|
||||
this.y += p.y;
|
||||
return this;
|
||||
},
|
||||
|
||||
_sub: function(p) {
|
||||
this.x -= p.x;
|
||||
this.y -= p.y;
|
||||
return this;
|
||||
},
|
||||
|
||||
_mult: function(k) {
|
||||
this.x *= k;
|
||||
this.y *= k;
|
||||
return this;
|
||||
},
|
||||
|
||||
_div: function(k) {
|
||||
this.x /= k;
|
||||
this.y /= k;
|
||||
return this;
|
||||
},
|
||||
|
||||
_unit: function() {
|
||||
this._div(this.mag());
|
||||
return this;
|
||||
},
|
||||
|
||||
_perp: function() {
|
||||
var y = this.y;
|
||||
this.y = this.x;
|
||||
this.x = -y;
|
||||
return this;
|
||||
},
|
||||
|
||||
_rotate: function(angle) {
|
||||
var cos = Math.cos(angle),
|
||||
sin = Math.sin(angle),
|
||||
x = cos * this.x - sin * this.y,
|
||||
y = sin * this.x + cos * this.y;
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
return this;
|
||||
},
|
||||
|
||||
_round: function() {
|
||||
this.x = Math.round(this.x);
|
||||
this.y = Math.round(this.y);
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
||||
// constructs Point from an array if necessary
|
||||
Point.convert = function (a) {
|
||||
if (a instanceof Point) {
|
||||
return a;
|
||||
}
|
||||
if (Array.isArray(a)) {
|
||||
return new Point(a[0], a[1]);
|
||||
}
|
||||
return a;
|
||||
};
|
||||
|
||||
},{}]},{},[1])(1)
|
||||
});
|
||||
ol.ext.vectortile = module.exports;
|
||||
})();
|
||||
Reference in New Issue
Block a user