Das Headtracking auf der PS4 im Spiel WarThunder ist schon ganz nett,
aber für mich persönlich nicht 100% zufriedenstellend.
Können wir uns das Headtracking selbst zusammen-hacken?

Eine USB-Mouse an die PS4 angeschliessen, funktioniert.
Damit kann man die Ansicht im Flugzeug sehr gut steuern und
mit einem Links-Klick die Sicht sofort geradeaus zentrieren.
Ok.

Mit der Windows Software Freetrack http://www.free-track.net/english/
kann man am Windows PC mit einer Camera/WebCam
bereits MotionCapturing (1-Point,3-Point,…) benutzen.
Ok.

Kann man der PS4 eine Mouse vortäuschen,
deren Bewegungen man programmieren kann?
Yes we can…
Mit dem Arduino Leonardo und dem ButtonMouseControl Rezept http://arduino.cc/en/Tutorial/ButtonMouseControl
kann man am PC den Arduino als USB Mouse anschliessen, und mit den an Arduino angeschlossenen Buttons die Richtungen hoch/runter, links/rechts, Linksklick
ausführen… it works.
Ok.

Funktioniert Arduino Leonardo ButtonMouseControl
auch an der PS4, im Spiel War Thunder?
JA, es funktioniert!
Ok.

Was wir jetzt noch brauchen,
sind Daten von einem MotionCapturing Tool
und die Übertragung vom PC an Arduino Leonardo.

Wenn sich herausstellt, dass es mit Freetrack nicht möglich ist,
die Bewegungsdaten auszulesen und in geeigneter Weise an Arduino zu übertragen,
dann muss OpenCV / SimpleCV (Python) herhalten, was den Vorteil hätte,
dass es sich auch auf Linux portieren ließe.
Dabei müsste man diverse Berechnungen selbst programmieren.

andere MC Projecte:
FaceTrackNoIR, opentrack,freepie,..

Wenn Tools wie FaceTrackNoIR,Freetrack eine MouseEmulation haben,
dann könnte man mit einem einfachen Python Code die Mouse Position auslesen,
in einer Endlosschleife die Mouse permanent verfolgen.

Python 2.7 + win32 Extension
https://www.python.org/getit/windows/
http://sourceforge.net/projects/pywin32/files/pywin32/Build%20219/

# python C:\python_scripts\win32_read_mouse\win32_read_mouse.py

import win32gui
import time
import sys
      
if 1==1:
	
	collected = 0
	attempts  = 50
	
	while collected < attempts :
	
	    try:
               x,y = win32gui.GetCursorPos() 
				
               collected += 1
		
               to_print = x,y  ," , attempt: ",collected
               to_print = str(to_print) + "\r"
				
               sys.stdout.write( to_print )
               sys.stdout.flush()   

               if collected == attempts:
                  collected = 0

               time.sleep(0.01) # set the inveral to read next

	    except:
               print "exception"                

Wie bekommt man nun diese Koordinaten auf unseren Arduino Leonardo?
Standard wäre die USB Serial-Schnittstelle (COM-Port).
Aber ein Arduino Leonardo ist mit seinem einzigen USB bereits an der PS4!
Somit ist der Weg PC->USB->Arduino nicht benutzbar.
Oder wir benutzen einen zweiten Arduino, [oder einfaches USB Device wie zBsp…],
um dann per RX/TX zu unserem PS4-Arduino zu kommunizieren.
PC->USB->Arduino_A->SerialRxTx->Arduino_B->USB->PS4
recht komplex.. es geht auch einfacher.

Besser und wahrscheinlich günstigste Lösung wäre:
http://arduino.cc/en/Main/USBSerial
http://www.dfrobot.com/index.php?route=product/product&product_id=581
http://www.komputer.de/zen/index.php?main_page=product_info&products_id=319
USBSerial kostet ca. 12,- Euro
PC->USB->USBSerial Adapter->SerialRxTx->ArduinoLeonardo->USB->PS4

Achtung, wichtig:
Nicht vergessen neben Rx, Tx immer auch GND zwischen
USB Serial Light Adapter und Arduino zu verbinden!
Dann klappts auch mit Serial1.

„Serial“ ist die Serielle Schnittstelle am Arduino Leonardo USB Stecker.
„Serial1“ ist die Serielle Schnittstelle am Arduino Leonardo Pins 0(Rx)/1(Tx).

folgendes Sketch, das ich auf den Arduino Leonardo aufspiele,
dient zum testen der Seriellen Schnittstellen.

int my_char = 0;
int my_charB = 0;



void setup() {                
  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode(13, OUTPUT);  


  Serial.begin(9600); 
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  
  
  Serial1.begin(9600); 
  while (!Serial1) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  
  
}

void loop() {
 

  
    while (Serial.available() > 0) {
       /* CODE */
       my_char = Serial.read(); // the first byte of incoming serial data available (or -1 if no data is available) - int
       //my_char = "Serial 0: " + my_char;
       
       
       Serial.print( "Serial 0: " );
       
       // Writes binary data to the serial port. 
       // This data is sent as a byte or series of bytes; 
       // to send the characters representing the digits of a number use the print() function instead.
       Serial.write( my_char ); // ausgabe des eingegebenen Zeichens "r"
       
       
       // Prints data to the serial port as human-readable ASCII text 
       // followed by a carriage return character (ASCII 13, or '\r') 
       // and a newline character (ASCII 10, or '\n'). 
       // This command takes the same forms as Serial.print().
       Serial.println( my_char ); // ausgabe des Int-Values des Zeichens "114" + NewLine
       
       delay(5);
       blink_once();
     }
     
     
    
    while (Serial1.available() > 0) {
      
      my_charB = Serial1.read();
      
      Serial1.print( "Serial 1: " );
      Serial1.write( my_charB );
      Serial1.println(  my_charB );
      
      delay(5);
      blink_once();      
    }
     
}



void blink_once(){

  digitalWrite(13, HIGH);   // set the LED on
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // set the LED off
  
}

Mit folgenden Zeilen bekommt man jederzeit
die aktuellen Details der COM Ports angezeigt..
Das ist sehr nützlich um zu erkennen,
an welchem COM Port gerade der Arduino Leonardo
oder/und der USB Serial Adapter(Arduino UNO) hängt.

python -m serial.tools.list_ports -v
PAUSE

erzeugt folgende Ausgabe:

COM14
desc: Arduino Uno (COM14)
hwid: USB VID:PID=2341:0001 SNR=55330343831351D03232
COM20
desc: Arduino Leonardo (COM20)
hwid: USB VID:PID=2341:8036
2 ports found

etzt probieren wir noch
das Zusammenspiel zwischen Python und Arduino.

Dazu installieren wir noch PySerial
http://pyserial.sourceforge.net/

nun können wir mit folgendem py-script
Daten über USB Serial Adapter(ArduinoUNO) zum Arduino Leonardo senden
und empfangen sogleich sein Antwort.

#  python C:\python_scripts\py_serial\py_serial.py


import serial
import time
import os

"""
C:\Users\MrRonsen>python -m serial.tools.list_ports -a
Usage: list_ports.py [options] []

list_ports.py: error: no such option: -a
"""
# C:\Python27\Lib\site-packages\serial\tools\list_ports.py  <<< look for options.. discoverd -v !
write_to_path = "C:\\python_scripts\\py_serial\\actual_com_ports.txt"
os.system("python -m serial.tools.list_ports -v > " + write_to_path)

fr = open( write_to_path , "rb")
frc = fr.read()
fr.close()

"""
COM14               
    desc: Arduino Uno (COM14)
    hwid: USB VID:PID=2341:0001 SNR=55330343831351D03232
COM9                
    desc: Arduino Leonardo (COM9)
    hwid: USB VID:PID=2341:8036
2 ports found
"""

frc = str(frc).split("\n")

com_dict = {}
COM_id = ""
for line in frc:
   #print line
   if line[0:3] == "COM":
		
		 COM_id = line.strip()
		 #print "COM_id: ",COM_id
		 com_dict[COM_id]  =  ""
		 
   if line.find("desc:") != -1:
		line2 = line
		line2 = line2.replace("desc: ","")
		line2 = line2.replace("("+COM_id+")","")
		line2 = line2.replace("\t","")
		line2 = line2.strip()
		#print "line2: >>",line2,"<<"
		com_dict[COM_id] = line2
	  
	  
arduino_leonardo_COMport = ""
arduino_uno_COMport = ""

for e in com_dict:
		print e, ": ", com_dict[e]
		
		if com_dict[e].lower().find("leonardo")!=-1:
			arduino_leonardo_COMport = e
		if com_dict[e].lower().find("uno")!=-1:
			arduino_uno_COMport = e

print "arduino_uno_COMport: ",arduino_uno_COMport
print "arduino_leonardo_COMport: ",arduino_leonardo_COMport




if 1==1:

	#COMport = 14
	#serial_port = COMport-1
	#serial_port = "COM14"
	#serial_port = "COM11"
	#serial_port = arduino_leonardo_COMport
	serial_port = arduino_uno_COMport

	baudrate = 9600

	connected = False

	
	"""
	ser = serial.Serial(port=serial_port,
baudrate=baudrate,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_TWO,
bytesize=serial.EIGHTBITS,
timeout=0,
xonxoff=0,
rtscts=0)
        """
        
        
	ser = serial.Serial( serial_port, baudrate)  # open first serial port
	#ser.DtrEnable = "true";
	
	print("initialising")
	time.sleep(2) # waiting the initialization...

	print ser.name          # check which port was really used

	i=0
	
	while i >" + str(xValue) + "<<" )
			
		time.sleep(2) # waits for 2 second

	 
	if 1==1111:
		print "reading: "
		while 1:
			xValue = ser.readline()
			print("something: " + str(xValue) )
	 
	print "END"



	ser.close()             # close port

Wo stehen wir jetzt?
Serial: Arduino Leonardo MouseEmulation an PS4 USB – WORKS
Serial1: senden/empfangen von Daten zw. Arduino Leonardo und PC mittels Arduino USB Serial Light Adapter mittels Python – WORKS
Python Script nutzen, um mit Arduino zu kommunizieren – WORKS
next steps:
– PS3 Eye Toy modifizieren
– HeadTracking Software Schnittstellen anzapfen, MouseEmulation->Mouse auslesen oder HeadTracking Schnittstellen per IP:PORT stream lesen
– alternativ Bildberechnungen bzgl. HeadTracking mit OpenCV/simpleCV selbst umsetzen

erste Tests mit FreeTrack:
ohne Zubehör wie den 3-Punkt Gestellen,
bleibt uns nur das FaceTracking, Gesichtserkennung.
Das funktioniert in ersten einfachen Tests ganz gut.
FreeTrack bietet verschiedene Schnittstellen/Protokolle an,
um die anfallenden Daten bereitzustellen.
Zudem kann man die Mouse steuern lassen, das klappt aber tatsächlich NICHT,
zumindest nicht bei mir, die Mouse sitzt in der Mitte des Bildschirms und flackert hin und wieder ganz links auf dem Bildschirm auf, keinerlei hoch/runter Mouse-Bewegung.

Mit der Software „eViacam“
http://eviacam.sourceforge.net/
kann man per FaceTracking die PC Mouse steuern.
Das funktioniert ganz gut, das FaceTracking und Mouse steuern funktioniert aber leider nicht 100prozentig.. es gibt einen Drift! Alle Kalibrierungsversuche verliefen negativ.

Offenbar müssen wir selbst ran, die Bildberechnungen selbst anstellen.

PS3 Eye – Camera,
funktioniert nicht sofort mit Win7/32bit.
Den Treiber dafür erhält man auf
www.codelaboratories.com/downloads/
für 2,99 $ (2,60 Euro)..

Mit einem PythonScript und den Frameworks/Libraries SimpleCV/OpenCV
kann man die Camera Settings nicht einfach lesen/schreiben,
wie es bei anderen Cams der Fall ist,
aber man kann mit SimpleCV die Camera starten,
wenn man nur Camera(Number) benutzt, OHNE Settings mitzugeben!

Um die PS3 Eye – Camera
in FreeTrack benutzen zu können,
muss man einen Fix/Hack einspielen
www.maximumpc.com/article/how-tos/how_build_your_own_ir_head_tracker
www.maximumpc.com/article/how-tos/how_build_your_own_ir_head_tracker?page=0,1
www.forum.free-track.net/index.php?showtopic=2416
www.sendspace.com/file/2stcof
also Freetrack deinstallieren,
Freetrack neu installieren OHNE Freetrack zu starten,
dann die Hackfiles in Freetrack Ordner kopieren,
dann Freetrack starten.
Wenn man sofort auf den Button „Camera“ klickt friert Freetrack ein!!!
Daher zuvor den Button „Stream“ klicken, hier kann man Auflösung und FPS auswählen,
dann den Button „Camera“ klicken, voila… nun funktionierts.

Vom Kollegen habe ich seine 3 Punkt Infrared BaseCap zum Testen erhalten.
Ohne Modifikationen an der PS3 Cam war von den InfraRed LEDs nichts zusehen.
Daher habe ich als nächstes anhand von Anleitungen, die PS3 Cam auseinandergebaut, die IR-blocking Linse entfernt und von einer Diskette einen Schnipsel zurecht geschnitten und eingesetzt um das Tageslicht zu filtern.
Nach dieser Modifikation sind die IR-LEDs der BaseCap sehr deutlich zu sehen.
www.youtube.com/watch?v=7jJfuP7YgPA
www.youtube.com/watch?v=CbMqsrm2TTs

Nachdem ich lange nach Beschreibungen der FreeTrack Schnittstellen gesucht und nichts gefunden habe,
werde ich den weiteren Weg mit OpenCV/SimpleCV gehen.

Fazit:
das nächste Puzzleteil ist also
eine eigene Software/Python-Script zu schreiben,
das die Kopfposition/ausrichtung anhand der IR-LEDs
aus den Kamerabildern/stream auswertet (SimpleCV, grayscale, binarize, findBlobs,..)

#############################

PC / Laptop mit Windows sollte man bereits haben und verwenden können.

Kosten:
Arduino Leonardo – 25,- Euro
wer noch keine Camera hat müsste sich eine zulegen, vielleicht
liegt ja noch eine benutztbare im Keller..
PS3 Eye Cam – 40,- Euro (sehr hohe Framerate, IR Infrarot Filter muss hier noch entfernt werden)
Infrarot-LEDs + Widerstände + AA-Batteriehalter   – ca. 10,- Euro

PS:

„TrackIR kann man nicht mit der PS4 verwenden“
das ist ein Zitat/Antwort vom deutschen Distributor 2connect.
Es braucht immer die PC Software.
www.trackir.eu/shop/
Zudem sind die Daten verschlüsselt…
man kann die anfallenden Daten also nicht verwenden.
www.en.wikipedia.org/wiki/TrackIR

SimpleCV
www.simplecv.org/
www.simplecv.org/book Page:206
ein erstaunlich kleines Script zur Gesichtserkennung, aber ob wir die wirklich einsetzen werden….
Tip: für bessere Performance kann man die Kameraauflösung herabsetzen
cam = Camera(0, {„width“: 320, „height“: 240})

das folgende Script ist ein Arduino-Sketch,
http://arduino.cc/en/Tutorial/ButtonMouseControl

/*
mouse steuerung,
parallel i2c LCD shield showing "clicked"
and sending "clicked" over Serial to PC... reading with Serial Monitor
and sending PC keyboard pressed key over serial to Arduino, Arduino reads and 
displays int value of pressed key on LCD and back to PC for reading on Serial Monitor
*/

/*
  ButtonMouseControl
 
 Controls the mouse from five pushbuttons on an Arduino Leonardo or Micro.
 
 Hardware:
 * 5 pushbuttons attached to D2, D3, D4, D5, D6  
!!! CHANGED  D2 to D8 and D3 to D9 for using I2C-LCD on Leonardo !!!
 
 
 The mouse movement is always relative. This sketch reads 
 four pushbuttons, and uses them to set the movement of the mouse.
 
 WARNING:  When you use the Mouse.move() command, the Arduino takes
 over your mouse!  Make sure you have control before you use the mouse commands.
 
 created 15 Mar 2012
 modified 27 Mar 2012
 by Tom Igoe
 
 this code is in the public domain
 
 */

#include 
#include 
LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display



// set pin numbers for the five buttons:
const int upButton = 8;  // 2   
const int downButton = 9; // 3        
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;

int range = 5;              // output range of X or Y movement; affects movement speed
int responseDelay = 10;     // response delay of the mouse, in ms

int incomingByte = 0;


void setup() {
  
  Serial.begin(9600);

  //display  
  lcd.init();                      // initialize the lcd 
  lcd.backlight();
  lcd.home();
  
  lcd.setCursor(0, 0);
  lcd.print("Hello world...");
  lcd.setCursor(0, 1);
  lcd.print("dfrobot.com");
  
  
  // initialize the buttons' inputs:
  pinMode(upButton,    INPUT);       
  pinMode(downButton,  INPUT);       
  pinMode(leftButton,  INPUT);       
  pinMode(rightButton, INPUT);       
  pinMode(mouseButton, INPUT);
  // initialize mouse control:
  Mouse.begin();
}

void loop() {
  // read the buttons:
  int upState    = digitalRead(upButton);
  int downState  = digitalRead(downButton);
  int rightState = digitalRead(rightButton);
  int leftState  = digitalRead(leftButton);
  int clickState = digitalRead(mouseButton);

  // calculate the movement distance based on the button states:
  int  xDistance = (leftState - rightState)*range;
  int  yDistance = (upState - downState)*range;

  // if X or Y is non-zero, move:
  if ((xDistance != 0) || (yDistance != 0)) {
    Mouse.move(xDistance, yDistance, 0);
  }

  // if the mouse button is pressed:
  if (clickState == HIGH) {
    // if the mouse is not pressed, press it:
    if (!Mouse.isPressed(MOUSE_LEFT)) {
      Mouse.press(MOUSE_LEFT); 
      
      Serial.println("mouse klick");
      
      writeLCD("mouse klick");
      delay(500);
      
    }
  } 
  // else the mouse button is not pressed:
  else {
    // if the mouse is pressed, release it:
    if (Mouse.isPressed(MOUSE_LEFT)) {
      Mouse.release(MOUSE_LEFT); 
    }
  }

  // a delay so the mouse doesn't move too fast:
  delay(responseDelay);
  
 
  
  // send data only when you receive data:
  if (Serial.available() > 0) {
     // read the incoming byte:
     incomingByte = Serial.read();

     // say what you got:
     Serial.print("I received: ");
     Serial.println(incomingByte, DEC);
     writeLCD(String(incomingByte));
     
  } // EOF serial available
        
}


void writeLCD(String input){
  
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print( input );    

}