Beschleunigungsvektor in Weg eines gek. Systems

Hallo!

der Code sieht - soweit ich das überblicken kann - gut aus.
Die Variablen weg_x, weg_y und weg_z geben aber nur den in dt
zurückgelegten Weg an. Sie entsprechen nicht der Gesamtstrecke
von Anfang an. Dazu müsste dann zu jedem weg_x noch jeweils
der weg_x aus der vorherigen time bin dazuaddiert werden.

Ja. Allerdings gebe ich ja auch relative Koordinaten weiter. Mit relativ meine ich: „Bewege jetzt die Maus um 3 Pixel nach links“ versus „Bewege die Maus zu Koordinate X = 332“.

Ich habe noch eine Verständnisfrage:
Sollen die Trackingdaten dazu dienen, die Blickrichtung des
Spielers im virtuellen Raum festzulegen? Also so ähnlich wie
in der Animation?

Gut formuliert. Genau das meine ich. Bildlich gesprochen: Schaue ich geradeaus nach vorne, ist der Winkel zu meiner Sichtachse 0°. Schaue ich 30° nach links davon, schaue ich auch 30° in meiner 3D-Anwendung nach links. Das heißt, sobald ich bei 30° im Spiel angekommen bin, soll MausRelativX Null sein.

Noch eine Frage zur Schwerkraftkompensation. Wird die
Erdbeschleunigung „von Hand“ aus den Daten herausgerechnet
oder macht das schon der Sensor im Handy? Möglicherweise
könnte man nämlich die Lagebestimmung durch das Auslesen der
Richtung der Erdbeschleunigung vereinfachen.

Gute Frage. Die Daten werden so herausgerechnet: http://pastebin.com/YibG51V3 bzw. http://developer.android.com/reference/android/hardw…

Grüße aus Köln

donatus

Ok,
dann würde ich die Bahn, also die momentane Position x(t), durch numerische Integration berechnen. Um dann auf die Mausposition zu kommen, muss x(t) auf die Kugelfläche projiziert werden (Stichwort: Richtungskosinus fällt mir da jetzt mal spontan ein).

Aber wäre dann nicht der Gyrosensor die bessere Wahl? Ähnlich wie bei einer Kompassanwendung, die gleich eine Richtung anzeigt? Ich kenn mich aber - was die Hardware im Handy und die zugreifbaren Variablen betrifft - nicht wirklich aus.

Aber wäre dann nicht der Gyrosensor die bessere Wahl? Ähnlich
wie bei einer Kompassanwendung, die gleich eine Richtung
anzeigt? Ich kenn mich aber - was die Hardware im Handy und
die zugreifbaren Variablen betrifft - nicht wirklich aus.

Ja, aber einen Gyrosensor hat mein Handy nicht. Einen Kompaß schon, dieser ist aber sehr langsam bei nur 1° Auflösung.

Hallo,

In einem System wo sich die Beschleunigungen mit der Zeit ständig ändern, kann man keine so einfachen Gleichungen nehmen wie Du sie aufführst, sondern muss die Beschleunigung über die Zeit integrieren. (Such mit dem Stichwort „Integral“ oder „Integrationsrechnung“ wenn Du mehr Informationen hierzu brauchst.)
Die Umrechnung des gekippten Koordinatensytems in ein nicht gekipptes ist dagegen vergleichsweise einfach mit einer Korrdinatentransformation zu erreichen. (Auch hier wird es natürlich komplizierter wenn sich der Kippwinkel über die Zeit ändert!)
Insgesamt erfordert das ganze einen größeren Programmieraufwand für eine iterative Berechnung, die nicht ohne Weiteres in analytischen Gleichungen darstellbar ist. Die Berechnungen kann aber jeder Computer (auch der im Handy) schaffen.

Viele Grüße,
Frank

Als Kombination evtl. den schwächer auflösenden Sensor als Bodenrelation und den beseren als eigentlichen Rotationssensor.

Ih würde allerdings zu anderen Methoden greifen, Motioncontroll zu betreiben. Wie wär es denn mit hiermit: http://www.golem.de/0610/48213.html

http://www.golem.de/0610/48213.html

Bist du sicher, daß du verstanden hast worauf ich hinauswill?

Hallo

was für ein Sensor ist das denn? Wirklich ein Beschleunigungssensor der nur bei beschleunigung Daten liefert oder ein Lagesensor (Gyro) der die Lage des Gerätes zur Erdnormalen angibt ?

Bei einen Beschleunigungssensor ist die Anfangslage nicht so wichtig da im Ausgangszustand theoretisch keine Beschleuinigung auftritt (Erdbeschleunigung ausgenommen).

Dein Ansatz für die Vektoren sieht doch ganz gut aus, ich würde mal behaupten das X_Maus_relativ = f(X_Handy,Z_Handy) und Y_Maus_relativ =
f(Y_Handy,Z_Handy) ausreichen und dem Mauscursor zu steuern.

Du musst natürlich noch die Zeit zwischen Beschelunigung und Abbremsen bestimmen und deinen Vektor verwenden zu können.

Hallo Donatus, das ist eine interessante Aufgabe, leider habe ich im Moment nicht soviel Zeit, um mich darein zu vertiefen … habe also bitte Verständnis dafür, dass ich diesesmal nicht helfen kann …

Viel Erfolg beim Weitersuchen …
Jórg

Dieses zeigt symbolhaft ein Mobiltelefon, das am Hinterkopf
eines
Menschen angebracht ist. Die weißen Kugeln symbolisieren die
Augen,
Drehung geschieht um den Hals in den Freiheitsgraden, die ein
Kopf hat.

Das Display des Mobiltelefones zeigt nach außen. Es hat einen
Schwerkraftkompensierten 3D-Beschleunigungssensor. Das heißt,
wird der
Kopf beschleunigt, wird auch das Mobiltelefon beschleunigt,
und - nicht
vergessen - negativ beschleunigt beim Abbremsen.

Wie es bei Headtrackern so ist, soll die Bewegung auf
Mausbewegung
umgelenkt werden. Das ist soweit kein Problem. Auch die Daten
vom Handy
zu gewinnen ist kein Problem.

Nein, es ist ein Logikproblem, aus den X, Y und Z-Komponenten
der
Beschleunigung(siehe
http://developer.android.com/images/axis_device.png
) relative Mausbewegungen abzuleiten.

Die Frage ist konkret: Wie muß - bei den im Video gezeigten
Bewegungen(merke, das Mobiltelefon ist gekippt) - eine
Funktion
X_Maus_relativ = f(X_Handy,Y_Handy,Z_Handy) und Y_Maus_relativ

f(X_Handy,Y_Handy,Z_Handy) aussehen?

Meine Ideen:
Weg_Vektor = Beschleunigung_Vektor * (Zeit)².

Weg_x = Beschleunigung_x * (Zeit)²
Weg_y = Beschleunigung_y * (Zeit)²
Weg_z = Beschleunigung_z * (Zeit)²

Du willst die Rotation deines Kopfes festhalten!?

Hallo donathus,

das ist ja schon ganz schön kompliziert.
Ich lese mich gerade ein bißchen durch den android devguide.

Ich habe den Eindruck, dass sich für die Lagebestimmung der
„Rotation Vector Sensor“ eignet
(http://developer.android.com/guide/topics/sensors/se… ganz unten und
http://www.sensorplatforms.com/which-sensors-in-andr…).
Weiß nur noch nicht wie.

Ich beschreib jetzt einfach mal, wie sich das Orientierungsproblem für mich darstellt
und vielleicht kommen wir dann auf einen Nenner.

Also zunächst die „Hardwaresituation“: Jemand hat das Handy am Hinterkopf - vermutlich in irgendeiner Halterung, so dass eine exakte Ausrichtung zu den Drehachsen des Kopfes nicht vorliegt und die reale Ausrichtung des Handys zu der „idealen“ Ausrichtung transformiert werden muss.
Dies könnte man durch eine kurze Kalibrationssequenz sicherstellen, z.B. indem der Spieler auf einen festgelegten Punkt vor ihm auf 0°/0° (links-rechts/oben-unten) schaut und die Rotation des Handys bezüglich der idealen Achsen festgestellt wird (z.B. durch den Gravity Sensor).

Dann stelle ich mir vor, dass der Spieler genau nach vorne schaut, das Handy ist kalibriert.
Entlang der optischen Achse der Augen verläuft die Horizontebene des Spielers. Oder anders ausgedrückt:
Die Sichtachse verläuft in Verlängerung der -z-Achse des Handys, die x-Achse des Handys spannt die Horizontebene auf.

An der folgenden Stelle bin ich mir jetzt nicht mehr sicher:
Erste Möglichkeit: Spielen sich die Aktionen auf einer Bildebene vor dem Betrachter ab? Du schreibst von Mausbewegungen relativ_x und relativ_y, deshalb komme ich darauf.
Oder - zweite Möglichkeit- kann man sich die von den Bildschirmen dargestellten Bilder als Bilder vorstellen, die sich auf einer Kugelfläche vor dem Betrachter projiziert befinden?
Intuitiv würde ich sagen, dass sich die Position des Cursors eher durch Winkel theta (rauf-runter)
und phi (links-rechts) beschreiben lassen sollte.

Sollte dieser zweite Fall stimmen, dann könnte man nämlich ein schönes Koordinatensystem in die Mitte des Kopfes des Spielers konstruieren. Die Sichtachse nach vorne würde sich in Verlängerung der Position des Handys nach hinten befinden. Der Horizont würde über die x-Achse des Handys festgelegt.

Jetzt lassen sich folgende Bewegungen durchführen, die alle für sich detektiert werden müssen.

  1. Drehung des Kopfes nach links-rechts
  2. Nicken des Kopfes nach oben-unten
  3. Kippen (Rollen) des Kopfes entlang der z-Achse des Handys in Neutralposition

Diese Bewegungen können eigentlich durch den Sensor „TYPE_ORIENTATION“ bestimmt werden (http://developer.android.com/guide/topics/sensors/se…)
Allerdings ist dieser Type seit Android 2.2 als „deprecated“ eingestuft. Stattdessen wird auf die Methoden „getRotationMatrix()“ und „getOrientation()“ verwiesen.

Aber vielleicht lässt sich hier der Sensor „TYPE_ROTATION_VECTOR“ ausnutzen. Mit diesem lässt sich die Drehung des Handys bezüglich bestimmter Achsen auslesen
(sieh dazu http://developer.android.com/reference/android/hardw… unter diesem Sensor).
Da wir ja eigentlich nur Drehbewegungen haben, scheint dies ein vielversprechender Weg zu sein.
Mit getRotationMatrix() werden diese Daten dann in ein Weltkoodinatensystem transformiert.
Ich vermute, dass sich Position des Handys auf der Kugelschale dann als Vektor ausgeben lässt.
Der antiparallele Vektor zu diesem wäre dann der Sichtachsenvektor.

Zusammenfassend will ich sagen, dass es wahrscheinlich sinnvoller ist, einen für diesen Zweck geeigneten virtuellen Sensor und ein paar Methoden zu verwenden, als das Rad neu zu erfinden und die Rohdaten der Beschleunigungsensoren mit aufwendiger Mathematik zu beackern.

Da ich von der Androidprogrammierung (noch) nicht so viel verstehe, sind diese ganzen Aussagen natürlich unter Vorbehalt zu verstehen. Bin aber gespannt, was Du dazu meinst. Helfen könnte ich dann wieder bei möglichen Verständnisproblemen bezüglich Sinn und Eigenschaften von Rotationsmatrizen.

Schöne Grüße aus dem Schwabenland,

Daniel

P.S.: Vielleicht hilft diese Demo hier noch weiter http://developer.android.com/resources/samples/ApiDe…

hallo, tut mir leid, kann dazu nichts ssgen; mein Bereich ist Elektrotechnik. Gruß Hufer

Hallo,
bei dieser Weg-Beschleunigungsgleichung fehlt der Faktor 1/2:
weil x(t)= Integral [v(t).dt]
und v(t)= b*t
zusammen: x(t)= Integral [b\*t dt]=1/2 * b *t²
Okeh?

deine Ideen:

Weg_Vektor = Beschleunigung_Vektor * (Zeit)².

Weg_x = Beschleunigung_x * (Zeit)²
Weg_y = Beschleunigung_y * (Zeit)²
Weg_z = Beschleunigung_z * (Zeit)²

Hallo,

verstehe die Frage. Schwer zu beantworten. Das subjektive Gefühl des Kopfbewegens muss der Bewegung der Maus entsprechen. Größere Beschleunigungen müssen auch zu größeren Mausbewegungen führen, nichtlinear vermute ich.
Deshalb sollte in der Formal die Beschleunigung mit einem Exponenten gewichtet werden, also
Mausweg = (Beschleunigung) hoch X * Zeit*Zeit

Die Zeit ist eigentlich ziemlich egal, weil die Kopfbewegung immer nur kurze Zeit dauert.
Es dürfte auch schwierig sein, die Maus zum Stillstand zu bringen. Wenn der Kopf einige Zeit keine Beschleunigung ausführt, so muss die Maus abgebremst werden.

Am besten ausprobieren.

Freundliche Grüße

Liebe/-r Experte/-in,

unter http://www.youtube.com/watch?v=XwwJkF9KDOA findest du
ein Video.
Dieses zeigt symbolhaft ein Mobiltelefon, das am Hinterkopf
eines
Menschen angebracht ist. Die weißen Kugeln symbolisieren die
Augen,
Drehung geschieht um den Hals in den Freiheitsgraden, die ein
Kopf hat.

Das Display des Mobiltelefones zeigt nach außen. Es hat einen
Schwerkraftkompensierten 3D-Beschleunigungssensor. Das heißt,
wird der
Kopf beschleunigt, wird auch das Mobiltelefon beschleunigt,
und - nicht
vergessen - negativ beschleunigt beim Abbremsen.

Wie es bei Headtrackern so ist, soll die Bewegung auf
Mausbewegung
umgelenkt werden. Das ist soweit kein Problem. Auch die Daten
vom Handy
zu gewinnen ist kein Problem.

Nein, es ist ein Logikproblem, aus den X, Y und Z-Komponenten
der
Beschleunigung(siehe
http://developer.android.com/images/axis_device.png
) relative Mausbewegungen abzuleiten.

Die Frage ist konkret: Wie muß - bei den im Video gezeigten
Bewegungen(merke, das Mobiltelefon ist gekippt) - eine
Funktion
X_Maus_relativ = f(X_Handy,Y_Handy,Z_Handy) und Y_Maus_relativ

f(X_Handy,Y_Handy,Z_Handy) aussehen?