Revision 8526ae8c
| R/Bestimmung_Umformungen_Rotm/Bestimmung_Drehrichtungen.r | ||
|---|---|---|
| 1 |
#!/usr/bin/env Rscript |
|
| 2 |
|
|
| 3 |
#Argumente einlesen |
|
| 4 |
args <- commandArgs(TRUE) |
|
| 5 |
if(length(args) == 2){
|
|
| 6 |
cat("dateiname=\"",args[1],"\"\n",sep="")
|
|
| 7 |
dateiname <- args[1] |
|
| 8 |
cat("vergleichsdatei=\"",args[2],"\"\n",sep="")
|
|
| 9 |
vergleichsdatei <- args[2] |
|
| 10 |
}else |
|
| 11 |
{
|
|
| 12 |
cat("Fehler: Bitte zwei Dateinamen angeben!","\n")
|
|
| 13 |
quit() |
|
| 14 |
} |
|
| 15 |
|
|
| 16 |
#Einlesen |
|
| 17 |
cat("Lese ","/home/jonas/Bachelorarbeit/bart2/",dateiname,"\n",sep="")
|
|
| 18 |
bart <- read.csv(file=paste("/home/jonas/Bachelorarbeit/bart2/",dateiname,sep=""),header=F)
|
|
| 19 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/alvar/2.0.0/alvar-2.0.0-sdk-linux64-gcc44/build/build_gcc44_release/sample/",dateiname,"\n",sep="")
|
|
| 20 |
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/",dateiname,sep=""),header=F)
|
|
| 21 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,"\n",sep="")
|
|
| 22 |
aruco <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,sep=""),header=F)
|
|
| 23 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,"\n",sep="")
|
|
| 24 |
aruco <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,sep=""),header=F)
|
|
| 25 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",vergleichsdatei, "\n",sep="")
|
|
| 26 |
blender <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",vergleichsdatei, sep=""),header=F)
|
|
| 27 |
#Doppelte Zeilen mit identischen Daten entfernen |
|
| 28 |
bart <- unique(bart) |
|
| 29 |
alvar <- unique(alvar) |
|
| 30 |
aruco <- unique(aruco) |
|
| 31 |
|
|
| 32 |
#Ermittelt die aktuell von fit.r benutzte Rotationsmatrix und gibt sie aus |
|
| 33 |
printRotm <- function(liste,pfadInvMat){
|
|
| 34 |
init_mat_table <- read.table(file=pfadInvMat) |
|
| 35 |
init_rotm_inv <- matrix(unlist(init_mat_table), ncol=3, nrow=3, byrow=TRUE) |
|
| 36 |
matA <- matrix(unlist(liste[3,3:11]),ncol=3,byrow=TRUE) |
|
| 37 |
matB <- matA %*% init_rotm_inv |
|
| 38 |
print(matB) |
|
| 39 |
matA <- matrix(unlist(liste[103,3:11]),ncol=3,byrow=TRUE) |
|
| 40 |
matB <- matA %*% init_rotm_inv |
|
| 41 |
print(matB) |
|
| 42 |
} |
|
| 43 |
|
|
| 44 |
cat("BART","\n")
|
|
| 45 |
printRotm(bart,"bart_init_rotm_inv.table") |
|
| 46 |
cat("ALVAR","\n")
|
|
| 47 |
printRotm(alvar,"alvar_init_rotm_inv.table") |
|
| 48 |
#Zeilen vertauschen |
|
| 49 |
aruco[3,3:8] <- aruco[3,c(6:8,3:5)] |
|
| 50 |
aruco[103,3:8] <- aruco[103,c(6:8,3:5)] |
|
| 51 |
cat("ARUCO","\n")
|
|
| 52 |
printRotm(aruco,"aruco_init_rotm_inv.table") |
|
| 53 |
cat("BLENDER","\n")
|
|
| 54 |
printRotm(aruco,"blender_init_rotm_inv.table") |
|
| 55 |
|
|
| R/Bestimmung_Umformungen_Rotm/Bestimmung_Drehrichtungen.r~ | ||
|---|---|---|
| 1 |
#!/usr/bin/env Rscript |
|
| 2 |
|
|
| 3 |
#Argumente einlesen |
|
| 4 |
args <- commandArgs(TRUE) |
|
| 5 |
if(length(args) == 2){
|
|
| 6 |
cat("dateiname=\"",args[1],"\"\n",sep="")
|
|
| 7 |
dateiname <- args[1] |
|
| 8 |
cat("vergleichsdatei=\"",args[2],"\"\n",sep="")
|
|
| 9 |
vergleichsdatei <- args[2] |
|
| 10 |
}else |
|
| 11 |
{
|
|
| 12 |
cat("Fehler: Bitte zwei Dateinamen angeben!","\n")
|
|
| 13 |
quit() |
|
| 14 |
} |
|
| 15 |
|
|
| 16 |
#Einlesen |
|
| 17 |
cat("Lese ","/home/jonas/Bachelorarbeit/bart2/",dateiname,"\n",sep="")
|
|
| 18 |
bart <- read.csv(file=paste("/home/jonas/Bachelorarbeit/bart2/",dateiname,sep=""),header=F)
|
|
| 19 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/alvar/2.0.0/alvar-2.0.0-sdk-linux64-gcc44/build/build_gcc44_release/sample/",dateiname,"\n",sep="")
|
|
| 20 |
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/",dateiname,sep=""),header=F)
|
|
| 21 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,"\n",sep="")
|
|
| 22 |
aruco <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,sep=""),header=F)
|
|
| 23 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,"\n",sep="")
|
|
| 24 |
aruco <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,sep=""),header=F)
|
|
| 25 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",vergleichsdatei, sep="")
|
|
| 26 |
blender <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",vergleichsdatei, sep=""),header=F)
|
|
| 27 |
#Doppelte Zeilen mit identischen Daten entfernen |
|
| 28 |
bart <- unique(bart) |
|
| 29 |
alvar <- unique(alvar) |
|
| 30 |
aruco <- unique(aruco) |
|
| 31 |
|
|
| 32 |
#Ermittelt die aktuell von fit.r benutzte Rotationsmatrix und gibt sie aus |
|
| 33 |
printRotm <- function(liste,pfadInvMat){
|
|
| 34 |
init_mat_table <- read.table(file=pfadInvMat) |
|
| 35 |
init_rotm_inv <- matrix(unlist(init_mat_table), ncol=3, nrow=3, byrow=TRUE) |
|
| 36 |
matA <- matrix(unlist(liste[3,3:11]),ncol=3,byrow=TRUE) |
|
| 37 |
matB <- matA %*% init_rotm_inv |
|
| 38 |
print(matB) |
|
| 39 |
matA <- matrix(unlist(liste[103,3:11]),ncol=3,byrow=TRUE) |
|
| 40 |
matB <- matA %*% init_rotm_inv |
|
| 41 |
print(matB) |
|
| 42 |
} |
|
| 43 |
|
|
| 44 |
cat("BART","\n")
|
|
| 45 |
printRotm(bart,"bart_init_rotm_inv.table") |
|
| 46 |
cat("ALVAR","\n")
|
|
| 47 |
printRotm(alvar,"alvar_init_rotm_inv.table") |
|
| 48 |
#Zeilen vertauschen |
|
| 49 |
aruco[3,3:8] <- aruco[3,c(6:8,3:5)] |
|
| 50 |
aruco[103,3:8] <- aruco[103,c(6:8,3:5)] |
|
| 51 |
cat("ARUCO","\n")
|
|
| 52 |
printRotm(aruco,"aruco_init_rotm_inv.table") |
|
| 53 |
cat("BLENDER","\n")
|
|
| 54 |
printRotm(aruco,"blender_init_rotm_inv.table") |
|
| 55 |
|
|
| R/Bestimmung_Umformungen_Rotm/alvar_init_rotm_inv.table | ||
|---|---|---|
| 1 |
"V1" "V2" "V3" |
|
| 2 |
"1" -1 0 0 |
|
| 3 |
"2" 0 -1 0 |
|
| 4 |
"3" 0 0 1 |
|
| R/Bestimmung_Umformungen_Rotm/alvar_init_rotm_inv.table~ | ||
|---|---|---|
| 1 |
"V1" "V2" "V3" |
|
| 2 |
"1" -1 -6.41318e-05 -0.000671618 |
|
| 3 |
"2" 6.41307e-05 -1 1.68697e-06 |
|
| 4 |
"3" -0.000671619 1.6439e-06 1 |
|
| R/Bestimmung_Umformungen_Rotm/aruco_init_rotm_inv.table | ||
|---|---|---|
| 1 |
"V1" "V2" "V3" |
|
| 2 |
"1" -1 0 0 |
|
| 3 |
"2" 0 1 0 |
|
| 4 |
"3" 0 0 -1 |
|
| R/Bestimmung_Umformungen_Rotm/aruco_init_rotm_inv.table~ | ||
|---|---|---|
| 1 |
"V1" "V2" "V3" |
|
| 2 |
"1" -1 2.11015e-05 -3.47431e-07 |
|
| 3 |
"2" 2.11013e-05 1 0.000720771 |
|
| 4 |
"3" 3.62641e-07 0.000720771 -1 |
|
| R/Bestimmung_Umformungen_Rotm/bart_init_rotm_inv.table | ||
|---|---|---|
| 1 |
"V1" "V2" "V3" |
|
| 2 |
"1" -1 0 0 |
|
| 3 |
"2" 0 1 0 |
|
| 4 |
"3" 0 0 -1 |
|
| R/Bestimmung_Umformungen_Rotm/bart_init_rotm_inv.table~ | ||
|---|---|---|
| 1 |
"V1" "V2" "V3" |
|
| 2 |
"1" -0.999989 5.06776e-05 -0.00460636 |
|
| 3 |
"2" 5.1958e-05 1 -0.000277859 |
|
| 4 |
"3" 0.00460634 -0.000278095 -0.999989 |
|
| R/Bestimmung_Umformungen_Rotm/blender_init_rotm_inv.table | ||
|---|---|---|
| 1 |
"V1" "V2" "V3" |
|
| 2 |
"1" -1 0 0 |
|
| 3 |
"2" 0 1 0 |
|
| 4 |
"3" 0 0 -1 |
|
| R/Bestimmung_Umformungen_Rotm/blender_init_rotm_inv.table~ | ||
|---|---|---|
| 1 |
"V1" "V2" "V3" |
|
| 2 |
"1" 1 0 0 |
|
| 3 |
"2" 0 1 0 |
|
| 4 |
"3" 0 0 1 |
|
| R/README.txt | ||
|---|---|---|
| 1 |
benchmark.r: Enthält den Benchmark |
|
| 2 |
|
|
| 3 |
rotm.r: Erzeugt Plotts von Rotationsungenauigkeiten |
|
| 4 |
transl.r: Erzeugt Plotts von Translationsungenauigkeiten |
|
| 5 |
hinstogramm_markernummern.r: Erzeugt ein Histogramm der Erkennungen über den Markernummern |
|
| 6 |
|
|
| 7 |
|
|
| 8 |
main2.r: Wandelt Rotationsungenauigkeiten in Eulerwinkel um |
|
| 9 |
- fit.r: Wandelt dafür eine einzelne Rotationsmatrix um |
|
| 10 |
|
|
| 11 |
share: Enthält ein gemeinsam genutztes Skript zum Laden der Dateien |
|
| 12 |
Bestimmung_Umformung_Rotm: Enthält die Anpassungsmatritzen für die Roatationsmatritzen der Bibliotheken. |
|
| R/README.txt~ | ||
|---|---|---|
| 1 |
benchmark.r: Enthält den Benchmark |
|
| 2 |
|
|
| 3 |
rotm.r: Erzeugt Plotts von Rotationsungenauigkeiten |
|
| 4 |
transl.r: Erzeugt Plotts von Translationsungenauigkeiten |
|
| 5 |
hinstogramm_markernummern.r: Erzeugt ein Histogramm der Erkennungen über den Markernummern |
|
| 6 |
|
|
| 7 |
|
|
| 8 |
main2.r: Wandelt Rotationsungenauigkeiten in Eulerwinkel um |
|
| 9 |
- fit.r: Wandelt dafür eine einzelne Rotationsmatrix um |
|
| 10 |
|
|
| 11 |
share: Enthält ein gemeinsam genutztes Skript zum Laden der Dateien |
|
| 12 |
Bestimmung_Umformung_Rotm: Enthält die Anpassungsmatritzen für die Roatationsmatritzen der Bibliotheken. |
|
| R/benchmark.r | ||
|---|---|---|
| 1 |
#Hilfsfunktionen |
|
| 2 |
|
|
| 3 |
filter <- function(selektor,wert){
|
|
| 4 |
if(selektor){
|
|
| 5 |
return(wert) |
|
| 6 |
}else{
|
|
| 7 |
return(0) |
|
| 8 |
} |
|
| 9 |
} |
|
| 10 |
|
|
| 11 |
zusammenfassen <- function(selektoren,werte){
|
|
| 12 |
#Punkte der Bibliothek für diese Phase nach Testen |
|
| 13 |
phase <- mapply(filter,selektoren,werte) |
|
| 14 |
#Summe zurückgeben |
|
| 15 |
return(sum(phase)) |
|
| 16 |
} |
|
| 17 |
|
|
| 18 |
zusammenfassenFuerAllePhasen <- function(werte,selektoren){
|
|
| 19 |
ret <- lapply(selektoren,zusammenfassen,werte) |
|
| 20 |
return(t(ret)) |
|
| 21 |
} |
|
| 22 |
|
|
| 23 |
|
|
| 24 |
|
|
| 25 |
#Liest die Logdatei zu dem übergebenen Basisnamen ein |
|
| 26 |
leseBart <- function(basisname){
|
|
| 27 |
bart <- read.csv(file=paste("/home/jonas/Bachelorarbeit/bart2/stat/",basisname,"_log.txt",sep=""),header=F)
|
|
| 28 |
return(bart) |
|
| 29 |
} |
|
| 30 |
leseAlvar <- function(basisname){
|
|
| 31 |
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)
|
|
| 32 |
return(alvar) |
|
| 33 |
} |
|
| 34 |
leseAruco <- function(basisname){
|
|
| 35 |
aruco <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/stat/",basisname,"_log.txt",sep=""),header=F)
|
|
| 36 |
return(aruco) |
|
| 37 |
} |
|
| 38 |
|
|
| 39 |
#Funktionen für das Parsen |
|
| 40 |
|
|
| 41 |
parse <- function(text){
|
|
| 42 |
|
|
| 43 |
# Extrahiere Zahl (mit Prozentzeichen um die Markerzahlen auszuschließen |
|
| 44 |
position <- regexpr("[[:digit:]|[:punct:]]{1,}[[:blank:]]%",text,perl=TRUE)
|
|
| 45 |
zahl <- regmatches(text,position) |
|
| 46 |
# Entferne Prozentzeichen |
|
| 47 |
position <- regexpr("[[:digit:]|[:punct:]]{1,}",zahl,perl=TRUE)
|
|
| 48 |
zahl <- regmatches(zahl,position) |
|
| 49 |
|
|
| 50 |
if(length(zahl) == 0){
|
|
| 51 |
return("-")
|
|
| 52 |
} |
|
| 53 |
|
|
| 54 |
#Ausgabeformat (in das Latex-Dokument): Zahl mit genau einer Nachkommastelle |
|
| 55 |
zahl <- as.numeric(zahl) |
|
| 56 |
|
|
| 57 |
return(zahl) |
|
| 58 |
} |
|
| 59 |
|
|
| 60 |
# 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. |
|
| 61 |
# benchmarkErgebnisse: Eine Liste, die für alle Auflösungen eine Liste mit den aktuellen Punkten für alle Phasen enthält. |
|
| 62 |
parseZeile <- function(stringTabelle,basisname,bezeichnung,gewichtungsZeile){
|
|
| 63 |
|
|
| 64 |
#print("Parse Zeile:")
|
|
| 65 |
#print(stringTabelle) |
|
| 66 |
#print(basisname) |
|
| 67 |
#print(bezeichnung) |
|
| 68 |
#print(gewichtungsZeile) |
|
| 69 |
|
|
| 70 |
# Parsen |
|
| 71 |
stringTabelle <- within(stringTabelle,zahlen <- parse(V1)) |
|
| 72 |
|
|
| 73 |
# Berechne Gewichtungsfaktor (aus den Normierungen) |
|
| 74 |
gewichtungsZeile[1:8] <- unlist(as.logical(gewichtungsZeile[1:8])) |
|
| 75 |
divisor <- length(Filter(function(x) x,gewichtungsZeile[1:8])) # Anzahl der TRUE |
|
| 76 |
divisor <- divisor*as.numeric(gewichtungsZeile[9]) |
|
| 77 |
|
|
| 78 |
# Teile Werte durch Divisor um die Punkte zu erhalten, die in die Kategorien eingehen |
|
| 79 |
if(divisor > 0){
|
|
| 80 |
punkte <- sapply(stringTabelle$zahlen,function(x){x/divisor})
|
|
| 81 |
}else{
|
|
| 82 |
# divisor = 0 bedeutet, dass die Punkte in keine Phase eingehen |
|
| 83 |
punkte <- c(0,0,0,0,0,0,0,0,0) |
|
| 84 |
} |
|
| 85 |
return(punkte[1:9]) |
|
| 86 |
} |
|
| 87 |
|
|
| 88 |
leseUndParseBa <- function(zeile){
|
|
| 89 |
# Eingaben umwandeln |
|
| 90 |
basisname <- as.character(unlist(zeile[1])) |
|
| 91 |
bezeichnung <- as.character(unlist(zeile[2])) |
|
| 92 |
gewichtungsZeile <- zeile[3:11] |
|
| 93 |
|
|
| 94 |
cat("### BART: Lese und verarbeite",bezeichnung,"###\n")
|
|
| 95 |
# Einlesen |
|
| 96 |
stringTabelle <- leseBart(basisname) |
|
| 97 |
# Parsen |
|
| 98 |
ret <- parseZeile(stringTabelle, basisname, bezeichnung,gewichtungsZeile) |
|
| 99 |
return(ret) |
|
| 100 |
} |
|
| 101 |
|
|
| 102 |
leseUndParseAl <- function(zeile){
|
|
| 103 |
# Eingaben umwandeln |
|
| 104 |
basisname <- as.character(unlist(zeile[1])) |
|
| 105 |
bezeichnung <- as.character(unlist(zeile[2])) |
|
| 106 |
gewichtungsZeile <- zeile[3:11] |
|
| 107 |
|
|
| 108 |
cat("### ALVAR: Lese und verarbeite",bezeichnung,"###\n")
|
|
| 109 |
# Einlesen |
|
| 110 |
stringTabelle <- leseAlvar(basisname) |
|
| 111 |
# Parsen |
|
| 112 |
ret <- parseZeile(stringTabelle, basisname, bezeichnung,gewichtungsZeile) |
|
| 113 |
|
|
| 114 |
return(ret) |
|
| 115 |
} |
|
| 116 |
|
|
| 117 |
leseUndParseAr <- function(zeile){
|
|
| 118 |
# Eingaben umwandeln |
|
| 119 |
basisname <- as.character(unlist(zeile[1])) |
|
| 120 |
bezeichnung <- as.character(unlist(zeile[2])) |
|
| 121 |
gewichtungsZeile <- zeile[3:11] |
|
| 122 |
|
|
| 123 |
cat("### ARUCO: Lese und verarbeite",bezeichnung,"###\n")
|
|
| 124 |
# Einlesen |
|
| 125 |
stringTabelle <- leseAruco(basisname) |
|
| 126 |
# Parsen |
|
| 127 |
ret <- parseZeile(stringTabelle, basisname, bezeichnung,gewichtungsZeile) |
|
| 128 |
|
|
| 129 |
return(ret) |
|
| 130 |
} |
|
| 131 |
|
|
| 132 |
# Wrapperfunktionen um Error wegen leerer Dateien abzufangen |
|
| 133 |
leseUndParseBaWrapper <- function(zeile){
|
|
| 134 |
ret <- try(leseUndParseBa(zeile)) |
|
| 135 |
#Teste ob ein Fehler auftrat (vgl. ?try) |
|
| 136 |
if(inherits(ret,"try-error")){
|
|
| 137 |
cat(paste("WARNUNG: Konnte",as.character(unlist(zeile[2])),"nicht auswerten. Nehme an, dass keine Marker erkannt wurden.\n"))
|
|
| 138 |
return(c(0,0,0,0,0,0,0,0,0)) |
|
| 139 |
} |
|
| 140 |
return(ret) |
|
| 141 |
} |
|
| 142 |
|
|
| 143 |
leseUndParseAlWrapper <- function(zeile){
|
|
| 144 |
ret <- try(leseUndParseAl(zeile)) |
|
| 145 |
#Teste ob ein Fehler auftrat (vgl. ?try) |
|
| 146 |
if(inherits(ret,"try-error")){
|
|
| 147 |
cat(paste("WARNUNG: Konnte",as.character(unlist(zeile[2])),"nicht auswerten. Nehme an, dass keine Marker erkannt wurden.\n"))
|
|
| 148 |
return(c(0,0,0,0,0,0,0,0,0)) |
|
| 149 |
} |
|
| 150 |
return(ret) |
|
| 151 |
} |
|
| 152 |
|
|
| 153 |
leseUndParseArWrapper <- function(zeile){
|
|
| 154 |
ret <- try(leseUndParseAr(zeile)) |
|
| 155 |
#Teste ob ein Fehler auftrat (vgl. ?try) |
|
| 156 |
if(inherits(ret,"try-error")){
|
|
| 157 |
print(paste("WARNUNG: Konnte",as.character(unlist(zeile[2])),"nicht auswerten. Nehme an, dass keine Marker erkannt wurden.\n"))
|
|
| 158 |
return(c(0,0,0,0,0,0,0,0,0)) |
|
| 159 |
} |
|
| 160 |
return(ret) |
|
| 161 |
} |
|
| 162 |
|
|
| 163 |
teste <- read.csv(file="/home/jonas/Dokumente/Studium/Bachelorarbeit/evaluation/tests.csv",header=FALSE) |
|
| 164 |
print(teste) |
|
| 165 |
|
|
| 166 |
# Umwandlung in eine Liste von Listen |
|
| 167 |
testeL <- split(teste,row(teste)) |
|
| 168 |
|
|
| 169 |
# ermittle gewichtete Punkte |
|
| 170 |
bartPunkte <- data.frame(t(mapply(leseUndParseBaWrapper,testeL))) |
|
| 171 |
alvarPunkte <- data.frame(t(mapply(leseUndParseAlWrapper,testeL))) |
|
| 172 |
arucoPunkte <- data.frame(t(mapply(leseUndParseArWrapper,testeL))) |
|
| 173 |
|
|
| 174 |
# Umrechnung in Phasen |
|
| 175 |
bartDaten <- lapply(bartPunkte,zusammenfassenFuerAllePhasen,teste[3:10]) |
|
| 176 |
alvarDaten <- lapply(alvarPunkte,zusammenfassenFuerAllePhasen,teste[3:10]) |
|
| 177 |
arucoDaten <- lapply(arucoPunkte,zusammenfassenFuerAllePhasen,teste[3:10]) |
|
| 178 |
|
|
| 179 |
# In Frames umwandeln |
|
| 180 |
bartDaten <- do.call(rbind,bartDaten) |
|
| 181 |
bartDaten <- data.frame(t(bartDaten)) |
|
| 182 |
|
|
| 183 |
alvarDaten <- do.call(rbind,alvarDaten) |
|
| 184 |
alvarDaten <- data.frame(t(alvarDaten)) |
|
| 185 |
|
|
| 186 |
arucoDaten <- do.call(rbind,arucoDaten) |
|
| 187 |
arucoDaten <- data.frame(t(arucoDaten)) |
|
| 188 |
|
|
| 189 |
# Numerisch machen |
|
| 190 |
bartDaten <- lapply(bartDaten,as.numeric) |
|
| 191 |
alvarDaten <- lapply(alvarDaten,as.numeric) |
|
| 192 |
arucoDaten <- lapply(arucoDaten,as.numeric) |
|
| 193 |
|
|
| 194 |
# Normalisierung, so dass für jede Phase 0 bis 100 Punkte erreicht werden können |
|
| 195 |
divisoren <- c(16.667,33.333,131.667,79.167,119.444,137.778,110.0,171.944) |
|
| 196 |
divisorenFrame <- data.frame(divisoren,divisoren,divisoren,divisoren,divisoren,divisoren,divisoren,divisoren,divisoren) |
|
| 197 |
bartDaten <- bartDaten / divisorenFrame * 100 |
|
| 198 |
alvarDaten <- alvarDaten / divisorenFrame * 100 |
|
| 199 |
arucoDaten <- arucoDaten / divisorenFrame * 100 |
|
| 200 |
|
|
| 201 |
# Beschriftung ergänzen |
|
| 202 |
zeilenBeschriftungen <- c("Graubild","Entstörung","Binarisierung","Segmentierung","Kanten und Eckenerkennung","Kandidatensuche","Normalisierung","Identifikation")
|
|
| 203 |
bartDaten <- cbind(zeilenBeschriftungen,bartDaten) |
|
| 204 |
alvarDaten <- cbind(zeilenBeschriftungen,alvarDaten) |
|
| 205 |
arucoDaten <- cbind(zeilenBeschriftungen,arucoDaten) |
|
| 206 |
|
|
| 207 |
print(bartDaten[c(1,2,3,4),]) |
|
| 208 |
print(alvarDaten[c(1,2,3,4),]) |
|
| 209 |
print(arucoDaten[c(1,2,3,4),]) |
|
| 210 |
|
|
| 211 |
# Zusammenführen |
|
| 212 |
tabelle1080p <- merge(bartDaten[c(1,2,3,4)],alvarDaten[c(1,2,3,4)],by=c("zeilenBeschriftungen"))
|
|
| 213 |
tabelle1080p <- merge(tabelle1080p,arucoDaten[c(1,2,3,4)],by=c("zeilenBeschriftungen"))
|
|
| 214 |
tabelle720p <- merge(bartDaten[c(1,5,6,7)],alvarDaten[c(1,5,6,7)],by=c("zeilenBeschriftungen"))
|
|
| 215 |
tabelle720p <- merge(tabelle720p,arucoDaten[c(1,5,6,7)],by=c("zeilenBeschriftungen"))
|
|
| 216 |
tabelle360p <- merge(bartDaten[c(1,8,9,10)],alvarDaten[c(1,8,9,10)],by=c("zeilenBeschriftungen"))
|
|
| 217 |
tabelle360p <- merge(tabelle360p,arucoDaten[c(1,8,9,10)],by=c("zeilenBeschriftungen"))
|
|
| 218 |
|
|
| 219 |
# Zeilen wieder in die Reihenfolge bringen, in der die Phasen beschrieben wurden |
|
| 220 |
positionen <- c(3,2,1,8,6,5,7,4) |
|
| 221 |
tabelle1080p <- tabelle1080p[positionen,] |
|
| 222 |
tabelle720p <- tabelle720p[positionen,] |
|
| 223 |
tabelle360p <- tabelle360p[positionen,] |
|
| 224 |
|
|
| 225 |
# Umwandlung in Latextabellenobjekte |
|
| 226 |
zeilen = nrow(tabelle1080p) |
|
| 227 |
#print(zeilen) |
|
| 228 |
if(zeilen > 32){
|
|
| 229 |
# erste Seiten |
|
| 230 |
latex1080p <- xtable::xtable(tabelle1080p[1:32,]) |
|
| 231 |
latex720p <- xtable::xtable(tabelle720p[1:32,]) |
|
| 232 |
latex360p <- xtable::xtable(tabelle360p[1:32,]) |
|
| 233 |
# print(latex1080p) |
|
| 234 |
# Ausgabe in die Latexdateien |
|
| 235 |
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 = ",")) |
|
| 236 |
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 = ",")) |
|
| 237 |
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 = ",")) |
|
| 238 |
|
|
| 239 |
# zweite Seiten |
|
| 240 |
latex1080p <- xtable::xtable(tabelle1080p[33:zeilen,]) |
|
| 241 |
latex720p <- xtable::xtable(tabelle720p[33:zeilen,]) |
|
| 242 |
latex360p <- xtable::xtable(tabelle360p[33:zeilen,]) |
|
| 243 |
|
|
| 244 |
# Ausgabe in die Latexdateien |
|
| 245 |
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 = ",")) |
|
| 246 |
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 = ",")) |
|
| 247 |
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 = ",")) |
|
| 248 |
|
|
| 249 |
} else {
|
|
| 250 |
latex1080p <- xtable::xtable(tabelle1080p) |
|
| 251 |
latex720p <- xtable::xtable(tabelle720p) |
|
| 252 |
latex360p <- xtable::xtable(tabelle360p) |
|
| 253 |
|
|
| 254 |
# Ausgabe in die Latexdateien |
|
| 255 |
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 = ",")) |
|
| 256 |
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 = ",")) |
|
| 257 |
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 = ",")) |
|
| 258 |
|
|
| 259 |
} |
|
| 260 |
|
|
| 261 |
|
|
| 262 |
|
|
| 263 |
|
|
| R/fit.r | ||
|---|---|---|
| 1 |
# Dies ist die Datei "fit.r". |
|
| 2 |
# Sie benutzt einen Levenberg-Marquardt-Algorithmus |
|
| 3 |
# um Eulerwinkel zu bestimmen, die der gegebenen |
|
| 4 |
# Rotationsmatrix möglicht gut entsprechen. |
|
| 5 |
# Dadurch wird der Fehler aller Matritzeneinträge |
|
| 6 |
# in den Eulerwinkeln abgebildet. |
|
| 7 |
|
|
| 8 |
|
|
| 9 |
# Berechnet die Abweichung dreier angenäherter Winkel an eine Rotationsmatrix. |
|
| 10 |
# Die Winkel werden in XYZ-Euler angenommen. |
|
| 11 |
# a ist ein Zeilenvektor der Rotationsmatrix |
|
| 12 |
# x ist ein Vektor der Rotationswinkel in XYZ-Euler |
|
| 13 |
# Das Ergebnis ist ein Vektor, der die Differenz der aus den Winkeln berechneten Rotationsmatrix von der vorgegebenen Matrix angibt. |
|
| 14 |
DiffXYZeulerRotmFIT <- function(x,a){
|
|
| 15 |
ret <- numeric(10) |
|
| 16 |
#cat("Diff",x,a,"\n")
|
|
| 17 |
#Die unten zugrundeliegende Berechnung der Rotationsmatrix entspricht der Darstellung in Weisstein (k.D.), wurde jedoch auf des verwendete Koordinatensystem (rechtshändig) und die Koordinatensysteme der verwendeten Bibliotheken umgerechnet |
|
| 18 |
#cat(class(as.numeric(x[2]))) |
|
| 19 |
ret[1]<- (cos(as.numeric(x[2]))*cos(as.numeric(x[3]))-as.numeric(a[3])) |
|
| 20 |
ret[2]<- ((sin(as.numeric(x[1]))*sin(as.numeric(x[2]))*cos(as.numeric(x[3]))-sin(as.numeric(x[3]))*cos(as.numeric(x[1])))-as.numeric(a[4])) |
|
| 21 |
ret[3]<- (cos(as.numeric(x[1]))*sin(as.numeric(x[2]))*cos(as.numeric(x[3]))+sin(as.numeric(x[1]))*sin(as.numeric(x[3]))-as.numeric(a[5])) |
|
| 22 |
ret[4]<- (cos(as.numeric(x[2]))*sin(as.numeric(x[3]))-as.numeric(a[6])) |
|
| 23 |
ret[5]<- (sin(as.numeric(x[1]))*sin(as.numeric(x[2]))*sin(as.numeric(x[3]))+cos(as.numeric(x[1]))*cos(as.numeric(x[3]))-as.numeric(a[7])) |
|
| 24 |
ret[6]<- (cos(as.numeric(x[1]))*sin(as.numeric(x[2]))*sin(as.numeric(x[3]))-sin(as.numeric(x[1]))*cos(as.numeric(x[3]))-as.numeric(a[8])) |
|
| 25 |
ret[7]<- (-sin(as.numeric(x[2])))-as.numeric(a[9]) |
|
| 26 |
ret[8]<- (cos(as.numeric(x[2]))*sin(as.numeric(x[1]))-a[10]) |
|
| 27 |
ret[9]<- (cos(as.numeric(x[1]))*cos(as.numeric(x[2]))-a[11]) |
|
| 28 |
|
|
| 29 |
#Dieser Eintrag kann für Anpassungen der Gewichtsfunktion verwendet werden |
|
| 30 |
ret[10]<- 0 |
|
| 31 |
return(ret) |
|
| 32 |
} |
|
| 33 |
|
|
| 34 |
# Die obenstehende Methode läuft oft in lokale Minima und liefert dann falsche Werte. |
|
| 35 |
# Um dies zu verhindern, werden die Werte für Blender aus 3 Gleichungen "analytisch" berechnet. (Das ist natürlich nicht wirklich eine analytische Rechnung, weil die trigonometrischen Funktionen nummerisch implementiert sein dürften). |
|
| 36 |
startXYZeulerFIT <- function(a){
|
|
| 37 |
|
|
| 38 |
toleranz = 1e-10 |
|
| 39 |
|
|
| 40 |
ret <- c(-1,-1,-1) |
|
| 41 |
|
|
| 42 |
#Bester Ansatz nach Slabaugh (2015) (Wesentliche Abweichungen sind angegeben) |
|
| 43 |
if (abs(abs(a[7])-1) > toleranz) #Betrachte auch Werte sehr nahe an +-1 als +-1 |
|
| 44 |
{
|
|
| 45 |
ret[2] <- asin(-a[7]) |
|
| 46 |
#cat("Y-Euler:",ret[2]," ")
|
|
| 47 |
temp <- cos(ret[2]) |
|
| 48 |
ret[1] <- atan2(a[8]/temp,a[9]/temp) |
|
| 49 |
#cat("X-Euler:",ret[1]," ")
|
|
| 50 |
ret[3] <- atan2(a[4]/temp,a[1]/temp) |
|
| 51 |
#cat("Z-Euler:",ret[3]," ",a[4]," ",a[1]," ",temp,"\n")
|
|
| 52 |
|
|
| 53 |
} |
|
| 54 |
else |
|
| 55 |
{
|
|
| 56 |
ret[3] <- (pi/2) # Die im Pseudocode von Slabaugh vorgeschlagene 0 ist für uns numerisch ungünstig |
|
| 57 |
if(abs(a[7]+1) <= toleranz) #Betrachte auch Werte sehr nahe an -1 als -1 |
|
| 58 |
{
|
|
| 59 |
ret[2] = pi/2 |
|
| 60 |
ret[1] = (pi/2)+atan2(a[2],a[3]) |
|
| 61 |
} |
|
| 62 |
else |
|
| 63 |
{
|
|
| 64 |
ret[2] = 3*pi/2 # Entspricht -pi/2 |
|
| 65 |
ret[1] = atan2(-a[2],-a[3])-(pi/2) |
|
| 66 |
} |
|
| 67 |
} |
|
| 68 |
|
|
| 69 |
#Sorgt für positive Winkel |
|
| 70 |
for(i in 1:3){
|
|
| 71 |
while(ret[i] < 0){
|
|
| 72 |
ret[i] <- ret[i]+2*pi |
|
| 73 |
} |
|
| 74 |
} |
|
| 75 |
return(ret) |
|
| 76 |
} |
|
| 77 |
|
|
| 78 |
#Wrapper für acos |
|
| 79 |
#min, max behebt Probleme mit der Maschienengenauigkeit im Grenzbereich und verhindert Nans, weil Werte die Definitionsgrenze auf hinteren Nachkommastellen überschreiten (vgl. Bolker (2012)). |
|
| 80 |
myacos <- function(x){
|
|
| 81 |
return (acos(max(min(x,1.0),-1.0))) |
|
| 82 |
} |
|
| 83 |
|
|
| 84 |
# Diese Funktion führt alle notwendigen Schritte aus. |
|
| 85 |
# Leider hat lsqnonlin ein Problem damit, wenn der perfekte Wert bereits im ersten Durchgang übergeben wird. Desshalb müssen wir vorher prüfen, ob wir bereits die optimale Lösung haben. |
|
| 86 |
# a ist wieder die Rotationsmatrix |
|
| 87 |
# x0 ist der Startwert |
|
| 88 |
# init_rotm_inv ist die Inverse der für die Bibliothek benötigten Anpassungsmatrix. |
|
| 89 |
Rot2XYZeulerFIT <- function(a,x0,init_rotm_inv) {
|
|
| 90 |
|
|
| 91 |
rotm <- as.numeric(as.character(a)) |
|
| 92 |
ret <- numeric(5) |
|
| 93 |
# Setze Frame und Markerid |
|
| 94 |
ret[1] <- a[1] |
|
| 95 |
ret[2] <- a[2] |
|
| 96 |
|
|
| 97 |
# Korrigiere Eingabematrix |
|
| 98 |
matA <- matrix(rotm[3:11],ncol=3,byrow=TRUE) |
|
| 99 |
matA <- matA %*% init_rotm_inv |
|
| 100 |
for(i in 0:2){
|
|
| 101 |
rotm[(i*3+3):(i*3+5)] <- unlist(matA[(i+1),]) |
|
| 102 |
} |
|
| 103 |
#Berechne aktuellen Fehler |
|
| 104 |
akterr <- pracma::rmserr(as.double(DiffXYZeulerRotmFIT(x=x0,a=rotm)),rep(0,10)) |
|
| 105 |
#Sind wir nicht perfekt (mse = gemittelter quadratischer Fehler)? |
|
| 106 |
if(akterr$mse > 0){
|
|
| 107 |
#winkel2 <- pracma::gaussNewton(as.double(winkel),DiffXYZeulerRotmFIT,JacobiFIT,maxiter=250,a=as.double(rotm)) |
|
| 108 |
winkel2 <- pracma::lsqnonlin(DiffXYZeulerRotmFIT,as.double(x0),options = list(tau=1e-9,maxeval=250),a=rotm) |
|
| 109 |
newerr <- pracma::rmserr(as.double(DiffXYZeulerRotmFIT(x=winkel2$x,rotm)),rep(0,10)) |
|
| 110 |
} |
|
| 111 |
if(newerr$mse <= akterr$mse){
|
|
| 112 |
#print("Verbesserung erfolgreich!")
|
|
| 113 |
#print(x0) |
|
| 114 |
#print(winkel2$x) |
|
| 115 |
ret[3:5] <- winkel2$x |
|
| 116 |
return(ret) |
|
| 117 |
} |
|
| 118 |
else{
|
|
| 119 |
#Verbesserung war nicht möglich |
|
| 120 |
print("Warnung: Verbesserung gescheitert!")
|
|
| 121 |
print(akterr$mse) |
|
| 122 |
print(newerr$mse) |
|
| 123 |
print(x0) |
|
| 124 |
print(winkel2$x) |
|
| 125 |
ret[3:5] <- x0 |
|
| 126 |
return(ret) |
|
| 127 |
} |
|
| 128 |
} |
|
| 129 |
|
|
| 130 |
Rot2XYZeulerBART <- function(a,x0) {
|
|
| 131 |
#print("BART")
|
|
| 132 |
x0 <- unlist(x0) |
|
| 133 |
#Drehrichtung um die X-Achse umdrehen |
|
| 134 |
x0[1]<- (2*pi)-x0[1] |
|
| 135 |
init_mat_table <- read.table(file="Bestimmung_Umformungen_Rotm/bart_init_rotm_inv.table") |
|
| 136 |
init_rotm_inv <- matrix(unlist(init_mat_table), ncol=3, nrow=3, byrow=TRUE) |
|
| 137 |
ret <- Rot2XYZeulerFIT(a,x0,init_rotm_inv) |
|
| 138 |
#Drehrichtung um die X-Achse umdrehen |
|
| 139 |
ret[[3]]<- (2*pi)-ret[[3]] |
|
| 140 |
return(ret) |
|
| 141 |
} |
|
| 142 |
|
|
| 143 |
Rot2XYZeulerALVAR <- function(a,x0) {
|
|
| 144 |
#print("ALVAR")
|
|
| 145 |
x0 <- unlist(x0) |
|
| 146 |
#Drehrichtung um die X-Achse umdrehen |
|
| 147 |
x0[1]<- (2*pi)-x0[1] |
|
| 148 |
init_mat_table <- read.table(file="Bestimmung_Umformungen_Rotm/alvar_init_rotm_inv.table") |
|
| 149 |
init_rotm_inv <- matrix(unlist(init_mat_table), ncol=3, nrow=3, byrow=TRUE) |
|
| 150 |
ret <- Rot2XYZeulerFIT(a,x0,init_rotm_inv) |
|
| 151 |
#Drehrichtung um die X-Achse umdrehen |
|
| 152 |
ret[[3]]<- (2*pi)-ret[[3]] |
|
| 153 |
return(ret) |
|
| 154 |
} |
|
| 155 |
|
|
| 156 |
Rot2XYZeulerARUCO <- function(a,x0) {
|
|
| 157 |
#print("ARUCO")
|
|
| 158 |
#print(x0) |
|
| 159 |
#Tausche die ersten beiden Zeilen |
|
| 160 |
a[3:8] <- a[c(6:8,3:5)] |
|
| 161 |
|
|
| 162 |
x0 <- unlist(x0) |
|
| 163 |
#Drehrichtung um die Z-Achse umdrehen |
|
| 164 |
x0[3] <- 2*pi-x0[3] |
|
| 165 |
init_mat_table <- read.table(file="Bestimmung_Umformungen_Rotm/aruco_init_rotm_inv.table") |
|
| 166 |
init_rotm_inv <- matrix(unlist(init_mat_table), ncol=3, nrow=3, byrow=TRUE) |
|
| 167 |
ret <- Rot2XYZeulerFIT(a,x0,init_rotm_inv) |
|
| 168 |
#Drehrichtung um die Z-Achse umdrehen |
|
| 169 |
ret[[5]]<- (2*pi)-ret[[5]] |
|
| 170 |
return(ret) |
|
| 171 |
} |
|
| 172 |
|
|
| 173 |
Rot2XYZeulerBLENDER <- function(a) {
|
|
| 174 |
rotm <- as.numeric(as.character(a)) |
|
| 175 |
ret <- numeric(5) |
|
| 176 |
# Setze Frame und Markerid |
|
| 177 |
ret[1] <- a[1] |
|
| 178 |
ret[2] <- a[2] |
|
| 179 |
#Skalierung auf der Z-Achse ausgleichen |
|
| 180 |
a[9:11] <- a[9:11]*200 |
|
| 181 |
|
|
| 182 |
ret[3:5] <- startXYZeulerFIT(unlist(a[3:11])) |
|
| 183 |
#Drehrichtung um die Y-Achse umdrehen |
|
| 184 |
ret[4] <- 2*pi-unlist(ret[4]) |
|
| 185 |
return(ret) |
|
| 186 |
} |
|
| 187 |
|
|
| 188 |
#Quellen: |
|
| 189 |
#Bolker, B. (2012, 24. Dezember) acos(1) returns NaN for some values, not others Antwort auf http://stackoverflow.com/questions/18806944/about-arccos-function-in-r-nan-produced |
|
| 190 |
#Slabaugh, G. G. (2015) Computing Euler angles from a rotation matrix http://staff.city.ac.uk/~sbbh653/publications/euler.pdf |
|
| R/histogramm_markernummern.r | ||
|---|---|---|
| 1 |
#!/usr/bin/env Rscript |
|
| 2 |
#Dieses Skript erzeugt ein Histogramm, das die Erkennungen über den Nummern der Marker aufträgt. |
|
| 3 |
|
|
| 4 |
#Argumente einlesen |
|
| 5 |
args <- commandArgs(TRUE) |
|
| 6 |
if(length(args) == 3){
|
|
| 7 |
cat("dateiname=\"",args[1],"\"\n",sep="")
|
|
| 8 |
cat("vergleichsdatei=\"",args[2],"\"\n",sep="")
|
|
| 9 |
cat("basisname=\"",args[3],"\"\n",sep="")
|
|
| 10 |
dateiname <- args[1] |
|
| 11 |
vergleichsdatei <- args[2] |
|
| 12 |
basisname <- args[3] |
|
| 13 |
}else |
|
| 14 |
{
|
|
| 15 |
cat("Fehler: Bitte zwei Eingabedateinamen und einen Basisnamen für die Ausgabedateien angeben!","\n")
|
|
| 16 |
quit() |
|
| 17 |
} |
|
| 18 |
|
|
| 19 |
##Hilsfunktionen## |
|
| 20 |
|
|
| 21 |
#Extrahiert die Markerid aus einer Gruppierung |
|
| 22 |
extrahiereMid <- function(gruppierung){
|
|
| 23 |
return(gruppierung$V2[1]) |
|
| 24 |
} |
|
| 25 |
|
|
| 26 |
#Gruppiert den übergebenen Datensatz anhand der Markerids und bestimmt die Anzahl der Erkennungen jedes Markers |
|
| 27 |
gruppierenUndZusammenfassen <- function(datensatz){
|
|
| 28 |
gruppiert <- split(datensatz,datensatz$V2) |
|
| 29 |
markerids <- unlist(lapply(gruppiert,extrahiereMid)) |
|
| 30 |
zahlDerErkennungen <- unlist(lapply(gruppiert,nrow)) |
|
| 31 |
frame <- data.frame(Markerid=markerids,Erkennungen=zahlDerErkennungen) |
|
| 32 |
return(frame) |
|
| 33 |
} |
|
| 34 |
|
|
| 35 |
#Plottet ein Histogramm aus den übergebenen Daten und speichert es als SVG |
|
| 36 |
histogrammPlotten <- function(frame,dateiname,bibliotheksbez){
|
|
| 37 |
# Datei öffnen |
|
| 38 |
svg(filename=paste("markernummernhist_",bibliotheksbez,"_",dateiname,".svg",sep=""))
|
|
| 39 |
# Plotten |
|
| 40 |
plot(frame,t="h") |
|
| 41 |
# Datei schreiben |
|
| 42 |
dev.off() |
|
| 43 |
} |
|
| 44 |
|
|
| 45 |
##Hauptprogramm## |
|
| 46 |
|
|
| 47 |
#Einlesen der Datensätze |
|
| 48 |
source("./share/hauptdatensaetze_laden.r")
|
|
| 49 |
|
|
| 50 |
#Gruppieren und Zusammenfassen |
|
| 51 |
frameBart <- gruppierenUndZusammenfassen(bart) |
|
| 52 |
frameAlvar <- gruppierenUndZusammenfassen(alvar) |
|
| 53 |
frameAruco <- gruppierenUndZusammenfassen(aruco) |
|
| 54 |
frameBlender <- gruppierenUndZusammenfassen(blender) |
|
| 55 |
|
|
| 56 |
histogrammPlotten(frameBart,dateiname,"bart") |
|
| 57 |
histogrammPlotten(frameAlvar,dateiname,"alvar") |
|
| 58 |
histogrammPlotten(frameAruco,dateiname,"aruco") |
|
| 59 |
histogrammPlotten(frameBlender,dateiname,"vergleichsdaten") |
|
| 60 |
|
|
| 61 |
return(0) |
|
| 62 |
|
|
| 63 |
|
|
| 64 |
|
|
| 65 |
|
|
| 66 |
|
|
| R/main2.r | ||
|---|---|---|
| 1 |
#!/usr/bin/env Rscript |
|
| 2 |
|
|
| 3 |
#Laden |
|
| 4 |
source("./fit.r")
|
|
| 5 |
|
|
| 6 |
#Argumente einlesen |
|
| 7 |
args <- commandArgs(TRUE) |
|
| 8 |
if(length(args) == 3){
|
|
| 9 |
cat("dateiname=\"",args[1],"\"\n",sep="")
|
|
| 10 |
cat("vergleichsdatei=\"",args[2],"\"\n",sep="")
|
|
| 11 |
cat("basisname=\"",args[3],"\"\n",sep="")
|
|
| 12 |
dateiname <- args[1] |
|
| 13 |
vergleichsdatei <- args[2] |
|
| 14 |
basisname <- args[3] |
|
| 15 |
}else |
|
| 16 |
{
|
|
| 17 |
cat("Fehler: Bitte zwei Eingabedateinamen und einen Basisnamen für die Ausgabedateien angeben!","\n")
|
|
| 18 |
quit() |
|
| 19 |
} |
|
| 20 |
|
|
| 21 |
#Hilfsfunktionen |
|
| 22 |
minusEins <- function(x){return (x-1)}
|
|
| 23 |
|
|
| 24 |
#Vergleicht zwei Winkel auf dem (mathematischen) Ring der Winkel zwischen 0 und pi |
|
| 25 |
#Das Vorzeichen ist positiv, falls alpha in Drehrichtung der Winkel der Koordinatenachse näher an beta liegt, als gegen die Drehrichtung |
|
| 26 |
verglWinkel <- function(alpha,beta){
|
|
| 27 |
alpha <- abs(alpha) |
|
| 28 |
beta <- abs(beta) |
|
| 29 |
while(alpha < 0){
|
|
| 30 |
alpha <- alpha + (2*pi) |
|
| 31 |
} |
|
| 32 |
while(beta < 0){
|
|
| 33 |
beta <- beta + (2*pi) |
|
| 34 |
} |
|
| 35 |
alpha <- alpha%%(2*pi) |
|
| 36 |
beta <- beta%%(2*pi) |
|
| 37 |
ret <- alpha-beta |
|
| 38 |
if(abs(ret) > (pi)){
|
|
| 39 |
if(alpha < beta){
|
|
| 40 |
alpha <- alpha+(2*pi) |
|
| 41 |
} |
|
| 42 |
else {
|
|
| 43 |
beta <- beta+(2*pi) |
|
| 44 |
} |
|
| 45 |
ret <- alpha-beta |
|
| 46 |
} |
|
| 47 |
return(ret) |
|
| 48 |
} |
|
| 49 |
|
|
| 50 |
#Vergleicht eine Liste von Winkeln |
|
| 51 |
verglListen <- function(x,y){
|
|
| 52 |
return(mapply(verglWinkel,x,y,USE.NAMES = FALSE)) |
|
| 53 |
} |
|
| 54 |
|
|
| 55 |
#Einlesen der Datensätze |
|
| 56 |
source("./share/hauptdatensaetze_laden.r")
|
|
| 57 |
|
|
| 58 |
#Winkel für Blender analytisch berechnen (Matritzen sollten ideale Rotationsmatritzen sein) |
|
| 59 |
print("Bestimme Winkel für Blendereingabe")
|
|
| 60 |
winkelBlender <- sapply(split(blender[,1:11],c(row(blender[,1:11]))),Rot2XYZeulerBLENDER) |
|
| 61 |
blenderFrame <- data.frame(t(winkelBlender)) |
|
| 62 |
names(blenderFrame)[1]<- "X1" |
|
| 63 |
names(blenderFrame)[2]<- "X2" |
|
| 64 |
names(blenderFrame)[3]<- "BW1" |
|
| 65 |
names(blenderFrame)[4]<- "BW2" |
|
| 66 |
names(blenderFrame)[5]<- "BW3" |
|
| 67 |
|
|
| 68 |
|
|
| 69 |
#Zusammenführen von Zeilen, die sich auf die gleichen Bildnummern und Marker beziehen |
|
| 70 |
print("Führe Blender und Bart zusammen")
|
|
| 71 |
bartFrame <- data.frame(bart) |
|
| 72 |
names(bartFrame)[1]<- "X1" |
|
| 73 |
names(bartFrame)[2]<- "X2" |
|
| 74 |
alvarFrame <- data.frame(alvar) |
|
| 75 |
names(alvarFrame)[1]<- "X1" |
|
| 76 |
names(alvarFrame)[2]<- "X2" |
|
| 77 |
arucoFrame <- data.frame(aruco) |
|
| 78 |
names(arucoFrame)[1]<- "X1" |
|
| 79 |
names(arucoFrame)[2]<- "X2" |
|
| 80 |
|
|
| 81 |
#Markerids und Bildnummern ggf. korrigieren |
|
| 82 |
print("Korrigiere Daten")
|
|
| 83 |
#bartFrame <- within(bartFrame,X2 <- lapply(X2,minusEins)) |
|
| 84 |
|
|
| 85 |
for(i in 1:9){
|
|
| 86 |
names(bartFrame)[(i+2)]<- paste("R",i,sep="")
|
|
| 87 |
} |
|
| 88 |
|
|
| 89 |
#Zusammenführung von Frames |
|
| 90 |
tempBart <- merge(bartFrame,blenderFrame,by = c("X1","X2"))
|
|
| 91 |
tempAlvar <- merge(alvarFrame,blenderFrame,by = c("X1","X2"))
|
|
| 92 |
tempAruco <- merge(arucoFrame,blenderFrame,by = c("X1","X2"))
|
|
| 93 |
|
|
| 94 |
#Doppelte Zeilen mit identischen Daten entfernen |
|
| 95 |
tempBart <- unique(tempBart) |
|
| 96 |
tempAlvar <- unique(tempAlvar) |
|
| 97 |
tempAruco <- unique(tempAruco) |
|
| 98 |
|
|
| 99 |
#Berechunung der Winkel der Bibliotheken |
|
| 100 |
t1 <- split(tempBart[,1:11],c(row(tempBart[,1:11]))) |
|
| 101 |
t2 <- split(tempBart[,grep("BW",names(tempBart))],row(tempBart[,grep("BW",names(tempBart))]))
|
|
| 102 |
winkelBart <- mapply(Rot2XYZeulerBART,t1,t2) |
|
| 103 |
t1 <- split(tempAlvar[,1:11],c(row(tempAlvar[,1:11]))) |
|
| 104 |
t2 <- split(tempAlvar[,grep("BW",names(tempAlvar))],row(tempAlvar[,grep("BW",names(tempAlvar))]))
|
|
| 105 |
winkelAlvar <- mapply(Rot2XYZeulerALVAR,t1,t2) |
|
| 106 |
t1 <- split(tempAruco[,1:11],c(row(tempAruco[,1:11]))) |
|
| 107 |
t2 <- split(tempAruco[,grep("BW",names(tempAruco))],row(tempAruco[,grep("BW",names(tempAruco))]))
|
|
| 108 |
winkelAruco <- mapply(Rot2XYZeulerARUCO,t1,t2) |
|
| 109 |
|
|
| 110 |
#Zusammenführung von Frames (Die try-Blöcke sind notwendig, da die Frames leer sein könnten (s.o) ) |
|
| 111 |
print(winkelBart) |
|
| 112 |
bartFrame <- data.frame(t(winkelBart)) |
|
| 113 |
try(bartFrame <- within(bartFrame,X2 <- unlist(X2))) |
|
| 114 |
try(tempBart <- merge(bartFrame,blenderFrame)) |
|
| 115 |
|
|
| 116 |
alvarFrame <- data.frame(t(winkelAlvar)) |
|
| 117 |
try(alvarFrame <- within(alvarFrame,X2 <- unlist(X2))) |
|
| 118 |
tempAlvar <- merge(alvarFrame,blenderFrame) |
|
| 119 |
arucoFrame <- data.frame(t(winkelAruco)) |
|
| 120 |
try(arucoFrame <- within(arucoFrame,X2 <- unlist(X2))) |
|
| 121 |
tempAruco <- merge(arucoFrame,blenderFrame) |
|
| 122 |
|
|
| 123 |
|
|
| 124 |
#winkelBart <- sapply(split(bart[,1:11],c(row(bart[,1:11]))),Rot2XYZeulerREF) |
|
| 125 |
#winkelBlender <- sapply(split(blender[,1:11],c(row(blender[,1:11]))),Rot2XYZeulerREF) |
|
| 126 |
#winkelAlvar <- sapply(split(alvar[,1:11],c(row(alvar[,1:11]))),Rot2XYZeulerREF) |
|
| 127 |
#winkelAlvar <- sapply(split(alvar[,1:11],c(row(alvar[,1:11]))),Rot2XYZeulerALVAR) |
|
| 128 |
#winkelAruco <- sapply(split(aruco[,1:11],c(row(aruco[,1:11]))),Rot2XYZeulerARUCO) |
|
| 129 |
|
|
| 130 |
|
|
| 131 |
#Differenzen bestimmen (falls die Listen die angegebenen Attribute enthalten) |
|
| 132 |
try(tempBart <- within(tempBart, DELTA1 <- verglListen(X3,BW1))) |
|
| 133 |
try(tempBart <- within(tempBart, DELTA2 <- verglListen(X4,BW2))) |
|
| 134 |
try(tempBart <- within(tempBart, DELTA3 <- verglListen(X5,BW3))) |
|
| 135 |
try(tempAlvar <- within(tempAlvar, DELTA1 <- verglListen(X3,BW1))) |
|
| 136 |
try(tempAlvar <- within(tempAlvar, DELTA2 <- verglListen(X4,BW2))) |
|
| 137 |
try(tempAlvar <- within(tempAlvar, DELTA3 <- verglListen(X5,BW3))) |
|
| 138 |
try(tempAruco <- within(tempAruco, DELTA1 <- verglListen(X3,BW1))) |
|
| 139 |
try(tempAruco <- within(tempAruco, DELTA2 <- verglListen(X4,BW2))) |
|
| 140 |
try(tempAruco <- within(tempAruco, DELTA3 <- verglListen(X5,BW3))) |
|
| 141 |
|
|
| 142 |
print("BART")
|
|
| 143 |
tempBart <- within(tempBart,X1 <- unlist(X1)) |
|
| 144 |
tempBart <- tempBart[order(tempBart$X1),] |
|
| 145 |
try(print(tempBart[c(1,2,9,10,11)])) |
|
| 146 |
try(write.csv(tempBart[c(1,2,9,10,11)],file=paste("/home/jonas/Bachelorarbeit/bart2/rot/",basisname,".csv",sep="")))
|
|
| 147 |
print("ALVAR")
|
|
| 148 |
tempAlvar <- within(tempAlvar,X1 <- unlist(X1)) |
|
| 149 |
tempAlvar <- tempAlvar[order(tempAlvar$X1),] |
|
| 150 |
try(print(tempAlvar[c(1,2,9,10,11)])) |
|
| 151 |
try(write.csv(tempAlvar[c(1,2,9,10,11)],file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/alvar/2.0.0/alvar-2.0.0-sdk-linux64-gcc44/build/build_gcc44_release/sample/rot/",basisname,".csv",sep="")))
|
|
| 152 |
print("ARUCO")
|
|
| 153 |
tempAruco <- within(tempAruco,X1 <- unlist(X1)) |
|
| 154 |
tempAruco <- tempAruco[order(tempAruco$X1),] |
|
| 155 |
try(print(tempAruco[c(1,2,9,10,11)])) |
|
| 156 |
try(write.csv(tempAruco[c(1,2,9,10,11)],file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/rot/",basisname,".csv",sep="")))
|
|
| 157 |
|
|
| 158 |
print("Bitte Ergebnisse auf Plausibilität prüfen!")
|
|
| 159 |
print("Eine numerische Stabilität der verwendeten Verfahren ist nicht garantiert.")
|
|
| R/rotm.r | ||
|---|---|---|
| 1 |
#!/usr/bin/env Rscript |
|
| 2 |
|
|
| 3 |
#Argumente einlesen |
|
| 4 |
args <- commandArgs(TRUE) |
|
| 5 |
if(length(args) == 3){
|
|
| 6 |
cat("basisname=\"",args[1],"\"\n",sep="")
|
|
| 7 |
cat("diagrammtitle=\"",args[2],"\"\n",sep="")
|
|
| 8 |
cat("achsenbeschriftung=\"",args[3],"\"\n",sep="")
|
|
| 9 |
basisname <- args[1] |
|
| 10 |
title <- args[2] |
|
| 11 |
xlab <- args[3] |
|
| 12 |
}else |
|
| 13 |
{
|
|
| 14 |
cat("Fehler: Bitte Basisname für die Ausgabedateien, Diagrammtitle und Beschriftung der X-Achse angeben!","\n")
|
|
| 15 |
quit() |
|
| 16 |
} |
|
| 17 |
|
|
| 18 |
## Hilfsfunktionen ## |
|
| 19 |
|
|
| 20 |
#Entfernt Einträge aus der übergebenen Liste mit Rotationsungenauigkeiten, die durch |
|
| 21 |
# numerische Probleme verfälscht sein dürften. |
|
| 22 |
entferneFehlerhafteRotationsungenauigkeiten <- function(liste){
|
|
| 23 |
laengeAlt <- nrow(liste) |
|
| 24 |
|
|
| 25 |
#Quadrat der Vektornorm berechnen |
|
| 26 |
liste <- within(liste,Norm <- (DELTA1*DELTA1+DELTA2*DELTA2+DELTA3*DELTA3)) |
|
| 27 |
#Einträge entfernen, deren Quadrat der Vektornorm zu groß ist |
|
| 28 |
liste <- liste[liste$Norm < 0.3,] |
|
| 29 |
|
|
| 30 |
#Veränderungen protokollieren |
|
| 31 |
laengeNeu <- nrow(liste) |
|
| 32 |
if(laengeNeu < laengeAlt){
|
|
| 33 |
if((laengeAlt-laengeNeu) == 1) |
|
| 34 |
cat("Warnung: Es wurde 1 Eintrag aussortiert!","\n")
|
|
| 35 |
else |
|
| 36 |
cat("Warnung: Es wurden",(laengeAlt-laengeNeu),"Einträge aussortiert!","\n")
|
|
| 37 |
} |
|
| 38 |
#Temporäre Spalte abschneiden |
|
| 39 |
return(liste[1:6]) |
|
| 40 |
} |
|
| 41 |
|
|
| 42 |
#Einlesen und berechnen von möglichen Datensätzen für die Beschriftung |
|
| 43 |
beschriftungEinlesen <- function(basisname){
|
|
| 44 |
gruppenname <- "Rotationen" |
|
| 45 |
data <- read.csv(file=paste("~/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",gruppenname,"/",basisname,".csv",sep=""),header=FALSE)
|
|
| 46 |
|
|
| 47 |
#Geeignete Spalten: |
|
| 48 |
#entfernungKamera: data$V16 |
|
| 49 |
#Rotation um die X-Achse: data$V17-(pi/2) |
|
| 50 |
data <- within(data,V17 <- V17-(pi/2)) |
|
| 51 |
#Rotation um die Y-Achse: data$V19 |
|
| 52 |
#Rotation um die Z-Achse: data$V18 * (-1.0) |
|
| 53 |
data <- within(data,V18 <- V18 * (-1.0)) |
|
| 54 |
|
|
| 55 |
#Bitte hier als dritte Zahl die gewünschte Spaltennummer eintragen |
|
| 56 |
return(data[c(1,2,19)]) |
|
| 57 |
} |
|
| 58 |
|
|
| 59 |
#Extrahiert zu einer Bildnummer die Beschriftung aus dem übergebenem Datensatz |
|
| 60 |
lookup <- function(bildnummer, beschriftungsdaten){
|
|
| 61 |
ret <- beschriftungsdaten[(beschriftungsdaten$V1==bildnummer),3] |
|
| 62 |
return(ret) |
|
| 63 |
} |
|
| 64 |
|
|
| 65 |
#Erstellt einen Plot der übergebenen Rotationsgenauigkeiten (datensatz) |
|
| 66 |
plotte <- function(datensatz,dateiname,title,xBeschriftung,bibliotheksbez){
|
|
| 67 |
#Ausschnitt berechnen |
|
| 68 |
ymin = min(datensatz$DELTA1,datensatz$DELTA2,datensatz$DELTA3) |
|
| 69 |
ymax = max(datensatz$DELTA1,datensatz$DELTA2,datensatz$DELTA3,abs(ymin)) |
|
| 70 |
# Datei öffnen |
|
| 71 |
svg(filename=paste("rotationsungenauigkeit_",bibliotheksbez,"_",dateiname,".svg",sep=""))
|
|
| 72 |
# Plotten |
|
| 73 |
plot(datensatz$X1,datensatz$DELTA3,ylim=c(ymin,ymax),type="l",main=paste(bibliotheksbez,":",title,sep=""),col="green4",xlab=xBeschriftung,ylab="Abweichung (rad)") |
|
| 74 |
lines(datensatz$X1,datensatz$DELTA2,col="blue") |
|
| 75 |
lines(datensatz$X1,datensatz$DELTA1,col="orange") |
|
| 76 |
legend("topleft", border=NA, c("Winkel um X","Winkel um Y","Winkel um Z"), fill=c("orange","blue","green4"))
|
|
| 77 |
# Datei schreiben |
|
| 78 |
dev.off() |
|
| 79 |
} |
|
| 80 |
|
|
| 81 |
## Hauptfunktionen ## |
|
| 82 |
|
|
| 83 |
leseUndPlotte <- function(dateiname){
|
|
| 84 |
|
|
| 85 |
#Einlesen |
|
| 86 |
bart <- read.csv(file=paste("/home/jonas/Bachelorarbeit/bart2/rot/",dateiname,".csv",sep=""),header=TRUE)
|
|
| 87 |
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/rot/",dateiname,".csv",sep=""),header=TRUE)
|
|
| 88 |
aruco <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/rot/",dateiname,".csv",sep=""),header=TRUE)
|
|
| 89 |
|
|
| 90 |
#Bereinigen |
|
| 91 |
cat("Bereinige BART \n")
|
|
| 92 |
bart <- entferneFehlerhafteRotationsungenauigkeiten(bart) |
|
| 93 |
cat("Bereinige ALVAR \n")
|
|
| 94 |
alvar <- entferneFehlerhafteRotationsungenauigkeiten(alvar) |
|
| 95 |
cat("Bereinige ARUCO \n")
|
|
| 96 |
aruco <- entferneFehlerhafteRotationsungenauigkeiten(aruco) |
|
| 97 |
|
|
| 98 |
cat("Maxima:","\nBART ",max(bart$DELTA1),max(bart$DELTA2),max(bart$DELTA3),"\nALVAR",max(alvar$DELTA1),max(alvar$DELTA2),max(alvar$DELTA3),"\nARUCO",max(aruco$DELTA1),max(aruco$DELTA2),max(aruco$DELTA3),"\n")
|
|
| 99 |
|
|
| 100 |
#Achsenbeschriftung |
|
| 101 |
#achse <- beschriftungEinlesen(basisname) |
|
| 102 |
#bart <- within(bart,X1 <- sapply(X1,lookup,achse)) |
|
| 103 |
#alvar <- within(alvar,X1 <- sapply(X1,lookup,achse)) |
|
| 104 |
#aruco <- within(aruco,X1 <- sapply(X1,lookup,achse)) |
|
| 105 |
|
|
| 106 |
#Plotten |
|
| 107 |
plotte(bart, dateiname, title, xlab, "BART") |
|
| 108 |
plotte(alvar, dateiname, title, xlab, "ALVAR") |
|
| 109 |
plotte(aruco, dateiname, title, xlab, "ARUCO") |
|
| 110 |
|
|
| 111 |
return(0) |
|
| 112 |
} |
|
| 113 |
|
|
| 114 |
## Hauptpogramm ## |
|
| 115 |
leseUndPlotte(paste(basisname,"_1080p48",sep="")) |
|
| 116 |
leseUndPlotte(paste(basisname,"_1080p24",sep="")) |
|
| 117 |
leseUndPlotte(paste(basisname,"_1080p12",sep="")) |
|
| 118 |
leseUndPlotte(paste(basisname,"_720p48",sep="")) |
|
| 119 |
leseUndPlotte(paste(basisname,"_720p24",sep="")) |
|
| 120 |
leseUndPlotte(paste(basisname,"_720p12",sep="")) |
|
| 121 |
leseUndPlotte(paste(basisname,"_360p48",sep="")) |
|
| 122 |
leseUndPlotte(paste(basisname,"_360p24",sep="")) |
|
| 123 |
leseUndPlotte(paste(basisname,"_360p12",sep="")) |
|
| 124 |
|
|
| 125 |
|
|
| 126 |
|
|
| R/share/hauptdatensaetze_laden.r | ||
|---|---|---|
| 1 |
#Diese Datei lädt die Datensätze mit den von den Bibliotheksanbindungen abgespeicherten Daten |
|
| 2 |
|
|
| 3 |
#Erzeugt eine Dummy-Frame, damit die anderen Bibliotheken, die evtl. Marker erkannt haben berechnet werden können. |
|
| 4 |
error <- function(e){
|
|
| 5 |
#Es werden die gleichen Tags gewählt, damit spätere Zugriffe durchlaufen |
|
| 6 |
data.frame(X1="",X2="",X3="",X4="",X5="",X6="",X7="",X8="",X9="",X10="",X11="",X12="",X13="",X14="",X15="",X16="",X18="",X19="",X20="") |
|
| 7 |
} |
|
| 8 |
|
|
| 9 |
#Einlesen (falls möglich, ansonsten ist die Datei vermutlich leer) |
|
| 10 |
cat("Lese ","/home/jonas/Bachelorarbeit/bart2/",dateiname,"\n",sep="")
|
|
| 11 |
bart <- tryCatch(read.csv(file=paste("/home/jonas/Bachelorarbeit/bart2/",dateiname,sep=""),header=F), error=error)
|
|
| 12 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/alvar/2.0.0/alvar-2.0.0-sdk-linux64-gcc44/build/build_gcc44_release/sample/",dateiname,"\n",sep="")
|
|
| 13 |
alvar <- tryCatch(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/",dateiname,sep=""),header=F), error=error)
|
|
| 14 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,"\n",sep="")
|
|
| 15 |
aruco <- tryCatch(read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,sep=""),header=F), error=error)
|
|
| 16 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",vergleichsdatei,"\n",sep="")
|
|
| 17 |
blender <- tryCatch(read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",vergleichsdatei, sep=""),header=F), error=error)
|
|
| R/share/hauptdatensaetze_laden.r~ | ||
|---|---|---|
| 1 |
#Diese Datei lädt die Datensätze mit den von den Bibliotheksanbindungen abgespeicherten Daten |
|
| 2 |
|
|
| 3 |
|
|
| 4 |
#Einlesen (falls möglich, ansonsten ist die Datei vermutlich leer) |
|
| 5 |
cat("Lese ","/home/jonas/Bachelorarbeit/bart2/",dateiname,"\n",sep="")
|
|
| 6 |
bart <- tryCatch(read.csv(file=paste("/home/jonas/Bachelorarbeit/bart2/",dateiname,sep=""),header=F), error=error)
|
|
| 7 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/alvar/2.0.0/alvar-2.0.0-sdk-linux64-gcc44/build/build_gcc44_release/sample/",dateiname,"\n",sep="")
|
|
| 8 |
alvar <- tryCatch(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/",dateiname,sep=""),header=F), error=error)
|
|
| 9 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,"\n",sep="")
|
|
| 10 |
aruco <- tryCatch(read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/",dateiname,sep=""),header=F), error=error)
|
|
| 11 |
cat("Lese ","/home/jonas/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",vergleichsdatei,"\n",sep="")
|
|
| 12 |
blender <- tryCatch(read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",vergleichsdatei, sep=""),header=F), error=error)
|
|
| R/transl.r | ||
|---|---|---|
| 1 |
#!/usr/bin/env Rscript |
|
| 2 |
|
|
| 3 |
#Argumente einlesen |
|
| 4 |
args <- commandArgs(TRUE) |
|
| 5 |
if(length(args) == 2){
|
|
| 6 |
cat("basisname=\"",args[1],"\"\n",sep="")
|
|
| 7 |
cat("diagrammtitle=\"",args[2],"\"\n",sep="")
|
|
| 8 |
basisname <- args[1] |
|
| 9 |
title <- args[2] |
|
| 10 |
}else |
|
| 11 |
{
|
|
| 12 |
cat("Fehler: Bitte Eingabedateiname, Basisname für die Ausgabedateien und Diagrammtitle angeben!","\n")
|
|
| 13 |
quit() |
|
| 14 |
} |
|
| 15 |
|
|
| 16 |
### Hilfsfunktionen ### |
|
| 17 |
|
|
| 18 |
#Einlesen des übergebenen Dateinamens für jede der Bibliotheken |
|
| 19 |
einlesen <- function(dateiname){
|
|
| 20 |
bart <- read.csv(file=paste("/home/jonas/Bachelorarbeit/bart2/transl/",dateiname,sep=""),header=FALSE)
|
|
| 21 |
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/transl/",dateiname,sep=""),header=FALSE)
|
|
| 22 |
aruco <- read.csv(file=paste("/home/jonas/Dokumente/Studium/Bachelorarbeit/aruco/aruco-1.2.5/transl/",dateiname,sep=""),header=FALSE)
|
|
| 23 |
return(list(bart,alvar,aruco)) |
|
| 24 |
} |
|
| 25 |
|
|
| 26 |
#Einlesen und berechnen von möglichen Datensätzen für die Beschriftung |
|
| 27 |
beschriftungEinlesen <- function(basisname){
|
|
| 28 |
gruppenname <- "Bewegungen" |
|
| 29 |
data <- read.csv(file=paste("~/Dokumente/Studium/Bachelorarbeit/blender-files/Positions/",gruppenname,"/",basisname,".csv",sep=""),header=FALSE)
|
|
| 30 |
#entfernungKamera: data$V16 |
|
| 31 |
#Rotation um die X-Achse: data$V17-(pi/2) |
|
| 32 |
#data <- within(data,V17 <- V17-(pi/2)) |
|
| 33 |
#Rotation um die Y-Achse: data$V19 |
|
| 34 |
#Rotation um die Z-Achse: data$V18 * (-1.0) |
|
| 35 |
#data <- within(data,V18 <- V18 * (-1.0)) |
|
| 36 |
return(data[c(1,2,12)]) |
|
| 37 |
} |
|
| 38 |
|
|
| 39 |
#Plottet den übergebenen Datensatz einer Auflösung |
|
| 40 |
plotten <- function(daten,basisname,korrektur){
|
|
| 41 |
bart <- daten[[1]] |
|
| 42 |
alvar <- daten[[2]] |
|
| 43 |
aruco <- daten[[3]] |
|
| 44 |
|
|
| 45 |
#Korrektur (überspringe k (= korrektur) Bildnummern) |
|
| 46 |
bart <- within(bart,V1<-lapply(V1,function(x,k){return(x*(k+1)-k)},korrektur))
|
|
| 47 |
alvar <- within(alvar,V1<-lapply(V1,function(x,k){return(x*(k+1)-k)},korrektur))
|
|
| 48 |
aruco <- within(aruco,V1<-lapply(V1,function(x,k){return(x*(k+1)-k)},korrektur))
|
|
| 49 |
|
|
| 50 |
cat("Maxima:","\nBART ",max(bart$V3),max(bart$V4),max(bart$V5),"\nALVAR",max(alvar$V3),max(alvar$V4),max(alvar$V5),"\nARUCO",max(aruco$V3),max(aruco$V4),max(aruco$V5),"\n")
|
|
| 51 |
#Plotten BART |
|
| 52 |
ymin = min(bart$V3,bart$V4,bart$V5) |
|
| 53 |
ymax = 1.2*max(bart$V3,bart$V4,bart$V5,abs(ymin)) |
|
| 54 |
svg(filename=paste("translationsungenauigkeit_bart_",basisname,".svg",sep=""))
|
|
| 55 |
#Feste Grenzen: |
|
| 56 |
#plot(bart$V1,bart$V5,ylim=c(0,0.01),xlim=c(0,20),type="l",main=paste("BART:",title),col="green4",xlab="Bildnummer",ylab="Abweichung (m)")
|
|
| 57 |
# Variable Grenzen: |
|
| 58 |
plot(bart$V1,bart$V5,ylim=c(ymin,ymax),type="l",main=paste("BART:",title),col="green4",xlab="Bildnummer",ylab="Abweichung (m)")
|
|
| 59 |
lines(bart$V1,bart$V4,col="blue") |
|
| 60 |
lines(bart$V1,bart$V3,col="orange") |
|
| 61 |
legend("topleft", border=NA, c("Position entlang X","Position entlang Y","Position entlang Z"), fill=c("orange","blue","green4"))
|
|
| 62 |
|
|
| 63 |
dev.off() |
|
| 64 |
|
|
| 65 |
#Plotten ALVAR |
|
| 66 |
ymin = min(alvar$V3,alvar$V4,alvar$V5) |
|
| 67 |
ymax = 1.2*max(alvar$V3,alvar$V4,alvar$V5,abs(ymin)) |
|
| 68 |
svg(filename=paste("translationsungenauigkeit_alvar_",basisname,".svg",sep=""))
|
|
| 69 |
#Feste Grenzen: |
|
| 70 |
#plot(alvar$V1,alvar$V5,ylim=c(0,0.01),xlim=c(0,20),type="l",main=paste("ALVAR:",title),col="green4",xlab="Bildnummer",ylab="Abweichung (m)")
|
|
| 71 |
# Variable Grenzen: |
|
| 72 |
plot(alvar$V1,alvar$V5,ylim=c(ymin,ymax),type="l",main=paste("ALVAR:",title),col="green4",xlab="Bildnummer",ylab="Abweichung (m)")
|
|
| 73 |
lines(alvar$V1,alvar$V4,col="blue") |
|
| 74 |
lines(alvar$V1,alvar$V3,col="orange") |
|
| 75 |
legend("topleft", border=NA, c("Position entlang X","Position entlang Y","Position entlang Z"), fill=c("orange","blue","green4"))
|
|
| 76 |
|
|
| 77 |
dev.off() |
|
| 78 |
|
|
| 79 |
|
|
| 80 |
#Plotten ARUCO |
|
| 81 |
ymin = min(aruco$V3,aruco$V4,aruco$V5) |
|
| 82 |
ymax = 1.2*max(aruco$V3,aruco$V4,aruco$V5,abs(ymin)) |
|
| 83 |
svg(filename=paste("translationsungenauigkeit_aruco_",basisname,".svg",sep=""))
|
|
| 84 |
#Feste Grenzen: |
|
| 85 |
#plot(aruco$V1,aruco$V5,ylim=c(0,0.01),xlim=c(0,20),type="l",main=paste("ARUCO:",title),col="green4",xlab="Bildnummer",ylab="Abweichung (m)")
|
|
| 86 |
# Variable Grenzen: |
|
| 87 |
plot(aruco$V1,aruco$V5,ylim=c(ymin,ymax),type="l",main=paste("ARUCO:",title),col="green4",xlab="Bildnummer",ylab="Abweichung (m)")
|
|
| 88 |
lines(aruco$V1,aruco$V4,col="blue") |
|
| 89 |
lines(aruco$V1,aruco$V3,col="orange") |
|
| 90 |
legend("topleft", border=NA, c("Position entlang X","Position entlang Y","Position entlang Z"), fill=c("orange","blue","green4"))
|
|
| 91 |
|
|
| 92 |
dev.off() |
|
| 93 |
|
|
| 94 |
svg(filename=paste("translationsungenauigkeit_x_",basisname,".svg",sep=""))
|
|
| 95 |
boxpX <- boxplot(bart$V3,alvar$V3,aruco$V3,names=c("BART","ALVAR","ARUCO"),main=paste(title,"entlang X"),xlab="Bibliothek",ylab="Abweichung (m)",range=0)
|
|
| 96 |
dev.off() |
|
| 97 |
|
|
| 98 |
svg(filename=paste("translationsungenauigkeit_y_",basisname,".svg",sep=""))
|
|
| 99 |
boxpY <- boxplot(bart$V4,alvar$V4,aruco$V4,names=c("BART","ALVAR","ARUCO"),main=paste(title,"entlang Y"),xlab="Bibliothek",ylab="Abweichung (m)",range=0)
|
|
| 100 |
dev.off() |
|
| 101 |
|
|
| 102 |
svg(filename=paste("translationsungenauigkeit_z_",basisname,".svg",sep=""))
|
|
| 103 |
boxpZ <- boxplot(bart$V5,alvar$V5,aruco$V5,names=c("BART","ALVAR","ARUCO"),main=paste(title,"entlang Z"),xlab="Bibliothek",ylab="Abweichung (m)",range=0)
|
|
| 104 |
dev.off() |
|
| 105 |
|
|
| 106 |
return(list(boxpX,boxpY,boxpZ)) |
|
| 107 |
} |
|
| 108 |
|
|
| 109 |
#Extrahiert zu einer Bildnummer die Beschriftung aus dem übergebenem Datensatz |
|
| 110 |
lookup <- function(bildnummer, beschriftungsdaten){
|
|
| 111 |
ret <- beschriftungsdaten[(beschriftungsdaten$V1==bildnummer),3] |
|
| 112 |
return(ret) |
|
| 113 |
} |
|
| 114 |
|
|
| 115 |
#Plottet den übergebenen Datensatz einer Auflösung wobei die Beschriftung aus dem zweiten übergebenem Datensatz gewonnen wird. |
|
| 116 |
plotten2 <- function(daten,basisname,achsendaten,korrektur){
|
|
| 117 |
bart <- daten[[1]] |
|
| 118 |
alvar <- daten[[2]] |
|
| 119 |
aruco <- daten[[3]] |
|
| 120 |
|
|
| 121 |
#Beschriftung der X-Achse |
|
| 122 |
xlab="X-Position" |
|
| 123 |
#Bildnummer der unteren Grenze |
|
| 124 |
xmin=1 |
|
| 125 |
#Bildnummer der oberen Grenze |
|
| 126 |
xmax=300 |
|
| 127 |
ymax2=1 |
|
| 128 |
#Prefix |
|
| 129 |
prefix="" |
|
| 130 |
|
|
| 131 |
if(bart[1,1]==0){
|
|
| 132 |
bart <- within(bart,V1<-lapply(V1,function(x){return(x+1)}))
|
|
| 133 |
} |
|
| 134 |
#Korrektur (überspringe k (= korrektur) Bildnummern) |
|
| 135 |
bart <- within(bart,V1<-lapply(V1,function(x,k){return(x*(k+1)-k)},korrektur))
|
|
| 136 |
alvar <- within(alvar,V1<-lapply(V1,function(x,k){return(x*(k+1)-k)},korrektur))
|
|
| 137 |
aruco <- within(aruco,V1<-lapply(V1,function(x,k){return(x*(k+1)-k)},korrektur))
|
|
| 138 |
|
|
| 139 |
bart <- within(bart,V1<-lapply(V1,lookup,beschriftungsdaten=achsendaten)) |
|
| 140 |
alvar <- within(alvar,V1<-lapply(V1,lookup,beschriftungsdaten=achsendaten)) |
|
| 141 |
aruco <- within(aruco,V1<-lapply(V1,lookup,beschriftungsdaten=achsendaten)) |
|
| 142 |
|
|
| 143 |
cat("Maxima:","\nBART ",max(bart$V3),max(bart$V4),max(bart$V5),"\nALVAR",max(alvar$V3),max(alvar$V4),max(alvar$V5),"\nARUCO",max(aruco$V3),max(aruco$V4),max(aruco$V5),"\n")
|
|
| 144 |
#Plotten BART |
|
| 145 |
ymin = min(bart$V3,bart$V4,bart$V5) |
|
| 146 |
ymax = 1.2*max(bart$V3,bart$V4,bart$V5,abs(ymin)) |
|
| 147 |
svg(filename=paste("translationsungenauigkeit_bart_",basisname,"",prefix,".svg",sep=""))
|
|
| 148 |
#Feste Grenzen: |
|
| 149 |
#plot(bart$V1,bart$V5,ylim=c(0,ymax2),xlim=c(lookup(xmin,beschriftungsdaten=achsendaten),lookup(xmax,beschriftungsdaten=achsendaten)),type="l",main=paste("BART:",title),col="green4",xlab=xlab,ylab="Abweichung (m)")
|
|
| 150 |
# Variable Grenzen: |
|
| 151 |
plot(bart$V1,bart$V5,ylim=c(ymin,ymax),type="l",main=paste("BART:",title),col="green4",xlab=xlab,ylab="Abweichung (m)")
|
|
| 152 |
lines(bart$V1,bart$V4,col="blue") |
|
| 153 |
lines(bart$V1,bart$V3,col="orange") |
|
| 154 |
legend("topleft", border=NA, c("Position entlang X","Position entlang Y","Position entlang Z"), fill=c("orange","blue","green4"))
|
|
| 155 |
|
|
| 156 |
dev.off() |
|
| 157 |
|
|
| 158 |
#Plotten ALVAR |
|
| 159 |
ymin = min(alvar$V3,alvar$V4,alvar$V5) |
|
| 160 |
ymax = 1.2*max(alvar$V3,alvar$V4,alvar$V5,abs(ymin)) |
|
| 161 |
svg(filename=paste("translationsungenauigkeit_alvar_",basisname,"",prefix,".svg",sep=""))
|
|
| 162 |
#Feste Grenzen: |
|
| 163 |
#plot(alvar$V1,alvar$V5,ylim=c(0,ymax2),xlim=c(lookup(xmin,beschriftungsdaten=achsendaten),lookup(xmax,beschriftungsdaten=achsendaten)),type="l",main=paste("ALVAR:",title),col="green4",xlab=xlab,ylab="Abweichung (m)")
|
|
| 164 |
# Variable Grenzen: |
|
| 165 |
plot(alvar$V1,alvar$V5,ylim=c(ymin,ymax),type="l",main=paste("ALVAR:",title),col="green4",xlab=xlab,ylab="Abweichung (m)")
|
|
| 166 |
lines(alvar$V1,alvar$V4,col="blue") |
|
| 167 |
lines(alvar$V1,alvar$V3,col="orange") |
|
| 168 |
legend("topleft", border=NA, c("Position entlang X","Position entlang Y","Position entlang Z"), fill=c("orange","blue","green4"))
|
|
| 169 |
|
|
| 170 |
dev.off() |
|
| 171 |
|
|
| 172 |
|
|
| 173 |
#Plotten ARUCO |
|
| 174 |
ymin = min(aruco$V3,aruco$V4,aruco$V5) |
|
| 175 |
ymax = 1.2*max(aruco$V3,aruco$V4,aruco$V5,abs(ymin)) |
|
| 176 |
svg(filename=paste("translationsungenauigkeit_aruco_",basisname,"",prefix,".svg",sep=""))
|
|
| 177 |
#Feste Grenzen: |
|
| 178 |
#plot(aruco$V1,aruco$V5,ylim=c(0,ymax2),xlim=c(lookup(xmin,beschriftungsdaten=achsendaten),lookup(xmax,beschriftungsdaten=achsendaten)),type="l",main=paste("ARUCO:",title),col="green4",xlab=xlab,ylab="Abweichung (m)")
|
|
| 179 |
# Variable Grenzen: |
|
| 180 |
plot(aruco$V1,aruco$V5,ylim=c(ymin,ymax),type="l",main=paste("ARUCO:",title),col="green4",xlab=xlab,ylab="Abweichung (m)")
|
|
| 181 |
lines(aruco$V1,aruco$V4,col="blue") |
|
| 182 |
lines(aruco$V1,aruco$V3,col="orange") |
|
| 183 |
legend("topleft", border=NA, c("Position entlang X","Position entlang Y","Position entlang Z"), fill=c("orange","blue","green4"))
|
|
| 184 |
|
|
| 185 |
dev.off() |
|
| 186 |
|
|
| 187 |
svg(filename=paste("translationsungenauigkeit_x_",basisname,".svg",sep=""))
|
|
| 188 |
boxpX <- boxplot(bart$V3,alvar$V3,aruco$V3,names=c("BART","ALVAR","ARUCO"),main=paste(title,"entlang X"),xlab="Bibliothek",ylab="Abweichung (m)",range=0)
|
|
| 189 |
dev.off() |
|
| 190 |
|
|
| 191 |
svg(filename=paste("translationsungenauigkeit_y_",basisname,".svg",sep=""))
|
|
| 192 |
boxpY <- boxplot(bart$V4,alvar$V4,aruco$V4,names=c("BART","ALVAR","ARUCO"),main=paste(title,"entlang Y"),xlab="Bibliothek",ylab="Abweichung (m)",range=0)
|
|
| 193 |
dev.off() |
|
| 194 |
|
|
| 195 |
svg(filename=paste("translationsungenauigkeit_z_",basisname,".svg",sep=""))
|
|
| 196 |
boxpZ <- boxplot(bart$V5,alvar$V5,aruco$V5,names=c("BART","ALVAR","ARUCO"),main=paste(title,"entlang Z"),xlab="Bibliothek",ylab="Abweichung (m)",range=0)
|
|
| 197 |
dev.off() |
|
| 198 |
|
|
| 199 |
return(list(boxpX,boxpY,boxpZ)) |
|
| 200 |
} |
|
| 201 |
|
|
| 202 |
### Hauptprogramm ### |
|
| 203 |
|
|
| 204 |
#Einlesen |
|
| 205 |
daten360 <- einlesen(paste(basisname, "_360p48_transl.csv",sep="")) |
|
| 206 |
daten720 <- einlesen(paste(basisname, "_720p48_transl.csv",sep="")) |
|
| 207 |
daten1080 <- einlesen(paste(basisname,"_1080p48_transl.csv",sep="")) |
|
| 208 |
|
|
| 209 |
#Plotten |
|
| 210 |
#boxp360 <- plotten(daten360,paste(basisname,"_360p48",sep=""),0) |
|
| 211 |
#boxp720 <- plotten(daten720,paste(basisname,"_720p48",sep=""),0) |
|
| 212 |
#boxp1080 <- plotten(daten1080,paste(basisname,"_1080p48",sep=""),0) |
|
| 213 |
|
|
| 214 |
|
|
| 215 |
#Alternative: Plotten mit Achsendaten |
|
| 216 |
achse <- beschriftungEinlesen(basisname) |
|
| 217 |
boxp360 <- plotten2(daten360,paste(basisname,"_360p48",sep=""),achse,0) |
|
| 218 |
boxp720 <- plotten2(daten720,paste(basisname,"_720p48",sep=""),achse,0) |
|
| 219 |
boxp1080 <- plotten2(daten1080,paste(basisname,"_1080p48",sep=""),achse,0) |
|
| 220 |
|
|
| 221 |
#Unterschiede zwischen den Auflösungen ausgeben |
|
| 222 |
cat("Differenzen zwischen 1080p und 720p: \n")
|
|
| 223 |
cat("X\n")
|
|
| 224 |
print(boxp1080[[1]]$stats-boxp720[[1]]$stats) |
|
| 225 |
cat("Y\n")
|
|
| 226 |
print(boxp1080[[2]]$stats-boxp720[[2]]$stats) |
|
| 227 |
cat("Z\n")
|
|
| 228 |
print(boxp1080[[3]]$stats-boxp720[[3]]$stats) |
|
| 229 |
cat("Differenzen zwischen 720p und 360p: \n")
|
|
| 230 |
cat("X\n")
|
|
| 231 |
print(boxp720[[1]]$stats-boxp360[[1]]$stats) |
|
| 232 |
cat("Y\n")
|
|
| 233 |
print(boxp720[[2]]$stats-boxp360[[2]]$stats) |
|
| 234 |
cat("Z\n")
|
|
| 235 |
print(boxp720[[3]]$stats-boxp360[[3]]$stats) |
|
| 236 |
|
|
| 237 |
|
|
| 238 |
|
|
Also available in: Unified diff