Klassenkonzept

faxe1008 · 21. Januar 2015, 21:20

Heyho,

Ich arbeite gerade an einer Klasse für die Vektorgeometrie. Mittlerweile bin ich kurz davor Ebenen einzubauen, daher meine Frage: Wie konzeptioniere ich die Klassen untereinander? Die Ebene hat ja 3(bzw. 4) unterschiedliche Formen:
- Parametergleichung
- Normalengleichung
- Koordinatengleichung
- (Hessche Normalform)

Eine einzige Klasse Ebene mit all diesen Propertys wäre sehr unübersichtlich. Als Info: Die Bibliothek enthält Vector3D und Point3D Klassen die verwendet werden können. Wie würdet ihr das angehen?

Artentus · 21. Januar 2015, 21:27

Sofern du eine vollständige Implementierung durchführst kannst du die Form verwenden, die dir am ehesten zusagt. Berechnungen werden dann über von dir implementierte Operatoren/Funktionen durchgeführt, sodass Drittcode vollständig unabhängig von der verwendeten Repräsentation ist.
Einzig um das Erstellen aus allen möglichen Formen musst du dich kümmern, dafür entweder Konstruktoren oder statische Funktionen verwenden. Optional kannst du auch noch ToXYZString-FUnktionen implementieren, um alle möglichen Darstellungen auszugeben, ähnlich wie bei DateTime.

Niko Ortner · 21. Januar 2015, 21:33

Was willst Du mit den Ebenen anstellen können? Ich sag jetzt einfach mal "Kürzeste Distanz zu einem Punkt finden". Dann könntest Du eine abstrakte Basisklasse schreiben, in der diese Funktion abstrakt ist. Dann leitest Du davon ab und implementierst die Funktion so, wie man das Ergebnis eben mit der Art von Ebene ausrechnet.
Wenn Du nicht neben der Basisklasse die 4 anderen Ebenen-Klassen öffentlich verfügbar machen willst, kannst Du sie z.B. als Friend deklarieren, damit sie nur in der eigenen Assembly zugreifbar sind, und in der Basisklasse statische Funktionen so in der Richtung zur Verfügung stellen:

VB.NET-Quellcode

Public MustInherit Class Plane
'...
Public Shared Function FromXYZ(XYZ As Irgendwas) As Plane
Return New XYZPlane(XYZ)
End Function
Public Shared Function FromThreePoints(Point1 As Point3D, Point2 As Point3D, Point3 As Point3D) As Plane
Return New PlaneThroughThreePoints(Point1, Point2, Point3)
End Function
End Class
Friend Clas XYZPlane
Inherits Plane
'...
End Class
Friend Clas PlaneThroughThreePoints
Inherits Plane
'...
End Class

faxe1008 · 21. Januar 2015, 21:39

Niko Ortner schrieb:

Was willst Du mit den Ebenen anstellen können?

Alles.
- Parallele Ebenen erzeugen
- Abstand zu einem Punkt
- Abstand zu einer Gerade
- Schnittpunkt mit einer Geraden
- Schnittgerade zweier Ebenen
- Schnittwinkel mit Gerade
- Schnittwinkel mit Ebene

Wie regel ich das mit den Properties in der Basisklasse? Die Formen müssen sich nahtlos ineinander umkonvertieren lassen, denn wenn ein PropertyChanged ausgelöst wird (z.B. der Spannvektor der Parametergleichung) muss sich ja auch der Normalenvektor ändern und umgekehrt. Ist das mit der Methode reibungslos möglich?

~blaze~ · 21. Januar 2015, 21:56

Hi
ich würde einen einzigen Wertetyp X für Ebenen schreiben (mit der Normalenform) und für die anderen Formen je eine Klasse anlegen. Anschließend würde ich ein Interface mit IProvidePlane oder etwas in der Richtung einführen, das eine Methode X ToPlane besitzt (noch schöner wäre ggf. sogar, dort die hessesche Normalenform zu generieren). Anschließend würde ich alle vier Typen (also auch den Wertetyp) eine Instanz von X erstellen lassen. Gegen die hesesche Normalenform spricht allerdings die Ineffizienz der Quadratwurzelberechnung.

Viele Grüße
~blaze~

Niko Ortner · 21. Januar 2015, 22:13

Wenn auch die Properties von außen zugreifbar sein sollen, funzt das mit den Friend Klassen natürlich nicht mehr. Aber ansonsten würde das Konzept gleich bleiben.
Aber mir stellt sich halt die Frage, warum man zwischen den Formen konvertieren möchte.
Ich stelle mir da sowas vor (vereinfacht):

Beispiel

VB.NET-Quellcode

Public MustInherit Class Line
Public MustOverride Function GetY(X As Double) As Double
End Class
Public Class LineThroughTwoPoints
Inherits Line
Dim _Point1 As Point2D
Public ReadOnly Property Point1 As Point2D
Get
Return _Point1
End Get
End Property
Dim _Point2 As Point2D
Public ReadOnly Property Point2 As Point2D
Get
Return _Point2
End Get
End Property
Public Sub New(NewPoint1 As Point2D, NewPoint2 As Point2D)
_Point1 = NewPoint1
_Point2 = NewPoint2
End Sub
Public Overrides Function GetY(X As Double) As Double
Return _Point1.Y + (X - _Point1.X) * (_Point2.Y - _Point1.Y) / (_Point2.X - _Point1.X)
End Function
End Class
Public Class LineFromLinearEquation
Inherits Line
Dim _K As Double
Public ReadOnly Property K As Double
Get
Return _K
End Get
End Property
Dim _D As Double
Public ReadOnly Property D As Double
Get
Return _D
End Get
End Property
Public Sub New(NewK As Double, NewD As Double)
_K = NewK
_D = NewD
End Sub
Public Overrides Function GetY(X As Double) As Double
Return _K * X + _D
End Function
End Class

RodFromGermany · 22. Januar 2015, 08:25

@faxe1008 Mach Dir zunächst eine ordentliche Vektor-Klasse, auf der Du dann alles andere aufbauen kannst.
Vielleicht ist es sinnvoll, zwischen Orts- und Richtungsvektoren zu unterscheiden, da kannst Du die Rechenoperatoren besser programmieren.
Wie Du die Ebenen-Daten reinbekommst, sollte an dei Anforderungen angepasst werden.
Auf welche Art Du die Ebenen intern darstellst, sollte so sein, dass Du gut und verständlich damit rechnen kannst. Ich nehme da einen Punkt (Ortsvektor) und 2 Richtungsvektoren.

faxe1008 · 22. Januar 2015, 17:14

@RFG:
So sehen die Beispielklassen momentan aus:

Point3D

Vector3D

VB.NET-Quellcode

Public Class Vector3D
'X-Koordinate
Public Property X1 As Double
'X2-Koordinate
Public Property X2 As Double
'X3-Koordinate
Public Property X3 As Double
'Konstruktor
Public Sub New(ByVal x1 As Double, ByVal x2 As Double, ByVal x3 As Double)
_X1 = x1
_X2 = x2
_X3 = X3
End Sub
Public Sub FromPoints(ByVal Point1 As Point3D, ByVal Point2 As Point3D)
_X1 = Point2.X1 - Point1.X1
_X2 = Point2.X2 - Point1.X2
_X3 = Point2.X3 - Point1.X3
End Sub
Public Function Magnitude() As Double
Return Math.Sqrt(Math.Pow(X1, 2) + Math.Pow(X2, 2) + Math.Pow(X3, 2))
End Function
Public Function ScalarProduct(ByVal vector As Vector3D) As Double
Return X1 * vector.X1 + X2 * vector.X2 + X3 * vector.X3
End Function
Public Function IsOrthogonalTo(ByVal vector As Vector3D) As Boolean
Return ScalarProduct(vector) = 0
End Function
Public Function AngleTo(ByVal vector As Vector3D) As Double
Return Math.Acos(Math.Abs(ScalarProduct(vector)) / (Magnitude() * vector.Magnitude)) / Math.PI * 180
End Function
Public Sub New(ByVal Point1 As Point3D, ByVal Point2 As Point3D)
_X1 = Point2.X1 - Point1.X1
_X2 = Point2.X2 - Point1.X2
_X3 = Point2.X3 - Point1.X3
End Sub
Public Overrides Function ToString() As String
Return String.Concat({"{", _X1.ToString, "|", _X2.ToString, "|", _X3.ToString, "}"})
End Function
End Class

Line3D

VB.NET-Quellcode

Public Class Line3D
Public Property DirectionVector As Vector3D
Public Property SupportVector As Vector3D
Public Sub New(ByVal supportvector As Vector3D, directionvector As Vector3D)
_DirectionVector = directionvector
_SupportVector = supportvector
End Sub
Public Sub New(ByVal Point1 As Point3D, ByVal Point2 As Point3D, ByVal Point3 As Point3D)
DirectionVector = New Vector3D(Point1, Point2)
SupportVector = New Vector3D(Point3.X1, Point3.X2, Point3.X3)
End Sub
Public Function PointOnLine(ByVal t As Double) As Point3D
Return New Point3D(SupportVector.X1 + t * DirectionVector.X1, SupportVector.X2 + t * DirectionVector.X2, SupportVector.X3 + t * DirectionVector.X3)
End Function
'!!!!!!!!!!!!!!!!!
Public Function DistanceToPoint(ByVal Point As Point3D) As Double
'Point(p1|p2|p3)
'Line= {s1,s2,s3}+t*{r1,r2,3}
'general point on line GP(s1+t*r1|s2+t*r2|s3+t*r3)
'vector Point to GP GPPoint(p1-(s1+t*r1)|p2-(s2+t*r2)|p3-(s3+t*r3))
'GPPoint(p1-s1-t*r1|p2-s2-t*r2|p3-s3-t*r3)
'product from point and GPPoint = 0
'p1*(p1-s1-t*r1)+p2*(p2-s2-t*r2)+p3*(p3-s3-t*r3)=0
't = (p1^2 + - p1*s1 + p2^2 - p2*s2 + p3^2-p3*s3)/(p1*r1+p2*r2+p3*r3)
Dim p1 As Double = Point.X1
Dim p2 As Double = Point.X2
Dim p3 As Double = Point.X3
Dim s1 As Double = SupportVector.X1
Dim s2 As Double = SupportVector.X2
Dim s3 As Double = SupportVector.X3
Dim r1 As Double = DirectionVector.X1
Dim r2 As Double = DirectionVector.X2
Dim r3 As Double = DirectionVector.X3
Dim t As Double = (r1 * (p1 - s1) + r2 * (p2 - s2) + r3 * (p3 - s3)) / (r1 ^ 2 + r2 ^ 2 + r3 ^ 2)
Dim NearestPointofLine As Point3D = PointOnLine(t)
Return NearestPointofLine.DistanceToPoint(Point)
End Function
Public Function ContainsPoint(ByVal Point As Point3D) As Boolean
'Point.x1 = supportvector.x1 + t * directionvector.x1
'Point.x2 = supportvector.x2 + t * directionvector.x2
'Point.x3 = supportvector.x3 + t * directionvector.x3
' t1 = (Point.x1 - supportvector.x1) / directionvector.x1
' t2 = (Point.x2 - supportvector.x2) / directionvector.x2
' t3 = (Point.x3 - supportvector.x3) / directionvector.x3
't1=t2=t3 => Line contains Point
Dim t1 As Double = (Point.X1 - SupportVector.X1) / DirectionVector.X1
Dim t2 As Double = (Point.X2 - SupportVector.X2) / DirectionVector.X2
Dim t3 As Double = (Point.X3 - SupportVector.X3) / DirectionVector.X3
If t1 = t2 AndAlso t2 = t3 Then Return True
Return False
End Function
Public Overrides Function ToString() As String
Return SupportVector.ToString & "t*" & DirectionVector.ToString
End Function
End Class

Mittlerweile bin ich fast soweit, dass ich die Ebene als Parameterform einfach implementiere und in den .ToString Überladungen die anderen Formen abfragbar mache.

ErfinderDesRades · 22. Januar 2015, 18:22

Ich hatte mal einiges rumgefuhrwerkt mit Sizes, Points, Lines, Rectangles etc, und ist mir tierisch auf die Nerven gefallen, dass man jeden Sch... mindestens doppelt codieren musste, mal in X, mal in Y-Richtung.

Durch vieles Hirnen kam ich zu einem neuartigen Konzept, was
einen Vektor als 2 Zahlen auffasst.
Und eine Strecke als 2 Vektoren.
Und ein Rechteck als 2 Strecken.

Also dasses immer dasselbe bleibt, nur mit mehr Dimensionen kommen auch mathematisch Dimensionen hinzu.

Dann habich das so organisiert, dass man immer mit foreach beide Richtungen pro Dimension durchnudeln konnte, ohne Sonder-Code schreiben zu müssen für x, y, width, height.
Und der Gedanke kam mir, dass mein Ansatz in 3D-Geometrie noch viel sinniger sei.

Also ausgeführt habe ich meine Ausführungen hier: codeproject.com/Articles/58647…ws-StickyWindows-reloaded
Ich habe das Konzept "homogene structure" genannt, aber möglicherweise ist ähnliches in der Mathematik als "Tesseract" ein alter Hut (jaja, das Rad neu erfinden :thumbdown:

)
Na, vlt. auch nicht - bei Tesseracts bin ich längst abgeschnallt

Nur so als Anregung, weil wenn du an Intersection gehst und sowas, kann sein, dasses da auch auftritt, dass man immer dasselbe mehrmals coden muss.

faxe1008 · 22. Januar 2015, 18:53

ErfinderDesRades schrieb:

ausgeführt habe ich meine Ausführungen

Made my day

ErfinderDesRades schrieb:

Nur so als Anregung, weil wenn du an Intersection gehst und sowas, kann sein, dasses da auch auftritt, dass man immer dasselbe mehrmals coden muss.

Ja das ist im Prinzip sehr häufig das selbe in 2D und 3D. Ich finde die Idee zwar sehr interessant allerdings ist es für schnelle 0815 Programme ein wenig arg kompliziert.

Niko Ortner schrieb:

Aber mir stellt sich halt die Frage, warum man zwischen den Formen konvertieren möchte.

Weils es mit der Parametergleichung extremst schwer ist Abstände zu berechnen z.B.

Artentus · 22. Januar 2015, 19:47

Wenn du mehrere Darstellungen zur Berechnung brauchst nur zu, verwende sie, das muss man deinem Code nicht ansehen können.
Du solltest allerdings darauf achten, die verschiedenen Darstellungen möglichst effizient ineinander zu konvertieren. D.h. entweder bei jeder Änderung genau einmal konvertieren oder besser das erste mal, wenn es gebraucht wird, konvertieren (bis eine Änderung dich dazu zwingt, die restlichen Darstellungen zu verwerfen).

ThePlexian · 22. Januar 2015, 22:39

Ich würde ebenfalls mich für eine Form entscheiden (Hess'sche Normalform imo) und dann statische Methoden wie public static Plane3D FromXYZForm(Vector3D supp, Vector3D dir1, Vector3D dir2) und dann darin zur Normalform umrechnen.

RodFromGermany · 23. Januar 2015, 08:08

@faxe1008 Schmeiß das Math.Pow(x, 2) raus und mach auch das ToString() ordentlich:

VB.NET-Quellcode

Public Function DistanceToPoint(ByVal Point As Point3D) As Double
Dim sum = (X1 - Point.X1) * (X1 - Point.X1)
sum += (X2 - Point.X2) * (X2 - Point.X2)
sum += (X3 - Point.X3) * (X3 - Point.X3)
Return Math.Sqrt(sum)
End Function
Public Overrides Function ToString() As String
Return String.Format("({0}|{1}|{2}", _X1, _X2, X3)
End Function

ErfinderDesRades · 23. Januar 2015, 11:26

naja, und eiglich heissen Koordinaten doch X, Y, Z?

Und DistanceToPoint(pt As Point) ist auch ein "weißer Schimmel" - es reicht der Name Distance - dasses eine Distance zum Point ist erkennt man ja am Argument.
Den Namen Distance sollteste dann sooft überladen, wie gebraucht mit je anderen Argument-Typen.

Hier nochmal eine fiktive Anwendung des Homogen-Structure-Ansatzes:

VB.NET-Quellcode

Class Point3D
Private _Values(2) As Double 'ein Punkt hat in jeder Dimension einen Wert
Public Function SquareDistance(ByVal Point As Point3D) As Double
Return _Values.Zip(Point._Values, Function(p0, p1) (p1 - p0) * (p1 - p0)).Sum
End Function
Public Function Distance(ByVal Point As Point3D) As Double
Return Math.Sqrt(SquareDistance(Point))
End Function
End Class

SquareDistance sollte man extra anbieten, weil ist vielfach schneller, und für viele Nutzungen ebensogut brauchbar wie die korrekte Distanz.

Klassenkonzept

Klassenkonzept

VB.NET-Quellcode

Niko Ortner schrieb:

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

ErfinderDesRades schrieb:

ErfinderDesRades schrieb:

Niko Ortner schrieb:

VB.NET-Quellcode

VB.NET-Quellcode

Ähnliche Themen

7 Benutzer haben hier geschrieben