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 --- .../projects/Markus/AbschlusArbeiterklasse.cs | 48 ++ Master/CGuCAD/projects/Markus/Abschluss.cs | 369 +++++++++++ Master/CGuCAD/projects/Markus/Commands.cs | 46 ++ Master/CGuCAD/projects/Markus/PolyNode.cs | 55 ++ Master/CGuCAD/projects/Markus/Praktikum.csproj | 107 +++ .../CGuCAD/projects/Markus/Praktikum.csproj.user | 24 + .../projects/Markus/Properties/AssemblyInfo.cs | 86 +++ Master/CGuCAD/projects/Markus/SpeichenStern.cs | 469 +++++++++++++ Master/CGuCAD/projects/Markus/SpeichenSternNode.cs | 17 + .../CGuCAD/projects/Markus/SpeichenSternStrahl.cs | 729 +++++++++++++++++++++ 10 files changed, 1950 insertions(+) create mode 100644 Master/CGuCAD/projects/Markus/AbschlusArbeiterklasse.cs create mode 100644 Master/CGuCAD/projects/Markus/Abschluss.cs create mode 100644 Master/CGuCAD/projects/Markus/Commands.cs create mode 100644 Master/CGuCAD/projects/Markus/PolyNode.cs create mode 100644 Master/CGuCAD/projects/Markus/Praktikum.csproj create mode 100644 Master/CGuCAD/projects/Markus/Praktikum.csproj.user create mode 100644 Master/CGuCAD/projects/Markus/Properties/AssemblyInfo.cs create mode 100644 Master/CGuCAD/projects/Markus/SpeichenStern.cs create mode 100644 Master/CGuCAD/projects/Markus/SpeichenSternNode.cs create mode 100644 Master/CGuCAD/projects/Markus/SpeichenSternStrahl.cs (limited to 'Master/CGuCAD/projects/Markus') diff --git a/Master/CGuCAD/projects/Markus/AbschlusArbeiterklasse.cs b/Master/CGuCAD/projects/Markus/AbschlusArbeiterklasse.cs new file mode 100644 index 0000000..2027761 --- /dev/null +++ b/Master/CGuCAD/projects/Markus/AbschlusArbeiterklasse.cs @@ -0,0 +1,48 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; +using Autodesk.AutoCAD.Geometry; + +namespace Praktikum +{ + class AbschlusArbeiterklasse + { + public ArrayList GetLinien(PolyNode[] pnPolyNodes) + { + ArrayList P2D = new ArrayList(); + + for (int i = 0; i < pnPolyNodes.Length; i++) + P2D.Add(pnPolyNodes[i]); + + + + SpeichenStern SPStern = new SpeichenStern(P2D); + ArrayList alTest = SPStern.GetAllPossibleLines(); + + + int iCounter = alTest.Count - 1; + ArrayList alErgebnisse = new ArrayList(); + for (int i = iCounter; i >= 0; --i) + { + // if (i == 19) + // i = i; + if (2 == i) + i = i; + //break; + + if ((SPStern.TryToSetLinie((structLinien)alTest[i]))) + { + SPStern.PrintStern(); + alErgebnisse.Add(i); + } + } + + // SPStern.RemoveOverlap(); + + + return SPStern.GetGesetzteLinien(); + + } + } +} diff --git a/Master/CGuCAD/projects/Markus/Abschluss.cs b/Master/CGuCAD/projects/Markus/Abschluss.cs new file mode 100644 index 0000000..73dd3dc --- /dev/null +++ b/Master/CGuCAD/projects/Markus/Abschluss.cs @@ -0,0 +1,369 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Autodesk.AutoCAD.Runtime; +using Autodesk.AutoCAD.DatabaseServices; +using Autodesk.AutoCAD.ApplicationServices; +using Autodesk.AutoCAD.EditorInput; +using Autodesk.AutoCAD.Geometry; +using System.Collections; + +namespace Praktikum +{ + + public struct structLinien + { + public int iAnfangsPunkt; + public int iEndPunkt; + public double dLaenge; + } + class Abschluss + { + public struct structEckPoint + { + public int iPolyPos; + public Point2d p2Eckpunkt; + } + + public struct structFlaeche + { + public Point3d PunktA; + public Point3d PunktB; + public Point3d PunktC; + } + + public void Main() + { + /* Line2d Linie = new Line2d(new Point2d(0,0),new Point2d(0,10)); + + Vector3d AnfangsPunkt = new Vector3d(0, 0, 1); + Vector3d EndPunkt = new Vector3d(10, 0, 1); + Vector3d Normale = AnfangsPunkt.CrossProduct(EndPunkt); + + Vector3d Punkt = new Vector3d(5, 5, 1); + double Value = Normale.DotProduct(Punkt); + */ + + CreateTriangle(getTriangPolyLine()); + } + + private bool CreateTriangle(ObjectId objPolyObject) + { + Editor ed = Application.DocumentManager.MdiActiveDocument.Editor; + ed.WriteMessage("Traingeln!!!!!"); + + Database db = Application.DocumentManager.MdiActiveDocument.Database; + Autodesk.AutoCAD.DatabaseServices.TransactionManager tm = db.TransactionManager; + Transaction transaction = tm.StartTransaction(); + BlockTable blockTable = (BlockTable)tm.GetObject(db.BlockTableId, OpenMode.ForRead, false); + BlockTableRecord blockTableRecord = (BlockTableRecord)tm.GetObject(blockTable[BlockTableRecord.ModelSpace], OpenMode.ForWrite, false); + + Polyline polPoliline; + try + { + polPoliline = (Polyline)tm.GetObject(objPolyObject, OpenMode.ForWrite, false); + } + catch + { + ed.WriteMessage("\nDas ist keine Polyline;)!!!!!"); + return false; + } + + int iEcken = polPoliline.NumberOfVertices - 1; + + if (polPoliline.GetPoint2dAt(0) != polPoliline.GetPoint2dAt(iEcken)) + { + ed.WriteMessage("\nLinie nicht geschlossen ;(!!!!!"); + return false; + } + + PolyNode[] pnEckpunkte = new PolyNode[iEcken]; + + for (int i = 0; i < (iEcken); i++) + { + pnEckpunkte[i] = new PolyNode(); + pnEckpunkte[i].iNodeIndex = i; + pnEckpunkte[i].p2DPoint = polPoliline.GetPoint2dAt(i); + } + + AbschlusArbeiterklasse ABArbeiter = new AbschlusArbeiterklasse(); + + ArrayList alLinien = ABArbeiter.GetLinien(pnEckpunkte); + + + createLayer("Triang"); + LinienZeichnen(ref blockTableRecord, ref tm, alLinien, pnEckpunkte); + // Flaechenzeichnen(ref blockTableRecord, ref tm, "Triang", alLinien, pnEckpunkte); + transaction.Commit(); + return true; + } + private void LinienZeichnen(ref BlockTableRecord blockTableRecord, ref Autodesk.AutoCAD.DatabaseServices.TransactionManager tm, ArrayList alLinien, PolyNode[] pnEckpunkte) + { + for (int i = 0; i < alLinien.Count; i++) + { + + Point2d PunktEins = pnEckpunkte[(((structLinien)alLinien[i]).iAnfangsPunkt)].p2DPoint; + Point2d PunktZwei = pnEckpunkte[(((structLinien)alLinien[i]).iEndPunkt)].p2DPoint; + + + Face FlaecheA = new Face(new Point3d(PunktEins.X, PunktEins.Y, 0), new Point3d(PunktZwei.X, PunktZwei.Y, 0), new Point3d(PunktEins.X, PunktEins.Y, 0), true, true, true, true); + + + blockTableRecord.AppendEntity(FlaecheA); + tm.AddNewlyCreatedDBObject(FlaecheA, true); + + } + } + private void Flaechenzeichnen(ref BlockTableRecord blockTableRecord, ref Autodesk.AutoCAD.DatabaseServices.TransactionManager tm, string sLayer, ArrayList alLinien, PolyNode[] pnEckpunkte) + { + int iFarbe = 99; + + + ArrayList alEckpunkte = new ArrayList(); + + for (int i = 0; i < pnEckpunkte.Length; i++) + alEckpunkte.Add(pnEckpunkte[i]); + + structFlaeche[] strFaceSeiten = new structFlaeche[alLinien.Count + 1]; + + int count = 0; + + for (int i = 0; i < alEckpunkte.Count; i++) + { + if (alLinien.Count == 0) + break; + + bool bEckpunkt = true; + + for (int j = 0; j < alLinien.Count; j++) + { + int iAnfangsPunkt = ((structLinien)alLinien[j]).iAnfangsPunkt; + int iEndPunkt = ((structLinien)alLinien[j]).iEndPunkt; + + if ((((PolyNode)pnEckpunkte[i]).iNodeIndex == iAnfangsPunkt) || (((PolyNode)pnEckpunkte[i]).iNodeIndex == iEndPunkt)) + { + bEckpunkt = false; + break; + } + } + + if (bEckpunkt) + { + strFaceSeiten[count].PunktA = getPoint(alEckpunkte, i); + + int iPosVorne = 0; + int iPosHinten = alEckpunkte.Count - 1; + + if ((i + 1) != alEckpunkte.Count - 1) + iPosVorne = i + 1; + if ((i - 1) >= 0) + iPosHinten = i - 1; + + strFaceSeiten[count].PunktB = getPoint(alEckpunkte, iPosVorne); + strFaceSeiten[count].PunktC = getPoint(alEckpunkte, iPosHinten); + count++; + + for (int j = 0; j < alLinien.Count; j++) + { + int iAnfangsPunkt = ((structLinien)alLinien[j]).iAnfangsPunkt; + int iEndPunkt = ((structLinien)alLinien[j]).iEndPunkt; + + if ((Pruefen(alEckpunkte, iPosHinten, iAnfangsPunkt)) || + (Pruefen(alEckpunkte, iPosHinten, iEndPunkt))) + if ((Pruefen(alEckpunkte, iPosVorne, iAnfangsPunkt)) || + (Pruefen(alEckpunkte, iPosVorne, iEndPunkt))) + { + alLinien.RemoveAt(j); + j = 0; + break; + } + + + } + alEckpunkte.RemoveAt(i); + i = -1; + + } + } + strFaceSeiten[strFaceSeiten.Length - 1] = getRestFace(alEckpunkte); + + for (int i = 0; i < strFaceSeiten.Length; i++) + Seite(strFaceSeiten[i], ref blockTableRecord, ref tm, "Triang", iFarbe); + } + private structFlaeche getRestFace(ArrayList alEckpunkte) + { + structFlaeche strFlaeche = new structFlaeche(); + strFlaeche.PunktA = new Point3d(((PolyNode)alEckpunkte[0]).p2DPoint.X, ((PolyNode)alEckpunkte[0]).p2DPoint.Y, 0); + strFlaeche.PunktB = new Point3d(((PolyNode)alEckpunkte[1]).p2DPoint.X, ((PolyNode)alEckpunkte[1]).p2DPoint.Y, 0); + strFlaeche.PunktC = new Point3d(((PolyNode)alEckpunkte[2]).p2DPoint.X, ((PolyNode)alEckpunkte[2]).p2DPoint.Y, 0); + return strFlaeche; + } + private bool Pruefen(ArrayList alEckpunkte, int Index, int iPruefwert) + { + if (((PolyNode)alEckpunkte[Index]).iNodeIndex == iPruefwert) + return true; + else + return false; + } + private Point3d getPoint(ArrayList alEckpunkte, int iIndex) + { + Point3d Temp = new Point3d(((PolyNode)alEckpunkte[iIndex]).p2DPoint.X, ((PolyNode)alEckpunkte[iIndex]).p2DPoint.Y, 0); + return Temp; + } + + private void Seite(structFlaeche Flaeche, ref BlockTableRecord blockTableRecord, ref Autodesk.AutoCAD.DatabaseServices.TransactionManager tm, string sLayer, int color) + { + Face FlaecheA = new Face(Flaeche.PunktA, Flaeche.PunktB, Flaeche.PunktC, true, true, true, true); + FlaecheA.Layer = sLayer; + FlaecheA.ColorIndex = color; + blockTableRecord.AppendEntity(FlaecheA); + tm.AddNewlyCreatedDBObject(FlaecheA, true); + } + private ArrayList getLinien(ArrayList alLinien, Polyline polPoliline) + { + ArrayList alGoodLines = new ArrayList(); + int iFoundLines = 0; + + for (int i = alLinien.Count - 1; 0 < i; i--) + { + bool bSchneidet = false; + + for (int j = 0; j < alGoodLines.Count; j++) + { + Point2d Punkt1Linie1 = polPoliline.GetPoint2dAt(((structLinien)alGoodLines[j]).iAnfangsPunkt); + Point2d Punkt2Linie1 = polPoliline.GetPoint2dAt(((structLinien)alGoodLines[j]).iEndPunkt); + Point2d Punkt1Linie2 = polPoliline.GetPoint2dAt(((structLinien)alLinien[i]).iAnfangsPunkt); + Point2d Punkt2Linie2 = polPoliline.GetPoint2dAt(((structLinien)alLinien[i]).iEndPunkt); + + bSchneidet = Schnittpunkt(Punkt1Linie1, Punkt2Linie1, Punkt1Linie2, Punkt2Linie2); + if (bSchneidet == true) + break; + } + + if (!(bSchneidet)) + { + alGoodLines.Add((structLinien)alLinien[i]); + iFoundLines++; + } + + if ((polPoliline.NumberOfVertices - 4) == iFoundLines) + break; + } + return alGoodLines; + } + private bool Schnittpunkt(Point2d Punkt1Linien1, Point2d Punkt2Linien1, Point2d Punkt1Linien2, Point2d Punkt2Linien2) + { + Vector3d VecLinieEinsAnfang = new Vector3d(Punkt1Linien1.X, Punkt1Linien1.Y, 1); + Vector3d VecLinieEinsEnde = new Vector3d(Punkt2Linien1.X, Punkt2Linien1.Y, 1); + Vector3d VecLinieZweiAnfang = new Vector3d(Punkt1Linien2.X, Punkt1Linien2.Y, 1); + Vector3d VecLinieZweiEnde = new Vector3d(Punkt2Linien2.X, Punkt2Linien2.Y, 1); + + Vector3d NormaleEins = VecLinieEinsAnfang.CrossProduct(VecLinieEinsEnde); + Vector3d NormaleZwei = VecLinieZweiAnfang.CrossProduct(VecLinieZweiEnde); + + Vector3d Schnittpunkt = NormaleEins.CrossProduct(NormaleZwei); + + Schnittpunkt = new Vector3d(Schnittpunkt.X / Schnittpunkt.Z, Schnittpunkt.Y / Schnittpunkt.Z, Schnittpunkt.Z / Schnittpunkt.Z); + + Point2d P2DSchnittpunkt = new Point2d(Schnittpunkt.X, Schnittpunkt.Y); + + if (VecLinieEinsAnfang != VecLinieZweiAnfang) + if (VecLinieEinsEnde != VecLinieZweiAnfang) + if (VecLinieEinsAnfang != VecLinieZweiEnde) + if (VecLinieEinsEnde != VecLinieZweiEnde) + { + bool bErgebnis = IstDrauf(Punkt1Linien1, Punkt2Linien1, P2DSchnittpunkt); + + if (bErgebnis) + return true; + bErgebnis = IstDrauf(Punkt1Linien1, Punkt2Linien1, P2DSchnittpunkt); + if (bErgebnis) + return true; + } + return false; + } + + public bool IstDrauf(Point2d Anfang, Point2d Ende, Point2d Endpunkt) + { + double LinieDist = Distance(Anfang, Ende); + double ErsteDist = Distance(Anfang, Endpunkt); + double ZweiteDist = Distance(Ende, Endpunkt); + if ((ErsteDist + ZweiteDist) == LinieDist) + return true; + else + return false; + } + + 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 ObjectId getTriangPolyLine() + { + Editor ed = Application.DocumentManager.MdiActiveDocument.Editor; + + Editor editor = Application.DocumentManager.MdiActiveDocument.Editor; + PromptEntityOptions options = new PromptEntityOptions("\nWähle die Polyline"); + PromptEntityResult result = editor.GetEntity(options); + + return result.ObjectId; + } + private double Distance(Point2d p2dPunktEins, Point2d p2dPunktZwei) + { + double xDist = (p2dPunktEins.X - p2dPunktZwei.X); + double yDist = (p2dPunktEins.Y - p2dPunktZwei.Y); + + return (Math.Sqrt(xDist * xDist + yDist * yDist)); + } + public void createLayer(string sLayer) + { + Database db = Application.DocumentManager.MdiActiveDocument.Database; + Autodesk.AutoCAD.DatabaseServices.TransactionManager tm = db.TransactionManager; + Transaction transaction = tm.StartTransaction(); + Editor editor = Application.DocumentManager.MdiActiveDocument.Editor; + + try + {// gettheLayerTable + LayerTable layerTable = (LayerTable)tm.GetObject(db.LayerTableId, OpenMode.ForRead, false); + // check iflayerisalreadythere + if (!layerTable.Has(sLayer)) + { + LayerTableRecord layerTableRecord = new LayerTableRecord(); + layerTableRecord.Name = sLayer; + layerTableRecord.IsFrozen = false; + // layersetto + layerTableRecord.IsOff = false; + // layersetto ON + layerTableRecord.IsLocked = false; + // layerun-locked + layerTableRecord.Color = Autodesk.AutoCAD.Colors.Color.FromColorIndex(Autodesk.AutoCAD.Colors.ColorMethod.ByAci, 50); + // setlayercolorto red + // Now, addthenewlayerto itscontainer + layerTable.UpgradeOpen(); + layerTable.Add(layerTableRecord); + tm.AddNewlyCreatedDBObject(layerTableRecord, true); + } + else + { + editor.WriteMessage("\n" + sLayer + " Layer gibt es schon"); + } + transaction.Commit(); + } + catch (Autodesk.AutoCAD.Runtime.Exception) + { + transaction.Dispose(); + } + } + + } +} diff --git a/Master/CGuCAD/projects/Markus/Commands.cs b/Master/CGuCAD/projects/Markus/Commands.cs new file mode 100644 index 0000000..8a48f78 --- /dev/null +++ b/Master/CGuCAD/projects/Markus/Commands.cs @@ -0,0 +1,46 @@ +// (C) Copyright 2002-2007 by Autodesk, Inc. +// +// Permission to use, copy, modify, and distribute this software in +// object code form for any purpose and without fee is hereby granted, +// provided that the above copyright notice appears in all copies and +// that both that copyright notice and the limited warranty and +// restricted rights notice below appear in all supporting +// documentation. +// +// AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS. +// AUTODESK SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF +// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE. AUTODESK, INC. +// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE +// UNINTERRUPTED OR ERROR FREE. +// +// Use, duplication, or disclosure by the U.S. Government is subject to +// restrictions set forth in FAR 52.227-19 (Commercial Computer +// Software - Restricted Rights) and DFAR 252.227-7013(c)(1)(ii) +// (Rights in Technical Data and Computer Software), as applicable. +// + +using System; +using Autodesk.AutoCAD.Runtime; +using Autodesk.AutoCAD.DatabaseServices; +using Autodesk.AutoCAD.ApplicationServices; +using Autodesk.AutoCAD.EditorInput; +using Autodesk.AutoCAD.Geometry; + +[assembly: CommandClass(typeof(Praktikum.MGCommands))] + +namespace Praktikum +{ + /// + /// Summary description for MGCommands. + /// + public class MGCommands + { + + [CommandMethod("1")] + static public void Abschluss() // This method can have any name + { + Abschluss Ab = new Abschluss(); + Ab.Main(); + } + } +} diff --git a/Master/CGuCAD/projects/Markus/PolyNode.cs b/Master/CGuCAD/projects/Markus/PolyNode.cs new file mode 100644 index 0000000..1eb5d56 --- /dev/null +++ b/Master/CGuCAD/projects/Markus/PolyNode.cs @@ -0,0 +1,55 @@ +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 PolyNode + { + public int iNodeIndex; + public Point2d p2DPoint; + + public double GetWinkelPoint(PolyNode ZielPunkt) + { + return GetWinkelPoint(ZielPunkt.p2DPoint); + } + + public double GetWinkelPoint(Point2d ZielPunkt) + { + return CalcAngle(GetAnglePointToPoint(p2DPoint, ZielPunkt)); + } + + private double CalcAngle(double dRadiant) + { + double RotationsWinkelGrad = dRadiant * 180.0f / Math.PI; + + if (RotationsWinkelGrad < 0) + return 360 + RotationsWinkelGrad; + else + return RotationsWinkelGrad; + } + + private double GetAnglePointToPoint(Point2d PAusgangspunkt, Point2d PKreispunkt) + { + return (double)(Math.Atan2((double)(PKreispunkt.Y - PAusgangspunkt.Y), (double)(PKreispunkt.X - PAusgangspunkt.X))); + } + + public double Distance(Point2d p2dPunkt) + { + double xDist = (p2dPunkt.X - p2DPoint.X); + double yDist = (p2dPunkt.Y - p2DPoint.Y); + + return (Math.Sqrt(xDist * xDist + yDist * yDist)); + } + + public double Distance(PolyNode p2dPunkt) + { + return Distance(p2dPunkt.p2DPoint); + } + } +} + diff --git a/Master/CGuCAD/projects/Markus/Praktikum.csproj b/Master/CGuCAD/projects/Markus/Praktikum.csproj new file mode 100644 index 0000000..3eb391f --- /dev/null +++ b/Master/CGuCAD/projects/Markus/Praktikum.csproj @@ -0,0 +1,107 @@ + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {830A3C7E-F0B2-4484-B5BC-1AB3BED22E05} + Library + Properties + Praktikum + Praktikum1 + v3.0 + {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + 3.5 + + + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + False + C:\Programme\AutoCAD 2007\acdbmgd.dll + + + False + c:\programme\AutoCAD 2007\acmgd.dll + False + + + + + + + + + + + + + + + + + + False + .NET Framework 2.0 %28x86%29 + false + + + False + .NET Framework 3.0 %28x86%29 + true + + + False + .NET Framework 3.5 + false + + + False + Windows Installer 3.1 + true + + + + + + \ No newline at end of file diff --git a/Master/CGuCAD/projects/Markus/Praktikum.csproj.user b/Master/CGuCAD/projects/Markus/Praktikum.csproj.user new file mode 100644 index 0000000..f581f15 --- /dev/null +++ b/Master/CGuCAD/projects/Markus/Praktikum.csproj.user @@ -0,0 +1,24 @@ + + + Program + C:\Program Files\AutoCAD 2010\acad.exe + + + Program + c:\Program Files\AutoCADacad.exe + + + + + + + + + + + + + de-DE + false + + \ No newline at end of file diff --git a/Master/CGuCAD/projects/Markus/Properties/AssemblyInfo.cs b/Master/CGuCAD/projects/Markus/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..f36d8df --- /dev/null +++ b/Master/CGuCAD/projects/Markus/Properties/AssemblyInfo.cs @@ -0,0 +1,86 @@ +// (C) Copyright 2002-2007 by Autodesk, Inc. +// +// Permission to use, copy, modify, and distribute this software in +// object code form for any purpose and without fee is hereby granted, +// provided that the above copyright notice appears in all copies and +// that both that copyright notice and the limited warranty and +// restricted rights notice below appear in all supporting +// documentation. +// +// AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS. +// AUTODESK SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF +// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE. AUTODESK, INC. +// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE +// UNINTERRUPTED OR ERROR FREE. +// +// Use, duplication, or disclosure by the U.S. Government is subject to +// restrictions set forth in FAR 52.227-19 (Commercial Computer +// Software - Restricted Rights) and DFAR 252.227-7013(c)(1)(ii) +// (Rights in Technical Data and Computer Software), as applicable. +// + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +// +[assembly: AssemblyTitle("")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("")] +[assembly: AssemblyCopyright("Copyright © ")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Revision and Build Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] + +[assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyFileVersion("1.0.*")] + +// +// In order to sign your assembly you must specify a key to use. Refer to the +// Microsoft .NET Framework documentation for more information on assembly signing. +// +// Use the attributes below to control which key is used for signing. +// +// Notes: +// (*) If no key is specified, the assembly is not signed. +// (*) KeyName refers to a key that has been installed in the Crypto Service +// Provider (CSP) on your machine. KeyFile refers to a file which contains +// a key. +// (*) If the KeyFile and the KeyName values are both specified, the +// following processing occurs: +// (1) If the KeyName can be found in the CSP, that key is used. +// (2) If the KeyName does not exist and the KeyFile does exist, the key +// in the KeyFile is installed into the CSP and used. +// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility. +// When specifying the KeyFile, the location of the KeyFile should be +// relative to the project output directory which is +// %Project Directory%\obj\. For example, if your KeyFile is +// located in the project directory, you would specify the AssemblyKeyFile +// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")] +// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework +// documentation for more information on this. +// +[assembly: AssemblyDelaySign(false)] +[assembly: AssemblyKeyFile("")] +[assembly: AssemblyKeyName("")] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("10D818CC-E15B-4A88-B4F5-C2262A6F478B")] +[assembly: ComVisibleAttribute(false)] 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; + } + } +} diff --git a/Master/CGuCAD/projects/Markus/SpeichenSternNode.cs b/Master/CGuCAD/projects/Markus/SpeichenSternNode.cs new file mode 100644 index 0000000..fb3d4f6 --- /dev/null +++ b/Master/CGuCAD/projects/Markus/SpeichenSternNode.cs @@ -0,0 +1,17 @@ +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 SpeichenSternNode + { + public PolyNode pnPunktPos; + public double dWinkel; + public int Blockiert; + } +} diff --git a/Master/CGuCAD/projects/Markus/SpeichenSternStrahl.cs b/Master/CGuCAD/projects/Markus/SpeichenSternStrahl.cs new file mode 100644 index 0000000..638a0d3 --- /dev/null +++ b/Master/CGuCAD/projects/Markus/SpeichenSternStrahl.cs @@ -0,0 +1,729 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; +using Autodesk.AutoCAD.Geometry; +using System.IO; +using System.Globalization; +using Autodesk.AutoCAD.EditorInput; +using Autodesk.AutoCAD.ApplicationServices; + +namespace Praktikum +{ + class SpeichenSternStrahl + { + const int cTKValue = -1; // TK -1; + const int cLeerValue = -1000; // -666 = Leer + const int cUnbekannt = -2000; // Unbekannt + const double dMainWinkelConst = 0; + + private int _iSternNode; + public bool bAusenkante = false; // 1 Mit dem Uhrzeigersinn // -1 Gegen dem Uhrzeigersinn + + public ArrayList _alStrahlNodes = new ArrayList(); + + private ArrayList _AlleGesetztenKanten = new ArrayList(); + + + public SpeichenSternStrahl(PolyNode Incoming, PolyNode Outcoming, PolyNode MainNode, int iSternNode) + { + _iSternNode = iSternNode; + SpeichenSternNode ssnStrahlNullPunkt = new SpeichenSternNode(); + ssnStrahlNullPunkt.dWinkel = dMainWinkelConst; + ssnStrahlNullPunkt.pnPunktPos = MainNode; + + SpeichenSternNode ssnStrahlEingehenderPunkt = new SpeichenSternNode(); + SpeichenSternNode ssnStrahlAusgehenderPunkt = new SpeichenSternNode(); + ssnStrahlEingehenderPunkt.pnPunktPos = Incoming; + ssnStrahlEingehenderPunkt.dWinkel = MainNode.GetWinkelPoint(Incoming); + ssnStrahlAusgehenderPunkt.pnPunktPos = Outcoming; + ssnStrahlAusgehenderPunkt.dWinkel = MainNode.GetWinkelPoint(Outcoming); + + if (ssnStrahlEingehenderPunkt.dWinkel < ssnStrahlAusgehenderPunkt.dWinkel) + { + SpeichenSternNode Temp = ssnStrahlEingehenderPunkt; + ssnStrahlEingehenderPunkt = ssnStrahlAusgehenderPunkt; + ssnStrahlAusgehenderPunkt = Temp; + } + + bool bDrehen = false; + + if (ssnStrahlNullPunkt.pnPunktPos.iNodeIndex == 0) + { + if ((ssnStrahlAusgehenderPunkt.pnPunktPos.iNodeIndex) > (ssnStrahlEingehenderPunkt.pnPunktPos.iNodeIndex)) + bDrehen = false; // OK für -1 + else + bDrehen = true; // OK für -1 + + } + else + { + if ((ssnStrahlNullPunkt.pnPunktPos.iNodeIndex > ssnStrahlEingehenderPunkt.pnPunktPos.iNodeIndex) + && (ssnStrahlNullPunkt.pnPunktPos.iNodeIndex > ssnStrahlAusgehenderPunkt.pnPunktPos.iNodeIndex)) + bDrehen = false; // hier + + else + if (ssnStrahlAusgehenderPunkt.pnPunktPos.iNodeIndex > ssnStrahlEingehenderPunkt.pnPunktPos.iNodeIndex) + bDrehen = true; + else + bDrehen = false; + } + + if (bDrehen == true ) + { + SpeichenSternNode Temp = ssnStrahlEingehenderPunkt; + ssnStrahlEingehenderPunkt = ssnStrahlAusgehenderPunkt; + ssnStrahlAusgehenderPunkt = Temp; + } + + ssnStrahlEingehenderPunkt.Blockiert = cTKValue; + ssnStrahlAusgehenderPunkt.Blockiert = cLeerValue; + + if (ssnStrahlEingehenderPunkt.dWinkel > ssnStrahlAusgehenderPunkt.dWinkel) + { + ssnStrahlNullPunkt.Blockiert = cTKValue; + bAusenkante = true; + } + else + ssnStrahlNullPunkt.Blockiert = cLeerValue; + + + if (ssnStrahlEingehenderPunkt.dWinkel == ssnStrahlNullPunkt.dWinkel) + ssnStrahlNullPunkt.Blockiert = ssnStrahlEingehenderPunkt.Blockiert; + + AddValueWinkel(ssnStrahlNullPunkt); + AddValueWinkel(ssnStrahlEingehenderPunkt); + AddValueWinkel(ssnStrahlAusgehenderPunkt); + } + + public ArrayList GetGesetzteKanten() + { + return _AlleGesetztenKanten; + } + + public bool SetSperrSektorenNeu(SpeichenSternNode ssnNeuStrahlBegin, SpeichenSternNode ssnNeuStrahlEnd) + { + int iAnfangIndex = -1; + int iEndIndex = -1; + for (int i = 0; i < _alStrahlNodes.Count; i++) + { + if (((SpeichenSternNode)_alStrahlNodes[i]).dWinkel == ssnNeuStrahlBegin.dWinkel) + { + iAnfangIndex = i; + break; + } + } + for (int i = 0; i < _alStrahlNodes.Count; i++) + { + if (((SpeichenSternNode)_alStrahlNodes[i]).dWinkel == ssnNeuStrahlEnd.dWinkel) + { + iEndIndex = i; + break; + } + } + if ((iAnfangIndex < 0) || (iEndIndex < 0)) + return false; + + int iBlockiertEnde = ((SpeichenSternNode)_alStrahlNodes[iEndIndex]).Blockiert; + + if (ssnNeuStrahlEnd.pnPunktPos.p2DPoint.IsEqualTo(((SpeichenSternNode)_alStrahlNodes[0]).pnPunktPos.p2DPoint)) + { + SpeichenSternNode Temp = new SpeichenSternNode(); + Temp.dWinkel = ssnNeuStrahlBegin.dWinkel+0.000000000001; + Temp.pnPunktPos = ssnNeuStrahlBegin.pnPunktPos; + + for (int j = 0; j < _AlleGesetztenKanten.Count; j++) + { + SpeichenSternNode aanAlleSub = (SpeichenSternNode)_AlleGesetztenKanten[j]; + if (aanAlleSub.dWinkel == ssnNeuStrahlBegin.dWinkel) + { + Temp.Blockiert = aanAlleSub.Blockiert; + break; + } + + } + + + + + + + + // Temp.Blockiert = ((SpeichenSternNode)_alStrahlNodes[iAnfangIndex - 1]).Blockiert; + AddValueWinkel(Temp); + iEndIndex = iAnfangIndex; + iEndIndex++; + } + + int iIndexCurrent = iAnfangIndex; + + do + { + iIndexCurrent++; + if (iIndexCurrent == _alStrahlNodes.Count) + iIndexCurrent = 0; + + if (iEndIndex == iIndexCurrent) + { + if (((SpeichenSternNode)_alStrahlNodes[iEndIndex]).Blockiert == cUnbekannt) + { + int iFound = 0; + SpeichenSternNode Temp = new SpeichenSternNode(); + for (int i = _AlleGesetztenKanten.Count - 1; i > 0; i--) + if (((SpeichenSternNode)_AlleGesetztenKanten[i]).dWinkel == ssnNeuStrahlBegin.dWinkel) + { + iFound++; + Temp =((SpeichenSternNode)_AlleGesetztenKanten[i]); + if (iFound == 2) + break; + } + + if (ssnNeuStrahlBegin.Blockiert == Temp.Blockiert) + { + Temp = new SpeichenSternNode(); + Temp.Blockiert = ((SpeichenSternNode)_alStrahlNodes[iAnfangIndex - 1]).Blockiert; + } + + + _AlleGesetztenKanten.Remove(ssnNeuStrahlEnd); + ssnNeuStrahlEnd.Blockiert = Temp.Blockiert; + + _alStrahlNodes[iIndexCurrent] = ssnNeuStrahlEnd; + _AlleGesetztenKanten.Add(ssnNeuStrahlEnd); // + } + break; + } + SpeichenSternNode strStrahl = (SpeichenSternNode)_alStrahlNodes[iIndexCurrent]; + if (strStrahl.dWinkel == dMainWinkelConst) + { + if (strStrahl.Blockiert != ssnNeuStrahlBegin.Blockiert) + { + strStrahl.Blockiert = ssnNeuStrahlBegin.Blockiert; + + _alStrahlNodes[iIndexCurrent] = strStrahl; + _AlleGesetztenKanten.Add(strStrahl); // + } + } + else + { + ssnNeuStrahlEnd.Blockiert = strStrahl.Blockiert; + iEndIndex--; + iIndexCurrent--; + _alStrahlNodes.Remove(strStrahl); + } + + } while (true); + + return true; + } + + + public void AddValueWinkel(SpeichenSternNode ssnStrahl) // Erweitern um TR Korrektur + { + int iInsertPosition = 0; + + for (int i = 0; i < _alStrahlNodes.Count; i++) + { + SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i]; + if (ssnTemp.dWinkel < ssnStrahl.dWinkel) + iInsertPosition = i; + else if (ssnTemp.dWinkel > ssnStrahl.dWinkel) + { + + if (iInsertPosition > 0) + iInsertPosition = i - 1; + break; + } + else + { + if (ssnTemp.pnPunktPos.p2DPoint.IsEqualTo(ssnStrahl.pnPunktPos.p2DPoint)) + { + if (ssnStrahl.Blockiert != cUnbekannt) + { + _alStrahlNodes[i] = ssnStrahl; + _AlleGesetztenKanten.Add(ssnStrahl); + } + iInsertPosition = (_alStrahlNodes.Count * -1) - 2; + } + // break; + } + } + if (iInsertPosition > -1) + { + if (_alStrahlNodes.Count == 0) + _alStrahlNodes.Insert(iInsertPosition, ssnStrahl); + else + _alStrahlNodes.Insert(iInsertPosition + 1, ssnStrahl); + _AlleGesetztenKanten.Add(ssnStrahl); + } + + } + + /* + public bool SetSperrSektorenNeu(SpeichenSternNode ssnNeuStrahlBegin, SpeichenSternNode ssnNeuStrahlEnd) + { + int iAnfangIndex = -1; + int iEndIndex = -1; + for (int i = 0; i < _alStrahlNodes.Count; i++) + { + if (((SpeichenSternNode)_alStrahlNodes[i]).dWinkel == ssnNeuStrahlBegin.dWinkel) + { + iAnfangIndex = i; + break; + } + } + for (int i = 0; i < _alStrahlNodes.Count; i++) + { + if (((SpeichenSternNode)_alStrahlNodes[i]).dWinkel == ssnNeuStrahlEnd.dWinkel) + { + iEndIndex = i; + break; + } + } + if ((iAnfangIndex < 0) || (iEndIndex < 0)) + return false; + + int iBlockiertAnfang = ((SpeichenSternNode)_alStrahlNodes[iAnfangIndex]).Blockiert; + + bool bLoeschen = true; + + if (iBlockiertAnfang != ssnNeuStrahlBegin.Blockiert) + { + bLoeschen = false; + ssnNeuStrahlEnd.Blockiert = iBlockiertAnfang; + _alStrahlNodes[iAnfangIndex] = ssnNeuStrahlBegin; + _AlleGesetztenKanten.Add(ssnNeuStrahlBegin); + } + + if (ssnNeuStrahlEnd.Blockiert == cUnbekannt) + { + if ((iAnfangIndex - 1) > -1) + iBlockiertAnfang = ((SpeichenSternNode)_alStrahlNodes[iAnfangIndex - 1]).Blockiert; + else + iBlockiertAnfang = ((SpeichenSternNode)_alStrahlNodes[_alStrahlNodes.Count - 1]).Blockiert; + + ssnNeuStrahlEnd.Blockiert = iBlockiertAnfang; + } + + int iIndexCurrent = iAnfangIndex; + + do + { + iIndexCurrent++; + if (iIndexCurrent == _alStrahlNodes.Count) + iIndexCurrent = 0; + + if (iEndIndex == iIndexCurrent) + { + if (((SpeichenSternNode)_alStrahlNodes[iEndIndex]).Blockiert == cUnbekannt) + { + _alStrahlNodes[iIndexCurrent] = ssnNeuStrahlEnd; + _AlleGesetztenKanten.Add(ssnNeuStrahlEnd); // + } + break; + } + SpeichenSternNode strStrahl = (SpeichenSternNode)_alStrahlNodes[iIndexCurrent]; + if (strStrahl.dWinkel == dMainWinkelConst) + { + if (strStrahl.Blockiert != ssnNeuStrahlBegin.Blockiert) + { + strStrahl.Blockiert = ssnNeuStrahlBegin.Blockiert; + + _alStrahlNodes[iIndexCurrent] = strStrahl; + _AlleGesetztenKanten.Add(strStrahl); // + } + } + } while (true); + + bool bGesperrt = false; + if (bLoeschen) + for (int i = 0; i < _alStrahlNodes.Count; i++) + { + if (bGesperrt == false) + if ((((SpeichenSternNode)_alStrahlNodes[i]).Blockiert != cLeerValue) && + (((SpeichenSternNode)_alStrahlNodes[i]).Blockiert != cTKValue)) + bGesperrt = true; + else { } + else + { + if ((((SpeichenSternNode)_alStrahlNodes[i]).Blockiert == cLeerValue) || + (((SpeichenSternNode)_alStrahlNodes[i]).Blockiert == cTKValue)) + bGesperrt = false; + else + { + // _alStrahlNodes.RemoveAt(i); + // i = i - 1; + } + } + } + PrintCurrentSpeichenStrahl(); + return true; + } + */ + private bool IstDrauf(PolyNode Anfang, PolyNode Ende, PolyNode Endpunkt) + { + double LinieDist = Anfang.Distance(Ende); + double ErsteDist = Anfang.Distance(Endpunkt); + double ZweiteDist = Ende.Distance(Endpunkt); + if (Math.Round((ErsteDist + ZweiteDist),6) == Math.Round(LinieDist,6)) + return true; + else + return false; + } + + public bool PruefeKorrigiereDoppelteBlockierung(SpeichenSternNode ssnNeuStrahlBegin, SpeichenSternNode ssnNeuStrahlEnd) + { + do + { + PolyNode SchnittLinieAnfang = new PolyNode(); + SchnittLinieAnfang.p2DPoint = new Point2d(ssnNeuStrahlBegin.dWinkel, 0); + + PolyNode SchnittLinieEnde = new PolyNode(); + SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel, 0); + + SpeichenSternNode ssnGefundeneAnfang = new SpeichenSternNode(); + SpeichenSternNode ssnGefundeneEnde = new SpeichenSternNode(); + + bool bSchneiden = false; + + for (int i = 1; i < _alStrahlNodes.Count; i++) + { + SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i]; + PolyNode pnGefundeneAnfang = new PolyNode(); + PolyNode pnGefundeneEnde = new PolyNode(); + + if ((ssnTemp.Blockiert != cLeerValue) && (ssnTemp.Blockiert != cTKValue)) + { + pnGefundeneAnfang.p2DPoint = new Point2d(ssnTemp.dWinkel, 0); + ssnGefundeneAnfang = ssnTemp; + + if ((i + 1) == _alStrahlNodes.Count) + { + if (ssnTemp.Blockiert == (((SpeichenSternNode)_alStrahlNodes[0]).Blockiert) && (1 != i)) + ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[1]); + else + ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[0]); + } + else + ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[i + 1]); + + pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel, 0); + + /* if (ssnNeuStrahlBegin.dWinkel > ssnNeuStrahlEnd.dWinkel) + SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0); + if (ssnTemp.dWinkel >ssnGefundeneEnde.dWinkel) + pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0); + */ + if (ssnNeuStrahlBegin.dWinkel > ssnNeuStrahlEnd.dWinkel) + SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0); + if (ssnTemp.dWinkel > ssnGefundeneEnde.dWinkel) + pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0); + + if (SchnittLinieEnde.p2DPoint.X > 360) + if ((ssnGefundeneEnde.dWinkel < 90) && (ssnTemp.dWinkel < 90)) + { + pnGefundeneAnfang.p2DPoint = new Point2d(ssnTemp.dWinkel + 360, 0); + pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0); + } + + if (pnGefundeneEnde.p2DPoint.X > 360) + if ((ssnNeuStrahlBegin.dWinkel < 90) && (ssnNeuStrahlEnd.dWinkel < 90)) + { + SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0); + SchnittLinieAnfang.p2DPoint = new Point2d(ssnNeuStrahlBegin.dWinkel + 360, 0); + } + + + int iSchnitte = 0; + + if (IstDrauf(SchnittLinieAnfang, SchnittLinieEnde, pnGefundeneAnfang)) + if ((SchnittLinieEnde.p2DPoint != pnGefundeneAnfang.p2DPoint) && (SchnittLinieEnde.p2DPoint != pnGefundeneAnfang.p2DPoint)) + iSchnitte++; + if (IstDrauf(SchnittLinieAnfang, SchnittLinieEnde, pnGefundeneEnde)) + if ((SchnittLinieAnfang.p2DPoint != pnGefundeneEnde.p2DPoint) && (SchnittLinieAnfang.p2DPoint != pnGefundeneEnde.p2DPoint)) + iSchnitte++; + if (IstDrauf(pnGefundeneAnfang, pnGefundeneEnde, SchnittLinieAnfang)) + if ((pnGefundeneEnde.p2DPoint != SchnittLinieAnfang.p2DPoint) && (pnGefundeneEnde.p2DPoint != SchnittLinieAnfang.p2DPoint)) + iSchnitte++; + if (IstDrauf(pnGefundeneAnfang, pnGefundeneEnde, SchnittLinieEnde)) + if ((pnGefundeneAnfang.p2DPoint != SchnittLinieEnde.p2DPoint) && (pnGefundeneAnfang.p2DPoint != SchnittLinieEnde.p2DPoint)) + iSchnitte++; + + if (iSchnitte > 1) + { + bSchneiden = true; + break; + } + else if (Math.Round(pnGefundeneAnfang.p2DPoint.X, 5) == Math.Round(pnGefundeneEnde.p2DPoint.X, 5)) + { + if (iSchnitte > 0) + { + bSchneiden = true; + break; + } + } + } + } + if (!bSchneiden) + return true; + + SpeichenSternNode ssnKnoten = (SpeichenSternNode)_alStrahlNodes[0]; + + double dKnotenLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnKnoten.pnPunktPos), 5); + double dAnfangLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnNeuStrahlBegin.pnPunktPos), 5); + double dEndeLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnNeuStrahlEnd.pnPunktPos), 5); + + if (dKnotenLage < 0) + if ((dAnfangLage <= 0) && (dEndeLage <= 0)) + { } + else + return false; + else + if ((dAnfangLage >= 0) && (dEndeLage >= 0)) + { + if ((dAnfangLage == 0) && (dEndeLage == 0) && (dKnotenLage == 0)) + return false; + } + else + return false; + + + for (int i = _AlleGesetztenKanten.Count - 1; i > 0; i--) + { + SpeichenSternNode ssnTemp = (SpeichenSternNode)_AlleGesetztenKanten[i]; + if (ssnTemp.dWinkel == ssnGefundeneAnfang.dWinkel) + { + ((SpeichenSternNode)_AlleGesetztenKanten[i]).Blockiert = cLeerValue; + // _AlleGesetztenKanten.RemoveAt(i); + + break; + } + } + for (int i = _alStrahlNodes.Count - 1; i > 0; i--) + { + SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i]; + if (ssnTemp.dWinkel == ssnGefundeneAnfang.dWinkel) + { + ((SpeichenSternNode)_alStrahlNodes[i]).Blockiert = cLeerValue; + break; + } + } + + /* ArrayList alUeberfluessige = (ArrayList)_alStrahlNodes.Clone(); + _alStrahlNodes.Clear(); + + int iGesetzteKanten = _AlleGesetztenKanten.Count; + ArrayList alTemp = (ArrayList)_AlleGesetztenKanten.Clone(); + _AlleGesetztenKanten.Clear(); + for (int i = 0; i < iGesetzteKanten; i++) + { + SpeichenSternNode ssnTemp = (SpeichenSternNode)alTemp[i]; + AddValueWinkel(ssnTemp); + + }*/ + SetKanten(); + + /* for (int i = 0; i < _alStrahlNodes.Count; i++) + { + if (!(alUeberfluessige.Contains(_alStrahlNodes[i]))) + { + _alStrahlNodes.RemoveAt(i); + i--; + } + }*/ + + // return true; + } while (true); + } + + public bool PruefeDoppelteBlockierung(SpeichenSternNode ssnNeuStrahlBegin, SpeichenSternNode ssnNeuStrahlEnd) + { + PolyNode SchnittLinieAnfang = new PolyNode(); + SchnittLinieAnfang.p2DPoint = new Point2d(ssnNeuStrahlBegin.dWinkel, 0); + + PolyNode SchnittLinieEnde = new PolyNode(); + SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel, 0); + + SpeichenSternNode ssnGefundeneAnfang = new SpeichenSternNode(); + SpeichenSternNode ssnGefundeneEnde = new SpeichenSternNode(); + + bool bSchneiden = false; + + for (int i = 1; i < _alStrahlNodes.Count; i++) + { + SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i]; + PolyNode pnGefundeneAnfang = new PolyNode(); + PolyNode pnGefundeneEnde = new PolyNode(); + + if ((ssnTemp.Blockiert != cLeerValue) && (ssnTemp.Blockiert != cTKValue)) + { + pnGefundeneAnfang.p2DPoint = new Point2d(ssnTemp.dWinkel, 0); + ssnGefundeneAnfang = ssnTemp; + + if ((i + 1) == _alStrahlNodes.Count) + { + if (ssnTemp.Blockiert == (((SpeichenSternNode)_alStrahlNodes[0]).Blockiert) && (1 != i)) + ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[1]); + else + ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[0]); + } + else + ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[i + 1]); + + pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel, 0); + + if (ssnNeuStrahlBegin.dWinkel > ssnNeuStrahlEnd.dWinkel) + SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0); + if (ssnTemp.dWinkel > ssnGefundeneEnde.dWinkel) + pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0); + + if (SchnittLinieEnde.p2DPoint.X > 360) + if ((ssnGefundeneEnde.dWinkel < 90) && (ssnTemp.dWinkel < 90)) + { + pnGefundeneAnfang.p2DPoint = new Point2d(ssnTemp.dWinkel + 360, 0); + pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0); + } + + if (pnGefundeneEnde.p2DPoint.X > 360) + if ((ssnNeuStrahlBegin.dWinkel < 90) && (ssnNeuStrahlEnd.dWinkel < 90)) + { + SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0); + SchnittLinieAnfang.p2DPoint = new Point2d(ssnNeuStrahlBegin.dWinkel + 360, 0); + } + + int iSchnitte = 0; + + if (IstDrauf(SchnittLinieAnfang, SchnittLinieEnde, pnGefundeneAnfang)) + if ((SchnittLinieEnde.p2DPoint != pnGefundeneAnfang.p2DPoint) && (SchnittLinieEnde.p2DPoint != pnGefundeneAnfang.p2DPoint)) + iSchnitte++; + if (IstDrauf(SchnittLinieAnfang, SchnittLinieEnde, pnGefundeneEnde)) + if ((SchnittLinieAnfang.p2DPoint != pnGefundeneEnde.p2DPoint) && (SchnittLinieAnfang.p2DPoint != pnGefundeneEnde.p2DPoint)) + iSchnitte++; + if (IstDrauf(pnGefundeneAnfang, pnGefundeneEnde, SchnittLinieAnfang)) + if ((pnGefundeneEnde.p2DPoint != SchnittLinieAnfang.p2DPoint) && (pnGefundeneEnde.p2DPoint != SchnittLinieAnfang.p2DPoint)) + iSchnitte++; + if (IstDrauf(pnGefundeneAnfang, pnGefundeneEnde, SchnittLinieEnde)) + if ((pnGefundeneAnfang.p2DPoint != SchnittLinieEnde.p2DPoint) && (pnGefundeneAnfang.p2DPoint != SchnittLinieEnde.p2DPoint)) + iSchnitte++; + + if (iSchnitte > 1) + { + bSchneiden = true; + break; + } + else if (Math.Round(pnGefundeneAnfang.p2DPoint.X, 5) == Math.Round(pnGefundeneEnde.p2DPoint.X, 5)) + { + if (iSchnitte > 0) + { + + bSchneiden = true; + break; + } + } + } + } + if (!bSchneiden) + return true; + + SpeichenSternNode ssnKnoten = (SpeichenSternNode)_alStrahlNodes[0]; + + double dKnotenLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnKnoten.pnPunktPos), 5); + double dAnfangLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnNeuStrahlBegin.pnPunktPos), 5); + double dEndeLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnNeuStrahlEnd.pnPunktPos), 5); + + if (dKnotenLage < 0) + if ((dAnfangLage <= 0) && (dEndeLage <= 0)) + { } + else + return false; + else + if ((dAnfangLage >= 0) && (dEndeLage >= 0)) + { + if ((dAnfangLage == 0) && (dEndeLage == 0) && (dKnotenLage == 0)) + return false; + } + else + return false; + + return true; // Keine Blockierung + } + + private void SetKanten() + { + for (int i = 1; i < _alStrahlNodes.Count; i++) + { + SpeichenSternNode ssnVorher = (SpeichenSternNode)_alStrahlNodes[i-1]; + SpeichenSternNode ssnDerzeit = (SpeichenSternNode)_alStrahlNodes[i]; + + if (ssnDerzeit.Blockiert == ssnVorher.Blockiert) + { + _alStrahlNodes.RemoveAt(i); + for(int j = 0; j < _AlleGesetztenKanten.Count;j++) + if (((SpeichenSternNode)_AlleGesetztenKanten[j]).dWinkel == ssnDerzeit.dWinkel) + { + _AlleGesetztenKanten.RemoveAt(j); + break; + } + i--; + } + } + } + + private double PunktLage(PolyNode AnfangLinie, PolyNode EndeLinie, PolyNode PunktPruefen) + { + Vector3d AnfangsPunkt = new Vector3d(AnfangLinie.p2DPoint.X, AnfangLinie.p2DPoint.Y, 1); + Vector3d EndPunkt = new Vector3d(EndeLinie.p2DPoint.X, EndeLinie.p2DPoint.Y, 1); + Vector3d Normale = AnfangsPunkt.CrossProduct(EndPunkt); + Vector3d Punkt = new Vector3d(PunktPruefen.p2DPoint.X, PunktPruefen.p2DPoint.Y, 1); + return Normale.DotProduct(Punkt); + } + + + public void AddValueWinkel(PolyNode pnNeuerPunkt) + { + PolyNode pnZentrum = (PolyNode)_alStrahlNodes[0]; + + double dTempWinkel = pnZentrum.GetWinkelPoint(pnNeuerPunkt); + + SpeichenSternNode ssnStrahl = new SpeichenSternNode(); + + ssnStrahl.pnPunktPos = pnNeuerPunkt; + ssnStrahl.dWinkel = dTempWinkel; + ssnStrahl.Blockiert = cLeerValue; //CalculateKonturkante(iSternEcke); + AddValueWinkel(ssnStrahl); + } + + public void PrintCurrentSpeichenStrahl() + { + Editor ed = Application.DocumentManager.MdiActiveDocument.Editor; + + ed.WriteMessage("\n"); + ed.WriteMessage("Speichenstrahl: "); + ed.WriteMessage(Convert.ToString(_iSternNode)); + + for(int i = 0; i < _alStrahlNodes.Count;i++) + { + ed.WriteMessage("\n"); + SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i]; + ed.WriteMessage("Index: "); + ed.WriteMessage(Convert.ToString(ssnTemp.pnPunktPos.iNodeIndex)); + ed.WriteMessage(" Knoten: "); + ed.WriteMessage(Convert.ToString(ssnTemp.pnPunktPos.iNodeIndex)); + ed.WriteMessage(" Winkel: "); + ed.WriteMessage(Convert.ToString(ssnTemp.dWinkel)); + ed.WriteMessage(" Blockiert: "); + + if (ssnTemp.Blockiert == cLeerValue) + ed.WriteMessage("Leer"); + else if (ssnTemp.Blockiert == cTKValue) + ed.WriteMessage("TK"); + else if (ssnTemp.Blockiert >= 10000) + { + ed.WriteMessage("K"+Convert.ToString(ssnTemp.Blockiert-10000)); + } + else + ed.WriteMessage(Convert.ToString(ssnTemp.Blockiert)); + } + } + } +} -- cgit v1.2.3