From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- Master/CGuCAD/projects/Markus/SpeichenStern.cs | 469 +++++++++++++++++++++++++ 1 file changed, 469 insertions(+) create mode 100644 Master/CGuCAD/projects/Markus/SpeichenStern.cs (limited to 'Master/CGuCAD/projects/Markus/SpeichenStern.cs') diff --git a/Master/CGuCAD/projects/Markus/SpeichenStern.cs b/Master/CGuCAD/projects/Markus/SpeichenStern.cs new file mode 100644 index 0000000..fc43148 --- /dev/null +++ b/Master/CGuCAD/projects/Markus/SpeichenStern.cs @@ -0,0 +1,469 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; +using Autodesk.AutoCAD.Geometry; +using System.IO; +using System.Globalization; + +namespace Praktikum +{ + class SpeichenStern + { + const int cTKValue = -1; // TK -1; + const int cLeerValue = -1000; // -666 = Leer + const int cUnbekannt = -2000; // Unbekannt + + ArrayList _alUmfangLinien = new ArrayList(); + private ArrayList _alKantenInSpeichen = new ArrayList(); + + private ArrayList _alKantenPool = new ArrayList(); + private ArrayList _alSpeichenStrahlen = new ArrayList(); // Element 0 ist HauptPunkt Pos + private ArrayList _alpnPoint; + + public SpeichenStern(ArrayList alpnPoints) + { + _alpnPoint = alpnPoints; + + for (int i = 0; i < alpnPoints.Count; i++) + { + PolyNode plMain = (PolyNode)alpnPoints[i]; + PolyNode plIncoming; + PolyNode plOutcoming; + + if ((i + 1) == alpnPoints.Count) + plOutcoming = (PolyNode)alpnPoints[0]; + else + plOutcoming =(PolyNode)alpnPoints[i + 1]; + if ((i-1) < 0) + plIncoming = (PolyNode)alpnPoints[(alpnPoints.Count - 1)]; + else + plIncoming = (PolyNode)alpnPoints[i - 1]; + + SpeichenSternStrahl spStrahl = new SpeichenSternStrahl(plIncoming, plOutcoming, plMain,i); + + _alSpeichenStrahlen.Add(spStrahl); + } + + _alUmfangLinien = GetUmfang(); + + for (int i = 0; i < _alUmfangLinien.Count; i++) + { + structLinien strTemp = (structLinien)(_alUmfangLinien[i]); + + SperrKante(strTemp.iAnfangsPunkt, strTemp.iEndPunkt, _alUmfangLinien.IndexOf(strTemp)+10000); + + + } + for (int i = 0; i < _alSpeichenStrahlen.Count; i++) + { + ((SpeichenSternStrahl)_alSpeichenStrahlen[i]).PrintCurrentSpeichenStrahl(); + } + CalcPossibleLines(); + } + + + + private ArrayList GetUmfang() + { + ArrayList UmfangLinien = new ArrayList(); + for (int i = 0; i < _alpnPoint.Count; i++) + { + PolyNode pnCurrent=(PolyNode)_alpnPoint[i]; + PolyNode pnNext; + structLinien TempLinien = new structLinien(); + + if ((i + 1) == _alpnPoint.Count) + pnNext = ((PolyNode)_alpnPoint[0]); + else + pnNext = ((PolyNode)_alpnPoint[i+1]); + + TempLinien.dLaenge = pnCurrent.Distance(pnNext); + TempLinien.iAnfangsPunkt = pnCurrent.iNodeIndex; + TempLinien.iEndPunkt = pnNext.iNodeIndex; + UmfangLinien.Add(TempLinien); + } + return UmfangLinien; + } + + public ArrayList GetAllPossibleLines() + { + return _alKantenPool; + } + private void CalcPossibleLines() + { + ArrayList alLinien = new ArrayList(); + + int counter = 0; + for (int i = 0; i < (_alpnPoint.Count); i++) + { + for (int j = i + 2; j < (_alpnPoint.Count - 1 + counter); j++) + { + PolyNode pnPointEins = (PolyNode)_alpnPoint[i]; + PolyNode pnPointZwei = (PolyNode)_alpnPoint[j]; + + structLinien strLinien = new structLinien(); + strLinien.iAnfangsPunkt = pnPointEins.iNodeIndex; + strLinien.iEndPunkt = pnPointZwei.iNodeIndex; + strLinien.dLaenge = pnPointEins.Distance(pnPointZwei); + if (strLinien.dLaenge > 0) // Noch Entfernen + alLinien.Add(strLinien); //Noch Entfernen + } + if (i == 0) + counter++; + } + + // ArrayList alLinienSortiert = (ArrayList)SortLines(alLinien); // Noch Entfernen + + // _alKantenPool = (ArrayList)LoescheKongruenz(_alpnPoint, alLinienSortiert); // Noch Entfernen + _alKantenPool = (ArrayList)SortLines(alLinien); + } + private ArrayList SortLines(ArrayList alLinien) + { + for (int i = (alLinien.Count - 1); i >= 0; i--) + for (int j = 1; j <= i; j++) + + if (((structLinien)alLinien[j - 1]).dLaenge < ((structLinien)alLinien[j]).dLaenge) + { + structLinien temp = (structLinien)alLinien[j - 1]; + alLinien[j - 1] = alLinien[j]; + alLinien[j] = temp; + } + + return alLinien; + } + + private bool TryLine(structLinien strLinie,PolyNode pnNodeEins, PolyNode pnZwei) + { + double dWinkel = pnNodeEins.GetWinkelPoint(pnZwei); + SpeichenSternStrahl alsssStrahl = (SpeichenSternStrahl)_alSpeichenStrahlen[pnNodeEins.iNodeIndex]; + + SpeichenSternNode strNeuStrahlBegin = new SpeichenSternNode(); + strNeuStrahlBegin.Blockiert = _alKantenPool.IndexOf(strLinie); + strNeuStrahlBegin.pnPunktPos = ((PolyNode)_alpnPoint[pnZwei.iNodeIndex]); + + strNeuStrahlBegin.dWinkel = ((SpeichenSternNode)alsssStrahl._alStrahlNodes[0]).pnPunktPos.GetWinkelPoint(strNeuStrahlBegin.pnPunktPos); + + SpeichenSternNode strNeuStrahlEnd = new SpeichenSternNode(); + strNeuStrahlEnd.Blockiert = _alKantenPool.IndexOf(strLinie); + strNeuStrahlEnd.pnPunktPos = ((PolyNode)_alpnPoint[pnNodeEins.iNodeIndex]); + strNeuStrahlEnd.dWinkel = ((SpeichenSternNode)alsssStrahl._alStrahlNodes[0]).pnPunktPos.GetWinkelPoint(strNeuStrahlEnd.pnPunktPos); + + SpeichenSternNode ssnElement; + for (int i = 0; i < alsssStrahl._alStrahlNodes.Count; i++) + { + ssnElement = (SpeichenSternNode)alsssStrahl._alStrahlNodes[i]; + + if (ssnElement.dWinkel > dWinkel) + { + if ((((SpeichenSternNode)alsssStrahl._alStrahlNodes[i - 1]).Blockiert) == cLeerValue) + return true; + else if ((((SpeichenSternNode)alsssStrahl._alStrahlNodes[i - 1]).Blockiert) == cTKValue) + return false; + if (alsssStrahl.PruefeDoppelteBlockierung(strNeuStrahlBegin, strNeuStrahlEnd)) + return true; + else + return false; + } + else if (ssnElement.dWinkel == dWinkel) + if (ssnElement.Blockiert == cLeerValue) + return true; + else if (ssnElement.Blockiert == cTKValue) + return false; + else + { + ArrayList alGesetzteKanten = alsssStrahl.GetGesetzteKanten(); + for (int j = 0; j < alGesetzteKanten.Count; j++) + { + SpeichenSternNode Temp = (SpeichenSternNode)alGesetzteKanten[j]; + if (Temp.dWinkel == dWinkel) + { + if (Temp.Blockiert == cLeerValue) + return true; + else if (Temp.Blockiert == cTKValue) + return false; + } + + } + if (alsssStrahl.PruefeDoppelteBlockierung(strNeuStrahlBegin, strNeuStrahlEnd)) + return true; + else + return false; + } + } + + if ((((SpeichenSternNode)alsssStrahl._alStrahlNodes[alsssStrahl._alStrahlNodes.Count - 1]).Blockiert) == cTKValue) + return false; + if (!alsssStrahl.PruefeDoppelteBlockierung(strNeuStrahlBegin, strNeuStrahlEnd)) + return false; + + return true; + } + + public bool TryToSetLinie(structLinien strLinie) + { + PolyNode pnAnfang = ((PolyNode)_alpnPoint[strLinie.iAnfangsPunkt]); + PolyNode pnEnde = ((PolyNode)_alpnPoint[strLinie.iEndPunkt]); + + if (!TryLine(strLinie, pnAnfang,pnEnde)) + return false; + if (!TryLine(strLinie, pnEnde,pnAnfang)) + return false; + + if (PruefeKongurent(_alpnPoint,strLinie)) + return false; + + SperrKante(strLinie.iAnfangsPunkt, strLinie.iEndPunkt, _alKantenPool.IndexOf(strLinie)); + + _alKantenInSpeichen.Add(strLinie); + return true; + } + + /* + + public bool TryToSetLinie(structLinien strLinie, bool bAddLine) + { + int iCounter = 0; + PolyNode AnfangsNode = ((PolyNode)_alpnPoint[strLinie.iAnfangsPunkt]); + PolyNode EndNode = ((PolyNode)_alpnPoint[strLinie.iEndPunkt]); + + double dWinkel = AnfangsNode.GetWinkelPoint(EndNode); + SpeichenSternStrahl alsssAnfangsPunkt = (SpeichenSternStrahl)_alSpeichenStrahlen[strLinie.iAnfangsPunkt]; + + bool bBlockiert; + + for (int i = 1; i < alsssAnfangsPunkt._alStrahlNodes.Count; i++) + { + if (((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i - 1]).Blockiert == cLeerValue) + bBlockiert = false; + else + bBlockiert = true; + + if (((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i]).dWinkel >= dWinkel) + if (bBlockiert) + if (((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i]).dWinkel == dWinkel) + if ((((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i]).Blockiert == cLeerValue) || + (((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i]).Blockiert == cTKValue)) + break; + else + // { + // iCounter++; + // break; + // } + return false; + else + return false; + else + break; + } + + dWinkel = EndNode.GetWinkelPoint(AnfangsNode); + SpeichenSternStrahl alsssEckEndPunkt = (SpeichenSternStrahl)_alSpeichenStrahlen[strLinie.iEndPunkt]; + + for (int i = 1; i < alsssEckEndPunkt._alStrahlNodes.Count; i++) + { + if (((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i - 1]).Blockiert == cLeerValue) + bBlockiert = false; + else + bBlockiert = true; + + if (((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i]).dWinkel >= dWinkel) + if (bBlockiert) + if (((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i]).dWinkel == dWinkel) + if ((((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i]).Blockiert == cLeerValue) || + (((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i]).Blockiert == cTKValue)) + break; + else + // { + // iCounter++; + // break; + // } + return false; + else + return false; + else + break; + } + if (iCounter == 2) + return false; + + int iKantenPool; + + if (!bAddLine) + iKantenPool = _alUmfangLinien.IndexOf(strLinie)+10000; + else + iKantenPool = _alKantenPool.IndexOf(strLinie); + + SperrKante(strLinie.iAnfangsPunkt, strLinie.iEndPunkt, iKantenPool); + + if (bAddLine) + _alKantenInSpeichen.Add(strLinie); + return true; + }*/ + public ArrayList GetGesetzteLinien() + { + return _alKantenInSpeichen; + } + + private void SperrKante(int iAnfangsEcke, int iEndEcke, int iKanteKantenPool) + { + for (int i = 0; i < _alSpeichenStrahlen.Count; i++) + if ((i != iAnfangsEcke) && (i != iEndEcke)) + { + ArrayList alEckStrahl = ((SpeichenSternStrahl)_alSpeichenStrahlen[i])._alStrahlNodes; + + SpeichenSternNode strNeuStrahlBegin = new SpeichenSternNode(); + strNeuStrahlBegin.Blockiert = iKanteKantenPool; + strNeuStrahlBegin.pnPunktPos = ((PolyNode)_alpnPoint[iAnfangsEcke]); + + strNeuStrahlBegin.dWinkel = ((SpeichenSternNode)alEckStrahl[0]).pnPunktPos.GetWinkelPoint(strNeuStrahlBegin.pnPunktPos); + + SpeichenSternNode strNeuStrahlEnd = new SpeichenSternNode(); + strNeuStrahlEnd.Blockiert = iKanteKantenPool; + strNeuStrahlEnd.pnPunktPos = ((PolyNode)_alpnPoint[iEndEcke]); + strNeuStrahlEnd.dWinkel = ((SpeichenSternNode)alEckStrahl[0]).pnPunktPos.GetWinkelPoint(strNeuStrahlEnd.pnPunktPos); + + if (strNeuStrahlEnd.dWinkel < strNeuStrahlBegin.dWinkel) + { + SpeichenSternNode Temp = strNeuStrahlBegin; + strNeuStrahlBegin = strNeuStrahlEnd; + strNeuStrahlEnd = Temp; + } + + if ((strNeuStrahlEnd.dWinkel - strNeuStrahlBegin.dWinkel) > 180) + { + SpeichenSternNode Temp = strNeuStrahlBegin; + strNeuStrahlBegin = strNeuStrahlEnd; + strNeuStrahlEnd = Temp; + } + SpeichenSternStrahl sssStrahl = (SpeichenSternStrahl)_alSpeichenStrahlen[i]; + + strNeuStrahlEnd.Blockiert = cUnbekannt; + if ((2== i)) + i = i; + if (sssStrahl.PruefeKorrigiereDoppelteBlockierung(strNeuStrahlBegin, strNeuStrahlEnd)) + { + sssStrahl.AddValueWinkel(strNeuStrahlBegin); + sssStrahl.AddValueWinkel(strNeuStrahlEnd); + sssStrahl.SetSperrSektorenNeu(strNeuStrahlBegin, strNeuStrahlEnd); + } + } + } + + public void PrintStern() + { + for (int i = 0; i < _alSpeichenStrahlen.Count; i++) + ((SpeichenSternStrahl)_alSpeichenStrahlen[i]).PrintCurrentSpeichenStrahl(); + } + + /* private ArrayList LoescheKongruenz(ArrayList alpnEckPoint, ArrayList alLinien) + { + ArrayList alUmfang = new ArrayList(); + + ArrayList alPossibleKongurent = new ArrayList(); + for (int i = 0; i < alpnEckPoint.Count; i++) + { + PolyNode pnEckPointEins = (PolyNode)alpnEckPoint[i]; + PolyNode pnEckPointZwei; + if ((i + 1) < alpnEckPoint.Count) + pnEckPointZwei = (PolyNode)alpnEckPoint[i + 1]; + else + pnEckPointZwei = (PolyNode)alpnEckPoint[0]; + + alUmfang.Add(pnEckPointEins.Distance(pnEckPointZwei)); + } + + for (int i = 0; i < alLinien.Count; i++) + if (alUmfang.Contains((((structLinien)alLinien[i]).dLaenge))) + alPossibleKongurent.Add(alLinien[i]); + + for (int i = 0; i < alPossibleKongurent.Count; i++) + { + structLinien strLinie = (structLinien)alPossibleKongurent[i]; + + PolyNode pnAnfang = (PolyNode)_alpnPoint[strLinie.iAnfangsPunkt]; + PolyNode pnEnde = (PolyNode)_alpnPoint[strLinie.iEndPunkt]; + + Line2d Line = new Line2d(pnAnfang.p2DPoint, pnEnde.p2DPoint); + + for (int j = 0; j < _alpnPoint.Count; j++) + { + PolyNode pnEckAnfang; + PolyNode pnEckEnde; + + pnEckAnfang = ((PolyNode)_alpnPoint[j]); + + if ((j + 1) == _alpnPoint.Count) + pnEckEnde = ((PolyNode)_alpnPoint[0]); + else + pnEckEnde = ((PolyNode)_alpnPoint[j + 1]); + + Line2d LineUmfang = new Line2d(pnEckAnfang.p2DPoint, pnEckEnde.p2DPoint); + Line2d LineUmfang2 = new Line2d(pnEckEnde.p2DPoint, pnEckAnfang.p2DPoint); + + if ((LineUmfang.IsEqualTo(Line)) || (LineUmfang2.IsEqualTo(Line))) + { + alLinien.Remove(alPossibleKongurent[i]); + alPossibleKongurent.RemoveAt(i); + i = i - 1; + break; + } + } + } + return alLinien; + }*/ + + private bool PruefeKongurent(ArrayList alpnEckPoint, structLinien strLinien) + { + ArrayList alUmfang = new ArrayList(); + + ArrayList alPossibleKongurent = new ArrayList(); + for (int i = 0; i < alpnEckPoint.Count; i++) + { + PolyNode pnEckPointEins = (PolyNode)alpnEckPoint[i]; + PolyNode pnEckPointZwei; + if ((i + 1) < alpnEckPoint.Count) + pnEckPointZwei = (PolyNode)alpnEckPoint[i + 1]; + else + pnEckPointZwei = (PolyNode)alpnEckPoint[0]; + + alUmfang.Add(pnEckPointEins.Distance(pnEckPointZwei)); + } + + if (alUmfang.Contains((strLinien.dLaenge))) + alPossibleKongurent.Add(strLinien); + + for(int i = 0; i < alPossibleKongurent.Count; i++) + { + structLinien strLinie = (structLinien)alPossibleKongurent[i]; + + PolyNode pnAnfang = (PolyNode)_alpnPoint[strLinie.iAnfangsPunkt]; + PolyNode pnEnde = (PolyNode)_alpnPoint[strLinie.iEndPunkt]; + + Line2d Line = new Line2d(pnAnfang.p2DPoint, pnEnde.p2DPoint); + + for(int j = 0; j < _alpnPoint.Count;j++) + { + PolyNode pnEckAnfang; + PolyNode pnEckEnde; + + pnEckAnfang = ((PolyNode)_alpnPoint[j]); + + if ((j+1) == _alpnPoint.Count) + pnEckEnde = ((PolyNode)_alpnPoint[0]); + else + pnEckEnde = ((PolyNode)_alpnPoint[j + 1]); + + Line2d LineUmfang = new Line2d(pnEckAnfang.p2DPoint, pnEckEnde.p2DPoint); + Line2d LineUmfang2 = new Line2d(pnEckEnde.p2DPoint, pnEckAnfang.p2DPoint); + + if ((LineUmfang.IsEqualTo(Line)) || (LineUmfang2.IsEqualTo(Line))) + { + return true; + } + } + } + return false; + } + } +} -- cgit v1.2.3