sysrap/tests/stra_test.cc

0001 /**
0002 stra_test.sh
0003 ==============
0004
0005 ::
0006
0007     ~/o/sysrap/tests/stra_test.sh
0008
0009
0010 **/
0011
0012 #include <sstream>
0013 #include <iostream>
0014 #include <iomanip>
0015 #include <vector>
0016 #include <string>
0017
0018 #include "ssys.h"
0019 #include "stra.h"
0020 #include "sbb.h"
0021
0022
0023 struct stra_test
0024 {
0025     static int Desc();
0026     static int Place();
0027
0028     template<typename T> static int Rows();
0029     template<typename T> static int Transform_AABB();
0030     template<typename T> static int Transform_AABB_Inplace();
0031     template<typename T> static int Transform_Vec();
0032     template<typename T> static int Transform_Data();
0033     template<typename T> static int Desc_strided();
0034     template<typename T> static int Transform_Strided();
0035     template<typename T> static int MakeTransformedArray();
0036     template<typename T> static int Copy_Columns_3x4();
0037     template<typename T> static int Elements();
0038
0039     static int Main();
0040 };
0041
0042
0043 int stra_test::Desc()
0044 {
0045     glm::tmat4x4<double> a(1.);
0046     glm::tmat4x4<double> b(2.);
0047     glm::tmat4x4<double> c(3.);
0048
0049     std::cout << stra<double>::Desc(a, b, c, "a", "b", "c" );
0050     return 0 ;
0051 }
0052
0053 int stra_test::Place()
0054 {
0055     glm::tvec3<double> va(0,0,1) ;   // +Z
0056     glm::tvec3<double> vb(1,0,0) ;   // +X
0057     glm::tvec3<double> vc(-250,0,0) ;
0058
0059     bool flip = true ;
0060     glm::tmat4x4<double> tr = stra<double>::Place(va, vb, vc, flip );
0061     std::cout << stra<double>::Desc(tr) << std::endl ;
0062     std::cout << stra<double>::Array(tr) << std::endl << std::endl ;
0063
0064     const int N = 7 ;
0065     double sx = 254. ;
0066     double sy = 254. ;
0067     double sz = 186. ;
0068
0069     std::vector<std::string> l(N) ;
0070     std::vector<std::string> m(N) ;
0071     std::vector<glm::tvec4<double>> a(N) ;
0072     std::vector<glm::tvec4<double>> b(N) ;
0073
0074     a[0] = {0,0,0,1 }  ; l[0] = "O" ;
0075
0076     a[1] = {sx,0,0,1 }  ; l[1] = "+sx" ;
0077     a[2] = {0,sy,0,1 }  ; l[2] = "+sy" ;
0078     a[3] = {0,0,sz,1 }  ; l[3] = "+sz" ;
0079
0080     a[4] = {-sx,0,0,1 } ; l[4] = "-sx" ;
0081     a[5] = {0,-sy,0,1 } ; l[5] = "-sy" ;
0082     a[6] = {0,0,-sz,1 } ; l[6] = "-sz" ;
0083
0084
0085     for(int i=0 ; i < N ; i++) b[i] = tr * a[i] ;
0086     for(int i=0 ; i < N ; i++) m[i] = "(tr * " + l[i] + ")" ;
0087
0088     for(int i=0 ; i < N ; i++) std::cout
0089         << std::setw(15) << l[i] << " "
0090         << stra<double>::Desc(a[i])
0091         << std::setw(15) << m[i] << " "
0092         << stra<double>::Desc(b[i])
0093         << std::endl
0094         ;
0095     return 0 ;
0096 }
0097
0098
0099 template<typename T>
0100 int stra_test::Rows()
0101 {
0102     std::array<T,16> a = {
0103           0., 1., 2., 3.,
0104           4., 5., 6., 7.,
0105           8., 9.,10.,11.,
0106          12.,13.,14.,15.
0107      };
0108
0109     glm::tmat4x4<T> m = stra<T>::FromData(a.data()) ;
0110     std::cout << " m " << m << std::endl ;
0111
0112     glm::tvec4<T> q0(0.);
0113     glm::tvec4<T> q1(0.);
0114     glm::tvec4<T> q2(0.);
0115     glm::tvec4<T> q3(0.);
0116
0117     stra<T>::Rows(q0,q1,q2,q3,m);
0118
0119     std::cout << " q0 " << q0 << std::endl ;
0120     std::cout << " q1 " << q1 << std::endl ;
0121     std::cout << " q2 " << q2 << std::endl ;
0122     std::cout << " q3 " << q3 << std::endl ;
0123
0124     /*
0125     // HUH: NOT COMPILING : NEEDS SOME EXTRA HEADER ?
0126     glm::tvec4<T> q01_min = glm::min<T>( q0, q1 );
0127     glm::tvec4<T> q01_max = glm::max<T>( q0, q1 );
0128
0129     std::cout << " q01_min " << q01_min << std::endl ;
0130     std::cout << " q01_max " << q01_max << std::endl ;
0131     */
0132
0133     return 0 ;
0134 }
0135
0136
0137 template<typename T>
0138 int stra_test::Transform_AABB()
0139 {
0140     std::cout << "stra_test::Transform_AABB" << std::endl ;
0141
0142     std::array<T,16> a = {
0143           1., 0., 0., 0.,
0144           0., 1., 0., 0.,
0145           0., 0., 1., 0.,
0146           0., 0.,100.,1.
0147      };
0148
0149     glm::tmat4x4<T> m = stra<T>::FromData(a.data()) ;
0150     std::cout << " m " << m << std::endl ;
0151
0152
0153     std::array<T,6> bb0 = { -100., -100., -100.,  100., 100., 100. } ;
0154     std::array<T,6> bb1(bb0) ;
0155
0156     std::cout << " bb0 " << sbb::Desc(bb0.data()) << std::endl ;
0157
0158     stra<T>::Transform_AABB( bb1.data(), bb0.data(),  m );
0159
0160     std::cout << " bb1 " << sbb::Desc(bb1.data()) << std::endl ;
0161     return 0 ;
0162 }
0163
0164 template<typename T>
0165 int stra_test::Transform_AABB_Inplace()
0166 {
0167     std::cout << "stra_test::Transform_AABB_Inplace" << std::endl ;
0168
0169     std::array<T,16> a = {
0170           1., 0., 0., 0.,
0171           0., 1., 0., 0.,
0172           0., 0., 1., 0.,
0173           0., 0.,100.,1.
0174      };
0175
0176     glm::tmat4x4<T> m = stra<T>::FromData(a.data()) ;
0177     std::cout << " m " << m << std::endl ;
0178
0179     std::array<T,6> bb0 = { -100., -100., -100.,  100., 100., 100. } ;
0180     std::array<T,6> bb1(bb0) ;
0181
0182     std::cout << " bb0 " << sbb::Desc(bb0.data()) << std::endl ;
0183
0184     stra<T>::Transform_AABB_Inplace( bb1.data(),  m );
0185
0186     std::cout << " bb1 " << sbb::Desc(bb1.data()) << std::endl ;
0187     return 0 ;
0188 }
0189
0190 template<typename T>
0191 int stra_test::Transform_Vec()
0192 {
0193     std::cout << "stra_test::Transform_Vec" << std::endl ;
0194
0195     std::array<T,16> a = {
0196           1., 0., 0., 0.,
0197           0., 1., 0., 0.,
0198           0., 0., 1., 0.,
0199           0., 0.,100.,1.
0200      };
0201
0202     glm::tmat4x4<T> m = stra<T>::FromData(a.data()) ;
0203     std::cout << " m " << m << std::endl ;
0204
0205     glm::tvec4<T> pos ;
0206     glm::tvec4<T> pos0 = { 0, 0, 0, 1 } ;
0207
0208     stra<T>::Transform_Vec(pos, pos0, m );
0209
0210     std::cout << " pos0 " << stra<T>::Desc(pos0)  << std::endl ;
0211     std::cout << " pos  " << stra<T>::Desc(pos)  << std::endl ;
0212
0213     return 0 ;
0214 }
0215
0216
0217
0218
0219 template<typename T>
0220 int stra_test::Transform_Data()
0221 {
0222     std::cout << "stra_test::Transform_Data" << std::endl ;
0223
0224     std::array<T,16> a = {
0225           1., 0., 0., 0.,
0226           0., 1., 0., 0.,
0227           0., 0., 1., 0.,
0228           0., 0.,100.,1.
0229      };
0230
0231     glm::tmat4x4<T> m = stra<T>::FromData(a.data()) ;
0232     std::cout << " m " << m << std::endl ;
0233
0234     std::array<double,3> pos0 = { 0, 0, 0 } ;
0235     std::array<double,3> pos = { 0, 0, 0 } ;
0236
0237     stra<T>::Transform_Data(pos.data(), pos0.data(), &m );
0238
0239     std::cout << " pos0 " << stra<T>::Desc(pos0.data(), 1, 3, 0)  << std::endl ;
0240     std::cout << " pos  " << stra<T>::Desc(pos.data(),  1, 3, 0 ) << std::endl ;
0241
0242     return 0 ;
0243 }
0244
0245 template<typename T>
0246 int stra_test::Desc_strided()
0247 {
0248     std::array<T,64> a = {
0249           1., 2., 3., 0.,
0250           0., 0., 0., 0.,
0251           0., 0., 0., 0.,
0252           0., 0., 0., 0.,
0253
0254           4., 5., 6., 0.,
0255           0., 0., 0., 0.,
0256           0., 0., 0., 0.,
0257           0., 0., 0., 0.,
0258
0259           7., 8., 9., 0.,
0260           0., 0., 0., 0.,
0261           0., 0., 0., 0.,
0262           0., 0., 0., 0.,
0263
0264          10.,11.,12., 0.,
0265           0., 0., 0., 0.,
0266           0., 0., 0., 0.,
0267           0., 0., 0., 0.
0268      };
0269
0270
0271    std::cout
0272        << "stra_test::Desc_strided"
0273        << std::endl
0274        << stra<T>::Desc( a.data(), 4, 3, 16 )
0275        << std::endl
0276        ;
0277
0278    return 0 ;
0279 }
0280
0281
0282
0283
0284
0285 template<typename T>
0286 int stra_test::Transform_Strided()
0287 {
0288     std::cout << "stra_test::Transform_Strided" << std::endl ;
0289
0290     std::array<T,16> _m = {
0291           1., 0., 0., 0.,
0292           0., 1., 0., 0.,
0293           0., 0., 1., 0.,
0294           0., 0.,100.,1.
0295      };
0296
0297     glm::tmat4x4<T> m = stra<T>::FromData(_m.data()) ;
0298     std::cout << " m " << m << std::endl ;
0299
0300
0301     std::array<T,64> p0 = {
0302           1., 2., 3., 0.,
0303           0., 0., 0., 0.,
0304           0., 0., 0., 0.,
0305           0., 0., 0., 0.,
0306
0307           4., 5., 6., 0.,
0308           0., 0., 0., 0.,
0309           0., 0., 0., 0.,
0310           0., 0., 0., 0.,
0311
0312           7., 8., 9., 0.,
0313           0., 0., 0., 0.,
0314           0., 0., 0., 0.,
0315           0., 0., 0., 0.,
0316
0317          10.,11.,12., 0.,
0318           0., 0., 0., 0.,
0319           0., 0., 0., 0.,
0320           0., 0., 0., 0.
0321      };
0322
0323      std::array<T,64> p1(p0) ;
0324
0325      stra<T>::Transform_Strided( p1.data(), p0.data(), 4, 3, 16, m, 1. );
0326
0327      std::array<T,64> p2(p0) ;
0328      stra<T>::Transform_Strided_Inplace( p2.data(), 4, 3, 16, m, 1. );
0329
0330
0331      std::cout
0332          << "stra_test::Transform_Strided"
0333          << std::endl
0334          << " p0 "
0335          << std::endl
0336          << stra<T>::Desc( p0.data(), 4, 3, 16 )
0337          << std::endl
0338          << " p1 "
0339          << std::endl
0340          << stra<T>::Desc( p1.data(), 4, 3, 16 )
0341          << std::endl
0342          << " p2 (check Transform_Strided_Inplace)  "
0343          << std::endl
0344          << stra<T>::Desc( p2.data(), 4, 3, 16 )
0345          << std::endl
0346          ;
0347
0348     return 0 ;
0349 }
0350
0351
0352
0353
0354
0355 template<typename T>
0356 int stra_test::MakeTransformedArray()
0357 {
0358     std::cout << "stra_test::MakeTransformedArray" << std::endl ;
0359
0360     std::array<double,12> _aa = {{
0361           0., 0., 0.,
0362           1., 0., 0.,
0363           0., 1., 0.,
0364           0., 0., 1.
0365     }};
0366
0367     int itemsize = sizeof(double)*3 ;
0368     NP* a = NP::Make<double>(4, 3 );
0369     a->read2( _aa.data() );
0370     const double* aa = a->cvalues<double>();
0371
0372     std::cout << "a" << std::endl ;
0373     for(int i=0 ; i < a->shape[0] ; i++)
0374     {
0375         glm::tvec3<double> v(0.) ;
0376         memcpy( glm::value_ptr(v) , aa + i*3, itemsize );
0377         std::cout << glm::to_string(v) << std::endl ;
0378     }
0379
0380
0381     glm::tmat4x4<double> t = {
0382          { 1., 0., 0., 0. },
0383          { 0., 1., 0., 0. },
0384          { 0., 0., 1., 0. },
0385          { 0., 0.,10., 1. } } ;
0386
0387     NP* b = stra<double>::MakeTransformedArray(a, &t );
0388     const double* bb = b->cvalues<double>();
0389
0390     std::cout << "b" << std::endl ;
0391     for(int i=0 ; i < b->shape[0] ; i++)
0392     {
0393         glm::tvec3<double> v(0.) ;
0394         memcpy( glm::value_ptr(v) , bb + i*3, itemsize );
0395         std::cout << glm::to_string(v) << std::endl ;
0396     }
0397     return 0 ;
0398 }
0399
0400
0401 template<typename T>
0402 int stra_test::Copy_Columns_3x4()
0403 {
0404     std::cout << "stra_test::Copy_Columns_3x4" << std::endl ;
0405     std::array<T,16> aa = {{
0406           0., 1., 2., 3.,
0407           4., 5., 6., 7.,
0408           8., 9.,10.,11.,
0409          12.,13.,14.,15.
0410     }};
0411
0412     glm::tmat4x4<T> src(0.) ;
0413     glm::tmat4x4<T> dst(0.) ;
0414
0415     memcpy( glm::value_ptr(src) , aa.data(), 16*sizeof(T) );
0416     stra<T>::Copy_Columns_3x4(dst, src);
0417
0418
0419     std::cout
0420         << " src \n"
0421         << glm::to_string(src)
0422         << std::endl
0423         << stra<T>::Desc(src)
0424         << std::endl
0425         ;
0426
0427     std::cout
0428         << " dst \n"
0429         << glm::to_string(dst)
0430         << std::endl
0431         << stra<T>::Desc(dst)
0432         << std::endl
0433         ;
0434
0435     return 0 ;
0436 }
0437
0438 /**
0439 stra_test::Elements
0440 ----------------------
0441
0442  |   0.   1.   2.   3.  |
0443  |                      |
0444  |   4.   5.   6.   7.  |
0445  |                      |
0446  |   8.   9.  10.  11.  |
0447  |                      |
0448  |  12.  13.  14.  15.  |
0449
0450
0451  | P[0][0]  P[0][1]  P[0][2]  P[0][3]   |
0452  |                                      |
0453  | P[1][0]  P[1][1]  P[1][2]  P[1][3]   |
0454  |                                      |
0455  | P[2][0]  P[2][1]  P[2][2]  P[2][3]   |
0456  |                                      |
0457  | P[3][0]  P[3][1]  P[3][2]  P[3][3]   |
0458
0459
0460 glm::tmat4x4 (aka mat4) element access indices are (row, column)
0461
0462 But beware the matrix may be transposed relative
0463 to your expectation : this happens often.
0464
0465 **/
0466
0467
0468 template<typename T>
0469 int stra_test::Elements()
0470 {
0471     std::cout << "stra_test::Elements" << std::endl ;
0472     std::array<T,16> aa = {{
0473           0., 1., 2., 3.,
0474           4., 5., 6., 7.,
0475           8., 9.,10.,11.,
0476          12.,13.,14.,15.
0477     }};
0478
0479     glm::tmat4x4<T> P(0.) ;
0480     memcpy( glm::value_ptr(P) , aa.data(), 16*sizeof(T) );
0481
0482     const T* pp = glm::value_ptr(P) ;
0483
0484     assert( P[0][0] == 0. );
0485     assert( P[0][1] == 1. );
0486     assert( P[0][2] == 2. );
0487     assert( P[0][3] == 3. );
0488
0489     assert( P[1][0] == 4. );
0490     assert( P[1][1] == 5. );
0491     assert( P[1][2] == 6. );
0492     assert( P[1][3] == 7. );
0493
0494     assert( P[2][0] == 8. );
0495     assert( P[2][1] == 9. );
0496     assert( P[2][2] == 10. );
0497     assert( P[2][3] == 11. );
0498
0499     assert( P[3][0] == 12. );
0500     assert( P[3][1] == 13. );
0501     assert( P[3][2] == 14. );
0502     assert( P[3][3] == 15. );
0503
0504     int ni = 4 ;
0505     int nj = 4 ;
0506
0507     for(int i=0 ; i < ni ; i++)
0508     for(int j=0 ; j < nj ; j++)
0509     {
0510         int n = i*nj + j ;
0511         assert( P[i][j] == *(pp + n) );
0512         assert( P[i][j] == pp[n] );
0513     }
0514
0515
0516     return 0 ;
0517 }
0518
0519
0520
0521 int stra_test::Main()
0522 {
0523     const char* TEST = ssys::getenvvar("TEST", "Copy_Columns_3x4");
0524     int rc = 0 ;
0525     if( strcmp(TEST,"Place")==0 )                   rc += Place();
0526     if( strcmp(TEST,"Rows")==0 )                    rc += Rows<double>();
0527     if( strcmp(TEST,"Transform_AABB")==0 )          rc += Transform_AABB<double>();
0528     if( strcmp(TEST,"Transform_AABB_Inplace")==0 )  rc += Transform_AABB_Inplace<double>();
0529     if( strcmp(TEST,"Transform_Vec")==0 )           rc += Transform_Vec<double>();
0530     if( strcmp(TEST,"Transform_Data")==0 )          rc += Transform_Data<double>();
0531     if( strcmp(TEST,"Transform_Strided")==0 )       rc += Transform_Strided<double>();
0532     if( strcmp(TEST,"MakeTransformedArray")==0 )    rc += MakeTransformedArray<double>();
0533     if( strcmp(TEST,"Desc_strided")==0 )            rc += Desc_strided<double>();
0534     if( strcmp(TEST,"Copy_Columns_3x4")==0 )        rc += Copy_Columns_3x4<double>();
0535     if( strcmp(TEST,"Elements")==0 )                rc += Elements<double>();
0536     return rc ;
0537 }
0538
0539 int main(){ return stra_test::Main() ; }
0540
0541