MapComplete/Logic/Osm/Actions/CreateWayWithPointReuseAction.ts

import { OsmCreateAction } from "./OsmChangeAction"
import { Tag } from "../../Tags/Tag"
import { Changes } from "../Changes"
import { ChangeDescription } from "./ChangeDescription"
import FeaturePipelineState from "../../State/FeaturePipelineState"
import { BBox } from "../../BBox"
import { TagsFilter } from "../../Tags/TagsFilter"
import { GeoOperations } from "../../GeoOperations"
import FeatureSource from "../../FeatureSource/FeatureSource"
import StaticFeatureSource from "../../FeatureSource/Sources/StaticFeatureSource"
import CreateNewNodeAction from "./CreateNewNodeAction"
import CreateNewWayAction from "./CreateNewWayAction"

export interface MergePointConfig {
    withinRangeOfM: number
    ifMatches: TagsFilter
    mode: "reuse_osm_point" | "move_osm_point"
}

/**
 * CreateWayWithPointreuse will create a 'CoordinateInfo' for _every_ point in the way to be created.
 *
 * The CoordinateInfo indicates the action to take, e.g.:
 *
 * - Create a new point
 * - Reuse an existing OSM point (and don't move it)
 * - Reuse an existing OSM point (and leave it where it is)
 * - Reuse another Coordinate info (and don't do anything else with it)
 *
 */
interface CoordinateInfo {
    /**
     * The new coordinate
     */
    lngLat: [number, number]
    /**
     * If set: indicates that this point is identical to an earlier point in the way and that that point should be used.
     * This is especially needed in closed ways, where the last CoordinateInfo will have '0' as identicalTo
     */
    identicalTo?: number
    /**
     * Information about the closebyNode which might be reused
     */
    closebyNodes?: {
        /**
         * Distance in meters between the target coordinate and this candidate coordinate
         */
        d: number
        node: any
        config: MergePointConfig
    }[]
}

/**
 * More or less the same as 'CreateNewWay', except that it'll try to reuse already existing points
 */
export default class CreateWayWithPointReuseAction extends OsmCreateAction {
    public newElementId: string = undefined
    public newElementIdNumber: number = undefined
    private readonly _tags: Tag[]
    /**
     * lngLat-coordinates
     * @private
     */
    private _coordinateInfo: CoordinateInfo[]
    private _state: FeaturePipelineState
    private _config: MergePointConfig[]

    constructor(
        tags: Tag[],
        coordinates: [number, number][],
        state: FeaturePipelineState,
        config: MergePointConfig[]
    ) {
        super(null, true)
        this._tags = tags
        this._state = state
        this._config = config

        // The main logic of this class: the coordinateInfo contains all the changes
        this._coordinateInfo = this.CalculateClosebyNodes(coordinates)
    }

    public async getPreview(): Promise<FeatureSource> {
        const features = []
        let geometryMoved = false
        for (let i = 0; i < this._coordinateInfo.length; i++) {
            const coordinateInfo = this._coordinateInfo[i]
            if (coordinateInfo.identicalTo !== undefined) {
                continue
            }
            if (
                coordinateInfo.closebyNodes === undefined ||
                coordinateInfo.closebyNodes.length === 0
            ) {
                const newPoint = {
                    type: "Feature",
                    properties: {
                        newpoint: "yes",
                        id: "new-geometry-with-reuse-" + i,
                    },
                    geometry: {
                        type: "Point",
                        coordinates: coordinateInfo.lngLat,
                    },
                }
                features.push(newPoint)
                continue
            }

            const reusedPoint = coordinateInfo.closebyNodes[0]
            if (reusedPoint.config.mode === "move_osm_point") {
                const moveDescription = {
                    type: "Feature",
                    properties: {
                        move: "yes",
                        "osm-id": reusedPoint.node.properties.id,
                        id: "new-geometry-move-existing" + i,
                        distance: GeoOperations.distanceBetween(
                            coordinateInfo.lngLat,
                            reusedPoint.node.geometry.coordinates
                        ),
                    },
                    geometry: {
                        type: "LineString",
                        coordinates: [reusedPoint.node.geometry.coordinates, coordinateInfo.lngLat],
                    },
                }
                features.push(moveDescription)
            } else {
                // The geometry is moved, the point is reused
                geometryMoved = true

                const reuseDescription = {
                    type: "Feature",
                    properties: {
                        move: "no",
                        "osm-id": reusedPoint.node.properties.id,
                        id: "new-geometry-reuse-existing" + i,
                        distance: GeoOperations.distanceBetween(
                            coordinateInfo.lngLat,
                            reusedPoint.node.geometry.coordinates
                        ),
                    },
                    geometry: {
                        type: "LineString",
                        coordinates: [coordinateInfo.lngLat, reusedPoint.node.geometry.coordinates],
                    },
                }
                features.push(reuseDescription)
            }
        }

        if (geometryMoved) {
            const coords: [number, number][] = []
            for (const info of this._coordinateInfo) {
                if (info.identicalTo !== undefined) {
                    coords.push(coords[info.identicalTo])
                    continue
                }

                if (info.closebyNodes === undefined || info.closebyNodes.length === 0) {
                    coords.push(coords[info.identicalTo])
                    continue
                }

                const closest = info.closebyNodes[0]
                if (closest.config.mode === "reuse_osm_point") {
                    coords.push(closest.node.geometry.coordinates)
                } else {
                    coords.push(info.lngLat)
                }
            }
            const newGeometry = {
                type: "Feature",
                properties: {
                    "resulting-geometry": "yes",
                    id: "new-geometry",
                },
                geometry: {
                    type: "LineString",
                    coordinates: coords,
                },
            }
            features.push(newGeometry)
        }
        return StaticFeatureSource.fromGeojson(features)
    }

    public async CreateChangeDescriptions(changes: Changes): Promise<ChangeDescription[]> {
        const theme = this._state?.layoutToUse?.id
        const allChanges: ChangeDescription[] = []
        const nodeIdsToUse: { lat: number; lon: number; nodeId?: number }[] = []
        for (let i = 0; i < this._coordinateInfo.length; i++) {
            const info = this._coordinateInfo[i]
            const lat = info.lngLat[1]
            const lon = info.lngLat[0]

            if (info.identicalTo !== undefined) {
                nodeIdsToUse.push(nodeIdsToUse[info.identicalTo])
                continue
            }
            if (info.closebyNodes === undefined || info.closebyNodes[0] === undefined) {
                const newNodeAction = new CreateNewNodeAction([], lat, lon, {
                    allowReuseOfPreviouslyCreatedPoints: true,
                    changeType: null,
                    theme,
                })

                allChanges.push(...(await newNodeAction.CreateChangeDescriptions(changes)))

                nodeIdsToUse.push({
                    lat,
                    lon,
                    nodeId: newNodeAction.newElementIdNumber,
                })
                continue
            }

            const closestPoint = info.closebyNodes[0]
            const id = Number(closestPoint.node.properties.id.split("/")[1])
            if (closestPoint.config.mode === "move_osm_point") {
                allChanges.push({
                    type: "node",
                    id,
                    changes: {
                        lat,
                        lon,
                    },
                    meta: {
                        theme,
                        changeType: null,
                    },
                })
            }
            nodeIdsToUse.push({ lat, lon, nodeId: id })
        }

        const newWay = new CreateNewWayAction(this._tags, nodeIdsToUse, {
            theme,
        })

        allChanges.push(...(await newWay.CreateChangeDescriptions(changes)))
        this.newElementId = newWay.newElementId
        this.newElementIdNumber = newWay.newElementIdNumber
        return allChanges
    }

    /**
     * Calculates the main changes.
     */
    private CalculateClosebyNodes(coordinates: [number, number][]): CoordinateInfo[] {
        const bbox = new BBox(coordinates)
        const state = this._state
        const allNodes = [].concat(
            ...(state?.featurePipeline?.GetFeaturesWithin("type_node", bbox.pad(1.2)) ?? [])
        )
        const maxDistance = Math.max(...this._config.map((c) => c.withinRangeOfM))

        // Init coordianteinfo with undefined but the same length as coordinates
        const coordinateInfo: {
            lngLat: [number, number]
            identicalTo?: number
            closebyNodes?: {
                d: number
                node: any
                config: MergePointConfig
            }[]
        }[] = coordinates.map((_) => undefined)

        // First loop: gather all information...
        for (let i = 0; i < coordinates.length; i++) {
            if (coordinateInfo[i] !== undefined) {
                // Already seen, probably a duplicate coordinate
                continue
            }
            const coor = coordinates[i]
            // Check closeby (and probably identical) points further in the coordinate list, mark them as duplicate
            for (let j = i + 1; j < coordinates.length; j++) {
                // We look into the 'future' of the way and mark those 'future' locations as being the same as this location
                // The continue just above will make sure they get ignored
                // This code is important to 'close' ways
                if (GeoOperations.distanceBetween(coor, coordinates[j]) < 0.1) {
                    coordinateInfo[j] = {
                        lngLat: coor,
                        identicalTo: i,
                    }
                    break
                }
            }

            // Gather the actual info for this point

            // Lets search applicable points and determine the merge mode
            const closebyNodes: {
                d: number
                node: any
                config: MergePointConfig
            }[] = []
            for (const node of allNodes) {
                const center = node.geometry.coordinates
                const d = GeoOperations.distanceBetween(coor, center)
                if (d > maxDistance) {
                    continue
                }

                for (const config of this._config) {
                    if (d > config.withinRangeOfM) {
                        continue
                    }
                    if (!config.ifMatches.matchesProperties(node.properties)) {
                        continue
                    }
                    closebyNodes.push({ node, d, config })
                }
            }

            // Sort by distance, closest first
            closebyNodes.sort((n0, n1) => {
                return n0.d - n1.d
            })

            coordinateInfo[i] = {
                identicalTo: undefined,
                lngLat: coor,
                closebyNodes,
            }
        }

        // Second loop: figure out which point moves where without creating conflicts
        let conflictFree = true
        do {
            conflictFree = true
            for (let i = 0; i < coordinateInfo.length; i++) {
                const coorInfo = coordinateInfo[i]
                if (coorInfo.identicalTo !== undefined) {
                    continue
                }
                if (coorInfo.closebyNodes === undefined || coorInfo.closebyNodes[0] === undefined) {
                    continue
                }

                for (let j = i + 1; j < coordinates.length; j++) {
                    const other = coordinateInfo[j]
                    if (other.closebyNodes === undefined || other.closebyNodes[0] === undefined) {
                        continue
                    }

                    if (coorInfo.closebyNodes[0] === undefined) {
                        continue
                    }

                    if (other.closebyNodes[0].node === coorInfo.closebyNodes[0].node) {
                        conflictFree = false
                        // We have found a conflict!
                        // We only keep the closest point
                        if (other.closebyNodes[0].d > coorInfo.closebyNodes[0].d) {
                            other.closebyNodes.shift()
                        } else {
                            coorInfo.closebyNodes.shift()
                        }
                    }
                }
            }
        } while (!conflictFree)

        return coordinateInfo
    }
}