diff options
| author | Sven Eisenhauer <sven@sven-eisenhauer.net> | 2023-11-10 15:11:48 +0100 |
|---|---|---|
| committer | Sven Eisenhauer <sven@sven-eisenhauer.net> | 2023-11-10 15:11:48 +0100 |
| commit | 33613a85afc4b1481367fbe92a17ee59c240250b (patch) | |
| tree | 670b842326116b376b505ec2263878912fca97e2 /Master/CGuCAD/projects/AbschlussPrj | |
| download | Studium-33613a85afc4b1481367fbe92a17ee59c240250b.tar.gz Studium-33613a85afc4b1481367fbe92a17ee59c240250b.tar.bz2 | |
Diffstat (limited to 'Master/CGuCAD/projects/AbschlussPrj')
12 files changed, 1908 insertions, 0 deletions
diff --git a/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj.sln b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj.sln new file mode 100644 index 0000000..bd7c826 --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj.sln @@ -0,0 +1,20 @@ +
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AbschlussPrj", "AbschlussPrj\AbschlussPrj.csproj", "{90196A92-7164-4DB9-BB5B-7F6004BBAC59}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {90196A92-7164-4DB9-BB5B-7F6004BBAC59}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {90196A92-7164-4DB9-BB5B-7F6004BBAC59}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {90196A92-7164-4DB9-BB5B-7F6004BBAC59}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {90196A92-7164-4DB9-BB5B-7F6004BBAC59}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj.suo b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj.suo Binary files differnew file mode 100644 index 0000000..78d66d2 --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj.suo diff --git a/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/AbschlusArbeiterklasse.cs b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/AbschlusArbeiterklasse.cs new file mode 100644 index 0000000..2027761 --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/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/AbschlussPrj/AbschlussPrj/Abschluss.cs b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/Abschluss.cs new file mode 100644 index 0000000..73dd3dc --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/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/AbschlussPrj/AbschlussPrj/AbschlussPrj.csproj b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/AbschlussPrj.csproj new file mode 100644 index 0000000..39ab9d5 --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/AbschlussPrj.csproj @@ -0,0 +1,63 @@ +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <PropertyGroup>
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+ <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+ <ProductVersion>8.0.50727</ProductVersion>
+ <SchemaVersion>2.0</SchemaVersion>
+ <ProjectGuid>{90196A92-7164-4DB9-BB5B-7F6004BBAC59}</ProjectGuid>
+ <OutputType>Library</OutputType>
+ <AppDesignerFolder>Properties</AppDesignerFolder>
+ <RootNamespace>AbschlussPrj</RootNamespace>
+ <AssemblyName>AbschlussPrj</AssemblyName>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+ <DebugSymbols>true</DebugSymbols>
+ <DebugType>full</DebugType>
+ <Optimize>false</Optimize>
+ <OutputPath>bin\Debug\</OutputPath>
+ <DefineConstants>DEBUG;TRACE</DefineConstants>
+ <ErrorReport>prompt</ErrorReport>
+ <WarningLevel>4</WarningLevel>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+ <DebugType>pdbonly</DebugType>
+ <Optimize>true</Optimize>
+ <OutputPath>bin\Release\</OutputPath>
+ <DefineConstants>TRACE</DefineConstants>
+ <ErrorReport>prompt</ErrorReport>
+ <WarningLevel>4</WarningLevel>
+ </PropertyGroup>
+ <ItemGroup>
+ <Reference Include="acdbmgd, Version=17.2.0.0, Culture=neutral, processorArchitecture=x86">
+ <SpecificVersion>False</SpecificVersion>
+ <HintPath>C:\Programme\AutoCAD Civil 3D 2009\acdbmgd.dll</HintPath>
+ <Private>False</Private>
+ </Reference>
+ <Reference Include="acmgd, Version=17.2.0.0, Culture=neutral, processorArchitecture=x86">
+ <SpecificVersion>False</SpecificVersion>
+ <HintPath>C:\Programme\AutoCAD Civil 3D 2009\acmgd.dll</HintPath>
+ <Private>False</Private>
+ </Reference>
+ <Reference Include="System" />
+ <Reference Include="System.Data" />
+ <Reference Include="System.Xml" />
+ </ItemGroup>
+ <ItemGroup>
+ <Compile Include="AbschlusArbeiterklasse.cs" />
+ <Compile Include="Abschluss.cs" />
+ <Compile Include="Commands.cs" />
+ <Compile Include="PolyNode.cs" />
+ <Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="SpeichenStern.cs" />
+ <Compile Include="SpeichenSternNode.cs" />
+ <Compile Include="SpeichenSternStrahl.cs" />
+ </ItemGroup>
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+ <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+ Other similar extension points exist, see Microsoft.Common.targets.
+ <Target Name="BeforeBuild">
+ </Target>
+ <Target Name="AfterBuild">
+ </Target>
+ -->
+</Project>
\ No newline at end of file diff --git a/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/AbschlussPrj.csproj.user b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/AbschlussPrj.csproj.user new file mode 100644 index 0000000..56d9abb --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/AbschlussPrj.csproj.user @@ -0,0 +1,13 @@ +<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+ <StartAction>Program</StartAction>
+ <StartProgram>C:\Programme\AutoCAD Civil 3D 2009\acad.exe</StartProgram>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+ <StartAction>Program</StartAction>
+ <StartProgram>C:\Programme\AutoCAD Civil 3D 2009\acad.exe</StartProgram>
+ </PropertyGroup>
+ <PropertyGroup>
+ <ProjectView>ShowAllFiles</ProjectView>
+ </PropertyGroup>
+</Project>
\ No newline at end of file diff --git a/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/Commands.cs b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/Commands.cs new file mode 100644 index 0000000..8a48f78 --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/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>
+ /// Summary description for MGCommands.
+ /// </summary>
+ 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/AbschlussPrj/AbschlussPrj/PolyNode.cs b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/PolyNode.cs new file mode 100644 index 0000000..1eb5d56 --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/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/AbschlussPrj/AbschlussPrj/Properties/AssemblyInfo.cs b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..f57adaa --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/Properties/AssemblyInfo.cs @@ -0,0 +1,79 @@ +// (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;
+
+//
+// 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("")]
+[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.*")]
+
+//
+// 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\<configuration>. 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("")]
diff --git a/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/SpeichenStern.cs b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/SpeichenStern.cs new file mode 100644 index 0000000..fc43148 --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/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/AbschlussPrj/AbschlussPrj/SpeichenSternNode.cs b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/SpeichenSternNode.cs new file mode 100644 index 0000000..fb3d4f6 --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/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/AbschlussPrj/AbschlussPrj/SpeichenSternStrahl.cs b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/SpeichenSternStrahl.cs new file mode 100644 index 0000000..638a0d3 --- /dev/null +++ b/Master/CGuCAD/projects/AbschlussPrj/AbschlussPrj/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));
+ }
+ }
+ }
+}
|