Studium, Ausbildung und Beruf
 StudiumHome   FAQFAQ   RegelnRegeln   SuchenSuchen    RegistrierenRegistrieren   LoginLogin

Formel gesucht
Gehe zu Seite Zurück  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12  Weiter
Neues Thema eröffnen   Neue Antwort erstellen
Foren-Übersicht -> Mathe-Forum -> Formel gesucht
 
Autor Nachricht
algebrafreak
Senior Member
Benutzer-Profile anzeigen
Senior Member


Anmeldungsdatum: 28.10.2004
Beiträge: 4143
Wohnort: Passau

BeitragVerfasst am: 13 Jun 2005 - 10:00:56    Titel:

Hmm, was wird das wohl für eine Sprache sein. Was eingebettetes vermutlich. Naja, ist auch egal.

Die Darstellung eines Objektes durch einen Vektor ist nicht ausrechend. Du brauchst mindestens einen Vektor für die Länge und einen für die Stützstelle (Genau so, wie von dem Spieler selbst). Wenn das gegeben ist, etwa (u,v) als Stützvektor bzw. (du,dv) als Richtungsvektor des Objektes und (x,y) als Stützvektor bzw. (dx,dy) als Richtungsvektor des Spielers, so beschreibt die Vektorgleichung:

(a,b) = (x,y) + alpha (dx,dy)

für alpha > 0 die Blickrichtung des Spielers und

(a,b) = (u,v) + beta (du,dv)

für beta in [0,1] die Objektmaße. Somit gilt im Falle des Schnittes

(x,y) + alpha (dx,dy) = (u,v) + beta (du,dv)

Daraus läßt sich alpha und beta wiefolgt berechnen:

>> eq1;

x + al dx = u + be du
>> eq2;

y + al dy = v + be dv
>> solve({eq1,eq2},{al,be});

Code:



         / { --        dv u - du v - dv x + du y
piecewise| { |  al = - -------------------------,
         \ { --              du dy - dv dx

          dy u - dx v - dy x + dx y -- }
   be = - -------------------------  | } if du dy - dv dx <> 0 and dx <> 0,
                du dy - dv dx       -- }

   { --      dy u - dy x + be dv dx -- }
   { |  al = ----------------------  | } if
   { --               dx dy         -- }

   - dy u + dx v + dy x - dx y = 0 and du dy - dv dx = 0 and dx <> 0,

   {} if du dy - dv dx = 0 and (- dy u + dx v + dy x - dx y <> 0 or

   dx = 0 and (u - x <> 0 and dy = 0 or u - x <> 0 or dv = 0 and dy = 0)),

   { --      v - y + be dv -- }
   { |  al = -------------  | } if dy <> 0 and du = 0 and dx = 0 and u = x,
   { --            dy      -- }

   { --        v - y -- }
   { |  be = - -----  | } if u - x = 0 and dv <> 0 and dx = 0 and dy = 0,
   { --          dv  -- }

   { --      u - x + be du -- }
   { |  al = -------------  | } if - dv u + du v + dv x - du y = 0 and
   { --            dx      -- }

   du dy - dv dx = 0 and dx <> 0, {} if

   du dy - dv dx = 0 and (- dv u + du v + dv x - du y <> 0 or

   dx = 0 and (dv u - du v - dv x + du y <> 0 or u - x <> 0 and du = 0 or

                        { --        u - x -- }
   du = 0 and dv = 0)), { |  be = - -----  | } if
                        { --          du  -- }

   dv u - du v - dv x + du y = 0 and du <> 0 and dx = 0 and dy = 0,

   { --        v - y -- }
   { |  be = - -----  | } if u - x = 0 and dv <> 0 and du = 0 and dx = 0,
   { --          dv  -- }

   { --      u - x + be du -- }
   { |  al = -------------  | } if - dy u + dx v + dy x - dx y = 0 and
   { --            dx      -- }

   du dy - dv dx = 0 and dx <> 0, {} if

   - dy u + dx v + dy x - dx y <> 0 and du dy - dv dx = 0,

   { --      dv u - dv x + be du dv -- }
   { |  al = ----------------------  | } if
   { --               du dy         -- }

   - dv u + du v + dv x - du y = 0 and du dy - dv dx = 0 and du dy <> 0,

   {} if du dy - dv dx = 0 and (du dy = 0 and u - x <> 0 or

   - dv u + du v + dv x - du y <> 0 or u <> x and dy = 0 or

   du dy = 0 and (dv u - du v - dv x + du y <> 0 or

   u - x <> 0 and du = 0 or du = 0 and dv = 0) or dv = 0 and dy = 0),

   { --      v - y + be dv -- }
   { |  al = -------------  | } if -dv dx = 0 and dy <> 0 and du = 0 and
   { --            dy      -- }

          { --        v - y -- }
   u = x, { |  be = - -----  | } if du dy - dv dx = 0 and
          { --          dv  -- }

   (du = 0 or dy = 0) and dv <> 0 and u = x,

   { --        u - x -- }
   { |  be = - -----  | } if dv u - du v - dv x + du y = 0 and
   { --          du  -- }

                                      {
   -dv dx = 0 and du <> 0 and dy = 0, {
                                      {

   --        dv u - du v - dv x + du y         u - x -- }
   |  al = - -------------------------, be = - -----  | } if
   --                  du dy                     du  -- }

                                   { --      v - y + be dv -- }
   du <> 0 and dy <> 0 and dx = 0, { |  al = -------------  | } if
                                   { --            dy      -- }

   u - x = 0 and dy <> 0 and du = 0 and dx = 0,

   {} if (du = 0 and (u - x <> 0 and dy = 0 or u - x <> 0 or

   dv = 0 and dy = 0) or dy = 0 and (dv u - du v - dv x + du y <> 0 or

   u - x <> 0 and du = 0 or du = 0 and dv = 0)) and dx = 0,

   { --        v - y -- }
   { |  be = - -----  | } if u - x = 0 and dv <> 0 and du = 0 and
   { --          dv  -- }

                      { --        u - x -- }
   dx = 0 and dy = 0, { |  be = - -----  | } if
                      { --          du  -- }

                                                                     \
   - dv u + du v + dv x - du y = 0 and du <> 0 and dx = 0 and dy = 0 |
                                                                     /



Dich interessiert aber nur der Fall, daß die Vektoren nicht 0-Vektoren sind und nicht parallel liegen (du dy - dv dx = 0). Das ist vor allem der erste Fall. Und daraus läßt sich auch ableiten, ob der Strahl das Objekt trifft oder nicht. Falls al < 0, dann ist das Objekt hinter dem Spieler. Falls be < 0 oder be > 1, so trifft der Strahl das Objekt nicht.

P.S. Ich habe bereits mehrere Implementierungen von diesem Verfahren gemacht. Mal für neuronale Netze, mal für RoboCUP, mal für eine Karte für einen 3D-Shooter. Und ich habe ein altes Buch, in dem das ganze auf Assembler-Niveau beschrieben wird. Wegen Passau, ich habe im aktuellen Semester jemanden mit gleichen Namen korrigiert.


Zuletzt bearbeitet von algebrafreak am 13 Jun 2005 - 10:37:57, insgesamt 8-mal bearbeitet
algebrafreak
Senior Member
Benutzer-Profile anzeigen
Senior Member


Anmeldungsdatum: 28.10.2004
Beiträge: 4143
Wohnort: Passau

BeitragVerfasst am: 13 Jun 2005 - 10:14:32    Titel:

Schau mal da rein. Ich benutze das selbe Verfahren um die Sonarkontakte mit den Wänden auszurechnen.

http://www.fmi.uni-passau.de/~lasaruk/sonar/index.html
algebrafreak
Senior Member
Benutzer-Profile anzeigen
Senior Member


Anmeldungsdatum: 28.10.2004
Beiträge: 4143
Wohnort: Passau

BeitragVerfasst am: 13 Jun 2005 - 18:06:05    Titel:

Zitat:
Heißt es, daß Du Dich nicht drehen willst. Die Lösung mit einem festen Reichtungsvektor bedeutet nämlich, daß Du zum Drehen die Welt um Dich herum drehen mußt!

Zitat:
Genau, Das ist nämlich einfacher, als anders herum.



Naja. Aus der Sicht der Komplexität der Drehung ist das Drehen an sich in O(1). Das Drehen der Welt geht in O(n) mit n Anzahl der Objekte. Die Ray-Casting-Technik bezieht sich allerdings (meines Wissens) nicht auf eine feste Stelle (obwohl in DOOM, glaube ich, die Welt sich auch dreht). Daher ist die Komplexität für die Darstellung konstant O(k*n), wobei k die Anzahl der Strahlen und n die Anzahl der Objekte. Obwohl die Summe natürlich in beiden Fällen wieder in O(k*n) ist, ist es trotzdem deutlich teurer. Da muß das Verfahren selbst was hergeben, damit es insgesamt einfacher (bzw. schneller geht).

Ich weiß nicht, was ich da an Zahlen rechnen kann. Was soll ich denn da ausrechnen? Schau mal den Code des Java-Applets an

Code:

    double cutLine(double x, double y, double a, double[][] l) {
        double dx0 = Math.cos(a);
        double dy0 = Math.sin(a);
        double x0 = x;
        double y0 = y;
        double dx1 = l[TO][X] - l[FROM][X];
        double dy1 = l[TO][Y] - l[FROM][Y];
        double x1 = l[FROM][X];
        double y1 = l[FROM][Y];

        if (dx1*dy0-dx0*dy1 == 0) return(BIG_DOUBLE);

        double al = (x0*dy1-y0*dx1-x1*dy1+y1*dx1)/(dx1*dy0-dx0*dy1);
        double be = (x0*dy0-y0*dx0-x1*dy0+y1*dx0)/(dx1*dy0-dx0*dy1);

        if (be <= 1 && be >= 0 && al >= 0)
            return(al);
        else
            return(BIG_DOUBLE);
    }


P.S: Poste doch Deinen kompletten PHP Code rein. Schauen wir mal, ob ich den Code so modifizieren kann, daß es funzt.
progs
Junior Member
Benutzer-Profile anzeigen
Junior Member


Anmeldungsdatum: 13.06.2005
Beiträge: 61

BeitragVerfasst am: 14 Jun 2005 - 10:40:39    Titel:

Allzuviel nützt mir das Java Code nichts, den die entscheidene Stelle fehlt wieder.

Code:

        double dx1 = l[TO][X] - l[FROM][X];
        double dy1 = l[TO][Y] - l[FROM][Y];
        double x1 = l[FROM][X];
        double y1 = l[FROM][Y];


Wie komme ich auf diese array-Werte, bzw. was sind das für Werte?

Hier mal mein PHP-Code:

Code:

for($i = 1; $i <= 320; $i++) {
   for($i2 = 0; $i2 < count($map_objects[0]); $i2++) {
      // Steigung Objekt
      $m1 = ($y2 - $y1) / ($x2 - $x1);
      // Länge Object
      $ax = $x2 - $x1;
      $ay = $y2 - $y1;
      $object_width = sqrt(($ax * $ax) + ($ay * $ay));
      
      // Steigung Sichtwinkel
      $m2 = tan(90 - ($i * $degree_step));
      
      // Schnittpunkt
      $xs = ($y1 - $m1 * $x1) / ($m2 - $m1);
      $ys = $m2 * $xs;
      
      // Länge Blickpunkt -> Schnittpunkt
      $view_width = sqrt(($xs * $xs) + ($ys * $ys));
      // Faktor 1
      $f1 = $view_width / $object_width;
      
      // Länge Object -> Schnittpunkt
      $ax = $xs - $x1;
      $ay = $ys - $y1;
      $os_width = sqrt(($ax * $ax) + ($ay * $ay));
      // Faktor 2
      $f2 = $os_width / $object_width;
      
            
      if($f1 > 0) {
         if($f2 > 0 && $f2 < 1) {
            // Halbe Höhe errechnen
            $height = $res_height * $f1 / 2;
            // Linie zeichnen
            imageline($img, $i, res_height - $height, $i, $res_height + $height, $nontexturecolor);
         }
      }
   }
}
algebrafreak
Senior Member
Benutzer-Profile anzeigen
Senior Member


Anmeldungsdatum: 28.10.2004
Beiträge: 4143
Wohnort: Passau

BeitragVerfasst am: 14 Jun 2005 - 11:23:48    Titel:

Zitat:
Wie komme ich auf diese array-Werte, bzw. was sind das für Werte?


Na das ist gar kein Problem. Die Werte sind, wie auch die (total unsaubere) Form andeutet die Anfangs und Endpunkte deiner Objekte.
FROM=0 ist der Startpunkt TO=1 ist der Endpunkt, X=0 und Y=1 sind die jeweiligen x und y koordinaten. So wäre für eine Gerade von (0,1) nach (3,4):

l[FROM][X] = 0
l[FROM][Y] = 1
l[TO][X]=3
l[TO][Y]=4

Hilft das? x und y ist die Position des Spielers und a ist der Blickwinkel. Wie Du siehst drehe ich mich und nicht die Welt. Auf dem Bild schaut es hingegen anders aus, da ich beim Zeichnen das Bild drehe. Ich weiß auch nicht warum ich das gemacht habe. Vielleicht, damit man die Sonarkontakte besser identifizieren kann. Was weiß ich. Das war ja schon vor 3 Jahren. Wir haben eine 90000 Zeilen lange Roboter-Ansteuerung geschreiben, und das Beispiel sollte zeigen, daß Sonarsensoren ausreichend für die Positionsbestimmung sind.

Was dein Programm anbetrifft, so werde ich es mir heute Abend anschauen.
progs
Junior Member
Benutzer-Profile anzeigen
Junior Member


Anmeldungsdatum: 13.06.2005
Beiträge: 61

BeitragVerfasst am: 14 Jun 2005 - 11:32:07    Titel:

Das hilft mir auf jeden Fall weiter. Mal schauen ob ich das jetzt irgendwie hinwurschteln kann.
progs
Junior Member
Benutzer-Profile anzeigen
Junior Member


Anmeldungsdatum: 13.06.2005
Beiträge: 61

BeitragVerfasst am: 14 Jun 2005 - 11:51:32    Titel:

Hab jetzt mal Deinen Code umgesetzt, und bekomme Dabei folgendes heraus:

http://test.bauer-martin.com/3d/engine.php

so ähnlich schauts auch mit meinem Code aus.
algebrafreak
Senior Member
Benutzer-Profile anzeigen
Senior Member


Anmeldungsdatum: 28.10.2004
Beiträge: 4143
Wohnort: Passau

BeitragVerfasst am: 14 Jun 2005 - 12:03:12    Titel:

Ich sehe nur ein Bild mit einer roten und einer schwarzen hälfte waagerecht geteilt.
progs
Junior Member
Benutzer-Profile anzeigen
Junior Member


Anmeldungsdatum: 13.06.2005
Beiträge: 61

BeitragVerfasst am: 14 Jun 2005 - 12:05:28    Titel:

Ja, das ist der Boden/Decke.

Und dazwischen sind ein paar blaue Linien die von oben nach unten gehen. Und das ist die Darstellung des Objektes.
algebrafreak
Senior Member
Benutzer-Profile anzeigen
Senior Member


Anmeldungsdatum: 28.10.2004
Beiträge: 4143
Wohnort: Passau

BeitragVerfasst am: 20 Jun 2005 - 18:43:33    Titel:

Es gibt wiederrum mehrere mögliche Fehlerquellen. Kannst Du mal schauen, wie oft die Körper der Bedingungen

Code:
if($dx1 * $dy0 - $dx0 * dy1 != 0) {
,

Code:
if($beta <= 1 && $beta >= 0 && $alpha > 0) {
und

Code:
if(!empty($si_t[0]))


aufgerufen Werden? Du überlädst die globale "sector" Variable mit dem Parameter "sector". Das ist nicht gut, denn Du wirst beide in dieser Funktion brauchen. Die Bedingung

Code:
if(!empty($si_t[0])) {


sollte anders lauten. Man kann nicht garantieren, daß alle inneren Seiten in den Sektor zeigen. Man muß prüfen, welcher Seite der Sektor zugewiesen wurde.

"Wenn s_i = sector und zugleich t_i gesetzt oder s_o = sector und zugleich t_o gesetzt"

Der else Case sollte dabei gar nichts machen. Da kommt die Rekursion mit einem anderen Sektor rein.

So wie ich das sehe, ist das Problem eine Daten-Struktur-Problem. Könntest Du mal danach den Spielerwinkel paar mal verändern und standbilder machen.
Beiträge der letzten Zeit anzeigen:   
Foren-Übersicht -> Mathe-Forum -> Formel gesucht
Neues Thema eröffnen   Neue Antwort erstellen Alle Zeiten sind GMT + 1 Stunde
Gehe zu Seite Zurück  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12  Weiter
Seite 2 von 12

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.

Chat :: Nachrichten:: Lexikon :: Bücher :: Impressum