@provoly/dashboard 0.11.0

package/esm2022/widgets/widget-map/component/widget-map-layer.service.mjs

@@ -0,0 +1,317 @@
+import { Injectable } from '@angular/core';
+import { ItemUtils } from '@provoly/dashboard';
+import { Feature } from 'ol';
+import { getTopLeft, getWidth } from 'ol/extent';
+import { GeoJSON, MVT } from 'ol/format';
+import { Heatmap, Tile } from 'ol/layer';
+import VectorLayer from 'ol/layer/Vector';
+import VectorTileLayer from 'ol/layer/VectorTile';
+import { Cluster, TileWMS, Vector, WMTS, XYZ } from 'ol/source';
+import VectorSource from 'ol/source/Vector';
+import VectorTile from 'ol/source/VectorTile';
+import { Circle, Fill, Stroke, Style, Text } from 'ol/style';
+import CircleStyle from 'ol/style/Circle';
+import WMTSTileGrid from 'ol/tilegrid/WMTS';
+import { DEFAULT_HEATMAP_RADIUS, DEFAULT_RADIUS_INTENSITY_FACTOR, DEFAULT_ZOOM_MAX, DEFAULT_ZOOM_MIN, getCircleFeatureFromItem, getFeatureFromItem } from '../utils/widget-map.utils';
+import * as i0 from "@angular/core";
+export class WidgetMapLayerService {
+    constructor() {
+        this.styleCache = {};
+        this.circleStyle = new Style({
+            fill: new Fill({
+                color: 'rgba(37,89,163,0.24)'
+            }),
+            stroke: new Stroke({
+                color: 'rgb(37,89,163)',
+                width: 2
+            })
+        });
+        this.selectedCircleStyle = new Style({
+            fill: new Fill({
+                color: 'rgba(37,163,58,0.24)'
+            }),
+            stroke: new Stroke({
+                color: 'rgb(37,163,58)',
+                width: 2
+            })
+        });
+        this.pointStyle = new Style({
+            image: new Circle({
+                fill: new Fill({ color: 'rgba(37,89,163,0.24)' }),
+                stroke: new Stroke({ color: 'rgb(37,89,163)', width: 2 }),
+                radius: 10
+            })
+        });
+        this.selectedPointStyle = new Style({
+            image: new Circle({
+                fill: new Fill({ color: 'rgba(37,163,58,0.24)' }),
+                stroke: new Stroke({ color: 'rgb(37,163,58)', width: 2 }),
+                radius: 10
+            })
+        });
+        this.dontNeedLocation = ['relation', 'wms', 'wmts', 'geoserver', 'featurelayer', 'vectortile', 'rastertile'];
+        this.dontNeedIntensity = [...this.dontNeedLocation, 'marker', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon'];
+        this.layersImplementation = {
+            heatmap: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                const heatmap = new Heatmap({
+                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    opacity: (layer.opacity ?? 100) / 100,
+                    source: new Vector({ attributions: [layer.attribution ?? ''] }),
+                    blur: (layer.radius ?? DEFAULT_HEATMAP_RADIUS) / 2,
+                    radius: layer.radius ?? DEFAULT_HEATMAP_RADIUS,
+                    weight: (feature) => {
+                        const value = ItemUtils.getAttributeCalculatedValue(feature, attributesForClass[feature.get('oClass')].intensityAttribute);
+                        const atScale = (value - range.min) / (range.max - range.min);
+                        return layer.intensityAsc ? atScale : 1 - atScale;
+                    }
+                });
+                layerClassesId.forEach((classId) => {
+                    (resultSet.items[classId] || [])
+                        .filter((item) => {
+                        const location = ItemUtils.readGeometry(item, 'point', attributesForClass[classId].locationAttribute);
+                        return !!location;
+                    })
+                        .forEach((item) => {
+                        heatmap
+                            .getSource()
+                            ?.addFeature(getFeatureFromItem(item, 'heatpoint', attributesForClass[item.oClass].locationAttribute));
+                    });
+                });
+                return heatmap;
+            },
+            marker: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                const vectorLayer = new VectorLayer({
+                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    opacity: (layer.opacity ?? 100) / 100,
+                    source: new VectorSource({ attributions: [layer.attribution ?? ''] })
+                });
+                layerClassesId.forEach((classId) => {
+                    (resultSet.items[classId] || [])
+                        .filter((item) => {
+                        const location = ItemUtils.readGeometry(item, 'point', attributesForClass[item.oClass].locationAttribute);
+                        return !!location;
+                    })
+                        .forEach(async (item) => {
+                        const itemFeature = getFeatureFromItem(item, 'marker', attributesForClass[item.oClass].locationAttribute, itemStyles[item.id]?.classic, itemStyles[item.id]?.bordered);
+                        itemFeature.setStyle(itemFeature.get('classicStyle'));
+                        vectorLayer.getSource()?.addFeature(itemFeature);
+                    });
+                });
+                return this.makeClustered(vectorLayer, layer);
+            },
+            point: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'point');
+            },
+            line: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'line');
+            },
+            'multi-line': (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'multi-line');
+            },
+            polygon: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'polygon');
+            },
+            'multi-polygon': (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'multi-polygon');
+            },
+            bubble: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                const bubbleLayer = new VectorLayer({
+                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    opacity: (layer.opacity ?? 100) / 100,
+                    source: new VectorSource({ attributions: [layer.attribution ?? ''] })
+                });
+                layerClassesId.forEach((classId) => {
+                    (resultSet.items[classId] || [])
+                        .filter((item) => {
+                        const location = ItemUtils.readGeometry(item, 'point', attributesForClass[item.oClass].locationAttribute);
+                        return !!location;
+                    })
+                        .forEach((item) => {
+                        const value = ItemUtils.getAttributeCalculatedValue(item, attributesForClass[item.oClass].intensityAttribute);
+                        const atScale = (value - range.min) / (range.max - range.min);
+                        const itemFeature = getCircleFeatureFromItem(item, attributesForClass[item.oClass].locationAttribute, (layer.intensityAsc ? atScale : 1 - atScale) * (layer.radiusFactor ?? DEFAULT_RADIUS_INTENSITY_FACTOR), this.circleStyle, this.selectedCircleStyle);
+                        itemFeature.setStyle(itemFeature.get('classicStyle'));
+                        bubbleLayer.getSource()?.addFeature(itemFeature);
+                    });
+                });
+                return bubbleLayer;
+            },
+            relation: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                return new VectorLayer({
+                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    opacity: (layer.opacity ?? 100) / 100,
+                    source: new VectorSource({ attributions: [layer.attribution ?? ''] })
+                });
+            },
+            wms: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                const impl = new Tile({
+                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    opacity: (layer.opacity ?? 100) / 100,
+                    source: new TileWMS({
+                        attributions: [layer.attribution ?? ''],
+                        crossOrigin: 'anonymous',
+                        url: layer.url,
+                        params: { LAYERS: layer.paramLayer, TILED: layer.paramTiled }
+                    })
+                });
+                impl.set('oClass', layer.oClass);
+                return impl;
+            },
+            wmts: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                const projection = map.getView().getProjection();
+                const projectionExtent = projection.getExtent();
+                const size = getWidth(projectionExtent) / 256;
+                const resolutions = new Array(19);
+                const matrixIds = new Array(19);
+                for (let z = 0; z < 19; ++z) {
+                    // generate resolutions and matrixIds arrays for this WMTS
+                    resolutions[z] = size / Math.pow(2, z);
+                    matrixIds[z] = z;
+                }
+                return new Tile({
+                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    opacity: (layer.opacity ?? 100) / 100,
+                    source: new WMTS({
+                        attributions: [layer.attribution ?? ''],
+                        crossOrigin: 'anonymous',
+                        url: layer.url,
+                        layer: layer.paramLayer,
+                        matrixSet: layer.matrixSet,
+                        projection,
+                        tileGrid: new WMTSTileGrid({
+                            origin: getTopLeft(projectionExtent),
+                            resolutions: resolutions,
+                            matrixIds: matrixIds
+                        }),
+                        style: layer.style
+                    })
+                });
+            },
+            geoserver: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                const impl = this.layersImplementation['wms']({ ...layer, type: 'wms', oClass: layer.oClass }, attributesForClass, layerClassesId, resultSet, range, itemStyles, map);
+                impl.set('title', layer.title);
+                impl.set('oClass', layer.oClass);
+                return impl;
+            },
+            featurelayer: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                return new VectorLayer({
+                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    opacity: (layer.opacity ?? 100) / 100,
+                    source: new VectorSource({
+                        attributions: [layer.attribution ?? ''],
+                        format: new GeoJSON(),
+                        url: layer.url
+                    })
+                });
+            },
+            vectortile: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                return new VectorTileLayer({
+                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    opacity: (layer.opacity ?? 100) / 100,
+                    source: new VectorTile({
+                        attributions: [layer.attribution ?? ''],
+                        format: new MVT(),
+                        url: layer.url
+                    })
+                });
+            },
+            rastertile: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
+                return new Tile({
+                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    opacity: (layer.opacity ?? 100) / 100,
+                    source: new XYZ({
+                        url: layer.url,
+                        attributions: [layer.attribution ?? '']
+                    })
+                });
+            }
+        };
+    }
+    get implementationList() {
+        return Object.keys(this.layersImplementation).filter((implementation) => implementation !== 'geoserver');
+    }
+    layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, type) {
+        const vectorLayer = new VectorLayer({
+            minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
+            maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+            opacity: (layer.opacity ?? 100) / 100,
+            source: new VectorSource({ attributions: [layer.attribution ?? ''] })
+        });
+        layerClassesId.forEach((classId) => {
+            (resultSet.items[classId] || [])
+                .map((item) => ({
+                item,
+                location: ItemUtils.readGeometry(item, type, attributesForClass[item.oClass].locationAttribute)
+            }))
+                .filter(({ location }) => !!location)
+                .forEach(async (subItem) => {
+                const itemFeature = new Feature({
+                    ...subItem.item,
+                    type,
+                    geometry: subItem.location,
+                    classicStyle: type === 'point' ? this.pointStyle : this.circleStyle,
+                    selectedStyle: type === 'point' ? this.selectedPointStyle : this.selectedCircleStyle
+                });
+                itemFeature.setStyle(itemFeature.get('classicStyle'));
+                vectorLayer.getSource()?.addFeature(itemFeature);
+            });
+        });
+        return this.makeClustered(vectorLayer, layer);
+    }
+    makeClustered(layer, layerOptions) {
+        if (!['marker', 'bubble'].includes(layerOptions.type) || !('clustered' in layerOptions && layerOptions.clustered)) {
+            return layer;
+        }
+        // Clustering source
+        const vectorLayer = layer;
+        vectorLayer.setSource(new Cluster({
+            distance: layerOptions.clusterDistance,
+            minDistance: 10,
+            source: vectorLayer.getSource()
+        }));
+        vectorLayer.setStyle((feature) => {
+            const size = feature.get('features').length;
+            if (size > 1) {
+                let style = this.styleCache[size];
+                if (!style) {
+                    style = new Style({
+                        image: new CircleStyle({
+                            radius: 10,
+                            stroke: new Stroke({
+                                color: '#fff'
+                            }),
+                            fill: new Fill({
+                                color: '#3399CC'
+                            })
+                        }),
+                        text: new Text({ text: `${size}` })
+                    });
+                    this.styleCache[size] = style;
+                }
+                return style;
+            }
+            else {
+                return size === 1 ? feature.get('features')[0].get('classicStyle') : null;
+            }
+        });
+        return layer;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetMapLayerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetMapLayerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetMapLayerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-map-layer.service.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/widgets/widget-map/component/widget-map-layer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Attribute,\n  ItemUtils,\n  MapFeatureLayerOptions,\n  MapGeoServerLayerOptions,\n  MapRasterTileLayerOptions,\n  MapVectorTileLayerOptions,\n  MapWidgetBubbleLayerOptions,\n  MapWidgetHeatMapLayerOptions,\n  MapWidgetLayerOptions,\n  MapWidgetMarkerLayerOptions,\n  MapWidgetRelationLayerOptions,\n  MapWMSLayerLayerOptions,\n  MapWMTSLayerLayerOptions,\n  ResultSet\n} from '@provoly/dashboard';\nimport { Feature, Map } from 'ol';\nimport { getTopLeft, getWidth } from 'ol/extent';\nimport { GeoJSON, MVT } from 'ol/format';\nimport { Geometry } from 'ol/geom';\nimport { Heatmap, Tile } from 'ol/layer';\nimport BaseLayer from 'ol/layer/Base';\nimport VectorLayer from 'ol/layer/Vector';\nimport VectorTileLayer from 'ol/layer/VectorTile';\nimport { Cluster, TileWMS, Vector, WMTS, XYZ } from 'ol/source';\nimport VectorSource from 'ol/source/Vector';\nimport VectorTile from 'ol/source/VectorTile';\nimport { Circle, Fill, Stroke, Style, Text } from 'ol/style';\nimport CircleStyle from 'ol/style/Circle';\nimport WMTSTileGrid from 'ol/tilegrid/WMTS';\nimport {\n  DEFAULT_HEATMAP_RADIUS,\n  DEFAULT_RADIUS_INTENSITY_FACTOR,\n  DEFAULT_ZOOM_MAX,\n  DEFAULT_ZOOM_MIN,\n  getCircleFeatureFromItem,\n  getFeatureFromItem\n} from '../utils/widget-map.utils';\n\nexport type AttributesForClass = {\n  [key: string]: {\n    intensityAttribute: Attribute;\n    locationAttribute: Attribute;\n  };\n};\n\nexport type ItemStyles = { [id: string]: { classic: Style; bordered: Style } };\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class WidgetMapLayerService {\n  styleCache: any = {};\n\n  circleStyle = new Style({\n    fill: new Fill({\n      color: 'rgba(37,89,163,0.24)'\n    }),\n    stroke: new Stroke({\n      color: 'rgb(37,89,163)',\n      width: 2\n    })\n  });\n  selectedCircleStyle = new Style({\n    fill: new Fill({\n      color: 'rgba(37,163,58,0.24)'\n    }),\n    stroke: new Stroke({\n      color: 'rgb(37,163,58)',\n      width: 2\n    })\n  });\n\n  pointStyle = new Style({\n    image: new Circle({\n      fill: new Fill({ color: 'rgba(37,89,163,0.24)' }),\n      stroke: new Stroke({ color: 'rgb(37,89,163)', width: 2 }),\n      radius: 10\n    })\n  });\n  selectedPointStyle = new Style({\n    image: new Circle({\n      fill: new Fill({ color: 'rgba(37,163,58,0.24)' }),\n      stroke: new Stroke({ color: 'rgb(37,163,58)', width: 2 }),\n      radius: 10\n    })\n  });\n\n  get implementationList() {\n    return Object.keys(this.layersImplementation).filter((implementation) => implementation !== 'geoserver');\n  }\n\n  dontNeedLocation = ['relation', 'wms', 'wmts', 'geoserver', 'featurelayer', 'vectortile', 'rastertile'];\n  dontNeedIntensity = [...this.dontNeedLocation, 'marker', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon'];\n\n  layersImplementation = {\n    heatmap: (\n      layer: MapWidgetHeatMapLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      const heatmap = new Heatmap({\n        minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n        maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n        opacity: (layer.opacity ?? 100) / 100,\n        source: new Vector({ attributions: [layer.attribution ?? ''] }),\n        blur: (layer.radius ?? DEFAULT_HEATMAP_RADIUS) / 2,\n        radius: layer.radius ?? DEFAULT_HEATMAP_RADIUS,\n        weight: (feature: any) => {\n          const value = ItemUtils.getAttributeCalculatedValue(\n            feature,\n            attributesForClass[feature.get('oClass') as string].intensityAttribute\n          ) as number;\n          const atScale = (value - range.min) / (range.max - range.min);\n          return layer.intensityAsc ? atScale : 1 - atScale;\n        }\n      });\n\n      layerClassesId.forEach((classId) => {\n        (resultSet.items[classId] || [])\n          .filter((item) => {\n            const location = ItemUtils.readGeometry(item, 'point', attributesForClass[classId].locationAttribute);\n            return !!location;\n          })\n          .forEach((item) => {\n            heatmap\n              .getSource()\n              ?.addFeature(getFeatureFromItem(item, 'heatpoint', attributesForClass[item.oClass].locationAttribute));\n          });\n      });\n\n      return heatmap as BaseLayer;\n    },\n    marker: (\n      layer: MapWidgetMarkerLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      const vectorLayer = new VectorLayer({\n        minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n        maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n        opacity: (layer.opacity ?? 100) / 100,\n        source: new VectorSource({ attributions: [layer.attribution ?? ''] })\n      });\n\n      layerClassesId.forEach((classId) => {\n        (resultSet.items[classId] || [])\n          .filter((item) => {\n            const location = ItemUtils.readGeometry(item, 'point', attributesForClass[item.oClass].locationAttribute);\n            return !!location;\n          })\n          .forEach(async (item) => {\n            const itemFeature = getFeatureFromItem(\n              item,\n              'marker',\n              attributesForClass[item.oClass].locationAttribute,\n              itemStyles[item.id]?.classic,\n              itemStyles[item.id]?.bordered\n            );\n            itemFeature.setStyle(itemFeature.get('classicStyle'));\n            vectorLayer.getSource()?.addFeature(itemFeature);\n          });\n      });\n\n      return this.makeClustered(vectorLayer, layer);\n    },\n    point: (\n      layer: MapWidgetMarkerLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'point');\n    },\n    line: (\n      layer: MapWidgetMarkerLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'line');\n    },\n    'multi-line': (\n      layer: MapWidgetMarkerLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'multi-line');\n    },\n    polygon: (\n      layer: MapWidgetMarkerLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'polygon');\n    },\n    'multi-polygon': (\n      layer: MapWidgetMarkerLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'multi-polygon');\n    },\n    bubble: (\n      layer: MapWidgetBubbleLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      const bubbleLayer = new VectorLayer({\n        minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n        maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n        opacity: (layer.opacity ?? 100) / 100,\n        source: new VectorSource({ attributions: [layer.attribution ?? ''] })\n      });\n\n      layerClassesId.forEach((classId) => {\n        (resultSet.items[classId] || [])\n          .filter((item) => {\n            const location = ItemUtils.readGeometry(item, 'point', attributesForClass[item.oClass].locationAttribute);\n            return !!location;\n          })\n          .forEach((item) => {\n            const value = ItemUtils.getAttributeCalculatedValue(\n              item,\n              attributesForClass[item.oClass].intensityAttribute\n            ) as number;\n            const atScale = (value - range.min) / (range.max - range.min);\n            const itemFeature = getCircleFeatureFromItem(\n              item,\n              attributesForClass[item.oClass].locationAttribute,\n              (layer.intensityAsc ? atScale : 1 - atScale) * (layer.radiusFactor ?? DEFAULT_RADIUS_INTENSITY_FACTOR),\n              this.circleStyle,\n              this.selectedCircleStyle\n            );\n            itemFeature.setStyle(itemFeature.get('classicStyle'));\n            bubbleLayer.getSource()?.addFeature(itemFeature);\n          });\n      });\n\n      return bubbleLayer;\n    },\n    relation: (\n      layer: MapWidgetRelationLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      return new VectorLayer({\n        minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n        maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n        opacity: (layer.opacity ?? 100) / 100,\n        source: new VectorSource({ attributions: [layer.attribution ?? ''] })\n      });\n    },\n    wms: (\n      layer: MapWMSLayerLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      const impl = new Tile({\n        minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n        maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n        opacity: (layer.opacity ?? 100) / 100,\n        source: new TileWMS({\n          attributions: [layer.attribution ?? ''],\n          crossOrigin: 'anonymous',\n          url: layer.url,\n          params: { LAYERS: layer.paramLayer, TILED: layer.paramTiled }\n        })\n      });\n      impl.set('oClass', layer.oClass);\n      return impl;\n    },\n    wmts: (\n      layer: MapWMTSLayerLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      const projection = map.getView().getProjection();\n      const projectionExtent = projection.getExtent();\n      const size = getWidth(projectionExtent) / 256;\n      const resolutions = new Array(19);\n      const matrixIds = new Array(19);\n      for (let z = 0; z < 19; ++z) {\n        // generate resolutions and matrixIds arrays for this WMTS\n        resolutions[z] = size / Math.pow(2, z);\n        matrixIds[z] = z;\n      }\n      return new Tile({\n        minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n        maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n        opacity: (layer.opacity ?? 100) / 100,\n        source: new WMTS({\n          attributions: [layer.attribution ?? ''],\n          crossOrigin: 'anonymous',\n          url: layer.url,\n          layer: layer.paramLayer,\n          matrixSet: layer.matrixSet,\n          projection,\n          tileGrid: new WMTSTileGrid({\n            origin: getTopLeft(projectionExtent),\n            resolutions: resolutions,\n            matrixIds: matrixIds\n          }),\n          style: layer.style\n        })\n      });\n    },\n    geoserver: (\n      layer: MapGeoServerLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      const impl = this.layersImplementation['wms'](\n        { ...layer, type: 'wms', oClass: layer.oClass },\n        attributesForClass,\n        layerClassesId,\n        resultSet,\n        range,\n        itemStyles,\n        map\n      );\n      impl.set('title', layer.title);\n      impl.set('oClass', layer.oClass);\n      return impl;\n    },\n    featurelayer: (\n      layer: MapFeatureLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      return new VectorLayer({\n        minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n        maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n        opacity: (layer.opacity ?? 100) / 100,\n        source: new VectorSource({\n          attributions: [layer.attribution ?? ''],\n          format: new GeoJSON(),\n          url: layer.url\n        })\n      });\n    },\n    vectortile: (\n      layer: MapVectorTileLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      return new VectorTileLayer({\n        minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n        maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n        opacity: (layer.opacity ?? 100) / 100,\n        source: new VectorTile({\n          attributions: [layer.attribution ?? ''],\n          format: new MVT(),\n          url: layer.url\n        })\n      });\n    },\n    rastertile: (\n      layer: MapRasterTileLayerOptions,\n      attributesForClass: AttributesForClass,\n      layerClassesId: string[],\n      resultSet: ResultSet,\n      range: { min: number; max: number },\n      itemStyles: ItemStyles,\n      map: Map\n    ) => {\n      return new Tile({\n        minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n        maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n        opacity: (layer.opacity ?? 100) / 100,\n        source: new XYZ({\n          url: layer.url,\n          attributions: [layer.attribution ?? '']\n        })\n      });\n    }\n  };\n\n  private layerFromGeoJsonGeometry(\n    layer: MapWidgetMarkerLayerOptions,\n    layerClassesId: string[],\n    resultSet: ResultSet,\n    attributesForClass: AttributesForClass,\n    type: 'point' | 'line' | 'multi-line' | 'polygon' | 'multi-polygon'\n  ) {\n    const vectorLayer = new VectorLayer({\n      minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,\n      maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,\n      opacity: (layer.opacity ?? 100) / 100,\n      source: new VectorSource({ attributions: [layer.attribution ?? ''] })\n    });\n\n    layerClassesId.forEach((classId) => {\n      (resultSet.items[classId] || [])\n        .map((item) => ({\n          item,\n          location: ItemUtils.readGeometry(item, type, attributesForClass[item.oClass].locationAttribute)\n        }))\n        .filter(({ location }) => !!location)\n        .forEach(async (subItem) => {\n          const itemFeature = new Feature({\n            ...subItem.item,\n            type,\n            geometry: subItem.location,\n            classicStyle: type === 'point' ? this.pointStyle : this.circleStyle,\n            selectedStyle: type === 'point' ? this.selectedPointStyle : this.selectedCircleStyle\n          });\n          itemFeature.setStyle(itemFeature.get('classicStyle'));\n          vectorLayer.getSource()?.addFeature(itemFeature);\n        });\n    });\n\n    return this.makeClustered(vectorLayer, layer);\n  }\n\n  private makeClustered(layer: BaseLayer, layerOptions: MapWidgetLayerOptions) {\n    if (!['marker', 'bubble'].includes(layerOptions.type) || !('clustered' in layerOptions && layerOptions.clustered)) {\n      return layer;\n    }\n    // Clustering source\n    const vectorLayer = layer as VectorLayer<VectorSource<Geometry>>;\n    vectorLayer.setSource(\n      new Cluster({\n        distance: layerOptions.clusterDistance,\n        minDistance: 10,\n        source: vectorLayer.getSource() as VectorSource\n      })\n    );\n\n    vectorLayer.setStyle((feature) => {\n      const size = feature.get('features').length;\n      if (size > 1) {\n        let style = this.styleCache[size];\n        if (!style) {\n          style = new Style({\n            image: new CircleStyle({\n              radius: 10,\n              stroke: new Stroke({\n                color: '#fff'\n              }),\n              fill: new Fill({\n                color: '#3399CC'\n              })\n            }),\n            text: new Text({ text: `${size}` })\n          });\n          this.styleCache[size] = style;\n        }\n        return style;\n      } else {\n        return size === 1 ? feature.get('features')[0].get('classicStyle') : null;\n      }\n    });\n\n    return layer;\n  }\n}\n"]}