@enervance/insight-cim-model 0.0.61 → 0.0.63

package/dist/converter/integral7/model/dl-utils/util-functions.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DLUtilFunctions = void 0;
+/**
+ * Hilfsklasse zum Abspeichern der Dl-Profil-relevanten Attribute
+ * um bspw. die Positionen der Schaltfelder leicher ermitteln zu können
+ */
 const constants_1 = require("./constants");
 const utils_1 = require("../../../../util/utils");
 const utils_schema_1 = require("../../utils-schema");
@@ -9,7 +13,84 @@ const DiagramObject_1 = require("../../../../model/diagram/DiagramObject");
 const QueryObjectSsabNsg_1 = require("./QueryObjectSsabNsg");
 const DiagramObjectPoint_1 = require("../../../../model/diagram/DiagramObjectPoint");
 class DLUtilFunctions {
+    static EPSILON = 0.0000001;
+    static getCenterOfPoints(diagramObjectPoints) {
+        const centerCoordinates = [0, 0];
+        for (const diagramObjectPoint of diagramObjectPoints) {
+            centerCoordinates[0] += diagramObjectPoint.xPosition;
+            centerCoordinates[1] += diagramObjectPoint.yPosition;
+        }
+        centerCoordinates[0] /= diagramObjectPoints.length;
+        centerCoordinates[1] /= diagramObjectPoints.length;
+        return centerCoordinates;
+    }
+    static distanceVector2Line(lStart, lEnd, v) {
+        const lineVector = [lEnd[0] - lStart[0], lEnd[1] - lStart[1]];
+        const a = [lEnd[0] - lStart[0], lEnd[1] - lStart[1]];
+        const b = [lStart[0] - v[0], lStart[1] - v[1]];
+        const crossProduct = a[0] * b[1] - b[0] * a[1];
+        const busbarSectionVectorLength = Math.sqrt(Math.pow(lineVector[0], 2) + Math.pow(lineVector[1], 2));
+        const dist = crossProduct / busbarSectionVectorLength;
+        return dist ?? 0;
+    }
+    static lengthOfVector(v) {
+        return Math.sqrt(Math.pow(v[0], 2) + Math.pow(v[1], 2));
+    }
+    static dot(v1, v2) {
+        return v1[0] * v2[0] + v1[1] * v2[1];
+    }
+    static mutliplyScalar(v, scalar) {
+        const resV = [];
+        for (let a = 0; a < v.length; ++a) {
+            resV.push(v[a] * scalar);
+        }
+        return resV;
+    }
+    static divideScalar(v, scalar) {
+        const resV = [];
+        for (let a = 0; a < v.length; ++a) {
+            resV.push(v[a] / scalar);
+        }
+        return resV;
+    }
+    static add(v1, v2) {
+        return [v1[0] + v2[0], v1[1] + v2[1]];
+    }
+    static subtract(v1, v2) {
+        return [v1[0] - v2[0], v1[1] - v2[1]];
+    }
+    static vec2(lStart, lEnd, v) {
+        const unitVec = [lEnd[0] - lStart[0], lEnd[1] - lStart[1]];
+        const unitVecLength = Math.sqrt(Math.pow(unitVec[0], 2) + Math.pow(unitVec[1], 2));
+        unitVec[0] = unitVec[0] / unitVecLength;
+        unitVec[1] = unitVec[1] / unitVecLength;
+        const d = DLUtilFunctions.subtract(v, lStart);
+        const temp = DLUtilFunctions.dot(d, unitVec);
+        const temp2 = DLUtilFunctions.mutliplyScalar(unitVec, temp);
+        const temp3 = DLUtilFunctions.add(lStart, temp2);
+        return temp3;
+    }
+    static isNegativeOrZero(v) {
+        const epsilon = 0.0000001;
+        return v < 0 || (v > -epsilon && v < epsilon);
+    }
+    static vec(lStart, lEnd, v) {
+        const unitVec = [lEnd[0] - lStart[0], lEnd[1] - lStart[1]];
+        const unitVecLength = Math.sqrt(Math.pow(unitVec[0], 2) + Math.pow(unitVec[1], 2));
+        unitVec[0] = unitVec[0] / unitVecLength;
+        unitVec[1] = unitVec[1] / unitVecLength;
+        const t = DLUtilFunctions.dot(v, unitVec) - DLUtilFunctions.dot(lStart, unitVec);
+        const tempV = DLUtilFunctions.add(lStart, DLUtilFunctions.subtract(DLUtilFunctions.mutliplyScalar(unitVec, t), v));
+        const tempVLength = Math.sqrt(Math.pow(tempV[0], 2) + Math.pow(tempV[1], 2));
+        const resultVec = DLUtilFunctions.divideScalar(tempV, tempVLength);
+        return tempV;
+    }
+    /**
+     * Rotiere einen DiagramObjectPoint um den gegebenen Winkel (clockwise Rotation)
+     * Der Winkel wird dabei in Grad angegeben und es wird am Ende auf eine bestimmte Anzahl an Nachkommastellen gerundet
+     */
     static rotateDiagramObjectPoint(point, angle) {
+        // negate the angle to rotate clockwise
         const radiansAngle = -angle * (Math.PI / 180);
         const coords = [point.xPosition, point.yPosition];
         const rotMat = [
@@ -22,7 +103,7 @@ class DLUtilFunctions {
                 resultCoords[a] += rotMat[a][b] * coords[b];
             }
         }
-        const amountOfDecimals = 100;
+        const amountOfDecimals = 100; // Die Anzahl der Nullen entspricht der Anzahl an Nachkommastellen
         point.xPosition = Math.round(resultCoords[0] * amountOfDecimals) / amountOfDecimals;
         point.yPosition = Math.round(resultCoords[1] * amountOfDecimals) / amountOfDecimals;
     }
@@ -36,6 +117,12 @@ class DLUtilFunctions {
         });
         this.addi7ObjectToCIMModel(uuidPointsMap, cimModel, integral7, variantenNr);
     }
+    /**
+     * Basierend auf der Ausrichtung der Schaltanlage wird die Rotation in Grad berechnet.
+     * Ausrichtung => Grad: 0 => 90°, 1 => 180°, 2, => 270°, 3 => 0°
+     *
+     * @param orientationNsgSa Ausrichtung der Schaltanlage (Mögl. Werte: 0, 1, 2, 3)
+     */
     static getRotationBasedOnNsgSa(orientationNsgSa) {
         return (orientationNsgSa * 90 + 90) % 360;
     }
@@ -43,13 +130,36 @@ class DLUtilFunctions {
         return (orientationTrafo2w * 90 + 90) % 360;
     }
     static getRotationBasedOnQuerzweig(orientationQuerzweig) {
-        return (orientationQuerzweig * 90 + 270) % 360;
+        return (orientationQuerzweig * 90 + 90) % 360;
     }
     static getRotationBasedOnNsgSaNsgSf(orientationNsgSa, orientationNsgSf) {
         const nsgSaDegrees = DLUtilFunctions.getRotationBasedOnNsgSa(orientationNsgSa);
         const nsgSfDegrees = orientationNsgSf === 0 ? -90 : 90;
+        // Um negative Rotationswerte zu vermeiden wird 360 dazu addiert
         return (360 + nsgSaDegrees + nsgSfDegrees) % 360;
     }
+    // static translate(vector: number[], ...diagramObjectPoints: DiagramObjectPoint[]) {
+    //   for(const diagramObjectPoint of diagramObjectPoints ) {
+    //   }
+    // }
+    // static rotate(angleInDegrees: number, ...diagramObjectPoints: DiagramObjectPoint[]) {
+    //   for(const diagramObjectPoint of diagramObjectPoints ) {
+    //   }
+    // }
+    static rotateAndShiftBasedOnNsgSAA(nsgSo, nsgSa, nsgSaab, diagramObjects, useLeftOffset = false) {
+        let saabShiftOffset = 0;
+        for (const tempNsgSaab of nsgSa.nsgSaabs) {
+            saabShiftOffset = saabShiftOffset < (tempNsgSaab.nslots + tempNsgSaab.laenge) ? (tempNsgSaab.nslots + tempNsgSaab.laenge) : saabShiftOffset;
+        }
+        for (const diagramObject of diagramObjects) {
+            for (const diagramObjectPoint of diagramObject.diagramObjectPoints) {
+                diagramObjectPoint.xPosition += useLeftOffset ? nsgSaab.nslots * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0;
+                DLUtilFunctions.rotateDiagramObjectPoint(diagramObjectPoint, -90 * nsgSa.ausrichtung);
+                diagramObjectPoint.xPosition += nsgSo.xrel + nsgSa.xrel + (nsgSa.ausrichtung === 2 ? saabShiftOffset * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0);
+                diagramObjectPoint.yPosition += nsgSo.yrel + nsgSa.yrel + (nsgSa.ausrichtung === 3 ? saabShiftOffset * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0);
+            }
+        }
+    }
     static rotateShiftAddBasedOnNsgSAA(cimModel, integral7, variantenNr, nsgSaaID, uuidPointsMap, useLeftOffset = false) {
         const nsgSaa = integral7.integralNSGSAAbschnitt.get(nsgSaaID);
         const nsgSa = integral7.integralNSGSchaltanlage.get(nsgSaa.nsgsaid);
@@ -65,14 +175,27 @@ class DLUtilFunctions {
                 entryDiagramObjectPoint.xPosition += nsgSo.xrel + nsgSa.xrel + (nsgSa.ausrichtung === 2 ? saaShiftOffset * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0);
                 entryDiagramObjectPoint.yPosition += nsgSo.yrel + nsgSa.yrel + (nsgSa.ausrichtung === 3 ? saaShiftOffset * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0);
             });
+            // entryDiagramObject.rotation = entryDiagramObject.rotation ? (entryDiagramObject.rotation + (90 * nsgSa.ausrichtung) + normalRotateFactor) % 360 : undefined;
         });
         this.addi7ObjectToCIMModel(uuidPointsMap, cimModel, integral7, variantenNr);
     }
+    static cloneDiagramObject(other) {
+        const newDiagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)());
+        newDiagramObject.rotation = other.rotation ?? 0;
+        for (let i = 0; i < other.diagramObjectPoints.length; i++) {
+            const p = other.diagramObjectPoints[i];
+            const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint(p.xPosition, p.yPosition, (i + 1));
+            diagramObjectPoint.mrid = (0, utils_1.generateUUID)();
+            diagramObjectPoint.diagramObject = newDiagramObject;
+            newDiagramObject.addDiagramObjectPoint(diagramObjectPoint);
+        }
+        return newDiagramObject;
+    }
     static addi7ObjectToCIMModel(uuidPointsMap, cimModel, integral7, variantenNr) {
         for (const nodePointEntry of uuidPointsMap.entries()) {
             const cimObject = cimModel.getObject(nodePointEntry[0]);
             const diagram = cimModel.getDiagram(integral7.i7SchemaID2UUID.get(variantenNr));
-            const diagramObject = new DiagramObject_1.DiagramObject(utils_1.getUUID(undefined));
+            const diagramObject = new DiagramObject_1.DiagramObject((0, utils_1.getUUID)(undefined));
             diagramObject.name = `DiagramObject`;
             if (cimObject !== undefined) {
                 diagramObject.setIdentifiedObject(cimObject);
@@ -82,25 +205,30 @@ class DLUtilFunctions {
             }
             diagramObject.setDiagram(diagram);
             diagram.addDiagramObject(diagramObject);
-            utils_schema_1.copyDiagramObject(diagramObject, nodePointEntry[1]);
+            (0, utils_schema_1.copyDiagramObject)(diagramObject, nodePointEntry[1]);
             integral7.placedCIMObjectsForDLProfil.set(nodePointEntry[0], diagramObject);
         }
     }
-    static placeKupplung(i7KnotenBeziehungen, uuidPointsMap, cimModel, relevantSSabIDs, integralNSGSsab, integralID2UUID, placedCIMObjectsForDLProfil, kpFeldDeltaausrichtung, kpFeldLeftOffset, isLKupplung) {
+    static placeKupplung(i7KnotenBeziehungen, relevantSSabIDs, nsgSSABs, integralID2UUID, placedCIMObjectUUIDs, kpFeldDeltaausrichtung, kpFeldLeftOffset, isLKupplung, objects) {
         const nodePointMap = new Map();
-        const maxSSabPos = Math.max(...[...integralNSGSsab.values()].map(ssab => ssab.posSSAB));
+        const maxSSabPos = Math.max(...[...nsgSSABs.values()].map(ssab => ssab.posSSAB));
         const containsLeistungsschalter = i7KnotenBeziehungen.find(entry => entry.knotenTyp === integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEISTUNGSSCHALTER]) !== undefined;
+        // Platziere zusammenhängende Elemente auf einer Linie
         const initialNodes = i7KnotenBeziehungen.filter(elem => relevantSSabIDs.has(elem.aknoten));
+        // Eine Kupplung belegt im Standardfall in integral7 drei Felder
         const defaultWidthOfKupplung = 2 * constants_1.NsgConstants.HORIZONTAL_OFFSET;
         for (const initialNode of initialNodes) {
-            if (nodePointMap.get(initialNode.id) || placedCIMObjectsForDLProfil.has(integralID2UUID.get(initialNode.id))) {
+            // some weird behavior
+            if (nodePointMap.get(initialNode.id) || placedCIMObjectUUIDs.has(integralID2UUID.get(initialNode.id))) {
                 continue;
             }
             let tempNodePoints = new Map();
+            // Mapped die Node-ID auf die SSAB, wenn das Node mit einer SSAB verbunden ist
             let tempNodeSSABConnectedMap = new Map();
             let connectionLength = 0;
             let lastNode = null;
             let crtNode = initialNode;
+            // Zähle die Anzahl an Nodes, die innberhalb der Kupplung liegen
             while (crtNode) {
                 connectionLength += 1;
                 lastNode = crtNode;
@@ -109,8 +237,12 @@ class DLUtilFunctions {
             let isUniversal = false;
             let lastNodeLeistungsschalter = false;
             if (relevantSSabIDs.has(lastNode.eknoten)) {
+                // Beziehung geht von Sammelschiene zu Sammelschiene
             }
             else {
+                // Schaue, ob ggfs. eine Universale Kupplung vorliegt
+                // => Endknoten liegt in einem anderen Knoten als Endknoten vor
+                // ==> Daher Erhöhe die Länge um 1
                 if (i7KnotenBeziehungen.find(elem => elem.eknoten === lastNode.eknoten && elem !== lastNode)) {
                     isUniversal = true;
                     lastNodeLeistungsschalter = (lastNode.knotenTyp === integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEISTUNGSSCHALTER]);
@@ -119,48 +251,55 @@ class DLUtilFunctions {
                     }
                 }
             }
+            //const defaultLength = 3 * NsgConstants.HORIZONTAL_OFFSET;
             let yVecLength = undefined;
             let ssabAnfYPos = undefined;
             if (isLKupplung && !isUniversal) {
-                ssabAnfYPos = QueryObjectSsabNsg_1.QueryObjectSsabNsg.getBottomRightPoint(integralNSGSsab.get(initialNode.aknoten)).y;
-                const ssabEndYPos = QueryObjectSsabNsg_1.QueryObjectSsabNsg.getTopLeftPoint(integralNSGSsab.get(lastNode.eknoten)).y;
+                ssabAnfYPos = QueryObjectSsabNsg_1.QueryObjectSsabNsg.getBottomRightPoint(nsgSSABs.get(initialNode.aknoten)).y;
+                const ssabEndYPos = QueryObjectSsabNsg_1.QueryObjectSsabNsg.getTopLeftPoint(nsgSSABs.get(lastNode.eknoten)).y;
                 yVecLength = ssabEndYPos - ssabAnfYPos;
             }
             let pointIndex = 0;
             if (connectionLength == 1) {
+                // Platziere Knoten in der Mitte ==> Setze daher die Länge auf 2
                 pointIndex = 1;
                 connectionLength = 3;
             }
+            /* BEGIN: Setze Null-basierte x-Koordinate und ggfs. y-Koordinate (wenn Längskupplung) */
             lastNode = null;
             crtNode = initialNode;
             while (crtNode) {
                 if (nodePointMap.get(crtNode.id) === undefined) {
+                    // let xPos = 3 * (initialXPos > 0 ? initialXPos : (pointIndex / connectionLength));
                     let xPos = (isUniversal && !lastNodeLeistungsschalter ? 1 : (pointIndex / (connectionLength - 1)));
                     let yPos = undefined;
                     if (isLKupplung && !isUniversal) {
                         yPos = ssabAnfYPos + yVecLength * (pointIndex / connectionLength);
                     }
                     else {
-                        yPos = 0;
+                        yPos = 0; // Setze y erstmal auf 0 ==> Die y-Position wird nachträglich erst gesetzt
                     }
-                    const crtNodeDiagramObject = new DiagramObject_1.DiagramObject();
-                    crtNodeDiagramObject.diagramObjectPoints.push(new DiagramObjectPoint_1.DiagramObjectPoint(xPos, yPos));
+                    const crtNodeDiagramObject = DLUtilFunctions.createDiagramObjectWithPoint(xPos, yPos);
                     nodePointMap.set(crtNode.id, crtNodeDiagramObject);
                     tempNodePoints.set(crtNode.id, crtNodeDiagramObject);
                     pointIndex += 1;
                 }
                 if (relevantSSabIDs.has(crtNode.aknoten) || relevantSSabIDs.has(crtNode.eknoten)) {
-                    const ssab = relevantSSabIDs.has(crtNode.aknoten) ? integralNSGSsab.get(crtNode.aknoten) : integralNSGSsab.get(crtNode.eknoten);
+                    const ssab = relevantSSabIDs.has(crtNode.aknoten) ? nsgSSABs.get(crtNode.aknoten) : nsgSSABs.get(crtNode.eknoten);
                     tempNodeSSABConnectedMap.set(crtNode.id, ssab);
                 }
                 lastNode = crtNode;
                 crtNode = i7KnotenBeziehungen.find(elem => elem.aknoten === crtNode.eknoten);
             }
+            /* END: Setze Null-basierte x-Koordinate und ggfs. y-Koordinate (wenn Längskupplung) */
+            /* BEGIN: Shifte Punkte entlang x-Achse basierend auf SSAB.x oder KpFeld-Position */
             let leftOffset = undefined;
             if (!isLKupplung) {
+                // Für Querkupplungen ist das leftOffset das Offset des KpFeldes
                 leftOffset = kpFeldLeftOffset;
             }
             else {
+                // Für Längskupplungen ist das leftOffset das Offset die rechte untere x-Position der Sammelschiene
                 if (isUniversal && !lastNodeLeistungsschalter) {
                     leftOffset = QueryObjectSsabNsg_1.QueryObjectSsabNsg.getTopLeftPoint(tempNodeSSABConnectedMap.get(initialNode.id)).x;
                 }
@@ -186,12 +325,16 @@ class DLUtilFunctions {
                 tempNodePoints.get(initialNode.id).diagramObjectPoints[0].xPosition += (constants_1.NsgConstants.HORIZONTAL_OFFSET / (connectionLength));
                 tempNodePoints.get(lastNode.id).diagramObjectPoints[0].xPosition -= (constants_1.NsgConstants.HORIZONTAL_OFFSET / (connectionLength));
             }
+            /* END: Shifte Punkte entlang x-Achse basierend auf SSAB.x oder KpFeld-Position */
             if (!isLKupplung) {
+                // Fall: Querkupplung
                 tempNodePoints.forEach((value, key) => {
                     value.rotation = 90;
                 });
+                // Setze die korrekten y-Positionen
                 for (const tempNodePointEntry of tempNodePoints) {
                     if (tempNodeSSABConnectedMap.get(tempNodePointEntry[0]) && containsLeistungsschalter) {
+                        // Sammelschienenknoten auf die Sammelschienen, falls ein Leistungsschalter in der Querkupplung vorhanden ist
                         tempNodePointEntry[1].diagramObjectPoints[0].yPosition = tempNodeSSABConnectedMap.get(tempNodePointEntry[0]).posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET;
                         const tempNode = i7KnotenBeziehungen.find(elem => elem.id === tempNodePointEntry[0]);
                         if (relevantSSabIDs.has(tempNode.eknoten)) {
@@ -202,8 +345,9 @@ class DLUtilFunctions {
                         }
                     }
                     else {
-                        const ssabOffset = kpFeldDeltaausrichtung === 0 ? 0 : maxSSabPos;
+                        const ssabOffset = kpFeldDeltaausrichtung === 0 ? 0 : maxSSabPos - 1;
                         const yOffsetMaxPosSSAB = ((kpFeldDeltaausrichtung === 0 ? -1 : 1) * (1) + ssabOffset) * constants_1.NsgConstants.VERTICAL_OFFSET;
+                        //const yOffsetMaxPosSSAB = (kpFeldDeltaausrichtung === 0 ? -1 : 1) * maxSSabPos * NsgConstants.VERTICAL_OFFSET;
                         tempNodePointEntry[1].diagramObjectPoints[0].yPosition = yOffsetMaxPosSSAB;
                         if (isUniversal && tempNodeSSABConnectedMap.get(tempNodePointEntry[0])) {
                             tempNodePointEntry[1].rotation = kpFeldDeltaausrichtung === 0 ? 0 : 180;
@@ -212,9 +356,11 @@ class DLUtilFunctions {
                 }
             }
             else {
+                // Fall: Längskupplung
                 if (isUniversal) {
                     for (const tempNodePointEntry of tempNodePoints) {
                         if (tempNodeSSABConnectedMap.get(tempNodePointEntry[0]) && containsLeistungsschalter) {
+                            // Sammelschienenknoten auf die Sammelschienen, falls ein Leistungsschalter in der Längskupplung vorhanden ist
                             tempNodePointEntry[1].diagramObjectPoints[0].yPosition = tempNodeSSABConnectedMap.get(tempNodePointEntry[0]).posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET;
                         }
                         else {
@@ -224,42 +370,60 @@ class DLUtilFunctions {
                     }
                 }
                 else {
+                    // Wurde bereits oben gesetzt
                 }
             }
+            // BEGIN: ConnectivityNode-Support
             let prevNode = null;
             crtNode = initialNode;
             while (crtNode) {
+                // Platzieren erst dann, wenn der Knoten nicht mehr auf eine Sammelschiene verweist
                 if (!relevantSSabIDs.has(crtNode.aknoten)) {
                     const aKnotenUUID = integralID2UUID.get(crtNode.aknoten);
                     const eKnotenUUID = integralID2UUID.get(crtNode.eknoten);
-                    if (!placedCIMObjectsForDLProfil.has(aKnotenUUID) && !nodePointMap.has(crtNode.aknoten)) {
+                    if (!placedCIMObjectUUIDs.has(aKnotenUUID) && !nodePointMap.has(crtNode.aknoten)) {
+                        // Standard-Platzierung
                         const prevNodePoint = nodePointMap.get(prevNode.id);
                         const crtNodePoint = nodePointMap.get(crtNode.id);
                         nodePointMap.set(crtNode.aknoten, DLUtilFunctions.createDiagramObjectWithPoint((prevNodePoint.diagramObjectPoints[0].xPosition + crtNodePoint.diagramObjectPoints[0].xPosition) / 2, (prevNodePoint.diagramObjectPoints[0].yPosition + crtNodePoint.diagramObjectPoints[0].yPosition) / 2));
                         if (isLKupplung) {
+                            // Bei Längskupplungen
                             if (isUniversal) {
                                 if (relevantSSabIDs.has(prevNode.aknoten) && !relevantSSabIDs.has(crtNode.eknoten)) {
+                                    // Erster Knoten hat Beziehung zu einer Sammelschiene und aktueller Knoten nicht
                                     nodePointMap.set(crtNode.aknoten, DLUtilFunctions.createDiagramObjectWithPoint(nodePointMap.get(prevNode.id).diagramObjectPoints[0].xPosition, nodePointMap.get(crtNode.id).diagramObjectPoints[0].yPosition));
                                 }
                             }
                         }
                         else {
+                            // Bei Querkupplungen
                             if (relevantSSabIDs.has(prevNode.aknoten) && !relevantSSabIDs.has(crtNode.eknoten)) {
+                                // Erster Knoten hat Beziehung zu einer Sammelschiene und aktueller Knoten nicht
                                 nodePointMap.set(crtNode.aknoten, DLUtilFunctions.createDiagramObjectWithPoint(nodePointMap.get(prevNode.id).diagramObjectPoints[0].xPosition, nodePointMap.get(crtNode.id).diagramObjectPoints[0].yPosition));
                             }
                             else if (relevantSSabIDs.has(crtNode.eknoten) && !relevantSSabIDs.has(prevNode.aknoten)) {
+                                // Letzer Knoten hat Beziehung zu einer Sammelschiene und vorheriger Knoten nicht
                                 nodePointMap.set(crtNode.aknoten, DLUtilFunctions.createDiagramObjectWithPoint(nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition, nodePointMap.get(prevNode.id).diagramObjectPoints[0].yPosition));
                             }
+                            /*if (isUniversal && !placedCIMObjectsForDLProfil.has(eKnotenUUID) && !nodePointMap.has(crtNode.eknoten)) {
+                              if( containsLeistungsschalter ) {
+                                const xExtraOffset = 0.75 * NsgConstants.HORIZONTAL_OFFSET;
+                                nodePointMap.set(crtNode.eknoten, new DiagramObjectPoint(nodePointMap.get(crtNode.id).x + xExtraOffset, nodePointMap.get(crtNode.id).y));
+                              } else {
+                                nodePointMap.set(crtNode.eknoten, new DiagramObjectPoint(nodePointMap.get(crtNode.id).x, nodePointMap.get(crtNode.id).y));
+                              }
+                            }*/
                         }
                     }
                 }
-                if (isUniversal && !placedCIMObjectsForDLProfil.has(integralID2UUID.get(crtNode.eknoten)) && !nodePointMap.has(crtNode.eknoten)) {
+                if (isUniversal && !placedCIMObjectUUIDs.has(integralID2UUID.get(crtNode.eknoten)) && !nodePointMap.has(crtNode.eknoten)) {
                     if (containsLeistungsschalter && !relevantSSabIDs.has(crtNode.aknoten)) {
                         const xExtraOffset = 0.75 * constants_1.NsgConstants.HORIZONTAL_OFFSET;
                         nodePointMap.set(crtNode.eknoten, DLUtilFunctions.createDiagramObjectWithPoint(nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition + xExtraOffset, nodePointMap.get(crtNode.id).diagramObjectPoints[0].yPosition));
                     }
                     else {
                         if (relevantSSabIDs.has(crtNode.aknoten) && !relevantSSabIDs.has(crtNode.eknoten)) {
+                            // Knoten hat Beziehung zu einer Sammelschiene verweist dann auf eine nicht Sammelschiene
                             let yOffsetMaxPosSSAB = undefined;
                             if (!isLKupplung) {
                                 const ssabOffset = kpFeldDeltaausrichtung === 0 ? 0 : maxSSabPos;
@@ -275,80 +439,96 @@ class DLUtilFunctions {
                 prevNode = crtNode;
                 crtNode = i7KnotenBeziehungen.find(elem => elem.aknoten === crtNode.eknoten);
             }
-            crtNode = initialNode;
-            while (crtNode) {
-                let aKnotenPos = undefined;
-                let eKnotenPos = undefined;
-                if (!isLKupplung) {
-                    if (relevantSSabIDs.has(crtNode.aknoten)) {
-                        aKnotenPos = new DiagramObjectPoint_1.DiagramObjectPoint(((containsLeistungsschalter) ? nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition : leftOffset), integralNSGSsab.get(crtNode.aknoten).posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET);
-                    }
-                    if (relevantSSabIDs.has(crtNode.eknoten)) {
-                        eKnotenPos = new DiagramObjectPoint_1.DiagramObjectPoint(((containsLeistungsschalter) ? nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition : leftOffset + defaultWidthOfKupplung), integralNSGSsab.get(crtNode.eknoten).posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET);
-                    }
-                }
-                else {
-                    if (relevantSSabIDs.has(crtNode.aknoten)) {
-                        if (isUniversal) {
-                            aKnotenPos = new DiagramObjectPoint_1.DiagramObjectPoint(nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition, integralNSGSsab.get(crtNode.aknoten).posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET);
-                        }
-                        else {
-                            aKnotenPos = new DiagramObjectPoint_1.DiagramObjectPoint(QueryObjectSsabNsg_1.QueryObjectSsabNsg.getBottomRightPoint(integralNSGSsab.get(crtNode.aknoten)).x, integralNSGSsab.get(crtNode.aknoten).posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET);
-                        }
-                    }
-                    if (relevantSSabIDs.has(crtNode.eknoten)) {
-                        if (isUniversal) {
-                            eKnotenPos = new DiagramObjectPoint_1.DiagramObjectPoint(nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition, integralNSGSsab.get(crtNode.eknoten).posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET);
-                        }
-                        else {
-                            eKnotenPos = new DiagramObjectPoint_1.DiagramObjectPoint(QueryObjectSsabNsg_1.QueryObjectSsabNsg.getTopLeftPoint(integralNSGSsab.get(crtNode.eknoten)).x, integralNSGSsab.get(crtNode.eknoten).posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET);
-                        }
-                    }
-                }
-                DLUtilFunctions.exportTerminals(crtNode, nodePointMap, uuidPointsMap, cimModel, integralID2UUID, aKnotenPos, eKnotenPos);
-                lastNode = crtNode;
-                crtNode = i7KnotenBeziehungen.find(elem => elem.aknoten === crtNode.eknoten);
-            }
-            [...nodePointMap.entries()].forEach(entry => {
-                uuidPointsMap.set(integralID2UUID.get(entry[0]), entry[1]);
-            });
+            // END: ConnectivityNode-Support
+            // BEGIN: Terminal-Support
+            // crtNode = initialNode;
+            // while (crtNode) {
+            //   let aKnotenPos: DiagramObjectPoint = undefined;
+            //   let eKnotenPos: DiagramObjectPoint = undefined;
+            //
+            //   if (!isLKupplung) {
+            //     if (relevantSSabIDs.has(crtNode.aknoten)) {
+            //       aKnotenPos = new DiagramObjectPoint(((containsLeistungsschalter) ? nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition : leftOffset), nsgSSABs.get(crtNode.aknoten).posSSAB * NsgConstants.VERTICAL_OFFSET);
+            //     }
+            //     if (relevantSSabIDs.has(crtNode.eknoten)) {
+            //       eKnotenPos = new DiagramObjectPoint(((containsLeistungsschalter) ? nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition : leftOffset + defaultWidthOfKupplung), nsgSSABs.get(crtNode.eknoten).posSSAB * NsgConstants.VERTICAL_OFFSET);
+            //     }
+            //   } else {
+            //     if (relevantSSabIDs.has(crtNode.aknoten)) {
+            //       if (isUniversal) {
+            //         aKnotenPos = new DiagramObjectPoint(nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition, nsgSSABs.get(crtNode.aknoten).posSSAB * NsgConstants.VERTICAL_OFFSET)
+            //       } else {
+            //         aKnotenPos = new DiagramObjectPoint(QueryObjectSsabNsg.getBottomRightPoint(nsgSSABs.get(crtNode.aknoten)).x, nsgSSABs.get(crtNode.aknoten).posSSAB * NsgConstants.VERTICAL_OFFSET)
+            //       }
+            //     }
+            //     if (relevantSSabIDs.has(crtNode.eknoten)) {
+            //       if (isUniversal) {
+            //         eKnotenPos = new DiagramObjectPoint(nodePointMap.get(crtNode.id).diagramObjectPoints[0].xPosition, nsgSSABs.get(crtNode.eknoten).posSSAB * NsgConstants.VERTICAL_OFFSET)
+            //       } else {
+            //         eKnotenPos = new DiagramObjectPoint(QueryObjectSsabNsg.getTopLeftPoint(nsgSSABs.get(crtNode.eknoten)).x, nsgSSABs.get(crtNode.eknoten).posSSAB * NsgConstants.VERTICAL_OFFSET)
+            //       }
+            //     }
+            //   }
+            //
+            //   DLUtilFunctions.exportTerminals(crtNode, nodePointMap, integralID2UUID, objects, aKnotenPos, eKnotenPos)
+            //
+            //   lastNode = crtNode;
+            //   crtNode = i7KnotenBeziehungen.find(elem => elem.aknoten === crtNode.eknoten);
+            // }
+            // END: Terminal-Support
         }
+        return nodePointMap;
     }
-    static exportTerminals(nodeRelation, nodePointMap, uuidPointsMap, cimModel, integralID2UUID, aKnotenPos = undefined, eKnotenPos = undefined) {
-        if (nodePointMap.has(nodeRelation.id)) {
-            const ceTerminals = cimModel.getConductingEquipment(integralID2UUID.get(nodeRelation.id)).terminals;
-            let terminalDiagramObject;
-            let cnTerminals = cimModel.getConnectivityNode(integralID2UUID.get(nodeRelation.aknoten)).terminals;
-            let terminal = [...cnTerminals.values()].filter(t => ceTerminals.has(t.getUUID()))[0];
-            let ceDiagramObject = nodePointMap.get(nodeRelation.id);
-            let cePoint = ceDiagramObject.diagramObjectPoints[0];
-            terminalDiagramObject = DLUtilFunctions.createDiagramObjectWithPoint(cePoint.xPosition, cePoint.yPosition);
-            let cnPoint;
-            if (nodePointMap.has(nodeRelation.aknoten)) {
-                cnPoint = aKnotenPos ? aKnotenPos : nodePointMap.get(nodeRelation.aknoten).diagramObjectPoints[0];
-                if (cnPoint.xPosition !== cePoint.xPosition && cnPoint.yPosition !== cePoint.yPosition) {
-                    terminalDiagramObject.diagramObjectPoints.push(new DiagramObjectPoint_1.DiagramObjectPoint(cnPoint.xPosition, cePoint.yPosition));
-                }
-                terminalDiagramObject.diagramObjectPoints.push(new DiagramObjectPoint_1.DiagramObjectPoint(cnPoint.xPosition, cnPoint.yPosition));
-                DLUtilFunctions.adjustTerminalCEPosition(nodePointMap.get(nodeRelation.id), cnPoint, terminalDiagramObject.diagramObjectPoints[0]);
-                uuidPointsMap.set(terminal.getUUID(), terminalDiagramObject);
-            }
-            cnTerminals = cimModel.getConnectivityNode(integralID2UUID.get(nodeRelation.eknoten)).terminals;
-            terminal = [...cnTerminals.values()].filter(t => ceTerminals.has(t.getUUID()))[0];
-            cePoint = nodePointMap.get(nodeRelation.id).diagramObjectPoints[0];
-            terminalDiagramObject = DLUtilFunctions.createDiagramObjectWithPoint(cePoint.xPosition, cePoint.yPosition);
-            if (nodePointMap.has(nodeRelation.eknoten)) {
-                cnPoint = eKnotenPos ? eKnotenPos : nodePointMap.get(nodeRelation.eknoten).diagramObjectPoints[0];
-                if (cnPoint.xPosition !== cePoint.xPosition && cnPoint.yPosition !== cePoint.yPosition) {
-                    terminalDiagramObject.diagramObjectPoints.push(new DiagramObjectPoint_1.DiagramObjectPoint(cnPoint.xPosition, cePoint.yPosition));
-                }
-                terminalDiagramObject.diagramObjectPoints.push(new DiagramObjectPoint_1.DiagramObjectPoint(cnPoint.xPosition, cnPoint.yPosition));
-                DLUtilFunctions.adjustTerminalCEPosition(nodePointMap.get(nodeRelation.id), cnPoint, terminalDiagramObject.diagramObjectPoints[0]);
-                uuidPointsMap.set(terminal.getUUID(), terminalDiagramObject);
-            }
-        }
+    static exportTerminals(nodeRelation, nodePointMap, integralID2UUID, objects, aKnotenPos = undefined, eKnotenPos = undefined) {
+        // if (nodePointMap.has(nodeRelation.id)) {
+        //   const ceTerminals = objects.getConductingEquipment(integralID2UUID.get(nodeRelation.id)).terminals;
+        //
+        //   /* aKnoten => current bzw. ConnectivityNode -> ConductingEquipment */
+        //   let terminalDiagramObject: DiagramObject;
+        //   let cnTerminals = cimModel.getConnectivityNode(integralID2UUID.get(nodeRelation.aknoten)).terminals;
+        //   let terminal = [...cnTerminals.values()].filter(t => ceTerminals.has(t.getUUID()))[0];
+        //
+        //   // ConductingEquipment-Punkt
+        //   let ceDiagramObject = nodePointMap.get(nodeRelation.id);
+        //
+        //   let cePoint = ceDiagramObject.diagramObjectPoints[0];
+        //   terminalDiagramObject = DLUtilFunctions.createDiagramObjectWithPoint(cePoint.xPosition, cePoint.yPosition);
+        //
+        //   let cnPoint;
+        //   // ConnectivityNode-Punkt
+        //   if (nodePointMap.has(nodeRelation.aknoten)) {
+        //     cnPoint = aKnotenPos ? aKnotenPos : nodePointMap.get(nodeRelation.aknoten).diagramObjectPoints[0];
+        //     if (cnPoint.xPosition !== cePoint.xPosition && cnPoint.yPosition !== cePoint.yPosition) {
+        //       // Füge zusätzlichen Eckpunkt ein
+        //       terminalDiagramObject.diagramObjectPoints.push(new DiagramObjectPoint(cnPoint.xPosition, cePoint.yPosition));
+        //     }
+        //     terminalDiagramObject.diagramObjectPoints.push(new DiagramObjectPoint(cnPoint.xPosition, cnPoint.yPosition));
+        //     DLUtilFunctions.adjustTerminalCEPosition(nodePointMap.get(nodeRelation.id), cnPoint, terminalDiagramObject.diagramObjectPoints[0]);
+        //   }
+        //   /* --- */
+        //
+        //   /* current => eKnoten bzw. ConductingEquipment -> ConnectivityNode */
+        //   cnTerminals = cimModel.getConnectivityNode(integralID2UUID.get(nodeRelation.eknoten)).terminals;
+        //   terminal = [...cnTerminals.values()].filter(t => ceTerminals.has(t.getUUID()))[0];
+        //
+        //   cePoint = nodePointMap.get(nodeRelation.id).diagramObjectPoints[0];
+        //   terminalDiagramObject = DLUtilFunctions.createDiagramObjectWithPoint(cePoint.xPosition, cePoint.yPosition);
+        //
+        //   // ConnectivityNode-Punkt
+        //   if (nodePointMap.has(nodeRelation.eknoten)) {
+        //     cnPoint = eKnotenPos ? eKnotenPos : nodePointMap.get(nodeRelation.eknoten).diagramObjectPoints[0];
+        //     if (cnPoint.xPosition !== cePoint.xPosition && cnPoint.yPosition !== cePoint.yPosition) {
+        //       // Füge zusätzlichen Eckpunkt ein
+        //       terminalDiagramObject.diagramObjectPoints.push(new DiagramObjectPoint(cnPoint.xPosition, cePoint.yPosition));
+        //     }
+        //     terminalDiagramObject.diagramObjectPoints.push(new DiagramObjectPoint(cnPoint.xPosition, cnPoint.yPosition));
+        //     DLUtilFunctions.adjustTerminalCEPosition(nodePointMap.get(nodeRelation.id), cnPoint, terminalDiagramObject.diagramObjectPoints[0]);
+        //   }
+        // }
+        /* --- */
     }
     static adjustTerminalCEPosition(ceDiagramObject, cnPoint, terminalDiagramObjectPoint) {
+        // Das Offset wird in Richtung des CN vollzogen entsprechend der Ausrichtung des CE
         const isLeft = cnPoint.xPosition < terminalDiagramObjectPoint.xPosition;
         const isTop = cnPoint.yPosition < terminalDiagramObjectPoint.yPosition;
         const ceRotation = ceDiagramObject.rotation;
@@ -359,14 +539,33 @@ class DLUtilFunctions {
             terminalDiagramObjectPoint.xPosition += (isLeft ? -1 : 1) * constants_1.NsgConstants.TERMINAL_CE_OFFSET;
         }
     }
+    static copyAndPushDiagramObjectPoint(diagramObject, diagramObjectPoint2Copy) {
+        const sequenceNumber = diagramObject.diagramObjectPoints.length + 1;
+        const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint(diagramObjectPoint2Copy.xPosition, diagramObjectPoint2Copy.yPosition, sequenceNumber);
+        diagramObjectPoint.mrid = (0, utils_1.generateUUID)();
+        diagramObjectPoint.diagramObject = diagramObject;
+        diagramObject.diagramObjectPoints.push(diagramObjectPoint);
+    }
+    static createDiagramObjectWithPoint2(args) {
+        const diagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)(), args.diagramObjectName);
+        diagramObject.diagramUUID = args.diagramUUID;
+        diagramObject.identifiedObjectUUID = args.identifiedObjectUUID;
+        diagramObject.rotation = args.rotation;
+        const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint(args.xPosition, args.yPosition);
+        diagramObjectPoint.mrid = (0, utils_1.generateUUID)();
+        diagramObjectPoint.sequenceNumber = args.sequenceNumber !== undefined ? args.sequenceNumber : 1;
+        diagramObjectPoint.diagramObject = diagramObject;
+        diagramObject.diagramObjectPoints.push(diagramObjectPoint);
+        return diagramObject;
+    }
     static createDiagramObjectWithPoint(x, y, rotation, sequenceNumber) {
-        const diagramObject = new DiagramObject_1.DiagramObject();
-        if (diagramObject !== undefined) {
-            diagramObject.rotation = rotation;
-            diagramObject.diagramObjectPoints.push(new DiagramObjectPoint_1.DiagramObjectPoint(x, y));
-            if (sequenceNumber !== undefined)
-                diagramObject.diagramObjectPoints[0].sequenceNumber = sequenceNumber;
-        }
+        const diagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)(), 'DiagramObject');
+        diagramObject.rotation = rotation;
+        const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint(x, y);
+        diagramObjectPoint.mrid = (0, utils_1.generateUUID)();
+        diagramObjectPoint.sequenceNumber = sequenceNumber !== undefined ? sequenceNumber : 1;
+        diagramObjectPoint.diagramObject = diagramObject;
+        diagramObject.diagramObjectPoints.push(diagramObjectPoint);
         return diagramObject;
     }
     static createDiagramObjectWithPointArrayBased(xy, rotation) {
@@ -384,32 +583,44 @@ class DLUtilFunctions {
         }
         return filteredResults;
     }
-    static getXYOffsetFromRelCM(type, integral7, anschlussID, nsgLeitungspkt) {
+    static getXYOffsetFromRelCM(type, nsgObject, anschlussID, nsgLeitungspkt) {
         let xOffset = 0;
         let yOffset = 0;
         if (type === integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) {
-            const nsgSchaltfeld = integral7.integralNSGSchaltfeld.get(anschlussID);
+            // Auswerten, ob ein Schaltfeld am Anfang angeschlossen ist
+            // Falls ja, Ausrichtung des Schaltfeldes und der zugehörigen Schaltanlage relevant
+            // Ignoriere xrel und yrel vom Leitungspunkt
+            // const nsgSchaltfeld = integral7.integralNSGSchaltfeld.get(anschlussID);
+            const nsgSchaltfeld = nsgObject;
             switch (nsgSchaltfeld.orientation) {
-                case 0:
+                case 0: // TOP
+                    // c =>  x += c
+                    // m =>  y += (m *-1)
                     xOffset = nsgLeitungspkt.abstand_rel_anchor_c;
                     yOffset = nsgLeitungspkt.abstand_rel_anchor_m * (-1);
                     break;
-                case 1:
+                case 1: // RIGHT
+                    // m =>  x += (m)
+                    // c =>  y += (c)
                     xOffset = nsgLeitungspkt.abstand_rel_anchor_m;
                     yOffset = nsgLeitungspkt.abstand_rel_anchor_c;
                     break;
-                case 2:
+                case 2: // BOTTOM
+                    // c =>  x += (c *-1)
+                    // m =>  y += (m)
                     xOffset = nsgLeitungspkt.abstand_rel_anchor_c * (-1);
                     yOffset = nsgLeitungspkt.abstand_rel_anchor_m;
                     break;
-                case 3:
+                case 3: // LEFT
+                    // m =>  x += (m *-1)
+                    // c =>  y += (c *-1)
                     xOffset = nsgLeitungspkt.abstand_rel_anchor_m * (-1);
                     yOffset = nsgLeitungspkt.abstand_rel_anchor_c * (-1);
                     break;
             }
         }
         else if (type === integral_sql_1.Integral7TableNames.NSG_QUERZWEIG) {
-            const nsgQuerzweig = integral7.integralNSGQuerzweig.get(anschlussID);
+            const nsgQuerzweig = nsgObject;
             switch (nsgQuerzweig.ausrichtung) {
                 case 0:
                     xOffset = nsgLeitungspkt.abstand_rel_anchor_c * (-1);
@@ -430,7 +641,7 @@ class DLUtilFunctions {
             }
         }
         else {
-            xOffset = nsgLeitungspkt.abstand_rel_anchor_c * (-1);
+            xOffset = nsgLeitungspkt.abstand_rel_anchor_c;
             yOffset = nsgLeitungspkt.abstand_rel_anchor_m * (-1);
         }
         return [xOffset, yOffset];
@@ -438,36 +649,51 @@ class DLUtilFunctions {
     static convertNsgKnoten(cimModel, integral7, data, refCimObjectUUID, width, height, xParentRel, yParentRel) {
         const diagramUUID = integral7.i7SchemaID2UUID.get(data.variantennr);
         const diagram = cimModel.getDiagram(diagramUUID);
-        if (!diagram) {
+        // const nsgStandort = integral7.integralNSGStandorte.get(data.nsgso);
+        // if (!diagram || !nsgStandort) {
+        if (!diagram) { // || !nsgStandort) {
             return;
         }
-        const diagramObject = new DiagramObject_1.DiagramObject(utils_1.generateUUID(), 'Abzweig');
+        const diagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)(), 'Abzweig');
         diagramObject.diagramUUID = diagramUUID;
         diagramObject.setDiagram(diagram);
         const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint(xParentRel + data.xrel + (width / 2), yParentRel + data.yrel + (height / 2));
-        diagramObjectPoint.mrid = utils_1.generateUUID();
+        diagramObjectPoint.mrid = (0, utils_1.generateUUID)();
         diagramObjectPoint.diagramObject = diagramObject;
         diagramObject.addDiagramObjectPoint(diagramObjectPoint);
+        // Füge dem CIMModel hinzu
         cimModel.addDiagramObject(diagramObject);
         cimModel.addDiagramObjectPoint(diagramObjectPoint);
         if (refCimObjectUUID !== undefined) {
             diagramObject.setIdentifiedObjectUUID(refCimObjectUUID);
             integral7.placedCIMObjectsForDLProfil.set(refCimObjectUUID, diagramObject);
-            DLUtilFunctions.setObjectIntoMapJSONBased(integral7.i7ID2UUID, DLUtilFunctions.stringifySchemaKey({ id: data.id, variantennr: data.variantennr }), refCimObjectUUID);
+            // TODO replaced with new key
+            DLUtilFunctions.setObjectIntoMapJSONBased(integral7.i7ID2UUID, DLUtilFunctions.stringifySchemaKey({
+                id: data.id,
+                variantennr: data.variantennr
+            }), refCimObjectUUID);
+            // integral7.i7ID2UUID.set(data.id, refCimObjectUUID);
         }
         else {
-            DLUtilFunctions.setObjectIntoMapJSONBased(integral7.i7ID2UUID, DLUtilFunctions.stringifySchemaKey({ id: data.id, variantennr: data.variantennr }), diagramObject.getUUID());
+            // TODO replaced with new key
+            DLUtilFunctions.setObjectIntoMapJSONBased(integral7.i7ID2UUID, DLUtilFunctions.stringifySchemaKey({
+                id: data.id,
+                variantennr: data.variantennr
+            }), diagramObject.getUUID());
+            // integral7.i7ID2UUID.set(data.id, diagramObject.getUUID());
             integral7.placedCIMObjectsForDLProfil.set(diagramObject.getUUID(), diagramObject);
         }
     }
     static convertACLineSegment(completeLength, segmentPercentages, eqUUIDs, i7LineBasePoints) {
         const returnedDiagramObjects = [];
+        // Bestimme komplette 'Pixellänge' der Leitung
         let completePixelLength = 0;
         for (let a = 1; a < i7LineBasePoints.length; ++a) {
             const tempX = i7LineBasePoints[a].xPosition - i7LineBasePoints[a - 1].xPosition;
             const tempY = i7LineBasePoints[a].yPosition - i7LineBasePoints[a - 1].yPosition;
             completePixelLength += Math.sqrt((tempX * tempX) + (tempY * tempY));
         }
+        // Der Leitungsabschnitt zwischen 'lastB' und 'b' wird mit der Leitung 'eqIdx' verknüpft
         let lastB = 0;
         let b = 1;
         for (let eqIdx = 0; eqIdx < segmentPercentages.length; ++eqIdx) {
@@ -481,6 +707,7 @@ class DLUtilFunctions {
                 crtPixelLength += Math.sqrt((tempX * tempX) + (tempY * tempY));
             }
             do {
+                // Nehme weitere DiagramObjectPoint zum aktuellen LineSegment hinzu
                 const tempX = i7LineBasePoints[b].xPosition - i7LineBasePoints[b - 1].xPosition;
                 const tempY = i7LineBasePoints[b].yPosition - i7LineBasePoints[b - 1].yPosition;
                 crtPixelLength += Math.sqrt((tempX * tempX) + (tempY * tempY));
@@ -490,11 +717,16 @@ class DLUtilFunctions {
             } while (crtPixelPercentageSize < segmentPercentages[eqIdx] && b < i7LineBasePoints.length);
             const crtPixelPercentage = (crtPixelLength / completePixelLength);
             if (crtPixelPercentage <= segmentPercentages[eqIdx] + epsilon) {
+                // Ende erreicht
             }
             else if (crtPixelPercentage > segmentPercentages[eqIdx]) {
                 let decreased = false;
+                //if (b === i7LineBasePoints.length) {
                 b--;
                 decreased = true;
+                //}
+                // Neuer DiagramObjectPoint notwendig
+                // Interpoliere dafür zwischen den letzten beiden Punkten und erzeuge neuen Punkt
                 let tempX = i7LineBasePoints[b].xPosition - i7LineBasePoints[b - 1].xPosition;
                 let tempY = i7LineBasePoints[b].yPosition - i7LineBasePoints[b - 1].yPosition;
                 const percentageOfSegment = crtPixelPercentageSize - lastPixelPercentageSize;
@@ -511,13 +743,13 @@ class DLUtilFunctions {
                 if (decreased)
                     b++;
             }
-            const diagramObject = new DiagramObject_1.DiagramObject(utils_1.generateUUID(), 'DiagramObject');
+            const diagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)(), 'DiagramObject');
             diagramObject.setIdentifiedObjectUUID(eqUUIDs[eqIdx]);
             returnedDiagramObjects.push(diagramObject);
             let i = 1;
             for (let idx = lastB; idx < b; ++idx) {
                 const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint(i7LineBasePoints[idx].xPosition, i7LineBasePoints[idx].yPosition, i);
-                diagramObjectPoint.mrid = utils_1.generateUUID();
+                diagramObjectPoint.mrid = (0, utils_1.generateUUID)();
                 diagramObjectPoint.diagramObject = diagramObject;
                 diagramObject.addDiagramObjectPoint(diagramObjectPoint);
                 ++i;
@@ -541,9 +773,17 @@ class DLUtilFunctions {
     }
     static lookupKnotenSOInBoundaryFramesI7IDBased(boundaryFrames, schemaID, variantennr, placedCimObjects, additionBoundaryNodeIDs) {
         for (const boundaryFrame of boundaryFrames) {
-            const schemaType = DLUtilFunctions.getObjectFromMapJSONBased(boundaryFrame.integral7Modell.i7SchemaID2Type, DLUtilFunctions.stringifySchemaKey({ id: schemaID, variantennr: variantennr }));
+            // const schemaType = boundaryFrame.integral7Modell.i7SchemaID2Type.find( arg => schemaID);
+            const schemaType = DLUtilFunctions.getObjectFromMapJSONBased(boundaryFrame.integral7Modell.i7SchemaID2Type, DLUtilFunctions.stringifySchemaKey({
+                id: schemaID,
+                variantennr: variantennr
+            }));
             if (schemaType) {
-                const lookupUUID = DLUtilFunctions.getObjectFromMapJSONBased(boundaryFrame.integral7Modell.i7ID2UUID, DLUtilFunctions.stringifySchemaKey({ id: schemaID, variantennr: variantennr }));
+                // const lookupUUID = boundaryFrame.integral7Modell.i7ID2UUID.get(schemaID);
+                const lookupUUID = DLUtilFunctions.getObjectFromMapJSONBased(boundaryFrame.integral7Modell.i7ID2UUID, DLUtilFunctions.stringifySchemaKey({
+                    id: schemaID,
+                    variantennr: variantennr
+                }));
                 const tempDiagramObject = boundaryFrame.integral7Modell.placedCIMObjectsForDLProfil.get(lookupUUID);
                 if (tempDiagramObject) {
                     if (!placedCimObjects.has(lookupUUID)) {