@regionerne/gis-komponent 0.0.84 → 0.0.85

package/fesm2022/regionerne-gis-komponent.mjs

@@ -61,8 +61,8 @@ import Feature$1 from 'ol/Feature';
 import { never, always } from 'ol/events/condition';
 import { buffer, lineIntersect, lineSplit, featureCollection, difference, booleanIntersects, union, point, booleanPointInPolygon, area, flatten, feature, booleanWithin, intersect, bboxPolygon } from '@turf/turf';
 import GeoJSON$1 from 'ol/format/GeoJSON';
+import { containsXY, extend, createEmpty, buffer as buffer$1 } from 'ol/extent';
 import { Feature } from 'ol';
-import { extend, createEmpty, buffer as buffer$1 } from 'ol/extent';
 import { easeOut } from 'ol/easing';
 import Select from 'ol/interaction/Select';
 import html2canvas from 'html2canvas-pro';
@@ -1591,9 +1591,9 @@ class GeometrySplitService {
         // Move back to 25832 
         bufferedLine.geometry.coordinates = bufferedLine.geometry.coordinates.map(a => a.map(c => proj4('EPSG:4326', 'EPSG:25832', c)));
         const overlappingFeatures = vectorSource.getFeatures().filter(f => !this._featureHelper.isLocked(f) && f.getGeometry()?.intersectsExtent(lineFeature.getGeometry()?.getExtent()));
+        const lineFeatureObject = this.geoJsonFormat.writeFeatureObject(lineFeature, { dataProjection: 'EPSG:4326', featureProjection: 'EPSG:25832' });
         overlappingFeatures.filter(f => f.getGeometry()?.getType() === 'LineString').forEach(feature => {
             const linestringFeatureObject = this.geoJsonFormat.writeFeatureObject(feature, { dataProjection: 'EPSG:4326', featureProjection: 'EPSG:25832' });
-            const lineFeatureObject = this.geoJsonFormat.writeFeatureObject(lineFeature, { dataProjection: 'EPSG:4326', featureProjection: 'EPSG:25832' });
             if (lineIntersect(lineFeatureObject, linestringFeatureObject)) {
                 const lines = lineSplit(linestringFeatureObject, lineFeatureObject);
                 const newFeatures = lines.features.map(lineSplitFeature => {
@@ -1607,8 +1607,19 @@ class GeometrySplitService {
                 vectorSource.removeFeature(feature);
             }
         });
-        // Handle polygons
-        overlappingFeatures.filter(f => f.getGeometry()?.getType() === 'Polygon').forEach((feature) => {
+        // Handle polygons - if the split line starts or ends inside of a polygon, that polygon is NOT split!
+        // That split leaves weird lines in the poly and it's handled by excluding those polys alltogether.
+        const splitLineCoordinates = lineFeature.getGeometry().getCoordinates();
+        const coordLength = splitLineCoordinates.length;
+        const lineFirstPoint = splitLineCoordinates[0];
+        const lineLastPoint = splitLineCoordinates[coordLength - 1];
+        overlappingFeatures.filter(f => f.getGeometry()?.getType() === 'Polygon')
+            .filter(feature => {
+            const containsStartingPoint = this.isPointStrictlyInside(feature.getGeometry(), lineFirstPoint);
+            const containsEndPoint = this.isPointStrictlyInside(feature.getGeometry(), lineLastPoint);
+            return !containsStartingPoint && !containsEndPoint;
+        })
+            .forEach((feature) => {
             const overlappingFeatureGeoJson = this.geoJsonFormat.writeFeatureObject(feature);
             const features = featureCollection([overlappingFeatureGeoJson, bufferedLine]);
             const clipped = difference(features);
@@ -1627,6 +1638,15 @@ class GeometrySplitService {
             }
         });
     }
+    isPointStrictlyInside(geom, coord) {
+        if (!geom.intersectsCoordinate(coord))
+            return false;
+        const extent = geom.getExtent();
+        // Hvis punktet ligger udenfor extents → false
+        if (!containsXY(extent, coord[0], coord[1]))
+            return false;
+        return true; // inde og ikke kun på kanten
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: GeometrySplitService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: GeometrySplitService, providedIn: 'root' });
 }
@@ -2950,6 +2970,7 @@ class ToolboxComponent {
     _originalMapHeight = 0;
     pointClickKey;
     _geometrySearchService = inject(GeometrySearchService);
+    // private _geomClipService = inject(GeometryClipService);
     drawInteraction;
     get showDocumentSearch() {
         return this.settings?.showDocumentSearch !== false;
@@ -3485,31 +3506,45 @@ class ToolboxComponent {
         });
         this._interactionHelper.setAsTemp(clipHoleDraw);
         clipHoleDraw.on('drawend', evt => {
-            const overlappingFeatures = this._drawLayerService.source.getFeatures().filter(f => !this._featureHelper.isLocked(f) && f.getGeometry()?.intersectsExtent(evt.feature.getGeometry().getExtent()));
-            const geoJsonFormat = new GeoJSON$1();
+            const featuresInExtent = this._drawLayerService.source.getFeatures().filter(f => !this._featureHelper.isLocked(f) && f.getGeometry()?.intersectsExtent(evt.feature.getGeometry().getExtent()));
+            const formatterOptions = { dataProjection: 'EPSG:4326', featureProjection: 'EPSG:25832' };
+            const geoJsonFormat = new GeoJSON$1(formatterOptions);
             const holeGeoJson = geoJsonFormat.writeFeatureObject(evt.feature);
-            overlappingFeatures.forEach(f => {
-                const overlappingFeatureGeoJson = geoJsonFormat.writeFeatureObject(f);
-                // because the difference function takes featurecollection, I add the two features to a collection
-                // I have to cast this as any, because the featurecollection needs to be of Polygon or MultiPoly and it
-                // doesnt resolve to that.
-                const features = featureCollection([overlappingFeatureGeoJson, holeGeoJson]);
-                const clipped = difference(features);
-                if (clipped) {
-                    // Ensures that the clipped feature is split into an array of features. Handles possible MultiPolygon
-                    const allPolys = flatten(clipped);
-                    allPolys.features.forEach((poly, idx) => {
-                        const geom = geoJsonFormat.readGeometry(poly.geometry);
-                        if (idx === 0) {
-                            f.setGeometry(geom);
-                        }
-                        else {
-                            const newFeature = f.clone();
-                            newFeature.setGeometry(geom);
-                            this._featureHelper.setId(newFeature);
-                            this._drawLayerService.source.addFeature(newFeature);
-                        }
-                    });
+            // Turf is not always able to handle difference if two polygons are completely on top of each other at the edge
+            // That can happen when Snap is active. To handle that, I do a tiny huffer around the hole
+            const bufferedHole = buffer(holeGeoJson, 0.01, { units: 'meters' });
+            const wktFormat = new WKT();
+            // This is a lot of code to handle that Turf is not very precise for larger areas, so I have to handle that. Because the clip will sometimes leave a small snippet
+            // that needs to be removed. Tha mostly happens on large areas and with snap enabled for the draw interaction.
+            const overlappingItems$ = featuresInExtent
+                .map(featureInExtent => ({ feature: featureInExtent, overlappingFeatureGeoJson: geoJsonFormat.writeFeatureObject(featureInExtent) })) // Here, I just build the items I need later
+                .map(item => ({ ...item, threshold: area(item.overlappingFeatureGeoJson) / 10000, clipped: difference(featureCollection([item.overlappingFeatureGeoJson, bufferedHole])) }))
+                .filter(item => !!item.clipped) // Filter out the items that aren't clipped. They are in the same extent, but don't actually overlap, so I leave those out
+                .map(item => ({ ...item, allPolys: flatten(item.clipped) })) // The clipped item can be an array of item, so I make sure to flatten it.
+                .map(item => ({ ...item, allPolysAsWkt: item.allPolys.features.map(poly => wktFormat.writeGeometry(geoJsonFormat.readGeometry(poly.geometry))) }))
+                .map(item => item.allPolysAsWkt.map(wkt => this._geometryService.validate(wkt).pipe(map(result => // Now, I need to validate all the clipped items
+             result.correctedGeometries ? { ...item, validWKTS: result.correctedGeometries } : { ...item, validWKTS: [wkt] } // If there were corrections, I return the corrected items. If not, just the original
+            ))))
+                .flatMap(r => r);
+            combineLatest(overlappingItems$).subscribe({
+                next: validatedItems => {
+                    const featuresToAdd = validatedItems
+                        .map(item => item.validWKTS
+                        .filter(wkt => {
+                        const feature = wktFormat.readFeature(wkt);
+                        return area(geoJsonFormat.writeFeatureObject(feature)) > item.threshold; // Map all the returned, validated wkts back to features and calc the area of them and remove the very small ones
+                    }).map(wkt => {
+                        const newFeature = item.feature.clone();
+                        this._featureHelper.setId(newFeature);
+                        const g = wktFormat.readGeometry(wkt);
+                        newFeature.setGeometry(g);
+                        return newFeature;
+                    })).flatMap(f => f);
+                    const featuresToRemove = validatedItems.map(item => item.feature);
+                    this._drawLayerService.source.removeFeatures(featuresToRemove);
+                    this._undoRedo.disable();
+                    this._drawLayerService.source.addFeatures(featuresToAdd);
+                    this._undoRedo.enable();
                 }
             });
         });