sgauthier
6e64e138e2
All checks were successful
Publish To Prod / deploy_and_publish (push) Successful in 35s
763 lines
29 KiB
JavaScript
763 lines
29 KiB
JavaScript
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
/**
|
|
* @module ol/format/WKB
|
|
*/
|
|
import Feature from '../Feature.js';
|
|
import FeatureFormat, { transformGeometryWithOptions } from './Feature.js';
|
|
import GeometryCollection from '../geom/GeometryCollection.js';
|
|
import GeometryLayout from '../geom/GeometryLayout.js';
|
|
import LineString from '../geom/LineString.js';
|
|
import MultiLineString from '../geom/MultiLineString.js';
|
|
import MultiPoint from '../geom/MultiPoint.js';
|
|
import MultiPolygon from '../geom/MultiPolygon.js';
|
|
import Point from '../geom/Point.js';
|
|
import Polygon from '../geom/Polygon.js';
|
|
import { get as getProjection } from '../proj.js';
|
|
import SimpleGeometry from '../geom/SimpleGeometry.js';
|
|
import { assign } from '../obj.js';
|
|
// WKB spec: https://www.ogc.org/standards/sfa
|
|
// EWKB spec: https://raw.githubusercontent.com/postgis/postgis/2.1.0/doc/ZMSgeoms.txt
|
|
/**
|
|
* @const
|
|
* @enum {number}
|
|
*/
|
|
var WKBGeometryType = {
|
|
POINT: 1,
|
|
LINE_STRING: 2,
|
|
POLYGON: 3,
|
|
MULTI_POINT: 4,
|
|
MULTI_LINE_STRING: 5,
|
|
MULTI_POLYGON: 6,
|
|
GEOMETRY_COLLECTION: 7,
|
|
/*
|
|
CIRCULAR_STRING: 8,
|
|
COMPOUND_CURVE: 9,
|
|
CURVE_POLYGON: 10,
|
|
|
|
MULTI_CURVE: 11,
|
|
MULTI_SURFACE: 12,
|
|
CURVE: 13,
|
|
SURFACE: 14,
|
|
*/
|
|
POLYHEDRAL_SURFACE: 15,
|
|
TIN: 16,
|
|
TRIANGLE: 17,
|
|
};
|
|
var WkbReader = /** @class */ (function () {
|
|
/**
|
|
* @param {DataView} view source to read
|
|
*/
|
|
function WkbReader(view) {
|
|
this.view_ = view;
|
|
this.pos_ = 0;
|
|
this.initialized_ = false;
|
|
this.isLittleEndian_ = false;
|
|
this.hasZ_ = false;
|
|
this.hasM_ = false;
|
|
/** @type {number|null} */
|
|
this.srid_ = null;
|
|
this.layout_ = GeometryLayout.XY;
|
|
}
|
|
/**
|
|
* @return {number} value
|
|
*/
|
|
WkbReader.prototype.readUint8 = function () {
|
|
return this.view_.getUint8(this.pos_++);
|
|
};
|
|
/**
|
|
* @param {boolean} [isLittleEndian] Whether read value as little endian
|
|
* @return {number} value
|
|
*/
|
|
WkbReader.prototype.readUint32 = function (isLittleEndian) {
|
|
return this.view_.getUint32((this.pos_ += 4) - 4, isLittleEndian !== undefined ? isLittleEndian : this.isLittleEndian_);
|
|
};
|
|
/**
|
|
* @param {boolean} [isLittleEndian] Whether read value as little endian
|
|
* @return {number} value
|
|
*/
|
|
WkbReader.prototype.readDouble = function (isLittleEndian) {
|
|
return this.view_.getFloat64((this.pos_ += 8) - 8, isLittleEndian !== undefined ? isLittleEndian : this.isLittleEndian_);
|
|
};
|
|
/**
|
|
* @return {import('../coordinate.js').Coordinate} coords for Point
|
|
*/
|
|
WkbReader.prototype.readPoint = function () {
|
|
/** @type import('../coordinate.js').Coordinate */
|
|
var coords = [];
|
|
coords.push(this.readDouble());
|
|
coords.push(this.readDouble());
|
|
if (this.hasZ_) {
|
|
coords.push(this.readDouble());
|
|
}
|
|
if (this.hasM_) {
|
|
coords.push(this.readDouble());
|
|
}
|
|
return coords;
|
|
};
|
|
/**
|
|
* @return {Array<import('../coordinate.js').Coordinate>} coords for LineString / LinearRing
|
|
*/
|
|
WkbReader.prototype.readLineString = function () {
|
|
var numPoints = this.readUint32();
|
|
/** @type Array<import('../coordinate.js').Coordinate> */
|
|
var coords = [];
|
|
for (var i = 0; i < numPoints; i++) {
|
|
coords.push(this.readPoint());
|
|
}
|
|
return coords;
|
|
};
|
|
/**
|
|
* @return {Array<Array<import('../coordinate.js').Coordinate>>} coords for Polygon like
|
|
*/
|
|
WkbReader.prototype.readPolygon = function () {
|
|
var numRings = this.readUint32();
|
|
/** @type Array<Array<import('../coordinate.js').Coordinate>> */
|
|
var rings = [];
|
|
for (var i = 0; i < numRings; i++) {
|
|
rings.push(this.readLineString()); // as a LinearRing
|
|
}
|
|
return rings;
|
|
};
|
|
/**
|
|
* @param {number} [expectedTypeId] Expected WKB Type ID
|
|
* @return {number} WKB Type ID
|
|
*/
|
|
WkbReader.prototype.readWkbHeader = function (expectedTypeId) {
|
|
var byteOrder = this.readUint8();
|
|
var isLittleEndian = byteOrder > 0;
|
|
var wkbType = this.readUint32(isLittleEndian);
|
|
var wkbTypeThousandth = Math.floor((wkbType & 0x0fffffff) / 1000);
|
|
var hasZ = Boolean(wkbType & 0x80000000) ||
|
|
wkbTypeThousandth === 1 ||
|
|
wkbTypeThousandth === 3;
|
|
var hasM = Boolean(wkbType & 0x40000000) ||
|
|
wkbTypeThousandth === 2 ||
|
|
wkbTypeThousandth === 3;
|
|
var hasSRID = Boolean(wkbType & 0x20000000);
|
|
var typeId = (wkbType & 0x0fffffff) % 1000; // Assume 1000 is an upper limit for type ID
|
|
var layout = ['XY', hasZ ? 'Z' : '', hasM ? 'M' : ''].join('');
|
|
var srid = hasSRID ? this.readUint32(isLittleEndian) : null;
|
|
if (expectedTypeId !== undefined && expectedTypeId !== typeId) {
|
|
throw new Error('Unexpected WKB geometry type ' + typeId);
|
|
}
|
|
if (this.initialized_) {
|
|
// sanity checks
|
|
if (this.isLittleEndian_ !== isLittleEndian) {
|
|
throw new Error('Inconsistent endian');
|
|
}
|
|
if (this.layout_ !== layout) {
|
|
throw new Error('Inconsistent geometry layout');
|
|
}
|
|
if (srid && this.srid_ !== srid) {
|
|
throw new Error('Inconsistent coordinate system (SRID)');
|
|
}
|
|
}
|
|
else {
|
|
this.isLittleEndian_ = isLittleEndian;
|
|
this.hasZ_ = hasZ;
|
|
this.hasM_ = hasM;
|
|
this.layout_ = layout;
|
|
this.srid_ = srid;
|
|
this.initialized_ = true;
|
|
}
|
|
return typeId;
|
|
};
|
|
/**
|
|
* @param {number} typeId WKB Type ID
|
|
* @return {any} values read
|
|
*/
|
|
WkbReader.prototype.readWkbPayload = function (typeId) {
|
|
switch (typeId) {
|
|
case WKBGeometryType.POINT:
|
|
return this.readPoint();
|
|
case WKBGeometryType.LINE_STRING:
|
|
return this.readLineString();
|
|
case WKBGeometryType.POLYGON:
|
|
case WKBGeometryType.TRIANGLE:
|
|
return this.readPolygon();
|
|
case WKBGeometryType.MULTI_POINT:
|
|
return this.readMultiPoint();
|
|
case WKBGeometryType.MULTI_LINE_STRING:
|
|
return this.readMultiLineString();
|
|
case WKBGeometryType.MULTI_POLYGON:
|
|
case WKBGeometryType.POLYHEDRAL_SURFACE:
|
|
case WKBGeometryType.TIN:
|
|
return this.readMultiPolygon();
|
|
case WKBGeometryType.GEOMETRY_COLLECTION:
|
|
return this.readGeometryCollection();
|
|
default:
|
|
throw new Error('Unsupported WKB geometry type ' + typeId + ' is found');
|
|
}
|
|
};
|
|
/**
|
|
* @param {number} expectedTypeId Expected WKB Type ID
|
|
* @return {any} values read
|
|
*/
|
|
WkbReader.prototype.readWkbBlock = function (expectedTypeId) {
|
|
return this.readWkbPayload(this.readWkbHeader(expectedTypeId));
|
|
};
|
|
/**
|
|
* @param {Function} reader reader function for each item
|
|
* @param {number} [expectedTypeId] Expected WKB Type ID
|
|
* @return {any} values read
|
|
*/
|
|
WkbReader.prototype.readWkbCollection = function (reader, expectedTypeId) {
|
|
var num = this.readUint32();
|
|
var items = [];
|
|
for (var i = 0; i < num; i++) {
|
|
var result = reader.call(this, expectedTypeId);
|
|
if (result) {
|
|
items.push(result);
|
|
}
|
|
}
|
|
return items;
|
|
};
|
|
/**
|
|
* @return {Array<import('../coordinate.js').Coordinate>} coords for MultiPoint
|
|
*/
|
|
WkbReader.prototype.readMultiPoint = function () {
|
|
return this.readWkbCollection(this.readWkbBlock, WKBGeometryType.POINT);
|
|
};
|
|
/**
|
|
* @return {Array<Array<import('../coordinate.js').Coordinate>>} coords for MultiLineString like
|
|
*/
|
|
WkbReader.prototype.readMultiLineString = function () {
|
|
return this.readWkbCollection(this.readWkbBlock, WKBGeometryType.LINE_STRING);
|
|
};
|
|
/**
|
|
* @return {Array<Array<Array<import('../coordinate.js').Coordinate>>>} coords for MultiPolygon like
|
|
*/
|
|
WkbReader.prototype.readMultiPolygon = function () {
|
|
return this.readWkbCollection(this.readWkbBlock, WKBGeometryType.POLYGON);
|
|
};
|
|
/**
|
|
* @return {Array<import('../geom/Geometry.js').default>} array of geometries
|
|
*/
|
|
WkbReader.prototype.readGeometryCollection = function () {
|
|
return this.readWkbCollection(this.readGeometry);
|
|
};
|
|
/**
|
|
* @return {import('../geom/Geometry.js').default} geometry
|
|
*/
|
|
WkbReader.prototype.readGeometry = function () {
|
|
var typeId = this.readWkbHeader();
|
|
var result = this.readWkbPayload(typeId);
|
|
switch (typeId) {
|
|
case WKBGeometryType.POINT:
|
|
return new Point(
|
|
/** @type {import('../coordinate.js').Coordinate} */ (result), this.layout_);
|
|
case WKBGeometryType.LINE_STRING:
|
|
return new LineString(
|
|
/** @type {Array<import('../coordinate.js').Coordinate>} */ (result), this.layout_);
|
|
case WKBGeometryType.POLYGON:
|
|
case WKBGeometryType.TRIANGLE:
|
|
return new Polygon(
|
|
/** @type {Array<Array<import('../coordinate.js').Coordinate>>} */ (result), this.layout_);
|
|
case WKBGeometryType.MULTI_POINT:
|
|
return new MultiPoint(
|
|
/** @type {Array<import('../coordinate.js').Coordinate>} */ (result), this.layout_);
|
|
case WKBGeometryType.MULTI_LINE_STRING:
|
|
return new MultiLineString(
|
|
/** @type {Array<Array<import('../coordinate.js').Coordinate>>} */ (result), this.layout_);
|
|
case WKBGeometryType.MULTI_POLYGON:
|
|
case WKBGeometryType.POLYHEDRAL_SURFACE:
|
|
case WKBGeometryType.TIN:
|
|
return new MultiPolygon(
|
|
/** @type {Array<Array<Array<import('../coordinate.js').Coordinate>>>} */ (result), this.layout_);
|
|
case WKBGeometryType.GEOMETRY_COLLECTION:
|
|
return new GeometryCollection(
|
|
/** @type {Array<import('../geom/Geometry.js').default>} */ (result));
|
|
default:
|
|
return null;
|
|
}
|
|
};
|
|
/**
|
|
* @return {number|null} SRID in the EWKB. `null` if not defined.
|
|
*/
|
|
WkbReader.prototype.getSrid = function () {
|
|
return this.srid_;
|
|
};
|
|
return WkbReader;
|
|
}());
|
|
var WkbWriter = /** @class */ (function () {
|
|
/**
|
|
* @type {Object}
|
|
* @property {string} [layout] geometryLayout
|
|
* @property {boolean} [littleEndian=true] littleEndian
|
|
* @property {boolean} [ewkb=true] Whether writes in EWKB format
|
|
* @property {Object} [nodata] NoData value for each axes
|
|
* @param {Object} opts options
|
|
*/
|
|
function WkbWriter(opts) {
|
|
opts = opts || {};
|
|
/** @type {string} */
|
|
this.layout_ = opts.layout;
|
|
this.isLittleEndian_ = opts.littleEndian !== false;
|
|
this.isEWKB_ = opts.ewkb !== false;
|
|
/** @type {Array<Array<number>>} */
|
|
this.writeQueue_ = [];
|
|
/**
|
|
* @type {Object}
|
|
* @property {number} X NoData value for X
|
|
* @property {number} Y NoData value for Y
|
|
* @property {number} Z NoData value for Z
|
|
* @property {number} M NoData value for M
|
|
*/
|
|
this.nodata_ = assign({ X: 0, Y: 0, Z: 0, M: 0 }, opts.nodata);
|
|
}
|
|
/**
|
|
* @param {number} value value
|
|
*/
|
|
WkbWriter.prototype.writeUint8 = function (value) {
|
|
this.writeQueue_.push([1, value]);
|
|
};
|
|
/**
|
|
* @param {number} value value
|
|
*/
|
|
WkbWriter.prototype.writeUint32 = function (value) {
|
|
this.writeQueue_.push([4, value]);
|
|
};
|
|
/**
|
|
* @param {number} value value
|
|
*/
|
|
WkbWriter.prototype.writeDouble = function (value) {
|
|
this.writeQueue_.push([8, value]);
|
|
};
|
|
/**
|
|
* @param {import('../coordinate.js').Coordinate} coords coords
|
|
* @param {import("../geom/GeometryLayout").default} layout layout
|
|
*/
|
|
WkbWriter.prototype.writePoint = function (coords, layout) {
|
|
/**
|
|
* @type {Object}
|
|
* @property {number} X NoData value for X
|
|
* @property {number} Y NoData value for Y
|
|
* @property {number} [Z] NoData value for Z
|
|
* @property {number} [M] NoData value for M
|
|
*/
|
|
var coordsObj = assign.apply(null, layout.split('').map(function (axis, idx) {
|
|
var _a;
|
|
return (_a = {}, _a[axis] = coords[idx], _a);
|
|
}));
|
|
for (var _i = 0, _a = this.layout_; _i < _a.length; _i++) {
|
|
var axis = _a[_i];
|
|
this.writeDouble(axis in coordsObj ? coordsObj[axis] : this.nodata_[axis]);
|
|
}
|
|
};
|
|
/**
|
|
* @param {Array<import('../coordinate.js').Coordinate>} coords coords
|
|
* @param {import("../geom/GeometryLayout").default} layout layout
|
|
*/
|
|
WkbWriter.prototype.writeLineString = function (coords, layout) {
|
|
this.writeUint32(coords.length); // numPoints
|
|
for (var i = 0; i < coords.length; i++) {
|
|
this.writePoint(coords[i], layout);
|
|
}
|
|
};
|
|
/**
|
|
* @param {Array<Array<import('../coordinate.js').Coordinate>>} rings rings
|
|
* @param {import("../geom/GeometryLayout").default} layout layout
|
|
*/
|
|
WkbWriter.prototype.writePolygon = function (rings, layout) {
|
|
this.writeUint32(rings.length); // numRings
|
|
for (var i = 0; i < rings.length; i++) {
|
|
this.writeLineString(rings[i], layout); // as a LinearRing
|
|
}
|
|
};
|
|
/**
|
|
* @param {number} wkbType WKB Type ID
|
|
* @param {number} [srid] SRID
|
|
*/
|
|
WkbWriter.prototype.writeWkbHeader = function (wkbType, srid) {
|
|
wkbType %= 1000; // Assume 1000 is an upper limit for type ID
|
|
if (this.layout_.indexOf('Z') >= 0) {
|
|
wkbType += this.isEWKB_ ? 0x80000000 : 1000;
|
|
}
|
|
if (this.layout_.indexOf('M') >= 0) {
|
|
wkbType += this.isEWKB_ ? 0x40000000 : 2000;
|
|
}
|
|
if (this.isEWKB_ && Number.isInteger(srid)) {
|
|
wkbType |= 0x20000000;
|
|
}
|
|
this.writeUint8(this.isLittleEndian_ ? 1 : 0);
|
|
this.writeUint32(wkbType);
|
|
if (this.isEWKB_ && Number.isInteger(srid)) {
|
|
this.writeUint32(srid);
|
|
}
|
|
};
|
|
/**
|
|
* @param {Array<import('../coordinate.js').Coordinate>} coords coords
|
|
* @param {string} layout layout
|
|
*/
|
|
WkbWriter.prototype.writeMultiPoint = function (coords, layout) {
|
|
this.writeUint32(coords.length); // numItems
|
|
for (var i = 0; i < coords.length; i++) {
|
|
this.writeWkbHeader(1);
|
|
this.writePoint(coords[i], layout);
|
|
}
|
|
};
|
|
/**
|
|
* @param {Array<Array<import('../coordinate.js').Coordinate>>} coords coords
|
|
* @param {string} layout layout
|
|
*/
|
|
WkbWriter.prototype.writeMultiLineString = function (coords, layout) {
|
|
this.writeUint32(coords.length); // numItems
|
|
for (var i = 0; i < coords.length; i++) {
|
|
this.writeWkbHeader(2);
|
|
this.writeLineString(coords[i], layout);
|
|
}
|
|
};
|
|
/**
|
|
* @param {Array<Array<Array<import('../coordinate.js').Coordinate>>>} coords coords
|
|
* @param {string} layout layout
|
|
*/
|
|
WkbWriter.prototype.writeMultiPolygon = function (coords, layout) {
|
|
this.writeUint32(coords.length); // numItems
|
|
for (var i = 0; i < coords.length; i++) {
|
|
this.writeWkbHeader(3);
|
|
this.writePolygon(coords[i], layout);
|
|
}
|
|
};
|
|
/**
|
|
* @param {Array<import('../geom/Geometry.js').default>} geometries geometries
|
|
*/
|
|
WkbWriter.prototype.writeGeometryCollection = function (geometries) {
|
|
this.writeUint32(geometries.length); // numItems
|
|
for (var i = 0; i < geometries.length; i++) {
|
|
this.writeGeometry(geometries[i]);
|
|
}
|
|
};
|
|
/**
|
|
* @param {import("../geom/Geometry.js").default} geom geometry
|
|
* @param {import("../geom/GeometryLayout.js").default} [layout] layout
|
|
* @return {import("../geom/GeometryLayout.js").default} minumum layout made by common axes
|
|
*/
|
|
WkbWriter.prototype.findMinimumLayout = function (geom, layout) {
|
|
if (layout === void 0) { layout = GeometryLayout.XYZM; }
|
|
/**
|
|
* @param {import("../geom/GeometryLayout.js").default} a A
|
|
* @param {import("../geom/GeometryLayout.js").default} b B
|
|
* @return {import("../geom/GeometryLayout.js").default} minumum layout made by common axes
|
|
*/
|
|
var GeometryLayout_min = function (a, b) {
|
|
if (a === b) {
|
|
return a;
|
|
}
|
|
if (a === GeometryLayout.XYZM) {
|
|
// anything `b` is minimum
|
|
return b;
|
|
}
|
|
if (b === GeometryLayout.XYZM) {
|
|
// anything `a` is minimum
|
|
return a;
|
|
}
|
|
// otherwise, incompatible
|
|
return GeometryLayout.XY;
|
|
};
|
|
if (geom instanceof SimpleGeometry) {
|
|
return GeometryLayout_min(geom.getLayout(), layout);
|
|
}
|
|
if (geom instanceof GeometryCollection) {
|
|
var geoms = geom.getGeometriesArray();
|
|
for (var i = 0; i < geoms.length && layout !== GeometryLayout.XY; i++) {
|
|
layout = this.findMinimumLayout(geoms[i], layout);
|
|
}
|
|
}
|
|
return layout;
|
|
};
|
|
/**
|
|
* @param {import("../geom/Geometry.js").default} geom geometry
|
|
* @param {number} [srid] SRID
|
|
*/
|
|
WkbWriter.prototype.writeGeometry = function (geom, srid) {
|
|
/**
|
|
* @type {Object<import("../geom/Geometry.js").Type, WKBGeometryType>}
|
|
*/
|
|
var wkblut = {
|
|
Point: WKBGeometryType.POINT,
|
|
LineString: WKBGeometryType.LINE_STRING,
|
|
Polygon: WKBGeometryType.POLYGON,
|
|
MultiPoint: WKBGeometryType.MULTI_POINT,
|
|
MultiLineString: WKBGeometryType.MULTI_LINE_STRING,
|
|
MultiPolygon: WKBGeometryType.MULTI_POLYGON,
|
|
GeometryCollection: WKBGeometryType.GEOMETRY_COLLECTION,
|
|
};
|
|
var geomType = geom.getType();
|
|
var typeId = wkblut[geomType];
|
|
if (!typeId) {
|
|
throw new Error('GeometryType ' + geomType + ' is not supported');
|
|
}
|
|
// first call of writeGeometry() traverse whole geometries to determine its output layout if not specified on constructor.
|
|
if (!this.layout_) {
|
|
this.layout_ = this.findMinimumLayout(geom);
|
|
}
|
|
this.writeWkbHeader(typeId, srid);
|
|
if (geom instanceof SimpleGeometry) {
|
|
var writerLUT = {
|
|
Point: this.writePoint,
|
|
LineString: this.writeLineString,
|
|
Polygon: this.writePolygon,
|
|
MultiPoint: this.writeMultiPoint,
|
|
MultiLineString: this.writeMultiLineString,
|
|
MultiPolygon: this.writeMultiPolygon,
|
|
};
|
|
writerLUT[geomType].call(this, geom.getCoordinates(), geom.getLayout());
|
|
}
|
|
else if (geom instanceof GeometryCollection) {
|
|
this.writeGeometryCollection(geom.getGeometriesArray());
|
|
}
|
|
};
|
|
WkbWriter.prototype.getBuffer = function () {
|
|
var _this = this;
|
|
var byteLength = this.writeQueue_.reduce(function (acc, item) { return acc + item[0]; }, 0);
|
|
var buffer = new ArrayBuffer(byteLength);
|
|
var view = new DataView(buffer);
|
|
var pos = 0;
|
|
this.writeQueue_.forEach(function (item) {
|
|
switch (item[0]) {
|
|
case 1:
|
|
view.setUint8(pos, item[1]);
|
|
break;
|
|
case 4:
|
|
view.setUint32(pos, item[1], _this.isLittleEndian_);
|
|
break;
|
|
case 8:
|
|
view.setFloat64(pos, item[1], _this.isLittleEndian_);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
pos += item[0];
|
|
});
|
|
return buffer;
|
|
};
|
|
return WkbWriter;
|
|
}());
|
|
/**
|
|
* @typedef {Object} Options
|
|
* @property {boolean} [splitCollection=false] Whether to split GeometryCollections into multiple features on reading.
|
|
* @property {boolean} [hex=true] Returns hex string instead of ArrayBuffer for output. This also is used as a hint internally whether it should load contents as text or ArrayBuffer on reading.
|
|
* @property {boolean} [littleEndian=true] Use littleEndian for output.
|
|
* @property {boolean} [ewkb=true] Use EWKB format for output.
|
|
* @property {import("../geom/GeometryLayout").default} [geometryLayout=null] Use specific coordinate layout for output features (null: auto detect)
|
|
* @property {number} [nodataZ=0] If the `geometryLayout` doesn't match with geometry to be output, this value is used to fill missing coordinate value of Z.
|
|
* @property {number} [nodataM=0] If the `geometryLayout` doesn't match with geometry to be output, this value is used to fill missing coordinate value of M.
|
|
* @property {number|boolean} [srid=true] SRID for output. Specify integer value to enforce the value as a SRID. Specify `true` to extract from `dataProjection`. `false` to suppress the output. This option only takes effect when `ewkb` is `true`.
|
|
*/
|
|
/**
|
|
* @classdesc
|
|
* Geometry format for reading and writing data in the `Well-Known Binary` (WKB) format.
|
|
* Also supports `Extended Well-Known Binary` (EWKB) format, used in PostGIS for example.
|
|
*
|
|
* @api
|
|
*/
|
|
var WKB = /** @class */ (function (_super) {
|
|
__extends(WKB, _super);
|
|
/**
|
|
* @param {Options} [opt_options] Optional configuration object.
|
|
*/
|
|
function WKB(opt_options) {
|
|
var _this = _super.call(this) || this;
|
|
var options = opt_options ? opt_options : {};
|
|
_this.splitCollection = Boolean(options.splitCollection);
|
|
_this.viewCache_ = null;
|
|
_this.hex_ = options.hex !== false;
|
|
_this.littleEndian_ = options.littleEndian !== false;
|
|
_this.ewkb_ = options.ewkb !== false;
|
|
_this.layout_ = options.geometryLayout; // null for auto detect
|
|
_this.nodataZ_ = options.nodataZ || 0;
|
|
_this.nodataM_ = options.nodataM || 0;
|
|
_this.srid_ = options.srid;
|
|
return _this;
|
|
}
|
|
/**
|
|
* @return {import("./Feature.js").Type} Format.
|
|
*/
|
|
WKB.prototype.getType = function () {
|
|
return this.hex_ ? 'text' : 'arraybuffer';
|
|
};
|
|
/**
|
|
* Read a single feature from a source.
|
|
*
|
|
* @param {string|ArrayBuffer|ArrayBufferView} source Source.
|
|
* @param {import("./Feature.js").ReadOptions} [opt_options] Read options.
|
|
* @return {import("../Feature.js").default} Feature.
|
|
* @api
|
|
*/
|
|
WKB.prototype.readFeature = function (source, opt_options) {
|
|
return new Feature({
|
|
geometry: this.readGeometry(source, opt_options),
|
|
});
|
|
};
|
|
/**
|
|
* Read all features from a source.
|
|
*
|
|
* @param {string|ArrayBuffer|ArrayBufferView} source Source.
|
|
* @param {import("./Feature.js").ReadOptions} [opt_options] Read options.
|
|
* @return {Array<import("../Feature.js").default>} Features.
|
|
* @api
|
|
*/
|
|
WKB.prototype.readFeatures = function (source, opt_options) {
|
|
var geometries = [];
|
|
var geometry = this.readGeometry(source, opt_options);
|
|
if (this.splitCollection && geometry instanceof GeometryCollection) {
|
|
geometries = geometry.getGeometriesArray();
|
|
}
|
|
else {
|
|
geometries = [geometry];
|
|
}
|
|
return geometries.map(function (geometry) { return new Feature({ geometry: geometry }); });
|
|
};
|
|
/**
|
|
* Read a single geometry from a source.
|
|
*
|
|
* @param {string|ArrayBuffer|ArrayBufferView} source Source.
|
|
* @param {import("./Feature.js").ReadOptions} [opt_options] Read options.
|
|
* @return {import("../geom/Geometry.js").default} Geometry.
|
|
* @api
|
|
*/
|
|
WKB.prototype.readGeometry = function (source, opt_options) {
|
|
var view = getDataView(source);
|
|
if (!view) {
|
|
return null;
|
|
}
|
|
var reader = new WkbReader(view);
|
|
var geometry = reader.readGeometry();
|
|
this.viewCache_ = view; // cache for internal subsequent call of readProjection()
|
|
var options = this.getReadOptions(source, opt_options);
|
|
this.viewCache_ = null; // release
|
|
return transformGeometryWithOptions(geometry, false, options);
|
|
};
|
|
/**
|
|
* Read the projection from a source.
|
|
*
|
|
* @param {string|ArrayBuffer|ArrayBufferView} source Source.
|
|
* @return {import("../proj/Projection.js").default|undefined} Projection.
|
|
* @api
|
|
*/
|
|
WKB.prototype.readProjection = function (source) {
|
|
var view = this.viewCache_ || getDataView(source);
|
|
if (!view) {
|
|
return undefined;
|
|
}
|
|
var reader = new WkbReader(view);
|
|
reader.readWkbHeader();
|
|
return ((reader.getSrid() && getProjection('EPSG:' + reader.getSrid())) ||
|
|
undefined);
|
|
};
|
|
/**
|
|
* Encode a feature in this format.
|
|
*
|
|
* @param {import("../Feature.js").default} feature Feature.
|
|
* @param {import("./Feature.js").WriteOptions} [opt_options] Write options.
|
|
* @return {string|ArrayBuffer} Result.
|
|
* @api
|
|
*/
|
|
WKB.prototype.writeFeature = function (feature, opt_options) {
|
|
return this.writeGeometry(feature.getGeometry(), opt_options);
|
|
};
|
|
/**
|
|
* Encode an array of features in this format.
|
|
*
|
|
* @param {Array<import("../Feature.js").default>} features Features.
|
|
* @param {import("./Feature.js").WriteOptions} [opt_options] Write options.
|
|
* @return {string|ArrayBuffer} Result.
|
|
* @api
|
|
*/
|
|
WKB.prototype.writeFeatures = function (features, opt_options) {
|
|
return this.writeGeometry(new GeometryCollection(features.map(function (f) { return f.getGeometry(); })), opt_options);
|
|
};
|
|
/**
|
|
* Write a single geometry in this format.
|
|
*
|
|
* @param {import("../geom/Geometry.js").default} geometry Geometry.
|
|
* @param {import("./Feature.js").WriteOptions} [opt_options] Write options.
|
|
* @return {string|ArrayBuffer} Result.
|
|
* @api
|
|
*/
|
|
WKB.prototype.writeGeometry = function (geometry, opt_options) {
|
|
var options = this.adaptOptions(opt_options);
|
|
var writer = new WkbWriter({
|
|
layout: this.layout_,
|
|
littleEndian: this.littleEndian_,
|
|
ewkb: this.ewkb_,
|
|
nodata: {
|
|
Z: this.nodataZ_,
|
|
M: this.nodataM_,
|
|
},
|
|
});
|
|
// extract SRID from `dataProjection`
|
|
var srid = Number.isInteger(this.srid_) ? Number(this.srid_) : null;
|
|
if (this.srid_ !== false && !Number.isInteger(this.srid_)) {
|
|
var dataProjection = options.dataProjection && getProjection(options.dataProjection);
|
|
if (dataProjection) {
|
|
var code = dataProjection.getCode();
|
|
if (code.indexOf('EPSG:') === 0) {
|
|
srid = Number(code.substring(5));
|
|
}
|
|
}
|
|
}
|
|
writer.writeGeometry(transformGeometryWithOptions(geometry, true, options), srid);
|
|
var buffer = writer.getBuffer();
|
|
return this.hex_ ? encodeHexString(buffer) : buffer;
|
|
};
|
|
return WKB;
|
|
}(FeatureFormat));
|
|
/**
|
|
* @param {ArrayBuffer} buffer source buffer
|
|
* @return {string} encoded hex string
|
|
*/
|
|
function encodeHexString(buffer) {
|
|
var view = new Uint8Array(buffer);
|
|
return Array.from(view.values())
|
|
.map(function (x) { return (x < 16 ? '0' : '') + Number(x).toString(16).toUpperCase(); })
|
|
.join('');
|
|
}
|
|
/**
|
|
* @param {string} text source text
|
|
* @return {DataView} decoded binary buffer
|
|
*/
|
|
function decodeHexString(text) {
|
|
var buffer = new Uint8Array(text.length / 2);
|
|
for (var i = 0; i < text.length / 2; i++) {
|
|
buffer[i] = parseInt(text.substr(i * 2, 2), 16);
|
|
}
|
|
return new DataView(buffer.buffer);
|
|
}
|
|
/**
|
|
* @param {string | ArrayBuffer | ArrayBufferView} source source
|
|
* @return {DataView} data view
|
|
*/
|
|
function getDataView(source) {
|
|
if (typeof source === 'string') {
|
|
return decodeHexString(source);
|
|
}
|
|
else if (ArrayBuffer.isView(source)) {
|
|
if (source instanceof DataView) {
|
|
return source;
|
|
}
|
|
return new DataView(source.buffer, source.byteOffset, source.byteLength);
|
|
}
|
|
else if (source instanceof ArrayBuffer) {
|
|
return new DataView(source);
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
export default WKB;
|
|
//# sourceMappingURL=WKB.js.map
|