Zusammenstoß von Kugeln

[braingrenade]

Moin Leute !


Ich arbeite gerade an einem neuen Projekt (chaos3) und nun habe ich das Problem das ich nicht weiß wie ich einen Zusammen-Stoß zweier Kugeln berechnen kann.

Folgendes weiß ich über die Kugeln :

1. Position
2. Geschwindigkeit in y-Richtung
3. Geschwindigkeit in x-Richtung
4. Wann und Wo sich die Kugeln berühren


Wie kann ich nun ausrechnen in welche Richtungen die Kugeln voneinander apprallen ?

[flomei]

ui...
Da gehört einiges an Physik zu wenn du das gut machen willst...
Wichtig wäre halt auch ob das nen elastischer Zusammenstoß ist und ob Kugel A eine größere Maße als Kugel B hat etc.
Hab im Moment wenig Zeit aber nachher kann ich mal nen bisschen dazu schreiben...

MfG Florian :hi:

[braingrenade]

Achso ja das hab ich vergessen :

1. Es ist ein vollelastischer Stoß
2. Die Massen der Kugeln sind gleich

Wir hatten in Physik auch schon den geraden Stoß, aber halt nicht den krummen :evil:

@flomei : Das wär nett !

edit : ein t hinzugefügt :mrgreen:

[StefanDP]

Seite von einem sehr beindruckenden OS Projekt:
http://www.tobias-nopper.de/BillardG...physik-de.html

stefan

[braingrenade]

Ah ja die seite is gut, ich probiers mir mal anhand der Zeichnungen zu erarbeiten.

[braingrenade]

Ich habs mir angeschut und versteh's auch soweit und kann mir's mit Pythagoras und Trygonomtrie ausrechnen, nur an einer Stelle hab ich ein Problem : Was is ein Skalarprodukt ?

[Chewie]

Zitat:

Zitat von braingrenade

Was is ein Skalarprodukt ?

Eine Operation der linearen Algebra. Falls du mehr als nur eine solche Vektoroperation berechnen musst, wäre es sinnvoll, zuerst einmal die mathematischen Grundlagen (Vektorrechnung im R2 (vielleicht auch im R3?)) dir anzueignen, dann verstehst du die Formeln auch besser.

[flomei]

hm... :roll: Geraden Stoß hatten wir auch. Ich denke mit "krummen" Stoß meinst du es Billard-ähnlich also das Kugeln auch andere "streifen" können usw.
Das hatten wir auch nicht aber sollten Probleme beim geraden Stoß sein, dann meld dich. Ich versuche zu helfen...

MfG Florian :hi:

[alcaeus]

Ich kann dir nur empfehlen, irgendwo die Grenze zu ziehen. Denn wenn du es ganz genau nehmen willst, dann bräuchtest du noch die Drallgeschwindigkeit und Drallrichtung der beiden Kugeln, sowie genau den Berührungspunkt, ebenso wie den Reibungskoeffizienten der beiden Kugeln. Denn wenn du jetzt an Billiard denkst, kann ich der Kugel dort ja auch einen Drall geben, welcher die Kugel nicht auf einer geraden sondern ellipsenförmigen Bahn entlangrollen lässt, noch dazu die Abweichung wegen Drall, sobald sich die zwei Kugeln berühren wird der Drall die andere Kugel wahrscheinlich in eine Drehung versetzen, wobei auch die eigene Drehung geändert wird, und, und, und...

Das sind alles Faktoren, aufgrund derer du bestimmen musst, wie genau deine Simulation/dein Spiel werden soll.

Greetz
alcaeus

[Ultimator]

Man kann ja auch die weiße Kugel weiter oben oder weiter unten anstoßen, damit sie stehen bleibt, wenn man 'ne Andere trifft. Aber das muss man ja nicht einbauen.

[alcaeus]

Genau das ist ja der Drall und die Sache mit den Reibungskoeffizienten. Aber noch ist glaube ich noch nicht mal bestätigt worden, dass es um Billiard geht (obwohl das irgendwie logisch ist)

Greetz
alcaeus

[Ultimator]

[OT] Stimmt, es könnte auch Snooker sein :mrgreen: [/OT]

[ibp]

das skalarprodukt ist ein produkt zweier vektoren, dabei ist die wichtigste eigenschaft, daß wenn das skalarprodukt 0 ist, die vektoren senkrecht aufeinander stehen!

[StefanDP]

wie wärs malwieder mit nem link von mir?! ;-)
http://www.delphigl.com/script/do_sh...gebra&action=2

stefan

ps: die seite ist allgemein sowieso empfehlenswert (tutorial-mäßig)

[braingrenade]

Danke für die Vielen Antworten !

Aber entegegen aller Vermutungen wird's kein Billardspiel :mrgreen:

Ich bin dabei eine Art Simulation des Chaos zu programieren und dabei brauch auch keine Reibung und Drall zu beachten. Das Grundprinzip ist das ich einen Haufen Teilchen hab die zufällige Richtungen und Positionen haben. Alle diese Kugeln beeinflussen sich gegenseitig, in dem Fall das zusammenstoßen(vielleicht auch noch was anderes), und werden sich dann durch auslößen eines Aktiviators hoffentlich in irgendeine Ordnung begeben.

Wenn's fertig ist dann post ich's in opensource.

Aber jetzt muss ich erstmal :coder:

[braingrenade]

Nun bin ich doch noch auf ein Probelem gestoßen:

Wie kann ich (siehe Anhang) den Vector x ausrechnen ?
Alle Variablen die auf dem Bild beschrieben sind hab ich.
Es ist alles in 2d !

[gmarts]

Zitat:

Zitat von braingrenade

Danke für die Vielen Antworten !

Alle diese Kugeln beeinflussen sich gegenseitig, ....

Na dann ist die Variante des Stoßes sicher nicht die richtige, denn dort beeinflusst meist nur eine Kugel eine andere zu einem bestimmten Zeitpunkt. Also keine dauerhafte Wechselwirkung.
Lad dir mal TVGenial runter und klicke dann mit der rechten Maustaste auf das Logo(links oben) ...dabei Shift+Alt gedrückt halten. Dann öffnet sich ein Gravitationssimulator. ..Tolle Sache um mit dem Chaos zu spielen.

[braingrenade]

Die anderen Wechselwirkungen kommen später noch nach ;-)

Aber das Teil kuck ich mir doch glatt mal an.

[gmarts]

Mach das...ein herrlich aufwendiges Easter Egg. :spin2: Spiele schon Stunden damit rum.

[flomei]

hm... Ich hab da nur so ein Kaleidoskop... :(

MfG Florian :hi:

[edit] :oops: Falsche Tastenkombo gedrückt... [/edit]

[braingrenade]

So , nu hab ich mir ne Lösung ausgedacht (siehe anhang) die aber nicht funktionert :(

In code Hab ich das so realisiert :

Delphi-Quellcode:

  var
    i,i2,i3 :integer;
    vbuf,v1,v2 : T2dvector;
    alpha,beta,gamma,lengthv : real;

      ...
 
       vbuf := makevector((chspr[i].x-chspr[i2].x),(chspr[i].y-chspr[i2].y) ) ;
       //chspr ist ein array meiner Chaossprite Klasse, x und y ist die Position des Sprites vom Typ 
       //real, v ist der Vektor des Sprites, v.x und v.y sind auch real
        

       alpha := dotproduct(chspr[i].v,vbuf);
       beta := arctan(chspr[i].v.x/chspr[i].v.y);
       gamma := alpha - beta;
       lengthv := cos(alpha)*(sqrt( sqr(chspr[i].x) + sqr(chspr[i].y)));
       v1 := makevector((lengthv*cos(gamma)),(lengthv*sin(gamma)));

       alpha := dotproduct(chspr[i2].v,vbuf);
       beta := arctan(chspr[i2].v.x/chspr[i2].v.y);
       gamma := alpha - beta;
       lengthv := cos(alpha)*(sqrt( sqr(chspr[i2].x) + sqr(chspr[i2].y)));
       v2 := makevector((lengthv*cos(gamma)),(lengthv*sin(gamma)));


       chspr[i].v := addvectors(chspr[i].v,v1);
       chspr[i2].v := addvectors(chspr[i2].v,v2);

Ich schätze mal der Fehler liegt irgenwo bei sinus oder cosinus.

[ibp]

in welcher form liegen denn die winkel vor ? in Grad oder im Bogenmaß?

[braingrenade]

Das müsste Bogenmaß sein da afaik Delhpi ja alles in Bogenmaß ausrechnet.

[Markus]

Auf Basis dieser Simulation könnte man doch noch irgendwie Schwerkraft oder so einbauen, dass die Kugeln zum Beispiel vom Boden abprallen, oder wenn man 2 Kugel übereinander loslässt (das wäre dann aber schon komplizierter :-) )

[braingrenade]

Genau das hab ich mir auch schon überlegt :mrgreen:

Was auch interessant wäre wenn man Große und kleine Kugeln nimmt könnte man die Diffusion simulieren.

[Markus]

Wenn man eine solche Situation korekt ausrechnen könnte, wärs schon toll :-) (siehe Bild)

[braingrenade]

Das sollte rein theoretisch später mit dem Programm möglich sein, beim dem Aufprall mit der schräge muss man ja "nur" die Regel Einfallwinkel gleich Ausfallwinkel beachten.

[braingrenade]

Ok , ich hab nun meinen Physik-Lehrer gefragt und der hat mir folgende Lösung (siehe Anhang) gegeben, die ich so in Code umgesetzt habe :

Delphi-Quellcode:

type T2dvector = record
    x,y : real;
end;

implementation

function  Tchaos.MakeVector(X,Y : real) : T2dVector;
begin
  result.x := x;
  result.y := y;
end;

function Tchaos.Magnitude(Vector : T2dVector) : real;
begin
   result := sqrt(Vector.X * Vector.X+
                  Vector.Y * Vector.Y);
end;

function Tchaos.DotProduct(VectorA,VectorB : T2dVector) : real;
begin
   result := VectorA.X*VectorB.X+
             VectorA.Y*VectorB.Y
end;


...
var
    i,i2,i3 :integer;
    vbuf,v1,v2 : T2dvector;
    alpha,beta,gamma,delta,lengthv : real;
...
       vbuf := makevector((chspr[i].x-chspr[i2].x),(chspr[i].y-chspr[i2].y) ) ;
       alpha := dotproduct(chspr[i].v,vbuf);
       beta := degtorad( 90-radtodeg(alpha));
       gamma := arctan(chspr[i].v.x/chspr[i].v.y);
       delta := beta + gamma;
       lengthv := sin(alpha)*magnitude(chspr[i].v);
       v1 := makevector((sin(delta)/lengthv),(cos(delta)/lengthv));

       alpha := dotproduct(chspr[i2].v,vbuf);
       beta := degtorad( 90-radtodeg(alpha));
       gamma := arctan(chspr[i2].v.x/chspr[i2].v.y);
       delta := beta + gamma;
       lengthv := sin(alpha)*magnitude(chspr[i2].v);
       v2 := makevector((sin(delta)/lengthv),(cos(delta)/lengthv));

       chspr[i].v := v1;
       chspr[i2].v := v2;
...

Nur leider geht das schon wieder nicht :wall:
Ich bin aber ziemlich sicher das der Fehler etwas damit zu tun hat das Delphi alles im Bogenmaß ausrechnet, aber ich komm nicht drauf wo der genau liegt.

[xineohp]

moin,


ich glaube das das nicht stimmt:
alpha = Skalarprodukt von VerktorA und VektorB

Den Schnittwinkel zweier Graden (Vektoren) berechnet man mit:
cos(alpha) = Skalarprodukt(VektorA, VektorB) / Betrag(=Länge) von VektorA * Betrag von VektorB

[braingrenade]

Ah ja dann hab ich da was falsch verstanden, nur leider is das nicht der einzige Fehler im Code.

Delphi-Quellcode:

       vbuf := makevector((chspr[i].x-chspr[i2].x),(chspr[i].y-chspr[i2].y) ) ;
       
       alpha := arccos(dotproduct(chspr[i].v,vbuf)/(magnitude(chspr[i].v)*magnitude(vbuf)));
       beta := degtorad( 90-radtodeg(alpha));
       gamma := arctan(chspr[i].v.x/chspr[i].v.y);
       delta := beta + gamma;
       lengthv := sin(alpha)*magnitude(chspr[i].v);
       v1 := makevector((sin(delta)/lengthv),(cos(delta)/lengthv));

       alpha := arccos(dotproduct(chspr[i2].v,vbuf)/(magnitude(chspr[i2].v)*magnitude(vbuf)));
       beta := degtorad( 90-radtodeg(alpha));
       gamma := arctan(chspr[i2].v.x/chspr[i2].v.y);
       delta := beta + gamma;
       lengthv := sin(alpha)*magnitude(chspr[i2].v);
       v2 := makevector((sin(delta)/lengthv),(cos(delta)/lengthv));

Geht leider immer noch nicht
:wall: :wall: :wall:

Ich glaub ich steh grad irgendwie auf'm Schlauch...

[xineohp]

so, ich hab das ganze mal durchgerechnet/gezeichnet:

Die pysikalische Seite hab ich mir nicht angeschaut, aber rein mathematisch müsste es so hinhauen.
Die Bilder beziehen sich auf die Billiard-Page, die auf der ersten Seite dieses Threads genannt wurde.

EDIT: bmp --> jpg

[Markus]

Bitte poste die Bilder nächstes mal als JPG :mrgreen:

Ich denk da würden sich einige Modem-User freuen... ;-)

[braingrenade]

Wow vielen Dank !

Nun hab ich meinen Fehler gefunden, ich hatte das VektorD = VektorB - VektorA vergessen,
aber leider versteh ich was an deinem Bild nicht, nähmlich wie kann ich VektorA=VektorD/|VektorD|*a ausrechnen ,ich kann ja nicht einfach den Vektor durch eine Zahl teilen oder?

[supermuckl]

hatte mal nen kugel stoß simulations proggi gemacht um zu testen wie das geht ( 2D )
für n billard proggi

[xineohp]

moin,

das ist ein bisschen Vektorrechnung ;)

Ein Vektor vermittelt folgende Informationen: Richtung, Betrag (und Angriffspunkt).
Wenn man einen VektorX hat, dann ist VektorX / |VektorX| der sogenannte Einheitsvektor zu X.
Der Einheitsvektor hat immer die Länge 1, d.h. |Einheitsvektor|=1. Der Vektor wird damit auf seine Richtung reduziert.

Multipliziert man nun im gegebenen Fall den Einheitsvektor von VektorD mit der Strecke a so erhält man den Vektora.

[xineohp]

Im zweiten Link auf Seite 1 wird das Ganze übrigens im Kapitel Einheitsvektoren behandelt. Die dazugehörige Funktion nennt sich dort "Normalize".

PS: Du kannst einen Vektor beliebig mit einem Skalar(=normale Zahl) multiplizieren/dividieren. Problematisch wirds erst wenn du zwei Vektoren mit einander verarbeiten willst ... normale Multiplikation gibt es da nicht, sondern nur das sogenannte Skalarprodukt.

[dizzy]

Man kann Vektoren natürlich nurch eine reelle Zahl dividieren. Ist ja nicht anderes wie eine Multiplikation mit dem Kehrwert der Zahl.
Mann nennt diese Zahl dann auch "Skalar", da sie den Vektor "skaliert" (in seiner Länge verändert). Dividiert man nun einen Vektor durch seine Länge ist der Ergebnisvektor 1 Einheit lang.
Bei einer normalen Zahl wäre das ja auch z.B.: 5/|5| = 1; da |5| = 5. Somit hätte man quasi einen 1-dimensionalen Vektor auf die Länge 1 "normiert".

Das nur als kleinen Einwurf ;)

[dizzy]

Zitat:

Zitat von xineohp

normale Multiplikation gibt es da nicht, sondern nur das sogenannte Skalarprodukt.

...und das Kreuzprodukt (nur im R³), das dyadische Produkt, im R² das komplexe Produkt, und im 4-dimensionalen Raum das Quaternionen- oder hyperkomplexe Produkt.
Zu dem lässt sich das Skalarprodukt auf Matrizenrechnung zurückführen, wo man sieht, dass es theoretisch unendlich viele verschiedene Skalarprodukte gibt, aber für normal sterbliche eigentlich ausschließlich das triviale von Bedeutung ist. :zwinker:

[xineohp]

:roll: Ich dachte halt das Skalarprodukt würde hier erstmal reichen ... außerdem hatte ich das ganze andere Zeugs noch nicht im Unterricht :mrgreen:

[braingrenade]

Ok dank eurer Hilfe bin ich nun soweit :

Delphi-Quellcode:

      vbuf := subvectors(chspr[i].v,chspr[i2].v) ;

       alpha := arccos(dotproduct(chspr[i].v,vbuf)/((magnitude(chspr[i].v)*magnitude(vbuf))));
       lengthv := cos(alpha)*magnitude(chspr[i].v);
       v1 := scalevector(normalize(vbuf),lengthv); 

       alpha := arccos(dotproduct(chspr[i2].v,vbuf)/((magnitude(chspr[i2].v)*magnitude(vbuf))));
       lengthv := cos(alpha)*magnitude(chspr[i2].v);
       v2 := scalevector(normalize(vbuf),lengthv);

       vbuf := addvectors(v1,v2); // vbuf ist am Ende immer (0,0), v1 und v2 sind "Gegenvektoren"

       chspr[i].v := subvectors(chspr[i].v,vbuf);
       chspr[i2].v := addvectors(chspr[i2].v,vbuf);

Aber vbuf ist am Ende immer (0,0) :shock: und die Bahnen der Kugeln verändern sich deshalb nicht