Archiv der Kategorie: C++

Einführung in C++ – Klassen: Vererbung, Adjustment, Friends, abstrakt – Teil5

by
Kommentar

Vererbung

Klassen können Funktionen und Member-Variablen vererben an anderen Klassen.

Class A{
public:
 void f();
};
Class B : public A{};//B erbt public von A
B* b = new B;
b.f(); //Funktion ist vorhanden, da geerbt

Einführung in C++ – Funktionen und Operatoren überladen (Overloading) – Teil4

by
Kommentar

Funktionen Überladen

  • es ist möglich einen Funktionsnamen mehrmals zu verwenden, wenn die Übergabeparameter nicht gleich sind und damit für den Compiler klar ist, welche Funktion aufgerufen werden soll
int a(int b);
int a(double b);
int a(char*);

int x = a(5); //ist ok, 5 ist int, 5.0 wäre double
  • nicht eindeutig ist:
int a(int b);
double a(int b);

int x = a(5); //welche Funktion nehmen, error

sowie bei Default-Argumenten:

int a(int b, int c = 3);
int a(int b);

int x = a(5); //welche Funktion nehmen, error

Das Überladen der Funktionen ist möglich durch Name-Mangeling: weiterlesen… “Einführung in C++ – Funktionen und Operatoren überladen (Overloading) – Teil4” »

Einführung in C++ – Datentypen, Casting, Klassen – Teil3

by
Kommentar

Datentypen

Implizite Typumwandlung

  • automatisches Casting bei Zahlen “von kleineren zu größeren” Datentypen

Rangfolge:

unsigned long long ("größter Wert") long long long double double float unsigned long long unsigned (int) int short bool
  • casting non const zu const, Referenzen
T->T& T&->T T->const T T*->const T* T&->const T&

Explzite Typumwandlung

  • mit static_cast<>
  • bei elementaren (einfachen) Datentypen
bool i = true; int y = static_cast<int> i; //y ist 1
  • zu Konstanten casten, mit const_cast<>
  • kritische Typumwandlung mit  reinterpret_cast<>
struct A{} a; struct B{} b; struct A *pa = &a; struct B *pb = pa; //Fehler, nicht derselbe Datentyp, obwohl selber Struct-Inhalt struct B *pb = reinterpret_cast<B*>(pa); //ist ok

Inline Funktionen weiterlesen… “Einführung in C++ – Datentypen, Casting, Klassen – Teil3” »

Einführung in C++ – Zeiger, Pointer,Referenzen – Teil2

by
Kommentar

Ein Zeiger ist eine Variable, die die Speicheradresse (des RAMs) einer anderen Variablen  enthält.

int i = 100;
int* pi = &i;
cout << pi; //Speicheradresse: z.B. 0x000026

Dereferenzieren von Zeigern: *Operator

  • auf den Wert zugreifen, auf den ein Zeiger(Pointer) zeigt
int i = 100;
int* pi = &i;
cout << *pi; //100
cout << pi; //Speicheradresse: z.B. 0x000026

void Zeiger

  • Zeiger auf unbekannten Typ -> dynamisch
  • muss gecastet werden bei Zugriff
int i=10;
void* pi;
pi=&i;
cout << *(int*) pi;

NULL-Zeiger

  • Speicher freigeben des Pointers, z.B. um Zombie Zeiger zu vermeiden, die auf nicht mehr existierende Objekte zeigen
int i = 100;
int* pi = &i;
pi = NULL;

Zeiger auf Konstanten

  • müssen auch const sein, damit nicht änderbar
const int i = 100;
const int* pi = &i;

Zeiger auf Funktionen

int f(float a){return 1;};
int (*pf)(float) = &f;
int x = (*pf)(1,5);

Zeiger bei Funktionen

Call by Value weiterlesen… “Einführung in C++ – Zeiger, Pointer,Referenzen – Teil2” »

Einführung in C++ – Vorteile, Compiler, Namespaces – Teil1

by
Kommentar

Vorteile von C++

  • sehr gute Performance, Code wird kompiliert und vom Betriebssystem ausgeführt wird. Keine Interpretation wie Java, Code kann nur von der JVM ausgeführt werden
  • es kann auch C eingebaut werden, selber Compiler: GNU C-Compiler

Vorteile von C++ gegenüber dem Vorgänger C

  • strengere Typprüfung, zur Laufzeit/Late Binding
  • Objektorientierung möglich
  • verbessertes Speichermanagement
  • Exceptions Handling

Der C++ Kompilationsvorgang: Wie arbeitet der GNU-Compiler?

  1. x.cc und x.h als Ausgangsdateien
  2. x.i, Header Dateien inkludieren, Hardware Plattform abfragen, Präprozessor Direktiven ausführen (z.B. #define, Variablen /Funktionen werden ersetzt im Code)
  3. x.o, mit C++ Compiler g++, Assembler Maschinencode erzeugen, dieser ist hardware- und betriebssystemabhängig
  4.  Linker schreibt die Adressen der verwendeten libs und verbindet alle Objektdateien (.o) miteinander
  5. x.exe, ausführbare Shell-Datei erzeugen

Deklaration, Definition, Initialisierung und Zuweisung in C++

Deklaration

  • keine Speicherzuweisung
  • beliebig oft möglich
inf f(char c);
extern char c;
inf f(char c);

Definition weiterlesen… “Einführung in C++ – Vorteile, Compiler, Namespaces – Teil1” »

Microsofts technische Entwicklungsgeschichte der Kinect

by
Kommentar

Die die Arbeit an der Kinect startete bei Microsoft nachdem Nintendo 2005 ihr Wii-Konsole mit der Wii Remote Steuerung herausgebracht hatte. An der eigentlichen Steuerung wurde aber schon seit 2003 gearbeitet: siehe  Geschichte der NUI/Kinect.

Die Entwicklung der Hardware

Zu Beginn wurden 2 Teams gegründet, die auf Basis von 2 unterschiedlichen Technologien die Kinect bauen sollten. Die Technologien kamen von den Firmen 3DV (gekauft für 35mio$) und PrimeSense (ein unabhängiges israelisches Forschungsunternehmen). Am Ende schaffte nur die PrimeSense Technologie die hohen Anforderungen an die Technik zu bewerkstelligen und einen Prototypen zu bauen, der RGB Kamera, Infrarotsensor und einen Infrarotlichtsensor enthielt und Tiefendaten mit 30fps rendern konnte. Die Geschwindigkeit wurde dadurch ermöglicht, dass die Tiefendaten mit Hilfe der Infrarotdaten auf eine neue Art und Weise bestimmt wurden:

Vorher wurde die Zeit gemessen, die die Daten benötigen, um vom Sensor auf einen Gegenstand und wieder zurück zum Sensor flogen. Die neue Technik projeziert ein Muster von rote Punkte auf den Raum und misst die Größe und den Abstand um die Tiefendaten zu bestimmen.

In die Kinect wurde ein 4-faches Mikrofon Array eingebaut, um in großen Räumen effektiv Spracherkennung durchführen zu können. Microsoft konnte dabei auf die Erfahrung von Windows zurückgreifen, in dem Spracherkennung seit Windows XP enthalten ist.

Die Entwicklung der Software

Auf Basis der Hardware wurde als erstes das Problem des Motion-Trackings gelöst. Das Kinect Entwicklungsteam (Project Natal) beauftragte Jamie Shotton den Microsoft Research in Cambridge mit der Verbesserung des ersten Motion-Trackings Algorithmuses, der folgende Nachteile hatte:

  • der Spieler musste zu Beginn die bekannte T-Pose einnehmen zur Kalibrierung
  • die Kamera verlor den User gelegentlich und das System musste wieder neu kalibriert werden incl T-Pose
  • es funktionierte nur mit bestimmten Körpertypen, nämlich mit denen der leitenden Microsoft Entwickler :)
  • aus der Silhouette des Users mussten die Körperteile und daraus die Gelenke extrahiert werden. Aus den Gelenken kann dann das Skelett erzeugt werden, welches die Kinect für die Bewegungen benutzt

Die Lösung: Es wurde Computer Learning verwendet und eine Bewegungssoftware mit Tonnen von Daten gefüttert, u.a. aus Hollywoods Motion Capture Studios. Daraus resultierte ein Entscheidungsbaum, der die Gelenke erkennen konnte.

Eine weiteres Highlight ist die amerikanische Spracherkennung, die mit verschiedenen amerikanischen Akzenten umgehen kann und auch mit Hilfe von Computer Learning erstellt wurde.

Die Kinect wurde schließlich am 26.9.2010 veröffentlicht, 3 Jahre nach dem eigentliche Veröffentlichungstermin zur E3 2007. In den ersten 60 Tagen wurden durchschnittlich 133.000 Einheiten verkauft pro Tag wodurch die Kinect vor dem iPhone und iPad im Guiness Buch der Rekorde steht.

Weiterlesen: Die technische Geschichte der Xbox Kinect und NUI oder Kinect SDK Tutorial Installation unter Windows 7

aus dem Buch:

Die technische Geschichte der Xbox Kinect und NUI

by
Kommentar

sieh auch Microsofts technische Entwicklungsgeschichte der Kinect

Put-That-There

In den später 70er Jahren entwickelte Chris Schmandt am MIT das erste Projekt mit Sprach- und Gestenerkennung zur Bedienung graphischer Oberflächen namens “Put-That-There”. Der User hatte dafür einen magnetischen Würfel auf dem Handgelenk und ein am Kopf befestigtes Mikrofon anzulegen.

Seine wissenschaftliche Arbeit über “Put-That-There” kann man hier lesen.

DreamSpace

Ende der 90er Jahre entwickelte Mark Lucente für IBM ein User Interface, welches ohne Referenzobjekte wie Stifte oder Handschuhe auskam und die Gesten des Users erkannte. Das Projekt war schon so visionär, dass es als Alternative für Maus und Keyboard ausgelegt war.

Minority Report

Bei dem Hollywood Film mit Tom Cruise von 2002 ist zum ersten Mal eine Kinect-artige Steuerung zu sehen, die zu dieser Zeit als Science Fiction gegolten haben durfte und für uns nicht mehr ganz so schwer vorstellbar ist. Als wissenschaftlichen Berater hatte Steven Spielberg  John Underkoffer vom MIT engagierte. Vielleicht nicht ganz zufällig begann Microsoft ein Jahr später (2003) mit der Entwicklung der Kinect-Technologie.

Der Minority Report zeigte die Möglichkeiten der New User Interfaces(NUI) als einer der ersten Produktionen aus. Damit ist der Film ein ähnlicher Vorreiter wie die Star Trek Serie, die z.B. automatisch öffnende Türen  oder aufklappbare Handys (Captain Kirk’s Communicator) “erfand”.

Besonders interessant an dem folgendem Ausschnitt aus Minority Report:

  • die Kalibrieung des User Interfaces mit einer T-artigen Bewegung (Video 1:26)
  • die Tücken dieser Technik bei falschen Bewegung (Video 1:46)
  • die Handgesten, die schon an die Kinect Steuerung erinnern zu einer Zeit, an der noch nicht einmal an der Entwicklung der Kinect gearbeitet wurde

Weiterlesen: Microsofts technische Entwicklungsgeschichte der Kinect oder Kinect SDK Tutorial Installation unter Windows 7

aus dem Buch:

Terminal/Konsolen Befehl aus dem Programm aus starten

by
Kommentar

Mit folgender Funktion lassen sich Konsolen Befehle aus einem C++/C Programm aus starten:

#include <iomanip>
#include <iostream>
#include <cstdlib>

using namespace std;

bool startExternalProgramm(char* terminalCommando)
{    
    bool returnVal = false;
    if(terminalCommando != "")
    {
        cout << "Executing terminal command: " << terminalCommando << endl;
        int systemReturn = system(terminalCommando);
        
        if (systemReturn == 0)
        {
            returnVal = true;
        }
        else
        {
            cout << "The value returned from Terminal  was: " << systemReturn << endl;
            cout << "Sorry,commando for terminal not executable" << endl; 
        }
    }
    else
    {
        cout << "Sorry, empty commando for terminal" << endl;         
    }
    return returnVal;
        
}