1 | /* |
---|
2 | |
---|
3 | Brian Curless |
---|
4 | |
---|
5 | Computer Graphics Laboratory |
---|
6 | Stanford University |
---|
7 | |
---|
8 | --------------------------------------------------------------------- |
---|
9 | |
---|
10 | Copyright (1997) The Board of Trustees of the Leland Stanford Junior |
---|
11 | University. Except for commercial resale, lease, license or other |
---|
12 | commercial transactions, permission is hereby given to use, copy, |
---|
13 | modify this software for academic purposes only. No part of this |
---|
14 | software or any derivatives thereof may be used in the production of |
---|
15 | computer models for resale or for use in a commercial |
---|
16 | product. STANFORD MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND |
---|
17 | CONCERNING THIS SOFTWARE. No support is implied or provided. |
---|
18 | |
---|
19 | */ |
---|
20 | |
---|
21 | |
---|
22 | #include <limits.h> |
---|
23 | #include <stdlib.h> |
---|
24 | #include <math.h> |
---|
25 | #include <unistd.h> |
---|
26 | #include <sys/wait.h> |
---|
27 | |
---|
28 | #include "vrip.h" |
---|
29 | #include "vripMiscCmds.h" |
---|
30 | #include "vripGlobals.h" |
---|
31 | #include "configure.h" |
---|
32 | #include "occFunc.h" |
---|
33 | |
---|
34 | |
---|
35 | |
---|
36 | int |
---|
37 | Vrip_ParamCmd(ClientData, Tcl_Interp *interp, int argc, const char *argv[]) |
---|
38 | { |
---|
39 | int ival, count; |
---|
40 | uchar ucval; |
---|
41 | float fval; |
---|
42 | |
---|
43 | if (argc == 1) { |
---|
44 | printf("Command: vrip_param [-option value]\n"); |
---|
45 | printf(" -verbose <boolean> (%d)\n", Verbose); |
---|
46 | printf(" -warn <boolean> (%d)\n", Warn); |
---|
47 | printf(" -quiet <boolean> (%d)\n", Quiet); |
---|
48 | |
---|
49 | printf(" -show_norm <boolean> (%d)\n", ShowNormals); |
---|
50 | printf(" -show_weight_slice <boolean> (%d)\n", ShowConfSlice); |
---|
51 | printf(" -show_value_weight <boolean> (%d)\n", ShowValueWeight); |
---|
52 | |
---|
53 | printf(" -use_tails <boolean> (%d)\n", UseTails); |
---|
54 | printf(" -tails_only <boolean> (%d)\n", TailsOnly); |
---|
55 | |
---|
56 | printf(" -fill_gaps <boolean> (%d)\n", FillGaps); |
---|
57 | printf(" -fill_bg <boolean> (%d)\n", FillBackground); |
---|
58 | printf(" -do_silhouette <boolean> (%d)\n", DoSilhouette); |
---|
59 | printf(" -extend_boundary_steps <byte> (%d)\n", EdgeExtensionSamples); |
---|
60 | //printf(" -mesh_resolution <int> (%d)\n", MeshResolution); |
---|
61 | |
---|
62 | printf(" -line_persp_center <float> <float> <float> (%f, %f, %f)\n", |
---|
63 | LASER_LINE_AT_T0_X, LASER_LINE_AT_T0_Y, LASER_LINE_AT_T0_Z); |
---|
64 | printf(" -line_persp_dir <float> <float> <float> (%f, %f, %f)\n", |
---|
65 | LASER_LINE_DIR_X, LASER_LINE_DIR_Y, LASER_LINE_DIR_Z); |
---|
66 | |
---|
67 | printf(" -persp_center <float> <float> <float> (%f, %f, %f)\n", |
---|
68 | PerspectiveCOP.x, PerspectiveCOP.y, PerspectiveCOP.z); |
---|
69 | printf(" -persp_dir <float> <float> <float> (%f, %f, %f)\n", |
---|
70 | PerspectiveDir.x, PerspectiveDir.y, PerspectiveDir.z); |
---|
71 | printf(" -use_persp_dir <boolean> (%d)\n", UsePerspectiveDir); |
---|
72 | |
---|
73 | printf(" -use_length <boolean> (%d)\n", UseEdgeLength); |
---|
74 | printf(" -min_view_dot <float> (%f)\n", MinViewDot); |
---|
75 | printf(" -max_edge_length <float> (%f)\n", MaxEdgeLength); |
---|
76 | printf(" -min_color <char> (%d)\n", MinColor); |
---|
77 | |
---|
78 | printf(" -vert_weight_bias <byte> (%d)\n", ConfidenceBias); |
---|
79 | |
---|
80 | printf(" -view_weight_exp <float> (%f)\n", ConfidenceExponent); |
---|
81 | |
---|
82 | printf(" -boundary_weight_exp <float> (%f)\n", EdgeConfExponent); |
---|
83 | printf(" -max_boundary_steps <int> (%d)\n", EdgeConfSteps); |
---|
84 | printf(" -min_boundary_weight <byte> (%d)\n", MinEdgeConfidence); |
---|
85 | printf(" -min_vertex_confidence float (%f)\n", MinVertexConfidence); |
---|
86 | |
---|
87 | printf(" -ramp_width <float> (%f)\n", OccupancyRampWidth); |
---|
88 | printf(" -w1 <float> (%f)\n", WeightPos1); |
---|
89 | printf(" -w2 <float> (%f)\n", WeightPos2); |
---|
90 | printf(" -w3 <float> (%f)\n", WeightPos3); |
---|
91 | printf(" -w4 <float> (%f)\n", WeightPos4); |
---|
92 | printf(" -w5 <float> (%f)\n", WeightPos5); |
---|
93 | printf(" -min_voxel_weight <byte> (%d)\n", MinWeight); |
---|
94 | |
---|
95 | return TCL_OK; |
---|
96 | } |
---|
97 | |
---|
98 | count = 1; |
---|
99 | while (count < argc) { |
---|
100 | if (EQSTR(argv[count], "-verbose")) { |
---|
101 | count++; |
---|
102 | ival = atoi(argv[count]); |
---|
103 | Verbose = ival != 0; |
---|
104 | } |
---|
105 | else if (EQSTR(argv[count], "-warn")) { |
---|
106 | count++; |
---|
107 | ival = atoi(argv[count]); |
---|
108 | Warn = ival != 0; |
---|
109 | } |
---|
110 | else if (EQSTR(argv[count], "-line_persp_center")) { |
---|
111 | count++; |
---|
112 | fval = atof(argv[count]); |
---|
113 | LASER_LINE_AT_T0_X = fval; |
---|
114 | count++; |
---|
115 | fval = atof(argv[count]); |
---|
116 | LASER_LINE_AT_T0_Y = fval; |
---|
117 | count++; |
---|
118 | fval = atof(argv[count]); |
---|
119 | LASER_LINE_AT_T0_Z = fval; |
---|
120 | } |
---|
121 | else if (EQSTR(argv[count], "-line_persp_dir")) { |
---|
122 | count++; |
---|
123 | fval = atof(argv[count]); |
---|
124 | LASER_LINE_DIR_X = fval; |
---|
125 | count++; |
---|
126 | fval = atof(argv[count]); |
---|
127 | LASER_LINE_DIR_Y = fval; |
---|
128 | count++; |
---|
129 | fval = atof(argv[count]); |
---|
130 | LASER_LINE_DIR_Z = fval; |
---|
131 | } |
---|
132 | else if (EQSTR(argv[count], "-persp_center")) { |
---|
133 | count++; |
---|
134 | fval = atof(argv[count]); |
---|
135 | PerspectiveCOP.x = fval; |
---|
136 | count++; |
---|
137 | fval = atof(argv[count]); |
---|
138 | PerspectiveCOP.y = fval; |
---|
139 | count++; |
---|
140 | fval = atof(argv[count]); |
---|
141 | PerspectiveCOP.z = fval; |
---|
142 | } |
---|
143 | else if (EQSTR(argv[count], "-persp_dir")) { |
---|
144 | count++; |
---|
145 | fval = atof(argv[count]); |
---|
146 | PerspectiveDir.x = fval; |
---|
147 | count++; |
---|
148 | fval = atof(argv[count]); |
---|
149 | PerspectiveDir.y = fval; |
---|
150 | count++; |
---|
151 | fval = atof(argv[count]); |
---|
152 | PerspectiveDir.z = fval; |
---|
153 | } |
---|
154 | else if (EQSTR(argv[count], "-use_tails")) { |
---|
155 | count++; |
---|
156 | ival = atoi(argv[count]); |
---|
157 | UseTails = ival != 0; |
---|
158 | } |
---|
159 | else if (EQSTR(argv[count], "-tails_only")) { |
---|
160 | count++; |
---|
161 | ival = atoi(argv[count]); |
---|
162 | TailsOnly = ival != 0; |
---|
163 | } |
---|
164 | else if (EQSTR(argv[count], "-fill_gaps")) { |
---|
165 | count++; |
---|
166 | ival = atoi(argv[count]); |
---|
167 | FillGaps = ival != 0; |
---|
168 | } |
---|
169 | else if (EQSTR(argv[count], "-fill_bg")) { |
---|
170 | count++; |
---|
171 | ival = atoi(argv[count]); |
---|
172 | FillBackground = ival != 0; |
---|
173 | } |
---|
174 | else if (EQSTR(argv[count], "-do_silhouette")) { |
---|
175 | count++; |
---|
176 | ival = atoi(argv[count]); |
---|
177 | DoSilhouette = ival != 0; |
---|
178 | } |
---|
179 | else if (EQSTR(argv[count], "-show_norm")) { |
---|
180 | count++; |
---|
181 | ival = atoi(argv[count]); |
---|
182 | ShowNormals = ival != 0; |
---|
183 | } |
---|
184 | else if (EQSTR(argv[count], "-show_value_weight")) { |
---|
185 | count++; |
---|
186 | ival = atoi(argv[count]); |
---|
187 | ShowValueWeight = ival != 0; |
---|
188 | } |
---|
189 | else if (EQSTR(argv[count], "-show_weight_slice") || |
---|
190 | EQSTR(argv[count], "-show_conf_slice")) { |
---|
191 | count++; |
---|
192 | ival = atoi(argv[count]); |
---|
193 | ShowConfSlice = ival != 0; |
---|
194 | } |
---|
195 | else if (EQSTR(argv[count], "-quiet")) { |
---|
196 | count++; |
---|
197 | ival = atoi(argv[count]); |
---|
198 | Quiet = ival != 0; |
---|
199 | } |
---|
200 | else if (EQSTR(argv[count], "-superQuiet")) { |
---|
201 | count++; |
---|
202 | ival = atoi(argv[count]); |
---|
203 | SuperQuiet = ival != 0; |
---|
204 | } |
---|
205 | else if (EQSTR(argv[count], "-mesh_resolution")) { |
---|
206 | count++; |
---|
207 | ival = atoi(argv[count]); |
---|
208 | MeshResolution = ival; |
---|
209 | } |
---|
210 | else if (EQSTR(argv[count], "-vert_weight_bias") || |
---|
211 | EQSTR(argv[count], "-confbias")) { |
---|
212 | count++; |
---|
213 | ival = atoi(argv[count]); |
---|
214 | ConfidenceBias = ival; |
---|
215 | } |
---|
216 | else if (EQSTR(argv[count], "-min_boundary_weight") || |
---|
217 | EQSTR(argv[count], "-minedgeconf")) { |
---|
218 | count++; |
---|
219 | ival = atoi(argv[count]); |
---|
220 | MinEdgeConfidence = ival; |
---|
221 | } |
---|
222 | else if (EQSTR(argv[count], "-min_vertex_confidence")) { |
---|
223 | count++; |
---|
224 | fval = atof(argv[count]); |
---|
225 | MinVertexConfidence = fval; |
---|
226 | } |
---|
227 | else if (EQSTR(argv[count], "-max_boundary_steps") || |
---|
228 | EQSTR(argv[count], "-edgeconfsteps")) { |
---|
229 | count++; |
---|
230 | ival = atoi(argv[count]); |
---|
231 | EdgeConfSteps = ival; |
---|
232 | } |
---|
233 | else if (EQSTR(argv[count], "-min_voxel_weight") || |
---|
234 | EQSTR(argv[count], "-minweight")) { |
---|
235 | count++; |
---|
236 | ival = atoi(argv[count]); |
---|
237 | MinWeight = ival; |
---|
238 | } |
---|
239 | else if (EQSTR(argv[count], "-extend_boundary_steps") || |
---|
240 | EQSTR(argv[count], "-extedge")) { |
---|
241 | count++; |
---|
242 | ival = atoi(argv[count]); |
---|
243 | EdgeExtensionSamples = ival; |
---|
244 | } |
---|
245 | else if (EQSTR(argv[count], "-max_edge_length") || |
---|
246 | EQSTR(argv[count], "-maxedge")) { |
---|
247 | count++; |
---|
248 | fval = atof(argv[count]); |
---|
249 | MaxEdgeLength = fval; |
---|
250 | } |
---|
251 | else if (EQSTR(argv[count], "-min_color") || |
---|
252 | EQSTR(argv[count], "-mincolor")) { |
---|
253 | count++; |
---|
254 | ucval = atoi(argv[count]); |
---|
255 | MinColor = ucval; |
---|
256 | } |
---|
257 | else if (EQSTR(argv[count], "-use_length") || |
---|
258 | EQSTR(argv[count], "-uselength")) { |
---|
259 | count++; |
---|
260 | ival = atoi(argv[count]); |
---|
261 | UseEdgeLength = ival; |
---|
262 | } |
---|
263 | else if (EQSTR(argv[count], "-min_view_dot") || |
---|
264 | EQSTR(argv[count], "-minviewdot")) { |
---|
265 | count++; |
---|
266 | fval = atof(argv[count]); |
---|
267 | MinViewDot = fval; |
---|
268 | } |
---|
269 | else if (EQSTR(argv[count], "-ramp_width") || |
---|
270 | EQSTR(argv[count], "-rampwidth")) { |
---|
271 | count++; |
---|
272 | fval = atof(argv[count]); |
---|
273 | OccupancyRampWidth = fval; |
---|
274 | } |
---|
275 | else if (EQSTR(argv[count], "-w1")) { |
---|
276 | count++; |
---|
277 | fval = atof(argv[count]); |
---|
278 | WeightPos1 = fval; |
---|
279 | } |
---|
280 | else if (EQSTR(argv[count], "-w2")) { |
---|
281 | count++; |
---|
282 | fval = atof(argv[count]); |
---|
283 | WeightPos2 = fval; |
---|
284 | } |
---|
285 | else if (EQSTR(argv[count], "-w3")) { |
---|
286 | count++; |
---|
287 | fval = atof(argv[count]); |
---|
288 | WeightPos3 = fval; |
---|
289 | } |
---|
290 | else if (EQSTR(argv[count], "-w4")) { |
---|
291 | count++; |
---|
292 | fval = atof(argv[count]); |
---|
293 | WeightPos4 = fval; |
---|
294 | } |
---|
295 | else if (EQSTR(argv[count], "-w5")) { |
---|
296 | count++; |
---|
297 | fval = atof(argv[count]); |
---|
298 | WeightPos5 = fval; |
---|
299 | } |
---|
300 | else if (EQSTR(argv[count], "-boundary_weight_exp") || |
---|
301 | EQSTR(argv[count], "-edgeconfexp")) { |
---|
302 | count++; |
---|
303 | fval = atof(argv[count]); |
---|
304 | EdgeConfExponent = fval; |
---|
305 | } |
---|
306 | else if (EQSTR(argv[count], "-view_weight_exp") || |
---|
307 | EQSTR(argv[count], "-confexp")) { |
---|
308 | count++; |
---|
309 | fval = atof(argv[count]); |
---|
310 | ConfidenceExponent = fval; |
---|
311 | } else { |
---|
312 | Tcl_AppendResult(interp, "vrip_param: No such parameter, `", |
---|
313 | argv[count], "'", (char *)NULL); |
---|
314 | return TCL_ERROR; |
---|
315 | } |
---|
316 | count++; |
---|
317 | } |
---|
318 | |
---|
319 | return TCL_OK; |
---|
320 | } |
---|
321 | |
---|
322 | |
---|
323 | |
---|
324 | int |
---|
325 | Vrip_MergeTimeCmd(ClientData, Tcl_Interp *interp, int argc, const char *argv[]) |
---|
326 | { |
---|
327 | char time[PATH_MAX]; |
---|
328 | |
---|
329 | sprintf(time, "%f", MergeTime); |
---|
330 | Tcl_SetResult(interp, time, TCL_VOLATILE); |
---|
331 | |
---|
332 | return TCL_OK; |
---|
333 | } |
---|
334 | |
---|
335 | |
---|
336 | int |
---|
337 | Vrip_TessTimeCmd(ClientData, Tcl_Interp *interp, int argc, const char *argv[]) |
---|
338 | { |
---|
339 | char time[PATH_MAX]; |
---|
340 | |
---|
341 | sprintf(time, "%f", TesselationTime); |
---|
342 | Tcl_SetResult(interp, time, TCL_VOLATILE); |
---|
343 | |
---|
344 | return TCL_OK; |
---|
345 | } |
---|
346 | |
---|
347 | |
---|
348 | int |
---|
349 | Vrip_ResampleRangeTimeCmd(ClientData, Tcl_Interp *interp, |
---|
350 | int argc, const char *argv[]) |
---|
351 | { |
---|
352 | char time[PATH_MAX]; |
---|
353 | |
---|
354 | sprintf(time, "%f", ResampleRangeTime); |
---|
355 | Tcl_SetResult(interp, time, TCL_VOLATILE); |
---|
356 | |
---|
357 | return TCL_OK; |
---|
358 | } |
---|
359 | |
---|
360 | |
---|
361 | int |
---|
362 | Vrip_CopyrightCmd(ClientData, Tcl_Interp *interp, int argc, const char *argv[]) |
---|
363 | { |
---|
364 | printf("\n"); |
---|
365 | printf("Copyright (2001)\n"); |
---|
366 | printf("\n"); |
---|
367 | printf("The Board of Regents of the University of Washington (UW)\n"); |
---|
368 | printf("The Board of Trustees of the Leland Stanford Junior University (Stanford)\n"); |
---|
369 | printf("\n"); |
---|
370 | printf("Except for commercial resale, lease, license or other\n"); |
---|
371 | printf("commercial transactions, permission is hereby given to use, copy,\n"); |
---|
372 | printf("modify this software for academic purposes only. No part of this\n"); |
---|
373 | printf("software or any derivatives thereof may be used in the production of\n"); |
---|
374 | printf("computer models for resale or for use in a commercial product.\n"); |
---|
375 | printf("UW AND STANFORD MAKE NO REPRESENTATIONS OR WARRANTIES OF ANY\n"); |
---|
376 | printf("KIND CONCERNING THIS SOFTWARE. No support is implied or provided.\n"); |
---|
377 | printf("\n"); |
---|
378 | |
---|
379 | return TCL_OK; |
---|
380 | } |
---|
381 | |
---|
382 | |
---|
383 | int |
---|
384 | PcreateCmd(ClientData, Tcl_Interp *interp, int argc, const char *argv[]) |
---|
385 | { |
---|
386 | // This used to mean something under IRIX... |
---|
387 | |
---|
388 | /* char newArgv[100][PATH_MAX]; |
---|
389 | char path[PATH_MAX]; |
---|
390 | int result; |
---|
391 | |
---|
392 | if (argc == 1) { |
---|
393 | interp->result = "wrong # of args"; |
---|
394 | return TCL_ERROR; |
---|
395 | } |
---|
396 | |
---|
397 | strcpy(path,argv[1]); |
---|
398 | for (int i = 1; i < argc; i++) { |
---|
399 | strcpy(newArgv[i-1],argv[i]); |
---|
400 | } |
---|
401 | newArgv[argc-1] = NULL; |
---|
402 | |
---|
403 | #ifndef LINUX |
---|
404 | result = pcreatevp(path, newArgv); |
---|
405 | |
---|
406 | wait(NULL); |
---|
407 | #endif |
---|
408 | */ |
---|
409 | |
---|
410 | return TCL_OK; |
---|
411 | } |
---|
412 | |
---|
413 | int |
---|
414 | Vrip_CalibrateRotationCmd(ClientData, Tcl_Interp *interp, |
---|
415 | int argc, const char *argv[]) |
---|
416 | { |
---|
417 | FILE *fp = fopen(argv[1], "r"); |
---|
418 | |
---|
419 | int i, count = 0; |
---|
420 | float t0, t1, t2, q0, q1, q2, q3, norm; |
---|
421 | float inAngles[1000], angles[1000], angle; |
---|
422 | Quaternion quats[1000]; |
---|
423 | Vec3f trans[1000], axes[1000], center[1000], axis; |
---|
424 | while (fscanf(fp, "%f %f %f %f %f %f %f %f", |
---|
425 | &angle, &t0, &t1, &t2, &q0, &q1, &q2, &q3) > 0) { |
---|
426 | inAngles[count] = angle; |
---|
427 | quats[count].setValue(q0, q1, q2, q3); |
---|
428 | quats[count].normalize(); |
---|
429 | trans[count].setValue(t0,t1,t2); |
---|
430 | count++; |
---|
431 | } |
---|
432 | |
---|
433 | fclose(fp); |
---|
434 | |
---|
435 | Matrix4f mbase, mbaseinv, mrot, newMat, mat; |
---|
436 | Quaternion quat, quatAccum; |
---|
437 | Vec3f transAccum; |
---|
438 | |
---|
439 | printf("\nXforms relative to origin:\n\n"); |
---|
440 | |
---|
441 | mbase.makeIdentity(); |
---|
442 | quats[0].toMatrix(mbase); |
---|
443 | mbase.setTranslate(trans[0]); |
---|
444 | mbaseinv = mbase.inverse(); |
---|
445 | |
---|
446 | for (i = 1; i < count; i++) { |
---|
447 | mat.makeIdentity(); |
---|
448 | quats[i].toMatrix(mat); |
---|
449 | mat.setTranslate(trans[i]); |
---|
450 | mat.multLeft(mbaseinv); |
---|
451 | quat.fromMatrix(mat); |
---|
452 | quat.toAxisAngle(angles[i], axes[i]); |
---|
453 | |
---|
454 | if (axes[i][1] > 0) { |
---|
455 | angles[i] = 360 - angles[i]; |
---|
456 | axes[i].negate(); |
---|
457 | } |
---|
458 | printf("Angle = %f, Axis = (%f, %f, %f)\n", angles[i], |
---|
459 | axes[i][0], axes[i][1], axes[i][2]); |
---|
460 | |
---|
461 | newMat.setValue(mat); |
---|
462 | newMat.setElem(0,0,1-newMat.elem(0,0)); |
---|
463 | newMat.setElem(1,1,1-newMat.elem(1,1)); |
---|
464 | newMat.setElem(2,2,1-newMat.elem(2,2)); |
---|
465 | newMat.inverse(); |
---|
466 | |
---|
467 | printf("Center = (%g, %g, %g)\n", |
---|
468 | -newMat.elem(0,3), -newMat.elem(1,3), -newMat.elem(2,3)); |
---|
469 | } |
---|
470 | |
---|
471 | printf("\nXforms relative to previous scan:\n\n"); |
---|
472 | |
---|
473 | quatAccum.setValue(0,0,0,0); |
---|
474 | transAccum.setValue(0,0,0); |
---|
475 | |
---|
476 | for (i = 1; i < count; i++) { |
---|
477 | mbase.makeIdentity(); |
---|
478 | quats[i-1].toMatrix(mbase); |
---|
479 | mbase.setTranslate(trans[i-1]); |
---|
480 | mbaseinv = mbase.inverse(); |
---|
481 | |
---|
482 | mat.makeIdentity(); |
---|
483 | quats[i].toMatrix(mat); |
---|
484 | mat.setTranslate(trans[i]); |
---|
485 | mat.multLeft(mbaseinv); |
---|
486 | quat.fromMatrix(mat); |
---|
487 | |
---|
488 | quat.normalize(); |
---|
489 | |
---|
490 | quatAccum.q[0] += quat.q[0]; |
---|
491 | quatAccum.q[1] += quat.q[1]; |
---|
492 | quatAccum.q[2] += quat.q[2]; |
---|
493 | quatAccum.q[3] += quat.q[3]; |
---|
494 | |
---|
495 | quat.toAxisAngle(angles[i], axes[i]); |
---|
496 | |
---|
497 | if (axes[i][1] > 0) { |
---|
498 | angles[i] = 360 - angles[i]; |
---|
499 | axes[i].negate(); |
---|
500 | } |
---|
501 | printf("Angle = %f, Axis = (%f, %f, %f)\n", angles[i], |
---|
502 | axes[i][0], axes[i][1], axes[i][2]); |
---|
503 | |
---|
504 | newMat.setValue(mat); |
---|
505 | newMat.setElem(0,0,1-newMat.elem(0,3)); |
---|
506 | newMat.setElem(1,1,1-newMat.elem(1,3)); |
---|
507 | newMat.setElem(2,2,1-newMat.elem(2,3)); |
---|
508 | newMat.inverse(); |
---|
509 | |
---|
510 | Vec3f center(newMat.elem(0,3), newMat.elem(1,3), newMat.elem(2,3)); |
---|
511 | center.negate(); |
---|
512 | |
---|
513 | transAccum += center; |
---|
514 | |
---|
515 | printf("Center = (%g, %g, %g)\n", center[0], center[1], center[2]); |
---|
516 | } |
---|
517 | |
---|
518 | transAccum /= -(count-1); |
---|
519 | |
---|
520 | quatAccum.q[0] /= (count-1); |
---|
521 | quatAccum.q[1] /= (count-1); |
---|
522 | quatAccum.q[2] /= (count-1); |
---|
523 | quatAccum.q[3] /= (count-1); |
---|
524 | quatAccum.normalize(); |
---|
525 | |
---|
526 | quatAccum.toAxisAngle(angle, axis); |
---|
527 | |
---|
528 | printf("\nRotation axis and translation based on pairwise:\n\n"); |
---|
529 | printf("Angle = %f, Axis = (%f, %f, %f)\n", angle, |
---|
530 | axis[0], axis[1], axis[2]); |
---|
531 | printf("Center = (%g, %g, %g)\n", |
---|
532 | transAccum[0], transAccum[1], transAccum[2]); |
---|
533 | |
---|
534 | return TCL_OK; |
---|
535 | |
---|
536 | } |
---|
537 | |
---|
538 | int |
---|
539 | Vrip_TestVAScannerCmd(ClientData, Tcl_Interp *interp, |
---|
540 | int argc, const char *argv[]) |
---|
541 | { |
---|
542 | int i; |
---|
543 | int numPairs; |
---|
544 | int doHorizontal; |
---|
545 | float triangAngle; |
---|
546 | float tiltAngle; |
---|
547 | FILE *fp; |
---|
548 | char filename[PATH_MAX]; |
---|
549 | Matrix4f mview1, mview1inv, mview2, mview2inv; |
---|
550 | |
---|
551 | numPairs = atoi(argv[1]); |
---|
552 | triangAngle = atof(argv[2])*M_PI/180; |
---|
553 | tiltAngle = atof(argv[3])*M_PI/180; |
---|
554 | doHorizontal = !strcmp(argv[4],"horiz"); |
---|
555 | |
---|
556 | // compute viewing transformations |
---|
557 | for (i = 0; i < numPairs; i++) { |
---|
558 | float pairAngle = 360/numPairs * i * M_PI/180; |
---|
559 | |
---|
560 | if (doHorizontal) { |
---|
561 | mview1.makeIdentity(); |
---|
562 | mview1.setRotateY(pairAngle); |
---|
563 | mview1.rotateX(-tiltAngle); |
---|
564 | |
---|
565 | sprintf(filename, "view%d-A.xf", i); |
---|
566 | fp = fopen(filename, "w"); |
---|
567 | mview1.write(fp); |
---|
568 | fclose(fp); |
---|
569 | |
---|
570 | mview2.makeIdentity(); |
---|
571 | mview2.setRotateY(pairAngle+triangAngle); |
---|
572 | mview2.rotateX(-tiltAngle); |
---|
573 | |
---|
574 | mview1inv = mview1.inverse(); |
---|
575 | mview1inv.multLeft(mview2); |
---|
576 | |
---|
577 | sprintf(filename, "view%d-A-to-B.xf", i); |
---|
578 | fp = fopen(filename, "w"); |
---|
579 | mview1inv.write(fp); |
---|
580 | fclose(fp); |
---|
581 | |
---|
582 | mview2inv = mview2.inverse(); |
---|
583 | |
---|
584 | sprintf(filename, "align%d-B.xf", i); |
---|
585 | fp = fopen(filename, "w"); |
---|
586 | mview2inv.write(fp); |
---|
587 | fclose(fp); |
---|
588 | } else { |
---|
589 | mview1.makeIdentity(); |
---|
590 | mview1.setRotateY(pairAngle); |
---|
591 | mview1.rotateX(-tiltAngle-triangAngle/2); |
---|
592 | |
---|
593 | sprintf(filename, "view%d-A.xf", i); |
---|
594 | fp = fopen(filename, "w"); |
---|
595 | mview1.write(fp); |
---|
596 | fclose(fp); |
---|
597 | |
---|
598 | mview2.makeIdentity(); |
---|
599 | mview2.setRotateY(pairAngle); |
---|
600 | mview2.rotateX(-tiltAngle+triangAngle/2); |
---|
601 | |
---|
602 | mview1inv = mview1.inverse(); |
---|
603 | mview1inv.multLeft(mview2); |
---|
604 | |
---|
605 | sprintf(filename, "view%d-A-to-B.xf", i); |
---|
606 | fp = fopen(filename, "w"); |
---|
607 | mview1inv.write(fp); |
---|
608 | fclose(fp); |
---|
609 | |
---|
610 | mview2inv = mview2.inverse(); |
---|
611 | |
---|
612 | sprintf(filename, "align%d-B.xf", i); |
---|
613 | fp = fopen(filename, "w"); |
---|
614 | mview2inv.write(fp); |
---|
615 | fclose(fp); |
---|
616 | } |
---|
617 | } |
---|
618 | |
---|
619 | return TCL_OK; |
---|
620 | } |
---|