@kalisio/kdk 2.5.3 → 2.6.0

package/map/client/utils/utils.features.js

@@ -1,7 +1,9 @@
 import _ from 'lodash'
 import logger from 'loglevel'
 import moment from 'moment'
+import jsts from 'jsts'
 import { getType, getGeom } from '@turf/invariant'
+import { lineString } from '@turf/helpers'
 import explode from '@turf/explode'
 import kinks from '@turf/kinks'
 import clean from '@turf/clean-coords'
@@ -10,13 +12,17 @@ import rhumbDistance from '@turf/rhumb-distance'
 import rotate from '@turf/transform-rotate'
 import scale from '@turf/transform-scale'
 import translate from '@turf/transform-translate'
+import bbox from "@turf/bbox"
+import convex from '@turf/convex'
 import { api, Time } from '../../../core/client/index.js'
 import { listenToServiceEvents, unlistenToServiceEvents } from '../../../core/client/utils/index.js'
+import { getStyleType } from './utils.style.js'
 import { isInMemoryLayer, isFeatureLayer } from './utils.layers.js'
+import { getGeoJsonFeatures } from '../utils.map.js'
 import chroma from 'chroma-js'
 
-export function processFeatures(geoJson, processor) {
-  const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+export function processFeatures (geoJson, processor) {
+  const features = getGeoJsonFeatures(geoJson)
   if (typeof processor === 'function') {
     features.forEach(feature => processor(feature))
   } else if (typeof processor === 'string') {
@@ -25,8 +31,8 @@ export function processFeatures(geoJson, processor) {
   }
 }
 
-export function transformFeatures(geoJson, transform) {
-  const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+export function transformFeatures (geoJson, transform) {
+  const features = getGeoJsonFeatures(geoJson)
   features.forEach(feature => {
     const scaling = _.get(transform, 'scale')
     const rotation = _.get(transform, 'rotate')
@@ -54,18 +60,40 @@ export function transformFeatures(geoJson, transform) {
   })
 }
 
-export async function buildGradientPath(geoJson, options) {
-  const variable = options.build.variable
+export function computeBoundingBox (geoJson, padding = 0) {
+  if (!geoJson) return
+  const box = bbox(geoJson)
+  if (!_.every(box, _.isFinite)) return null
+  if (!padding) return box
+  // compute padding
+  const padX = (box[2] - box[0]) * padding
+  const padY = (box[3] - box[1]) * padding
+  return [box[0] - padX, box[1] - padY, box[2] + padX, box[3] + padY]
+}
+
+export function computeConvexHull (geoJson) {
+  if (!geoJson) return
+  const points = explode(geoJson)
+  const count = _.size(points.features)
+  if (count === 0) return null
+  if (count === 1) return points.features[0]
+  if (count === 2) return lineString(points.features.map(point => point.geometry.coordinates))
+  const hull = convex(points)
+  // specific case if points are colinear
+  if (!hull) return lineString(points.features.map(point => point.geometry.coordinates))
+  return hull
+}
 
+export async function buildGradientPath (geoJson, options) {
+  const variable = options.build.variable
   // Check if the GeoJSON is a FeatureCollection
   if (!geoJson || geoJson.type !== 'FeatureCollection') {
-    console.error('Invalid GeoJSON, a FeatureCollection is required to build a gradient path')
+    logger.warn('[KDK] Invalid GeoJSON, a FeatureCollection is required to build a gradient path')
     return
   }
-
   // Check chromajs has required infos
   if (!variable.chromajs.colors) {
-    console.error(`Invalid chromajs on variable ${variable.name}, missing colors.`)
+    logger.warn(`[KDK] Invalid chromajs on variable ${variable.name}, missing colors.`)
     return
   }
   let scale
@@ -75,30 +103,25 @@ export async function buildGradientPath(geoJson, options) {
     scale = chroma.scale(variable.chromajs.colors).classes(variable.chromajs.classes)
   }
   if (!scale) {
-    console.error(`Invalid chromajs on variable ${variable.name}, missing domain or classes.`)
+    logger.warn(`[KDK] Invalid chromajs on variable ${variable.name}, missing domain or classes.`)
     return
   }
-
   geoJson.features = geoJson.features.map((feature) => {
     const geometries = feature.geometry.geometries.map(g => g.coordinates)
     const values = feature.properties[variable.name]
-
+    const gradient = values.map(value => scale(value).hex())
     // Check if the feature has at least two geometries and they are different
-    if (geometries.length < 2 || _.uniqBy(geometries, JSON.stringify).length < 2) {
-      console.error('Invalid GeoJSON, at least two geometries are required to construct a line')
-      // convert it to a point
+    if (geometries.length < 2) {
+      // Make it a line
       return {
         type: 'Feature',
         geometry: {
-          type: 'Point',
-          coordinates: geometries[0],
+          type: 'LineString',
+          coordinates: [ geometries[0], geometries[0] ]
         },
-        properties: feature.properties,
+        properties: Object.assign({ gradient: [ gradient[0], gradient[0] ] }, _.omit(feature.properties, variable.name), variable.gradientPath.properties)
       }
     }
-
-    const gradient = values.map(value => scale(value).hex())
-
     return {
       type: 'Feature',
       geometry: {
@@ -108,11 +131,10 @@ export async function buildGradientPath(geoJson, options) {
       properties: Object.assign({ gradient }, _.omit(feature.properties, variable.name), variable.gradientPath.properties)
     }
   })
-
   geoJson.total = geoJson.features.length
 }
 
-async function checkBuildInstructions(options) {
+async function checkBuildInstructions (options) {
   const knownInstructions = ['gradientPath']
   if (!options.variables) return
 
@@ -125,7 +147,7 @@ async function checkBuildInstructions(options) {
   }
 }
 
-export async function getBaseQueryForFeatures(options) {
+export async function getBaseQueryForFeatures (options) {
   // Any base query to process ?
   const baseQuery = {}
   if (options.baseQuery) {
@@ -141,7 +163,7 @@ export async function getBaseQueryForFeatures(options) {
   return baseQuery
 }
 
-export async function getFilterQueryForFeatures(options) {
+export async function getFilterQueryForFeatures (options) {
   // Any filter query to process ?
   const filterQuery = {}
   if (options.filterQuery) {
@@ -173,7 +195,7 @@ export async function getFilterQueryForFeatures(options) {
   return filterQuery
 }
 
-export async function getSortQueryForFeatures(options) {
+export async function getSortQueryForFeatures (options) {
   // Any sort query to process ?
   const sortQuery = {}
   if (options.sortQuery) {
@@ -187,12 +209,12 @@ export async function getSortQueryForFeatures(options) {
   return { $sort: sortQuery }
 }
 
-export function getFeaturesUpdateInterval(options) {
+export function getFeaturesUpdateInterval (options) {
   const interval = _.get(options, 'every')
   return (interval ? moment.duration(interval) : null)
 }
 
-export function getFeaturesQueryInterval(options) {
+export function getFeaturesQueryInterval (options) {
   const interval = getFeaturesUpdateInterval(options)
   let queryInterval = _.get(options, 'queryFrom')
   // If query interval not given use 2 x refresh interval as default value
@@ -214,7 +236,7 @@ export function shouldSkipFeaturesUpdate(lastUpdateTime, options, interval) {
   return (Math.abs(elapsed.asMilliseconds()) < interval.asMilliseconds())
 }
 
-export async function getProbeFeatures(options) {
+export async function getProbeFeatures (options) {
   // Any base/filter/sort query to process ?
   const query = await getBaseQueryForFeatures(options)
   const filterQuery = await getFilterQueryForFeatures(options)
@@ -228,7 +250,7 @@ export async function getProbeFeatures(options) {
   return response
 }
 
-export async function getFeaturesQuery(options, queryInterval, queryLevel) {
+export async function getFeaturesQuery (options, queryInterval, queryLevel) {
   // If not given try to compute query interval from options
   if (!queryInterval) {
     queryInterval = getFeaturesQueryInterval(options)
@@ -306,7 +328,7 @@ export async function getFeaturesQuery(options, queryInterval, queryLevel) {
   return query
 }
 
-export function isFeatureInQueryInterval(feature, options) {
+export function isFeatureInQueryInterval (feature, options) {
   // We assume this is not a time-varying layer
   if (!feature.time) return true
   const queryInterval = getFeaturesQueryInterval(options)
@@ -324,7 +346,7 @@ export function isFeatureInQueryInterval(feature, options) {
   return time.isSameOrAfter(gte) && time.isSameOrBefore(lte)
 }
 
-export async function getFeaturesFromQuery(options, query) {
+export async function getFeaturesFromQuery (options, query) {
   // Check API to be used in case the layer is coming from a remote "planet"
   const planetApi = (typeof options.getPlanetApi === 'function' ? options.getPlanetApi() : api)
   const response = await planetApi.getService(options.service).find(Object.assign({ query }, options.baseParams))
@@ -342,7 +364,7 @@ export async function getFeaturesFromQuery(options, query) {
   return response
 }
 
-export function getMeasureForFeatureBaseQuery(layer, feature) {
+export function getMeasureForFeatureBaseQuery (layer, feature) {
   // We might have a different ID to identify measures related to a timeseries (what is called a chronicle)
   // than measures displayed on a map. For instance mobile measures might appear at different locations,
   // but when selecting one we would like to display the timeseries related to all locations.
@@ -356,7 +378,7 @@ export function getMeasureForFeatureBaseQuery(layer, feature) {
   return query
 }
 
-export async function getMeasureForFeatureQuery(layer, feature, startTime, endTime, level) {
+export async function getMeasureForFeatureQuery (layer, feature, startTime, endTime, level) {
   const query = await getFeaturesQuery(_.merge({
     baseQuery: getMeasureForFeatureBaseQuery(layer, feature)
   }, layer), {
@@ -366,12 +388,12 @@ export async function getMeasureForFeatureQuery(layer, feature, startTime, endTi
   return query
 }
 
-export async function getMeasureForFeatureFromQuery(layer, feature, query) {
+export async function getMeasureForFeatureFromQuery (layer, feature, query) {
   const result = await getFeaturesFromQuery(layer, query)
   return _.get(result, 'features[0]')
 }
 
-export async function getMeasureForFeature(layer, feature, startTime, endTime, level) {
+export async function getMeasureForFeature (layer, feature, startTime, endTime, level) {
   let probedLocation
   try {
     const query = await getMeasureForFeatureQuery(layer, feature, startTime, endTime, level)
@@ -382,11 +404,59 @@ export async function getMeasureForFeature(layer, feature, startTime, endTime, l
   return probedLocation
 }
 
-export function checkFeatures(geoJson, options = {
+const JstsErrorI18nKeys = [
+  'GEOMETRY_ERROR',
+  'GEOMETRY_REPEATED_POINT',
+  'GEOMETRY_HOLE_OUTSIDE_SHELL',
+  'GEOMETRY_NESTED_HOLES',
+  'GEOMETRY_DISCONNECTED_INTERIOR',
+  'GEOMETRY_SELF_INTERSECTION',
+  'GEOMETRY_RING_SELF_INTERSECTION',
+  'GEOMETRY_NESTED_SHELLS',
+  'GEOMETRY_DUPLICATE_RINGS',
+  'GEOMETRY_TOO_FEW_POINTS',
+  'GEOMETRY_INVALID_COORDINATES',
+  'GEOMETRY_RING_NOT_CLOSED'
+]
+
+export function cleanFeatures (geoJson, precision = 1e-9) {
+  let errors = []
+  const geometryTypes = new Set()
+  if (geoJson.type === 'Feature') {
+    const geometryType = _.get(geoJson, 'geometry.type')
+    if (!geometryType) {
+      logger.warn('[KDK] feature has undefined geometry')
+      return
+    }
+    geometryTypes.add(geometryType)
+    if (geometryType === 'Polygon' || geometryType === 'MultiPolygon') {
+      const reader = new jsts.io.GeoJSONReader()
+      const writer = new jsts.io.GeoJSONWriter()
+      const geometry = reader.read(geoJson.geometry)
+      const validator = new jsts.operation.valid.IsValidOp(geometry)
+      if (!validator.isValid()) {
+        errors.push({ error: 'errors.' + JstsErrorI18nKeys[validator.getValidationError()._errorType], identifier: _.get(geoJson, 'properties.id', _.get(geoJson, 'properties.name', _.get(geoJson, 'properties.label'))) })
+        const correctedGeometry = geometry.buffer(precision).buffer(-precision)
+        geoJson.geometry = writer.write(correctedGeometry)
+      }
+    }
+  } else {
+    _.forEach(geoJson.features, feature => {
+      const { errors: errs, geometryTypes: types } = cleanFeatures(feature)
+      if (errs) errors = _.concat(errors, errs)
+      if (types) {
+        _.forEach(types, type => geometryTypes.add(type))
+      }
+    })
+  }
+  return { errors, geometryTypes: Array.from(geometryTypes) }
+}
+
+export function checkFeatures (geoJson, options = {
   kinks: true,
   redundantCoordinates: true
 }) {
-  const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+  const features = getGeoJsonFeatures(geoJson)
   // Removes redundant coordinates
   if (options.redundantCoordinates) {
     features.forEach(feature => clean(feature, { mutate: true }))
@@ -407,9 +477,9 @@ export function checkFeatures(geoJson, options = {
   return { kinks: kinksFeatures }
 }
 
-export async function createFeatures(geoJson, layer, chunkSize = 5000, processCallback) {
+export async function createFeatures (geoJson, layer, chunkSize = 5000, processCallback) {
   if (!layer) return
-  const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+  const features = getGeoJsonFeatures(geoJson)
   features.forEach(feature => {
     // Remove any temporary ID as we will use the one from MongoDB
     delete feature._id
@@ -457,8 +527,8 @@ export async function createFeatures(geoJson, layer, chunkSize = 5000, processCa
   }
 }
 
-export async function editFeaturesGeometry(geoJson, layer) {
-  const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+export async function editFeaturesGeometry (geoJson, layer) {
+  const features = getGeoJsonFeatures(geoJson)
   const updatedFeatures = []
   for (let i = 0; i < features.length; i++) {
     const feature = features[i]
@@ -470,8 +540,8 @@ export async function editFeaturesGeometry(geoJson, layer) {
   return (geoJson.type === 'FeatureCollection' ? Object.assign(geoJson, { features: updatedFeatures }) : updatedFeatures)
 }
 
-export async function editFeaturesProperties(geoJson, layer) {
-  const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+export async function editFeaturesProperties (geoJson, layer) {
+  const features = getGeoJsonFeatures(geoJson)
   const updatedFeatures = []
   for (let i = 0; i < features.length; i++) {
     const feature = features[i]
@@ -483,8 +553,8 @@ export async function editFeaturesProperties(geoJson, layer) {
   return (geoJson.type === 'FeatureCollection' ? Object.assign(geoJson, { features: updatedFeatures }) : updatedFeatures)
 }
 
-export async function editFeaturesStyle(geoJson, layer) {
-  const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+export async function editFeaturesStyle (geoJson, layer) {
+  const features = getGeoJsonFeatures(geoJson)
   const updatedFeatures = []
   for (let i = 0; i < features.length; i++) {
     const feature = features[i]
@@ -496,12 +566,12 @@ export async function editFeaturesStyle(geoJson, layer) {
   return (geoJson.type === 'FeatureCollection' ? Object.assign(geoJson, { features: updatedFeatures }) : updatedFeatures)
 }
 
-export async function removeFeatures(geoJson, layer) {
+export async function removeFeatures (geoJson, layer) {
   // Remove all features of a given layer
   if (!geoJson) {
     await api.getService(layer.service).remove(null, { query: { layer: layer._id } })
   } else {
-    const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+    const features = getGeoJsonFeatures(geoJson)
     for (let i = 0; i < features.length; i++) {
       const feature = features[i]
       if (feature._id) await api.getService(layer.service).remove(feature._id)
@@ -509,7 +579,7 @@ export async function removeFeatures(geoJson, layer) {
   }
 }
 
-export async function fetchGeoJson(dataSource, options = {}) {
+export async function fetchGeoJson (dataSource, options = {}) {
   const response = await fetch(dataSource)
   if (response.status !== 200) {
     throw new Error(`Impossible to fetch ${dataSource}: ` + response.status)
@@ -526,11 +596,7 @@ export function getFeatureStyleType (feature) {
     logger.warn('[KDK] feature has undefined geometry')
     return
   }
-  if (['Point', 'MultiPoint'].includes(geometryType)) return 'point'
-  if (['LineString', 'MultiLineString'].includes(geometryType)) return 'line'
-  if (['Polygon', 'MultiPolygon'].includes(geometryType)) return 'polygon'
-  logger.warn(`[KDK] unsupported geometry of type of ${geometryType}`)
-  return
+  return getStyleType(geometryType)
 }
 
 // Bind listeners to layer service events and store it in the returned object

package/map/client/utils/utils.js

@@ -2,18 +2,29 @@ import _ from 'lodash'
 import formatcoords from 'formatcoords'
 
 // Find the nearest time of a given one in a given moment time list
-export function getNearestTime (time, times) {
+// if the time list is already sorted in ascending order use the last argument to speed up search
+export function getNearestTime (time, times, sorted = false) {
   // Look for the nearest time
-  let timeIndex = -1
-  let minDiff = Infinity
-  times.forEach((currentTime, index) => {
-    const diff = Math.abs(time.diff(currentTime))
-    if (diff < minDiff) {
-      minDiff = diff
-      timeIndex = index
+  if (sorted) {
+    let timeIndex = 0
+    for (; timeIndex < times.length; timeIndex++) {
+      if (time.valueOf() < times[timeIndex].valueOf()) break
     }
-  })
-  return { index: timeIndex, difference: minDiff }
+    // We've found the first index greater than the time so return the previous
+    if (timeIndex > 0) timeIndex--
+    return { index: timeIndex, difference: Math.abs(time.diff(times[timeIndex])) }
+  } else {
+    let timeIndex = -1
+    let minDiff = Infinity
+    times.forEach((currentTime, index) => {
+      const diff = Math.abs(time.diff(currentTime))
+      if (diff < minDiff) {
+        minDiff = diff
+        timeIndex = index
+      }
+    })
+    return { index: timeIndex, difference: minDiff }
+  }
 }
 
 // Find the minimum or maximum time interval in a given moment time list
@@ -64,3 +75,7 @@ export function coordinatesToGeoJSON (lat, lon, format, options) {
     }
   }
 }
+
+export function getGeoJsonFeatures (geoJson) {
+  return (Array.isArray(geoJson) ? geoJson : (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson]))
+}

package/map/client/utils/utils.layers.js

@@ -4,14 +4,14 @@ import { Notify, Loading, uid } from 'quasar'
 import explode from '@turf/explode'
 import SphericalMercator from '@mapbox/sphericalmercator'
 import { i18n, api, LocalCache, utils as kCoreUtils, hooks as kCoreHooks } from '../../../core/client/index.js'
-import { checkFeatures, createFeatures, removeFeatures } from './utils.features.js'
+import { cleanFeatures, createFeatures, removeFeatures } from './utils.features.js'
 import { PMTiles, findTile, zxyToTileId } from 'pmtiles'
 import { sourcesToViews } from 'protomaps-leaflet'
 import * as kMapHooks from '../hooks/index.js'
-import { generatePropertiesSchema } from '../utils.map.js'
-import { generateStyleTemplates, filterQueryToConditions, getDefaultStyleFromTemplates } from './utils.style.js'
+import { generatePropertiesSchema, getGeoJsonFeatures } from '../utils.map.js'
+import { generateStyleTemplates, filterQueryToConditions, getDefaultStyleFromTemplates, DefaultStyle, getStyleType } from './utils.style.js'
 
-export const InternalLayerProperties = ['actions', 'label', 'isVisible', 'isDisabled']
+const InternalLayerProperties = ['actions', 'label', 'isVisible', 'isDisabled']
 
 export function isInMemoryLayer (layer) {
   return layer._id === undefined
@@ -330,6 +330,10 @@ export function isLayerDataEditable (layer) {
   return _.get(layer, 'isDataEditable', isUserLayer(layer) && isFeatureLayer(layer))
 }
 
+export function isLayerFilterEditable (layer) {
+  return _.get(layer, 'isFilterEditable', isUserLayer(layer) && isFeatureLayer(layer))
+}
+
 export function isTerrainLayer (layer) {
   if (layer.type === 'TerrainLayer') return true
   const cesiumOptions = layer.cesium || layer
@@ -349,7 +353,7 @@ async function parseFiltersFromLayer (layer) {
     if (!filter.style) continue
     styles.push({
       conditions: filterQueryToConditions(filter.active),
-      values: await styleService.get(filter.style)
+      values: _.isObject(filter.style) ? filter.style : await styleService.get(filter.style)
     })
   }
   return styles
@@ -368,19 +372,27 @@ async function generateStyleFromFilters (layer, defaultStyle) {
   return result
 }
 
-export async function editLayerStyle (layer, style) {
+export async function editLayerStyle (layer, style, ignoreFeatureStyle = false) {
   style = _.pick(style, ['point', 'line', 'polygon'])
   if (layer._id) {
     // Need to regenerate templates to update default style in them
     const result = await generateStyleFromFilters(layer, style)
     if (result) {
+      // Update legend
+      Object.assign(result, await getLegendForLayer(Object.assign({}, layer, result)))
+      if (ignoreFeatureStyle) result.ignoreFeatureStyle = true
       await api.getService('catalog').patch(layer._id, result)
     } else {
-      await api.getService('catalog').patch(layer._id, { 'cesium.style': style, 'leaflet.style': style })
+      const legend = await getLegendForLayer(Object.assign({}, layer, { 'cesium.style': style, 'leaflet.style': style }))
+      const patch = Object.assign({}, { 'cesium.style': style, 'leaflet.style': style }, legend)
+      if (ignoreFeatureStyle) patch.ignoreFeatureStyle = true
+      await api.getService('catalog').patch(layer._id, patch)
     }
   } else {
     _.set(layer, 'cesium.style', style)
     _.set(layer, 'leaflet.style', style)
+    Object.assign(layer, await getLegendForLayer(layer))
+    if (ignoreFeatureStyle) layer.ignoreFeatureStyle = true
   }
   return layer
 }
@@ -394,6 +406,106 @@ export async function updateLayerWithFiltersStyle (layer) {
   await api.getService('catalog').patch(layer._id, style)
 }
 
+export async function editFilterStyle (layer, filter, engineStyle, style, ignoreFeatureStyle = false) {
+  if (!layer._id) return
+  const layerDefaultStyle = getDefaultStyleFromTemplates(_.get(layer, 'leaflet.style', {}))
+
+  const filters = await parseFiltersFromLayer(layer)
+  const targetFilterCondition = filterQueryToConditions(filter.active)
+  // Update filter style
+  _.forEach(filters, f => {
+    if (_.isEqual(f.conditions, targetFilterCondition)) {
+      f.values = style
+    }
+  })
+
+  // Generate new templates
+  const templates = generateStyleTemplates(_.merge({}, DefaultStyle, engineStyle, layerDefaultStyle), filters)
+  const layerFilters = _.cloneDeep(_.get(layer, 'filters', []))
+  // Update filters in layer
+  _.forEach(layerFilters, f => {
+    if (_.isEqual(f.label, filter.label) && _.isEqual(f.active, filter.active)) {
+      f.style = style._id
+    }
+  })
+
+  // Patch layer with new templates and filters
+  const patch = Object.assign(
+    {},
+    _.mapKeys(templates, (value, key) => `leaflet.${key}`),
+    _.mapKeys(templates, (value, key) => `cesium.${key}`),
+    { filters: layerFilters }
+  )
+  if (ignoreFeatureStyle) patch.ignoreFeatureStyle = true
+  // Update legend
+  Object.assign(patch, await getLegendForLayer(Object.assign({}, layer, { filters: layerFilters })))
+  await api.getService('catalog').patch(layer._id, patch)
+}
+
+async function getLayerFiltersWithStyle (layer) {
+  const filters = _.get(layer, 'filters', [])
+  if (!filters.length) return []
+  const styleService = api.getService('styles')
+  const filtersWithStyle = []
+  for (const filter of filters) {
+    const filterWithStyle = _.cloneDeep(filter)
+    if (filter.style) {
+      filterWithStyle.linkedStyle = _.isObject(filter.style) ? filter.style : await styleService.get(filter.style)
+    }
+    filtersWithStyle.push(filterWithStyle)
+  }
+  return filtersWithStyle
+}
+
+// Return generic legend or filters for a layer without mutating it
+export async function getLegendForLayer (layer) {
+  const generateLegendFromStyle = (root, style, layerGeometryTypes) => {
+    const layerStyleTypes = _.uniq(_.map(layerGeometryTypes, type => getStyleType(type)))
+    const shapes = { point: 'circle', line: 'polyline', polygon: 'rect' }
+    const symbols = []
+    _.forIn(shapes, (shape, type) => {
+      const isInLayerGeometryTypes = (layerStyleTypes.length === 0) || (layerStyleTypes.includes(type))
+      if (style[type] && isInLayerGeometryTypes) {
+        symbols.push({
+          symbol: { 'media/KShape': { options: _.merge({ shape }, _.omit(style[type], ['size'])) } },
+          label: _.get(root, 'label', _.get(root, 'name'))
+        })
+      }
+    })
+    return {
+      type: 'symbols',
+      content: {
+        symbols
+      }
+    }
+  }
+
+  if (_.has(layer, 'filters') && !_.isEmpty(layer.filters)) {
+    const filtersWithStyle = await getLayerFiltersWithStyle(layer)
+    let hasFilterWithStyle = false
+    _.forEach(filtersWithStyle, filter => {
+      if (!_.has(filter, 'linkedStyle')) return
+      hasFilterWithStyle = true
+
+      const filterLegend = generateLegendFromStyle(filter, filter.linkedStyle, _.get(layer, 'geometryTypes', []))
+      filter.legend = filterLegend
+    })
+    const legend = {
+      legend: { type: 'symbols', label: _.get(layer, 'label', _.get(layer, 'name')), content: {} },
+      filters: _.map(filtersWithStyle, filter => _.omit(filter, 'linkedStyle'))
+    }
+    // For now, only filter with style are displayed in the legend
+    // If no filter has style, we want to remove the legend
+    if (!hasFilterWithStyle) return { $unset: { legend: '' } }
+    return legend
+  } else {
+    const layerStyle = getDefaultStyleFromTemplates(_.get(layer, 'leaflet.style', {}))
+    const legend = generateLegendFromStyle(layer, layerStyle, _.get(layer, 'geometryTypes', []))
+    legend.label = _.get(layer, 'label', _.get(layer, 'name'))
+    return { legend }
+  }
+}
+
 export function generateLayerDefinition (layerSpec, geoJson) {
   // Check wether the geoJson content is a valid geoJson
   if (geoJson.type !== 'FeatureCollection' && geoJson.type !== 'Feature') {
@@ -446,18 +558,35 @@ export function generateLayerDefinition (layerSpec, geoJson) {
 
 export async function saveGeoJsonLayer (layer, geoJson, chunkSize = 5000) {
   // Check for invalid features first
-  const check = checkFeatures(geoJson)
-  if (check.kinks.length > 0) {
+  const { errors } = cleanFeatures(geoJson)
+
+  if (errors.length > 0) {
+    const errorsByKeys = {}
+    _.forEach(errors, error => {
+      if (!_.has(errorsByKeys, error.error)) errorsByKeys[error.error] = { count: 0, features: [] }
+      errorsByKeys[error.error].count++
+      if (error.identifier) errorsByKeys[error.error].features.push(error.identifier)
+    })
+    const errorsList = _.map(errors, error => {
+      const hasIdentifiedFeatures = errorsByKeys[error.error].features.length
+      const errorString = [
+        '<li>',
+        i18n.t(error.error, { total: errorsByKeys[error.error].count }),
+        hasIdentifiedFeatures ? i18n.t('utils.layers.INVALID_FEATURES_LIST_FEATURES') : '',
+        '</li>'
+      ].join('')
+      const sublist = _.map(errorsByKeys[error.error].features, featureIdentifier => {
+        return '<li class="q-ml-lg">' + featureIdentifier + '</li>'
+      }).join('')
+      return errorString + sublist
+    }).join('')
+
     const result = await kCoreUtils.dialog({
-      title: i18n.t('utils.layers.INVALID_FEATURES_DIALOG_TITLE', { total: check.kinks.length }),
-      message: i18n.t('utils.layers.INVALID_FEATURES_DIALOG_MESSAGE', { total: check.kinks.length }),
-      options: {
-        type: 'toggle',
-        model: [],
-        items: [
-          { label: i18n.t('utils.layers.DOWNLOAD_INVALID_FEATURES_LABEL'), value: 'download' }
-        ]
-      },
+      title: i18n.t('utils.layers.INVALID_FEATURES_DIALOG_TITLE', { total: errors.length }),
+      message: [
+        i18n.t('utils.layers.INVALID_FEATURES_DIALOG_MESSAGE', { total: errors.length }),
+        i18n.t('utils.layers.INVALID_FEATURES_LIST_ERRORS', { errors: errorsList })
+      ].join(''),
       html: true,
       ok: {
         label: i18n.t('OK'),
@@ -469,17 +598,12 @@ export async function saveGeoJsonLayer (layer, geoJson, chunkSize = 5000) {
       }
     })
     if (!result.ok) return
-    // Export invalid features if required
-    if (_.get(result, 'data', []).includes('download')) {
-      kCoreUtils.downloadAsBlob(JSON.stringify({ type: 'FeatureCollection', features: check.kinks }),
-        i18n.t('utils.layers.INVALID_FEATURES_FILE'), 'application/json;charset=utf-8;')
-    }
   }
   // Change data source from in-memory to features service
   _.set(layer, 'service', 'features')
   if (_.has(layer, 'leaflet')) _.set(layer, 'leaflet.source', '/api/features')
   if (_.has(layer, 'cesium')) _.set(layer, 'cesium.source', '/api/features')
-  const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+  const features = getGeoJsonFeatures(geoJson)
   // If too much data use tiling
   // The threshold is based on the number of points and not features.
   // Indeed otherwise the complexity will be different depending on the geometry type