Revision history for TutoriumMobileEingebetteteIntelligenzSS18
Additions:
CategoryTutorienFKITSS18;CategoryTutorienFKITSS19
Deletions:
Additions:
----
CategoryTutorienFKITSS18;
CategoryTutorienFKITSS18;
Additions:
{{image class="center" url="1.png" width="300"}}
{{image class="center" url="2.png" width="300"}}
{{image class="center" url="3.png" width="300"}}
{{image class="center" url="4.png" width="300"}}
{{image class="center" url="5.png" width="300"}}
{{image class="center" url="2.png" width="300"}}
{{image class="center" url="3.png" width="300"}}
{{image class="center" url="4.png" width="300"}}
{{image class="center" url="5.png" width="300"}}
Deletions:
{{image url="2.png" width="200"}}
{{image url="3.png" width="200"}}
{{image url="4.png" width="200"}}
{{image url="5.png" width="200"}}
Additions:
{{image url="1.png" width="200"}}
Abb.: Achsen eines Smartphones:
(Quelle: developer.android.com)
**Funktionsweise der App**
{{image url="2.png" width="200"}}
Abb.: Grafische Oberfläche der Aufzeichnungsanwendung
Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird. Zum Aufzeichnen wird der Knopf in der Mitte gedrückt und gehalten, wenn die Aufzeichnung beendet ist, den Knopf bitte loslassen. Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
{{image url="3.png" width="200"}}
Abb.: Verzeichnis mit aufgezeichneten Datein auf Smartphone
In dem Bild lässt sich auch schon erkennen wie das Namesschema der Dateien ist:
1) rot - Typ der Geste (quadrat, circle, hline...)
1) grün - Zufallszahl
1) blau - Sensortyp (lin_acc, magf, grav..., bitte beachten es sind mehr Sensoren, als oben aufgeführt)
1) .csv
Die Dateien lassen sich entweder manuell per USB auf den PC übertragen (Ordner: Android/data/com.example.schieck.ga/files/*) oder per Email an eine zuvor eingestellte Adresse versenden. Sie enthalten die Bewegungsmuster die später genutzt werden um das neuronale Netz zu trainieren.
{{image url="4.png" width="200"}}
Abb.: Inhalt einer csv Datei
In dem Bild sieht man was der Sensor eigentlich macht, es wird zu einem bestimmten Zeitpunkt ein bestimmter Zustand gemessen. Die App schreibt dann diese Zustände in die Dateien.
Es liegen also timestamp-value-paare vor.
**Implementierung**
Namensschema:
[Geste].[Zufallszahl].[Sensortyp].csv
Das Namensschema hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, was sie enthält.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
{{image url="5.png" width="200"}}
Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein SensorManager genutzt und ein SensorEventListener (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
class MainActivity() : Activity(), SensorEventListener {
var sensor_manager: SensorManager? = null
...und im onCreate() Callback initialisiert.
sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte, da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.
- Abtastraten
val delay = SensorManager.SENSOR_DELAY_FASTEST
{{image url="6.png" width="400"}}
//
Die Quellcodes können von mir direkt erhalten werden, bitte schreiben sie mich an. __schieck@stud.fh-sm.de__//
**{{color text="2. Vorverarbeitung der Daten:" c="#00386a"}}**
**Anpassen der Zeitstempel**
Um die timestamps besser überschauen zu können, wird von allen timestamps der niedrigste abgezogen, das geschieht mit:
fun adjustTimestamps(sample: Sample): Sample {
var first = sample.timestamp.first()
var retVal = sample
sample.timestamp.forEachIndexed { index, fl ->
retVal.timestamp[index] -= first
}
return retVal
}
**
Betragsquadrat berechnen **
Mittels des Betragsquadrat werden aus den Werten für x, y und z, ein Wert gemacht. Dadurch wird erreicht das die Werte Orientierungsunabhängig sind.
TODO: hier gehört ne formel hin, aber ==formel== ... ==formel== funktioniert nicht...
fun AbsoluteSquare(sample: Sample): Sample {
val sampleSize = sample.x.size
val retVal = Sample(sample.sensor, sample.gesture)
for (i in 0 until sampleSize) {
val absSquare = Math.abs((sample.x[i] + sample.y[i] + sample.z[i]))
retVal.absoluteSquare.add(absSquare)
}
return retVal
}
**Fehlende Werte ermitteln**
Die Werte die von Android Sensoren zurückgeliefert werden, sind nicht äquidistant (gleicher zeitlicher Abstand zwischen den Messwerten). Das ist aber nötig um sie später einem maschinellem Lernalgorhythmus zuzuführen. Die Sensoren von Android Geräten haben i.d.R. eine Abtastrate von 20-80Hz. Daher ist, verbunden mit der Unsicherheit WANN bestimmte Sensoren, bestimmte Werte zurückliefern, eine starke Fluktuation zu erkennen.
{{image url="7.png" width="400"}}
Abb.: Nicht-Äquidistante Abstände bei den Timestamps
Um dieses Problem zu beheben kann man das Signal (linear) interpolieren. Dabei werden die fehlenden Punkte durch die Mittel der umliegenden Punkte aufgefüllt.
TODO: Formel für lineares interpolieren, die YAML für die wiki nervt echt, sie kommt nicht mal mit simplen formeln klar...
fun interpolate(sample: Sample): Sample {
//require(count < 2) { "interpolate: illegal count!" }
val retVal = sample
for (i in 0 until sample.size) {
retVal.timestamp[i] = sample.timestamp.first() + i * (sample.timestamp.last() - sample.timestamp.first()) / sample.size
retVal.x[i] = sample.x.first() + i * (sample.x.last() - sample.x.first()) / sample.size
retVal.y[i] = sample.y.first() + i * (sample.y.last() - sample.y.first()) / sample.size
retVal.z[i] = sample.z.first() + i * (sample.z.last() - sample.z.first()) / sample.size
}
return retVal
}
**Trainieren von OLVQ1**
Abb.: Achsen eines Smartphones:
(Quelle: developer.android.com)
**Funktionsweise der App**
{{image url="2.png" width="200"}}
Abb.: Grafische Oberfläche der Aufzeichnungsanwendung
Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird. Zum Aufzeichnen wird der Knopf in der Mitte gedrückt und gehalten, wenn die Aufzeichnung beendet ist, den Knopf bitte loslassen. Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
{{image url="3.png" width="200"}}
Abb.: Verzeichnis mit aufgezeichneten Datein auf Smartphone
In dem Bild lässt sich auch schon erkennen wie das Namesschema der Dateien ist:
1) rot - Typ der Geste (quadrat, circle, hline...)
1) grün - Zufallszahl
1) blau - Sensortyp (lin_acc, magf, grav..., bitte beachten es sind mehr Sensoren, als oben aufgeführt)
1) .csv
Die Dateien lassen sich entweder manuell per USB auf den PC übertragen (Ordner: Android/data/com.example.schieck.ga/files/*) oder per Email an eine zuvor eingestellte Adresse versenden. Sie enthalten die Bewegungsmuster die später genutzt werden um das neuronale Netz zu trainieren.
{{image url="4.png" width="200"}}
Abb.: Inhalt einer csv Datei
In dem Bild sieht man was der Sensor eigentlich macht, es wird zu einem bestimmten Zeitpunkt ein bestimmter Zustand gemessen. Die App schreibt dann diese Zustände in die Dateien.
Es liegen also timestamp-value-paare vor.
**Implementierung**
Namensschema:
[Geste].[Zufallszahl].[Sensortyp].csv
Das Namensschema hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, was sie enthält.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
{{image url="5.png" width="200"}}
Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein SensorManager genutzt und ein SensorEventListener (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
class MainActivity() : Activity(), SensorEventListener {
var sensor_manager: SensorManager? = null
...und im onCreate() Callback initialisiert.
sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte, da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.
- Abtastraten
val delay = SensorManager.SENSOR_DELAY_FASTEST
{{image url="6.png" width="400"}}
//
Die Quellcodes können von mir direkt erhalten werden, bitte schreiben sie mich an. __schieck@stud.fh-sm.de__//
**{{color text="2. Vorverarbeitung der Daten:" c="#00386a"}}**
**Anpassen der Zeitstempel**
Um die timestamps besser überschauen zu können, wird von allen timestamps der niedrigste abgezogen, das geschieht mit:
fun adjustTimestamps(sample: Sample): Sample {
var first = sample.timestamp.first()
var retVal = sample
sample.timestamp.forEachIndexed { index, fl ->
retVal.timestamp[index] -= first
}
return retVal
}
**
Betragsquadrat berechnen **
Mittels des Betragsquadrat werden aus den Werten für x, y und z, ein Wert gemacht. Dadurch wird erreicht das die Werte Orientierungsunabhängig sind.
TODO: hier gehört ne formel hin, aber ==formel== ... ==formel== funktioniert nicht...
fun AbsoluteSquare(sample: Sample): Sample {
val sampleSize = sample.x.size
val retVal = Sample(sample.sensor, sample.gesture)
for (i in 0 until sampleSize) {
val absSquare = Math.abs((sample.x[i] + sample.y[i] + sample.z[i]))
retVal.absoluteSquare.add(absSquare)
}
return retVal
}
**Fehlende Werte ermitteln**
Die Werte die von Android Sensoren zurückgeliefert werden, sind nicht äquidistant (gleicher zeitlicher Abstand zwischen den Messwerten). Das ist aber nötig um sie später einem maschinellem Lernalgorhythmus zuzuführen. Die Sensoren von Android Geräten haben i.d.R. eine Abtastrate von 20-80Hz. Daher ist, verbunden mit der Unsicherheit WANN bestimmte Sensoren, bestimmte Werte zurückliefern, eine starke Fluktuation zu erkennen.
{{image url="7.png" width="400"}}
Abb.: Nicht-Äquidistante Abstände bei den Timestamps
Um dieses Problem zu beheben kann man das Signal (linear) interpolieren. Dabei werden die fehlenden Punkte durch die Mittel der umliegenden Punkte aufgefüllt.
TODO: Formel für lineares interpolieren, die YAML für die wiki nervt echt, sie kommt nicht mal mit simplen formeln klar...
fun interpolate(sample: Sample): Sample {
//require(count < 2) { "interpolate: illegal count!" }
val retVal = sample
for (i in 0 until sample.size) {
retVal.timestamp[i] = sample.timestamp.first() + i * (sample.timestamp.last() - sample.timestamp.first()) / sample.size
retVal.x[i] = sample.x.first() + i * (sample.x.last() - sample.x.first()) / sample.size
retVal.y[i] = sample.y.first() + i * (sample.y.last() - sample.y.first()) / sample.size
retVal.z[i] = sample.z.first() + i * (sample.z.last() - sample.z.first()) / sample.size
}
return retVal
}
**Trainieren von OLVQ1**
Deletions:
Additions:
Es werden dazu drei Anwendungen geschrieben:
1. eine App zum aufzeichen und labeln der gewünschten Muster
2. ein Computerprogramm welches die aufgezeichneten Trainingsdaten so verarbeitet wie das Smartphone, und danach das neuronale Netz trainiert
3. eine App die das trainierte neuronale Netz ausführt und damit die Bewegungen erkennt
Wenn nicht anders angegeben, bin ich der Urheber der Bilder, in dieser Wiki.
**{{color text="1. Datengewinnung/-erhebung:" c="#00386a"}}**
Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zur Bewegungserkennung:
- den (linearen) Beschleunigungssensor,
- das Gyroskop sowie
- den Schwerkraftsensor.
Es gibt weitere Sensoren, das sind aber die Grundlegenden.
Diese Sensoren werden genutzt um die Bewegungen in Signale umzuwandeln.
Genutztes Koordinatensystem
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
{{files}}
1. eine App zum aufzeichen und labeln der gewünschten Muster
2. ein Computerprogramm welches die aufgezeichneten Trainingsdaten so verarbeitet wie das Smartphone, und danach das neuronale Netz trainiert
3. eine App die das trainierte neuronale Netz ausführt und damit die Bewegungen erkennt
Wenn nicht anders angegeben, bin ich der Urheber der Bilder, in dieser Wiki.
**{{color text="1. Datengewinnung/-erhebung:" c="#00386a"}}**
Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zur Bewegungserkennung:
- den (linearen) Beschleunigungssensor,
- das Gyroskop sowie
- den Schwerkraftsensor.
Es gibt weitere Sensoren, das sind aber die Grundlegenden.
Diese Sensoren werden genutzt um die Bewegungen in Signale umzuwandeln.
Genutztes Koordinatensystem
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
{{files}}
Additions:
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverlässigkeit zu erkennen. z.B. Kreise, Linien, Quadrate, etc.
Die App führt die Erkennung mittels eine trainierten neuronalen Netzes durch, was zuvor auf einem Computer trainiert wurde.
Das Training dieses Netzes benötigt Trainings-und Testdaten, die vorher aufgezeichnet werden.
Die App führt die Erkennung mittels eine trainierten neuronalen Netzes durch, was zuvor auf einem Computer trainiert wurde.
Das Training dieses Netzes benötigt Trainings-und Testdaten, die vorher aufgezeichnet werden.
Deletions:
//**TODO: wo kommt dieser Kommentar her?**//
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverl
No Differences
Additions:
//**In Bearbeitung**//
//**TODO: wo kommt dieser Kommentar her?**//
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverl
//**TODO: wo kommt dieser Kommentar her?**//
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverl
Deletions:
Additions:
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverlässlichkeit
Deletions:
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverl
Additions:
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverl
Deletions:
======**{{color text="A. Datengewinnung/-erhebung:" c="#00386a"}}**======
Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zur Bewegungserkennung:
- den [[https://de.wikipedia.org/wiki/Beschleunigungssensor (linearen) Beschleunigungssensor]],
- das [[https://de.wikipedia.org/wiki/Kreiselinstrument Gyroskop]] sowie
- den [[https://de.wikipedia.org/wiki/Bewegungssensor Schwerkraftsensor]].
Diese werden hier genutzt, um die Datenbasis anzulegen und später die zu erkennenden Gesten aufzuzeichnen bzw. die Gestenerkennung selbst durchzuführen.
**Genutztes Koordinatensystem**
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
Achsen eines Smartphones: [[https://developer.android.com/images/axis_device.png]]
**Funktionsweise der App**
Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird.
Danach wird der Knopf in der Mitte unten gerückt gehalten und die Geste aufgezeichnet. Als letztes wird der Knopf wieder losgelassen.
Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
{{image url="https://i.imgur.com/Kh5jBZL.jpg" title="text" alt="text"}}
Abb.: MainActivity.xml
==Implementierung==
Als erstes schreiben wir die App, die aus den Sensorwerten Listen mit timestamp-value-Paaren erstellt und diese in seperate Dateien schreibt.
Es werden csv ("comma seperated value" -> "Komma getrennte Werte") Dateien generiert. Jeweils pro Sensor und Geste, eine Datei.
Der Dateiname wird nach folgendem Schema gebildet:
[Geste].[Zufallszahl].[Sensortyp].csv
Das hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, welche Werte sie enthält.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien
von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
- [[https://i.imgur.com/slhwby9.png]]
- [[https://i.imgur.com/UGIACfM.png]]
In diesen Dateien ist in der ersten Spalte der timestamp (in Nanosekunden) der vom System vergeben wird zu sehen,
in den letzten drei Spalten stehen die Werte (in m/s^2). Je nachdem was für eine Geste aufgezeichnet wurde, können die
Dateien in der Größe variierern.
Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein [[https://developer.android.com/reference/android/hardware/SensorManager
SensorManager]] genutzt und ein
[[https://developer.android.com/reference/android/hardware/SensorEventListener
SensorEventListener]] (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
%%class MainActivity() : Activity(), SensorEventListener {%% %% var sensor_manager: SensorManager? = null%%
...und im onCreate() Callback initialisiert.
%% sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager %%
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte, da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.
- [[https://developer.android.com/reference/android/hardware/SensorManager.html#SENSOR_DELAY_FASTEST
Abtastraten]]
%%val delay = SensorManager.SENSOR_DELAY_FASTEST%%
{{image class="left" image url="https://i.imgur.com/5RGMxJh.png" width="1024"}}
Abb.: Funktionsweise der Aufzeichnungsroutine
Quellcodes/Gesten aufzeichnen:
{{image class="left" image url="anweisungen.png" width="200"}}
Abb.: Beschreibung der Gesten die mit dem Programm aufgezeichnet werden sollen.
{{image class="left" image url="iclauncherbackground.png" width="300"}}
**{{color text="Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum" c="red"}}**
{{image class="left" image url="activitymain.png" width="300"}}
**{{color text="Z. Literaturhinweise:" c="#00386a"}} **
https://developer.android.com/reference/android/hardware/SensorEvent
----
CategoryTutorienFKITSS18
Additions:
{{image class="left" image url="anweisungen.png" width="200"}}
Abb.: Beschreibung der Gesten die mit dem Programm aufgezeichnet werden sollen.
Abb.: Beschreibung der Gesten die mit dem Programm aufgezeichnet werden sollen.
Deletions:
{{image class="left" image url="anweisungen.png" width="100"}}
Additions:
Abb.: MainActivity.xml
{{image class="left" image url="https://i.imgur.com/5RGMxJh.png" width="1024"}}
Abb.: Funktionsweise der Aufzeichnungsroutine
{{image class="left" image url="https://i.imgur.com/5RGMxJh.png" width="1024"}}
Abb.: Funktionsweise der Aufzeichnungsroutine
Deletions:
**{{color text="Abb. MainActivity.xml"}}**
Additions:
**{{color text="Abb. MainActivity.xml"}}**
Additions:
----
CategoryTutorienFKITSS18
CategoryTutorienFKITSS18
Deletions:
{{files}}
Additions:
{{image class="left" image url="activitymain.png" width="300"}}
No Differences
Additions:
{{image class="left" image url="anweisungen.png" width="100"}}
Deletions:
Additions:
{{image class="left" image url="anweisungen.png" width="200"}}
{{image class="left" image url="iclauncherbackground.png" width="300"}}
{{image class="left" image url="iclauncherbackground.png" width="300"}}
Deletions:
{{image class="left" image url="iclauncherbackground.png" width="100"}}
Additions:
{{image class="left" image url="iclauncherbackground.png" width="100"}}
{{files}}
{{files}}
No Differences
Additions:
Quellcodes/Gesten aufzeichnen:
Deletions:
Deletions:
Additions:
{{image class="left" image url="anweisungen.png" width="100"}}
Deletions:
Additions:
{{image class="left" image url="anweisungen.png" width="400"}}
Deletions:
No Differences
Additions:
{{image class="left" anweisungen.png" width="300"}}
Deletions:
Additions:
{{image class="left" aufzeichnungen.png" width="300"}}
Deletions:
Additions:
{{image class="left" .png" width="300"}}
{{files}}
{{files}}
Additions:
Gesten aufzeichnen:
Additions:
- [[https://developer.android.com/reference/android/hardware/SensorManager.html#SENSOR_DELAY_FASTEST
Deletions:
Additions:
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte, da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.
Deletions:
Additions:
%%class MainActivity() : Activity(), SensorEventListener {%% %% var sensor_manager: SensorManager? = null%%
...und im onCreate() Callback initialisiert.
...und im onCreate() Callback initialisiert.
Deletions:
Additions:
**{{color text="Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum" c="red"}}**
**{{color text="Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum" c="red"}}**
**{{color text="Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum" c="red"}}**
Deletions:
**{{color text="Bitte ergänzen: Abb.: Titel, Quelle, Datum" c="red"}}**
No Differences
Additions:
{{image class="left" image url="https://i.imgur.com/5RGMxJh.png" width="800"}}
Deletions:
No Differences
No Differences
Additions:
- [[https://i.imgur.com/slhwby9.png]]
- [[https://i.imgur.com/UGIACfM.png]]
In diesen Dateien ist in der ersten Spalte der timestamp (in Nanosekunden) der vom System vergeben wird zu sehen,
in den letzten drei Spalten stehen die Werte (in m/s^2). Je nachdem was für eine Geste aufgezeichnet wurde, können die
Dateien in der Größe variierern.
- [[https://i.imgur.com/UGIACfM.png]]
In diesen Dateien ist in der ersten Spalte der timestamp (in Nanosekunden) der vom System vergeben wird zu sehen,
in den letzten drei Spalten stehen die Werte (in m/s^2). Je nachdem was für eine Geste aufgezeichnet wurde, können die
Dateien in der Größe variierern.
Deletions:
[[https://i.imgur.com/UGIACfM.png]]
In diesen Dateien ist in der ersten Spalte der timestamp (in
Nanosekunden) der vom System vergeben wird zu sehen, in den letzten drei Spalten stehen die Werte (in m/s^2). Je nachdem was für eine Geste aufgezeichnet wurde, können die Dateien in der Größe variierern.
Additions:
[[https://i.imgur.com/slhwby9.png]]
[[https://i.imgur.com/UGIACfM.png]]
[[https://i.imgur.com/UGIACfM.png]]
Deletions:
alt="text"}}{{image url="https://i.imgur.com/UGIACfM.png" title="text"
alt="text"}}
Additions:
Das hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, welche Werte sie enthält.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien
von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien
von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
Deletions:
Additions:
Es werden csv ("comma seperated value" -> "Komma getrennte Werte") Dateien generiert. Jeweils pro Sensor und Geste, eine Datei.
Der Dateiname wird nach folgendem Schema gebildet:
Der Dateiname wird nach folgendem Schema gebildet:
Deletions:
Additions:
Danach wird der Knopf in der Mitte unten gerückt gehalten und die Geste aufgezeichnet. Als letztes wird der Knopf wieder losgelassen.
Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
Deletions:
Additions:
Als erstes schreiben wir die App, die aus den Sensorwerten Listen mit timestamp-value-Paaren erstellt und diese in seperate Dateien schreibt.
Deletions:
Additions:
**{{color text="Bitte ergänzen: Abb.: Titel, Quelle, Datum" c="red"}}**
No Differences
Additions:
Achsen eines Smartphones: [[https://developer.android.com/images/axis_device.png]]
Deletions:
title="Achsen eines Smartphones" alt="Achsen eines Smartphones"}}
Additions:
[[https://developer.android.com/images/axis_device.png]]
Deletions:
Additions:
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
Deletions:
Additions:
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Deletions:
Additions:
Diese werden hier genutzt, um die Datenbasis anzulegen und später die zu erkennenden Gesten aufzuzeichnen bzw. die Gestenerkennung selbst durchzuführen.
Deletions:
Additions:
Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zur Bewegungserkennung:
- den [[https://de.wikipedia.org/wiki/Beschleunigungssensor (linearen) Beschleunigungssensor]],
- das [[https://de.wikipedia.org/wiki/Kreiselinstrument Gyroskop]] sowie
- den [[https://de.wikipedia.org/wiki/Bewegungssensor Schwerkraftsensor]].
- den [[https://de.wikipedia.org/wiki/Beschleunigungssensor (linearen) Beschleunigungssensor]],
- das [[https://de.wikipedia.org/wiki/Kreiselinstrument Gyroskop]] sowie
- den [[https://de.wikipedia.org/wiki/Bewegungssensor Schwerkraftsensor]].
Deletions:
Additions:
Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zu Bewegungserkennung, den [[https://de.wikipedia.org/wiki/Beschleunigungssensor (linearen) Beschleunigungssensor]], das [[https://de.wikipedia.org/wiki/Kreiselinstrument Gyroskop]] und den [[https://de.wikipedia.org/wiki/Bewegungssensor Schwerkraftsensor]].
Deletions:
Additions:
//**In Bearbeitung**//
No Differences
Additions:
Diese werden hier genutzt um die Datenbasis anzulegen und später die zu erkennenden Gesten aufzuzeichnen bzw. die Gestenerkennung selbst durchzuführen.
**Genutztes Koordinatensystem**
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert. Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
{{image url="https://developer.android.com/images/axis_device.png"
title="Achsen eines Smartphones" alt="Achsen eines Smartphones"}}
**Funktionsweise der App**
Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird.
Danach wird der Knopf in der Mitte unten gerückt gehalten und die Geste aufgezeichnet. Als letztes wird der Knopf wieder losgelassen. Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
{{image url="https://i.imgur.com/Kh5jBZL.jpg" title="text" alt="text"}}
==Implementierung==
Als erstes schreiben wir die App die aus den Sensorwerten Listen mit timestamp-value-Paaren erstellt und diese in seperate Dateien schreibt.
Es werden csv ("comma seperated value" -> "Komma getrennte Werte") Dateien generiert. Jeweils pro Sensor und Geste, eine Datei. Der Dateiname wird nach folgendem Schema gebildet:
[Geste].[Zufallszahl].[Sensortyp].csv
Das hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, welche Werte sie enthält. Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
{{image url="https://i.imgur.com/slhwby9.png" title="text"
alt="text"}}{{image url="https://i.imgur.com/UGIACfM.png" title="text"
alt="text"}}
In diesen Dateien ist in der ersten Spalte der timestamp (in
Nanosekunden) der vom System vergeben wird zu sehen, in den letzten drei Spalten stehen die Werte (in m/s^2). Je nachdem was für eine Geste aufgezeichnet wurde, können die Dateien in der Größe variierern.
Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein [[https://developer.android.com/reference/android/hardware/SensorManager
SensorManager]] genutzt und ein
[[https://developer.android.com/reference/android/hardware/SensorEventListener
SensorEventListener]] (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
%%class MainActivity() : Activity(), SensorEventListener {%% %% var sensor_manager: SensorManager? = null%% ...und im onCreate() Callback initialisiert.
%% sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager %%
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.
[[https://developer.android.com/reference/android/hardware/SensorManager.html#SENSOR_DELAY_FASTEST
Abtastraten]]
%%val delay = SensorManager.SENSOR_DELAY_FASTEST%%
{{image url="https://i.imgur.com/5RGMxJh.png" title="text" alt="text"}}
{{files download="Quellcodes-Gesten-Aufzeichnen.zip" text="Quellcodes der App"}}
**{{color text="Z. Literaturhinweise:" c="#00386a"}} **
https://developer.android.com/reference/android/hardware/SensorEvent
**Genutztes Koordinatensystem**
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert. Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
{{image url="https://developer.android.com/images/axis_device.png"
title="Achsen eines Smartphones" alt="Achsen eines Smartphones"}}
**Funktionsweise der App**
Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird.
Danach wird der Knopf in der Mitte unten gerückt gehalten und die Geste aufgezeichnet. Als letztes wird der Knopf wieder losgelassen. Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
{{image url="https://i.imgur.com/Kh5jBZL.jpg" title="text" alt="text"}}
==Implementierung==
Als erstes schreiben wir die App die aus den Sensorwerten Listen mit timestamp-value-Paaren erstellt und diese in seperate Dateien schreibt.
Es werden csv ("comma seperated value" -> "Komma getrennte Werte") Dateien generiert. Jeweils pro Sensor und Geste, eine Datei. Der Dateiname wird nach folgendem Schema gebildet:
[Geste].[Zufallszahl].[Sensortyp].csv
Das hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, welche Werte sie enthält. Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
{{image url="https://i.imgur.com/slhwby9.png" title="text"
alt="text"}}{{image url="https://i.imgur.com/UGIACfM.png" title="text"
alt="text"}}
In diesen Dateien ist in der ersten Spalte der timestamp (in
Nanosekunden) der vom System vergeben wird zu sehen, in den letzten drei Spalten stehen die Werte (in m/s^2). Je nachdem was für eine Geste aufgezeichnet wurde, können die Dateien in der Größe variierern.
Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein [[https://developer.android.com/reference/android/hardware/SensorManager
SensorManager]] genutzt und ein
[[https://developer.android.com/reference/android/hardware/SensorEventListener
SensorEventListener]] (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
%%class MainActivity() : Activity(), SensorEventListener {%% %% var sensor_manager: SensorManager? = null%% ...und im onCreate() Callback initialisiert.
%% sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager %%
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.
[[https://developer.android.com/reference/android/hardware/SensorManager.html#SENSOR_DELAY_FASTEST
Abtastraten]]
%%val delay = SensorManager.SENSOR_DELAY_FASTEST%%
{{image url="https://i.imgur.com/5RGMxJh.png" title="text" alt="text"}}
{{files download="Quellcodes-Gesten-Aufzeichnen.zip" text="Quellcodes der App"}}
**{{color text="Z. Literaturhinweise:" c="#00386a"}} **
https://developer.android.com/reference/android/hardware/SensorEvent
Additions:
Die meisten Android-Smartphones verfuegen über mindestens drei Sensoren zu Bewegungserkennung, den [[https://de.wikipedia.org/wiki/Beschleunigungssensor (linearen) Beschleunigungssensor]], das [[https://de.wikipedia.org/wiki/Kreiselinstrument Gyroskop]] und den [[https://de.wikipedia.org/wiki/Bewegungssensor Schwerkraftsensor]].
Additions:
**{{color text="Tutor:" c="#00386a"}}** Timmy Schieck
======**{{color text="A. Datengewinnung/-erhebung:" c="#00386a"}}**======
Die meisten Android-Smartphones verf
======**{{color text="A. Datengewinnung/-erhebung:" c="#00386a"}}**======
Die meisten Android-Smartphones verf
Deletions:
**{{color text="A. Datengewinnung:" c="#00386a"}}**
1. Erstellung einer Android Anwendung zum Aufzeichnen von Sensordaten.
2. Vorverarbeitung der gewonnenen Sensordaten, um die Mustererkennung darauf auszuführen.
3. Trainieren eines Models mit den vorhandenen Daten.
4. Implementation des Models auf Android.
**{{color text="Z. Literaturhinweise:" c="#00386a"}} **
https://developer.android.com/reference/android/hardware/SensorEvent
Additions:
**{{color text="Adressaten des Lehrangebotes:" c="#00386a"}}**
Deletions:
Additions:
**{{color text="Tutor/in:" c="#00386a"}}** Timmy Schieck
**{{color text="Ziel des Tutoriums:" c="#00386a"}}**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten zu erkennen. z.B. Kreise, Linien, Quadrate, etc.
**{{color text="C. Adressaten des Lehrangebotes:" c="#00386a"}}**
Studenten des Studienganges "Mobile Computing"
**{{color text="A. Datengewinnung:" c="#00386a"}}**
1. Erstellung einer Android Anwendung zum Aufzeichnen von Sensordaten.
2. Vorverarbeitung der gewonnenen Sensordaten, um die Mustererkennung darauf auszuführen.
3. Trainieren eines Models mit den vorhandenen Daten.
4. Implementation des Models auf Android.
**{{color text="Z. Literaturhinweise:" c="#00386a"}} **
https://developer.android.com/reference/android/hardware/SensorEvent
**{{color text="Ziel des Tutoriums:" c="#00386a"}}**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten zu erkennen. z.B. Kreise, Linien, Quadrate, etc.
**{{color text="C. Adressaten des Lehrangebotes:" c="#00386a"}}**
Studenten des Studienganges "Mobile Computing"
**{{color text="A. Datengewinnung:" c="#00386a"}}**
1. Erstellung einer Android Anwendung zum Aufzeichnen von Sensordaten.
2. Vorverarbeitung der gewonnenen Sensordaten, um die Mustererkennung darauf auszuführen.
3. Trainieren eines Models mit den vorhandenen Daten.
4. Implementation des Models auf Android.
**{{color text="Z. Literaturhinweise:" c="#00386a"}} **
https://developer.android.com/reference/android/hardware/SensorEvent
Deletions:
**{{color text="B. Ziel des Tutoriums:" c="#00386a"}}**
Es wird eine App f
Additions:
Es wird eine App f
Deletions:
**{{color text="C. Adressaten des Lehrangebotes:" c="#00386a"}}**
Studenten des Studienganges "Mobile Computing"
**{{color text="D. Veranstaltungsinhalte:" c="#00386a"}}**
1. Erstellung einer Android Anwendung zum Aufzeichnen von Sensordaten.
2. Vorverarbeitung der gewonnenen Sensordaten, um die Mustererkennung darauf auszuführen.
3. Trainieren eines Models mit den vorhandenen Daten.
4. Implementation des Models auf Android.
**{{color text="E. Literaturhinweise:" c="#00386a"}} **
https://developer.android.com/reference/android/hardware/SensorEvent
Deletions:
CategoryInfoTutorien
No Differences
Deletions:
Additions:
===**{{color text="Tutorium Mobile und Eingebettete Intelligenz" c="#00386a"}}** ===
