IMU Brick in Unity3D

[BastianR]

Hallo liebe Tinkerforge Gemeinde,

 

ich habe folgendes vorhaben.

Ich würde gerne einen IMU Brick nutzen um damit eine Kamera in Unity3D anzusteueren.

 

Heißt die Werte sollen in Java an eine in Unity3D existierende Kamera übergeben werden.

Und diese sollte sich dann nach den Werten des IMU im 3d Raum der Unity3d ausrichten.

 

Hat jemand schonmal etwas ähnliches realisiert? Bzw. gibt es ein ähnliches Projekt welches ihr kennt?

 

 

 

Habe nur folgendes Projekt gefunden:

http://www.drtomallen.com/blog.html  dort die IMUCAM.

 

Hier der Code der Kamerasteuerung:

https://github.com/Schwolop/IMUCam/blob/master/CameraFromIMU.cs

 

Wenn ich den _speed einfach runter setzte bzw. entferne, sollte ich ja meine Kamera mit der IMU in Unity bewegen können?

 

Grüße,

Basti

 

 

 

[borg]

Das Projekt was du da gefunden hast ist sehr cool, das kannte ich noch gar nicht!

 

Zu deiner Frage: Das sollte gehen, der csharp code sollte ja fast genauso auch in Java funktionieren, ich wüsste nicht was dagegen spricht. Von Unity3D selbst hab ich leide keine Ahnung .

[Nic]

In der Tat sehr interessant, BastianR.

Könntest Du uns bitte einige Grundlagen zu Unity3D vermitteln. Nun der Code in C# ist ja fast fertig vorhanden. Du müsstest das einfach nur in Java übersetzen.

[AuronX]

@Nic: Was genau willst du jetzt erfahren?

Welchen Code willst du nach Java übersetzt haben? Eigentlich sieht sich Java und C# ja so ähnlich, dass es dort am verständnis nicht scheitern dürfte

[Nic]

Lieber Kollege AuronX, lies bitte genauer mein Posting.

Nun der Code in C# ist ja fast fertig vorhanden...

Und mit

Du

in

Du müsstest das einfach nur in Java übersetzen.

ist also der Threaderöffner gemeint.

@Nic: Was genau willst du jetzt erfahren?

Vom Threaderöffner Infos zu Unity3D.

[AuronX]

Lieber Mitmensch Nic:

Wenn du Antowrten von niemand anderem als dem Threaderöffner möchtest, dann schreibe ihm doch eine PM. Meine Frage bezog sich auf zwei Dinge:

1. Ist deine Frage nach einer Einführung in Unity3D weit außerhalb des Scope eines Tinkerforge-Forums, deswegen dachte ich du hättest eine speziellere Frage

2. Frage ich mich halt ganz ernsthaft was du mit "einfach nur in Java übersetzen" meinst. Willst du den dahinterliegenden Code verstehen, willst du es benutzen? Da du hier gerade fremden Menschen potenziell viel Arbeit aufbürdest wird man wohl nochmal nach dem Hintergrund der Frage fragen dürfen.

 

edit: Was mcih an der Frage nach der Übersetzung halt nervt ist, dass wenn es "einfach nur" übersetzen wäre, dann könntest du es auch selbst machen. Das heißt also da steckt offenbar ein anderes Bedürfnis hinter als am Ende tollen Java-Code bekommen zu haben. Dieses Bedürfnis von dir zu kennen, BEVOR jemand mit der Arbeit beginnt wäre toll...

[Nic]

Seltsam. Ich habe hier nicht nach Code-Übersetzungen von x nach y angefragt, noch dazu aufgefordert. Oder anders gesagt, dass was borg als Hinweis

der csharp code sollte ja fast genauso auch in Java funktionieren

mitgegeben hat, habe ich nur in anderen Worten gefasst.

Gibt also keinen Grund hier was auf die Goldwaage zu legen, noch mit Bestürzung zu reagieren, macht sich auch nicht so gut für die Lesbarkeit und das Feedback des eigentlichen Thread-Themas, denn für ein paar spannende Infos zu Unity3D hat es hier noch nicht gefruchtet.

 

[BastianR]

Hallo und Danke für das rege Interesse.

Mittlerweile habe ich einen IMU Brick bestellt und werde, sobald er ankommt mit den ersten Test beginnen.

Von Unity3d habe ich leider noch gar keine Ahnung bzw gar keine Erfahrungen sammeln können.

Kann daher auch leider keine Grundlagen übermitteln

Werde mich selber erst ein wenig in Unity einarbeiten müssen.

Aber da ja wie schon erwähnt ein nahezu fertiger C# Code vorhanden ist und Unity3d

mit C# arbeitet, werde ich den Code nicht in Java übersetzen müssen.

 

Es geht mir im Projekt um folgendes.

Ich würde in Unity gerne auf eine Fläche ein Video projizieren in einem bestimmen Abstand soll dann vor der Fläche eine Kamera erstellt werden. Welche mit Hilfe der IMU bewegt werden kann. So, dass man sich mit dem Brick auf der Fläche umsehen kann.

Denke dafür sollte der Code herhalte. Bin jetzt nicht der größte Programmierer, aber werde , sobald der Brick da ist , einfach den vorhandenen Code ausprobieren.

 

Ich hoffe ihr könnt euch vorstellen worum es mir bei dem Projekt geht

[Nic]

Hört sich sehr interessant an, berichte hier ruhig weiter über Deine Ergebnisse.

Zu C# und im speziellen die C#-API zu Tinkerforge-Produkten gibt es hier reges Feedback - einen der Experten hast du weiter oben schon kennengelernt - , da wird Dir sicher geholfen wenn es mal nicht weitergehen sollte.

Zu Deinem Wissen würde ich nicht so tief stappeln, immerhin scheinst du konkrete Vorstellungen zu haben. Ich vermute mal um Unity handelt es sich um Echtzeit-Rendering mit der Option externe Hardware zum Steuern des Viewpoints/Standpunkts anzusprechen. Das was Du mit Kamera erwähnst, meint sicher eine virtuelle Kamera(-fahrt), richtig ?

 

Hmmh, ich vermute es ist das hier:

http://de.wikipedia.org/wiki/Unity_(Spielengine)

Die Basisversion scheint kostenlos, Programmiersprachen C#, C++ und Javascript(!), hat also mit Java nix zu tun.

[BastianR]

Danke für die Antwort, Nic.

 

Du scheinst das Projekt verstanden zu haben

Und ich habe mich wohl etwas undeutlich ausgedrückt aber es geht sehr wohl um eine virtuelle Kamera in einem 3D Raum.

Dass es hier einige Experten zu der C#API gibt habe ich auch schon entdeckt.

Denke wenn der Brick da ist, wird erstmal probiert und sich dann bei euch gemeldet.

Bin selber gespannt, wie das alles so funktioniert.

Werde berichten.

[Nic]

Ich vermute mal mit VisualStudio von M$ wird man für das C#-Scripting in Unity nicht weit kommen, braucht man dafür zwingend Mono ?

PS: Kann ich selber beantworten, geht anscheinend auch mit VS:

http://docs.unity3d.com/Documentation/Manual/VisualStudioIntegration.html

[rifmetroid]

Moinsen,

ich hab das gestern einfach mal runtergezogen und installiert. Mono wird da gleich mit installiert als Script-Editor und integriert sich in Unity. Von daher muss man da nicht noch irgendwelche Sachen einbinden. Mehr hab ich damit aber auch noch nicht gemacht als installiert und mal rumgespielt mit nem Beispielprojekt. Finde ich aber auch sehr interessant in Verbindung mit dem IMU. Also, wenn ihr da mal etwas weiter seid, immer her mit den Infos, wie das genau funktioniert.

 

Gruß rif

[neomutant]

ob es muss Unity3D werden? Ich kann empfehlen, eine bewährte Grafik-Engine GLScene + Delphi und ich am Anfang zu helfen. Verwendet es seit vielen Jahren.

 

(whether it must be Unity3D? I can recommend a proven graphics engine GLScene + Delphi and I help at the beginning. Used it for many years.)

 

Translated from Polish (google translate)

 

http://sourceforge.net/projects/glscene/

http://en.wikipedia.org/wiki/GLScene

[Nic]

@neomutant

Not really, most people here are not familiar with any rendering stuff, but you are welcome to share your experience especially and at best Tinkerforge stuff combined with your favourite graphic engine. I assume most people can understand you if you write down your postings in pure English.

 

@rif

Danke für den Hinweis, probiere das mal am WE aus wenn mich meine Familie lässt . Mein IMU könnte mal ein bisschen Beschäftigung brauchen...

[neomutant]

later on (as I catch some time), it will try to make a demo with source code explaining how to view (from IMUBrick) orientation of the 3D object in a 3D scene using Delphi + GLScene and tootorial installation of this graphics components in delphi. 

[BastianR]

Hallo nochmal,

 

finde es klasse, wie viele Leute sich für das Projekt interessieren.

Habe sowas schon geahnt und daher meinem Chef die Tinkerforge Produkte empfohlen.

Habe mehrere Wochen nach der geeigneten Hardware recherchiert und bin dann bei dieser IMU gelandet.

Wie ihr am dem "Chef" schon erkennen könnt, geht das ganze um die Projektabwicklung innerhalb eines Unternehmens.

 

Genauergesagt sind wir eigentlich eine reine 3D Agentur und erstellen fotorealistische Rendering und Animationen.

Bei dem projekt geht es um die Visualisierung innerer Bauteile oder Organe von Maschinen oder Lebewesen.

Es soll zum Beispiel in einem realen Skelett animierte Organe gezeigt werden.

Das ganze soll über einen Monitor ( welcher über 2 Achsen drehbar ist ) dem Nutzer zugänglich gemacht werden.

 

D.h. der Nutzer sieht ein reales Skelett und wenn er durch den Monitor guckt sieht er ebenfalls das reale Skelett aber eben auch die animierten Organe usw.

Dabei soll er die Möglichkeit haben den Monitor zu bewegen , und sich somit in dem Skelett umzusehen.

 

Gelößt werden soll das ganze wie schon gesagt in Unity3D. Ich kann mir vorstellen, dass es noch einige andere Umsetzungmöglichkeiten gibt.

Aber mittlerweile haben wir diese als für uns am idealsten erkannt und entwickeln gerade einen Prototypen.

 

Ich denke mit dem IMU ( welcher an dem Monitor angebracht ist ) als Sensor für die Kamerabewegungen, welcher die Daten  an die virtuelle Kamera übergibt ist das schon ein guter Lösungsansatz.

 

Die größten Probleme werden wohl:

 

- die genaue abnahme und übergabe der Werte an die virtuelle Kamera ( Wobei hier das Skript ja schon fast fertig zur Verfügung steht )

 

- und die Einberechnung der Verzerrungen von Realbilden ( Panoramaaufnahme ) und der Animationen ( über eine spherical Cam gerednert ).

 

 

[BastianR]

@neomutant

 

Thank you for your Idea of using Delphi and GLszene.

But i think unity3d has more power at realtime rendering than Glszene.

And as we use high poly animations and renderings , we would prefer unity3d.

 

On the other handside , we are thinking of just mapping an spherical rendering ( finished video animation ) on a sphere in unity3d , so that realtime rendering would not be necessary.

[neomutant]

@BastianR

 

Personally, if i have a commercial type of engine like Unity3D (which has an extensive editor and support for many platforms it has just stick to it)

 

However, in the case of small and medium-sized projects GLScene (and modified GLScene) is totally sufficient.

 

Most of the modifications that have been made ​​to the engine in the past years increased animation performance and real time rendering. Lots of ASM Optimizations. Even the mid-range graphics card is very good.

 

GLScene also has skeletal animation as if you need.

 

If you would like to compare the performance, it being in the house and will grab and post the demo car that has 1-1.5 million polygons that runs on a collision ODE engine. where in this demo frame rate is quite high.

 

GLScene has a long way to the Unreal engine or CryEngine but yet is so good that I can recommend it.

[BastianR]

Hallo, es gibt neues zu dem Unity/IMU Projekt.

Mittlerweile ist mein IMU eingetroffen und ich hatte im vorhinein genug Zeit

mich etwas in Unity einzuarbeiten.

Das Projekt befindet sich momentan an folgendem Punkt.

 

In der Unityumgebung habe ich eine Halbkugel erstellt auf welche ein 4k Video gemappt ist ( dieses besteht aus einer Realen Aufnahem und den Animierten Bildern - Compositing ).

Das ganze läuft in einer Endlosschleife auf der Kugel, quasi als Videotextur.

 

Vor der Halbkugel befindet sich eine UnityKamera welche über die IMU angesprochen werden soll bzw wird.

 

Mit dem vorhanden Script von Tom Allen ( welches ich auf der vorherigen Seite schon gepostet habe ).

Sein vorhandenden Script geht aber eher in die Richtung einer "Flugzeugsteuerung".

Als erstes habe ich die _speed Variable auf 0 gesetzt, damit die Kamera sich nicht vorwärts bewegt.

Jetzt habe ich folgendes Problem. Ich kann mich mit der Kamera auf dem Objekt umsehen, ABER auf der Y-Achse wandert Sie immer wieder auf den Ausgangswert zurück.

Das heißt, wenn ich den IMU bewege, folgt die Kamera in Unity zwar, aber fängt dann an sich langsam wieder auf den Ausgangspunkt zu bewegen.

Habe festgestellt, dass es an dem _imu.SetConvergenceSpeed liegt.

Wenn ich den auf 0 setze, kann ich mich frei umsehen, aber die Kamera bewegt sich ziemlich langsam. Also bleibt nicht statisch stehen, wenn den in dem IMU nicht bewege.

 

Ich denke, das ich nicht die richtige Lösung?

Denn so arbeitet ja nur der Gyroscopesensor.

Denke ich steige bei dem Code nicht komplett durch.

Könnte mir da jemand unter die Arme greifen?

Wäre wirklich super!

 

Hier der CODE wie ich ihn gerade verwende:

 

using UnityEngine;
using System.Collections;
using System;
using Tinkerforge;

public class CameraFromIMU : MonoBehaviour {

private static string _host = "localhost";
private static int _port = 4223;
private static string _uid = "9ekEFavqCxK"; // Change to your UID

private static BrickIMU _imu;
private static IPConnection _ipcon;

private static Quaternion _q = new Quaternion(0.0f,0.0f,0.0f,1.0f);
private static Quaternion _qOrigin = new Quaternion(0.0f,0.0f,0.0f,1.0f);
private static Quaternion _qPrevious = new Quaternion(0.0f,0.0f,0.0f,1.0f);

public float _speed = 100.0f;

// Use this for initialization
void Start () {
_ipcon = new IPConnection(_host, _port); // Create connection to brickd
_imu = new BrickIMU(_uid); // Create device object
_ipcon.AddDevice(_imu); // Add device to IP connection
// Don't use device before it is added to a connection

// Set period for quaternion callback to 10ms
_imu.SetQuaternionPeriod(10);

// Register quaternion callback to QuaternionCB
_imu.RegisterCallback(new BrickIMU.Quaternion(QuaternionCB));

// Set rotational origin to however the IMU is pointing at the start.
float x,y,z,w;
_imu.GetQuaternion(out x, out y, out z, out w);
_qOrigin.w = w;
_qOrigin.x = x;
_qOrigin.y = y;
_qOrigin.z = z;	



_imu.SetConvergenceSpeed( 0 ); // 5ms convergence.
}

// Quaternion callback
static void QuaternionCB(float x, float y, float z, float w)
{
//Debug.Log("x: " + x + "\ny: " + y + "\nz: " + z + "\nw: " + w + "\n");
_qPrevious = _q; // Save q to qPrevious
_q.w = w;
_q.x = x;
_q.y = y;
_q.z = z;
}

void OnApplicationExit() {
_ipcon.Destroy();
}

void OnGUI() {
GUI.Box( new Rect( 5, 5, 200, 24*2 ),
"Quaternion: " + _q.ToString() + "\n" +
"Camera: " + transform.rotation.ToString() );

	if(GUI.Button(new Rect(20,450,80,20), "ON")) 
		_imu.LedsOn();
	if(GUI.Button(new Rect(20,480,80,20), "OFF")) 
		_imu.LedsOff();
}

// Update is called once per frame
void Update () {
// Conjugate of current quaternion:
float x,y,z,w;
x = -_q.x;
y = -_q.y;
z = -_q.z;
w = _q.w;

// Multiply with origin quaternion:
float xn,yn,zn,wn;
wn = w * _qOrigin.w - x * _qOrigin.x - y * _qOrigin.y - z * _qOrigin.z;
xn = w * _qOrigin.x + x * _qOrigin.w + y * _qOrigin.z - z * _qOrigin.y;
yn = w * _qOrigin.y - x * _qOrigin.z + y * _qOrigin.w + z * _qOrigin.x;
zn = w * _qOrigin.z + x * _qOrigin.y - y * _qOrigin.x + z * _qOrigin.w;

// Rotate the camera relative to the world frame axes, by the roll pitch yaw of the IMU.
Quaternion q = new Quaternion( xn, yn, zn, wn );
transform.rotation = Quaternion.identity;
transform.Rotate( Vector3.right 	* q.eulerAngles.x, Space.World );
transform.Rotate( Vector3.forward 	* q.eulerAngles.y, Space.World );
transform.Rotate( Vector3.up 		* q.eulerAngles.z, Space.World );

// Fly forwards.
transform.Translate(Vector3.forward * Time.deltaTime * _speed);
}
}