root/OpenSceneGraph/trunk/examples/osgunittests/osgunittests.cpp @ 13295

Revision 11186, 24.8 kB (checked in by robert, 5 years ago)

Added tests of various FileNameUtils? functions, tests invoked by osgunittests filenames

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* OpenSceneGraph example, osgunittests.
2*
3*  Permission is hereby granted, free of charge, to any person obtaining a copy
4*  of this software and associated documentation files (the "Software"), to deal
5*  in the Software without restriction, including without limitation the rights
6*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7*  copies of the Software, and to permit persons to whom the Software is
8*  furnished to do so, subject to the following conditions:
9*
10*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
11*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
13*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
14*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
15*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
16*  THE SOFTWARE.
17*/
18
19#include <osg/ArgumentParser>
20#include <osg/ApplicationUsage>
21
22#include <osg/Vec3>
23#include <osg/Matrix>
24#include <osg/Polytope>
25#include <osg/Timer>
26#include <osg/io_utils>
27
28#include <OpenThreads/Thread>
29
30#include "UnitTestFramework.h"
31#include "performance.h"
32#include "MultiThreadRead.h"
33
34#include <iostream>
35
36extern void runFileNameUtilsTest(osg::ArgumentParser& arguments);
37
38void testFrustum(double left,double right,double bottom,double top,double zNear,double zFar)
39{
40    osg::Matrix f;
41    f.makeFrustum(left,right,bottom,top,zNear,zFar);
42
43    double c_left=0;
44    double c_right=0;
45    double c_top=0;
46    double c_bottom=0;
47    double c_zNear=0;
48    double c_zFar=0;
49   
50   
51    std::cout << "testFrustum"<<f.getFrustum(c_left,c_right,c_bottom,c_top,c_zNear,c_zFar)<<std::endl;
52    std::cout << "  left = "<<left<<" compute "<<c_left<<std::endl;
53    std::cout << "  right = "<<right<<" compute "<<c_right<<std::endl;
54
55    std::cout << "  bottom = "<<bottom<<" compute "<<c_bottom<<std::endl;
56    std::cout << "  top = "<<top<<" compute "<<c_top<<std::endl;
57
58    std::cout << "  zNear = "<<zNear<<" compute "<<c_zNear<<std::endl;
59    std::cout << "  zFar = "<<zFar<<" compute "<<c_zFar<<std::endl;
60   
61    std::cout << std::endl;
62}
63
64void testOrtho(double left,double right,double bottom,double top,double zNear,double zFar)
65{
66    osg::Matrix f;
67    f.makeOrtho(left,right,bottom,top,zNear,zFar);
68
69    double c_left=0;
70    double c_right=0;
71    double c_top=0;
72    double c_bottom=0;
73    double c_zNear=0;
74    double c_zFar=0;
75
76    std::cout << "testOrtho "<< f.getOrtho(c_left,c_right,c_bottom,c_top,c_zNear,c_zFar) << std::endl;
77    std::cout << "  left = "<<left<<" compute "<<c_left<<std::endl;
78    std::cout << "  right = "<<right<<" compute "<<c_right<<std::endl;
79
80    std::cout << "  bottom = "<<bottom<<" compute "<<c_bottom<<std::endl;
81    std::cout << "  top = "<<top<<" compute "<<c_top<<std::endl;
82
83    std::cout << "  zNear = "<<zNear<<" compute "<<c_zNear<<std::endl;
84    std::cout << "  zFar = "<<zFar<<" compute "<<c_zFar<<std::endl;
85   
86    std::cout << std::endl;
87}
88
89void testPerspective(double fovy,double aspect,double zNear,double zFar)
90{
91    osg::Matrix f;
92    f.makePerspective(fovy,aspect,zNear,zFar);
93
94    double c_fovy=0;
95    double c_aspect=0;
96    double c_zNear=0;
97    double c_zFar=0;
98
99    std::cout << "testPerspective "<< f.getPerspective(c_fovy,c_aspect,c_zNear,c_zFar) << std::endl;
100    std::cout << "  fovy = "<<fovy<<" compute "<<c_fovy<<std::endl;
101    std::cout << "  aspect = "<<aspect<<" compute "<<c_aspect<<std::endl;
102
103    std::cout << "  zNear = "<<zNear<<" compute "<<c_zNear<<std::endl;
104    std::cout << "  zFar = "<<zFar<<" compute "<<c_zFar<<std::endl;
105   
106    std::cout << std::endl;
107}
108
109void testLookAt(const osg::Vec3& eye,const osg::Vec3& center,const osg::Vec3& up)
110{
111    osg::Matrix mv;
112    mv.makeLookAt(eye,center,up);
113   
114    osg::Vec3 c_eye,c_center,c_up;
115    mv.getLookAt(c_eye,c_center,c_up);
116   
117    std::cout << "testLookAt"<<std::endl;
118    std::cout << "  eye "<<eye<< " compute "<<c_eye<<std::endl;
119    std::cout << "  center "<<center<< " compute "<<c_center<<std::endl;
120    std::cout << "  up "<<up<< " compute "<<c_up<<std::endl;
121   
122    std::cout << std::endl;
123   
124}
125
126
127void testMatrixInvert(const osg::Matrix& matrix)
128{
129    //Invert it twice using the two inversion functions and view the results
130    osg::notify(osg::NOTICE)<<"testMatrixInvert("<<std::endl;
131    osg::notify(osg::NOTICE)<<matrix<<std::endl;
132    osg::notify(osg::NOTICE)<<")"<<std::endl;
133
134    osg::Matrix invM1_0;
135    invM1_0.invert(matrix);
136    osg::notify(osg::NOTICE)<<"Matrix::invert"<<std::endl;
137    osg::notify(osg::NOTICE)<<invM1_0<<std::endl;
138    osg::Matrix default_result = matrix*invM1_0;
139    osg::notify(osg::NOTICE)<<"matrix * invert="<<std::endl;
140    osg::notify(osg::NOTICE)<<default_result<<std::endl;;
141
142}
143
144void sizeOfTest()
145{
146  std::cout<<"sizeof(bool)=="<<sizeof(bool)<<std::endl;
147  std::cout<<"sizeof(char)=="<<sizeof(char)<<std::endl;
148  std::cout<<"sizeof(short)=="<<sizeof(short)<<std::endl;
149  std::cout<<"sizeof(short int)=="<<sizeof(short int)<<std::endl;
150  std::cout<<"sizeof(int)=="<<sizeof(int)<<std::endl;
151  std::cout<<"sizeof(long)=="<<sizeof(long)<<std::endl;
152  std::cout<<"sizeof(long int)=="<<sizeof(long int)<<std::endl;
153
154#if defined(_MSC_VER)
155  // long long isn't supported on VS6.0...
156  std::cout<<"sizeof(__int64)=="<<sizeof(__int64)<<std::endl;
157#else
158  std::cout<<"sizeof(long long)=="<<sizeof(long long)<<std::endl;
159#endif
160  std::cout<<"sizeof(float)=="<<sizeof(float)<<std::endl;
161  std::cout<<"sizeof(double)=="<<sizeof(double)<<std::endl;
162
163  std::cout<<"sizeof(std::istream::pos_type)=="<<sizeof(std::istream::pos_type)<<std::endl;
164  std::cout<<"sizeof(std::istream::off_type)=="<<sizeof(std::istream::off_type)<<std::endl;
165  std::cout<<"sizeof(OpenThreads::Mutex)=="<<sizeof(OpenThreads::Mutex)<<std::endl;
166
167  std::cout<<"sizeof(std::string)=="<<sizeof(std::string)<<std::endl;
168
169}
170
171/// Exercise the Matrix.getRotate function.
172/// Compare the output of:
173///  q1 * q2
174/// versus
175///  (mat(q1)*mat(q2)*scale).getRotate()
176/// for a range of rotations
177void testGetQuatFromMatrix(const osg::Vec3d& scale)
178{
179   
180    // Options
181   
182    // acceptable error range
183    double eps=1e-6;
184
185    // scale matrix
186    // To not test with scale, use 1,1,1
187    // Not sure if 0's or negative values are acceptable
188    osg::Matrixd scalemat;
189    scalemat.makeScale(scale);
190   
191    // range of rotations
192#if 1
193    // wide range
194    double rol1start = 0.0;
195    double rol1stop = 360.0;
196    double rol1step = 20.0;
197
198    double pit1start = 0.0;
199    double pit1stop = 90.0;
200    double pit1step = 20.0;
201
202    double yaw1start = 0.0;
203    double yaw1stop = 360.0;
204    double yaw1step = 20.0;
205
206    double rol2start = 0.0;
207    double rol2stop = 360.0;
208    double rol2step = 20.0;
209
210    double pit2start = 0.0;
211    double pit2stop = 90.0;
212    double pit2step = 20.0;
213
214    double yaw2start = 0.0;
215    double yaw2stop = 360.0;
216    double yaw2step = 20.0;
217#else
218    // focussed range
219    double rol1start = 0.0;
220    double rol1stop = 0.0;
221    double rol1step = 0.1;
222
223    double pit1start = 0.0;
224    double pit1stop = 5.0;
225    double pit1step = 5.0;
226
227    double yaw1start = 89.0;
228    double yaw1stop = 91.0;
229    double yaw1step = 0.1;
230
231    double rol2start = 0.0;
232    double rol2stop = 0.0;
233    double rol2step = 0.1;
234
235    double pit2start = 0.0;
236    double pit2stop = 0.0;
237    double pit2step = 0.1;
238
239    double yaw2start = 89.0;
240    double yaw2stop = 91.0;
241    double yaw2step = 0.1;
242#endif
243
244    std::cout << std::endl << "Starting testGetQuatFromMatrix, it can take a while ..." << std::endl;
245
246    osg::Timer_t tstart, tstop;
247    tstart = osg::Timer::instance()->tick();
248    int count=0;
249    for (double rol1 = rol1start; rol1 <= rol1stop; rol1 += rol1step) {
250        for (double pit1 = pit1start; pit1 <= pit1stop; pit1 += pit1step) {
251            for (double yaw1 = yaw1start; yaw1 <= yaw1stop; yaw1 += yaw1step) {
252                for (double rol2 = rol2start; rol2 <= rol2stop; rol2 += rol2step) {
253                    for (double pit2 = pit2start; pit2 <= pit2stop; pit2 += pit2step) {
254                        for (double yaw2 = yaw2start; yaw2 <= yaw2stop; yaw2 += yaw2step)
255                        {
256                            count++;
257                            // create two quats based on the roll, pitch and yaw values
258                            osg::Quat rot_quat1 =
259                            osg::Quat(osg::DegreesToRadians(rol1),osg::Vec3d(1,0,0),
260                                  osg::DegreesToRadians(pit1),osg::Vec3d(0,1,0),
261                                  osg::DegreesToRadians(yaw1),osg::Vec3d(0,0,1));
262
263                            osg::Quat rot_quat2 =
264                            osg::Quat(osg::DegreesToRadians(rol2),osg::Vec3d(1,0,0),
265                                  osg::DegreesToRadians(pit2),osg::Vec3d(0,1,0),
266                                  osg::DegreesToRadians(yaw2),osg::Vec3d(0,0,1));
267
268                            // create an output quat using quaternion math
269                            osg::Quat out_quat1;
270                            out_quat1 = rot_quat2 * rot_quat1;
271
272                            // create two matrices based on the input quats
273                            osg::Matrixd mat1,mat2;
274                            mat1.makeRotate(rot_quat1);
275                            mat2.makeRotate(rot_quat2);
276
277                            // create an output quat by matrix multiplication and getRotate
278                            osg::Matrixd out_mat;
279                            out_mat = mat2 * mat1;
280                            // add matrix scale for even more nastiness
281                            out_mat = out_mat * scalemat;
282                            osg::Quat out_quat2;
283                            out_quat2 = out_mat.getRotate();
284
285                            // If the quaternion W is <0, then we should reflect
286                            // to get it into the positive W.
287                            // Unfortunately, when W is very small (close to 0), the sign
288                            // does not really make sense because of precision problems
289                            // and the reflection might not work.
290                            if(out_quat1.w()<0) out_quat1 = out_quat1 * -1.0;
291                            if(out_quat2.w()<0) out_quat2 = out_quat2 * -1.0;
292
293                            // if the output quat length is not one
294                            // or if the components do not match,
295                            // something is amiss
296
297                            bool componentsOK = false;
298                            if ( ((fabs(out_quat1.x()-out_quat2.x())) < eps) &&
299                                 ((fabs(out_quat1.y()-out_quat2.y())) < eps) &&
300                                 ((fabs(out_quat1.z()-out_quat2.z())) < eps) &&
301                                 ((fabs(out_quat1.w()-out_quat2.w())) < eps) )
302                                    {
303                                componentsOK = true;
304                            }
305                            // We should also test for q = -q which is valid, so reflect
306                            // one quat.
307                            out_quat2 = out_quat2 * -1.0;
308                            if ( ((fabs(out_quat1.x()-out_quat2.x())) < eps) &&
309                                 ((fabs(out_quat1.y()-out_quat2.y())) < eps) &&
310                                 ((fabs(out_quat1.z()-out_quat2.z())) < eps) &&
311                                 ((fabs(out_quat1.w()-out_quat2.w())) < eps) )
312                            {
313                                componentsOK = true;
314                            }
315
316                            bool lengthOK = false;
317                            if (fabs(1.0-out_quat2.length()) < eps)
318                            {
319                                lengthOK = true;
320                            }
321
322                            if (!lengthOK || !componentsOK)
323                            {
324                                std::cout << "testGetQuatFromMatrix problem at: \n"
325                                      << " r1=" << rol1
326                                      << " p1=" << pit1
327                                      << " y1=" << yaw1
328                                      << " r2=" << rol2
329                                      << " p2=" << pit2
330                                      << " y2=" << yaw2 << "\n";
331                                std::cout << "quats:        " << out_quat1 << " length: " << out_quat1.length() << "\n";
332                                std::cout << "mats and get: " << out_quat2 << " length: " << out_quat2.length() << "\n\n";
333                            }
334                        }
335                    }
336                }
337            }
338        }
339    }
340    tstop = osg::Timer::instance()->tick();
341    double duration = osg::Timer::instance()->delta_s(tstart,tstop);
342    std::cout << "Time for testGetQuatFromMatrix with " << count << " iterations: " << duration << std::endl << std::endl;
343}
344
345void testQuatRotate(const osg::Vec3d& from, const osg::Vec3d& to)
346{
347    osg::Quat q_nicolas;
348    q_nicolas.makeRotate(from,to);
349   
350    osg::Quat q_original;
351    q_original.makeRotate_original(from,to);
352   
353    std::cout<<"osg::Quat::makeRotate("<<from<<", "<<to<<")"<<std::endl;
354    std::cout<<"  q_nicolas = "<<q_nicolas<<std::endl;
355    std::cout<<"  q_original = "<<q_original<<std::endl;
356    std::cout<<"  from * M4x4(q_nicolas) = "<<from * osg::Matrixd::rotate(q_nicolas)<<std::endl;
357    std::cout<<"  from * M4x4(q_original) = "<<from * osg::Matrixd::rotate(q_original)<<std::endl;
358}
359
360void testQuat(const osg::Vec3d& quat_scale)
361{
362    osg::Quat q1;
363    q1.makeRotate(osg::DegreesToRadians(30.0),0.0f,0.0f,1.0f);
364
365    osg::Quat q2;
366    q2.makeRotate(osg::DegreesToRadians(133.0),0.0f,1.0f,1.0f);
367
368    osg::Quat q1_2 = q1*q2;
369    osg::Quat q2_1 = q2*q1;
370
371    osg::Matrix m1 = osg::Matrix::rotate(q1);
372    osg::Matrix m2 = osg::Matrix::rotate(q2);
373   
374    osg::Matrix m1_2 = m1*m2;
375    osg::Matrix m2_1 = m2*m1;
376   
377    osg::Quat qm1_2;
378    qm1_2.set(m1_2);
379   
380    osg::Quat qm2_1;
381    qm2_1.set(m2_1);
382   
383    std::cout<<"q1*q2 = "<<q1_2<<std::endl;
384    std::cout<<"q2*q1 = "<<q2_1<<std::endl;
385    std::cout<<"m1*m2 = "<<qm1_2<<std::endl;
386    std::cout<<"m2*m1 = "<<qm2_1<<std::endl;
387
388
389    testQuatRotate(osg::Vec3d(1.0,0.0,0.0),osg::Vec3d(0.0,1.0,0.0));
390    testQuatRotate(osg::Vec3d(0.0,1.0,0.0),osg::Vec3d(1.0,0.0,0.0));
391    testQuatRotate(osg::Vec3d(0.0,0.0,1.0),osg::Vec3d(0.0,1.0,0.0));
392    testQuatRotate(osg::Vec3d(1.0,1.0,1.0),osg::Vec3d(1.0,0.0,0.0));
393    testQuatRotate(osg::Vec3d(1.0,0.0,0.0),osg::Vec3d(1.0,0.0,0.0));
394    testQuatRotate(osg::Vec3d(1.0,0.0,0.0),osg::Vec3d(-1.0,0.0,0.0));
395    testQuatRotate(osg::Vec3d(-1.0,0.0,0.0),osg::Vec3d(1.0,0.0,0.0));
396    testQuatRotate(osg::Vec3d(0.0,1.0,0.0),osg::Vec3d(0.0,-1.0,0.0));
397    testQuatRotate(osg::Vec3d(0.0,-1.0,0.0),osg::Vec3d(0.0,1.0,0.0));
398    testQuatRotate(osg::Vec3d(0.0,0.0,1.0),osg::Vec3d(0.0,0.0,-1.0));
399    testQuatRotate(osg::Vec3d(0.0,0.0,-1.0),osg::Vec3d(0.0,0.0,1.0));
400
401    // Test a range of rotations
402    testGetQuatFromMatrix(quat_scale);
403
404    // This is a specific test case for a matrix containing scale and rotation
405    osg::Matrix matrix(0.5, 0.0, 0.0, 0.0,
406                       0.0, 0.5, 0.0, 0.0,
407                       0.0, 0.0, 0.5, 0.0,
408                       1.0, 1.0, 1.0, 1.0);
409                       
410    osg::Quat quat;
411    matrix.get(quat);
412   
413    osg::notify(osg::NOTICE)<<"Matrix = "<<matrix<<"rotation = "<<quat<<", expected quat = (0,0,0,1)"<<std::endl;
414}
415
416void testDecompose()
417{
418    double angx = osg::DegreesToRadians(30.0);
419    double angy = osg::DegreesToRadians(30.0);
420    double angz = osg::DegreesToRadians(30.0);
421
422    osg::Quat qx, qy, qz;
423    qx.makeRotate(angx, osg::Vec3f (1.0f, 0.0f, 0.0f));
424    qy.makeRotate(angy, osg::Vec3f (0.0f, 1.0f, 0.0f));
425    qz.makeRotate(angz, osg::Vec3f (0.0f, 0.0f, 1.0f));
426
427    osg::Quat rotation = qx * qy * qz;
428
429    osg::Matrixf matf;
430    matf.makeRotate(rotation);
431
432    printf ("Test - Matrix::decompos(), input rotation  : %f %f %f %f\n", rotation._v[0], rotation._v[1], rotation._v[2], rotation._v[3]);
433
434    osg::Vec3f transf;
435    osg::Quat  rotf;
436    osg::Vec3f sclf;
437    osg::Quat  sof;
438    matf.decompose (transf, rotf, sclf, sof);
439    printf ("Matrixf::decomposef\n");
440    printf ("Translation      : %f %f %f\n", transf.x(), transf.y(), transf.z());
441    printf ("Rotation         : %f %f %f %f\n", rotf._v[0], rotf._v[1], rotf._v[2], rotf._v[3]);
442    printf ("Scale            : %f %f %f\n", sclf.x(), sclf.y(), sclf.z());
443    printf ("Scale Orientation: %f %f %f %f\n", sof._v[0], sof._v[1], sof._v[2], sof._v[3]);
444
445    osg::Matrixd matd;
446    matd.makeRotate(rotation);
447
448    osg::Vec3f transd;
449    osg::Quat  rotd;
450    osg::Vec3f scld;
451    osg::Quat  sod;
452    matd.decompose (transd, rotd, scld, sod);
453    printf ("Matrixd::decompose\n");
454    printf ("Translation      : %f %f %f\n", transd.x(), transd.y(), transd.z());
455    printf ("Rotation         : %f %f %f %f\n", rotd._v[0], rotd._v[1], rotd._v[2], rotd._v[3]);
456    printf ("Scale            : %f %f %f\n", scld.x(), scld.y(), scld.z());
457    printf ("Scale Orientation: %f %f %f %f\n", sod._v[0], sod._v[1], sod._v[2], sod._v[3]);
458
459    osg::notify(osg::NOTICE)<<std::endl;
460}
461
462class MyThread : public OpenThreads::Thread {
463public:
464    void run(void) { }
465};
466
467class NotifyThread : public OpenThreads::Thread {
468public:
469
470    NotifyThread(osg::NotifySeverity level, const std::string& message):
471    _done(false),
472    _level(level),
473    _message(message) {}
474
475    ~NotifyThread()
476    {
477        _done = true;
478        while(isRunning())
479        {
480            OpenThreads::Thread::YieldCurrentThread();
481        }
482    }
483
484    void run(void)
485    {
486        std::cout << "Entering thread ..." <<_message<< std::endl;
487
488        unsigned int count=0;
489
490        while(!_done)
491        {
492            ++count;
493#if 1
494            osg::notify(_level)<<_message<<this<<"\n";
495#else
496            osg::notify(_level)<<_message<<this<<std::endl;
497#endif
498        }
499
500        std::cout << "Leaving thread ..." <<_message<< " count="<<count<<std::endl;
501    }
502
503    bool                  _done;
504    osg::NotifySeverity   _level;
505    std::string           _message;
506 
507};
508
509void testThreadInitAndExit()
510{
511    std::cout<<"******   Running thread start and delete test   ****** "<<std::endl;
512
513    {
514        MyThread thread;
515        thread.startThread();
516    }
517   
518    // add a sleep to allow the thread start to fall over it its going to.
519    OpenThreads::Thread::microSleep(500000);
520   
521    std::cout<<"pass    thread start and delete test"<<std::endl<<std::endl;
522
523
524    std::cout<<"******   Running notify thread test   ****** "<<std::endl;
525
526    {
527        NotifyThread thread1(osg::INFO,"thread one:");
528        NotifyThread thread2(osg::INFO,"thread two:");
529        NotifyThread thread3(osg::INFO,"thread three:");
530        NotifyThread thread4(osg::INFO,"thread four:");
531        thread1.startThread();
532        thread2.startThread();
533        thread3.startThread();
534        thread4.startThread();
535
536        // add a sleep to allow the thread start to fall over it its going to.
537        OpenThreads::Thread::microSleep(5000000);
538    }
539
540    std::cout<<"pass    noitfy thread test."<<std::endl<<std::endl;
541}
542
543void testPolytope()
544{
545    osg::Polytope pt;
546    pt.setToBoundingBox(osg::BoundingBox(-1000, -1000, -1000, 1000, 1000, 1000));
547    bool bContains = pt.contains(osg::Vec3(0, 0, 0));
548    if (bContains)
549    {
550        std::cout<<"Polytope pt.contains(osg::Vec3(0, 0, 0)) has succeeded."<<std::endl;
551    }
552    else
553    {
554        std::cout<<"Polytope pt.contains(osg::Vec3(0, 0, 0)) has failed."<<std::endl;
555    }
556
557}
558
559
560int main( int argc, char** argv )
561{
562    osg::ArgumentParser arguments(&argc,argv);
563
564    // set up the usage document, in case we need to print out how to use this program.
565    arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the example which runs units tests.");
566    arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options]");
567    arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display this information");
568    arguments.getApplicationUsage()->addCommandLineOption("qt","Display qualified tests.");
569    arguments.getApplicationUsage()->addCommandLineOption("quat","Display extended quaternion tests.");
570    arguments.getApplicationUsage()->addCommandLineOption("quat_scaled sx sy sz","Display extended quaternion tests of pre scaled matrix.");
571    arguments.getApplicationUsage()->addCommandLineOption("sizeof","Display sizeof tests.");
572    arguments.getApplicationUsage()->addCommandLineOption("matrix","Display qualified tests.");
573    arguments.getApplicationUsage()->addCommandLineOption("performance","Display qualified tests.");
574    arguments.getApplicationUsage()->addCommandLineOption("read-threads <numthreads>","Run multi-thread reading test.");
575 
576
577    if (arguments.argc()<=1)
578    {
579        arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
580        return 1;
581    }
582
583    bool printQualifiedTest = false;
584    while (arguments.read("qt")) printQualifiedTest = true;
585
586    bool printMatrixTest = false;
587    while (arguments.read("matrix")) printMatrixTest = true;
588
589    bool printSizeOfTest = false;
590    while (arguments.read("sizeof")) printSizeOfTest = true;
591
592    bool printFileNameUtilsTests = false;
593    while (arguments.read("filenames")) printFileNameUtilsTests = true;
594
595    bool printQuatTest = false;
596    while (arguments.read("quat")) printQuatTest = true;
597
598    int numReadThreads = 0;
599    while (arguments.read("read-threads", numReadThreads)) {}
600
601    bool printPolytopeTest = false;
602    while (arguments.read("polytope")) printPolytopeTest = true;
603   
604    bool doTestThreadInitAndExit = false;
605    while (arguments.read("thread")) doTestThreadInitAndExit = true;
606
607    osg::Vec3d quat_scale(1.0,1.0,1.0);
608    while (arguments.read("quat_scaled", quat_scale.x(), quat_scale.y(), quat_scale.z() )) printQuatTest = true;
609
610    bool performanceTest = false;
611    while (arguments.read("p") || arguments.read("performance")) performanceTest = true;
612
613    // if user request help write it out to cout.
614    if (arguments.read("-h") || arguments.read("--help"))
615    {
616        std::cout<<arguments.getApplicationUsage()->getCommandLineUsage()<<std::endl;
617        arguments.getApplicationUsage()->write(std::cout,arguments.getApplicationUsage()->getCommandLineOptions());
618        return 1;
619    }
620
621    // any option left unread are converted into errors to write out later.
622    arguments.reportRemainingOptionsAsUnrecognized();
623
624    // report any errors if they have occurred when parsing the program arguments.
625    if (arguments.errors())
626    {
627        arguments.writeErrorMessages(std::cout);
628        return 1;
629    }
630   
631    if (printQuatTest)
632    {
633        testQuat(quat_scale);
634    }
635
636    if (printMatrixTest)
637    {
638        std::cout<<"******   Running matrix tests   ******"<<std::endl;
639
640        testFrustum(-1,1,-1,1,1,1000);
641        testFrustum(0,1,1,2,2.5,100000);
642
643        testOrtho(0,1,1,2,2.1,1000);
644        testOrtho(-1,10,1,20,2.5,100000);
645
646        testPerspective(20,1,1,1000);
647        testPerspective(90,2,1,1000);
648
649        testLookAt(osg::Vec3(10.0,4.0,2.0),osg::Vec3(10.0,4.0,2.0)+osg::Vec3(0.0,1.0,0.0),osg::Vec3(0.0,0.0,1.0));
650        testLookAt(osg::Vec3(10.0,4.0,2.0),osg::Vec3(10.0,4.0,2.0)+osg::Vec3(1.0,1.0,0.0),osg::Vec3(0.0,0.0,1.0));
651       
652        testMatrixInvert(osg::Matrix(0.999848,  -0.002700,  0.017242, -0.1715,
653                                     0,         0.987960,   0.154710,  0.207295,
654                                     -0.017452, -0.154687,  0.987809, -0.98239,
655                                     0,         0,          0,         1));
656
657        testMatrixInvert(osg::Matrix(0.999848,  -0.002700,  0.017242,   0.0,
658                                     0.0,        0.987960,   0.154710,   0.0,
659                                     -0.017452, -0.154687,  0.987809,   0.0,
660                                     -0.1715,    0.207295,  -0.98239,   1.0));
661
662        testDecompose();
663
664    }
665   
666    if (printSizeOfTest)
667    {
668        std::cout<<"**** sizeof() tests  ******"<<std::endl;
669       
670        sizeOfTest();
671
672        std::cout<<std::endl;
673    }
674
675
676    if (performanceTest)
677    {
678        std::cout<<"**** performance tests  ******"<<std::endl;
679       
680        runPerformanceTests();
681    }
682
683    if (numReadThreads>0)
684    {
685        runMultiThreadReadTests(numReadThreads, arguments);
686        return 0;
687    }
688
689
690    if (printPolytopeTest)
691    {
692        testPolytope();
693    }
694
695
696    if (printQualifiedTest)
697    {
698         std::cout<<"*****   Qualified Tests  ******"<<std::endl;
699
700         osgUtx::QualifiedTestPrinter printer;
701         osgUtx::TestGraph::instance().root()->accept( printer );   
702         std::cout<<std::endl;
703    }
704
705    if (printFileNameUtilsTests)
706    {
707        runFileNameUtilsTest(arguments);
708    }
709
710
711    if (doTestThreadInitAndExit)
712    {
713        testThreadInitAndExit();
714    }
715
716    std::cout<<"******   Running tests   ******"<<std::endl;
717
718    // Global Data or Context
719    osgUtx::TestContext ctx;
720    osgUtx::TestRunner runner( ctx );
721    runner.specify("root");
722
723    osgUtx::TestGraph::instance().root()->accept( runner );
724
725    return 0;
726}
Note: See TracBrowser for help on using the browser.