5332 lines
159 KiB
JavaScript
5332 lines
159 KiB
JavaScript
/*!
|
||
* author: FDD <smileFDD@gmail.com>
|
||
* ol-plot v2.1.3
|
||
* build-time: 2018-3-27 21:54
|
||
* LICENSE: MIT
|
||
* (c) 2016-2018 https://sakitam-fdd.github.io/ol-plot
|
||
*/
|
||
(function (global, factory) {
|
||
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('openlayers')) :
|
||
typeof define === 'function' && define.amd ? define(['openlayers'], factory) :
|
||
(global.olPlot = factory(global.ol));
|
||
}(this, (function (ol) { 'use strict';
|
||
|
||
ol = ol && ol.hasOwnProperty('default') ? ol['default'] : ol;
|
||
|
||
const Observable = function () {
|
||
this.Events = {};
|
||
this.__cnt = 0;
|
||
};
|
||
|
||
Observable.hasOwnKey = Function.call.bind(Object.hasOwnProperty);
|
||
|
||
Observable.slice = Function.call.bind(Array.prototype.slice);
|
||
|
||
/**
|
||
* 事件分发
|
||
* @param eventName
|
||
* @param callback
|
||
* @param context
|
||
* @returns {(*|*)[]}
|
||
*/
|
||
Observable.prototype.on = function (eventName, callback, context) {
|
||
return (this.bindEvent(eventName, callback, 0, context))
|
||
};
|
||
|
||
/**
|
||
* 取消监听
|
||
* @param event
|
||
* @returns {boolean}
|
||
*/
|
||
Observable.prototype.un = function (event) {
|
||
var eventName = '';
|
||
var key = '';
|
||
var r = false;
|
||
var type = typeof event;
|
||
var that = this;
|
||
if (type === 'string') {
|
||
if (Observable.hasOwnKey(this.Events, event)) {
|
||
delete this.Events[event];
|
||
return true
|
||
}
|
||
return false
|
||
} else if (type === 'object') {
|
||
eventName = event[0];
|
||
key = event[1];
|
||
if (Observable.hasOwnKey(this.Events, eventName) && Observable.hasOwnKey(this.Events[eventName], key)) {
|
||
delete this.Events[eventName][key];
|
||
return true
|
||
}
|
||
return false
|
||
} else if (type === 'function') {
|
||
that.eachEvent(that.Events, function (keyA, itemA) {
|
||
that.eachEvent(itemA, function (keyB, itemB) {
|
||
if (itemB[0] === event) {
|
||
delete that.Events[keyA][keyB];
|
||
r = true;
|
||
}
|
||
});
|
||
});
|
||
return r
|
||
}
|
||
return true
|
||
};
|
||
|
||
/**
|
||
* 事件监听（只触发一次）
|
||
* @param eventName
|
||
* @param callback
|
||
* @param context
|
||
* @returns {(*|*)[]}
|
||
*/
|
||
Observable.prototype.once = function (eventName, callback, context) {
|
||
return (this.bindEvent(eventName, callback, 1, context))
|
||
};
|
||
|
||
/**
|
||
* 响应事件
|
||
* @param eventName
|
||
* @param args
|
||
*/
|
||
Observable.prototype.action = function (eventName, args) {
|
||
if (Observable.hasOwnKey(this.Events, eventName)) {
|
||
this.eachEvent(this.Events[eventName], function (key, item) {
|
||
item[0].apply(item[2], args);
|
||
if (item[1]) {
|
||
delete this.Events[eventName][key];
|
||
}
|
||
});
|
||
}
|
||
};
|
||
|
||
/**
|
||
* 实时触发响应
|
||
* @param eventName
|
||
*/
|
||
Observable.prototype.dispatch = function (eventName) {
|
||
var that = this;
|
||
var args = Observable.slice(arguments, 1);
|
||
setTimeout(function () {
|
||
that.action(eventName, args);
|
||
});
|
||
};
|
||
|
||
/**
|
||
* 延后触发响应
|
||
* @param eventName
|
||
*/
|
||
Observable.prototype.dispatchSync = function (eventName) {
|
||
this.action(eventName, Observable.slice(arguments, 1));
|
||
};
|
||
|
||
/**
|
||
* 清空发布中心
|
||
*/
|
||
Observable.prototype.clear = function () {
|
||
this.Events = {};
|
||
};
|
||
|
||
/**
|
||
* 绑定事件
|
||
* @param eventName
|
||
* @param callback
|
||
* @param isOne
|
||
* @param context
|
||
* @returns {[*,*]}
|
||
*/
|
||
Observable.prototype.bindEvent = function (eventName, callback, isOne, context) {
|
||
if (typeof eventName !== 'string' || typeof callback !== 'function') {
|
||
throw new Error('传入的事件名称和回调函数有误！')
|
||
}
|
||
if (!Observable.hasOwnKey(this.Events, eventName)) {
|
||
this.Events[eventName] = {};
|
||
}
|
||
this.Events[eventName][++this.__cnt] = [callback, isOne, context];
|
||
return [eventName, this.__cnt]
|
||
};
|
||
|
||
/**
|
||
* 循环触发事件
|
||
* @param obj
|
||
* @param callback
|
||
*/
|
||
Observable.prototype.eachEvent = function (obj, callback) {
|
||
for (var key in obj) {
|
||
if (Observable.hasOwnKey(obj, key)) {
|
||
callback(key, obj[key]);
|
||
}
|
||
}
|
||
};
|
||
|
||
var FITTING_COUNT = 100;
|
||
var HALF_PI = Math.PI / 2;
|
||
var ZERO_TOLERANCE = 0.0001;
|
||
var TWO_PI = Math.PI * 2;
|
||
var BASE_LAYERNAME = 'ol-plot-vector-layer';
|
||
var BASE_HELP_CONTROL_POINT_ID = 'plot-helper-control-point-div';
|
||
var BASE_HELP_HIDDEN = 'plot-helper-hidden-div';
|
||
var DEF_TEXT_STYEL = {
|
||
borderRadius: '2px',
|
||
fontSize: '12px',
|
||
outline: 0,
|
||
overflow: 'hidden',
|
||
boxSizing: 'border-box',
|
||
border: '1px solid #eeeeee',
|
||
fontFamily: 'Helvetica Neue,Helvetica,PingFang SC,Hiragino Sans GB,Microsoft YaHei,Noto Sans CJK SC,WenQuanYi Micro Hei,Arial,sans-serif',
|
||
color: '#010500',
|
||
fontWeight: 400,
|
||
padding: '3px',
|
||
fontStretch: 'normal',
|
||
lineHeight: 'normal',
|
||
textAlign: 'left',
|
||
marginLeft: 'auto',
|
||
marginRight: 'auto',
|
||
width: 'auto',
|
||
height: 'auto',
|
||
background: 'rgb(255, 255, 255)',
|
||
fontStyle: '',
|
||
fontVariant: ''
|
||
};
|
||
|
||
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
|
||
return typeof obj;
|
||
} : function (obj) {
|
||
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
var classCallCheck = function (instance, Constructor) {
|
||
if (!(instance instanceof Constructor)) {
|
||
throw new TypeError("Cannot call a class as a function");
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
var inherits = function (subClass, superClass) {
|
||
if (typeof superClass !== "function" && superClass !== null) {
|
||
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
|
||
}
|
||
|
||
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
||
constructor: {
|
||
value: subClass,
|
||
enumerable: false,
|
||
writable: true,
|
||
configurable: true
|
||
}
|
||
});
|
||
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
var possibleConstructorReturn = function (self, call) {
|
||
if (!self) {
|
||
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||
}
|
||
|
||
return call && (typeof call === "object" || typeof call === "function") ? call : self;
|
||
};
|
||
|
||
var MathDistance = function MathDistance(pnt1, pnt2) {
|
||
return Math.sqrt(Math.pow(pnt1[0] - pnt2[0], 2) + Math.pow(pnt1[1] - pnt2[1], 2));
|
||
};
|
||
|
||
var wholeDistance = function wholeDistance(points) {
|
||
var distance = 0;
|
||
if (points && Array.isArray(points) && points.length > 0) {
|
||
points.forEach(function (item, index) {
|
||
if (index < points.length - 1) {
|
||
distance += MathDistance(item, points[index + 1]);
|
||
}
|
||
});
|
||
}
|
||
return distance;
|
||
};
|
||
|
||
var getBaseLength = function getBaseLength(points) {
|
||
return Math.pow(wholeDistance(points), 0.99);
|
||
};
|
||
|
||
var Mid = function Mid(point1, point2) {
|
||
return [(point1[0] + point2[0]) / 2, (point1[1] + point2[1]) / 2];
|
||
};
|
||
|
||
var getCircleCenterOfThreePoints = function getCircleCenterOfThreePoints(point1, point2, point3) {
|
||
var pntA = [(point1[0] + point2[0]) / 2, (point1[1] + point2[1]) / 2];
|
||
var pntB = [pntA[0] - point1[1] + point2[1], pntA[1] + point1[0] - point2[0]];
|
||
var pntC = [(point1[0] + point3[0]) / 2, (point1[1] + point3[1]) / 2];
|
||
var pntD = [pntC[0] - point1[1] + point3[1], pntC[1] + point1[0] - point3[0]];
|
||
return getIntersectPoint(pntA, pntB, pntC, pntD);
|
||
};
|
||
|
||
var getIntersectPoint = function getIntersectPoint(pntA, pntB, pntC, pntD) {
|
||
if (pntA[1] === pntB[1]) {
|
||
var _f = (pntD[0] - pntC[0]) / (pntD[1] - pntC[1]);
|
||
var _x = _f * (pntA[1] - pntC[1]) + pntC[0];
|
||
var _y = pntA[1];
|
||
return [_x, _y];
|
||
}
|
||
if (pntC[1] === pntD[1]) {
|
||
var _e = (pntB[0] - pntA[0]) / (pntB[1] - pntA[1]);
|
||
var _x2 = _e * (pntC[1] - pntA[1]) + pntA[0];
|
||
var _y2 = pntC[1];
|
||
return [_x2, _y2];
|
||
}
|
||
var e = (pntB[0] - pntA[0]) / (pntB[1] - pntA[1]);
|
||
var f = (pntD[0] - pntC[0]) / (pntD[1] - pntC[1]);
|
||
var y = (e * pntA[1] - pntA[0] - f * pntC[1] + pntC[0]) / (e - f);
|
||
var x = e * y - e * pntA[1] + pntA[0];
|
||
return [x, y];
|
||
};
|
||
|
||
var getAzimuth = function getAzimuth(startPoint, endPoint) {
|
||
var azimuth = void 0;
|
||
var angle = Math.asin(Math.abs(endPoint[1] - startPoint[1]) / MathDistance(startPoint, endPoint));
|
||
if (endPoint[1] >= startPoint[1] && endPoint[0] >= startPoint[0]) {
|
||
azimuth = angle + Math.PI;
|
||
} else if (endPoint[1] >= startPoint[1] && endPoint[0] < startPoint[0]) {
|
||
azimuth = Math.PI * 2 - angle;
|
||
} else if (endPoint[1] < startPoint[1] && endPoint[0] < startPoint[0]) {
|
||
azimuth = angle;
|
||
} else if (endPoint[1] < startPoint[1] && endPoint[0] >= startPoint[0]) {
|
||
azimuth = Math.PI - angle;
|
||
}
|
||
return azimuth;
|
||
};
|
||
|
||
var getAngleOfThreePoints = function getAngleOfThreePoints(pntA, pntB, pntC) {
|
||
var angle = getAzimuth(pntB, pntA) - getAzimuth(pntB, pntC);
|
||
return angle < 0 ? angle + Math.PI * 2 : angle;
|
||
};
|
||
|
||
var isClockWise = function isClockWise(pnt1, pnt2, pnt3) {
|
||
return (pnt3[1] - pnt1[1]) * (pnt2[0] - pnt1[0]) > (pnt2[1] - pnt1[1]) * (pnt3[0] - pnt1[0]);
|
||
};
|
||
|
||
|
||
|
||
var getCubicValue = function getCubicValue(t, startPnt, cPnt1, cPnt2, endPnt) {
|
||
t = Math.max(Math.min(t, 1), 0);
|
||
var tp = 1 - t,
|
||
t2 = t * t;
|
||
|
||
var t3 = t2 * t;
|
||
var tp2 = tp * tp;
|
||
var tp3 = tp2 * tp;
|
||
var x = tp3 * startPnt[0] + 3 * tp2 * t * cPnt1[0] + 3 * tp * t2 * cPnt2[0] + t3 * endPnt[0];
|
||
var y = tp3 * startPnt[1] + 3 * tp2 * t * cPnt1[1] + 3 * tp * t2 * cPnt2[1] + t3 * endPnt[1];
|
||
return [x, y];
|
||
};
|
||
|
||
var getThirdPoint = function getThirdPoint(startPnt, endPnt, angle, distance, clockWise) {
|
||
var azimuth = getAzimuth(startPnt, endPnt);
|
||
var alpha = clockWise ? azimuth + angle : azimuth - angle;
|
||
var dx = distance * Math.cos(alpha);
|
||
var dy = distance * Math.sin(alpha);
|
||
return [endPnt[0] + dx, endPnt[1] + dy];
|
||
};
|
||
|
||
|
||
|
||
var getArcPoints = function getArcPoints(center, radius, startAngle, endAngle) {
|
||
var x = null,
|
||
y = null,
|
||
pnts = [],
|
||
angleDiff = endAngle - startAngle;
|
||
|
||
angleDiff = angleDiff < 0 ? angleDiff + Math.PI * 2 : angleDiff;
|
||
for (var i = 0; i <= 100; i++) {
|
||
var angle = startAngle + angleDiff * i / 100;
|
||
x = center[0] + radius * Math.cos(angle);
|
||
y = center[1] + radius * Math.sin(angle);
|
||
pnts.push([x, y]);
|
||
}
|
||
return pnts;
|
||
};
|
||
|
||
var getBisectorNormals = function getBisectorNormals(t, pnt1, pnt2, pnt3) {
|
||
var normal = getNormal(pnt1, pnt2, pnt3);
|
||
var bisectorNormalRight = null,
|
||
bisectorNormalLeft = null,
|
||
dt = null,
|
||
x = null,
|
||
y = null;
|
||
|
||
var dist = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
|
||
var uX = normal[0] / dist;
|
||
var uY = normal[1] / dist;
|
||
var d1 = MathDistance(pnt1, pnt2);
|
||
var d2 = MathDistance(pnt2, pnt3);
|
||
if (dist > ZERO_TOLERANCE) {
|
||
if (isClockWise(pnt1, pnt2, pnt3)) {
|
||
dt = t * d1;
|
||
x = pnt2[0] - dt * uY;
|
||
y = pnt2[1] + dt * uX;
|
||
bisectorNormalRight = [x, y];
|
||
dt = t * d2;
|
||
x = pnt2[0] + dt * uY;
|
||
y = pnt2[1] - dt * uX;
|
||
bisectorNormalLeft = [x, y];
|
||
} else {
|
||
dt = t * d1;
|
||
x = pnt2[0] + dt * uY;
|
||
y = pnt2[1] - dt * uX;
|
||
bisectorNormalRight = [x, y];
|
||
dt = t * d2;
|
||
x = pnt2[0] - dt * uY;
|
||
y = pnt2[1] + dt * uX;
|
||
bisectorNormalLeft = [x, y];
|
||
}
|
||
} else {
|
||
x = pnt2[0] + t * (pnt1[0] - pnt2[0]);
|
||
y = pnt2[1] + t * (pnt1[1] - pnt2[1]);
|
||
bisectorNormalRight = [x, y];
|
||
x = pnt2[0] + t * (pnt3[0] - pnt2[0]);
|
||
y = pnt2[1] + t * (pnt3[1] - pnt2[1]);
|
||
bisectorNormalLeft = [x, y];
|
||
}
|
||
return [bisectorNormalRight, bisectorNormalLeft];
|
||
};
|
||
|
||
var getNormal = function getNormal(pnt1, pnt2, pnt3) {
|
||
var dX1 = pnt1[0] - pnt2[0];
|
||
var dY1 = pnt1[1] - pnt2[1];
|
||
var d1 = Math.sqrt(dX1 * dX1 + dY1 * dY1);
|
||
dX1 /= d1;
|
||
dY1 /= d1;
|
||
var dX2 = pnt3[0] - pnt2[0];
|
||
var dY2 = pnt3[1] - pnt2[1];
|
||
var d2 = Math.sqrt(dX2 * dX2 + dY2 * dY2);
|
||
dX2 /= d2;
|
||
dY2 /= d2;
|
||
var uX = dX1 + dX2;
|
||
var uY = dY1 + dY2;
|
||
return [uX, uY];
|
||
};
|
||
|
||
var getLeftMostControlPoint = function getLeftMostControlPoint(controlPoints, t) {
|
||
var _ref = [controlPoints[0], controlPoints[1], controlPoints[2], null, null],
|
||
pnt1 = _ref[0],
|
||
pnt2 = _ref[1],
|
||
pnt3 = _ref[2],
|
||
controlX = _ref[3],
|
||
controlY = _ref[4];
|
||
|
||
var pnts = getBisectorNormals(0, pnt1, pnt2, pnt3);
|
||
var normalRight = pnts[0];
|
||
var normal = getNormal(pnt1, pnt2, pnt3);
|
||
var dist = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
|
||
if (dist > ZERO_TOLERANCE) {
|
||
var mid = Mid(pnt1, pnt2);
|
||
var pX = pnt1[0] - mid[0];
|
||
var pY = pnt1[1] - mid[1];
|
||
var d1 = MathDistance(pnt1, pnt2);
|
||
var n = 2.0 / d1;
|
||
var nX = -n * pY;
|
||
var nY = n * pX;
|
||
var a11 = nX * nX - nY * nY;
|
||
var a12 = 2 * nX * nY;
|
||
var a22 = nY * nY - nX * nX;
|
||
var dX = normalRight[0] - mid[0];
|
||
var dY = normalRight[1] - mid[1];
|
||
controlX = mid[0] + a11 * dX + a12 * dY;
|
||
controlY = mid[1] + a12 * dX + a22 * dY;
|
||
} else {
|
||
controlX = pnt1[0] + t * (pnt2[0] - pnt1[0]);
|
||
controlY = pnt1[1] + t * (pnt2[1] - pnt1[1]);
|
||
}
|
||
return [controlX, controlY];
|
||
};
|
||
|
||
var getRightMostControlPoint = function getRightMostControlPoint(controlPoints, t) {
|
||
var count = controlPoints.length;
|
||
var pnt1 = controlPoints[count - 3];
|
||
var pnt2 = controlPoints[count - 2];
|
||
var pnt3 = controlPoints[count - 1];
|
||
var pnts = getBisectorNormals(0, pnt1, pnt2, pnt3);
|
||
var normalLeft = pnts[1];
|
||
var normal = getNormal(pnt1, pnt2, pnt3);
|
||
var dist = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
|
||
var controlX = null,
|
||
controlY = null;
|
||
|
||
if (dist > ZERO_TOLERANCE) {
|
||
var mid = Mid(pnt2, pnt3);
|
||
var pX = pnt3[0] - mid[0];
|
||
var pY = pnt3[1] - mid[1];
|
||
var d1 = MathDistance(pnt2, pnt3);
|
||
var n = 2.0 / d1;
|
||
var nX = -n * pY;
|
||
var nY = n * pX;
|
||
var a11 = nX * nX - nY * nY;
|
||
var a12 = 2 * nX * nY;
|
||
var a22 = nY * nY - nX * nX;
|
||
var dX = normalLeft[0] - mid[0];
|
||
var dY = normalLeft[1] - mid[1];
|
||
controlX = mid[0] + a11 * dX + a12 * dY;
|
||
controlY = mid[1] + a12 * dX + a22 * dY;
|
||
} else {
|
||
controlX = pnt3[0] + t * (pnt2[0] - pnt3[0]);
|
||
controlY = pnt3[1] + t * (pnt2[1] - pnt3[1]);
|
||
}
|
||
return [controlX, controlY];
|
||
};
|
||
|
||
var getCurvePoints = function getCurvePoints(t, controlPoints) {
|
||
var leftControl = getLeftMostControlPoint(controlPoints, t);
|
||
var pnt1 = null,
|
||
pnt2 = null,
|
||
pnt3 = null,
|
||
normals = [leftControl],
|
||
points = [];
|
||
|
||
for (var i = 0; i < controlPoints.length - 2; i++) {
|
||
var _ref2 = [controlPoints[i], controlPoints[i + 1], controlPoints[i + 2]];
|
||
pnt1 = _ref2[0];
|
||
pnt2 = _ref2[1];
|
||
pnt3 = _ref2[2];
|
||
|
||
var normalPoints = getBisectorNormals(t, pnt1, pnt2, pnt3);
|
||
normals = normals.concat(normalPoints);
|
||
}
|
||
var rightControl = getRightMostControlPoint(controlPoints, t);
|
||
if (rightControl) {
|
||
normals.push(rightControl);
|
||
}
|
||
for (var _i = 0; _i < controlPoints.length - 1; _i++) {
|
||
pnt1 = controlPoints[_i];
|
||
pnt2 = controlPoints[_i + 1];
|
||
points.push(pnt1);
|
||
for (var _t = 0; _t < FITTING_COUNT; _t++) {
|
||
var pnt = getCubicValue(_t / FITTING_COUNT, pnt1, normals[_i * 2], normals[_i * 2 + 1], pnt2);
|
||
points.push(pnt);
|
||
}
|
||
points.push(pnt2);
|
||
}
|
||
return points;
|
||
};
|
||
|
||
var getBezierPoints = function getBezierPoints(points) {
|
||
if (points.length <= 2) {
|
||
return points;
|
||
} else {
|
||
var bezierPoints = [];
|
||
var n = points.length - 1;
|
||
for (var t = 0; t <= 1; t += 0.01) {
|
||
var x = 0,
|
||
y = 0;
|
||
|
||
for (var index = 0; index <= n; index++) {
|
||
var factor = getBinomialFactor(n, index);
|
||
var a = Math.pow(t, index);
|
||
var b = Math.pow(1 - t, n - index);
|
||
x += factor * a * b * points[index][0];
|
||
y += factor * a * b * points[index][1];
|
||
}
|
||
bezierPoints.push([x, y]);
|
||
}
|
||
bezierPoints.push(points[n]);
|
||
return bezierPoints;
|
||
}
|
||
};
|
||
|
||
var getFactorial = function getFactorial(n) {
|
||
var result = 1;
|
||
switch (n) {
|
||
case n <= 1:
|
||
result = 1;
|
||
break;
|
||
case n === 2:
|
||
result = 2;
|
||
break;
|
||
case n === 3:
|
||
result = 6;
|
||
break;
|
||
case n === 24:
|
||
result = 24;
|
||
break;
|
||
case n === 5:
|
||
result = 120;
|
||
break;
|
||
default:
|
||
for (var i = 1; i <= n; i++) {
|
||
result *= i;
|
||
}
|
||
break;
|
||
}
|
||
return result;
|
||
};
|
||
|
||
var getBinomialFactor = function getBinomialFactor(n, index) {
|
||
return getFactorial(n) / (getFactorial(index) * getFactorial(n - index));
|
||
};
|
||
|
||
var getQBSplinePoints = function getQBSplinePoints(points) {
|
||
if (points.length <= 2) {
|
||
return points;
|
||
} else {
|
||
var n = 2,
|
||
bSplinePoints = [];
|
||
|
||
var m = points.length - n - 1;
|
||
bSplinePoints.push(points[0]);
|
||
for (var i = 0; i <= m; i++) {
|
||
for (var t = 0; t <= 1; t += 0.05) {
|
||
var x = 0,
|
||
y = 0;
|
||
|
||
for (var k = 0; k <= n; k++) {
|
||
var factor = getQuadricBSplineFactor(k, t);
|
||
x += factor * points[i + k][0];
|
||
y += factor * points[i + k][1];
|
||
}
|
||
bSplinePoints.push([x, y]);
|
||
}
|
||
}
|
||
bSplinePoints.push(points[points.length - 1]);
|
||
return bSplinePoints;
|
||
}
|
||
};
|
||
|
||
var getQuadricBSplineFactor = function getQuadricBSplineFactor(k, t) {
|
||
var res = 0;
|
||
if (k === 0) {
|
||
res = Math.pow(t - 1, 2) / 2;
|
||
} else if (k === 1) {
|
||
res = (-2 * Math.pow(t, 2) + 2 * t + 1) / 2;
|
||
} else if (k === 2) {
|
||
res = Math.pow(t, 2) / 2;
|
||
}
|
||
return res;
|
||
};
|
||
|
||
var getuuid = function getuuid() {
|
||
var s = [],
|
||
hexDigits = '0123456789abcdef';
|
||
|
||
for (var i = 0; i < 36; i++) {
|
||
s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
|
||
}
|
||
s[14] = '4';
|
||
s[19] = hexDigits.substr(s[19] & 0x3 | 0x8, 1);
|
||
s[8] = s[13] = s[18] = s[23] = '-';
|
||
return s.join('');
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
var isObject = function isObject(value) {
|
||
var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
|
||
return value !== null && (type === 'object' || type === 'function');
|
||
};
|
||
|
||
var merge = function merge(a, b) {
|
||
for (var key in b) {
|
||
if (isObject(b[key]) && isObject(a[key])) {
|
||
merge(a[key], b[key]);
|
||
} else {
|
||
a[key] = b[key];
|
||
}
|
||
}
|
||
return a;
|
||
};
|
||
|
||
var $Group = ol.layer.Group;
|
||
var $VectorLayer = ol.layer.Vector;
|
||
var $VectorSource = ol.source.Vector;
|
||
var $Style = ol.style.Style;
|
||
var $Stroke = ol.style.Stroke;
|
||
var $Circle = ol.style.Circle;
|
||
var $Fill = ol.style.Fill;
|
||
|
||
var getLayerByLayerName = function getLayerByLayerName(map, layerName) {
|
||
try {
|
||
var targetLayer = null;
|
||
if (map) {
|
||
var layers = map.getLayers().getArray();
|
||
targetLayer = getLayerInternal(layers, 'layerName', layerName);
|
||
}
|
||
return targetLayer;
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
var getLayerInternal = function getLayerInternal(layers, key, value) {
|
||
var _target = null;
|
||
if (layers.length > 0) {
|
||
layers.every(function (layer) {
|
||
if (layer instanceof $Group) {
|
||
var _layers = layer.getLayers().getArray();
|
||
_target = getLayerInternal(_layers, key, value);
|
||
if (_target) {
|
||
return false;
|
||
} else {
|
||
return true;
|
||
}
|
||
} else if (layer.get(key) === value) {
|
||
_target = layer;
|
||
return false;
|
||
} else {
|
||
return true;
|
||
}
|
||
});
|
||
}
|
||
return _target;
|
||
};
|
||
|
||
var createVectorLayer = function createVectorLayer(map, layerName, params) {
|
||
try {
|
||
if (map) {
|
||
var vectorLayer = getLayerByLayerName(map, layerName);
|
||
if (!(vectorLayer instanceof $VectorLayer)) {
|
||
vectorLayer = null;
|
||
}
|
||
if (!vectorLayer) {
|
||
if (params && params.create) {
|
||
vectorLayer = new $VectorLayer({
|
||
layerName: layerName,
|
||
params: params,
|
||
layerType: 'vector',
|
||
source: new $VectorSource({
|
||
wrapX: false
|
||
}),
|
||
style: new $Style({
|
||
fill: new $Fill({
|
||
color: 'rgba(67, 110, 238, 0.4)'
|
||
}),
|
||
stroke: new $Stroke({
|
||
color: '#4781d9',
|
||
width: 2
|
||
}),
|
||
image: new $Circle({
|
||
radius: 7,
|
||
fill: new $Fill({
|
||
color: '#ffcc33'
|
||
})
|
||
})
|
||
})
|
||
});
|
||
}
|
||
}
|
||
if (map && vectorLayer) {
|
||
if (params && params.hasOwnProperty('selectable')) {
|
||
vectorLayer.set('selectable', params.selectable);
|
||
}
|
||
|
||
var _vectorLayer = getLayerByLayerName(map, layerName);
|
||
if (!_vectorLayer || !(_vectorLayer instanceof $VectorLayer)) {
|
||
map.addLayer(vectorLayer);
|
||
}
|
||
}
|
||
return vectorLayer;
|
||
}
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
||
|
||
|
||
|
||
|
||
|
||
function createCommonjsModule(fn, module) {
|
||
return module = { exports: {} }, fn(module, module.exports), module.exports;
|
||
}
|
||
|
||
var autosize = createCommonjsModule(function (module, exports) {
|
||
/*!
|
||
autosize 4.0.1
|
||
license: MIT
|
||
http://www.jacklmoore.com/autosize
|
||
*/
|
||
(function (global, factory) {
|
||
if (typeof undefined === "function" && undefined.amd) {
|
||
undefined(['module', 'exports'], factory);
|
||
} else {
|
||
factory(module, exports);
|
||
}
|
||
})(commonjsGlobal, function (module, exports) {
|
||
var map = typeof Map === "function" ? new Map() : function () {
|
||
var keys = [];
|
||
var values = [];
|
||
|
||
return {
|
||
has: function has(key) {
|
||
return keys.indexOf(key) > -1;
|
||
},
|
||
get: function get(key) {
|
||
return values[keys.indexOf(key)];
|
||
},
|
||
set: function set(key, value) {
|
||
if (keys.indexOf(key) === -1) {
|
||
keys.push(key);
|
||
values.push(value);
|
||
}
|
||
},
|
||
delete: function _delete(key) {
|
||
var index = keys.indexOf(key);
|
||
if (index > -1) {
|
||
keys.splice(index, 1);
|
||
values.splice(index, 1);
|
||
}
|
||
}
|
||
};
|
||
}();
|
||
|
||
var createEvent = function createEvent(name) {
|
||
return new Event(name, { bubbles: true });
|
||
};
|
||
try {
|
||
new Event('test');
|
||
} catch (e) {
|
||
// IE does not support `new Event()`
|
||
createEvent = function createEvent(name) {
|
||
var evt = document.createEvent('Event');
|
||
evt.initEvent(name, true, false);
|
||
return evt;
|
||
};
|
||
}
|
||
|
||
function assign(ta) {
|
||
if (!ta || !ta.nodeName || ta.nodeName !== 'TEXTAREA' || map.has(ta)) return;
|
||
|
||
var heightOffset = null;
|
||
var clientWidth = null;
|
||
var cachedHeight = null;
|
||
|
||
function init() {
|
||
var style = window.getComputedStyle(ta, null);
|
||
|
||
if (style.resize === 'vertical') {
|
||
ta.style.resize = 'none';
|
||
} else if (style.resize === 'both') {
|
||
ta.style.resize = 'horizontal';
|
||
}
|
||
|
||
if (style.boxSizing === 'content-box') {
|
||
heightOffset = -(parseFloat(style.paddingTop) + parseFloat(style.paddingBottom));
|
||
} else {
|
||
heightOffset = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
|
||
}
|
||
// Fix when a textarea is not on document body and heightOffset is Not a Number
|
||
if (isNaN(heightOffset)) {
|
||
heightOffset = 0;
|
||
}
|
||
|
||
update();
|
||
}
|
||
|
||
function changeOverflow(value) {
|
||
{
|
||
// Chrome/Safari-specific fix:
|
||
// When the textarea y-overflow is hidden, Chrome/Safari do not reflow the text to account for the space
|
||
// made available by removing the scrollbar. The following forces the necessary text reflow.
|
||
var width = ta.style.width;
|
||
ta.style.width = '0px';
|
||
// Force reflow:
|
||
/* jshint ignore:start */
|
||
ta.offsetWidth;
|
||
/* jshint ignore:end */
|
||
ta.style.width = width;
|
||
}
|
||
|
||
ta.style.overflowY = value;
|
||
}
|
||
|
||
function getParentOverflows(el) {
|
||
var arr = [];
|
||
|
||
while (el && el.parentNode && el.parentNode instanceof Element) {
|
||
if (el.parentNode.scrollTop) {
|
||
arr.push({
|
||
node: el.parentNode,
|
||
scrollTop: el.parentNode.scrollTop
|
||
});
|
||
}
|
||
el = el.parentNode;
|
||
}
|
||
|
||
return arr;
|
||
}
|
||
|
||
function resize() {
|
||
if (ta.scrollHeight === 0) {
|
||
// If the scrollHeight is 0, then the element probably has display:none or is detached from the DOM.
|
||
return;
|
||
}
|
||
|
||
var overflows = getParentOverflows(ta);
|
||
var docTop = document.documentElement && document.documentElement.scrollTop; // Needed for Mobile IE (ticket #240)
|
||
|
||
ta.style.height = '';
|
||
ta.style.height = ta.scrollHeight + heightOffset + 'px';
|
||
|
||
// used to check if an update is actually necessary on window.resize
|
||
clientWidth = ta.clientWidth;
|
||
|
||
// prevents scroll-position jumping
|
||
overflows.forEach(function (el) {
|
||
el.node.scrollTop = el.scrollTop;
|
||
});
|
||
|
||
if (docTop) {
|
||
document.documentElement.scrollTop = docTop;
|
||
}
|
||
}
|
||
|
||
function update() {
|
||
resize();
|
||
|
||
var styleHeight = Math.round(parseFloat(ta.style.height));
|
||
var computed = window.getComputedStyle(ta, null);
|
||
|
||
// Using offsetHeight as a replacement for computed.height in IE, because IE does not account use of border-box
|
||
var actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(computed.height)) : ta.offsetHeight;
|
||
|
||
// The actual height not matching the style height (set via the resize method) indicates that
|
||
// the max-height has been exceeded, in which case the overflow should be allowed.
|
||
if (actualHeight !== styleHeight) {
|
||
if (computed.overflowY === 'hidden') {
|
||
changeOverflow('scroll');
|
||
resize();
|
||
actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;
|
||
}
|
||
} else {
|
||
// Normally keep overflow set to hidden, to avoid flash of scrollbar as the textarea expands.
|
||
if (computed.overflowY !== 'hidden') {
|
||
changeOverflow('hidden');
|
||
resize();
|
||
actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;
|
||
}
|
||
}
|
||
|
||
if (cachedHeight !== actualHeight) {
|
||
cachedHeight = actualHeight;
|
||
var evt = createEvent('autosize:resized');
|
||
try {
|
||
ta.dispatchEvent(evt);
|
||
} catch (err) {
|
||
// Firefox will throw an error on dispatchEvent for a detached element
|
||
// https://bugzilla.mozilla.org/show_bug.cgi?id=889376
|
||
}
|
||
}
|
||
}
|
||
|
||
var pageResize = function pageResize() {
|
||
if (ta.clientWidth !== clientWidth) {
|
||
update();
|
||
}
|
||
};
|
||
|
||
var destroy = function (style) {
|
||
window.removeEventListener('resize', pageResize, false);
|
||
ta.removeEventListener('input', update, false);
|
||
ta.removeEventListener('keyup', update, false);
|
||
ta.removeEventListener('autosize:destroy', destroy, false);
|
||
ta.removeEventListener('autosize:update', update, false);
|
||
|
||
Object.keys(style).forEach(function (key) {
|
||
ta.style[key] = style[key];
|
||
});
|
||
|
||
map.delete(ta);
|
||
}.bind(ta, {
|
||
height: ta.style.height,
|
||
resize: ta.style.resize,
|
||
overflowY: ta.style.overflowY,
|
||
overflowX: ta.style.overflowX,
|
||
wordWrap: ta.style.wordWrap
|
||
});
|
||
|
||
ta.addEventListener('autosize:destroy', destroy, false);
|
||
|
||
// IE9 does not fire onpropertychange or oninput for deletions,
|
||
// so binding to onkeyup to catch most of those events.
|
||
// There is no way that I know of to detect something like 'cut' in IE9.
|
||
if ('onpropertychange' in ta && 'oninput' in ta) {
|
||
ta.addEventListener('keyup', update, false);
|
||
}
|
||
|
||
window.addEventListener('resize', pageResize, false);
|
||
ta.addEventListener('input', update, false);
|
||
ta.addEventListener('autosize:update', update, false);
|
||
ta.style.overflowX = 'hidden';
|
||
ta.style.wordWrap = 'break-word';
|
||
|
||
map.set(ta, {
|
||
destroy: destroy,
|
||
update: update
|
||
});
|
||
|
||
init();
|
||
}
|
||
|
||
function destroy(ta) {
|
||
var methods = map.get(ta);
|
||
if (methods) {
|
||
methods.destroy();
|
||
}
|
||
}
|
||
|
||
function update(ta) {
|
||
var methods = map.get(ta);
|
||
if (methods) {
|
||
methods.update();
|
||
}
|
||
}
|
||
|
||
var autosize = null;
|
||
|
||
// Do nothing in Node.js environment and IE8 (or lower)
|
||
if (typeof window === 'undefined' || typeof window.getComputedStyle !== 'function') {
|
||
autosize = function autosize(el) {
|
||
return el;
|
||
};
|
||
autosize.destroy = function (el) {
|
||
return el;
|
||
};
|
||
autosize.update = function (el) {
|
||
return el;
|
||
};
|
||
} else {
|
||
autosize = function autosize(el, options) {
|
||
if (el) {
|
||
Array.prototype.forEach.call(el.length ? el : [el], function (x) {
|
||
return assign(x, options);
|
||
});
|
||
}
|
||
return el;
|
||
};
|
||
autosize.destroy = function (el) {
|
||
if (el) {
|
||
Array.prototype.forEach.call(el.length ? el : [el], destroy);
|
||
}
|
||
return el;
|
||
};
|
||
autosize.update = function (el) {
|
||
if (el) {
|
||
Array.prototype.forEach.call(el.length ? el : [el], update);
|
||
}
|
||
return el;
|
||
};
|
||
}
|
||
|
||
exports.default = autosize;
|
||
module.exports = exports['default'];
|
||
});
|
||
});
|
||
|
||
var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
|
||
var MOZ_HACK_REGEXP = /^moz([A-Z])/;
|
||
|
||
var create = function create(tagName, className, container, id) {
|
||
var el = document.createElement(tagName);
|
||
el.className = className || '';
|
||
if (id) {
|
||
el.id = id;
|
||
}
|
||
if (container) {
|
||
container.appendChild(el);
|
||
}
|
||
return el;
|
||
};
|
||
|
||
var getElement = function getElement(id) {
|
||
return typeof id === 'string' ? document.getElementById(id) : id;
|
||
};
|
||
|
||
var remove = function remove(el) {
|
||
var parent = el.parentNode;
|
||
if (parent) {
|
||
parent.removeChild(el);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
var createHidden = function createHidden(tagName, parent, id) {
|
||
var element = document.createElement(tagName);
|
||
element.style.display = 'none';
|
||
if (id) {
|
||
element.id = id;
|
||
}
|
||
if (parent) {
|
||
parent.appendChild(element);
|
||
}
|
||
return element;
|
||
};
|
||
|
||
var camelCase = function camelCase(name) {
|
||
return name.replace(SPECIAL_CHARS_REGEXP, function (_, separator, letter, offset) {
|
||
return offset ? letter.toUpperCase() : letter;
|
||
}).replace(MOZ_HACK_REGEXP, 'Moz$1');
|
||
};
|
||
|
||
var on = function () {
|
||
if (document.addEventListener) {
|
||
return function (element, event, handler) {
|
||
if (element && event && handler) {
|
||
element.addEventListener(event, handler, false);
|
||
}
|
||
};
|
||
}
|
||
}();
|
||
|
||
var off = function () {
|
||
if (document.removeEventListener) {
|
||
return function (element, event, handler) {
|
||
if (element && event) {
|
||
element.removeEventListener(event, handler, false);
|
||
}
|
||
};
|
||
}
|
||
}();
|
||
|
||
|
||
|
||
function hasClass(el, cls) {
|
||
if (!el || !cls) return false;
|
||
if (cls.indexOf(' ') !== -1) throw new Error('className should not contain space.');
|
||
if (el.classList) {
|
||
return el.classList.contains(cls);
|
||
} else {
|
||
return (' ' + el.className + ' ').indexOf(' ' + cls + ' ') > -1;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
function getStyle(element, styleName) {
|
||
if (!element || !styleName) return null;
|
||
styleName = camelCase(styleName);
|
||
if (styleName === 'float') {
|
||
styleName = 'cssFloat';
|
||
}
|
||
try {
|
||
var computed = document.defaultView.getComputedStyle(element, '');
|
||
return element.style[styleName] || computed ? computed[styleName] : null;
|
||
} catch (e) {
|
||
return element.style[styleName];
|
||
}
|
||
}
|
||
|
||
function setStyle(element, styleName, value) {
|
||
if (!element || !styleName) return;
|
||
if ((typeof styleName === 'undefined' ? 'undefined' : _typeof(styleName)) === 'object') {
|
||
for (var prop in styleName) {
|
||
if (styleName.hasOwnProperty(prop)) {
|
||
setStyle(element, prop, styleName[prop]);
|
||
}
|
||
}
|
||
} else {
|
||
styleName = camelCase(styleName);
|
||
if (styleName === 'opacity') {
|
||
element.style.filter = isNaN(value) ? '' : 'alpha(opacity=' + value * 100 + ')';
|
||
} else {
|
||
element.style[styleName] = value;
|
||
}
|
||
}
|
||
}
|
||
|
||
var $DragPan = ol.interaction.DragPan;
|
||
|
||
var PlotTextBox = function (_ol$Overlay) {
|
||
inherits(PlotTextBox, _ol$Overlay);
|
||
|
||
function PlotTextBox() {
|
||
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
||
classCallCheck(this, PlotTextBox);
|
||
var _ref = [options['id'], options['element'], options['offset'], options['stopEvent'], options['positioning'], options['insertFirst'], options['autoPan'], options['autoPanAnimation'], options['autoPanMargin'], options['className'] ? options['className'] : 'ol-plot-text-editor'],
|
||
id = _ref[0],
|
||
element = _ref[1],
|
||
offset = _ref[2],
|
||
stopEvent = _ref[3],
|
||
positioning = _ref[4],
|
||
insertFirst = _ref[5],
|
||
autoPan = _ref[6],
|
||
autoPanAnimation = _ref[7],
|
||
autoPanMargin = _ref[8],
|
||
className = _ref[9];
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$Overlay.call(this, {
|
||
id: id,
|
||
element: element,
|
||
stopEvent: stopEvent,
|
||
insertFirst: insertFirst,
|
||
autoPan: autoPan,
|
||
autoPanAnimation: autoPanAnimation,
|
||
autoPanMargin: autoPanMargin,
|
||
className: className
|
||
}));
|
||
|
||
_this.setOffset(offset !== undefined ? offset : [0, 0]);
|
||
_this.setPositioning(positioning !== undefined ? positioning : 'center-center');
|
||
|
||
_this.mapDragPan = undefined;
|
||
|
||
_this.isClick_ = false;
|
||
|
||
_this.dragging_ = false;
|
||
|
||
_this.isFocus_ = false;
|
||
|
||
_this.options_ = options;
|
||
|
||
_this._position = options['position'] && options['position'].length > 0 ? options['position'] : [];
|
||
|
||
_this.handleTimer_ = null;
|
||
|
||
_this.currentPixel_ = [];
|
||
|
||
_this.createTextContent(options);
|
||
return _this;
|
||
}
|
||
|
||
PlotTextBox.prototype.createTextContent = function createTextContent(options) {
|
||
var _className = options.className || 'ol-plot-text-editor';
|
||
var content = document.createElement('textarea');
|
||
content.className = _className;
|
||
content.style.width = options['width'] + 'px';
|
||
content.style.height = options['height'] + 'px';
|
||
content.style.minHeight = options['minHeight'] + 'px';
|
||
content.setAttribute('id', options['id']);
|
||
content.setAttribute('autofocus', true);
|
||
autosize(content);
|
||
on(content, 'focus', this.handleFocus_.bind(this));
|
||
on(content, 'blur', this.handleBlur_.bind(this));
|
||
on(content, 'click', this.handleClick_.bind(this));
|
||
on(content, 'mousedown', this.handleDragStart_.bind(this));
|
||
on(window, 'mouseup', this.handleDragEnd_.bind(this));
|
||
this.set('isPlotText', true);
|
||
this.setElement(content);
|
||
this.createCloseButton(options);
|
||
this.createResizeButton(options);
|
||
this.setPosition(this._position);
|
||
this.dispatchEvent('textBoxDrawEnd', {
|
||
overlay: this,
|
||
element: content,
|
||
uuid: options['id']
|
||
});
|
||
};
|
||
|
||
PlotTextBox.prototype.getTextAreaFromContent_ = function getTextAreaFromContent_() {
|
||
var _node = '';
|
||
var childrens_ = Array.prototype.slice.call(this.element && this.element.children, 0);
|
||
if (childrens_.length > 0) {
|
||
childrens_.every(function (ele) {
|
||
if (ele.nodeType === 1 && ele.nodeName.toLowerCase() === 'textarea') {
|
||
_node = ele;
|
||
return false;
|
||
} else {
|
||
return true;
|
||
}
|
||
});
|
||
}
|
||
return _node;
|
||
};
|
||
|
||
PlotTextBox.prototype.createCloseButton = function createCloseButton(options) {
|
||
var _closeSpan = document.createElement('span');
|
||
_closeSpan.className = 'ol-plot-text-editor-close';
|
||
_closeSpan.setAttribute('data-id', options['id']);
|
||
off(_closeSpan, 'click', this.closeCurrentPlotText.bind(this));
|
||
on(_closeSpan, 'click', this.closeCurrentPlotText.bind(this));
|
||
this.element.appendChild(_closeSpan);
|
||
};
|
||
|
||
PlotTextBox.prototype.createResizeButton = function createResizeButton(options) {
|
||
var _resizeSpan = document.createElement('span');
|
||
_resizeSpan.className = 'ol-plot-text-editor-resize';
|
||
_resizeSpan.setAttribute('data-id', options['id']);
|
||
off(_resizeSpan, 'mousedown', this.handleResizeMouseDown_.bind(this));
|
||
off(_resizeSpan, 'mousemove', this.handleResizeMouseMove_.bind(this));
|
||
on(_resizeSpan, 'mousedown', this.handleResizeMouseDown_.bind(this));
|
||
on(_resizeSpan, 'mousemove', this.handleResizeMouseMove_.bind(this));
|
||
this.element.appendChild(_resizeSpan);
|
||
};
|
||
|
||
PlotTextBox.prototype.resizeButtonMoveHandler_ = function resizeButtonMoveHandler_(event) {
|
||
var pixel_ = event.pixel;
|
||
var element_ = this.getTextAreaFromContent_();
|
||
if (pixel_.length < 1 || this.currentPixel_.length < 1 || !element_) return;
|
||
var _offset = [pixel_[0] - this.currentPixel_[0], pixel_[1] - this.currentPixel_[1]];
|
||
var _size = [element_.offsetWidth, element_.offsetHeight];
|
||
var _width = _size[0] + _offset[0] * 2;
|
||
var _height = _size[1] + _offset[1] * 2;
|
||
setStyle(element_, 'width', _width + 'px');
|
||
setStyle(element_, 'height', _height + 'px');
|
||
this.currentPixel_ = pixel_;
|
||
this.getMap().render();
|
||
};
|
||
|
||
PlotTextBox.prototype.handleResizeMouseMove_ = function handleResizeMouseMove_(event) {
|
||
event.stopImmediatePropagation();
|
||
};
|
||
|
||
PlotTextBox.prototype.handleResizeMouseDown_ = function handleResizeMouseDown_(event) {
|
||
if (!this.getMap()) return;
|
||
this.currentPixel_ = [event.x, event.y];
|
||
this.getMap().on('pointermove', this.resizeButtonMoveHandler_, this);
|
||
on(this.getMap().getViewport(), 'mouseup', this.handleResizeMouseUp_.bind(this));
|
||
};
|
||
|
||
PlotTextBox.prototype.handleResizeMouseUp_ = function handleResizeMouseUp_(event) {
|
||
if (!this.getMap()) return;
|
||
this.getMap().un('pointermove', this.resizeButtonMoveHandler_, this);
|
||
off(this.getMap().getViewport(), 'mouseup', this.handleResizeMouseUp_.bind(this));
|
||
this.currentPixel_ = [];
|
||
};
|
||
|
||
PlotTextBox.prototype.closeCurrentPlotText = function closeCurrentPlotText(event) {
|
||
if (!this.getMap()) return;
|
||
if (event && hasClass(event.target, 'ol-plot-text-editor-close')) {
|
||
var _id = event.target.getAttribute('data-id');
|
||
if (_id) {
|
||
var _overlay = this.getMap().getOverlayById(_id);
|
||
if (_overlay) {
|
||
this.getMap().removeOverlay(_overlay);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.handleFocus_ = function handleFocus_() {
|
||
this.isFocus_ = true;
|
||
if (this.getMap()) {
|
||
this.getMap().set('activeTextArea', this);
|
||
this.getMap().dispatchEvent('activeTextArea');
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.handleBlur_ = function handleBlur_() {
|
||
this.isFocus_ = false;
|
||
if (this.getMap()) {
|
||
this.getMap().set('activeTextArea', null);
|
||
this.getMap().set('disActiveTextArea', this);
|
||
this.getMap().dispatchEvent('disActiveTextArea');
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.handleDragStart_ = function handleDragStart_(event) {
|
||
var _this2 = this;
|
||
|
||
if (!this.getMap()) return;
|
||
if (!this.dragging_ && this.isMoveModel() && this.isFocus_) {
|
||
this.handleTimer_ = window.setTimeout(function () {
|
||
window.clearTimeout(_this2.handleTimer_);
|
||
_this2.handleTimer_ = null;
|
||
if (!_this2.isClick_) {
|
||
_this2.dragging_ = true;
|
||
_this2.disableMapDragPan();
|
||
_this2.preCursor_ = _this2.element.style.cursor;
|
||
on(_this2.getMap().getViewport(), 'mousemove', _this2.handleDragDrag_.bind(_this2));
|
||
on(_this2.element, 'mouseup', _this2.handleDragEnd_.bind(_this2));
|
||
}
|
||
}, 300);
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.handleDragDrag_ = function handleDragDrag_(event) {
|
||
if (this.dragging_) {
|
||
this.element.style.cursor = 'move';
|
||
this._position = this.getMap().getCoordinateFromPixel([event.clientX, event.clientY]);
|
||
this.setPosition(this._position);
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.handleDragEnd_ = function handleDragEnd_(event) {
|
||
this.isClick_ = false;
|
||
window.clearTimeout(this.handleTimer_);
|
||
this.handleTimer_ = null;
|
||
if (this.dragging_ && this.isFocus_) {
|
||
this.dragging_ = false;
|
||
this.enableMapDragPan();
|
||
this.element.style.cursor = this.preCursor_;
|
||
off(this.getMap().getViewport(), 'mousemove', this.handleDragDrag_.bind(this));
|
||
off(this.element, 'mouseup', this.handleDragEnd_.bind(this));
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.handleClick_ = function handleClick_(event) {
|
||
if (event.target === this.element) {
|
||
this.isClick_ = true;
|
||
} else {
|
||
this.isClick_ = false;
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.isMoveModel = function isMoveModel() {
|
||
var range = window.getSelection().getRangeAt(0);
|
||
return range.collapsed;
|
||
};
|
||
|
||
PlotTextBox.prototype.setStyle = function setStyle$$1() {
|
||
var style = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
||
|
||
var _element = this.getTextAreaFromContent_();
|
||
if (_element) {
|
||
for (var key in style) {
|
||
if (style[key]) {
|
||
setStyle(_element, key, style[key]);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.getStyle = function getStyle$$1() {
|
||
var _style = {};
|
||
var _element = this.getTextAreaFromContent_();
|
||
if (_element) {
|
||
for (var key in DEF_TEXT_STYEL) {
|
||
_style[key] = getStyle(_element, key);
|
||
}
|
||
}
|
||
return _style;
|
||
};
|
||
|
||
PlotTextBox.prototype.setValue = function setValue(value) {
|
||
var _element = this.getTextAreaFromContent_();
|
||
if (_element) {
|
||
_element.value = value;
|
||
if (value) {
|
||
autosize.update(_element);
|
||
}
|
||
this.getMap().render();
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.getValue = function getValue() {
|
||
var _element = this.getTextAreaFromContent_();
|
||
if (_element) {
|
||
return _element.value;
|
||
} else {
|
||
return '';
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.getWidth = function getWidth() {
|
||
var element_ = this.getTextAreaFromContent_();
|
||
if (element_ && element_.offsetWidth) {
|
||
return element_.offsetWidth;
|
||
} else {
|
||
return 0;
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.getHeight = function getHeight() {
|
||
var element_ = this.getTextAreaFromContent_();
|
||
if (element_ && element_.offsetHeight) {
|
||
return element_.offsetHeight;
|
||
} else {
|
||
return 0;
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.enableMapDragPan = function enableMapDragPan() {
|
||
var _map = this.getMap();
|
||
if (!_map) return;
|
||
if (this.mapDragPan && this.mapDragPan instanceof $DragPan) {
|
||
_map.addInteraction(this.mapDragPan);
|
||
delete this.mapDragPan;
|
||
}
|
||
};
|
||
|
||
PlotTextBox.prototype.disableMapDragPan = function disableMapDragPan() {
|
||
var _this3 = this;
|
||
|
||
var _map = this.getMap();
|
||
if (!_map) return;
|
||
var interactions = _map.getInteractions().getArray();
|
||
interactions.every(function (item) {
|
||
if (item instanceof $DragPan) {
|
||
_this3.mapDragPan = item;
|
||
_map.removeInteraction(item);
|
||
return false;
|
||
} else {
|
||
return true;
|
||
}
|
||
});
|
||
};
|
||
|
||
PlotTextBox.prototype.setMap = function setMap(map) {
|
||
ol.Overlay.prototype.setMap.call(this, map);
|
||
if (map && map instanceof ol.Map) {
|
||
this.setStyle(merge(DEF_TEXT_STYEL, this.options_['style']));
|
||
this.setValue(this.options_['value']);
|
||
}
|
||
};
|
||
|
||
return PlotTextBox;
|
||
}(ol.Overlay);
|
||
|
||
var TEXTAREA = 'TextArea';
|
||
var ARC = 'Arc';
|
||
var CURVE = 'Curve';
|
||
var GATHERING_PLACE = 'GatheringPlace';
|
||
var POLYLINE = 'Polyline';
|
||
var FREEHANDLINE = 'FreeHandLine';
|
||
var POINT = 'Point';
|
||
var PENNANT = 'Pennant';
|
||
var RECTANGLE = 'RectAngle';
|
||
var CIRCLE = 'Circle';
|
||
var ELLIPSE = 'Ellipse';
|
||
var LUNE = 'Lune';
|
||
var SECTOR = 'Sector';
|
||
var CLOSED_CURVE = 'ClosedCurve';
|
||
var POLYGON = 'Polygon';
|
||
var FREE_POLYGON = 'FreePolygon';
|
||
var ATTACK_ARROW = 'AttackArrow';
|
||
var DOUBLE_ARROW = 'DoubleArrow';
|
||
var STRAIGHT_ARROW = 'StraightArrow';
|
||
var FINE_ARROW = 'FineArrow';
|
||
var ASSAULT_DIRECTION = 'AssaultDirection';
|
||
var TAILED_ATTACK_ARROW = 'TailedAttackArrow';
|
||
var SQUAD_COMBAT = 'SquadCombat';
|
||
var TAILED_SQUAD_COMBAT = 'TailedSquadCombat';
|
||
var RECTFLAG = 'RectFlag';
|
||
var TRIANGLEFLAG = 'TriangleFlag';
|
||
var CURVEFLAG = 'CurveFlag';
|
||
|
||
|
||
var PlotTypes = Object.freeze({
|
||
TEXTAREA: TEXTAREA,
|
||
ARC: ARC,
|
||
CURVE: CURVE,
|
||
GATHERING_PLACE: GATHERING_PLACE,
|
||
POLYLINE: POLYLINE,
|
||
FREEHANDLINE: FREEHANDLINE,
|
||
POINT: POINT,
|
||
PENNANT: PENNANT,
|
||
RECTANGLE: RECTANGLE,
|
||
CIRCLE: CIRCLE,
|
||
ELLIPSE: ELLIPSE,
|
||
LUNE: LUNE,
|
||
SECTOR: SECTOR,
|
||
CLOSED_CURVE: CLOSED_CURVE,
|
||
POLYGON: POLYGON,
|
||
FREE_POLYGON: FREE_POLYGON,
|
||
ATTACK_ARROW: ATTACK_ARROW,
|
||
DOUBLE_ARROW: DOUBLE_ARROW,
|
||
STRAIGHT_ARROW: STRAIGHT_ARROW,
|
||
FINE_ARROW: FINE_ARROW,
|
||
ASSAULT_DIRECTION: ASSAULT_DIRECTION,
|
||
TAILED_SQUAD_COMBAT: TAILED_SQUAD_COMBAT,
|
||
TAILED_ATTACK_ARROW: TAILED_ATTACK_ARROW,
|
||
SQUAD_COMBAT: SQUAD_COMBAT,
|
||
RECTFLAG: RECTFLAG,
|
||
TRIANGLEFLAG: TRIANGLEFLAG,
|
||
CURVEFLAG: CURVEFLAG
|
||
});
|
||
|
||
var Point = function (_ol$geom$Point) {
|
||
inherits(Point, _ol$geom$Point);
|
||
|
||
function Point(coordinates, point, params) {
|
||
classCallCheck(this, Point);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Point.call(this, []));
|
||
|
||
_this.type = POINT;
|
||
_this.options = params || {};
|
||
_this.set('params', _this.options);
|
||
_this.fixPointCount = 1;
|
||
if (point && point.length > 0) {
|
||
_this.setPoints(point);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Point.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Point.prototype.generate = function generate() {
|
||
var pnt = this.points[0];
|
||
this.setCoordinates(pnt);
|
||
};
|
||
|
||
Point.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Point.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Point.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Point.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Point.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Point.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Point.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Point.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Point.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Point;
|
||
}(ol.geom.Point);
|
||
|
||
var Pennant = function (_ol$geom$Point) {
|
||
inherits(Pennant, _ol$geom$Point);
|
||
|
||
function Pennant(coordinates, point, params) {
|
||
classCallCheck(this, Pennant);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Point.call(this, []));
|
||
|
||
_this.type = PENNANT;
|
||
_this.options = params || {};
|
||
_this.set('params', _this.options);
|
||
if (point && point.length > 0) {
|
||
_this.setPoints(point);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Pennant.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Pennant.prototype.generate = function generate() {
|
||
this.setCoordinates(this.points);
|
||
};
|
||
|
||
Pennant.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Pennant.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Pennant.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Pennant.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Pennant.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Pennant.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Pennant.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Pennant.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Pennant.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Pennant;
|
||
}(ol.geom.Point);
|
||
|
||
var Polyline = function (_ol$geom$LineString) {
|
||
inherits(Polyline, _ol$geom$LineString);
|
||
|
||
function Polyline(coordinates, points, params) {
|
||
classCallCheck(this, Polyline);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$LineString.call(this, []));
|
||
|
||
_this.type = POLYLINE;
|
||
_this.freehand = false;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Polyline.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Polyline.prototype.generate = function generate() {
|
||
this.setCoordinates(this.points);
|
||
};
|
||
|
||
Polyline.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Polyline.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Polyline.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Polyline.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Polyline.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Polyline.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Polyline.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Polyline.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Polyline.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Polyline;
|
||
}(ol.geom.LineString);
|
||
|
||
var Arc = function (_ol$geom$LineString) {
|
||
inherits(Arc, _ol$geom$LineString);
|
||
|
||
function Arc(coordinates, points, params) {
|
||
classCallCheck(this, Arc);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$LineString.call(this, []));
|
||
|
||
_this.type = ARC;
|
||
_this.fixPointCount = 3;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Arc.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Arc.prototype.generate = function generate() {
|
||
var count = this.getPointCount();
|
||
if (count < 2) return;
|
||
if (count === 2) {
|
||
this.setCoordinates(this.points);
|
||
} else {
|
||
var _ref = [this.points[0], this.points[1], this.points[2], null, null],
|
||
pnt1 = _ref[0],
|
||
pnt2 = _ref[1],
|
||
pnt3 = _ref[2],
|
||
startAngle = _ref[3],
|
||
endAngle = _ref[4];
|
||
|
||
var center = getCircleCenterOfThreePoints(pnt1, pnt2, pnt3);
|
||
var radius = MathDistance(pnt1, center);
|
||
var angle1 = getAzimuth(pnt1, center);
|
||
var angle2 = getAzimuth(pnt2, center);
|
||
if (isClockWise(pnt1, pnt2, pnt3)) {
|
||
startAngle = angle2;
|
||
endAngle = angle1;
|
||
} else {
|
||
startAngle = angle1;
|
||
endAngle = angle2;
|
||
}
|
||
this.setCoordinates(getArcPoints(center, radius, startAngle, endAngle));
|
||
}
|
||
};
|
||
|
||
Arc.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Arc.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Arc.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Arc.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Arc.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Arc.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Arc.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Arc.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Arc.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Arc;
|
||
}(ol.geom.LineString);
|
||
|
||
var Circle = function (_ol$geom$Polygon) {
|
||
inherits(Circle, _ol$geom$Polygon);
|
||
|
||
function Circle(coordinates, points, params) {
|
||
classCallCheck(this, Circle);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = CIRCLE;
|
||
_this.fixPointCount = 2;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Circle.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Circle.prototype.generate = function generate() {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else {
|
||
var center = this.points[0];
|
||
var radius = MathDistance(center, this.points[1]);
|
||
this.setCoordinates([this.generatePoints(center, radius)]);
|
||
}
|
||
};
|
||
|
||
Circle.prototype.generatePoints = function generatePoints(center, radius) {
|
||
var x = null,
|
||
y = null,
|
||
angle = null,
|
||
points = [];
|
||
|
||
for (var i = 0; i <= 100; i++) {
|
||
angle = Math.PI * 2 * i / 100;
|
||
x = center[0] + radius * Math.cos(angle);
|
||
y = center[1] + radius * Math.sin(angle);
|
||
points.push([x, y]);
|
||
}
|
||
return points;
|
||
};
|
||
|
||
Circle.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Circle.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Circle.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Circle.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Circle.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Circle.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Circle.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Circle.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Circle.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Circle;
|
||
}(ol.geom.Polygon);
|
||
|
||
var Curve = function (_ol$geom$LineString) {
|
||
inherits(Curve, _ol$geom$LineString);
|
||
|
||
function Curve(coordinates, points, params) {
|
||
classCallCheck(this, Curve);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$LineString.call(this, []));
|
||
|
||
_this.type = CURVE;
|
||
_this.t = 0.3;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Curve.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Curve.prototype.generate = function generate() {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else if (count === 2) {
|
||
this.setCoordinates(this.points);
|
||
} else {
|
||
var points = getCurvePoints(this.t, this.points);
|
||
this.setCoordinates(points);
|
||
}
|
||
};
|
||
|
||
Curve.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Curve.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Curve.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Curve.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Curve.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Curve.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Curve.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Curve.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Curve.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Curve;
|
||
}(ol.geom.LineString);
|
||
|
||
var FreeHandLine = function (_ol$geom$LineString) {
|
||
inherits(FreeHandLine, _ol$geom$LineString);
|
||
|
||
function FreeHandLine(coordinates, points, params) {
|
||
classCallCheck(this, FreeHandLine);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$LineString.call(this, []));
|
||
|
||
_this.type = FREEHANDLINE;
|
||
_this.freehand = true;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
FreeHandLine.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
FreeHandLine.prototype.generate = function generate() {
|
||
this.setCoordinates(this.points);
|
||
};
|
||
|
||
FreeHandLine.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
FreeHandLine.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
FreeHandLine.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
FreeHandLine.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
FreeHandLine.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
FreeHandLine.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
FreeHandLine.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
FreeHandLine.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
FreeHandLine.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return FreeHandLine;
|
||
}(ol.geom.LineString);
|
||
|
||
var RectAngle = function (_ol$geom$Polygon) {
|
||
inherits(RectAngle, _ol$geom$Polygon);
|
||
|
||
function RectAngle(coordinates, points, params) {
|
||
classCallCheck(this, RectAngle);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = RECTANGLE;
|
||
_this.fixPointCount = 2;
|
||
_this.set('params', params);
|
||
_this.isFill = params['isFill'] === false ? params['isFill'] : true;
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
RectAngle.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
RectAngle.prototype.generate = function generate() {
|
||
if (this.points.length === 2) {
|
||
var coordinates = [];
|
||
if (this.isFill) {
|
||
var extent = ol.extent.boundingExtent(this.points);
|
||
var polygon = ol.geom.Polygon.fromExtent(extent);
|
||
coordinates = polygon.getCoordinates();
|
||
} else {
|
||
var start = this.points[0];
|
||
var end = this.points[1];
|
||
coordinates = [start, [start[0], end[1]], end, [end[0], start[1]], start];
|
||
}
|
||
this.setCoordinates(coordinates);
|
||
}
|
||
};
|
||
|
||
RectAngle.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
RectAngle.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
RectAngle.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
RectAngle.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
RectAngle.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
RectAngle.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
RectAngle.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
RectAngle.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
RectAngle.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return RectAngle;
|
||
}(ol.geom.Polygon);
|
||
|
||
var Ellipse = function (_ol$geom$Polygon) {
|
||
inherits(Ellipse, _ol$geom$Polygon);
|
||
|
||
function Ellipse(coordinates, points, params) {
|
||
classCallCheck(this, Ellipse);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = ELLIPSE;
|
||
_this.fixPointCount = 2;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Ellipse.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Ellipse.prototype.generate = function generate() {
|
||
if (this.getPointCount() < 2) {
|
||
return false;
|
||
} else {
|
||
var _ref = [this.points[0], this.points[1]],
|
||
pnt1 = _ref[0],
|
||
pnt2 = _ref[1];
|
||
|
||
var center = Mid(pnt1, pnt2);
|
||
var majorRadius = Math.abs((pnt1[0] - pnt2[0]) / 2);
|
||
var minorRadius = Math.abs((pnt1[1] - pnt2[1]) / 2);
|
||
var res = this.generatePoints(center, majorRadius, minorRadius);
|
||
this.setCoordinates([res]);
|
||
}
|
||
};
|
||
|
||
Ellipse.prototype.generatePoints = function generatePoints(center, majorRadius, minorRadius) {
|
||
var x = null,
|
||
y = null,
|
||
angle = null,
|
||
points = [];
|
||
|
||
for (var i = 0; i <= FITTING_COUNT; i++) {
|
||
angle = Math.PI * 2 * i / FITTING_COUNT;
|
||
x = center[0] + majorRadius * Math.cos(angle);
|
||
y = center[1] + minorRadius * Math.sin(angle);
|
||
points.push([x, y]);
|
||
}
|
||
return points;
|
||
};
|
||
|
||
Ellipse.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Ellipse.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Ellipse.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Ellipse.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Ellipse.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Ellipse.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Ellipse.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Ellipse.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Ellipse.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Ellipse;
|
||
}(ol.geom.Polygon);
|
||
|
||
var Lune = function (_ol$geom$Polygon) {
|
||
inherits(Lune, _ol$geom$Polygon);
|
||
|
||
function Lune(coordinates, points, params) {
|
||
classCallCheck(this, Lune);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = LUNE;
|
||
_this.fixPointCount = 3;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Lune.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Lune.prototype.generate = function generate() {
|
||
if (this.getPointCount() < 2) {
|
||
return false;
|
||
} else {
|
||
var pnts = this.getPoints();
|
||
if (this.getPointCount() === 2) {
|
||
var mid = Mid(pnts[0], pnts[1]);
|
||
var d = MathDistance(pnts[0], mid);
|
||
var pnt = getThirdPoint(pnts[0], mid, HALF_PI, d);
|
||
pnts.push(pnt);
|
||
}
|
||
var _ref = [pnts[0], pnts[1], pnts[2], undefined, undefined],
|
||
pnt1 = _ref[0],
|
||
pnt2 = _ref[1],
|
||
pnt3 = _ref[2],
|
||
startAngle = _ref[3],
|
||
endAngle = _ref[4];
|
||
|
||
var center = getCircleCenterOfThreePoints(pnt1, pnt2, pnt3);
|
||
var radius = MathDistance(pnt1, center);
|
||
var angle1 = getAzimuth(pnt1, center);
|
||
var angle2 = getAzimuth(pnt2, center);
|
||
if (isClockWise(pnt1, pnt2, pnt3)) {
|
||
startAngle = angle2;
|
||
endAngle = angle1;
|
||
} else {
|
||
startAngle = angle1;
|
||
endAngle = angle2;
|
||
}
|
||
pnts = getArcPoints(center, radius, startAngle, endAngle);
|
||
pnts.push(pnts[0]);
|
||
this.setCoordinates([pnts]);
|
||
}
|
||
};
|
||
|
||
Lune.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Lune.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Lune.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Lune.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Lune.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Lune.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Lune.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Lune.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Lune.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Lune;
|
||
}(ol.geom.Polygon);
|
||
|
||
var Sector = function (_ol$geom$Polygon) {
|
||
inherits(Sector, _ol$geom$Polygon);
|
||
|
||
function Sector(coordinates, points, params) {
|
||
classCallCheck(this, Sector);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = SECTOR;
|
||
_this.fixPointCount = 3;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Sector.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Sector.prototype.generate = function generate() {
|
||
var points = this.getPointCount();
|
||
if (points < 2) {
|
||
return false;
|
||
} else if (points === 2) {
|
||
this.setCoordinates([this.points]);
|
||
} else {
|
||
var pnts = this.getPoints();
|
||
var _ref = [pnts[0], pnts[1], pnts[2]],
|
||
center = _ref[0],
|
||
pnt2 = _ref[1],
|
||
pnt3 = _ref[2];
|
||
|
||
var radius = MathDistance(pnt2, center);
|
||
var startAngle = getAzimuth(pnt2, center);
|
||
var endAngle = getAzimuth(pnt3, center);
|
||
var pList = getArcPoints(center, radius, startAngle, endAngle);
|
||
pList.push(center, pList[0]);
|
||
this.setCoordinates([pList]);
|
||
}
|
||
};
|
||
|
||
Sector.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Sector.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Sector.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Sector.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Sector.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Sector.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Sector.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Sector.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Sector.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Sector;
|
||
}(ol.geom.Polygon);
|
||
|
||
var ClosedCurve = function (_ol$geom$Polygon) {
|
||
inherits(ClosedCurve, _ol$geom$Polygon);
|
||
|
||
function ClosedCurve(coordinates, points, params) {
|
||
classCallCheck(this, ClosedCurve);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = CLOSED_CURVE;
|
||
_this.t = 0.3;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
ClosedCurve.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
ClosedCurve.prototype.generate = function generate() {
|
||
var points = this.getPointCount();
|
||
if (points < 2) {
|
||
return false;
|
||
} else if (points === 2) {
|
||
this.setCoordinates([this.points]);
|
||
} else {
|
||
var pnts = this.getPoints();
|
||
pnts.push(pnts[0], pnts[1]);
|
||
var normals = [],
|
||
pList = [];
|
||
|
||
for (var i = 0; i < pnts.length - 2; i++) {
|
||
var normalPoints = getBisectorNormals(this.t, pnts[i], pnts[i + 1], pnts[i + 2]);
|
||
normals = normals.concat(normalPoints);
|
||
}
|
||
var count = normals.length;
|
||
normals = [normals[count - 1]].concat(normals.slice(0, count - 1));
|
||
for (var _i = 0; _i < pnts.length - 2; _i++) {
|
||
var pnt1 = pnts[_i];
|
||
var pnt2 = pnts[_i + 1];
|
||
pList.push(pnt1);
|
||
for (var t = 0; t <= FITTING_COUNT; t++) {
|
||
var pnt = getCubicValue(t / FITTING_COUNT, pnt1, normals[_i * 2], normals[_i * 2 + 1], pnt2);
|
||
pList.push(pnt);
|
||
}
|
||
pList.push(pnt2);
|
||
}
|
||
this.setCoordinates([pList]);
|
||
}
|
||
};
|
||
|
||
ClosedCurve.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
ClosedCurve.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
ClosedCurve.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
ClosedCurve.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
ClosedCurve.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
ClosedCurve.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
ClosedCurve.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
ClosedCurve.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
ClosedCurve.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return ClosedCurve;
|
||
}(ol.geom.Polygon);
|
||
|
||
var Polygon = function (_ol$geom$Polygon) {
|
||
inherits(Polygon, _ol$geom$Polygon);
|
||
|
||
function Polygon(coordinates, points, params) {
|
||
classCallCheck(this, Polygon);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = POLYGON;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
Polygon.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
Polygon.prototype.generate = function generate() {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else {
|
||
this.setCoordinates([this.points]);
|
||
}
|
||
};
|
||
|
||
Polygon.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
Polygon.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
Polygon.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
Polygon.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Polygon.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
Polygon.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
Polygon.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
Polygon.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
Polygon.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return Polygon;
|
||
}(ol.geom.Polygon);
|
||
|
||
var FreePolygon = function (_ol$geom$Polygon) {
|
||
inherits(FreePolygon, _ol$geom$Polygon);
|
||
|
||
function FreePolygon(coordinates, points, params) {
|
||
classCallCheck(this, FreePolygon);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = FREE_POLYGON;
|
||
_this.freehand = true;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
FreePolygon.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
FreePolygon.prototype.generate = function generate() {
|
||
this.setCoordinates([this.points]);
|
||
};
|
||
|
||
FreePolygon.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
FreePolygon.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
FreePolygon.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
FreePolygon.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
FreePolygon.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
FreePolygon.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
FreePolygon.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
FreePolygon.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
FreePolygon.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return FreePolygon;
|
||
}(ol.geom.Polygon);
|
||
|
||
var AttackArrow = function (_ol$geom$Polygon) {
|
||
inherits(AttackArrow, _ol$geom$Polygon);
|
||
|
||
function AttackArrow(coordinates, points, params) {
|
||
classCallCheck(this, AttackArrow);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = ATTACK_ARROW;
|
||
_this.headHeightFactor = 0.18;
|
||
_this.headWidthFactor = 0.3;
|
||
_this.neckHeightFactor = 0.85;
|
||
_this.neckWidthFactor = 0.15;
|
||
_this.headTailFactor = 0.8;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
AttackArrow.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
AttackArrow.prototype.generate = function generate() {
|
||
try {
|
||
var points = this.getPointCount();
|
||
if (points < 2) {
|
||
return false;
|
||
} else if (points === 2) {
|
||
this.setCoordinates([this.points]);
|
||
} else {
|
||
var pnts = this.getPoints();
|
||
var _ref = [pnts[0], pnts[1]],
|
||
tailLeft = _ref[0],
|
||
tailRight = _ref[1];
|
||
|
||
if (isClockWise(pnts[0], pnts[1], pnts[2])) {
|
||
tailLeft = pnts[1];
|
||
tailRight = pnts[0];
|
||
}
|
||
var midTail = Mid(tailLeft, tailRight);
|
||
var bonePnts = [midTail].concat(pnts.slice(2));
|
||
var headPnts = this.getArrowHeadPoints(bonePnts, tailLeft, tailRight);
|
||
var _ref2 = [headPnts[0], headPnts[4]],
|
||
neckLeft = _ref2[0],
|
||
neckRight = _ref2[1];
|
||
|
||
var tailWidthFactor = MathDistance(tailLeft, tailRight) / getBaseLength(bonePnts);
|
||
var bodyPnts = this.getArrowBodyPoints(bonePnts, neckLeft, neckRight, tailWidthFactor);
|
||
var count = bodyPnts.length;
|
||
var leftPnts = [tailLeft].concat(bodyPnts.slice(0, count / 2));
|
||
leftPnts.push(neckLeft);
|
||
var rightPnts = [tailRight].concat(bodyPnts.slice(count / 2, count));
|
||
rightPnts.push(neckRight);
|
||
leftPnts = getQBSplinePoints(leftPnts);
|
||
rightPnts = getQBSplinePoints(rightPnts);
|
||
this.setCoordinates([leftPnts.concat(headPnts, rightPnts.reverse())]);
|
||
}
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
AttackArrow.prototype.getArrowPoints = function getArrowPoints(pnt1, pnt2, pnt3, clockWise) {
|
||
var midPnt = Mid(pnt1, pnt2);
|
||
var len = MathDistance(midPnt, pnt3);
|
||
var midPnt1 = getThirdPoint(pnt3, midPnt, 0, len * 0.3, true);
|
||
var midPnt2 = getThirdPoint(pnt3, midPnt, 0, len * 0.5, true);
|
||
midPnt1 = getThirdPoint(midPnt, midPnt1, HALF_PI, len / 5, clockWise);
|
||
midPnt2 = getThirdPoint(midPnt, midPnt2, HALF_PI, len / 4, clockWise);
|
||
var points = [midPnt, midPnt1, midPnt2, pnt3];
|
||
var arrowPnts = this.getArrowHeadPoints(points);
|
||
if (arrowPnts && Array.isArray(arrowPnts) && arrowPnts.length > 0) {
|
||
var _ref3 = [arrowPnts[0], arrowPnts[4]],
|
||
neckLeftPoint = _ref3[0],
|
||
neckRightPoint = _ref3[1];
|
||
|
||
var tailWidthFactor = MathDistance(pnt1, pnt2) / getBaseLength(points) / 2;
|
||
var bodyPnts = this.getArrowBodyPoints(points, neckLeftPoint, neckRightPoint, tailWidthFactor);
|
||
if (bodyPnts) {
|
||
var n = bodyPnts.length;
|
||
var lPoints = bodyPnts.slice(0, n / 2);
|
||
var rPoints = bodyPnts.slice(n / 2, n);
|
||
lPoints.push(neckLeftPoint);
|
||
rPoints.push(neckRightPoint);
|
||
lPoints = lPoints.reverse();
|
||
lPoints.push(pnt2);
|
||
rPoints = rPoints.reverse();
|
||
rPoints.push(pnt1);
|
||
return lPoints.reverse().concat(arrowPnts, rPoints);
|
||
}
|
||
} else {
|
||
throw new Error('插值出错');
|
||
}
|
||
};
|
||
|
||
AttackArrow.prototype.getArrowHeadPoints = function getArrowHeadPoints(points, tailLeft, tailRight) {
|
||
try {
|
||
var len = getBaseLength(points);
|
||
var headHeight = len * this.headHeightFactor;
|
||
var headPnt = points[points.length - 1];
|
||
len = MathDistance(headPnt, points[points.length - 2]);
|
||
var tailWidth = MathDistance(tailLeft, tailRight);
|
||
if (headHeight > tailWidth * this.headTailFactor) {
|
||
headHeight = tailWidth * this.headTailFactor;
|
||
}
|
||
var headWidth = headHeight * this.headWidthFactor;
|
||
var neckWidth = headHeight * this.neckWidthFactor;
|
||
headHeight = headHeight > len ? len : headHeight;
|
||
var neckHeight = headHeight * this.neckHeightFactor;
|
||
var headEndPnt = getThirdPoint(points[points.length - 2], headPnt, 0, headHeight, true);
|
||
var neckEndPnt = getThirdPoint(points[points.length - 2], headPnt, 0, neckHeight, true);
|
||
var headLeft = getThirdPoint(headPnt, headEndPnt, HALF_PI, headWidth, false);
|
||
var headRight = getThirdPoint(headPnt, headEndPnt, HALF_PI, headWidth, true);
|
||
var neckLeft = getThirdPoint(headPnt, neckEndPnt, HALF_PI, neckWidth, false);
|
||
var neckRight = getThirdPoint(headPnt, neckEndPnt, HALF_PI, neckWidth, true);
|
||
return [neckLeft, headLeft, headPnt, headRight, neckRight];
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
AttackArrow.prototype.getArrowBodyPoints = function getArrowBodyPoints(points, neckLeft, neckRight, tailWidthFactor) {
|
||
var allLen = wholeDistance(points);
|
||
var len = getBaseLength(points);
|
||
var tailWidth = len * tailWidthFactor;
|
||
var neckWidth = MathDistance(neckLeft, neckRight);
|
||
var widthDif = (tailWidth - neckWidth) / 2;
|
||
var tempLen = 0,
|
||
leftBodyPnts = [],
|
||
rightBodyPnts = [];
|
||
|
||
for (var i = 1; i < points.length - 1; i++) {
|
||
var angle = getAngleOfThreePoints(points[i - 1], points[i], points[i + 1]) / 2;
|
||
tempLen += MathDistance(points[i - 1], points[i]);
|
||
var w = (tailWidth / 2 - tempLen / allLen * widthDif) / Math.sin(angle);
|
||
var left = getThirdPoint(points[i - 1], points[i], Math.PI - angle, w, true);
|
||
var right = getThirdPoint(points[i - 1], points[i], angle, w, false);
|
||
leftBodyPnts.push(left);
|
||
rightBodyPnts.push(right);
|
||
}
|
||
return leftBodyPnts.concat(rightBodyPnts);
|
||
};
|
||
|
||
AttackArrow.prototype.getTempPoint4 = function getTempPoint4(linePnt1, linePnt2, point) {
|
||
try {
|
||
var midPnt = Mid(linePnt1, linePnt2);
|
||
var len = MathDistance(midPnt, point);
|
||
var angle = getAngleOfThreePoints(linePnt1, midPnt, point);
|
||
var symPnt = undefined,
|
||
distance1 = undefined,
|
||
distance2 = undefined,
|
||
mid = undefined;
|
||
|
||
if (angle < HALF_PI) {
|
||
distance1 = len * Math.sin(angle);
|
||
distance2 = len * Math.cos(angle);
|
||
mid = getThirdPoint(linePnt1, midPnt, HALF_PI, distance1, false);
|
||
symPnt = getThirdPoint(midPnt, mid, HALF_PI, distance2, true);
|
||
} else if (angle >= HALF_PI && angle < Math.PI) {
|
||
distance1 = len * Math.sin(Math.PI - angle);
|
||
distance2 = len * Math.cos(Math.PI - angle);
|
||
mid = getThirdPoint(linePnt1, midPnt, HALF_PI, distance1, false);
|
||
symPnt = getThirdPoint(midPnt, mid, HALF_PI, distance2, false);
|
||
} else if (angle >= Math.PI && angle < Math.PI * 1.5) {
|
||
distance1 = len * Math.sin(angle - Math.PI);
|
||
distance2 = len * Math.cos(angle - Math.PI);
|
||
mid = getThirdPoint(linePnt1, midPnt, HALF_PI, distance1, true);
|
||
symPnt = getThirdPoint(midPnt, mid, HALF_PI, distance2, true);
|
||
} else {
|
||
distance1 = len * Math.sin(Math.PI * 2 - angle);
|
||
distance2 = len * Math.cos(Math.PI * 2 - angle);
|
||
mid = getThirdPoint(linePnt1, midPnt, HALF_PI, distance1, true);
|
||
symPnt = getThirdPoint(midPnt, mid, HALF_PI, distance2, false);
|
||
}
|
||
return symPnt;
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
AttackArrow.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
AttackArrow.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
AttackArrow.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
AttackArrow.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
AttackArrow.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
AttackArrow.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
AttackArrow.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
AttackArrow.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
AttackArrow.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return AttackArrow;
|
||
}(ol.geom.Polygon);
|
||
|
||
var DoubleArrow = function (_ol$geom$Polygon) {
|
||
inherits(DoubleArrow, _ol$geom$Polygon);
|
||
|
||
function DoubleArrow(coordinates, points, params) {
|
||
classCallCheck(this, DoubleArrow);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = DOUBLE_ARROW;
|
||
_this.headHeightFactor = 0.25;
|
||
_this.headWidthFactor = 0.3;
|
||
_this.neckHeightFactor = 0.85;
|
||
_this.neckWidthFactor = 0.15;
|
||
_this.connPoint = null;
|
||
_this.tempPoint4 = null;
|
||
_this.fixPointCount = 4;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
DoubleArrow.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
DoubleArrow.prototype.generate = function generate() {
|
||
try {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else if (count === 2) {
|
||
this.setCoordinates([this.points]);
|
||
return false;
|
||
}
|
||
if (count > 2) {
|
||
var _ref = [this.points[0], this.points[1], this.points[2]],
|
||
pnt1 = _ref[0],
|
||
pnt2 = _ref[1],
|
||
pnt3 = _ref[2];
|
||
|
||
if (count === 3) {
|
||
this.tempPoint4 = this.getTempPoint4(pnt1, pnt2, pnt3);
|
||
this.connPoint = Mid(pnt1, pnt2);
|
||
} else if (count === 4) {
|
||
this.tempPoint4 = this.points[3];
|
||
this.connPoint = Mid(pnt1, pnt2);
|
||
} else {
|
||
this.tempPoint4 = this.points[3];
|
||
this.connPoint = this.points[4];
|
||
}
|
||
var leftArrowPnts = undefined,
|
||
rightArrowPnts = undefined;
|
||
|
||
if (isClockWise(pnt1, pnt2, pnt3)) {
|
||
leftArrowPnts = this.getArrowPoints(pnt1, this.connPoint, this.tempPoint4, false);
|
||
rightArrowPnts = this.getArrowPoints(this.connPoint, pnt2, pnt3, true);
|
||
} else {
|
||
leftArrowPnts = this.getArrowPoints(pnt2, this.connPoint, pnt3, false);
|
||
rightArrowPnts = this.getArrowPoints(this.connPoint, pnt1, this.tempPoint4, true);
|
||
}
|
||
var m = leftArrowPnts.length;
|
||
var t = (m - 5) / 2;
|
||
var llBodyPnts = leftArrowPnts.slice(0, t);
|
||
var lArrowPnts = leftArrowPnts.slice(t, t + 5);
|
||
var lrBodyPnts = leftArrowPnts.slice(t + 5, m);
|
||
var rlBodyPnts = rightArrowPnts.slice(0, t);
|
||
var rArrowPnts = rightArrowPnts.slice(t, t + 5);
|
||
var rrBodyPnts = rightArrowPnts.slice(t + 5, m);
|
||
rlBodyPnts = getBezierPoints(rlBodyPnts);
|
||
var bodyPnts = getBezierPoints(rrBodyPnts.concat(llBodyPnts.slice(1)));
|
||
lrBodyPnts = getBezierPoints(lrBodyPnts);
|
||
var pnts = rlBodyPnts.concat(rArrowPnts, bodyPnts, lArrowPnts, lrBodyPnts);
|
||
this.setCoordinates([pnts]);
|
||
}
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
DoubleArrow.prototype.getArrowPoints = function getArrowPoints(pnt1, pnt2, pnt3, clockWise) {
|
||
var midPnt = Mid(pnt1, pnt2);
|
||
var len = MathDistance(midPnt, pnt3);
|
||
var midPnt1 = getThirdPoint(pnt3, midPnt, 0, len * 0.3, true);
|
||
var midPnt2 = getThirdPoint(pnt3, midPnt, 0, len * 0.5, true);
|
||
midPnt1 = getThirdPoint(midPnt, midPnt1, HALF_PI, len / 5, clockWise);
|
||
midPnt2 = getThirdPoint(midPnt, midPnt2, HALF_PI, len / 4, clockWise);
|
||
var points = [midPnt, midPnt1, midPnt2, pnt3];
|
||
var arrowPnts = this.getArrowHeadPoints(points);
|
||
if (arrowPnts && Array.isArray(arrowPnts) && arrowPnts.length > 0) {
|
||
var _ref2 = [arrowPnts[0], arrowPnts[4]],
|
||
neckLeftPoint = _ref2[0],
|
||
neckRightPoint = _ref2[1];
|
||
|
||
var tailWidthFactor = MathDistance(pnt1, pnt2) / getBaseLength(points) / 2;
|
||
var bodyPnts = this.getArrowBodyPoints(points, neckLeftPoint, neckRightPoint, tailWidthFactor);
|
||
if (bodyPnts) {
|
||
var n = bodyPnts.length;
|
||
var lPoints = bodyPnts.slice(0, n / 2);
|
||
var rPoints = bodyPnts.slice(n / 2, n);
|
||
lPoints.push(neckLeftPoint);
|
||
rPoints.push(neckRightPoint);
|
||
lPoints = lPoints.reverse();
|
||
lPoints.push(pnt2);
|
||
rPoints = rPoints.reverse();
|
||
rPoints.push(pnt1);
|
||
return lPoints.reverse().concat(arrowPnts, rPoints);
|
||
}
|
||
} else {
|
||
throw new Error('插值出错');
|
||
}
|
||
};
|
||
|
||
DoubleArrow.prototype.getArrowHeadPoints = function getArrowHeadPoints(points) {
|
||
try {
|
||
var len = getBaseLength(points);
|
||
var headHeight = len * this.headHeightFactor;
|
||
var headPnt = points[points.length - 1];
|
||
var headWidth = headHeight * this.headWidthFactor;
|
||
var neckWidth = headHeight * this.neckWidthFactor;
|
||
var neckHeight = headHeight * this.neckHeightFactor;
|
||
var headEndPnt = getThirdPoint(points[points.length - 2], headPnt, 0, headHeight, true);
|
||
var neckEndPnt = getThirdPoint(points[points.length - 2], headPnt, 0, neckHeight, true);
|
||
var headLeft = getThirdPoint(headPnt, headEndPnt, HALF_PI, headWidth, false);
|
||
var headRight = getThirdPoint(headPnt, headEndPnt, HALF_PI, headWidth, true);
|
||
var neckLeft = getThirdPoint(headPnt, neckEndPnt, HALF_PI, neckWidth, false);
|
||
var neckRight = getThirdPoint(headPnt, neckEndPnt, HALF_PI, neckWidth, true);
|
||
return [neckLeft, headLeft, headPnt, headRight, neckRight];
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
DoubleArrow.prototype.getArrowBodyPoints = function getArrowBodyPoints(points, neckLeft, neckRight, tailWidthFactor) {
|
||
var allLen = wholeDistance(points);
|
||
var len = getBaseLength(points);
|
||
var tailWidth = len * tailWidthFactor;
|
||
var neckWidth = MathDistance(neckLeft, neckRight);
|
||
var widthDif = (tailWidth - neckWidth) / 2;
|
||
var tempLen = 0,
|
||
leftBodyPnts = [],
|
||
rightBodyPnts = [];
|
||
|
||
for (var i = 1; i < points.length - 1; i++) {
|
||
var angle = getAngleOfThreePoints(points[i - 1], points[i], points[i + 1]) / 2;
|
||
tempLen += MathDistance(points[i - 1], points[i]);
|
||
var w = (tailWidth / 2 - tempLen / allLen * widthDif) / Math.sin(angle);
|
||
var left = getThirdPoint(points[i - 1], points[i], Math.PI - angle, w, true);
|
||
var right = getThirdPoint(points[i - 1], points[i], angle, w, false);
|
||
leftBodyPnts.push(left);
|
||
rightBodyPnts.push(right);
|
||
}
|
||
return leftBodyPnts.concat(rightBodyPnts);
|
||
};
|
||
|
||
DoubleArrow.prototype.getTempPoint4 = function getTempPoint4(linePnt1, linePnt2, point) {
|
||
try {
|
||
var midPnt = Mid(linePnt1, linePnt2);
|
||
var len = MathDistance(midPnt, point);
|
||
var angle = getAngleOfThreePoints(linePnt1, midPnt, point);
|
||
var symPnt = undefined,
|
||
distance1 = undefined,
|
||
distance2 = undefined,
|
||
mid = undefined;
|
||
|
||
if (angle < HALF_PI) {
|
||
distance1 = len * Math.sin(angle);
|
||
distance2 = len * Math.cos(angle);
|
||
mid = getThirdPoint(linePnt1, midPnt, HALF_PI, distance1, false);
|
||
symPnt = getThirdPoint(midPnt, mid, HALF_PI, distance2, true);
|
||
} else if (angle >= HALF_PI && angle < Math.PI) {
|
||
distance1 = len * Math.sin(Math.PI - angle);
|
||
distance2 = len * Math.cos(Math.PI - angle);
|
||
mid = getThirdPoint(linePnt1, midPnt, HALF_PI, distance1, false);
|
||
symPnt = getThirdPoint(midPnt, mid, HALF_PI, distance2, false);
|
||
} else if (angle >= Math.PI && angle < Math.PI * 1.5) {
|
||
distance1 = len * Math.sin(angle - Math.PI);
|
||
distance2 = len * Math.cos(angle - Math.PI);
|
||
mid = getThirdPoint(linePnt1, midPnt, HALF_PI, distance1, true);
|
||
symPnt = getThirdPoint(midPnt, mid, HALF_PI, distance2, true);
|
||
} else {
|
||
distance1 = len * Math.sin(Math.PI * 2 - angle);
|
||
distance2 = len * Math.cos(Math.PI * 2 - angle);
|
||
mid = getThirdPoint(linePnt1, midPnt, HALF_PI, distance1, true);
|
||
symPnt = getThirdPoint(midPnt, mid, HALF_PI, distance2, false);
|
||
}
|
||
return symPnt;
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
DoubleArrow.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
DoubleArrow.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
DoubleArrow.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
DoubleArrow.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
DoubleArrow.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
DoubleArrow.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
DoubleArrow.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
DoubleArrow.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
DoubleArrow.prototype.finishDrawing = function finishDrawing() {
|
||
if (this.getPointCount() === 3 && this.tempPoint4 !== null) {
|
||
this.points.push(this.tempPoint4);
|
||
}
|
||
if (this.connPoint !== null) {
|
||
this.points.push(this.connPoint);
|
||
}
|
||
};
|
||
|
||
return DoubleArrow;
|
||
}(ol.geom.Polygon);
|
||
|
||
var StraightArrow = function (_ol$geom$LineString) {
|
||
inherits(StraightArrow, _ol$geom$LineString);
|
||
|
||
function StraightArrow(coordinates, points, params) {
|
||
classCallCheck(this, StraightArrow);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$LineString.call(this, []));
|
||
|
||
_this.type = STRAIGHT_ARROW;
|
||
_this.fixPointCount = 2;
|
||
_this.maxArrowLength = 3000000;
|
||
_this.arrowLengthScale = 5;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
StraightArrow.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
StraightArrow.prototype.generate = function generate() {
|
||
try {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else {
|
||
var pnts = this.getPoints();
|
||
var _ref = [pnts[0], pnts[1]],
|
||
pnt1 = _ref[0],
|
||
pnt2 = _ref[1];
|
||
|
||
var distance = MathDistance(pnt1, pnt2);
|
||
var len = distance / this.arrowLengthScale;
|
||
len = len > this.maxArrowLength ? this.maxArrowLength : len;
|
||
var leftPnt = getThirdPoint(pnt1, pnt2, Math.PI / 6, len, false);
|
||
var rightPnt = getThirdPoint(pnt1, pnt2, Math.PI / 6, len, true);
|
||
this.setCoordinates([pnt1, pnt2, leftPnt, pnt2, rightPnt]);
|
||
}
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
StraightArrow.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
StraightArrow.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
StraightArrow.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
StraightArrow.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
StraightArrow.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
StraightArrow.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
StraightArrow.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
StraightArrow.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
StraightArrow.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return StraightArrow;
|
||
}(ol.geom.LineString);
|
||
|
||
var FineArrow = function (_ol$geom$Polygon) {
|
||
inherits(FineArrow, _ol$geom$Polygon);
|
||
|
||
function FineArrow(coordinates, points, params) {
|
||
classCallCheck(this, FineArrow);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = FINE_ARROW;
|
||
_this.tailWidthFactor = 0.1;
|
||
_this.neckWidthFactor = 0.2;
|
||
_this.headWidthFactor = 0.25;
|
||
_this.headAngle = Math.PI / 8.5;
|
||
_this.neckAngle = Math.PI / 13;
|
||
_this.fixPointCount = 2;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
FineArrow.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
FineArrow.prototype.generate = function generate() {
|
||
try {
|
||
var cont = this.getPointCount();
|
||
if (cont < 2) {
|
||
return false;
|
||
} else {
|
||
var pnts = this.getPoints();
|
||
var _ref = [pnts[0], pnts[1]],
|
||
pnt1 = _ref[0],
|
||
pnt2 = _ref[1];
|
||
|
||
var len = getBaseLength(pnts);
|
||
var tailWidth = len * this.tailWidthFactor;
|
||
var neckWidth = len * this.neckWidthFactor;
|
||
var headWidth = len * this.headWidthFactor;
|
||
var tailLeft = getThirdPoint(pnt2, pnt1, HALF_PI, tailWidth, true);
|
||
var tailRight = getThirdPoint(pnt2, pnt1, HALF_PI, tailWidth, false);
|
||
var headLeft = getThirdPoint(pnt1, pnt2, this.headAngle, headWidth, false);
|
||
var headRight = getThirdPoint(pnt1, pnt2, this.headAngle, headWidth, true);
|
||
var neckLeft = getThirdPoint(pnt1, pnt2, this.neckAngle, neckWidth, false);
|
||
var neckRight = getThirdPoint(pnt1, pnt2, this.neckAngle, neckWidth, true);
|
||
var pList = [tailLeft, neckLeft, headLeft, pnt2, headRight, neckRight, tailRight];
|
||
this.setCoordinates([pList]);
|
||
}
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
FineArrow.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
FineArrow.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
FineArrow.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
FineArrow.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
FineArrow.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
FineArrow.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
FineArrow.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
FineArrow.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
FineArrow.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return FineArrow;
|
||
}(ol.geom.Polygon);
|
||
|
||
var AssaultDirection = function (_FineArrow) {
|
||
inherits(AssaultDirection, _FineArrow);
|
||
|
||
function AssaultDirection(coordinates, points, params) {
|
||
classCallCheck(this, AssaultDirection);
|
||
|
||
var _this = possibleConstructorReturn(this, _FineArrow.call(this, coordinates, points, params));
|
||
|
||
_this.tailWidthFactor = 0.05;
|
||
_this.neckWidthFactor = 0.1;
|
||
_this.headWidthFactor = 0.15;
|
||
_this.type = ASSAULT_DIRECTION;
|
||
_this.headAngle = Math.PI / 4;
|
||
_this.neckAngle = Math.PI * 0.17741;
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
_this.set('params', params);
|
||
return _this;
|
||
}
|
||
|
||
return AssaultDirection;
|
||
}(FineArrow);
|
||
|
||
var TailedAttackArrow = function (_AttackArrow) {
|
||
inherits(TailedAttackArrow, _AttackArrow);
|
||
|
||
function TailedAttackArrow(coordinates, points, params) {
|
||
classCallCheck(this, TailedAttackArrow);
|
||
|
||
var _this = possibleConstructorReturn(this, _AttackArrow.call(this, coordinates, points, params));
|
||
|
||
_this.type = TAILED_ATTACK_ARROW;
|
||
_this.headHeightFactor = 0.18;
|
||
_this.headWidthFactor = 0.3;
|
||
_this.neckHeightFactor = 0.85;
|
||
_this.neckWidthFactor = 0.15;
|
||
_this.tailWidthFactor = 0.1;
|
||
_this.headTailFactor = 0.8;
|
||
_this.swallowTailFactor = 1;
|
||
_this.swallowTailPnt = null;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
TailedAttackArrow.prototype.generate = function generate() {
|
||
try {
|
||
var points = this.getPointCount();
|
||
if (points < 2) {
|
||
return false;
|
||
} else if (points === 2) {
|
||
this.setCoordinates([this.points]);
|
||
return false;
|
||
} else {
|
||
var pnts = this.getPoints();
|
||
var _ref = [pnts[0], pnts[1]],
|
||
tailLeft = _ref[0],
|
||
tailRight = _ref[1];
|
||
|
||
if (isClockWise(pnts[0], pnts[1], pnts[2])) {
|
||
tailLeft = pnts[1];
|
||
tailRight = pnts[0];
|
||
}
|
||
var midTail = Mid(tailLeft, tailRight);
|
||
var bonePnts = [midTail].concat(pnts.slice(2));
|
||
var headPnts = this.getArrowHeadPoints(bonePnts, tailLeft, tailRight);
|
||
var _ref2 = [headPnts[0], headPnts[4]],
|
||
neckLeft = _ref2[0],
|
||
neckRight = _ref2[1];
|
||
|
||
var tailWidth = MathDistance(tailLeft, tailRight);
|
||
var allLen = getBaseLength(bonePnts);
|
||
var len = allLen * this.tailWidthFactor * this.swallowTailFactor;
|
||
this.swallowTailPnt = getThirdPoint(bonePnts[1], bonePnts[0], 0, len, true);
|
||
var factor = tailWidth / allLen;
|
||
var bodyPnts = this.getArrowBodyPoints(bonePnts, neckLeft, neckRight, factor);
|
||
var count = bodyPnts.length;
|
||
var leftPnts = [tailLeft].concat(bodyPnts.slice(0, count / 2));
|
||
leftPnts.push(neckLeft);
|
||
var rightPnts = [tailRight].concat(bodyPnts.slice(count / 2, count));
|
||
rightPnts.push(neckRight);
|
||
leftPnts = getQBSplinePoints(leftPnts);
|
||
rightPnts = getQBSplinePoints(rightPnts);
|
||
this.setCoordinates([leftPnts.concat(headPnts, rightPnts.reverse(), [this.swallowTailPnt, leftPnts[0]])]);
|
||
}
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
return TailedAttackArrow;
|
||
}(AttackArrow);
|
||
|
||
var SquadCombat = function (_AttackArrow) {
|
||
inherits(SquadCombat, _AttackArrow);
|
||
|
||
function SquadCombat(coordinates, points, params) {
|
||
classCallCheck(this, SquadCombat);
|
||
|
||
var _this = possibleConstructorReturn(this, _AttackArrow.call(this, coordinates, points, params));
|
||
|
||
_this.type = SQUAD_COMBAT;
|
||
_this.headHeightFactor = 0.18;
|
||
_this.headWidthFactor = 0.3;
|
||
_this.neckHeightFactor = 0.85;
|
||
_this.neckWidthFactor = 0.15;
|
||
_this.tailWidthFactor = 0.1;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
SquadCombat.prototype.generate = function generate() {
|
||
try {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else {
|
||
var pnts = this.getPoints();
|
||
var tailPnts = this.getTailPoints(pnts);
|
||
var headPnts = this.getArrowHeadPoints(pnts, tailPnts[0], tailPnts[1]);
|
||
var neckLeft = headPnts[0];
|
||
var neckRight = headPnts[4];
|
||
var bodyPnts = this.getArrowBodyPoints(pnts, neckLeft, neckRight, this.tailWidthFactor);
|
||
var _count = bodyPnts.length;
|
||
var leftPnts = [tailPnts[0]].concat(bodyPnts.slice(0, _count / 2));
|
||
leftPnts.push(neckLeft);
|
||
var rightPnts = [tailPnts[1]].concat(bodyPnts.slice(_count / 2, _count));
|
||
rightPnts.push(neckRight);
|
||
leftPnts = getQBSplinePoints(leftPnts);
|
||
rightPnts = getQBSplinePoints(rightPnts);
|
||
this.setCoordinates([leftPnts.concat(headPnts, rightPnts.reverse())]);
|
||
}
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
SquadCombat.prototype.getTailPoints = function getTailPoints(points) {
|
||
var allLen = getBaseLength(points);
|
||
var tailWidth = allLen * this.tailWidthFactor;
|
||
var tailLeft = getThirdPoint(points[1], points[0], HALF_PI, tailWidth, false);
|
||
var tailRight = getThirdPoint(points[1], points[0], HALF_PI, tailWidth, true);
|
||
return [tailLeft, tailRight];
|
||
};
|
||
|
||
return SquadCombat;
|
||
}(AttackArrow);
|
||
|
||
var TailedSquadCombat = function (_AttackArrow) {
|
||
inherits(TailedSquadCombat, _AttackArrow);
|
||
|
||
function TailedSquadCombat(coordinates, points, params) {
|
||
classCallCheck(this, TailedSquadCombat);
|
||
|
||
var _this = possibleConstructorReturn(this, _AttackArrow.call(this, coordinates, points, params));
|
||
|
||
_this.type = TAILED_SQUAD_COMBAT;
|
||
_this.headHeightFactor = 0.18;
|
||
_this.headWidthFactor = 0.3;
|
||
_this.neckHeightFactor = 0.85;
|
||
_this.neckWidthFactor = 0.15;
|
||
_this.tailWidthFactor = 0.1;
|
||
_this.swallowTailFactor = 1;
|
||
_this.swallowTailPnt = null;
|
||
_this.fixPointCount = 2;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
TailedSquadCombat.prototype.generate = function generate() {
|
||
try {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else {
|
||
var pnts = this.getPoints();
|
||
var tailPnts = this.getTailPoints(pnts);
|
||
var headPnts = this.getArrowHeadPoints(pnts, tailPnts[0], tailPnts[2]);
|
||
var neckLeft = headPnts[0];
|
||
var neckRight = headPnts[4];
|
||
var bodyPnts = this.getArrowBodyPoints(pnts, neckLeft, neckRight, this.tailWidthFactor);
|
||
var _count = bodyPnts.length;
|
||
var leftPnts = [tailPnts[0]].concat(bodyPnts.slice(0, _count / 2));
|
||
leftPnts.push(neckLeft);
|
||
var rightPnts = [tailPnts[2]].concat(bodyPnts.slice(_count / 2, _count));
|
||
rightPnts.push(neckRight);
|
||
leftPnts = getQBSplinePoints(leftPnts);
|
||
rightPnts = getQBSplinePoints(rightPnts);
|
||
this.setCoordinates([leftPnts.concat(headPnts, rightPnts.reverse(), [tailPnts[1], leftPnts[0]])]);
|
||
}
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
TailedSquadCombat.prototype.getTailPoints = function getTailPoints(points) {
|
||
var allLen = getBaseLength(points);
|
||
var tailWidth = allLen * this.tailWidthFactor;
|
||
var tailLeft = getThirdPoint(points[1], points[0], HALF_PI, tailWidth, false);
|
||
var tailRight = getThirdPoint(points[1], points[0], HALF_PI, tailWidth, true);
|
||
var len = tailWidth * this.swallowTailFactor;
|
||
var swallowTailPnt = getThirdPoint(points[1], points[0], 0, len, true);
|
||
return [tailLeft, swallowTailPnt, tailRight];
|
||
};
|
||
|
||
return TailedSquadCombat;
|
||
}(AttackArrow);
|
||
|
||
var GatheringPlace = function (_ol$geom$Polygon) {
|
||
inherits(GatheringPlace, _ol$geom$Polygon);
|
||
|
||
function GatheringPlace(coordinates, points, params) {
|
||
classCallCheck(this, GatheringPlace);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = GATHERING_PLACE;
|
||
_this.t = 0.4;
|
||
_this.fixPointCount = 3;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
GatheringPlace.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
GatheringPlace.prototype.generate = function generate() {
|
||
var pnts = this.getPoints();
|
||
var points = this.getPointCount();
|
||
if (pnts.length < 2) {
|
||
return false;
|
||
} else {
|
||
if (points === 2) {
|
||
var _mid = Mid(pnts[0], pnts[1]);
|
||
var d = MathDistance(pnts[0], _mid) / 0.9;
|
||
var pnt = getThirdPoint(pnts[0], _mid, HALF_PI, d, true);
|
||
pnts = [pnts[0], pnt, pnts[1]];
|
||
}
|
||
var mid = Mid(pnts[0], pnts[2]);
|
||
pnts.push(mid, pnts[0], pnts[1]);
|
||
var normals = [],
|
||
pnt1 = undefined,
|
||
pnt2 = undefined,
|
||
pnt3 = undefined,
|
||
pList = [];
|
||
|
||
for (var i = 0; i < pnts.length - 2; i++) {
|
||
pnt1 = pnts[i];
|
||
pnt2 = pnts[i + 1];
|
||
pnt3 = pnts[i + 2];
|
||
var normalPoints = getBisectorNormals(this.t, pnt1, pnt2, pnt3);
|
||
normals = normals.concat(normalPoints);
|
||
}
|
||
var count = normals.length;
|
||
normals = [normals[count - 1]].concat(normals.slice(0, count - 1));
|
||
for (var _i = 0; _i < pnts.length - 2; _i++) {
|
||
pnt1 = pnts[_i];
|
||
pnt2 = pnts[_i + 1];
|
||
pList.push(pnt1);
|
||
for (var t = 0; t <= FITTING_COUNT; t++) {
|
||
var _pnt = getCubicValue(t / FITTING_COUNT, pnt1, normals[_i * 2], normals[_i * 2 + 1], pnt2);
|
||
pList.push(_pnt);
|
||
}
|
||
pList.push(pnt2);
|
||
}
|
||
this.setCoordinates([pList]);
|
||
}
|
||
};
|
||
|
||
GatheringPlace.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
GatheringPlace.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
GatheringPlace.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
GatheringPlace.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
GatheringPlace.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
GatheringPlace.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
GatheringPlace.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
GatheringPlace.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
GatheringPlace.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return GatheringPlace;
|
||
}(ol.geom.Polygon);
|
||
|
||
var RectFlag = function (_ol$geom$Polygon) {
|
||
inherits(RectFlag, _ol$geom$Polygon);
|
||
|
||
function RectFlag(coordinates, points, params) {
|
||
classCallCheck(this, RectFlag);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = RECTFLAG;
|
||
_this.fixPointCount = 2;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
RectFlag.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
RectFlag.prototype.generate = function generate() {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else {
|
||
this.setCoordinates([this.calculatePonits(this.points)]);
|
||
}
|
||
};
|
||
|
||
RectFlag.prototype.calculatePonits = function calculatePonits(points) {
|
||
var components = [];
|
||
|
||
if (points.length > 1) {
|
||
var startPoint = points[0];
|
||
|
||
var endPoint = points[points.length - 1];
|
||
var point1 = [endPoint[0], startPoint[1]];
|
||
var point2 = [endPoint[0], (startPoint[1] + endPoint[1]) / 2];
|
||
var point3 = [startPoint[0], (startPoint[1] + endPoint[1]) / 2];
|
||
var point4 = [startPoint[0], endPoint[1]];
|
||
components = [startPoint, point1, point2, point3, point4];
|
||
}
|
||
return components;
|
||
};
|
||
|
||
RectFlag.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
RectFlag.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
RectFlag.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
RectFlag.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
RectFlag.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
RectFlag.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
RectFlag.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
RectFlag.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
RectFlag.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return RectFlag;
|
||
}(ol.geom.Polygon);
|
||
|
||
var TriangleFlag = function (_ol$geom$Polygon) {
|
||
inherits(TriangleFlag, _ol$geom$Polygon);
|
||
|
||
function TriangleFlag(coordinates, points, params) {
|
||
classCallCheck(this, TriangleFlag);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = TRIANGLEFLAG;
|
||
_this.fixPointCount = 2;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
TriangleFlag.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
TriangleFlag.prototype.generate = function generate() {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else {
|
||
this.setCoordinates([this.calculatePonits(this.points)]);
|
||
}
|
||
};
|
||
|
||
TriangleFlag.prototype.calculatePonits = function calculatePonits(points) {
|
||
var components = [];
|
||
|
||
if (points.length > 1) {
|
||
var startPoint = points[0];
|
||
|
||
var endPoint = points[points.length - 1];
|
||
var point1 = [endPoint[0], (startPoint[1] + endPoint[1]) / 2];
|
||
var point2 = [startPoint[0], (startPoint[1] + endPoint[1]) / 2];
|
||
var point3 = [startPoint[0], endPoint[1]];
|
||
components = [startPoint, point1, point2, point3];
|
||
}
|
||
return components;
|
||
};
|
||
|
||
TriangleFlag.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
TriangleFlag.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
TriangleFlag.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
TriangleFlag.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
TriangleFlag.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
TriangleFlag.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
TriangleFlag.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
TriangleFlag.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
TriangleFlag.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return TriangleFlag;
|
||
}(ol.geom.Polygon);
|
||
|
||
var CurveFlag = function (_ol$geom$Polygon) {
|
||
inherits(CurveFlag, _ol$geom$Polygon);
|
||
|
||
function CurveFlag(coordinates, points, params) {
|
||
classCallCheck(this, CurveFlag);
|
||
|
||
var _this = possibleConstructorReturn(this, _ol$geom$Polygon.call(this, []));
|
||
|
||
_this.type = CURVEFLAG;
|
||
_this.fixPointCount = 2;
|
||
_this.set('params', params);
|
||
if (points && points.length > 0) {
|
||
_this.setPoints(points);
|
||
} else if (coordinates && coordinates.length > 0) {
|
||
_this.setCoordinates(coordinates);
|
||
}
|
||
return _this;
|
||
}
|
||
|
||
CurveFlag.prototype.getPlotType = function getPlotType() {
|
||
return this.type;
|
||
};
|
||
|
||
CurveFlag.prototype.generate = function generate() {
|
||
var count = this.getPointCount();
|
||
if (count < 2) {
|
||
return false;
|
||
} else {
|
||
this.setCoordinates([this.calculatePonits(this.points)]);
|
||
}
|
||
};
|
||
|
||
CurveFlag.prototype.calculatePonits = function calculatePonits(points) {
|
||
var components = [];
|
||
|
||
if (points.length > 1) {
|
||
var startPoint = points[0];
|
||
|
||
var endPoint = points[points.length - 1];
|
||
|
||
var point1 = startPoint;
|
||
|
||
var point2 = [(endPoint[0] - startPoint[0]) / 4 + startPoint[0], (endPoint[1] - startPoint[1]) / 8 + startPoint[1]];
|
||
|
||
var point3 = [(startPoint[0] + endPoint[0]) / 2, startPoint[1]];
|
||
|
||
var point4 = [(endPoint[0] - startPoint[0]) * 3 / 4 + startPoint[0], -(endPoint[1] - startPoint[1]) / 8 + startPoint[1]];
|
||
|
||
var point5 = [endPoint[0], startPoint[1]];
|
||
|
||
var point6 = [endPoint[0], (startPoint[1] + endPoint[1]) / 2];
|
||
|
||
var point7 = [(endPoint[0] - startPoint[0]) * 3 / 4 + startPoint[0], (endPoint[1] - startPoint[1]) * 3 / 8 + startPoint[1]];
|
||
|
||
var point8 = [(startPoint[0] + endPoint[0]) / 2, (startPoint[1] + endPoint[1]) / 2];
|
||
|
||
var point9 = [(endPoint[0] - startPoint[0]) / 4 + startPoint[0], (endPoint[1] - startPoint[1]) * 5 / 8 + startPoint[1]];
|
||
|
||
var point10 = [startPoint[0], (startPoint[1] + endPoint[1]) / 2];
|
||
|
||
var point11 = [startPoint[0], endPoint[1]];
|
||
|
||
var curve1 = getBezierPoints([point1, point2, point3, point4, point5]);
|
||
|
||
var curve2 = getBezierPoints([point6, point7, point8, point9, point10]);
|
||
|
||
components = curve1.concat(curve2);
|
||
components.push(point11);
|
||
}
|
||
return components;
|
||
};
|
||
|
||
CurveFlag.prototype.setMap = function setMap(map) {
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
};
|
||
|
||
CurveFlag.prototype.getMap = function getMap() {
|
||
return this.map;
|
||
};
|
||
|
||
CurveFlag.prototype.isPlot = function isPlot() {
|
||
return true;
|
||
};
|
||
|
||
CurveFlag.prototype.setPoints = function setPoints(value) {
|
||
this.points = !value ? [] : value;
|
||
if (this.points.length >= 1) {
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
CurveFlag.prototype.getPoints = function getPoints() {
|
||
return this.points.slice(0);
|
||
};
|
||
|
||
CurveFlag.prototype.getPointCount = function getPointCount() {
|
||
return this.points.length;
|
||
};
|
||
|
||
CurveFlag.prototype.updatePoint = function updatePoint(point, index) {
|
||
if (index >= 0 && index < this.points.length) {
|
||
this.points[index] = point;
|
||
this.generate();
|
||
}
|
||
};
|
||
|
||
CurveFlag.prototype.updateLastPoint = function updateLastPoint(point) {
|
||
this.updatePoint(point, this.points.length - 1);
|
||
};
|
||
|
||
CurveFlag.prototype.finishDrawing = function finishDrawing() {};
|
||
|
||
return CurveFlag;
|
||
}(ol.geom.Polygon);
|
||
|
||
|
||
|
||
var Geometry = Object.freeze({
|
||
Point: Point,
|
||
Pennant: Pennant,
|
||
Polyline: Polyline,
|
||
Arc: Arc,
|
||
Circle: Circle,
|
||
Curve: Curve,
|
||
FreeHandLine: FreeHandLine,
|
||
RectAngle: RectAngle,
|
||
Ellipse: Ellipse,
|
||
Lune: Lune,
|
||
Sector: Sector,
|
||
ClosedCurve: ClosedCurve,
|
||
Polygon: Polygon,
|
||
FreePolygon: FreePolygon,
|
||
AttackArrow: AttackArrow,
|
||
DoubleArrow: DoubleArrow,
|
||
StraightArrow: StraightArrow,
|
||
FineArrow: FineArrow,
|
||
AssaultDirection: AssaultDirection,
|
||
TailedAttackArrow: TailedAttackArrow,
|
||
SquadCombat: SquadCombat,
|
||
TailedSquadCombat: TailedSquadCombat,
|
||
GatheringPlace: GatheringPlace,
|
||
RectFlag: RectFlag,
|
||
TriangleFlag: TriangleFlag,
|
||
CurveFlag: CurveFlag,
|
||
PlotTextBox: PlotTextBox
|
||
});
|
||
|
||
var $DrawInteraction = ol.interaction.Draw;
|
||
var $Style$1 = ol.style.Style;
|
||
var $Icon = ol.style.Icon;
|
||
var $Stroke$1 = ol.style.Stroke;
|
||
var $Fill$1 = ol.style.Fill;
|
||
|
||
var PlotDraw = function (_Observable) {
|
||
inherits(PlotDraw, _Observable);
|
||
|
||
function PlotDraw(map, params) {
|
||
classCallCheck(this, PlotDraw);
|
||
|
||
var _this = possibleConstructorReturn(this, _Observable.call(this));
|
||
|
||
if (map && map instanceof ol.Map) {
|
||
_this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
_this.options = params || {};
|
||
|
||
_this.points = null;
|
||
|
||
_this.plot = null;
|
||
|
||
_this.feature = null;
|
||
|
||
_this.plotType = null;
|
||
|
||
_this.plotParams = null;
|
||
|
||
_this.mapViewport = _this.map.getViewport();
|
||
|
||
_this.dblClickZoomInteraction = null;
|
||
|
||
_this.drawInteraction_ = null;
|
||
|
||
_this.layerName = _this.options && _this.options['layerName'] ? _this.options['layerName'] : BASE_LAYERNAME;
|
||
|
||
_this.drawLayer = createVectorLayer(_this.map, _this.layerName, {
|
||
create: true
|
||
});
|
||
_this.drawLayer.setZIndex(_this.options['zIndex'] || 99);
|
||
return _this;
|
||
}
|
||
|
||
PlotDraw.prototype.createPlot = function createPlot(type, points, _params) {
|
||
var params = _params || {};
|
||
switch (type) {
|
||
case TEXTAREA:
|
||
return 'TextArea';
|
||
case POINT:
|
||
return new Point([], points, params);
|
||
case PENNANT:
|
||
return new Pennant([], points, params);
|
||
case POLYLINE:
|
||
return new Polyline([], points, params);
|
||
case ARC:
|
||
return new Arc([], points, params);
|
||
case CIRCLE:
|
||
return new Circle([], points, params);
|
||
case CURVE:
|
||
return new Curve([], points, params);
|
||
case FREEHANDLINE:
|
||
return new FreeHandLine([], points, params);
|
||
case RECTANGLE:
|
||
return new RectAngle([], points, params);
|
||
case ELLIPSE:
|
||
return new Ellipse([], points, params);
|
||
case LUNE:
|
||
return new Lune([], points, params);
|
||
case SECTOR:
|
||
return new Sector([], points, params);
|
||
case CLOSED_CURVE:
|
||
return new ClosedCurve([], points, params);
|
||
case POLYGON:
|
||
return new Polygon([], points, params);
|
||
case ATTACK_ARROW:
|
||
return new AttackArrow([], points, params);
|
||
case FREE_POLYGON:
|
||
return new FreePolygon([], points, params);
|
||
case DOUBLE_ARROW:
|
||
return new DoubleArrow([], points, params);
|
||
case STRAIGHT_ARROW:
|
||
return new StraightArrow([], points, params);
|
||
case FINE_ARROW:
|
||
return new FineArrow([], points, params);
|
||
case ASSAULT_DIRECTION:
|
||
return new AssaultDirection([], points, params);
|
||
case TAILED_ATTACK_ARROW:
|
||
return new TailedAttackArrow([], points, params);
|
||
case SQUAD_COMBAT:
|
||
return new SquadCombat([], points, params);
|
||
case TAILED_SQUAD_COMBAT:
|
||
return new TailedSquadCombat([], points, params);
|
||
case GATHERING_PLACE:
|
||
return new GatheringPlace([], points, params);
|
||
case RECTFLAG:
|
||
return new RectFlag([], points, params);
|
||
case TRIANGLEFLAG:
|
||
return new TriangleFlag([], points, params);
|
||
case CURVEFLAG:
|
||
return new CurveFlag([], points, params);
|
||
}
|
||
return null;
|
||
};
|
||
|
||
PlotDraw.prototype.active = function active(type) {
|
||
var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
|
||
this.disActive();
|
||
this.deactiveMapTools();
|
||
this.plotType = type;
|
||
this.plotParams = params;
|
||
if (type === TEXTAREA) {
|
||
this.activeInteraction();
|
||
} else if (Object.keys(PlotTypes).some(function (key) {
|
||
return PlotTypes[key] === type;
|
||
})) {
|
||
this.map.on('click', this.mapFirstClickHandler, this);
|
||
} else {
|
||
console.warn('不存在的标绘类型！');
|
||
}
|
||
};
|
||
|
||
PlotDraw.prototype.activeInteraction = function activeInteraction() {
|
||
this.drawInteraction_ = new $DrawInteraction({
|
||
style: new $Style$1({
|
||
fill: new $Fill$1({
|
||
color: 'rgba(255, 255, 255, 0.7)'
|
||
}),
|
||
stroke: new $Stroke$1({
|
||
color: 'rgba(0, 0, 0, 0.15)',
|
||
width: 2
|
||
}),
|
||
image: new $Icon({
|
||
anchor: [1, 1],
|
||
anchorXUnits: 'fraction',
|
||
anchorYUnits: 'fraction',
|
||
opacity: 0.75,
|
||
src: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAABgklEQVQ4T41T0W3CQAy1lfwRqR0h/CE5UhkBJmiZADpB0wlKJwA2aDegE5QR+Igl/noj9OPuLydXPuXQEYUKS5FyPvvd87ONRDRFxEdr7c4Y8ws3WFmW90VRvIjIF1ZVtQaANxH59N6v8zwvRaQEgCMATDu88I+Ipm1bk2XZHhEfAOAdFW00Gh2YOQafOeidHoaYEdGHc65GDZhMJuXpdDJ99hqkPmZe9e9iTgCoqmrWNM0hDerq/FGftXbcZxFzAgARrZg5vBaNiGpE3OhZRF6Zedu7DzkRYMrMKlQKYBBRQVVgw8zj3n3IGWSg9ESkds6tiqJQbe4AYJ6WGVkPAqh4+romdP9LbXMqZh/gXIKqm+d5EK9vbduOY7d0AAdL6AYLmqbRAQtGRMc4ONF/wSC2RF/PsuwbABapqLEjKqb3fq4sLtoYh6Lbiydr7TbtuwYDgH5qB9XmPEjdKG+Y+Xmo7ms+Lcs5N0uX6ei9X9y4TGtEXIZlukb7PzbdmNcisv8DtQILak2vZsYAAAAASUVORK5CYII='
|
||
})
|
||
}),
|
||
type: 'Circle',
|
||
geometryFunction: $DrawInteraction.createBox()
|
||
});
|
||
this.map.addInteraction(this.drawInteraction_);
|
||
this.drawInteraction_.on('drawend', this.textAreaDrawEnd, this);
|
||
};
|
||
|
||
PlotDraw.prototype.textAreaDrawEnd = function textAreaDrawEnd(event) {
|
||
if (event && event.feature) {
|
||
this.map.removeInteraction(this.drawInteraction_);
|
||
var extent = event.feature.getGeometry().getExtent();
|
||
var _center = [(extent[0] + extent[2]) / 2, (extent[1] + extent[3]) / 2];
|
||
var topLeft = this.map.getPixelFromCoordinate([extent[0], extent[1]]);
|
||
var bottomRight = this.map.getPixelFromCoordinate([extent[2], extent[3]]);
|
||
var _ref = [Math.abs(topLeft[0] - bottomRight[0]), Math.abs(topLeft[1] - bottomRight[1])],
|
||
_width = _ref[0],
|
||
_height = _ref[1];
|
||
|
||
var _plotText = new PlotTextBox({
|
||
id: getuuid(),
|
||
position: _center,
|
||
value: '',
|
||
width: _width,
|
||
height: _height,
|
||
style: {
|
||
width: _width + 'px',
|
||
height: _height + 'px'
|
||
}
|
||
});
|
||
if (this.map && this.map instanceof ol.Map && _plotText) {
|
||
this.map.addOverlay(_plotText);
|
||
} else {
|
||
console.warn('未传入地图对象或者plotText创建失败！');
|
||
}
|
||
} else {
|
||
console.info('未获取到要素！');
|
||
}
|
||
};
|
||
|
||
PlotDraw.prototype.disActive = function disActive() {
|
||
this.removeEventHandlers();
|
||
if (this.drawInteraction_) {
|
||
this.map.removeInteraction(this.drawInteraction_);
|
||
this.drawInteraction_ = null;
|
||
}
|
||
this.points = [];
|
||
this.plot = null;
|
||
this.feature = null;
|
||
this.plotType = null;
|
||
this.plotParams = null;
|
||
this.activateMapTools();
|
||
};
|
||
|
||
PlotDraw.prototype.isDrawing = function isDrawing() {
|
||
return !!this.plotType;
|
||
};
|
||
|
||
PlotDraw.prototype.mapFirstClickHandler = function mapFirstClickHandler(event) {
|
||
this.map.un('click', this.mapFirstClickHandler, this);
|
||
this.points.push(event.coordinate);
|
||
this.plot = this.createPlot(this.plotType, this.points, this.plotParams);
|
||
this.feature = new ol.Feature(this.plot);
|
||
this.feature.set('isPlot', true);
|
||
this.drawLayer.getSource().addFeature(this.feature);
|
||
if (this.plotType === POINT || this.plotType === PENNANT) {
|
||
this.plot.finishDrawing();
|
||
this.drawEnd(event);
|
||
} else {
|
||
this.map.on('click', this.mapNextClickHandler, this);
|
||
if (!this.plot.freehand) {
|
||
this.map.on('dblclick', this.mapDoubleClickHandler, this);
|
||
}
|
||
this.map.un('pointermove', this.mapMouseMoveHandler, this);
|
||
this.map.on('pointermove', this.mapMouseMoveHandler, this);
|
||
}
|
||
if (this.plotType && this.feature) {
|
||
this.plotParams['plotType'] = this.plotType;
|
||
this.feature.setProperties(this.plotParams);
|
||
}
|
||
};
|
||
|
||
PlotDraw.prototype.mapNextClickHandler = function mapNextClickHandler(event) {
|
||
if (!this.plot.freehand) {
|
||
if (MathDistance(event.coordinate, this.points[this.points.length - 1]) < 0.0001) {
|
||
return false;
|
||
}
|
||
}
|
||
this.points.push(event.coordinate);
|
||
this.plot.setPoints(this.points);
|
||
if (this.plot.fixPointCount === this.plot.getPointCount()) {
|
||
this.mapDoubleClickHandler(event);
|
||
}
|
||
if (this.plot && this.plot.freehand) {
|
||
this.mapDoubleClickHandler(event);
|
||
}
|
||
};
|
||
|
||
PlotDraw.prototype.mapDoubleClickHandler = function mapDoubleClickHandler(event) {
|
||
event.preventDefault();
|
||
this.plot.finishDrawing();
|
||
this.drawEnd(event);
|
||
};
|
||
|
||
PlotDraw.prototype.mapMouseMoveHandler = function mapMouseMoveHandler(event) {
|
||
var coordinate = event.coordinate;
|
||
if (MathDistance(coordinate, this.points[this.points.length - 1]) < 0.0001) {
|
||
return false;
|
||
}
|
||
if (!this.plot.freehand) {
|
||
var pnts = this.points.concat([coordinate]);
|
||
this.plot.setPoints(pnts);
|
||
} else {
|
||
this.points.push(coordinate);
|
||
this.plot.setPoints(this.points);
|
||
}
|
||
};
|
||
|
||
PlotDraw.prototype.removeEventHandlers = function removeEventHandlers() {
|
||
this.map.un('click', this.mapFirstClickHandler, this);
|
||
this.map.un('click', this.mapNextClickHandler, this);
|
||
this.map.un('pointermove', this.mapMouseMoveHandler, this);
|
||
this.map.un('dblclick', this.mapDoubleClickHandler, this);
|
||
};
|
||
|
||
PlotDraw.prototype.drawEnd = function drawEnd(event) {
|
||
this.dispatchSync('drawEnd', {
|
||
type: 'drawEnd',
|
||
originalEvent: event,
|
||
feature: this.feature
|
||
});
|
||
if (this.feature && this.options['isClear']) {
|
||
this.drawLayer.getSource().removeFeature(this.feature);
|
||
}
|
||
this.disActive();
|
||
};
|
||
|
||
PlotDraw.prototype.addFeature = function addFeature() {
|
||
this.feature = new ol.Feature(this.plot);
|
||
if (this.feature && this.drawLayer) {
|
||
this.drawLayer.getSource().addFeature(this.feature);
|
||
}
|
||
};
|
||
|
||
PlotDraw.prototype.deactiveMapTools = function deactiveMapTools() {
|
||
var _this2 = this;
|
||
|
||
var interactions = this.map.getInteractions().getArray();
|
||
interactions.every(function (item) {
|
||
if (item instanceof ol.interaction.DoubleClickZoom) {
|
||
_this2.dblClickZoomInteraction = item;
|
||
_this2.map.removeInteraction(item);
|
||
return false;
|
||
} else {
|
||
return true;
|
||
}
|
||
});
|
||
};
|
||
|
||
PlotDraw.prototype.activateMapTools = function activateMapTools() {
|
||
if (this.dblClickZoomInteraction && this.dblClickZoomInteraction instanceof ol.interaction.DoubleClickZoom) {
|
||
this.map.addInteraction(this.dblClickZoomInteraction);
|
||
this.dblClickZoomInteraction = null;
|
||
}
|
||
};
|
||
|
||
return PlotDraw;
|
||
}(Observable);
|
||
|
||
var PlotEdit = function (_Observable) {
|
||
inherits(PlotEdit, _Observable);
|
||
|
||
function PlotEdit(map) {
|
||
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
classCallCheck(this, PlotEdit);
|
||
|
||
var _this = possibleConstructorReturn(this, _Observable.call(this));
|
||
|
||
if (map && map instanceof ol.Map) {
|
||
_this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
|
||
_this.options = options;
|
||
|
||
_this.mapViewport = _this.map.getViewport();
|
||
|
||
_this.activePlot = null;
|
||
|
||
_this.startPoint = null;
|
||
|
||
_this.ghostControlPoints = null;
|
||
|
||
_this.controlPoints = null;
|
||
|
||
_this.mouseOver = false;
|
||
|
||
_this.elementTable = {};
|
||
|
||
_this.activeControlPointId = null;
|
||
|
||
_this.mapDragPan = null;
|
||
|
||
_this.previousCursor_ = null;
|
||
return _this;
|
||
}
|
||
|
||
PlotEdit.prototype.initHelperDom = function initHelperDom() {
|
||
var _this2 = this;
|
||
|
||
if (!this.map || !this.activePlot) {
|
||
return false;
|
||
}
|
||
var parent = this.getMapParentElement();
|
||
if (!parent) {
|
||
return false;
|
||
} else {
|
||
var hiddenDiv = createHidden('div', parent, BASE_HELP_HIDDEN);
|
||
var cPnts = this.getControlPoints();
|
||
if (cPnts && Array.isArray(cPnts) && cPnts.length > 0) {
|
||
cPnts.forEach(function (item, index) {
|
||
var id = BASE_HELP_CONTROL_POINT_ID + '-' + index;
|
||
create('div', BASE_HELP_CONTROL_POINT_ID, hiddenDiv, id);
|
||
_this2.elementTable[id] = index;
|
||
});
|
||
}
|
||
}
|
||
};
|
||
|
||
PlotEdit.prototype.getMapParentElement = function getMapParentElement() {
|
||
var mapElement = this.map.getTargetElement();
|
||
if (!mapElement) {
|
||
return false;
|
||
} else {
|
||
return mapElement.parentNode;
|
||
}
|
||
};
|
||
|
||
PlotEdit.prototype.destroyHelperDom = function destroyHelperDom() {
|
||
var _this3 = this;
|
||
|
||
if (this.controlPoints && Array.isArray(this.controlPoints) && this.controlPoints.length > 0) {
|
||
this.controlPoints.forEach(function (item, index) {
|
||
if (item && item instanceof ol.Overlay) {
|
||
_this3.map.removeOverlay(item);
|
||
}
|
||
var element = getElement(BASE_HELP_CONTROL_POINT_ID + '-' + index);
|
||
if (element) {
|
||
off(element, 'mousedown', _this3.controlPointMouseDownHandler.bind(_this3));
|
||
off(element, 'mousemove', _this3.controlPointMouseMoveHandler2.bind(_this3));
|
||
}
|
||
});
|
||
this.controlPoints = [];
|
||
}
|
||
var parent = this.getMapParentElement();
|
||
var hiddenDiv = getElement(BASE_HELP_HIDDEN);
|
||
if (hiddenDiv && parent) {
|
||
remove(hiddenDiv, parent);
|
||
}
|
||
};
|
||
|
||
PlotEdit.prototype.initControlPoints = function initControlPoints() {
|
||
this.controlPoints = [];
|
||
var cPnts = this.getControlPoints();
|
||
if (cPnts && Array.isArray(cPnts) && cPnts.length > 0) {
|
||
if (cPnts.length > this.options['limitControlPoints'] && this.options.hasOwnProperty('limitControlPoints') && this.options['limitControlPoints'] > 2) {
|
||
var _n = Math.floor(cPnts.length / (this.options['limitControlPoints'] - 2)) || 1;
|
||
for (var i = 0; i < this.options['limitControlPoints'] - 2; i++) {
|
||
var _index = (i + 1) * _n - 1;
|
||
this._addControlPoint(cPnts, _index);
|
||
}
|
||
this._addControlPoint(cPnts, 0);
|
||
this._addControlPoint(cPnts, cPnts.length - 1);
|
||
} else {
|
||
for (var _i = 0; _i < cPnts.length; _i++) {
|
||
this._addControlPoint(cPnts, _i);
|
||
}
|
||
}
|
||
this.map.render();
|
||
}
|
||
};
|
||
|
||
PlotEdit.prototype._addControlPoint = function _addControlPoint(points, _index) {
|
||
var id = BASE_HELP_CONTROL_POINT_ID + '-' + _index;
|
||
this.elementTable[id] = _index;
|
||
var element = getElement(id);
|
||
var pnt = new ol.Overlay({
|
||
id: id,
|
||
position: points[_index],
|
||
positioning: 'center-center',
|
||
element: element
|
||
});
|
||
this.controlPoints.push(pnt);
|
||
this.map.addOverlay(pnt);
|
||
on(element, 'mousedown', this.controlPointMouseDownHandler.bind(this));
|
||
on(element, 'mousemove', this.controlPointMouseMoveHandler2.bind(this));
|
||
};
|
||
|
||
PlotEdit.prototype.controlPointMouseMoveHandler2 = function controlPointMouseMoveHandler2(e) {
|
||
e.stopImmediatePropagation();
|
||
};
|
||
|
||
PlotEdit.prototype.controlPointMouseDownHandler = function controlPointMouseDownHandler(e) {
|
||
this.activeControlPointId = e.target.id;
|
||
this.map.on('pointermove', this.controlPointMouseMoveHandler, this);
|
||
on(this.mapViewport, 'mouseup', this.controlPointMouseUpHandler.bind(this));
|
||
};
|
||
|
||
PlotEdit.prototype.controlPointMouseMoveHandler = function controlPointMouseMoveHandler(event) {
|
||
var coordinate = event.coordinate;
|
||
if (this.activeControlPointId) {
|
||
var plot = this.activePlot.getGeometry();
|
||
var index = this.elementTable[this.activeControlPointId];
|
||
plot.updatePoint(coordinate, index);
|
||
var overlay = this.map.getOverlayById(this.activeControlPointId);
|
||
if (overlay) {
|
||
overlay.setPosition(coordinate);
|
||
}
|
||
}
|
||
};
|
||
|
||
PlotEdit.prototype.controlPointMouseUpHandler = function controlPointMouseUpHandler(event) {
|
||
this.map.un('pointermove', this.controlPointMouseMoveHandler, this);
|
||
off(this.mapViewport, 'mouseup', this.controlPointMouseUpHandler.bind(this));
|
||
};
|
||
|
||
PlotEdit.prototype.activate = function activate(plot) {
|
||
var _this4 = this;
|
||
|
||
if (plot && plot instanceof ol.Feature && plot.get('isPlot') && plot.getGeometry().isPlot && plot !== this.activePlot) {
|
||
this.deactivate();
|
||
this.activePlot = plot;
|
||
this.previousCursor_ = this.map.getTargetElement().style.cursor;
|
||
window.setTimeout(function () {
|
||
_this4.dispatch('active_plot_change', _this4.activePlot);
|
||
}, 500);
|
||
this.map.on('pointermove', this.plotMouseOverOutHandler, this);
|
||
this.initHelperDom();
|
||
this.initControlPoints();
|
||
}
|
||
};
|
||
|
||
PlotEdit.prototype.getControlPoints = function getControlPoints() {
|
||
var points = [];
|
||
if (this.activePlot) {
|
||
var geom = this.activePlot.getGeometry();
|
||
if (geom) {
|
||
points = geom.getPoints();
|
||
}
|
||
}
|
||
return points;
|
||
};
|
||
|
||
PlotEdit.prototype.plotMouseOverOutHandler = function plotMouseOverOutHandler(e) {
|
||
var feature = this.map.forEachFeatureAtPixel(e.pixel, function (feature) {
|
||
return feature;
|
||
});
|
||
if (feature && feature === this.activePlot) {
|
||
if (!this.mouseOver) {
|
||
this.mouseOver = true;
|
||
this.map.getTargetElement().style.cursor = 'move';
|
||
this.map.on('pointerdown', this.plotMouseDownHandler, this);
|
||
}
|
||
} else {
|
||
if (this.mouseOver) {
|
||
this.mouseOver = false;
|
||
this.map.getTargetElement().style.cursor = 'default';
|
||
this.map.un('pointerdown', this.plotMouseDownHandler, this);
|
||
}
|
||
}
|
||
return feature;
|
||
};
|
||
|
||
PlotEdit.prototype.plotMouseDownHandler = function plotMouseDownHandler(event) {
|
||
this.ghostControlPoints = this.getControlPoints();
|
||
this.startPoint = event.coordinate;
|
||
this.disableMapDragPan();
|
||
this.map.on('pointerup', this.plotMouseUpHandler, this);
|
||
this.map.on('pointerdrag', this.plotMouseMoveHandler, this);
|
||
};
|
||
|
||
PlotEdit.prototype.plotMouseMoveHandler = function plotMouseMoveHandler(event) {
|
||
var deltaX = event.coordinate[0] - this.startPoint[0],
|
||
deltaY = event.coordinate[1] - this.startPoint[1],
|
||
newPoints = [];
|
||
|
||
if (this.ghostControlPoints && Array.isArray(this.ghostControlPoints) && this.ghostControlPoints.length > 0) {
|
||
for (var i = 0; i < this.ghostControlPoints.length; i++) {
|
||
var coordinate = [this.ghostControlPoints[i][0] + deltaX, this.ghostControlPoints[i][1] + deltaY];
|
||
newPoints.push(coordinate);
|
||
var id = BASE_HELP_CONTROL_POINT_ID + '-' + i;
|
||
var overlay = this.map.getOverlayById(id);
|
||
if (overlay) {
|
||
overlay.setPosition(coordinate);
|
||
overlay.setPositioning('center-center');
|
||
}
|
||
}
|
||
}
|
||
var _geometry = this.activePlot.getGeometry();
|
||
_geometry.setPoints(newPoints);
|
||
};
|
||
|
||
PlotEdit.prototype.plotMouseUpHandler = function plotMouseUpHandler(event) {
|
||
this.enableMapDragPan();
|
||
this.map.un('pointerup', this.plotMouseUpHandler, this);
|
||
this.map.un('pointerdrag', this.plotMouseMoveHandler, this);
|
||
};
|
||
|
||
PlotEdit.prototype.disconnectEventHandlers = function disconnectEventHandlers() {
|
||
this.map.un('pointermove', this.plotMouseOverOutHandler, this);
|
||
this.map.un('pointermove', this.controlPointMouseMoveHandler, this);
|
||
off(this.mapViewport, 'mouseup', this.controlPointMouseUpHandler.bind(this));
|
||
this.map.un('pointerdown', this.plotMouseDownHandler, this);
|
||
this.map.un('pointerup', this.plotMouseUpHandler, this);
|
||
this.map.un('pointerdrag', this.plotMouseMoveHandler, this);
|
||
};
|
||
|
||
PlotEdit.prototype.deactivate = function deactivate() {
|
||
this.activePlot = null;
|
||
this.mouseOver = false;
|
||
this.map.getTargetElement().style.cursor = this.previousCursor_;
|
||
this.previousCursor_ = null;
|
||
this.destroyHelperDom();
|
||
this.disconnectEventHandlers();
|
||
this.enableMapDragPan();
|
||
this.elementTable = {};
|
||
this.activeControlPointId = null;
|
||
this.startPoint = null;
|
||
};
|
||
|
||
PlotEdit.prototype.disableMapDragPan = function disableMapDragPan() {
|
||
var _this5 = this;
|
||
|
||
var interactions = this.map.getInteractions().getArray();
|
||
interactions.every(function (item) {
|
||
if (item instanceof ol.interaction.DragPan) {
|
||
_this5.mapDragPan = item;
|
||
_this5.map.removeInteraction(item);
|
||
return false;
|
||
} else {
|
||
return true;
|
||
}
|
||
});
|
||
};
|
||
|
||
PlotEdit.prototype.enableMapDragPan = function enableMapDragPan() {
|
||
if (this.mapDragPan && this.mapDragPan instanceof ol.interaction.DragPan) {
|
||
this.map.addInteraction(this.mapDragPan);
|
||
this.mapDragPan = null;
|
||
}
|
||
};
|
||
|
||
PlotEdit.getLimitControlPoints = function getLimitControlPoints(points, limit) {
|
||
var _coordinates = [];
|
||
if (points && points.length > 0) {
|
||
var _n = Math.floor(points.length / limit) || 1;
|
||
for (var i = 0; i < limit; i++) {
|
||
_coordinates.push(points[(i + 1) * _n - 1]);
|
||
}
|
||
}
|
||
return _coordinates;
|
||
};
|
||
|
||
return PlotEdit;
|
||
}(Observable);
|
||
|
||
var StyleFactory = function StyleFactory(options) {
|
||
var option = options && (typeof options === 'undefined' ? 'undefined' : _typeof(options)) === 'object' ? options : {};
|
||
var style = new ol.style.Style({});
|
||
if (option['geometry'] && option['geometry'] instanceof ol.geom.Geometry) {
|
||
style.setGeometry(option['geometry']);
|
||
}
|
||
if (option['zIndex'] && typeof option['zIndex'] === 'number') {
|
||
style.setZIndex(option['zIndex']);
|
||
}
|
||
if (option['fill'] && _typeof(option['fill']) === 'object') {
|
||
style.setFill(this._getFill(option['fill']));
|
||
}
|
||
if (option['image'] && _typeof(option['image']) === 'object') {
|
||
style.setImage(this._getImage(option['image']));
|
||
}
|
||
if (option['stroke'] && _typeof(option['stroke']) === 'object') {
|
||
style.setStroke(this._getStroke(option['stroke']));
|
||
}
|
||
if (option['text'] && _typeof(option['text']) === 'object') {
|
||
style.setText(this._getText(option['text']));
|
||
}
|
||
return style;
|
||
};
|
||
|
||
StyleFactory.prototype._getRegularShape = function (options) {
|
||
try {
|
||
var regularShape = new ol.style.RegularShape({
|
||
fill: this._getFill(options['fill']) || undefined,
|
||
points: typeof options['points'] === 'number' ? options['points'] : 1,
|
||
radius: typeof options['radius'] === 'number' ? options['radius'] : undefined,
|
||
radius1: typeof options['radius1'] === 'number' ? options['radius1'] : undefined,
|
||
radius2: typeof options['radius2'] === 'number' ? options['radius2'] : undefined,
|
||
angle: typeof options['angle'] === 'number' ? options['angle'] : 0,
|
||
snapToPixel: typeof options['snapToPixel'] === 'boolean' ? options['snapToPixel'] : true,
|
||
stroke: this._getStroke(options['stroke']) || undefined,
|
||
rotation: typeof options['rotation'] === 'number' ? options['rotation'] : 0,
|
||
rotateWithView: typeof options['rotateWithView'] === 'boolean' ? options['rotateWithView'] : false,
|
||
atlasManager: options['atlasManager'] ? options['atlasManager'] : undefined
|
||
});
|
||
return regularShape;
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
StyleFactory.prototype._getImage = function (options) {
|
||
try {
|
||
var image = void 0;
|
||
options = options || {};
|
||
if (options['type'] === 'icon') {
|
||
image = this._getIcon(options['image']);
|
||
} else {
|
||
image = this._getRegularShape(options['image']);
|
||
}
|
||
return image;
|
||
} catch (e) {
|
||
console.log(e);
|
||
}
|
||
};
|
||
|
||
StyleFactory.prototype._getIcon = function (options) {
|
||
try {
|
||
options = options || {};
|
||
var icon = new ol.style.Icon({
|
||
anchor: options['imageAnchor'] ? options['imageAnchor'] : [0.5, 0.5],
|
||
anchorXUnits: options['imageAnchorXUnits'] ? options['imageAnchorXUnits'] : 'fraction',
|
||
anchorYUnits: options['imageAnchorYUnits'] ? options['imageAnchorYUnits'] : 'fraction',
|
||
anchorOrigin: options['imageAnchorOrigin'] ? options['imageAnchorYUnits'] : 'top-left',
|
||
color: options['imageColor'] ? options['imageColor'] : undefined,
|
||
crossOrigin: options['crossOrigin'] ? options['crossOrigin'] : undefined,
|
||
img: options['img'] ? options['img'] : undefined,
|
||
offset: options['offset'] && Array.isArray(options['offset']) && options['offset'].length === 2 ? options['offset'] : [0, 0],
|
||
offsetOrigin: options['offsetOrigin'] ? options['offsetOrigin'] : 'top-left',
|
||
scale: typeof options['scale'] === 'number' ? options['scale'] : 1,
|
||
snapToPixel: typeof options['snapToPixel'] === 'boolean' ? options['snapToPixel'] : true,
|
||
rotateWithView: typeof options['rotateWithView'] === 'boolean' ? options['rotateWithView'] : false,
|
||
opacity: typeof options['imageOpacity'] === 'number' ? options['imageOpacity'] : 1,
|
||
rotation: typeof options['imageRotation'] === 'number' ? options['imageRotation'] : 0,
|
||
size: options['size'] && Array.isArray(options['size']) && options['size'].length === 2 ? options['size'] : undefined,
|
||
imgSize: options['imgSize'] && Array.isArray(options['imgSize']) && options['imgSize'].length === 2 ? options['imgSize'] : undefined,
|
||
src: options['imageSrc'] ? options['imageSrc'] : undefined
|
||
});
|
||
return icon;
|
||
} catch (error) {
|
||
console.log(error);
|
||
}
|
||
};
|
||
|
||
StyleFactory.prototype._getStroke = function (options) {
|
||
try {
|
||
options = options || {};
|
||
var stroke = new ol.style.Stroke({
|
||
color: options['strokeColor'] ? options['strokeColor'] : undefined,
|
||
lineCap: options['strokeLineCap'] && typeof options['strokeLineCap'] === 'string' ? options['strokeLineCap'] : 'round',
|
||
lineJoin: options['strokeLineJoin'] && typeof options['strokeLineJoin'] === 'string' ? options['strokeLineJoin'] : 'round',
|
||
lineDash: options['strokeLineDash'] ? options['strokeLineDash'] : undefined,
|
||
lineDashOffset: typeof options['strokeLineDashOffset'] === 'number' ? options['strokeLineDashOffset'] : '0',
|
||
miterLimit: typeof options['strokeMiterLimit'] === 'number' ? options['strokeMiterLimit'] : 10,
|
||
width: typeof options['strokeWidth'] === 'number' ? options['strokeWidth'] : undefined
|
||
});
|
||
return stroke;
|
||
} catch (error) {
|
||
console.log(error);
|
||
}
|
||
};
|
||
|
||
StyleFactory.prototype._getText = function (options) {
|
||
try {
|
||
var text = new ol.style.Text({
|
||
font: options['textFont'] && typeof options['textFont'] === 'string' ? options['textFont'] : '10px sans-serif',
|
||
offsetX: typeof options['textOffsetX'] === 'number' ? options['textOffsetX'] : 0,
|
||
offsetY: typeof options['textOffsetY'] === 'number' ? options['textOffsetY'] : 0,
|
||
scale: typeof options['textScale'] === 'number' ? options['textScale'] : undefined,
|
||
rotation: typeof options['textRotation'] === 'number' ? options['textRotation'] : 0,
|
||
text: options['text'] && typeof options['text'] === 'string' ? options['text'] : undefined,
|
||
textAlign: options['textAlign'] && typeof options['textAlign'] === 'string' ? options['textAlign'] : 'start',
|
||
textBaseline: options['textBaseline'] && typeof options['textBaseline'] === 'string' ? options['textBaseline'] : 'alphabetic',
|
||
rotateWithView: typeof options['rotateWithView'] === 'boolean' ? options['rotateWithView'] : false,
|
||
fill: this._getFill(options['textFill']),
|
||
stroke: this._getStroke(options['textStroke'])
|
||
});
|
||
return text;
|
||
} catch (error) {
|
||
console.log(error);
|
||
}
|
||
};
|
||
|
||
StyleFactory.prototype._getFill = function (options) {
|
||
try {
|
||
options = options || {};
|
||
var fill = new ol.style.Fill({
|
||
color: options['fillColor'] ? options['fillColor'] : undefined
|
||
});
|
||
return fill;
|
||
} catch (error) {
|
||
console.log(error);
|
||
}
|
||
};
|
||
|
||
var PlotUtils = function () {
|
||
function PlotUtils(map, options) {
|
||
classCallCheck(this, PlotUtils);
|
||
|
||
if (map && map instanceof ol.Map) {
|
||
this.map = map;
|
||
} else {
|
||
throw new Error('传入的不是地图对象！');
|
||
}
|
||
|
||
this.options = options;
|
||
this.layerName = this.options && this.options['layerName'] ? this.options['layerName'] : BASE_LAYERNAME;
|
||
}
|
||
|
||
PlotUtils.prototype.getBaseStyle = function getBaseStyle(feature) {
|
||
var style = feature.getStyle();
|
||
if (!style) {
|
||
var layer = getLayerByLayerName(this.map, this.layerName);
|
||
if (layer && layer instanceof ol.layer.Vector) {
|
||
style = layer.getStyle();
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
return style;
|
||
};
|
||
|
||
PlotUtils.prototype.setIcon = function setIcon(feature, image) {
|
||
try {
|
||
if (feature && feature instanceof ol.Feature) {
|
||
var style = this.getBaseStyle(feature);
|
||
var tempStyle = style.clone();
|
||
var _image = this._getImage(image);
|
||
if (_image) {
|
||
tempStyle.setImage(_image);
|
||
feature.setStyle(tempStyle);
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn(e);
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype.setBackgroundColor = function setBackgroundColor(feature, backgroundColor) {
|
||
try {
|
||
if (feature && feature instanceof ol.Feature) {
|
||
var style = this.getBaseStyle(feature);
|
||
var tempStyle = style.clone();
|
||
var fill = tempStyle.getFill();
|
||
var color = fill.getColor();
|
||
if (color) {
|
||
var tempColor = ol.color.asArray(color);
|
||
var _color = ol.color.asArray(backgroundColor);
|
||
var currentColor = this.handleBackgroundColor(_color, tempColor[3]);
|
||
fill.setColor(currentColor);
|
||
feature.setStyle(tempStyle);
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn(e);
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype.setOpacity = function setOpacity(feature, opacity) {
|
||
try {
|
||
if (feature && feature instanceof ol.Feature) {
|
||
var style = this.getBaseStyle(feature);
|
||
if (style) {
|
||
var tempStyle = style.clone();
|
||
var fill = tempStyle.getFill();
|
||
var color = fill.getColor();
|
||
if (color) {
|
||
var tempColor = ol.color.asArray(color);
|
||
tempColor[3] = opacity;
|
||
var currentColor = 'rgba(' + tempColor.join(',') + ')';
|
||
fill.setColor(currentColor);
|
||
feature.setStyle(tempStyle);
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn(e);
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype.setBorderColor = function setBorderColor(feature, borderColor) {
|
||
try {
|
||
if (feature && feature instanceof ol.Feature) {
|
||
var style = this.getBaseStyle(feature);
|
||
var tempStyle = style.clone();
|
||
var stroke = tempStyle.getStroke();
|
||
stroke.setColor(borderColor);
|
||
feature.setStyle(tempStyle);
|
||
}
|
||
} catch (e) {
|
||
console.warn(e);
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype.setBorderWidth = function setBorderWidth(feature, borderWidth) {
|
||
try {
|
||
if (feature && feature instanceof ol.Feature) {
|
||
var style = this.getBaseStyle(feature);
|
||
var tempStyle = style.clone();
|
||
var stroke = tempStyle.getStroke();
|
||
stroke.setWidth(borderWidth);
|
||
feature.setStyle(tempStyle);
|
||
}
|
||
} catch (e) {
|
||
console.warn(e);
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype.handleBackgroundColor = function handleBackgroundColor(color, opacity) {
|
||
try {
|
||
if (!opacity) opacity = 1;
|
||
var tempColor = ol.color.asArray(color);
|
||
tempColor[3] = opacity;
|
||
return 'rgba(' + tempColor.join(',') + ')';
|
||
} catch (e) {
|
||
console.warn(e);
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype.getColor = function getColor(color) {
|
||
try {
|
||
var colorTarget = ol.color.asArray(color);
|
||
return ol.color.asString(colorTarget);
|
||
} catch (e) {
|
||
console.warn(e);
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype.fixObject = function fixObject(obj) {
|
||
if (obj && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object') {
|
||
for (var key in obj) {
|
||
if (key && typeof obj[key] === 'undefined') {
|
||
delete obj[key];
|
||
}
|
||
}
|
||
}
|
||
return obj;
|
||
};
|
||
|
||
PlotUtils.prototype.getStroke_ = function getStroke_(style) {
|
||
var stroke = null;
|
||
if (style) {
|
||
var olStyle_ = style.getStroke();
|
||
if (olStyle_) {
|
||
stroke = {};
|
||
stroke['strokeColor'] = this.getColor(olStyle_.getColor());
|
||
stroke['strokeWidth'] = olStyle_.getWidth();
|
||
stroke['strokeLineDash'] = olStyle_.getLineDash();
|
||
stroke['lineDashOffset'] = olStyle_.getLineDashOffset();
|
||
stroke['strokeLineCap'] = olStyle_.getLineCap();
|
||
stroke['strokeLineJoin'] = olStyle_.getLineJoin();
|
||
stroke['strokeMiterLimit'] = olStyle_.getMiterLimit();
|
||
}
|
||
}
|
||
return this.fixObject(stroke);
|
||
};
|
||
|
||
PlotUtils.prototype.getFill_ = function getFill_(style) {
|
||
var fill = null;
|
||
if (style) {
|
||
var olStyle_ = style.getFill();
|
||
if (olStyle_) {
|
||
fill = {};
|
||
var color = olStyle_.getColor();
|
||
fill['fillColor'] = this.getColor(color);
|
||
}
|
||
}
|
||
return this.fixObject(fill);
|
||
};
|
||
|
||
PlotUtils.prototype.getText_ = function getText_(style) {
|
||
var text = null;
|
||
if (style) {
|
||
var olStyle_ = style.getText();
|
||
if (olStyle_) {
|
||
text = {};
|
||
text['textFont'] = olStyle_.getFont();
|
||
text['textOffsetX'] = olStyle_.getOffsetX();
|
||
text['textOffsetY'] = olStyle_.getOffsetY();
|
||
text['textScale'] = olStyle_.getScale();
|
||
text['textRotation'] = olStyle_.getRotation();
|
||
text['text'] = olStyle_.getText();
|
||
text['textAlign'] = olStyle_.getTextAlign();
|
||
text['textBaseline'] = olStyle_.getTextBaseline();
|
||
text['rotateWithView'] = olStyle_.getRotateWithView();
|
||
text['textFill'] = this.getFill_(olStyle_);
|
||
text['textStroke'] = this.getStroke_(olStyle_);
|
||
}
|
||
}
|
||
return this.fixObject(text);
|
||
};
|
||
|
||
PlotUtils.prototype.getImage_ = function getImage_(style) {
|
||
var image = null;
|
||
if (style) {
|
||
var olStyle_ = style.getImage();
|
||
if (olStyle_) {
|
||
image = {};
|
||
if (olStyle_ instanceof ol.style.Icon) {
|
||
image['type'] = 'icon';
|
||
image['image'] = {};
|
||
image['image']['imageAnchor'] = olStyle_.getAnchor();
|
||
image['image']['imageColor'] = olStyle_.getColor();
|
||
image['image']['imageSrc'] = olStyle_.getSrc();
|
||
image['image']['imgSize'] = olStyle_.getSize();
|
||
image['image']['scale'] = olStyle_.getScale();
|
||
image['image']['imageRotation'] = olStyle_.getRotation();
|
||
image['image']['rotateWithView'] = olStyle_.getRotateWithView();
|
||
image['image']['imageOpacity'] = olStyle_.getOpacity();
|
||
image['image']['snapToPixel'] = olStyle_.getSnapToPixel();
|
||
image['image']['offset'] = olStyle_.getOrigin();
|
||
} else if (olStyle_ instanceof ol.style.RegularShape) {
|
||
image['type'] = '';
|
||
image['image'] = {};
|
||
image['image']['fill'] = this.getFill_(olStyle_);
|
||
image['image']['points'] = olStyle_.getPoints();
|
||
image['image']['radius'] = olStyle_.getRadius();
|
||
image['image']['radius2'] = olStyle_.getRadius2();
|
||
image['image']['angle'] = olStyle_.getAngle();
|
||
image['image']['stroke'] = this.getStroke_(olStyle_);
|
||
image['image']['rotateWithView'] = olStyle_.getRotateWithView();
|
||
image['image']['snapToPixel'] = olStyle_.getSnapToPixel();
|
||
}
|
||
}
|
||
}
|
||
return this.fixObject(image);
|
||
};
|
||
|
||
PlotUtils.prototype.getStyleCode = function getStyleCode(feature) {
|
||
try {
|
||
if (feature && feature instanceof ol.Feature) {
|
||
var style = this.getBaseStyle(feature);
|
||
if (style && style instanceof ol.style.Style) {
|
||
var fill = this.getFill_(style);
|
||
var _ref = [1, null],
|
||
opacity = _ref[0],
|
||
rgbaArray = _ref[1],
|
||
backgroundColor = _ref[2];
|
||
|
||
if (fill && fill['fillColor']) {
|
||
rgbaArray = ol.color.asArray(fill['fillColor']);
|
||
opacity = parseFloat(rgbaArray[3]);
|
||
if (rgbaArray && typeof opacity === 'number') {
|
||
backgroundColor = this.handleBackgroundColor(ol.color.asString(rgbaArray), opacity);
|
||
}
|
||
}
|
||
|
||
var stroke = this.getStroke_(style);
|
||
|
||
var text = this.getText_(style);
|
||
|
||
var icon = this.getImage_(style);
|
||
return {
|
||
fill: {
|
||
fillColor: backgroundColor,
|
||
opacity: opacity
|
||
},
|
||
stroke: stroke,
|
||
image: icon,
|
||
text: text
|
||
};
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn(e);
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype.removeAllFeatures = function removeAllFeatures() {
|
||
var layer = getLayerByLayerName(this.map, this.layerName);
|
||
var overlays_ = this.map.getOverlays().getArray();
|
||
if (layer) {
|
||
var source = layer.getSource();
|
||
source.clear();
|
||
}
|
||
if (overlays_ && overlays_.length > 0) {
|
||
var len = overlays_.length;
|
||
for (var i = 0; i < len; i++) {
|
||
if (overlays_[i] && overlays_[i].get('isPlotText')) {
|
||
this.map.removeOverlay(overlays_[i]);
|
||
i--;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype.getFeatures = function getFeatures() {
|
||
var _this = this;
|
||
|
||
var rFeatures = [];
|
||
var layer = getLayerByLayerName(this.map, this.layerName);
|
||
if (layer) {
|
||
var source = layer.getSource();
|
||
if (source && source instanceof ol.source.Vector) {
|
||
var features = source.getFeatures();
|
||
if (features && features.length > 0) {
|
||
features.forEach(function (feature, index) {
|
||
if (feature && feature.getGeometry) {
|
||
var geom = feature.getGeometry();
|
||
if (geom && geom.getCoordinates) {
|
||
var type = geom.getType();
|
||
var coordinates = geom.getCoordinates();
|
||
rFeatures.push({
|
||
'type': 'Feature',
|
||
'geometry': {
|
||
'type': type,
|
||
'coordinates': coordinates
|
||
},
|
||
'properties': {
|
||
'type': feature.getGeometry().getPlotType(),
|
||
'style': _this.getStyleCode(feature),
|
||
'points': feature.getGeometry().getPoints()
|
||
}
|
||
});
|
||
}
|
||
}
|
||
});
|
||
}
|
||
}
|
||
}
|
||
var overlays_ = this.map.getOverlays().getArray();
|
||
overlays_.forEach(function (overlay) {
|
||
if (overlay.get('isPlotText')) {
|
||
var style_ = overlay.getStyle();
|
||
style_['width'] = overlay.getWidth() + 'px';
|
||
style_['height'] = overlay.getHeight() + 'px';
|
||
rFeatures.push({
|
||
'type': 'Feature',
|
||
'geometry': {
|
||
'type': 'PlotText',
|
||
'coordinates': overlay.getPosition()
|
||
},
|
||
'properties': {
|
||
'id': overlay.getId(),
|
||
'width': overlay.getWidth(),
|
||
'height': overlay.getHeight(),
|
||
'style': style_,
|
||
'value': overlay.getValue()
|
||
}
|
||
});
|
||
}
|
||
});
|
||
return rFeatures;
|
||
};
|
||
|
||
PlotUtils.prototype.addFeatures = function addFeatures(features) {
|
||
var _this2 = this;
|
||
|
||
if (features && Array.isArray(features) && features.length > 0) {
|
||
var layer = getLayerByLayerName(this.map, this.layerName);
|
||
if (!layer) {
|
||
layer = createVectorLayer(this.map, this.layerName, {
|
||
create: true
|
||
});
|
||
layer.setZIndex(this.options['zIndex'] || 99);
|
||
}
|
||
if (layer) {
|
||
var source = layer.getSource();
|
||
if (source && source instanceof ol.source.Vector) {
|
||
var _extents = [];
|
||
features.forEach(function (feature) {
|
||
if (feature && feature['geometry'] && feature['geometry']['type'] !== 'PlotText') {
|
||
if (feature['properties']['type'] && Geometry[feature['properties']['type']]) {
|
||
var feat = new ol.Feature({
|
||
geometry: new Geometry[feature['properties']['type']]([], feature['properties']['points'], feature['properties'])
|
||
});
|
||
feat.set('isPlot', true);
|
||
_extents.push(feat.getGeometry().getExtent());
|
||
if (feature['properties']['style']) {
|
||
var style_ = new StyleFactory(feature['properties']['style']);
|
||
if (style_) {
|
||
feat.setStyle(style_);
|
||
}
|
||
}
|
||
source.addFeature(feat);
|
||
} else {
|
||
console.warn('不存在的标绘类型！');
|
||
}
|
||
} else if (feature && feature['geometry'] && feature['geometry']['type'] === 'PlotText') {
|
||
_extents.push(new ol.geom.Point(feature.geometry['coordinates']).getExtent());
|
||
var _plotText = new PlotTextBox({
|
||
id: feature.properties.id,
|
||
position: feature.geometry['coordinates'],
|
||
width: feature.properties['width'],
|
||
height: feature.properties['height'],
|
||
value: feature.properties['value'],
|
||
style: feature.properties.style
|
||
});
|
||
if (_this2.map && _this2.map instanceof ol.Map && _plotText) {
|
||
_this2.map.addOverlay(_plotText);
|
||
} else {
|
||
console.warn('未传入地图对象或者plotText创建失败！');
|
||
}
|
||
}
|
||
});
|
||
if (this.options['zoomToExtent'] && _extents && _extents.length > 0) {
|
||
var _extent = this._getExtent(_extents);
|
||
var size = this.map.getSize();
|
||
var _view = this.map.getView();
|
||
_view.fit(_extent, {
|
||
size: size,
|
||
duration: 800,
|
||
maxZoom: _view.getMaxZoom() || undefined
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
PlotUtils.prototype._getExtent = function _getExtent(extents) {
|
||
var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
|
||
var bbox = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
|
||
var _extent = extents.reduce(function (prev, coord) {
|
||
return [Math.min(coord[0], prev[0]), Math.min(coord[1], prev[1]), Math.max(coord[2], prev[2]), Math.max(coord[3], prev[3])];
|
||
}, bbox);
|
||
var size = ol.extent.getSize(_extent);
|
||
var adjust = typeof params['adjust'] === 'number' ? params['adjust'] : 0.2;
|
||
var minWidth = typeof params['minWidth'] === 'number' ? params['minWidth'] : 0.05;
|
||
var minHeight = typeof params['minHeight'] === 'number' ? params['minHeight'] : 0.05;
|
||
if (size[0] <= minWidth || size[1] <= minHeight) {
|
||
var bleft = ol.extent.getBottomLeft(_extent);
|
||
var tright = ol.extent.getTopRight(_extent);
|
||
var xmin = bleft[0] - adjust;
|
||
var ymin = bleft[1] - adjust;
|
||
var xmax = tright[0] + adjust;
|
||
var ymax = tright[1] + adjust;
|
||
_extent = ol.extent.buffer([xmin, ymin, xmax, ymax], adjust);
|
||
}
|
||
return _extent;
|
||
};
|
||
|
||
return PlotUtils;
|
||
}();
|
||
|
||
var olPlot = function olPlot(map, options) {
|
||
classCallCheck(this, olPlot);
|
||
|
||
this.plotDraw = new PlotDraw(map, options);
|
||
this.plotEdit = new PlotEdit(map, options);
|
||
this.plotUtils = new PlotUtils(map, options);
|
||
};
|
||
|
||
olPlot.PlotTypes = PlotTypes;
|
||
olPlot.Geometry = Geometry;
|
||
|
||
return olPlot;
|
||
|
||
})));
|