Bielefeld Augmented Reality Tracker

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <libgen.h>

/* Diese Datei dient der Berechnung der Erkennungsraten und 

   der Genauigkeit bei der Positionsbestimmung */

//Struktur, die eine Transformationsmatrix einer Markerposition beeinhaltet

typedef struct{

    double rot1;

    double rot2;

    double rot3;

    double rot4;

    double rot5;

    double rot6;

    double rot7;

    double rot8;

    double rot9;

    double trans1;

    double trans2;

    double trans3;

} Position;

void einlesen(Position***, FILE*, int);

void parameterEinlesen(char* param, int* debug, int* minuend, int* ueberspringen, int* wuerfel);

int main(int argc, char* argv[]){

//Wird von den Markerids der Bibliothek abgezogen

int minuend = 0;

//Wird von den Framenummern aus Blender Abgezogen

int korrektur = 0;

//Zeigt an, ob der Debugmodus aktiviert ist: 0 = nicht aktiviert und 1 = aktiviert

int debug = 0;

int ueberspringen = 0;

//Zeigt an, ob es sich um die analyse eines Videos mit Würfeln statt Marker handelt

int wuerfel = 0;

if(argc > 5){

    int pcount;

    for(pcount = 5;pcount<argc;pcount++)

    {

        parameterEinlesen(argv[pcount],&debug,&minuend,&ueberspringen,&wuerfel);

    }

}

if(argc > 4){

    int maxMarker = atoi(argv[3]);

    int maxFrame = atoi(argv[4]);

    //Werte erhöhen um später davon ausgehen zu können, dass dies exklusive Schranken sind.

    maxMarker++;

    maxFrame++;

    if(debug){

        printf("%s -> maxMarker: %d\n",argv[3],maxMarker);

        printf("%s -> maxFrame: %d\n",argv[4],maxFrame);

        printf("%s -> minuend: %d\n",argv[5],minuend);

    }

    /* Dateien öffnen */

    FILE* handle = fopen(argv[1],"r");

    FILE* blenderHandle = fopen(argv[2],"r");

    if(handle == NULL || blenderHandle == NULL){

        printf("Fehler beim Lesen der angegebenen Dateien!\n");

        return 1;

    }

    /* Dateinamen ohne Endung berechnen:

       Der Pfad wird nach 100 Zeichen abgeschnitten! */

    char* basenameArg1 = (char*) malloc(101* sizeof(char));

    strncpy(basenameArg1,argv[1],100);

    char* dotPtr = strrchr(basenameArg1,'.');

    *dotPtr = 0;

    char* datName = (char*) malloc(101* sizeof(char));

    strncpy(datName,basenameArg1,100);

    strcat(datName,"_transl.csv");

    FILE* translHandle = fopen(datName,"w");

    datName = (char*) malloc(101* sizeof(char));

    strncpy(datName,basenameArg1,100);

    strcat(datName,"_log.txt");

    FILE* logHandle = fopen(datName,"w");

    free(datName);

    free(basenameArg1);    

    /* Das Array für den Inhalt aus handle */

    Position*** array;

    /* Das Array für den inhalt aus blenderHandle */

    Position*** blenderArray;

    /* Speicher reservieren */

    array = (Position***) malloc(maxFrame*sizeof(Position**));

    int index;

    for(index=0; index < maxFrame; index++)

    {

        Position** temp = malloc(maxMarker*sizeof(Position*));

        array[index] = temp;        

    }

    blenderArray = (Position***) malloc(maxFrame*sizeof(Position**));

    for(index=0; index < maxFrame; index++)

    {

        Position** temp = malloc(maxMarker*sizeof(Position*));

        blenderArray[index] = temp;        

    }

    /* Daten einlesen */

    printf("Lese bibliotheksseitige Daten ein.\n");

    einlesen(array, handle, debug);

    printf("Lese blenderseitige Daten ein.\n");

    einlesen(blenderArray, blenderHandle, debug);

    /* Daten auswerten */

    int frameIndex;

    int markerIndex;

    int erkannteMarker = 0;

    int nichtErkannteMarker = 0;

    int blenderFrameIndex;

    int debug = 0;

    int wuerfelErkannt = 0; /* 0 bedeutet kein Würfel im Bild, 1 bedeutet Würfel erkannt und 2 bedeutet Würfel nicht erkannt*/

    for(frameIndex = 0, blenderFrameIndex=(frameIndex * (ueberspringen+1))+korrektur; blenderFrameIndex < maxFrame; ){

        for(markerIndex = 0; markerIndex < maxMarker && (markerIndex-minuend) < maxMarker; markerIndex++){

            if(array[frameIndex][markerIndex-minuend] != NULL && blenderArray[blenderFrameIndex][markerIndex] != NULL){

                /** Genauigkeit bei der Positionsbestimmung berechnen **/

                /* Betrachte Absolutwerte, da die Vorzeichen nur von bibliotheksseitiger Definition des Koordinatensystemes abhängen. */

                Position* messung = array[frameIndex][markerIndex-minuend];

                Position* theorie = blenderArray[blenderFrameIndex][markerIndex];

                fprintf(translHandle,"%i,%i,%lf,%lf,%lf\n",frameIndex,markerIndex,fabs(fabs(messung->trans1)-fabs(theorie->trans1)),fabs(fabs(messung->trans2)-fabs(theorie->trans2)),fabs(fabs(messung->trans3)-fabs(theorie->trans3)));

                if(wuerfel){

                    /*Das Bild gilt als erkannt */

                    wuerfelErkannt = 1;

                }

                else{

                    erkannteMarker++;

                }

            }

            else if(erkannteMarker == 0 && array[frameIndex][markerIndex-minuend] != NULL){

                 if(blenderArray[blenderFrameIndex+1][markerIndex] != NULL && korrektur < 1) {

                    korrektur = 1;

                    markerIndex = 0;

                    printf("Warnung: Korrektur der Bildnummern eingeschaltet!\n");

                }

                else

                    printf("#Falsch erkannt: Bild: %d Marker: %d\n",frameIndex,markerIndex-minuend);

            }

            else if(blenderArray[blenderFrameIndex][markerIndex] != NULL){

                printf("#Nicht erkannt: Bild:%d Marker: %d\n",frameIndex,markerIndex-minuend);

                if(wuerfel && (wuerfelErkannt = 0)){

                    wuerfelErkannt = 2;

                }

                else if(! wuerfel){

                    nichtErkannteMarker++;

                }

            }

        }

        /* Prüfe ob der Würfel erkannt wurde und erhöhe den entsprechenden Zähler */

        if(wuerfel && (wuerfelErkannt == 1)){

           erkannteMarker++;

        }

        else if (wuerfel && (wuerfelErkannt == 2)){

           nichtErkannteMarker++;

        }

        wuerfelErkannt = 0;

        frameIndex++;

        blenderFrameIndex=(frameIndex * (ueberspringen+1))+korrektur;

    }

    int gesamtzahlMarker = (erkannteMarker+nichtErkannteMarker);

    printf("#Es wurden von %d Markern %d erkannt. Dies entspricht %g %%.\n",gesamtzahlMarker,erkannteMarker,(erkannteMarker*100.0)/gesamtzahlMarker);

    fprintf(logHandle,"#Es wurden von %d Markern %d erkannt. Dies entspricht %g %%.\n",gesamtzahlMarker,erkannteMarker,(erkannteMarker*100.0)/gesamtzahlMarker);

    printf("%d\n",debug);

    /* Ressourcen freigeben*/

    fflush(translHandle);

    fflush(logHandle);

    fclose(translHandle);

    fclose(logHandle);

    return 0;

}

else {

    printf("Bitte Datei, Vergleichsdatei (von Blender), maximale Markerid und maximale Bildanzahl angeben!\n" );

    return 1;

}

}

/* Liest die übergebene CSV-Datei mit Markererkennungen ein.*/

void einlesen(Position*** array, FILE* handle, int debug)

{

    /* Initialisierung */

    char* string = malloc(80);

    int frameNumber = -1;

    int markerID = -1;

    double rot1 = -1.0;

    double rot2 = -1.0;

    double rot3 = -1.0;

    double rot4 = -1.0;

    double rot5 = -1.0;

    double rot6 = -1.0;

    double rot7 = -1.0;

    double rot8 = -1.0;

    double rot9 = -1.0;

    double trans1 = -1.0;

    double trans2 = -1.0;

    double trans3 = -1.0;

    double s = -1.0;

    int erkannt;

    while(!feof(handle)){

        erkannt = fscanf(handle,"%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%s\n",&frameNumber,&markerID,&rot1,&rot2,&rot3,&rot4,&rot5,&rot6,&rot7,&rot8,&rot9,&trans1,&trans2,&trans3,&s,string);

        if(erkannt < 15){

              printf("Überspringe eine Zeile. %d \n",erkannt);

          printf("%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%s\n",frameNumber,markerID,rot1,rot2,rot3,rot4,rot5,rot6,rot7,rot8,rot9,trans1,trans2,trans3,s,string);

              erkannt = fscanf(handle,"%s\n",string);

          continue;

            }

            else if(debug){

           printf("Processing Marker %d. (%d)\n",markerID,frameNumber);

        }

            Position* tempstruct;

        tempstruct = (Position*) malloc(sizeof(Position));

        tempstruct->rot1 = rot1;

        tempstruct->rot2 = rot2;

        tempstruct->rot3 = rot3;

        tempstruct->rot4 = rot4;

        tempstruct->rot5 = rot5;

        tempstruct->rot6 = rot6;

        tempstruct->rot7 = rot7;

        tempstruct->rot8 = rot8;

        tempstruct->rot9 = rot9;

        tempstruct->trans1 = trans1;

        tempstruct->trans2 = trans2;

        tempstruct->trans3 = trans3;       

        array[frameNumber][markerID] = tempstruct;

    }

    free(string);

}

/* Liest einen übergebenen Parameter ein */

void parameterEinlesen(char* param, int* debug, int* minuend, int* ueberspringen, int* wuerfel){

    if(strncmp(param,"--debug",7) == 0){

        *debug = 1;

    }

    else if(strncmp(param,"--skipp1",8) == 0)

    {

        *ueberspringen = 1;

    }

    else if(strncmp(param,"--skipp3",8) == 0)

    {

        *ueberspringen = 3;

    }

    else if(strncmp(param,"--wuerfel",6) == 0)

    {

        printf("ACHTUNG: Würfelmodus aktiviert!\n");

        *wuerfel = 1;

    }

    else{

        int temp = atoi(param);

        if(temp != 0){

            *minuend = temp;

        }

    }

}

/*

Referenzen:

Die Programmiersprache C. Ein Nachschlagewerk 14. Aufl.; Regionales Rechenzentrum für Niedersachsen / Leibnitz Universität Hannover

Möller, R; Kurze Einführung in die Programmiersprache C; 2014

*/