private void FormVectorsOfEdges(DataStructure dm, List <VectorOfEdge> vectorList)
        {
            Edge currentEdge;

            DataModel.Point point1;
            DataModel.Point point2;
            double          currentVectorX;
            double          currentVectorY;
            double          currentVectorZ;
            bool            noObjectYet;

            for (int currentEdgeNumber = 0; dm.edges.GetEdge(currentEdgeNumber) != null; currentEdgeNumber++)
            {
                currentEdge = dm.edges.GetEdge(currentEdgeNumber);
                if (currentEdge.CurrentCondition == Edge.Condition.PotentiallyFaulty)
                {
                    noObjectYet    = true;
                    point1         = currentEdge.P1;
                    point2         = currentEdge.P2;
                    currentVectorX = point1.X - point2.X;
                    currentVectorY = point1.Y - point2.Y;

                    // Theorie: Für die Ausrichtung eines Vektors im Raum werden nur zwei Werte benötigt. Sowie sich bei der Rotation eines Körpers im Raum aus der Rotation auf zwei Achsen die Dritte ergibt.

                    if (currentVectorX == 0 && currentVectorY != 0)             // Sonderfall, wenn Vektor paralell zur yz-Ebene liegt
                    {
                        currentVectorZ = (point1.Z - point2.Z) / (currentVectorY);
                    }
                    else if (currentVectorX == 0 && currentVectorY == 0)        // Sonderfall, wenn Vektor paralell zur z-Achse liegt
                    {
                        currentVectorZ = 1;
                    }
                    else                                                        // Standardfall. currentVectorY und currentVectorZ geben an, wo der Wert auf der y und z-Achse bei x=1 liegt.
                    {
                        currentVectorY = currentVectorY / currentVectorX;       // Diese beiden Divisionen stellen sicher, dass die Vorzeichen bei entgegengerichteten Vektoren gleich sind.
                        currentVectorZ = (point1.Z - point2.Z) / currentVectorX;
                    }

                    // Wenn bereits eine Edge mit dem gleichen Vektor gefunden wurde, wird die aktuelle Edge in der Liste hinzugefügt. Wenn nicht, wird ein neues Objekt mit den Vektoren erzeugt.
                    foreach (VectorOfEdge vector in vectorList)
                    {
                        if (ApproximatelyEqual(vector.vectorY, vector.vectorZ, currentVectorY, currentVectorZ))
                        {
                            vector.edgeIDList.Add(currentEdgeNumber);
                            noObjectYet = false;
                            break;
                        }
                    }
                    if (noObjectYet)
                    {
                        VectorOfEdge vectorOfEdge = new VectorOfEdge();
                        vectorList.Add(vectorOfEdge);
                        vectorOfEdge.addCoordinates(currentVectorY, currentVectorZ);
                        vectorOfEdge.edgeIDList.Add(currentEdgeNumber);
                    }
                }
            }
        }
 /// <summary>
 /// Schreibt Kanten, die Teil eines Pfades sind einen wählbaren Zustand zu.
 /// </summary>
 /// <param name="dm">Datenmodell</param>
 /// <param name="vec">Kanten befinden sich in der Liste, die Teil der Klasse VectorOfEdge ist</param>
 /// <param name="condition">Zustand</param>
 private void SetCycleEdges(DataStructure dm, VectorOfEdge vec, Edge.Condition condition)
 {
     foreach (int edgeID in vec.edgeIDList)
     {
         if (dm.edges.GetEdge(edgeID).cycle)
         {
             dm.edges.GetEdge(edgeID).CurrentCondition = condition;
             if (condition == Edge.Condition.Faulty)
             {
                 dm.FaultyEdges.Add(edgeID);
             }
         }
     }
 }