mirror of
https://github.com/jiawanlong/Cesium-Examples.git
synced 2025-11-04 01:04:17 +00:00
1195 lines
45 KiB
HTML
1195 lines
45 KiB
HTML
<!doctype html>
|
||
<html lang="en">
|
||
|
||
<!--
|
||
* 名称: 3D热力图
|
||
* 作者: 20Savage https://github.com/zhengsixsix
|
||
-->
|
||
|
||
<head>
|
||
<meta charset="UTF-8" />
|
||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||
<title>3D热力图</title>
|
||
<link rel="stylesheet" href="https://file.threehub.cn/js/cesium/style.css">
|
||
<script type="importmap">
|
||
{
|
||
"imports": {
|
||
"cesium": "https://file.threehub.cn/js/cesium/Cesium.js"
|
||
}
|
||
}
|
||
</script>
|
||
<style>
|
||
body {
|
||
margin: 0;
|
||
padding: 1px;
|
||
box-sizing: border-box;
|
||
background-color: #1f1f1f;
|
||
display: flex;
|
||
flex-direction: column;
|
||
width: 100vw;
|
||
height: 100vh;
|
||
overflow: hidden;
|
||
}
|
||
|
||
#box {
|
||
width: 100%;
|
||
height: 100%;
|
||
}
|
||
</style>
|
||
</head>
|
||
|
||
<body>
|
||
<div id="box"></div>
|
||
<script type="module">
|
||
import {
|
||
EllipsoidSurfaceAppearance,
|
||
GeometryInstance,
|
||
Material,
|
||
Primitive,
|
||
Rectangle,
|
||
RectangleGeometry,
|
||
SingleTileImageryProvider,
|
||
ImageryLayer,
|
||
ImageMaterialProperty,
|
||
Entity,
|
||
} from "cesium";
|
||
import * as Cesium from "cesium";
|
||
|
||
/* ----------------------------------------------------heatMap类----------------------------------------------- */
|
||
var HeatmapConfig = {
|
||
defaultRadius: 40,
|
||
defaultRenderer: "canvas2d",
|
||
defaultGradient: {
|
||
0.25: "rgb(0,0,255)",
|
||
0.55: "rgb(0,255,0)",
|
||
0.85: "yellow",
|
||
1.0: "rgb(255,0,0)",
|
||
},
|
||
defaultMaxOpacity: 1,
|
||
defaultMinOpacity: 0,
|
||
defaultBlur: 0.85,
|
||
defaultXField: "x",
|
||
defaultYField: "y",
|
||
defaultValueField: "value",
|
||
plugins: {},
|
||
};
|
||
var Store = (function StoreClosure() {
|
||
var Store = function Store(config) {
|
||
this._coordinator = {};
|
||
this._data = [];
|
||
this._radi = [];
|
||
this._min = 0;
|
||
this._max = 1;
|
||
this._xField = config["xField"] || config.defaultXField;
|
||
this._yField = config["yField"] || config.defaultYField;
|
||
this._valueField = config["valueField"] || config.defaultValueField;
|
||
|
||
if (config["radius"]) {
|
||
this._cfgRadius = config["radius"];
|
||
}
|
||
};
|
||
|
||
var defaultRadius = HeatmapConfig.defaultRadius;
|
||
|
||
Store.prototype = {
|
||
// when forceRender = false -> called from setData, omits renderall event
|
||
_organiseData: function (dataPoint, forceRender) {
|
||
var x = dataPoint[this._xField];
|
||
var y = dataPoint[this._yField];
|
||
var radi = this._radi;
|
||
var store = this._data;
|
||
var max = this._max;
|
||
var min = this._min;
|
||
var value = dataPoint[this._valueField] || 1;
|
||
var radius = dataPoint.radius || this._cfgRadius || defaultRadius;
|
||
|
||
if (!store[x]) {
|
||
store[x] = [];
|
||
radi[x] = [];
|
||
}
|
||
|
||
if (!store[x][y]) {
|
||
store[x][y] = value;
|
||
radi[x][y] = radius;
|
||
} else {
|
||
store[x][y] += value;
|
||
}
|
||
|
||
if (store[x][y] > max) {
|
||
if (!forceRender) {
|
||
this._max = store[x][y];
|
||
} else {
|
||
this.setDataMax(store[x][y]);
|
||
}
|
||
return false;
|
||
} else {
|
||
return {
|
||
x: x,
|
||
y: y,
|
||
value: value,
|
||
radius: radius,
|
||
min: min,
|
||
max: max,
|
||
};
|
||
}
|
||
},
|
||
_unOrganizeData: function () {
|
||
var unorganizedData = [];
|
||
var data = this._data;
|
||
var radi = this._radi;
|
||
|
||
for (var x in data) {
|
||
for (var y in data[x]) {
|
||
unorganizedData.push({
|
||
x: x,
|
||
y: y,
|
||
radius: radi[x][y],
|
||
value: data[x][y],
|
||
});
|
||
}
|
||
}
|
||
return {
|
||
min: this._min,
|
||
max: this._max,
|
||
data: unorganizedData,
|
||
};
|
||
},
|
||
_onExtremaChange: function () {
|
||
this._coordinator.emit("extremachange", {
|
||
min: this._min,
|
||
max: this._max,
|
||
});
|
||
},
|
||
addData: function () {
|
||
if (arguments[0].length > 0) {
|
||
var dataArr = arguments[0];
|
||
var dataLen = dataArr.length;
|
||
while (dataLen--) {
|
||
this.addData.call(this, dataArr[dataLen]);
|
||
}
|
||
} else {
|
||
// add to store
|
||
var organisedEntry = this._organiseData(arguments[0], true);
|
||
if (organisedEntry) {
|
||
this._coordinator.emit("renderpartial", {
|
||
min: this._min,
|
||
max: this._max,
|
||
data: [organisedEntry],
|
||
});
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
setData: function (data) {
|
||
var dataPoints = data.data;
|
||
var pointsLen = dataPoints.length;
|
||
|
||
// reset data arrays
|
||
this._data = [];
|
||
this._radi = [];
|
||
|
||
for (var i = 0; i < pointsLen; i++) {
|
||
this._organiseData(dataPoints[i], false);
|
||
}
|
||
this._max = data.max;
|
||
this._min = data.min || 0;
|
||
|
||
this._onExtremaChange();
|
||
this._coordinator.emit("renderall", this._getInternalData());
|
||
return this;
|
||
},
|
||
removeData: function () {
|
||
// TODO: implement
|
||
},
|
||
setDataMax: function (max) {
|
||
this._max = max;
|
||
this._onExtremaChange();
|
||
this._coordinator.emit("renderall", this._getInternalData());
|
||
return this;
|
||
},
|
||
setDataMin: function (min) {
|
||
this._min = min;
|
||
this._onExtremaChange();
|
||
this._coordinator.emit("renderall", this._getInternalData());
|
||
return this;
|
||
},
|
||
setCoordinator: function (coordinator) {
|
||
this._coordinator = coordinator;
|
||
},
|
||
_getInternalData: function () {
|
||
return {
|
||
max: this._max,
|
||
min: this._min,
|
||
data: this._data,
|
||
radi: this._radi,
|
||
};
|
||
},
|
||
getData: function () {
|
||
return this._unOrganizeData();
|
||
} /*,
|
||
|
||
TODO: rethink.
|
||
|
||
getValueAt: function(point) {
|
||
var value;
|
||
var radius = 100;
|
||
var x = point.x;
|
||
var y = point.y;
|
||
var data = this._data;
|
||
|
||
if (data[x] && data[x][y]) {
|
||
return data[x][y];
|
||
} else {
|
||
var values = [];
|
||
// radial search for datapoints based on default radius
|
||
for(var distance = 1; distance < radius; distance++) {
|
||
var neighbors = distance * 2 +1;
|
||
var startX = x - distance;
|
||
var startY = y - distance;
|
||
|
||
for(var i = 0; i < neighbors; i++) {
|
||
for (var o = 0; o < neighbors; o++) {
|
||
if ((i == 0 || i == neighbors-1) || (o == 0 || o == neighbors-1)) {
|
||
if (data[startY+i] && data[startY+i][startX+o]) {
|
||
values.push(data[startY+i][startX+o]);
|
||
}
|
||
} else {
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (values.length > 0) {
|
||
return Math.max.apply(Math, values);
|
||
}
|
||
}
|
||
return false;
|
||
}*/,
|
||
};
|
||
|
||
return Store;
|
||
})();
|
||
|
||
var Canvas2dRenderer = (function Canvas2dRendererClosure() {
|
||
var _getColorPalette = function (config) {
|
||
var gradientConfig = config.gradient || config.defaultGradient;
|
||
var paletteCanvas = document.createElement("canvas");
|
||
var paletteCtx = paletteCanvas.getContext("2d");
|
||
|
||
paletteCanvas.width = 256;
|
||
paletteCanvas.height = 1;
|
||
|
||
var gradient = paletteCtx.createLinearGradient(0, 0, 256, 1);
|
||
for (var key in gradientConfig) {
|
||
gradient.addColorStop(key, gradientConfig[key]);
|
||
}
|
||
|
||
paletteCtx.fillStyle = gradient;
|
||
paletteCtx.fillRect(0, 0, 256, 1);
|
||
|
||
return paletteCtx.getImageData(0, 0, 256, 1).data;
|
||
};
|
||
|
||
var _getPointTemplate = function (radius, blurFactor) {
|
||
var tplCanvas = document.createElement("canvas");
|
||
var tplCtx = tplCanvas.getContext("2d");
|
||
var x = radius;
|
||
var y = radius;
|
||
tplCanvas.width = tplCanvas.height = radius * 2;
|
||
|
||
if (blurFactor == 1) {
|
||
tplCtx.beginPath();
|
||
tplCtx.arc(x, y, radius, 0, 2 * Math.PI, false);
|
||
tplCtx.fillStyle = "rgba(0,0,0,1)";
|
||
tplCtx.fill();
|
||
} else {
|
||
var gradient = tplCtx.createRadialGradient(
|
||
x,
|
||
y,
|
||
radius * blurFactor,
|
||
x,
|
||
y,
|
||
radius
|
||
);
|
||
gradient.addColorStop(0, "rgba(0,0,0,1)");
|
||
gradient.addColorStop(1, "rgba(0,0,0,0)");
|
||
tplCtx.fillStyle = gradient;
|
||
tplCtx.fillRect(0, 0, 2 * radius, 2 * radius);
|
||
}
|
||
|
||
return tplCanvas;
|
||
};
|
||
|
||
var _prepareData = function (data) {
|
||
var renderData = [];
|
||
var min = data.min;
|
||
var max = data.max;
|
||
var radi = data.radi;
|
||
var data = data.data;
|
||
|
||
var xValues = Object.keys(data);
|
||
var xValuesLen = xValues.length;
|
||
|
||
while (xValuesLen--) {
|
||
var xValue = xValues[xValuesLen];
|
||
var yValues = Object.keys(data[xValue]);
|
||
var yValuesLen = yValues.length;
|
||
while (yValuesLen--) {
|
||
var yValue = yValues[yValuesLen];
|
||
var value = data[xValue][yValue];
|
||
var radius = radi[xValue][yValue];
|
||
renderData.push({
|
||
x: xValue,
|
||
y: yValue,
|
||
value: value,
|
||
radius: radius,
|
||
});
|
||
}
|
||
}
|
||
|
||
return {
|
||
min: min,
|
||
max: max,
|
||
data: renderData,
|
||
};
|
||
};
|
||
|
||
function Canvas2dRenderer(config) {
|
||
var container = config.container;
|
||
var shadowCanvas = (this.shadowCanvas = document.createElement("canvas"));
|
||
var canvas = (this.canvas =
|
||
config.canvas || document.createElement("canvas"));
|
||
var renderBoundaries = (this._renderBoundaries = [10000, 10000, 0, 0]);
|
||
|
||
var computed = getComputedStyle(config.container) || {};
|
||
|
||
canvas.className = "heatmap-canvas";
|
||
|
||
this._width =
|
||
canvas.width =
|
||
shadowCanvas.width =
|
||
+computed.width.replace(/px/, "");
|
||
this._height =
|
||
canvas.height =
|
||
shadowCanvas.height =
|
||
+computed.height.replace(/px/, "");
|
||
|
||
this.shadowCtx = shadowCanvas.getContext("2d");
|
||
this.ctx = canvas.getContext("2d");
|
||
|
||
// @TODO:
|
||
// conditional wrapper
|
||
|
||
canvas.style.cssText = shadowCanvas.style.cssText =
|
||
"position:absolute;left:0;top:0;";
|
||
|
||
container.style.position = "relative";
|
||
container.appendChild(canvas);
|
||
|
||
this._palette = _getColorPalette(config);
|
||
this._templates = {};
|
||
|
||
this._setStyles(config);
|
||
}
|
||
|
||
Canvas2dRenderer.prototype = {
|
||
renderPartial: function (data) {
|
||
this._drawAlpha(data);
|
||
this._colorize();
|
||
},
|
||
renderAll: function (data) {
|
||
// reset render boundaries
|
||
this._clear();
|
||
this._drawAlpha(_prepareData(data));
|
||
this._colorize();
|
||
},
|
||
_updateGradient: function (config) {
|
||
this._palette = _getColorPalette(config);
|
||
},
|
||
updateConfig: function (config) {
|
||
if (config["gradient"]) {
|
||
this._updateGradient(config);
|
||
}
|
||
this._setStyles(config);
|
||
},
|
||
setDimensions: function (width, height) {
|
||
this._width = width;
|
||
this._height = height;
|
||
this.canvas.width = this.shadowCanvas.width = width;
|
||
this.canvas.height = this.shadowCanvas.height = height;
|
||
},
|
||
_clear: function () {
|
||
this.shadowCtx.clearRect(0, 0, this._width, this._height);
|
||
this.ctx.clearRect(0, 0, this._width, this._height);
|
||
},
|
||
_setStyles: function (config) {
|
||
this._blur = config.blur == 0 ? 0 : config.blur || config.defaultBlur;
|
||
|
||
if (config.backgroundColor) {
|
||
this.canvas.style.backgroundColor = config.backgroundColor;
|
||
}
|
||
|
||
this._opacity = (config.opacity || 0) * 255;
|
||
this._maxOpacity = (config.maxOpacity || config.defaultMaxOpacity) * 255;
|
||
this._minOpacity = (config.minOpacity || config.defaultMinOpacity) * 255;
|
||
this._useGradientOpacity = !!config.useGradientOpacity;
|
||
},
|
||
_drawAlpha: function (data) {
|
||
var min = (this._min = data.min);
|
||
var max = (this._max = data.max);
|
||
var data = data.data || [];
|
||
var dataLen = data.length;
|
||
// on a point basis?
|
||
var blur = 1 - this._blur;
|
||
|
||
while (dataLen--) {
|
||
var point = data[dataLen];
|
||
|
||
var x = point.x;
|
||
var y = point.y;
|
||
var radius = point.radius;
|
||
// if value is bigger than max
|
||
// use max as value
|
||
var value = Math.min(point.value, max);
|
||
var rectX = x - radius;
|
||
var rectY = y - radius;
|
||
var shadowCtx = this.shadowCtx;
|
||
|
||
var tpl;
|
||
if (!this._templates[radius]) {
|
||
this._templates[radius] = tpl = _getPointTemplate(radius, blur);
|
||
} else {
|
||
tpl = this._templates[radius];
|
||
}
|
||
// value from minimum / value range
|
||
// => [0, 1]
|
||
shadowCtx.globalAlpha = (value - min) / (max - min);
|
||
|
||
shadowCtx.drawImage(tpl, rectX, rectY);
|
||
|
||
// update renderBoundaries
|
||
if (rectX < this._renderBoundaries[0]) {
|
||
this._renderBoundaries[0] = rectX;
|
||
}
|
||
if (rectY < this._renderBoundaries[1]) {
|
||
this._renderBoundaries[1] = rectY;
|
||
}
|
||
if (rectX + 2 * radius > this._renderBoundaries[2]) {
|
||
this._renderBoundaries[2] = rectX + 2 * radius;
|
||
}
|
||
if (rectY + 2 * radius > this._renderBoundaries[3]) {
|
||
this._renderBoundaries[3] = rectY + 2 * radius;
|
||
}
|
||
}
|
||
},
|
||
_colorize: function () {
|
||
var x = this._renderBoundaries[0];
|
||
var y = this._renderBoundaries[1];
|
||
var width = this._renderBoundaries[2] - x;
|
||
var height = this._renderBoundaries[3] - y;
|
||
var maxWidth = this._width;
|
||
var maxHeight = this._height;
|
||
var opacity = this._opacity;
|
||
var maxOpacity = this._maxOpacity;
|
||
var minOpacity = this._minOpacity;
|
||
var useGradientOpacity = this._useGradientOpacity;
|
||
|
||
if (x < 0) {
|
||
x = 0;
|
||
}
|
||
if (y < 0) {
|
||
y = 0;
|
||
}
|
||
if (x + width > maxWidth) {
|
||
width = maxWidth - x;
|
||
}
|
||
if (y + height > maxHeight) {
|
||
height = maxHeight - y;
|
||
}
|
||
|
||
var img = this.shadowCtx.getImageData(x, y, width, height);
|
||
var imgData = img.data;
|
||
var len = imgData.length;
|
||
var palette = this._palette;
|
||
|
||
for (var i = 3; i < len; i += 4) {
|
||
var alpha = imgData[i];
|
||
var offset = alpha * 4;
|
||
|
||
if (!offset) {
|
||
continue;
|
||
}
|
||
|
||
var finalAlpha;
|
||
if (opacity > 0) {
|
||
finalAlpha = opacity;
|
||
} else {
|
||
if (alpha < maxOpacity) {
|
||
if (alpha < minOpacity) {
|
||
finalAlpha = minOpacity;
|
||
} else {
|
||
finalAlpha = alpha;
|
||
}
|
||
} else {
|
||
finalAlpha = maxOpacity;
|
||
}
|
||
}
|
||
|
||
imgData[i - 3] = palette[offset];
|
||
imgData[i - 2] = palette[offset + 1];
|
||
imgData[i - 1] = palette[offset + 2];
|
||
imgData[i] = useGradientOpacity ? palette[offset + 3] : finalAlpha;
|
||
}
|
||
Object.defineProperty(img, "data", {
|
||
value: imgData,
|
||
writable: true,
|
||
configurable: true,
|
||
enumerable: true,
|
||
});
|
||
// img.data = imgData;
|
||
this.ctx.putImageData(img, x, y);
|
||
|
||
this._renderBoundaries = [1000, 1000, 0, 0];
|
||
},
|
||
getValueAt: function (point) {
|
||
var value;
|
||
var shadowCtx = this.shadowCtx;
|
||
var img = shadowCtx.getImageData(point.x, point.y, 1, 1);
|
||
var data = img.data[3];
|
||
var max = this._max;
|
||
var min = this._min;
|
||
|
||
value = (Math.abs(max - min) * (data / 255)) >> 0;
|
||
|
||
return value;
|
||
},
|
||
getDataURL: function () {
|
||
return this.canvas.toDataURL();
|
||
},
|
||
};
|
||
|
||
return Canvas2dRenderer;
|
||
})();
|
||
|
||
var Renderer = (function RendererClosure() {
|
||
var rendererFn = false;
|
||
|
||
if (HeatmapConfig["defaultRenderer"] === "canvas2d") {
|
||
rendererFn = Canvas2dRenderer;
|
||
}
|
||
|
||
return rendererFn;
|
||
})();
|
||
|
||
var Util = {
|
||
merge: function () {
|
||
var merged = {};
|
||
var argsLen = arguments.length;
|
||
for (var i = 0; i < argsLen; i++) {
|
||
var obj = arguments[i];
|
||
for (var key in obj) {
|
||
merged[key] = obj[key];
|
||
}
|
||
}
|
||
return merged;
|
||
},
|
||
};
|
||
// Heatmap Constructor
|
||
var Heatmap = (function HeatmapClosure() {
|
||
var Coordinator = (function CoordinatorClosure() {
|
||
function Coordinator() {
|
||
this.cStore = {};
|
||
}
|
||
|
||
Coordinator.prototype = {
|
||
on: function (evtName, callback, scope) {
|
||
var cStore = this.cStore;
|
||
|
||
if (!cStore[evtName]) {
|
||
cStore[evtName] = [];
|
||
}
|
||
cStore[evtName].push(function (data) {
|
||
return callback.call(scope, data);
|
||
});
|
||
},
|
||
emit: function (evtName, data) {
|
||
var cStore = this.cStore;
|
||
if (cStore[evtName]) {
|
||
var len = cStore[evtName].length;
|
||
for (var i = 0; i < len; i++) {
|
||
var callback = cStore[evtName][i];
|
||
callback(data);
|
||
}
|
||
}
|
||
},
|
||
};
|
||
|
||
return Coordinator;
|
||
})();
|
||
|
||
var _connect = function (scope) {
|
||
var renderer = scope._renderer;
|
||
var coordinator = scope._coordinator;
|
||
var store = scope._store;
|
||
|
||
coordinator.on("renderpartial", renderer.renderPartial, renderer);
|
||
coordinator.on("renderall", renderer.renderAll, renderer);
|
||
coordinator.on("extremachange", function (data) {
|
||
scope._config.onExtremaChange &&
|
||
scope._config.onExtremaChange({
|
||
min: data.min,
|
||
max: data.max,
|
||
gradient:
|
||
scope._config["gradient"] || scope._config["defaultGradient"],
|
||
});
|
||
});
|
||
store.setCoordinator(coordinator);
|
||
};
|
||
|
||
function Heatmap() {
|
||
var config = (this._config = Util.merge(HeatmapConfig, arguments[0] || {}));
|
||
this._coordinator = new Coordinator();
|
||
if (config["plugin"]) {
|
||
var pluginToLoad = config["plugin"];
|
||
if (!HeatmapConfig.plugins[pluginToLoad]) {
|
||
throw new Error(
|
||
"Plugin '" +
|
||
pluginToLoad +
|
||
"' not found. Maybe it was not registered."
|
||
);
|
||
} else {
|
||
var plugin = HeatmapConfig.plugins[pluginToLoad];
|
||
// set plugin renderer and store
|
||
this._renderer = new plugin.renderer(config);
|
||
this._store = new plugin.store(config);
|
||
}
|
||
} else {
|
||
this._renderer = new Renderer(config);
|
||
this._store = new Store(config);
|
||
}
|
||
_connect(this);
|
||
}
|
||
|
||
// @TODO:
|
||
// add API documentation
|
||
Heatmap.prototype = {
|
||
addData: function () {
|
||
this._store.addData.apply(this._store, arguments);
|
||
return this;
|
||
},
|
||
removeData: function () {
|
||
this._store.removeData &&
|
||
this._store.removeData.apply(this._store, arguments);
|
||
return this;
|
||
},
|
||
setData: function () {
|
||
this._store.setData.apply(this._store, arguments);
|
||
return this;
|
||
},
|
||
setDataMax: function () {
|
||
this._store.setDataMax.apply(this._store, arguments);
|
||
return this;
|
||
},
|
||
setDataMin: function () {
|
||
this._store.setDataMin.apply(this._store, arguments);
|
||
return this;
|
||
},
|
||
configure: function (config) {
|
||
this._config = Util.merge(this._config, config);
|
||
this._renderer.updateConfig(this._config);
|
||
this._coordinator.emit("renderall", this._store._getInternalData());
|
||
return this;
|
||
},
|
||
repaint: function () {
|
||
this._coordinator.emit("renderall", this._store._getInternalData());
|
||
return this;
|
||
},
|
||
getData: function () {
|
||
return this._store.getData();
|
||
},
|
||
getDataURL: function () {
|
||
return this._renderer.getDataURL();
|
||
},
|
||
getValueAt: function (point) {
|
||
if (this._store.getValueAt) {
|
||
return this._store.getValueAt(point);
|
||
} else if (this._renderer.getValueAt) {
|
||
return this._renderer.getValueAt(point);
|
||
} else {
|
||
return null;
|
||
}
|
||
},
|
||
};
|
||
|
||
return Heatmap;
|
||
})();
|
||
|
||
var h337 = {
|
||
create: function (config) {
|
||
return new Heatmap(config);
|
||
},
|
||
register: function (pluginKey, plugin) {
|
||
HeatmapConfig.plugins[pluginKey] = plugin;
|
||
},
|
||
};
|
||
/* ----------------------------------------------------heatMap类--------------------------------------------------- */
|
||
|
||
/**
|
||
* 创建三维热力图
|
||
* @param {Cesium.Viewer} viewer 地图viewer对象
|
||
* @param {Object} options 基础参数
|
||
* @param {Array} options.dataPoints 热力值数组
|
||
* @param {Array} options.radius 热力点半径
|
||
* @param {Array} options.baseElevation 最低高度
|
||
* @param {Array} options.colorGradient 颜色配置
|
||
*/
|
||
function create3DHeatmap(viewer, options = {}) {
|
||
const heatmapState = {
|
||
viewer,
|
||
options,
|
||
dataPoints: options.dataPoints || [],
|
||
containerElement: undefined,
|
||
instanceId: Number(
|
||
`${new Date().getTime()}${Number(Math.random() * 1000).toFixed(0)}`
|
||
),
|
||
canvasWidth: 200,
|
||
boundingBox: undefined, // 四角坐标
|
||
boundingRect: {}, // 经纬度范围
|
||
xAxis: undefined, // x 轴
|
||
yAxis: undefined, // y 轴
|
||
xAxisLength: 0, // x轴长度
|
||
yAxisLength: 0, // y轴长度
|
||
baseElevation: options.baseElevation || 0,
|
||
heatmapPrimitive: undefined,
|
||
positionHierarchy: [],
|
||
heatmapInstance: null,
|
||
};
|
||
|
||
if (!heatmapState.dataPoints || heatmapState.dataPoints.length < 2) {
|
||
console.log("热力图点位不得少于3个！");
|
||
return;
|
||
}
|
||
|
||
createHeatmapContainer(heatmapState);
|
||
|
||
const heatmapConfig = {
|
||
container: document.getElementById(`heatmap-${heatmapState.instanceId}`),
|
||
radius: options.radius || 20,
|
||
maxOpacity: 0.7,
|
||
minOpacity: 0,
|
||
blur: 0.75,
|
||
gradient: options.colorGradient || {
|
||
".1": "blue",
|
||
".5": "yellow",
|
||
".7": "red",
|
||
".99": "white",
|
||
},
|
||
};
|
||
|
||
heatmapState.primitiveType = options.primitiveType || "TRIANGLES";
|
||
heatmapState.heatmapInstance = h337.create(heatmapConfig);
|
||
|
||
initializeHeatmap(heatmapState);
|
||
|
||
return {
|
||
destroy: () => destroyHeatmap(heatmapState),
|
||
heatmapState,
|
||
};
|
||
}
|
||
|
||
function initializeHeatmap(heatmapState) {
|
||
for (const [index, dataPoint] of heatmapState.dataPoints.entries()) {
|
||
const cartesianPosition = Cesium.Cartesian3.fromDegrees(
|
||
dataPoint.lnglat[0],
|
||
dataPoint.lnglat[1],
|
||
0
|
||
);
|
||
heatmapState.positionHierarchy.push(cartesianPosition);
|
||
}
|
||
|
||
computeBoundingBox(heatmapState.positionHierarchy, heatmapState);
|
||
|
||
const heatmapPoints = heatmapState.positionHierarchy.map(
|
||
(position, index) => {
|
||
const normalizedCoords = computeNormalizedCoordinates(
|
||
position,
|
||
heatmapState
|
||
);
|
||
return {
|
||
x: normalizedCoords.x,
|
||
y: normalizedCoords.y,
|
||
value: heatmapState.dataPoints[index].value,
|
||
};
|
||
}
|
||
);
|
||
|
||
heatmapState.heatmapInstance.addData(heatmapPoints);
|
||
|
||
const geometryInstance = new Cesium.GeometryInstance({
|
||
geometry: createHeatmapGeometry(heatmapState),
|
||
});
|
||
|
||
heatmapState.heatmapPrimitive = heatmapState.viewer.scene.primitives.add(
|
||
new Cesium.Primitive({
|
||
geometryInstances: geometryInstance,
|
||
appearance: new Cesium.MaterialAppearance({
|
||
material: new Cesium.Material({
|
||
fabric: {
|
||
type: "Image",
|
||
uniforms: {
|
||
image: heatmapState.heatmapInstance.getDataURL(),
|
||
},
|
||
},
|
||
}),
|
||
vertexShaderSource: `
|
||
in vec3 position3DHigh;
|
||
in vec3 position3DLow;
|
||
in vec2 st;
|
||
in float batchId;
|
||
uniform sampler2D image_0;
|
||
out vec3 v_positionEC;
|
||
in vec3 normal;
|
||
out vec3 v_normalEC;
|
||
out vec2 v_st;
|
||
void main(){
|
||
vec4 p = czm_computePosition();
|
||
|
||
v_normalEC = czm_normal * normal;
|
||
v_positionEC = (czm_modelViewRelativeToEye * p).xyz;
|
||
vec4 positionWC=czm_inverseModelView* vec4(v_positionEC,1.0);
|
||
v_st = st;
|
||
vec4 color = texture(image_0, v_st);
|
||
vec3 upDir = normalize(positionWC.xyz);
|
||
p += vec4(color.r *upDir * 1000., 0.0);
|
||
gl_Position = czm_modelViewProjectionRelativeToEye * p;
|
||
}`,
|
||
translucent: true,
|
||
flat: true,
|
||
}),
|
||
asynchronous: false,
|
||
})
|
||
);
|
||
heatmapState.heatmapPrimitive.id = "heatmap3d";
|
||
}
|
||
|
||
function destroyHeatmap(heatmapState) {
|
||
const containerElement = document.getElementById(
|
||
`heatmap-${heatmapState.instanceId}`
|
||
);
|
||
if (containerElement) containerElement.remove();
|
||
if (heatmapState.heatmapPrimitive) {
|
||
heatmapState.viewer.scene.primitives.remove(heatmapState.heatmapPrimitive);
|
||
heatmapState.heatmapPrimitive = undefined;
|
||
}
|
||
}
|
||
|
||
function computeNormalizedCoordinates(position, heatmapState) {
|
||
if (!position) return;
|
||
const cartographic = Cesium.Cartographic.fromCartesian(position.clone());
|
||
cartographic.height = 0;
|
||
position = Cesium.Cartographic.toCartesian(cartographic.clone());
|
||
|
||
const originVector = Cesium.Cartesian3.subtract(
|
||
position.clone(),
|
||
heatmapState.boundingBox.leftTop,
|
||
new Cesium.Cartesian3()
|
||
);
|
||
const xOffset = Cesium.Cartesian3.dot(originVector, heatmapState.xAxis);
|
||
const yOffset = Cesium.Cartesian3.dot(originVector, heatmapState.yAxis);
|
||
return {
|
||
x: Number(
|
||
(xOffset / heatmapState.xAxisLength) * heatmapState.canvasWidth
|
||
).toFixed(0),
|
||
y: Number(
|
||
(yOffset / heatmapState.yAxisLength) * heatmapState.canvasWidth
|
||
).toFixed(0),
|
||
};
|
||
}
|
||
|
||
function cartesiansToLnglats(cartesians, viewer) {
|
||
if (!cartesians || cartesians.length < 1) return;
|
||
viewer = viewer || window.viewer;
|
||
if (!viewer) {
|
||
console.log("请传入viewer对象");
|
||
return;
|
||
}
|
||
var coordinates = [];
|
||
for (var i = 0; i < cartesians.length; i++) {
|
||
coordinates.push(cartesianToLnglat(cartesians[i], viewer));
|
||
}
|
||
return coordinates;
|
||
}
|
||
|
||
function cartesianToLnglat(cartesian, viewer) {
|
||
if (!cartesian) return [];
|
||
viewer = viewer || window.viewer;
|
||
var cartographic = Cesium.Cartographic.fromCartesian(cartesian);
|
||
var latitude = Cesium.Math.toDegrees(cartographic.latitude);
|
||
var longitude = Cesium.Math.toDegrees(cartographic.longitude);
|
||
var height = cartographic.height;
|
||
return [longitude, latitude, height];
|
||
}
|
||
|
||
function computeBoundingBox(positions, heatmapState) {
|
||
if (!positions) return;
|
||
const boundingSphere = Cesium.BoundingSphere.fromPoints(
|
||
positions,
|
||
new Cesium.BoundingSphere()
|
||
);
|
||
const centerPoint = boundingSphere.center;
|
||
const sphereRadius = boundingSphere.radius;
|
||
|
||
const modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
|
||
centerPoint.clone()
|
||
);
|
||
const modelMatrixInverse = Cesium.Matrix4.inverse(
|
||
modelMatrix.clone(),
|
||
new Cesium.Matrix4()
|
||
);
|
||
const yAxisVector = new Cesium.Cartesian3(0, 1, 0);
|
||
|
||
const boundingVertices = [];
|
||
for (let angle = 45; angle <= 360; angle += 90) {
|
||
const rotationMatrix = Cesium.Matrix3.fromRotationZ(
|
||
Cesium.Math.toRadians(angle),
|
||
new Cesium.Matrix3()
|
||
);
|
||
let rotatedYAxis = Cesium.Matrix3.multiplyByVector(
|
||
rotationMatrix,
|
||
yAxisVector,
|
||
new Cesium.Cartesian3()
|
||
);
|
||
rotatedYAxis = Cesium.Cartesian3.normalize(
|
||
rotatedYAxis,
|
||
new Cesium.Cartesian3()
|
||
);
|
||
const scaledVector = Cesium.Cartesian3.multiplyByScalar(
|
||
rotatedYAxis,
|
||
sphereRadius,
|
||
new Cesium.Cartesian3()
|
||
);
|
||
const vertex = Cesium.Matrix4.multiplyByPoint(
|
||
modelMatrix,
|
||
scaledVector.clone(),
|
||
new Cesium.Cartesian3()
|
||
);
|
||
|
||
boundingVertices.push(vertex);
|
||
}
|
||
|
||
const coordinates = cartesiansToLnglats(
|
||
boundingVertices,
|
||
heatmapState.viewer
|
||
);
|
||
let minLatitude = Number.MAX_VALUE,
|
||
maxLatitude = Number.MIN_VALUE,
|
||
minLongitude = Number.MAX_VALUE,
|
||
maxLongitude = Number.MIN_VALUE;
|
||
const vertexCount = boundingVertices.length;
|
||
|
||
coordinates.forEach((coordinate) => {
|
||
if (coordinate[0] < minLongitude) minLongitude = coordinate[0];
|
||
if (coordinate[0] > maxLongitude) maxLongitude = coordinate[0];
|
||
if (coordinate[1] < minLatitude) minLatitude = coordinate[1];
|
||
if (coordinate[1] > maxLatitude) maxLatitude = coordinate[1];
|
||
});
|
||
|
||
const latitudeRange = maxLatitude - minLatitude;
|
||
const longitudeRange = maxLongitude - minLongitude;
|
||
|
||
heatmapState.boundingRect = {
|
||
minLatitude: minLatitude - latitudeRange / vertexCount,
|
||
maxLatitude: maxLatitude + latitudeRange / vertexCount,
|
||
minLongitude: minLongitude - longitudeRange / vertexCount,
|
||
maxLongitude: maxLongitude + longitudeRange / vertexCount,
|
||
};
|
||
|
||
heatmapState.boundingBox = {
|
||
leftTop: Cesium.Cartesian3.fromDegrees(
|
||
heatmapState.boundingRect.minLongitude,
|
||
heatmapState.boundingRect.maxLatitude
|
||
),
|
||
leftBottom: Cesium.Cartesian3.fromDegrees(
|
||
heatmapState.boundingRect.minLongitude,
|
||
heatmapState.boundingRect.minLatitude
|
||
),
|
||
rightTop: Cesium.Cartesian3.fromDegrees(
|
||
heatmapState.boundingRect.maxLongitude,
|
||
heatmapState.boundingRect.maxLatitude
|
||
),
|
||
rightBottom: Cesium.Cartesian3.fromDegrees(
|
||
heatmapState.boundingRect.maxLongitude,
|
||
heatmapState.boundingRect.minLatitude
|
||
),
|
||
};
|
||
|
||
heatmapState.xAxis = Cesium.Cartesian3.subtract(
|
||
heatmapState.boundingBox.rightTop,
|
||
heatmapState.boundingBox.leftTop,
|
||
new Cesium.Cartesian3()
|
||
);
|
||
heatmapState.xAxis = Cesium.Cartesian3.normalize(
|
||
heatmapState.xAxis,
|
||
new Cesium.Cartesian3()
|
||
);
|
||
heatmapState.yAxis = Cesium.Cartesian3.subtract(
|
||
heatmapState.boundingBox.leftBottom,
|
||
heatmapState.boundingBox.leftTop,
|
||
new Cesium.Cartesian3()
|
||
);
|
||
heatmapState.yAxis = Cesium.Cartesian3.normalize(
|
||
heatmapState.yAxis,
|
||
new Cesium.Cartesian3()
|
||
);
|
||
heatmapState.xAxisLength = Cesium.Cartesian3.distance(
|
||
heatmapState.boundingBox.rightTop,
|
||
heatmapState.boundingBox.leftTop
|
||
);
|
||
heatmapState.yAxisLength = Cesium.Cartesian3.distance(
|
||
heatmapState.boundingBox.leftBottom,
|
||
heatmapState.boundingBox.leftTop
|
||
);
|
||
}
|
||
|
||
function createHeatmapGeometry(heatmapState) {
|
||
const meshData = generateMeshData(heatmapState);
|
||
const geometry = new Cesium.Geometry({
|
||
attributes: new Cesium.GeometryAttributes({
|
||
position: new Cesium.GeometryAttribute({
|
||
componentDatatype: Cesium.ComponentDatatype.DOUBLE,
|
||
componentsPerAttribute: 3,
|
||
values: meshData.positions,
|
||
}),
|
||
st: new Cesium.GeometryAttribute({
|
||
componentDatatype: Cesium.ComponentDatatype.FLOAT,
|
||
componentsPerAttribute: 2,
|
||
values: new Float32Array(meshData.textureCoords),
|
||
}),
|
||
}),
|
||
indices: new Uint16Array(meshData.indices),
|
||
primitiveType: Cesium.PrimitiveType[heatmapState.primitiveType],
|
||
boundingSphere: Cesium.BoundingSphere.fromVertices(meshData.positions),
|
||
});
|
||
return geometry;
|
||
}
|
||
|
||
function generateMeshData(heatmapState) {
|
||
const gridWidth = heatmapState.canvasWidth || 200;
|
||
const gridHeight = heatmapState.canvasWidth || 200;
|
||
const { maxLongitude, maxLatitude, minLongitude, minLatitude } =
|
||
heatmapState.boundingRect;
|
||
|
||
const longitudeStep = (maxLongitude - minLongitude) / gridWidth;
|
||
const latitudeStep = (maxLatitude - minLatitude) / gridHeight;
|
||
const positions = [];
|
||
const textureCoords = [];
|
||
const indices = [];
|
||
|
||
for (let i = 0; i < gridWidth; i++) {
|
||
const currentLongitude = minLongitude + longitudeStep * i;
|
||
|
||
for (let j = 0; j < gridHeight; j++) {
|
||
const currentLatitude = minLatitude + latitudeStep * j;
|
||
const heatValue = heatmapState.heatmapInstance.getValueAt({
|
||
x: i,
|
||
y: j,
|
||
});
|
||
const cartesian3 = Cesium.Cartesian3.fromDegrees(
|
||
currentLongitude,
|
||
currentLatitude,
|
||
heatmapState.baseElevation + heatValue
|
||
);
|
||
positions.push(cartesian3.x, cartesian3.y, cartesian3.z);
|
||
textureCoords.push(i / gridWidth, j / gridHeight);
|
||
if (j !== gridHeight - 1 && i !== gridWidth - 1) {
|
||
indices.push(
|
||
i * gridHeight + j,
|
||
i * gridHeight + j + 1,
|
||
(i + 1) * gridHeight + j
|
||
);
|
||
indices.push(
|
||
(i + 1) * gridHeight + j,
|
||
(i + 1) * gridHeight + j + 1,
|
||
i * gridHeight + j + 1
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
positions,
|
||
textureCoords,
|
||
indices,
|
||
};
|
||
}
|
||
|
||
function createHeatmapContainer(heatmapState) {
|
||
heatmapState.containerElement = window.document.createElement("div");
|
||
heatmapState.containerElement.id = `heatmap-${heatmapState.instanceId}`;
|
||
heatmapState.containerElement.className = `heatmap`;
|
||
heatmapState.containerElement.style.width = `${heatmapState.canvasWidth}px`;
|
||
heatmapState.containerElement.style.height = `${heatmapState.canvasWidth}px`;
|
||
heatmapState.containerElement.style.position = "absolute";
|
||
heatmapState.containerElement.style.display = "none";
|
||
const mapContainer = window.document.getElementById(
|
||
heatmapState.viewer.container.id
|
||
);
|
||
mapContainer.appendChild(heatmapState.containerElement);
|
||
}
|
||
|
||
const DOM = document.getElementById("box");
|
||
|
||
const viewer = new Cesium.Viewer(DOM, {
|
||
animation: false, //是否创建动画小器件，左下角仪表
|
||
|
||
baseLayerPicker: false, //是否显示图层选择器，右上角图层选择按钮
|
||
|
||
baseLayer: Cesium.ImageryLayer.fromProviderAsync(
|
||
Cesium.ArcGisMapServerImageryProvider.fromUrl(
|
||
"https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer"
|
||
)
|
||
),
|
||
|
||
fullscreenButton: false, //是否显示全屏按钮，右下角全屏选择按钮
|
||
|
||
timeline: false, //是否显示时间轴
|
||
|
||
infoBox: false, //是否显示信息框
|
||
});
|
||
|
||
viewer._cesiumWidget._creditContainer.style.display = "none";
|
||
|
||
// 模拟数值
|
||
const points = new Array(50).fill("").map(() => {
|
||
return {
|
||
lnglat: [
|
||
116.46 + Math.random() * 0.1 * (Math.random() > 0.5 ? 1 : -1),
|
||
39.92 + Math.random() * 0.1 * (Math.random() > 0.5 ? 1 : -1),
|
||
],
|
||
|
||
value: 1000 * Math.random(),
|
||
};
|
||
});
|
||
// 创建热力图
|
||
create3DHeatmap(viewer, {
|
||
dataPoints: points,
|
||
radius: 15,
|
||
baseElevation: 0,
|
||
primitiveType: "TRIANGLES",
|
||
colorGradient: {
|
||
".3": "blue",
|
||
".5": "green",
|
||
".7": "yellow",
|
||
".95": "red",
|
||
},
|
||
});
|
||
viewer.camera.flyTo({
|
||
destination: Cesium.Cartesian3.fromDegrees(116.46, 39.92, 100000),
|
||
orientation: {},
|
||
duration: 3,
|
||
});
|
||
|
||
</script>
|
||
</body>
|
||
|
||
</html> |