Bielefeld Augmented Reality Tracker

#Hilfsfunktionen

filter <- function(selektor,wert){

    if(selektor){

        return(wert)

    }else{

        return(0)

    }

}

zusammenfassen <- function(selektoren,werte){

    #Punkte der Bibliothek für diese Phase nach Testen

    phase <- mapply(filter,selektoren,werte)

    #Summe zurückgeben

    return(sum(phase))

}

zusammenfassenFuerAllePhasen <- function(werte,selektoren){

    ret <- lapply(selektoren,zusammenfassen,werte)

    return(t(ret))

}

#Liest die Logdatei zu dem übergebenen Basisnamen ein

leseBart <- function(basisname){

    bart <- read.csv(file=paste("/home/jonas/Bachelorarbeit/bart2/stat/",basisname,"_log.txt",sep=""),header=F)

    return(bart)

}

leseAlvar <- function(basisname){

    alvar <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/alvar/2.0.0/alvar-2.0.0-sdk-linux64-gcc44/build/build_gcc44_release/sample/stat/",basisname,"_log.txt",sep=""),header=F)

    return(alvar)

}

leseAruco <- function(basisname){

    aruco <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/stat/",basisname,"_log.txt",sep=""),header=F)

    return(aruco)

}

#Funktionen für das Parsen

parse <- function(text){    

    # Extrahiere Zahl (mit Prozentzeichen um die Markerzahlen auszuschließen

    position <- regexpr("[[:digit:]|[:punct:]]{1,}[[:blank:]]%",text,perl=TRUE)

    zahl <- regmatches(text,position)

    # Entferne Prozentzeichen

    position <- regexpr("[[:digit:]|[:punct:]]{1,}",zahl,perl=TRUE)

    zahl <- regmatches(zahl,position)

    if(length(zahl) == 0){

        return("-")

    }

    #Ausgabeformat (in das Latex-Dokument): Zahl mit genau einer Nachkommastelle

    zahl <- as.numeric(zahl)

    return(zahl)

}

# gewichtungsZeile: Eine Liste, die an den Positionen 1 bis 8 den Wahrheitswert enthält, ob die Prozentzahl berücksichtigt wird und an der Position 9 die Gruppengröße angibt.

# benchmarkErgebnisse: Eine Liste, die für alle Auflösungen eine Liste mit den aktuellen Punkten für alle Phasen enthält.

parseZeile <- function(stringTabelle,basisname,bezeichnung,gewichtungsZeile){

   #print("Parse Zeile:")

   #print(stringTabelle)

   #print(basisname)

   #print(bezeichnung)

   #print(gewichtungsZeile)

    # Parsen

    stringTabelle <- within(stringTabelle,zahlen <- parse(V1))

    # Berechne Gewichtungsfaktor (aus den Normierungen)

    gewichtungsZeile[1:8] <- unlist(as.logical(gewichtungsZeile[1:8]))

    divisor <- length(Filter(function(x) x,gewichtungsZeile[1:8])) # Anzahl der TRUE

    divisor <- divisor*as.numeric(gewichtungsZeile[9])

    # Teile Werte durch Divisor um die Punkte zu erhalten, die in die Kategorien eingehen

    if(divisor > 0){

        punkte <- sapply(stringTabelle$zahlen,function(x){x/divisor})

    }else{

        # divisor = 0 bedeutet, dass die Punkte in keine Phase eingehen

        punkte <- c(0,0,0,0,0,0,0,0,0)

    }

    return(punkte[1:9])

}

leseUndParseBa <- function(zeile){

    # Eingaben umwandeln

    basisname <- as.character(unlist(zeile[1]))

    bezeichnung <- as.character(unlist(zeile[2]))

    gewichtungsZeile <- zeile[3:11]  

    cat("### BART:  Lese und verarbeite",bezeichnung,"###\n")

    # Einlesen

    stringTabelle <- leseBart(basisname)

    # Parsen

    ret <- parseZeile(stringTabelle, basisname, bezeichnung,gewichtungsZeile)

    return(ret)

}

leseUndParseAl <- function(zeile){

    # Eingaben umwandeln

    basisname <- as.character(unlist(zeile[1]))

    bezeichnung <- as.character(unlist(zeile[2]))

    gewichtungsZeile <- zeile[3:11]  

    cat("### ALVAR:  Lese und verarbeite",bezeichnung,"###\n")

    # Einlesen

    stringTabelle <- leseAlvar(basisname)

    # Parsen

    ret <- parseZeile(stringTabelle, basisname, bezeichnung,gewichtungsZeile)

    return(ret)

}

leseUndParseAr <- function(zeile){

    # Eingaben umwandeln

    basisname <- as.character(unlist(zeile[1]))

    bezeichnung <- as.character(unlist(zeile[2]))

    gewichtungsZeile <- zeile[3:11]  

    cat("### ARUCO:  Lese und verarbeite",bezeichnung,"###\n")

    # Einlesen

    stringTabelle <- leseAruco(basisname)

    # Parsen

    ret <- parseZeile(stringTabelle, basisname, bezeichnung,gewichtungsZeile)

    return(ret)

}

# Wrapperfunktionen um Error wegen leerer Dateien abzufangen

leseUndParseBaWrapper <- function(zeile){

    ret <- try(leseUndParseBa(zeile))

    #Teste ob ein Fehler auftrat (vgl. ?try)

    if(inherits(ret,"try-error")){

        cat(paste("WARNUNG: Konnte",as.character(unlist(zeile[2])),"nicht auswerten. Nehme an, dass keine Marker erkannt wurden.\n"))

        return(c(0,0,0,0,0,0,0,0,0))

    }

    return(ret)

}

leseUndParseAlWrapper <- function(zeile){

    ret <- try(leseUndParseAl(zeile))

    #Teste ob ein Fehler auftrat (vgl. ?try)

    if(inherits(ret,"try-error")){

        cat(paste("WARNUNG: Konnte",as.character(unlist(zeile[2])),"nicht auswerten. Nehme an, dass keine Marker erkannt wurden.\n"))

        return(c(0,0,0,0,0,0,0,0,0))

    }

    return(ret)

}

leseUndParseArWrapper <- function(zeile){

    ret <- try(leseUndParseAr(zeile))

    #Teste ob ein Fehler auftrat (vgl. ?try)

    if(inherits(ret,"try-error")){

        print(paste("WARNUNG: Konnte",as.character(unlist(zeile[2])),"nicht auswerten. Nehme an, dass keine Marker erkannt wurden.\n"))

        return(c(0,0,0,0,0,0,0,0,0))

    }

    return(ret)

}

teste <- read.csv(file="/home/jonas/Dokumente/Studium/Bachelorarbeit/evaluation/tests.csv",header=FALSE)

print(teste)

# Umwandlung in eine Liste von Listen

testeL <- split(teste,row(teste))

# ermittle gewichtete Punkte

bartPunkte <- data.frame(t(mapply(leseUndParseBaWrapper,testeL)))

alvarPunkte <- data.frame(t(mapply(leseUndParseAlWrapper,testeL)))

arucoPunkte <- data.frame(t(mapply(leseUndParseArWrapper,testeL)))

# Umrechnung in Phasen

bartDaten <- lapply(bartPunkte,zusammenfassenFuerAllePhasen,teste[3:10])

alvarDaten <- lapply(alvarPunkte,zusammenfassenFuerAllePhasen,teste[3:10])

arucoDaten <- lapply(arucoPunkte,zusammenfassenFuerAllePhasen,teste[3:10])

# In Frames umwandeln

bartDaten <- do.call(rbind,bartDaten)

bartDaten <- data.frame(t(bartDaten))

alvarDaten <- do.call(rbind,alvarDaten)

alvarDaten <- data.frame(t(alvarDaten))

arucoDaten <- do.call(rbind,arucoDaten)

arucoDaten <- data.frame(t(arucoDaten))

# Numerisch machen

bartDaten <- lapply(bartDaten,as.numeric)

alvarDaten <- lapply(alvarDaten,as.numeric)

arucoDaten <- lapply(arucoDaten,as.numeric)

# Normalisierung, so dass für jede Phase 0 bis 100 Punkte erreicht werden können

divisoren <- c(16.667,33.333,131.667,79.167,119.444,137.778,110.0,171.944)

divisorenFrame <- data.frame(divisoren,divisoren,divisoren,divisoren,divisoren,divisoren,divisoren,divisoren,divisoren)

bartDaten <- bartDaten / divisorenFrame * 100

alvarDaten <- alvarDaten / divisorenFrame * 100

arucoDaten <- arucoDaten / divisorenFrame * 100

# Beschriftung ergänzen

zeilenBeschriftungen <- c("Graubild","Entstörung","Binarisierung","Segmentierung","Kanten und Eckenerkennung","Kandidatensuche","Normalisierung","Identifikation")

bartDaten <- cbind(zeilenBeschriftungen,bartDaten)

alvarDaten <- cbind(zeilenBeschriftungen,alvarDaten)

arucoDaten <- cbind(zeilenBeschriftungen,arucoDaten)

print(bartDaten[c(1,2,3,4),])

print(alvarDaten[c(1,2,3,4),])

print(arucoDaten[c(1,2,3,4),])

# Zusammenführen

tabelle1080p <- merge(bartDaten[c(1,2,3,4)],alvarDaten[c(1,2,3,4)],by=c("zeilenBeschriftungen"))

tabelle1080p <- merge(tabelle1080p,arucoDaten[c(1,2,3,4)],by=c("zeilenBeschriftungen"))

tabelle720p  <- merge(bartDaten[c(1,5,6,7)],alvarDaten[c(1,5,6,7)],by=c("zeilenBeschriftungen"))

tabelle720p  <- merge(tabelle720p,arucoDaten[c(1,5,6,7)],by=c("zeilenBeschriftungen"))

tabelle360p  <- merge(bartDaten[c(1,8,9,10)],alvarDaten[c(1,8,9,10)],by=c("zeilenBeschriftungen"))

tabelle360p  <- merge(tabelle360p,arucoDaten[c(1,8,9,10)],by=c("zeilenBeschriftungen"))

# Zeilen wieder in die Reihenfolge bringen, in der die Phasen beschrieben wurden

positionen <- c(3,2,1,8,6,5,7,4)

tabelle1080p <- tabelle1080p[positionen,]

tabelle720p <- tabelle720p[positionen,]

tabelle360p <- tabelle360p[positionen,]

# Umwandlung in Latextabellenobjekte

zeilen = nrow(tabelle1080p)

#print(zeilen)

if(zeilen > 32){

    # erste Seiten

    latex1080p <- xtable::xtable(tabelle1080p[1:32,])

    latex720p  <- xtable::xtable(tabelle720p[1:32,])

    latex360p  <- xtable::xtable(tabelle360p[1:32,])

#    print(latex1080p)

    # Ausgabe in die Latexdateien

    print(latex1080p,file="../text/tabellen/benchm_tabelle1080p.tex",tabular.environment="tabulary",only.contents=TRUE,include.rownames=FALSE,include.colnames=FALSE,hline.after=NULL,format.args=list(decimal.mark = ","))

    print(latex720p,file="../text/tabellen/benchm_tabelle720p.tex",tabular.environment="tabulary",only.contents=TRUE,include.rownames=FALSE,include.colnames=FALSE,hline.after=NULL,format.args=list(decimal.mark = ","))

    print(latex360p,file="../text/tabellen/benchm_tabelle360p.tex",tabular.environment="tabulary",only.contents=TRUE,include.rownames=FALSE,include.colnames=FALSE,hline.after=NULL,format.args=list(decimal.mark = ","))

    # zweite Seiten

    latex1080p <- xtable::xtable(tabelle1080p[33:zeilen,])

    latex720p  <- xtable::xtable(tabelle720p[33:zeilen,])

    latex360p  <- xtable::xtable(tabelle360p[33:zeilen,])

    # Ausgabe in die Latexdateien

    print(latex1080p,file="../text/tabellen/benchm_tabelle1080p2.tex",tabular.environment="tabulary",only.contents=TRUE,include.rownames=FALSE,include.colnames=FALSE,hline.after=NULL,format.args=list(big.mark = "'", decimal.mark = ","))

    print(latex720p,file="../text/tabellen/benchm_tabelle720p2.tex",tabular.environment="tabulary",only.contents=TRUE,include.rownames=FALSE,include.colnames=FALSE,hline.after=NULL,format.args=list(big.mark = "'", decimal.mark = ","))

    print(latex360p,file="../text/tabellen/benchm_tabelle360p2.tex",tabular.environment="tabulary",only.contents=TRUE,include.rownames=FALSE,include.colnames=FALSE,hline.after=NULL,format.args=list(big.mark = "'", decimal.mark = ","))

} else {

    latex1080p <- xtable::xtable(tabelle1080p)

    latex720p  <- xtable::xtable(tabelle720p)

    latex360p  <- xtable::xtable(tabelle360p)

    # Ausgabe in die Latexdateien

    print(latex1080p,file="../text/tabellen/benchm_tabelle1080p.tex",tabular.environment="tabulary",only.contents=TRUE,include.rownames=FALSE,include.colnames=FALSE,hline.after=NULL,format.args=list(decimal.mark = ","))

    print(latex720p,file="../text/tabellen/benchm_tabelle720p.tex",tabular.environment="tabulary",only.contents=TRUE,include.rownames=FALSE,include.colnames=FALSE,hline.after=NULL,format.args=list(decimal.mark = ","))

    print(latex360p,file="../text/tabellen/benchm_tabelle360p.tex",tabular.environment="tabulary",only.contents=TRUE,include.rownames=FALSE,include.colnames=FALSE,hline.after=NULL,format.args=list(decimal.mark = ","))

}