@enervance/insight-cim-model 0.0.62 → 0.0.64

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,6 +13,7 @@ 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) {
@@ -26,7 +31,7 @@ class DLUtilFunctions {
         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 !== null && dist !== void 0 ? dist : 0;
+        return dist ?? 0;
     }
     static lengthOfVector(v) {
         return Math.sqrt(Math.pow(v[0], 2) + Math.pow(v[1], 2));
@@ -80,7 +85,12 @@ class DLUtilFunctions {
         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 = [
@@ -93,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;
     }
@@ -107,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;
     }
@@ -119,8 +135,17 @@ class DLUtilFunctions {
     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) {
@@ -135,10 +160,28 @@ class DLUtilFunctions {
             }
         }
     }
+    static rotateShiftAddBasedOnNsgSAA(cimModel, integral7, variantenNr, nsgSaaID, uuidPointsMap, useLeftOffset = false) {
+        const nsgSaa = integral7.integralNSGSAAbschnitt.get(nsgSaaID);
+        const nsgSa = integral7.integralNSGSchaltanlage.get(nsgSaa.nsgsaid);
+        const nsgSo = integral7.integralNSGStandorte.get(nsgSa.nsgsoid);
+        let saaShiftOffset = 0;
+        for (const tempNsgSaa of nsgSa.saabNsg) {
+            saaShiftOffset = saaShiftOffset < (tempNsgSaa.nslots + tempNsgSaa.laenge) ? (tempNsgSaa.nslots + tempNsgSaa.laenge) : saaShiftOffset;
+        }
+        uuidPointsMap.forEach((entryDiagramObject, key) => {
+            entryDiagramObject.diagramObjectPoints.forEach(entryDiagramObjectPoint => {
+                entryDiagramObjectPoint.xPosition += useLeftOffset ? nsgSaa.nslots * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0;
+                DLUtilFunctions.rotateDiagramObjectPoint(entryDiagramObjectPoint, -90 * nsgSa.ausrichtung);
+                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) {
-        var _a;
         const newDiagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)());
-        newDiagramObject.rotation = (_a = other.rotation) !== null && _a !== void 0 ? _a : 0;
+        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));
@@ -170,17 +213,22 @@ class DLUtilFunctions {
         const nodePointMap = new Map();
         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) {
+            // 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;
@@ -189,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]);
@@ -199,6 +251,7 @@ class DLUtilFunctions {
                     }
                 }
             }
+            //const defaultLength = 3 * NsgConstants.HORIZONTAL_OFFSET;
             let yVecLength = undefined;
             let ssabAnfYPos = undefined;
             if (isLKupplung && !isUniversal) {
@@ -208,20 +261,23 @@ class DLUtilFunctions {
             }
             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 = DLUtilFunctions.createDiagramObjectWithPoint(xPos, yPos);
                     nodePointMap.set(crtNode.id, crtNodeDiagramObject);
@@ -235,11 +291,15 @@ class DLUtilFunctions {
                 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;
                 }
@@ -265,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)) {
@@ -283,6 +347,7 @@ class DLUtilFunctions {
                     else {
                         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;
@@ -291,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 {
@@ -303,32 +370,49 @@ 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 (!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));
+                              }
+                            }*/
                         }
                     }
                 }
@@ -339,6 +423,7 @@ class DLUtilFunctions {
                     }
                     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;
@@ -354,10 +439,96 @@ class DLUtilFunctions {
                 prevNode = crtNode;
                 crtNode = i7KnotenBeziehungen.find(elem => elem.aknoten === crtNode.eknoten);
             }
+            // 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, 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;
@@ -416,21 +587,33 @@ class DLUtilFunctions {
         let xOffset = 0;
         let yOffset = 0;
         if (type === integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) {
+            // 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;
@@ -466,7 +649,9 @@ 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((0, utils_1.generateUUID)(), 'Abzweig');
@@ -476,32 +661,39 @@ class DLUtilFunctions {
         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);
+            // 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 {
+            // 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) {
@@ -515,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));
@@ -524,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;
@@ -575,11 +773,13 @@ class DLUtilFunctions {
     }
     static lookupKnotenSOInBoundaryFramesI7IDBased(boundaryFrames, schemaID, variantennr, placedCimObjects, additionBoundaryNodeIDs) {
         for (const boundaryFrame of boundaryFrames) {
+            // 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 = boundaryFrame.integral7Modell.i7ID2UUID.get(schemaID);
                 const lookupUUID = DLUtilFunctions.getObjectFromMapJSONBased(boundaryFrame.integral7Modell.i7ID2UUID, DLUtilFunctions.stringifySchemaKey({
                     id: schemaID,
                     variantennr: variantennr
@@ -613,5 +813,4 @@ class DLUtilFunctions {
     }
 }
 exports.DLUtilFunctions = DLUtilFunctions;
-DLUtilFunctions.EPSILON = 0.0000001;
 //# sourceMappingURL=util-functions.js.map