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