diff --git a/Logic/FeatureSource/Sources/RenderingMultiPlexerFeatureSource.ts b/Logic/FeatureSource/Sources/RenderingMultiPlexerFeatureSource.ts
index 1f5d8cbb41..86eebeaf31 100644
--- a/Logic/FeatureSource/Sources/RenderingMultiPlexerFeatureSource.ts
+++ b/Logic/FeatureSource/Sources/RenderingMultiPlexerFeatureSource.ts
@@ -6,23 +6,90 @@ import {GeoOperations} from "../../GeoOperations";
 import FeatureSource from "../FeatureSource";
 import PointRenderingConfig from "../../../Models/ThemeConfig/PointRenderingConfig";
 import LayerConfig from "../../../Models/ThemeConfig/LayerConfig";
+import LineRenderingConfig from "../../../Models/ThemeConfig/LineRenderingConfig";
+import {within} from "@turf/turf";
 
 export default class RenderingMultiPlexerFeatureSource {
     public readonly features: UIEventSource<(any & { pointRenderingIndex: number | undefined, lineRenderingIndex: number | undefined })[]>;
+    private readonly pointRenderings: { rendering: PointRenderingConfig; index: number }[];
+    private centroidRenderings: { rendering: PointRenderingConfig; index: number }[];
+    private projectedCentroidRenderings: { rendering: PointRenderingConfig; index: number }[];
+    private startRenderings: { rendering: PointRenderingConfig; index: number }[];
+    private endRenderings: { rendering: PointRenderingConfig; index: number }[];
+    private hasCentroid: boolean;
+    private lineRenderObjects: LineRenderingConfig[];
 
+    
+    private inspectFeature(feat, addAsPoint: (feat, rendering, centerpoint: [number, number]) => void, withIndex: any[]){
+        if (feat.geometry.type === "Point") {
+
+            for (const rendering of this.pointRenderings) {
+                withIndex.push({
+                    ...feat,
+                    pointRenderingIndex: rendering.index
+                })
+            }
+        } else {
+            // This is a a line: add the centroids
+            let centerpoint: [number, number] = undefined;
+            let projectedCenterPoint : [number, number] = undefined
+            if(this.hasCentroid){
+                centerpoint  = GeoOperations.centerpointCoordinates(feat)
+                if(this.projectedCentroidRenderings.length > 0){
+                    projectedCenterPoint = <[number,number]> GeoOperations.nearestPoint(feat, centerpoint).geometry.coordinates
+                }
+            }
+            for (const rendering of this.centroidRenderings) {
+                addAsPoint(feat, rendering, centerpoint)
+            }
+
+
+            if (feat.geometry.type === "LineString") {
+
+                for (const rendering of this.projectedCentroidRenderings) {
+                    addAsPoint(feat, rendering, projectedCenterPoint)
+                }
+
+                // Add start- and endpoints
+                const coordinates = feat.geometry.coordinates
+                for (const rendering of this.startRenderings) {
+                    addAsPoint(feat, rendering, coordinates[0])
+                }
+                for (const rendering of this.endRenderings) {
+                    const coordinate = coordinates[coordinates.length - 1]
+                    addAsPoint(feat, rendering, coordinate)
+                }
+
+            }else{
+                for (const rendering of this.projectedCentroidRenderings) {
+                    addAsPoint(feat, rendering, centerpoint)
+                }
+            }
+
+            // AT last, add it 'as is' to what we should render 
+            for (let i = 0; i < this.lineRenderObjects.length; i++) {
+                withIndex.push({
+                    ...feat,
+                    lineRenderingIndex: i
+                })
+            }
+
+        }
+    }
+    
     constructor(upstream: FeatureSource, layer: LayerConfig) {
         
         const pointRenderObjects: { rendering: PointRenderingConfig, index: number }[] = layer.mapRendering.map((r, i) => ({
             rendering: r,
             index: i
         }))
-        const pointRenderings = pointRenderObjects.filter(r => r.rendering.location.has("point"))
-        const centroidRenderings = pointRenderObjects.filter(r => r.rendering.location.has("centroid"))
-        const projectedCentroidRenderings = pointRenderObjects.filter(r => r.rendering.location.has("projected_centerpoint"))
-        const startRenderings = pointRenderObjects.filter(r => r.rendering.location.has("start"))
-        const endRenderings = pointRenderObjects.filter(r => r.rendering.location.has("end"))
-        const hasCentroid = centroidRenderings.length > 0 || projectedCentroidRenderings.length > 0
-        const lineRenderObjects = layer.lineRendering
+        this.pointRenderings = pointRenderObjects.filter(r => r.rendering.location.has("point"))
+        this.centroidRenderings = pointRenderObjects.filter(r => r.rendering.location.has("centroid"))
+        this.projectedCentroidRenderings = pointRenderObjects.filter(r => r.rendering.location.has("projected_centerpoint"))
+        this.startRenderings = pointRenderObjects.filter(r => r.rendering.location.has("start"))
+        this.endRenderings = pointRenderObjects.filter(r => r.rendering.location.has("end"))
+        this.hasCentroid = this.centroidRenderings.length > 0 || this.projectedCentroidRenderings.length > 0
+        this.lineRenderObjects = layer.lineRendering
         
         this.features = upstream.features.map(
             features => {
@@ -31,8 +98,7 @@ export default class RenderingMultiPlexerFeatureSource {
                 }
 
 
-                const withIndex: (any & { pointRenderingIndex: number | undefined, lineRenderingIndex: number | undefined, multiLineStringIndex: number | undefined })[] = [];
-
+                const withIndex: any[] = [];
 
                 function addAsPoint(feat, rendering, coordinate) {
                     const patched = {
@@ -45,63 +111,10 @@ export default class RenderingMultiPlexerFeatureSource {
                     }
                     withIndex.push(patched)
                 }
+         
 
                 for (const f of features) {
-                    const feat = f.feature;
-                    if (feat.geometry.type === "Point") {
-
-                        for (const rendering of pointRenderings) {
-                            withIndex.push({
-                                ...feat,
-                                pointRenderingIndex: rendering.index
-                            })
-                        }
-                    } else {
-                        // This is a a line: add the centroids
-                        let centerpoint: [number, number] = undefined;
-                        let projectedCenterPoint : [number, number] = undefined
-                        if(hasCentroid){
-                            centerpoint  = GeoOperations.centerpointCoordinates(feat)
-                            if(projectedCentroidRenderings.length > 0){
-                                projectedCenterPoint = <[number,number]> GeoOperations.nearestPoint(feat, centerpoint).geometry.coordinates
-                            }
-                        }
-                        for (const rendering of centroidRenderings) {
-                            addAsPoint(feat, rendering, centerpoint)
-                        }
-                        
-
-                        if (feat.geometry.type === "LineString") {
-
-                            for (const rendering of projectedCentroidRenderings) {
-                                addAsPoint(feat, rendering, projectedCenterPoint)
-                            }
-                            
-                            // Add start- and endpoints
-                            const coordinates = feat.geometry.coordinates
-                            for (const rendering of startRenderings) {
-                                addAsPoint(feat, rendering, coordinates[0])
-                            }
-                            for (const rendering of endRenderings) {
-                                const coordinate = coordinates[coordinates.length - 1]
-                                addAsPoint(feat, rendering, coordinate)
-                            }
-
-                        }else{
-                            for (const rendering of projectedCentroidRenderings) {
-                                addAsPoint(feat, rendering, centerpoint)
-                            }
-                        }
-
-                        // AT last, add it 'as is' to what we should render 
-                        for (let i = 0; i < lineRenderObjects.length; i++) {
-                            withIndex.push({
-                                ...feat,
-                                lineRenderingIndex: i
-                            })
-                        }
-
-                    }
+                   this.inspectFeature(f.feature, addAsPoint, withIndex)
                 }