diff options
Diffstat (limited to 'Master/CGuCAD/projects/Markus/SpeichenStern.cs')
| -rw-r--r-- | Master/CGuCAD/projects/Markus/SpeichenStern.cs | 469 |
1 files changed, 469 insertions, 0 deletions
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;
+ }
+ }
+}
|