Revision 6a294261
evaluation/genauigkeit_berechnen.c | ||
---|---|---|
1 |
#include <stdio.h> |
|
2 |
#include <stdlib.h> |
|
3 |
#include <string.h> |
|
4 |
#include <math.h> |
|
5 |
#include <libgen.h> |
|
6 |
|
|
7 |
/* Diese Datei dient der Berechnung der Erkennungsraten und |
|
8 |
der Genauigkeit bei der Positionsbestimmung */ |
|
9 |
|
|
10 |
//Struktur, die eine Transformationsmatrix einer Markerposition beeinhaltet |
|
11 |
typedef struct{ |
|
12 |
double rot1; |
|
13 |
double rot2; |
|
14 |
double rot3; |
|
15 |
double rot4; |
|
16 |
double rot5; |
|
17 |
double rot6; |
|
18 |
double rot7; |
|
19 |
double rot8; |
|
20 |
double rot9; |
|
21 |
double trans1; |
|
22 |
double trans2; |
|
23 |
double trans3; |
|
24 |
} Position; |
|
25 |
|
|
26 |
void einlesen(Position***, FILE*, int); |
|
27 |
void parameterEinlesen(char* param, int* debug, int* minuend, int* ueberspringen, int* wuerfel); |
|
28 |
|
|
29 |
int main(int argc, char* argv[]){ |
|
30 |
|
|
31 |
//Wird von den Markerids der Bibliothek abgezogen |
|
32 |
int minuend = 0; |
|
33 |
//Wird von den Framenummern aus Blender Abgezogen |
|
34 |
int korrektur = 0; |
|
35 |
//Zeigt an, ob der Debugmodus aktiviert ist: 0 = nicht aktiviert und 1 = aktiviert |
|
36 |
int debug = 0; |
|
37 |
int ueberspringen = 0; |
|
38 |
//Zeigt an, ob es sich um die analyse eines Videos mit Würfeln statt Marker handelt |
|
39 |
int wuerfel = 0; |
|
40 |
if(argc > 5){ |
|
41 |
int pcount; |
|
42 |
for(pcount = 5;pcount<argc;pcount++) |
|
43 |
{ |
|
44 |
parameterEinlesen(argv[pcount],&debug,&minuend,&ueberspringen,&wuerfel); |
|
45 |
} |
|
46 |
} |
|
47 |
if(argc > 4){ |
|
48 |
int maxMarker = atoi(argv[3]); |
|
49 |
int maxFrame = atoi(argv[4]); |
|
50 |
|
|
51 |
//Werte erhöhen um später davon ausgehen zu können, dass dies exklusive Schranken sind. |
|
52 |
maxMarker++; |
|
53 |
maxFrame++; |
|
54 |
|
|
55 |
if(debug){ |
|
56 |
printf("%s -> maxMarker: %d\n",argv[3],maxMarker); |
|
57 |
printf("%s -> maxFrame: %d\n",argv[4],maxFrame); |
|
58 |
printf("%s -> minuend: %d\n",argv[5],minuend); |
|
59 |
} |
|
60 |
|
|
61 |
/* Dateien öffnen */ |
|
62 |
FILE* handle = fopen(argv[1],"r"); |
|
63 |
FILE* blenderHandle = fopen(argv[2],"r"); |
|
64 |
|
|
65 |
if(handle == NULL || blenderHandle == NULL){ |
|
66 |
printf("Fehler beim Lesen der angegebenen Dateien!\n"); |
|
67 |
return 1; |
|
68 |
} |
|
69 |
|
|
70 |
/* Dateinamen ohne Endung berechnen: |
|
71 |
Der Pfad wird nach 100 Zeichen abgeschnitten! */ |
|
72 |
char* basenameArg1 = (char*) malloc(101* sizeof(char)); |
|
73 |
strncpy(basenameArg1,argv[1],100); |
|
74 |
char* dotPtr = strrchr(basenameArg1,'.'); |
|
75 |
*dotPtr = 0; |
|
76 |
char* datName = (char*) malloc(101* sizeof(char)); |
|
77 |
strncpy(datName,basenameArg1,100); |
|
78 |
strcat(datName,"_transl.csv"); |
|
79 |
FILE* translHandle = fopen(datName,"w"); |
|
80 |
datName = (char*) malloc(101* sizeof(char)); |
|
81 |
strncpy(datName,basenameArg1,100); |
|
82 |
strcat(datName,"_log.txt"); |
|
83 |
FILE* logHandle = fopen(datName,"w"); |
|
84 |
free(datName); |
|
85 |
free(basenameArg1); |
|
86 |
|
|
87 |
/* Das Array für den Inhalt aus handle */ |
|
88 |
Position*** array; |
|
89 |
/* Das Array für den inhalt aus blenderHandle */ |
|
90 |
Position*** blenderArray; |
|
91 |
|
|
92 |
/* Speicher reservieren */ |
|
93 |
array = (Position***) malloc(maxFrame*sizeof(Position**)); |
|
94 |
int index; |
|
95 |
for(index=0; index < maxFrame; index++) |
|
96 |
{ |
|
97 |
Position** temp = malloc(maxMarker*sizeof(Position*)); |
|
98 |
array[index] = temp; |
|
99 |
} |
|
100 |
blenderArray = (Position***) malloc(maxFrame*sizeof(Position**)); |
|
101 |
for(index=0; index < maxFrame; index++) |
|
102 |
{ |
|
103 |
Position** temp = malloc(maxMarker*sizeof(Position*)); |
|
104 |
blenderArray[index] = temp; |
|
105 |
} |
|
106 |
|
|
107 |
/* Daten einlesen */ |
|
108 |
printf("Lese bibliotheksseitige Daten ein.\n"); |
|
109 |
einlesen(array, handle, debug); |
|
110 |
printf("Lese blenderseitige Daten ein.\n"); |
|
111 |
einlesen(blenderArray, blenderHandle, debug); |
|
112 |
|
|
113 |
/* Daten auswerten */ |
|
114 |
int frameIndex; |
|
115 |
int markerIndex; |
|
116 |
int erkannteMarker = 0; |
|
117 |
int nichtErkannteMarker = 0; |
|
118 |
int blenderFrameIndex; |
|
119 |
int debug = 0; |
|
120 |
int wuerfelErkannt = 0; /* 0 bedeutet kein Würfel im Bild, 1 bedeutet Würfel erkannt und 2 bedeutet Würfel nicht erkannt*/ |
|
121 |
|
|
122 |
|
|
123 |
for(frameIndex = 0, blenderFrameIndex=(frameIndex * (ueberspringen+1))+korrektur; blenderFrameIndex < maxFrame; ){ |
|
124 |
for(markerIndex = 0; markerIndex < maxMarker && (markerIndex-minuend) < maxMarker; markerIndex++){ |
|
125 |
if(array[frameIndex][markerIndex-minuend] != NULL && blenderArray[blenderFrameIndex][markerIndex] != NULL){ |
|
126 |
/** Genauigkeit bei der Positionsbestimmung berechnen **/ |
|
127 |
/* Betrachte Absolutwerte, da die Vorzeichen nur von bibliotheksseitiger Definition des Koordinatensystemes abhängen. */ |
|
128 |
Position* messung = array[frameIndex][markerIndex-minuend]; |
|
129 |
Position* theorie = blenderArray[blenderFrameIndex][markerIndex]; |
|
130 |
fprintf(translHandle,"%i,%i,%lf,%lf,%lf\n",frameIndex,markerIndex,fabs(fabs(messung->trans1)-fabs(theorie->trans1)),fabs(fabs(messung->trans2)-fabs(theorie->trans2)),fabs(fabs(messung->trans3)-fabs(theorie->trans3))); |
|
131 |
|
|
132 |
if(wuerfel){ |
|
133 |
/*Das Bild gilt als erkannt */ |
|
134 |
wuerfelErkannt = 1; |
|
135 |
} |
|
136 |
else{ |
|
137 |
erkannteMarker++; |
|
138 |
} |
|
139 |
} |
|
140 |
else if(erkannteMarker == 0 && array[frameIndex][markerIndex-minuend] != NULL){ |
|
141 |
if(blenderArray[blenderFrameIndex+1][markerIndex] != NULL && korrektur < 1) { |
|
142 |
korrektur = 1; |
|
143 |
markerIndex = 0; |
|
144 |
printf("Warnung: Korrektur der Bildnummern eingeschaltet!\n"); |
|
145 |
} |
|
146 |
else |
|
147 |
printf("#Falsch erkannt: Bild: %d Marker: %d\n",frameIndex,markerIndex-minuend); |
|
148 |
} |
|
149 |
else if(blenderArray[blenderFrameIndex][markerIndex] != NULL){ |
|
150 |
printf("#Nicht erkannt: Bild:%d Marker: %d\n",frameIndex,markerIndex-minuend); |
|
151 |
if(wuerfel && (wuerfelErkannt = 0)){ |
|
152 |
wuerfelErkannt = 2; |
|
153 |
} |
|
154 |
else if(! wuerfel){ |
|
155 |
nichtErkannteMarker++; |
|
156 |
} |
|
157 |
} |
|
158 |
|
|
159 |
} |
|
160 |
/* Prüfe ob der Würfel erkannt wurde und erhöhe den entsprechenden Zähler */ |
|
161 |
if(wuerfel && (wuerfelErkannt == 1)){ |
|
162 |
erkannteMarker++; |
|
163 |
} |
|
164 |
else if (wuerfel && (wuerfelErkannt == 2)){ |
|
165 |
nichtErkannteMarker++; |
|
166 |
} |
|
167 |
wuerfelErkannt = 0; |
|
168 |
frameIndex++; |
|
169 |
blenderFrameIndex=(frameIndex * (ueberspringen+1))+korrektur; |
|
170 |
} |
|
171 |
int gesamtzahlMarker = (erkannteMarker+nichtErkannteMarker); |
|
172 |
printf("#Es wurden von %d Markern %d erkannt. Dies entspricht %g %%.\n",gesamtzahlMarker,erkannteMarker,(erkannteMarker*100.0)/gesamtzahlMarker); |
|
173 |
fprintf(logHandle,"#Es wurden von %d Markern %d erkannt. Dies entspricht %g %%.\n",gesamtzahlMarker,erkannteMarker,(erkannteMarker*100.0)/gesamtzahlMarker); |
|
174 |
printf("%d\n",debug); |
|
175 |
|
|
176 |
/* Ressourcen freigeben*/ |
|
177 |
fflush(translHandle); |
|
178 |
fflush(logHandle); |
|
179 |
fclose(translHandle); |
|
180 |
fclose(logHandle); |
|
181 |
|
|
182 |
return 0; |
|
183 |
} |
|
184 |
else { |
|
185 |
printf("Bitte Datei, Vergleichsdatei (von Blender), maximale Markerid und maximale Bildanzahl angeben!\n" ); |
|
186 |
return 1; |
|
187 |
} |
|
188 |
|
|
189 |
} |
|
190 |
|
|
191 |
/* Liest die übergebene CSV-Datei mit Markererkennungen ein.*/ |
|
192 |
void einlesen(Position*** array, FILE* handle, int debug) |
|
193 |
{ |
|
194 |
/* Initialisierung */ |
|
195 |
char* string = malloc(80); |
|
196 |
int frameNumber = -1; |
|
197 |
int markerID = -1; |
|
198 |
double rot1 = -1.0; |
|
199 |
double rot2 = -1.0; |
|
200 |
double rot3 = -1.0; |
|
201 |
double rot4 = -1.0; |
|
202 |
double rot5 = -1.0; |
|
203 |
double rot6 = -1.0; |
|
204 |
double rot7 = -1.0; |
|
205 |
double rot8 = -1.0; |
|
206 |
double rot9 = -1.0; |
|
207 |
double trans1 = -1.0; |
|
208 |
double trans2 = -1.0; |
|
209 |
double trans3 = -1.0; |
|
210 |
double s = -1.0; |
|
211 |
int erkannt; |
|
212 |
|
|
213 |
while(!feof(handle)){ |
|
214 |
erkannt = fscanf(handle,"%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%s\n",&frameNumber,&markerID,&rot1,&rot2,&rot3,&rot4,&rot5,&rot6,&rot7,&rot8,&rot9,&trans1,&trans2,&trans3,&s,string); |
|
215 |
if(erkannt < 15){ |
|
216 |
printf("Überspringe eine Zeile. %d \n",erkannt); |
|
217 |
printf("%d,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%s\n",frameNumber,markerID,rot1,rot2,rot3,rot4,rot5,rot6,rot7,rot8,rot9,trans1,trans2,trans3,s,string); |
|
218 |
erkannt = fscanf(handle,"%s\n",string); |
|
219 |
continue; |
|
220 |
} |
|
221 |
else if(debug){ |
|
222 |
printf("Processing Marker %d. (%d)\n",markerID,frameNumber); |
|
223 |
} |
|
224 |
Position* tempstruct; |
|
225 |
tempstruct = (Position*) malloc(sizeof(Position)); |
|
226 |
tempstruct->rot1 = rot1; |
|
227 |
tempstruct->rot2 = rot2; |
|
228 |
tempstruct->rot3 = rot3; |
|
229 |
tempstruct->rot4 = rot4; |
|
230 |
tempstruct->rot5 = rot5; |
|
231 |
tempstruct->rot6 = rot6; |
|
232 |
tempstruct->rot7 = rot7; |
|
233 |
tempstruct->rot8 = rot8; |
|
234 |
tempstruct->rot9 = rot9; |
|
235 |
tempstruct->trans1 = trans1; |
|
236 |
tempstruct->trans2 = trans2; |
|
237 |
tempstruct->trans3 = trans3; |
|
238 |
array[frameNumber][markerID] = tempstruct; |
|
239 |
} |
|
240 |
free(string); |
|
241 |
} |
|
242 |
|
|
243 |
/* Liest einen übergebenen Parameter ein */ |
|
244 |
void parameterEinlesen(char* param, int* debug, int* minuend, int* ueberspringen, int* wuerfel){ |
|
245 |
if(strncmp(param,"--debug",7) == 0){ |
|
246 |
*debug = 1; |
|
247 |
} |
|
248 |
else if(strncmp(param,"--skipp1",8) == 0) |
|
249 |
{ |
|
250 |
*ueberspringen = 1; |
|
251 |
} |
|
252 |
else if(strncmp(param,"--skipp3",8) == 0) |
|
253 |
{ |
|
254 |
*ueberspringen = 3; |
|
255 |
} |
|
256 |
else if(strncmp(param,"--wuerfel",6) == 0) |
|
257 |
{ |
|
258 |
printf("ACHTUNG: Würfelmodus aktiviert!\n"); |
|
259 |
*wuerfel = 1; |
|
260 |
} |
|
261 |
else{ |
|
262 |
int temp = atoi(param); |
|
263 |
if(temp != 0){ |
|
264 |
*minuend = temp; |
|
265 |
} |
|
266 |
} |
|
267 |
} |
|
268 |
|
|
269 |
/* |
|
270 |
Referenzen: |
|
271 |
|
|
272 |
Die Programmiersprache C. Ein Nachschlagewerk 14. Aufl.; Regionales Rechenzentrum für Niedersachsen / Leibnitz Universität Hannover |
|
273 |
Möller, R; Kurze Einführung in die Programmiersprache C; 2014 |
|
274 |
*/ |
Also available in: Unified diff