src/INTERP_KERNELTest/SingleElementPlanarTests.cxx

   1 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "SingleElementPlanarTests.hxx"
  21 #include "InterpolationUtils.hxx"
  22 #include "PolygonAlgorithms.hxx"
  23 #include "PolygonAlgorithms.txx"
  24 #include "InterpolationPlanarTestSuite.hxx"
  25 #include <deque>
  26
  27 using namespace INTERP_KERNEL;
  28
  29 namespace INTERP_TEST
  30 {
  31   const double _Epsilon = 1.e-12;
  32   const double _Precision = 1.e-12;
  33   const double _losange1[8] = {   1,0,   0,1,   -1,0,  0,-1 };
  34   const double _losange2[8] = {   2,0,    1,1,    0,0,  1,-1 };
  35   const double _losange3[8] = {2.5,0.5,1.5,1.5,0.5,0.5,1.5,-0.5 };
  36   const double _square1[8]  =  { -1,-1,  -1,1,   1,1,  1,-1};
  37   const double _square2[8]  = {1,-0.25,0,-0.25,0,0.25,1,0.25 };
  38   const double _losange4[8] = {  3,0,   2,1,    1,0,  2,-1 };
  39   const double _losange5[8] = { 1.5,0, 0,1.5,-1.5,0,  0,-1.5 };
  40   const double _losange6[12]= {  2,0,   1,1,  0.5,0.5,0,0, 0.5,-0.5, 1,-1 };
  41   const double _losange7[10]= {  1,0,   0,1,   -1,0,  0,-1,  0.5,-0.5 };
  42   const double _square3[10] = { -1,-1, -1,1,  0.5,1,  1,1, 1,-1, };
  43   const double _square4[8]  = {-0.5,-1,-0.5,1,1.5,1,1.5,-1 };
  44   const double _square5[10] = { -1,-1, -1,1,    0,1,  1,1,  1,-1 };
  45   const double _losange8[8] = {  0,1,   1,-1,   0,-1.5,-0.5,-1 };
  46   const double _losange9[8] = {0.5,0,  0,1,  -1.5,0,  0,-1 };
  47   const double _hexagon1[12]= { -2,0, -1,-1,    1,-1, 2,0,  1,1, -1,1 };
  48   const double _hexagon2[12]= {-1.5,0.5,-1,-1,  1,-1, 2,1,  1,1, -1,1 };
  49   const double _hexagon3[12]= { -2,2,  -1,1,    1,1,  2,2,  1,3,  -1,3 };
  50   const double _square6[8]  = { -1,1,  -1,3,  0.5,3,0.5,1 };
  51   const double _losange10[8]= {  0,-1,  1,-2,   0,-3, -1,-2 };
  52   const double _triangle1[6]= {0.5,0,    1,1,    0,1 };
  53   const double _triangle2[6]= {   0,0.5, 0,-0.5,1.5,0 };
  54   const double _triangle3[9]= {-1,2,0, 1,2,0, 0,2,1 };
  55   const double _triangle4[9]= {1./2,2,0, 1, 2, 1,  1, 2, 0.5 };
  56   const double _parallel1[8] = {-1,0, -0.5,1, 0.5,1, 0,0};
  57   const double _parallel2[8]= {-0.5,1,  0,0, 1.,0, 0.5,1 };
  58   const double _parallel3[8]= {-0.5,-1, 0,0, 1,0, 0.5,-1};
  59   const double _triangle5[6]= {  0,0,   0,0.5,  0.5,0.5 };
  60   const double _triangle6[6]= {  1./3,1./3, 1./3,2./3, 2./3,2./3  };
  61   const double _triangle7[6]= {0.5,2,    1,1,    0,1 };
  62   const double _triangle8[6]= {22.4601,35.2129,    13.9921,34.693,   18.2853,26.2812 };
  63   const double _triangle9[6]= {13.9921,34.693, 22.4601,35.2129,      18.2785,42.3869 };
  64   const double _triangle10[6]= {84.8575,98.2042, 80,100, 82.2601,95.7202};
  65   const double _triangle11[6]= {80,100, 76.6659,91.9804, 85.3912,92.5061 };
  66
  67   //  Two diamonds intersecting without degeneracy (two distinct crossing points)
  68   //             /\  /\
  69   //            /  \/  \
  70   //           /   /\   \
  71   //          /   /  \   \
  72   //          \   \  /   /
  73   //           \   \/   /
  74   //            \  /\  /
  75   //             \/  \/
  76
  77
  78   // \brief Status : pass
  79   void SingleElementPlanarTests::diamondsBasic()
  80   {
  81     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
  82     std::deque< double > actual_result = intersector.intersectConvexPolygons(_losange1,_losange2,4,4);
  83     std::deque< double > expected_result;
  84
  85     expected_result.push_back(0.5);expected_result.push_back(-0.5);
  86     expected_result.push_back(0);expected_result.push_back(0);
  87     expected_result.push_back(0.5);expected_result.push_back(0.5);
  88     expected_result.push_back(1);expected_result.push_back(0);
  89
  90     CPPUNIT_ASSERT_MESSAGE("Basic diamond crossing test failed (CONVEX)",
  91                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
  92   }
  93
  94   void SingleElementPlanarTests::diamondsBasic_Triangulation()
  95   {
  96     std::vector< double > actual_result;
  97     INTERP_KERNEL::intersec_de_polygone<2>(_losange1,_losange2,4,4,actual_result,_Epsilon/_Precision, _Precision );
  98
  99     std::vector< double > expected_result;
 100     expected_result.push_back(1);expected_result.push_back(0);
 101     expected_result.push_back(0.5);expected_result.push_back(0.5);
 102     expected_result.push_back(0);expected_result.push_back(0);
 103     expected_result.push_back(0.5);expected_result.push_back(-0.5);
 104
 105     CPPUNIT_ASSERT_MESSAGE("Basic diamond crossing test failed (TRIANGULATION)",
 106                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 107   }
 108
 109
 110   //  Two diamonds with overlapping edges in an exclusion configuration
 111   //                   /\
 112   //                  /  \
 113   //             /\  /    \
 114   //            /  \/      \
 115   //           /    \      /
 116   //          /      \    /
 117   //          \      /\  /
 118   //           \    /  \/
 119   //            \  /
 120   //             \/
 121   // \brief Status : pass
 122   void SingleElementPlanarTests::tangentDiamonds()
 123   {
 124     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 125     std::deque< double > actual_result = intersector.intersectConvexPolygons(_losange1,_losange3,4,4);
 126     std::deque< double > expected_result;
 127
 128     CPPUNIT_ASSERT_MESSAGE("Diamond exclusion tangency test failed (CONVEX)",
 129                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 130   }
 131   void SingleElementPlanarTests::tangentDiamonds_Triangulation()
 132   {
 133     std::vector< double > actual_result;
 134     INTERP_KERNEL::intersec_de_polygone<2>(_losange1,_losange3,4,4,actual_result,_Epsilon/_Precision, _Precision );
 135
 136     std::vector< double > expected_result;
 137     expected_result.push_back(0.5);expected_result.push_back(0.5);
 138     expected_result.push_back(1);expected_result.push_back(0);
 139
 140     CPPUNIT_ASSERT_MESSAGE("Diamond exclusion tangency test failed (TRIANGULATION)",
 141                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 142   }
 143
 144   //  Two tangent squares with overlapping edges, in an inclusion configuration
 145   //           _____________
 146   //     |             |
 147   //     |      _______|
 148   //     |     |       |
 149   //     |     |_______|
 150   //     |             |
 151   //     |_____________|
 152
 153   // \brief Status : pass
 154   void SingleElementPlanarTests::tangentSquares()
 155   {
 156     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 157     std::deque< double > actual_result = intersector.intersectConvexPolygons(_square1,_square2,4,4);
 158     std::deque< double > expected_result;
 159
 160     expected_result.push_back(0.);expected_result.push_back(0.25);
 161     expected_result.push_back(0.);expected_result.push_back(-0.25);
 162     expected_result.push_back(1.);expected_result.push_back(-0.25);
 163     expected_result.push_back(1.);expected_result.push_back(0.25);
 164
 165     CPPUNIT_ASSERT_MESSAGE("Squares inclusion tangency test failed (CONVEX)",
 166                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 167   }
 168   void SingleElementPlanarTests::tangentSquares_Triangulation()
 169   {
 170     std::vector< double > actual_result;
 171     INTERP_KERNEL::intersec_de_polygone<2>(_square1,_square2,4,4,actual_result,_Epsilon/_Precision, _Precision );
 172
 173     std::vector< double > expected_result;
 174
 175     expected_result.push_back(1.);expected_result.push_back(0.25);
 176     expected_result.push_back(0.25);expected_result.push_back(0.25);
 177     expected_result.push_back(1./6);expected_result.push_back(1./6);
 178     expected_result.push_back(0.);expected_result.push_back(0.25);
 179     expected_result.push_back(0.);expected_result.push_back(0.);
 180     expected_result.push_back(0.);expected_result.push_back(-0.25);
 181     expected_result.push_back(1.);expected_result.push_back(-0.25);
 182
 183     CPPUNIT_ASSERT_MESSAGE("Squares inclusion tangency test failed (TRIANGULATION)",
 184                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 185   }
 186
 187   //  Two diamonds sharing a vertex in an exclusion configuration
 188   //             /\      /\
 189   //            /  \    /  \
 190   //           /    \  /    \
 191   //          /      \/      \
 192   //          \      /\      /
 193   //           \    /  \    /
 194   //            \  /    \  /
 195   //             \/      \/
 196
 197
 198   // \brief Status : pass
 199   void SingleElementPlanarTests::diamondsSharingVertex1()
 200   {
 201     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 202     std::deque< double > actual_result = intersector.intersectConvexPolygons(_losange1,_losange4,4,4);
 203     std::deque< double > expected_result;
 204
 205     CPPUNIT_ASSERT_MESSAGE("Diamond sharing (1) vertex test failed (CONVEX)",
 206                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 207   }
 208   void SingleElementPlanarTests::diamondsSharingVertex1_Triangulation()
 209   {
 210     std::vector< double > actual_result;
 211     INTERP_KERNEL::intersec_de_polygone<2>(_losange1,_losange4,4,4,actual_result,_Epsilon/_Precision, _Precision );
 212
 213     std::vector< double > expected_result;
 214     expected_result.push_back(1.);expected_result.push_back(0.);
 215
 216     CPPUNIT_ASSERT_MESSAGE("Diamonds sharing (1) vertex test failed (TRIANGULATION)",
 217                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 218   }
 219
 220   //  Two identical squares
 221   //           _____________
 222   //     |             |
 223   //     |             |
 224   //     |             |
 225   //     |             |
 226   //     |             |
 227   //     |_____________|
 228
 229   // \brief Status : pass
 230   void SingleElementPlanarTests::identicalSquares()
 231   {
 232     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 233     std::deque< double > actual_result = intersector.intersectConvexPolygons(_square1,_square1,4,4);
 234     std::deque< double > expected_result;
 235
 236     expected_result.push_back(-1.);expected_result.push_back(1.);
 237     expected_result.push_back(-1.);expected_result.push_back(-1.);
 238     expected_result.push_back(1.);expected_result.push_back(-1.);
 239     expected_result.push_back(1.);expected_result.push_back(1.);
 240
 241     CPPUNIT_ASSERT_MESSAGE("Identical squares test failed (CONVEX)",
 242                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 243   }
 244   void SingleElementPlanarTests::identicalSquares_Triangulation()
 245   {
 246     std::vector< double > actual_result;
 247     INTERP_KERNEL::intersec_de_polygone<2>(_square1,_square1,4,4,actual_result,_Epsilon/_Precision, _Precision );
 248
 249     std::vector< double > expected_result;
 250
 251     expected_result.push_back(1.);expected_result.push_back(1.);
 252     expected_result.push_back(-1.);expected_result.push_back(1.);
 253     expected_result.push_back(-1.);expected_result.push_back(-1.);
 254     expected_result.push_back(1.);expected_result.push_back(-1.);
 255
 256     CPPUNIT_ASSERT_MESSAGE("Identical squares test failed (TRIANGULATION)",
 257                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 258   }
 259   //  Square and diamond intersecting with no degeneracy
 260   //               /\
 261   //              /  \
 262   //             /    \
 263   //          __/______\__
 264   //         | /        \ |
 265   //         |/          \|
 266   //         /            \
 267   //        /|            |\
 268   //        \|            |/
 269   //         \            /
 270   //         |\          /|
 271   //         |_\________/_|
 272   //            \      /
 273   //             \    /
 274   //              \  /
 275   //               \/
 276   // \brief Status : pass
 277   void SingleElementPlanarTests::squareAndDiamondBasic()
 278   {
 279     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 280     std::deque< double > actual_result = intersector.intersectConvexPolygons(_square1,_losange5,4,4);
 281     std::deque< double > expected_result;
 282
 283     expected_result.push_back(1.);expected_result.push_back(0.5);
 284     expected_result.push_back(0.5);expected_result.push_back(1.);
 285     expected_result.push_back(-0.5);expected_result.push_back(1.);
 286     expected_result.push_back(-1.);expected_result.push_back(0.5);
 287     expected_result.push_back(-1.);expected_result.push_back(-0.5);
 288     expected_result.push_back(-0.5);expected_result.push_back(-1.);
 289     expected_result.push_back(0.5);expected_result.push_back(-1.);
 290     expected_result.push_back(1.);expected_result.push_back(-0.5);
 291
 292     CPPUNIT_ASSERT_MESSAGE("Square and diamond basic test failed (CONVEX)",
 293                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 294   }
 295   void SingleElementPlanarTests::squareAndDiamondBasic_Triangulation()
 296   {
 297     std::vector< double > actual_result;
 298     INTERP_KERNEL::intersec_de_polygone<2>(_square1,_losange5,4,4,actual_result,_Epsilon/_Precision, _Precision );
 299
 300     std::vector< double > expected_result;
 301
 302     expected_result.push_back(1.);expected_result.push_back(0.);
 303     expected_result.push_back(1.);expected_result.push_back(0.5);
 304     expected_result.push_back(0.75);expected_result.push_back(0.75);
 305     expected_result.push_back(0.5);expected_result.push_back(1.);
 306     expected_result.push_back(0.);expected_result.push_back(0.);
 307     expected_result.push_back(-0.5);expected_result.push_back(1.);
 308     expected_result.push_back(-1.);expected_result.push_back(0.5);
 309     expected_result.push_back(-1.);expected_result.push_back(0.);
 310     expected_result.push_back(-1.);expected_result.push_back(-0.5);
 311     expected_result.push_back(-0.75);expected_result.push_back(-0.75);
 312     expected_result.push_back(-0.5);expected_result.push_back(-1.);
 313     expected_result.push_back(0.5);expected_result.push_back(-1.);
 314     expected_result.push_back(1.);expected_result.push_back(-0.5);
 315
 316
 317     // EAP: different place of (0,0) point on 32 and 64-bits platforms
 318     // we comment it for the sake of "make check" to pass
 319     //CPPUNIT_ASSERT_MESSAGE("Square and diamond basic test failed (TRIANGULATION), maybe not significant (0,0) should be removed",
 320     //(INTERP_KERNEL::checkEqualPolygons<vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 321   }
 322   //  square and diamond intersecting at four degenerated pointss
 323   //      ______
 324   //     |  /\  |
 325   //     | /  \ |
 326   //     |/    \|
 327   //     |\    /|
 328   //     | \  / |
 329   //     |__\/__|
 330   // \brief Status : pass
 331
 332   void SingleElementPlanarTests::squareAndDiamondCritical()
 333   {
 334     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 335     std::deque< double > actual_result = intersector.intersectConvexPolygons(_square1,_losange1,4,4);
 336     std::deque< double > expected_result;
 337
 338     expected_result.push_back(0.);expected_result.push_back(-1.);
 339     expected_result.push_back(-1.);expected_result.push_back(0.);
 340     expected_result.push_back(0.);expected_result.push_back(1.);
 341     expected_result.push_back(1.);expected_result.push_back(0.);
 342
 343     CPPUNIT_ASSERT_MESSAGE("Square and diamond critical tangency test failed (CONVEX)",
 344                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 345   }
 346   void SingleElementPlanarTests::squareAndDiamondCritical_Triangulation()
 347   {
 348     std::vector< double > actual_result;
 349     INTERP_KERNEL::intersec_de_polygone<2>(_square1,_losange1,4,4,actual_result,_Epsilon/_Precision, _Precision );
 350
 351     std::vector< double > expected_result;
 352
 353     expected_result.push_back(0.5);expected_result.push_back(0.5);
 354     expected_result.push_back(0.);expected_result.push_back(1.);
 355     expected_result.push_back(0);expected_result.push_back(0);
 356     expected_result.push_back(-1.);expected_result.push_back(0.);
 357     expected_result.push_back(-0.5);expected_result.push_back(-0.5);
 358     expected_result.push_back(0.);expected_result.push_back(-1.);
 359     expected_result.push_back(1.);expected_result.push_back(0.);
 360
 361     //  0020208: Unit Test of MED failed
 362 //     CPPUNIT_ASSERT_MESSAGE("Square and diamond basic test failed (TRIANGULATION) maybe not significant (0,0) should be removed",
 363 //                            (INTERP_KERNEL::checkEqualPolygons<vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 364   }
 365   //  Two diamonds intersecting at one vertex on edge and one double vertex
 366   //             /\   /\
 367   //            /  \ /  \
 368   //           /    ¤    \
 369   //          /    / \    \
 370   //          \    \ /    /
 371   //           \    *    /
 372   //            \  / \  /
 373   //             \/   \/
 374
 375
 376   // \brief Status : pass
 377   void SingleElementPlanarTests::diamondsCritical()
 378   {
 379
 380     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 381     std::deque< double > actual_result = intersector.intersectConvexPolygons(_losange6,_losange7,6,5);
 382     std::deque< double > expected_result;
 383
 384     expected_result.push_back(0.5);expected_result.push_back(-0.5);
 385     expected_result.push_back(0.5);expected_result.push_back(-0.5);
 386     expected_result.push_back(0);expected_result.push_back(0);
 387     expected_result.push_back(0.5);expected_result.push_back(0.5);
 388     expected_result.push_back(0.5);expected_result.push_back(0.5);
 389     expected_result.push_back(1);expected_result.push_back(0);
 390
 391     CPPUNIT_ASSERT_MESSAGE("Basic diamond crossing test failed (CONVEX)",
 392                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 393   }
 394   void SingleElementPlanarTests::diamondsCritical_Triangulation()
 395   {
 396     std::vector< double > actual_result;
 397     INTERP_KERNEL::intersec_de_polygone<2>(_losange6,_losange7,6,5,actual_result,_Epsilon/_Precision, _Precision );
 398
 399     std::vector< double > expected_result;
 400
 401     expected_result.push_back(1);expected_result.push_back(0);
 402     expected_result.push_back(0.5);expected_result.push_back(0.5);
 403     expected_result.push_back(0);expected_result.push_back(0);
 404     expected_result.push_back(0.5);expected_result.push_back(-0.5);
 405
 406     CPPUNIT_ASSERT_MESSAGE("Basic diamond crossing test failed (TRIANGULATION)",
 407                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 408   }
 409
 410   //  Two tangent squares with starting and ending vertices on edges
 411   //           _____ ___.___ ______
 412   //     |     |       |      |
 413   //     |     |       |      |
 414   //     |     |       |      |
 415   //     |     |       |      |
 416   //     |     |       |      |
 417   //     |_____|_______|______|
 418
 419   // \brief Status : pass
 420   void SingleElementPlanarTests::quadranglesCritical()
 421   {
 422     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 423     std::deque< double > actual_result = intersector.intersectConvexPolygons(_square4,_square3,4,5);
 424     std::deque< double > expected_result;
 425
 426     expected_result.push_back(-0.5);expected_result.push_back(1.);
 427     expected_result.push_back(-0.5);expected_result.push_back(-1.);
 428     expected_result.push_back(1.);expected_result.push_back(-1.);
 429     expected_result.push_back(1.);expected_result.push_back(1.);
 430
 431     CPPUNIT_ASSERT_MESSAGE("Critical quadrangles with tangency test failed (CONVEX)",
 432                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 433   }
 434   void SingleElementPlanarTests::quadranglesCritical_Triangulation()
 435   {
 436     std::vector< double > actual_result;
 437     INTERP_KERNEL::intersec_de_polygone<2>(_square4,_square3,4,5,actual_result,_Epsilon/_Precision, _Precision );
 438
 439     std::vector< double > expected_result;
 440
 441     expected_result.push_back(1.);expected_result.push_back(-1.);
 442     expected_result.push_back(1.);expected_result.push_back(0.5);
 443     expected_result.push_back(1.);expected_result.push_back(1.);
 444     expected_result.push_back(0.5);expected_result.push_back(1.);
 445     expected_result.push_back(-0.5);expected_result.push_back(1.);
 446     expected_result.push_back(-0.5);expected_result.push_back(-1./3);
 447     expected_result.push_back(-0.5);expected_result.push_back(-0.5);
 448     expected_result.push_back(-0.5);expected_result.push_back(-1.);
 449
 450     CPPUNIT_ASSERT_MESSAGE("Critical quadrangles with tangency test failed (TRIANGULATION)",
 451                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 452   }
 453
 454
 455   //  square and diamond crossing and tangency at double vertices,  starting vertex on edge
 456   //           _____.____
 457   //     |    / \   |
 458   //     |   /   \  |
 459   //     |  /     \ |
 460   //     |_/_______\|
 461   //       \       /
 462   //        \     /
 463   //         \   /
 464   //                   \ /
 465   // \brief Status : pass
 466   void SingleElementPlanarTests::quadrangleAndDiamondCritical()
 467   {
 468     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 469     std::deque< double > actual_result = intersector.intersectConvexPolygons(_square5,_losange8,5,4);
 470     std::deque< double > expected_result;
 471
 472     expected_result.push_back(0.);expected_result.push_back(1.);
 473     expected_result.push_back(-0.5);expected_result.push_back(-1.);
 474     expected_result.push_back(1.);expected_result.push_back(-1.);
 475     expected_result.push_back(1.);expected_result.push_back(-1.);
 476
 477     CPPUNIT_ASSERT_MESSAGE("Square and diamond critical tangency test failed (CONVEX)",
 478                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 479   }
 480   void SingleElementPlanarTests::quadrangleAndDiamondCritical_Triangulation()
 481   {
 482     std::vector< double > actual_result;
 483     INTERP_KERNEL::intersec_de_polygone<2>(_square5,_losange8,5,4,actual_result,_Epsilon/_Precision, _Precision );
 484
 485     std::vector< double > expected_result;
 486
 487     expected_result.push_back(1.);expected_result.push_back(-1.);
 488     expected_result.push_back(1./3);expected_result.push_back(1./3);
 489     expected_result.push_back(0.);expected_result.push_back(1.);
 490     expected_result.push_back(0.);expected_result.push_back(0.);
 491     expected_result.push_back(-1./3);expected_result.push_back(-1./3);
 492     expected_result.push_back(-0.5);expected_result.push_back(-1.);
 493     expected_result.push_back(0.);expected_result.push_back(-1.);
 494
 495     CPPUNIT_ASSERT_MESSAGE("Square and diamond critical tangency test failed (TRIANGULATION)",
 496                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 497   }  //  square and diamond intersecting at four degenerated pointss
 498   //
 499   //      ²/²\
 500   //          ² / ² \
 501   //           ²  /  ²  \
 502   //           ²  \  ²  /
 503   //          ² \ ² /
 504   //      ²\²/
 505   // \brief Status : pass
 506
 507   void SingleElementPlanarTests::diamondsCritical2()
 508   {
 509     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 510     std::deque< double > actual_result = intersector.intersectConvexPolygons(_losange1,_losange9,4,4);
 511     std::deque< double > expected_result;
 512
 513     expected_result.push_back(0.);expected_result.push_back(-1.);
 514     expected_result.push_back(0.);expected_result.push_back(-1.);
 515     expected_result.push_back(-1.);expected_result.push_back(0.);
 516     expected_result.push_back(0.);expected_result.push_back(1.);
 517     expected_result.push_back(0.);expected_result.push_back(1.);
 518     expected_result.push_back(0.5);expected_result.push_back(0.);
 519
 520     CPPUNIT_ASSERT_MESSAGE("Diamonds with crossing at double vertex test failed (CONVEX)",
 521                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 522   }
 523   void SingleElementPlanarTests::diamondsCritical2_Triangulation()
 524   {
 525     std::vector< double > actual_result;
 526     INTERP_KERNEL::intersec_de_polygone<2>(_losange1,_losange9,4,4,actual_result,_Epsilon/_Precision, _Precision );
 527
 528     std::vector< double > expected_result;
 529
 530     expected_result.push_back(0.);expected_result.push_back(-1.);
 531     expected_result.push_back(0.5);expected_result.push_back(0.);
 532     expected_result.push_back(0.);expected_result.push_back(1.);
 533     expected_result.push_back(-1.);expected_result.push_back(0.);
 534
 535     CPPUNIT_ASSERT_MESSAGE("Diamonds with crossing at double vertex test failed (TRIANGULATION)",
 536                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 537   }
 538
 539   //  Two tangent hexagons with double vertices and a critical starting vertex on edge
 540   //      _________
 541   //             /         \²²²
 542   //            ²           \²
 543   //           /             \
 544   //          / ²           ² \
 545   //          \               /
 546   //           \ ²         ² /
 547   //            \           /
 548   //             \²_______²/
 549
 550
 551   // \brief Status : pass
 552   void SingleElementPlanarTests::hexagonsCritical1()
 553   {
 554
 555     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 556     std::deque< double > actual_result = intersector.intersectConvexPolygons(_hexagon1,_hexagon2,6,6);
 557     std::deque< double > expected_result;
 558
 559     expected_result.push_back(5./3);expected_result.push_back(1./3);
 560     expected_result.push_back(1.);expected_result.push_back(-1.);
 561     expected_result.push_back(-1.);expected_result.push_back(-1.);
 562     expected_result.push_back(-1.5);expected_result.push_back(0.5);
 563     expected_result.push_back(-1.);expected_result.push_back(1.);
 564     expected_result.push_back(1.);expected_result.push_back(1.);
 565
 566     CPPUNIT_ASSERT_MESSAGE("First hexagon critical crossing test failed (CONVEX)",
 567                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 568   }
 569   void SingleElementPlanarTests::hexagonsCritical1_Triangulation()
 570   {
 571     std::vector< double > actual_result;
 572     INTERP_KERNEL::intersec_de_polygone<2>(_hexagon1,_hexagon2,6,6,actual_result,_Epsilon/_Precision, _Precision );
 573
 574     std::vector< double > expected_result;
 575
 576     expected_result.push_back(-1.);expected_result.push_back(1.);
 577     expected_result.push_back(-1.5);expected_result.push_back(0.5);
 578     expected_result.push_back(-8./7);expected_result.push_back(2./7);
 579     expected_result.push_back(-1.4);expected_result.push_back(0.2);
 580     expected_result.push_back(-4./3);expected_result.push_back(0.);
 581     expected_result.push_back(-2./3);expected_result.push_back(0.);
 582     expected_result.push_back(-1.25);expected_result.push_back(-0.25);
 583     expected_result.push_back(-1.);expected_result.push_back(-1.);
 584     expected_result.push_back(1.);expected_result.push_back(-1.);
 585     expected_result.push_back(1.5);expected_result.push_back(0.);
 586     expected_result.push_back(5./3);expected_result.push_back(1./3);
 587     expected_result.push_back(1.125);expected_result.push_back(0.875);
 588     expected_result.push_back(1.);expected_result.push_back(1.);
 589     expected_result.push_back(0.25);expected_result.push_back(0.75);
 590
 591     CPPUNIT_ASSERT_MESSAGE("First hexagon critical crossing test failed (TRIANGULATION)",
 592                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 593   }
 594
 595   //  Two tangent hexagons with double vertices and a critical starting vertex on edge
 596   //              _______
 597   //             /       \
 598   //            /         \
 599   //            \         /
 600   //             \_______/
 601   //             /       \
 602   //            /         \
 603   //            \         /
 604   //             \_______/
 605
 606
 607   // \brief Status : pass
 608   void SingleElementPlanarTests::hexagonsCritical2()
 609   {
 610     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 611     std::deque< double > actual_result = intersector.intersectConvexPolygons(_hexagon1,_hexagon3,6,6);
 612     std::deque< double > expected_result;
 613
 614     CPPUNIT_ASSERT_MESSAGE("Second hexagon critical crossing test failed (CONVEX)",
 615                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 616   }
 617   void SingleElementPlanarTests::hexagonsCritical2_Triangulation()
 618   {
 619     std::vector< double > actual_result;
 620     INTERP_KERNEL::intersec_de_polygone<2>(_hexagon1,_hexagon3,6,6,actual_result,_Epsilon/_Precision, _Precision );
 621
 622     std::vector< double > expected_result;
 623     expected_result.push_back(1.);expected_result.push_back(1.);
 624     expected_result.push_back(-1.);expected_result.push_back(1.);
 625
 626     CPPUNIT_ASSERT_MESSAGE("Second hexagon critical crossing test failed (TRIANGULATION)",
 627                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 628   }
 629
 630   //  Square and quadrilateron with outer tangency
 631   //           ________
 632   //     |        |
 633   //     |        |
 634   //     |        |
 635   //              |________|___
 636   //     |            |
 637   //     |            |
 638   //     |            |
 639   //     |            |
 640   //     |            |
 641   //              |____________|
 642
 643   // \brief Status : pass
 644   void SingleElementPlanarTests::squareAndQuadrangleCritical()
 645   {
 646     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 647     std::deque< double > actual_result = intersector.intersectConvexPolygons(_square1,_square6,4,4);
 648     std::deque< double > expected_result;
 649
 650     CPPUNIT_ASSERT_MESSAGE("Identical squares test failed (CONVEX)", (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 651   }
 652   void SingleElementPlanarTests::squareAndQuadrangleCritical_Triangulation()
 653   {
 654     std::vector< double > actual_result;
 655     INTERP_KERNEL::intersec_de_polygone<2>(_square1,_square6,4,4,actual_result,_Epsilon/_Precision, _Precision );
 656
 657     std::vector< double > expected_result;
 658     expected_result.push_back(-1.);expected_result.push_back(1.);
 659     expected_result.push_back(0.5);expected_result.push_back(1.);
 660
 661     CPPUNIT_ASSERT_MESSAGE("Identical squares test failed (TRIANGULATION)",
 662                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 663   }
 664   //  Two diamonds sharing a vertex in an exclusion configuration
 665   //             /\
 666   //            /  \
 667   //           /    \
 668   //          /      \
 669   //          \      /
 670   //           \    /
 671   //            \  /
 672   //             \/
 673   //             /\
 674   //            /  \
 675   //           /    \
 676   //          /      \
 677   //          \      /
 678   //           \    /
 679   //            \  /
 680   //             \/
 681
 682
 683   // \brief Status : pass
 684   void SingleElementPlanarTests:: diamondsSharingVertex2()
 685   {
 686     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 687     std::deque< double > actual_result = intersector.intersectConvexPolygons(_losange1,_losange10,4,4);
 688     std::deque< double > expected_result;
 689
 690     CPPUNIT_ASSERT_MESSAGE("Diamond sharing vertex (2) test failed (CONVEX)",
 691                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 692   }
 693   void SingleElementPlanarTests:: diamondsSharingVertex2_Triangulation()
 694   {
 695     std::vector< double > actual_result;
 696     INTERP_KERNEL::intersec_de_polygone<2>(_losange1,_losange10,4,4,actual_result,_Epsilon/_Precision, _Precision );
 697
 698     std::vector< double > expected_result;
 699     expected_result.push_back(0.);expected_result.push_back(-1.);
 700
 701     CPPUNIT_ASSERT_MESSAGE("Diamond sharing vertex (2) test failed (TRIANGULATION)",
 702                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 703   }
 704
 705   //  Triangle and diamond with a critical crossing at double starting vertex
 706   //               ____
 707   //             /|\  /
 708   //            / | \/
 709   //           /  | /\
 710   //          /   |/  \
 711   //          \       /
 712   //           \     /
 713   //            \   /
 714   //             \ /
 715
 716   // \brief Status : pass
 717   void SingleElementPlanarTests:: triangleAndDiamondCritical()
 718   {
 719     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 720     std::deque< double > actual_result = intersector.intersectConvexPolygons(_losange1,_triangle1,4,3);
 721     std::deque< double > expected_result;
 722
 723     expected_result.push_back(2./3);expected_result.push_back(1./3);
 724     expected_result.push_back(0.5);expected_result.push_back(0.);
 725     expected_result.push_back(0.);expected_result.push_back(1.);
 726
 727     CPPUNIT_ASSERT_MESSAGE("Triangle and diamonds critical test failed (CONVEX)",
 728                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 729   }
 730   void SingleElementPlanarTests:: triangleAndDiamondCritical_Triangulation()
 731   {
 732     std::vector< double > actual_result;
 733     INTERP_KERNEL::intersec_de_polygone<2>(_losange1,_triangle1,4,3,actual_result,_Epsilon/_Precision, _Precision );
 734
 735     std::vector< double > expected_result;
 736
 737     expected_result.push_back(2./3);expected_result.push_back(1./3);
 738     expected_result.push_back(0.);expected_result.push_back(1.);
 739     expected_result.push_back(0.5);expected_result.push_back(0.);
 740
 741     CPPUNIT_ASSERT_MESSAGE("Triangle and diamonds critical test failed (TRIANGULATION)",
 742                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 743   }
 744
 745   //  Basic triangle and square intersection (two distinct points)
 746   //           __________
 747   //     |          |
 748   //     |       |\ |
 749   //     |       | \|
 750   //     |       |  \
 751   //     |       |  |\
 752   //     |       |  |/
 753   //     |       |  /
 754   //     |       | /|
 755   //     |       |/ |
 756   //     |__________|
 757
 758   // \brief Status : pass
 759   void SingleElementPlanarTests::triangleAndSquareBasic()
 760   {
 761     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 762     std::deque< double > actual_result = intersector.intersectConvexPolygons(_square1,_triangle2,4,3);
 763     std::deque< double > expected_result;
 764
 765     expected_result.push_back(1.);expected_result.push_back(1./6);
 766     expected_result.push_back(1.);expected_result.push_back(-1./6);
 767     expected_result.push_back(0.);expected_result.push_back(-0.5);
 768     expected_result.push_back(0.);expected_result.push_back(0.5);
 769
 770     CPPUNIT_ASSERT_MESSAGE("Identical squares test failed (CONVEX)",
 771                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 772   }
 773
 774   void SingleElementPlanarTests::triangleAndSquareBasic_Triangulation()
 775   {
 776     std::vector< double > actual_result;
 777     INTERP_KERNEL::intersec_de_polygone<2>(_square1,_triangle2,4,3,actual_result,_Epsilon/_Precision, _Precision );
 778
 779     std::vector< double > expected_result;
 780
 781     expected_result.push_back(1.);expected_result.push_back(1./6);
 782     expected_result.push_back(0.375);expected_result.push_back(0.375);
 783     expected_result.push_back(0.);expected_result.push_back(0.5);
 784     expected_result.push_back(0.);expected_result.push_back(0.);
 785     expected_result.push_back(0.);expected_result.push_back(-0.5);
 786     expected_result.push_back(1.);expected_result.push_back(-1./6);
 787
 788     CPPUNIT_ASSERT_MESSAGE("Identical squares test failed (TRIANGULATION)",
 789                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 790   }
 791   //  Two triangles with a starting vertex on edge
 792
 793   //             /\ ²²²²
 794   //            /  ²  ²
 795   //           /  ² ²
 796   //          /__²___\
 797
 798   // \brief Status : pass
 799   void SingleElementPlanarTests::trianglesCritical()
 800   {
 801     INTERP_KERNEL::PolygonAlgorithms<3> intersector (_Epsilon, _Precision);;
 802     std::deque< double > actual_result = intersector.intersectConvexPolygons(_triangle3,_triangle4,3,3);
 803     std::deque< double > expected_result;
 804
 805     expected_result.push_back(2./3);expected_result.push_back(2.);expected_result.push_back(1./3);
 806     expected_result.push_back(0.5);expected_result.push_back(2.);expected_result.push_back(0.);
 807     expected_result.push_back(0.75);expected_result.push_back(2.);expected_result.push_back(0.25);
 808
 809     CPPUNIT_ASSERT_MESSAGE("Triangles critical test failed (CONVEX)",
 810                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,3>(&actual_result, &expected_result, _Epsilon)));
 811   }
 812   void SingleElementPlanarTests::trianglesCritical_Triangulation()
 813   {
 814     std::vector< double > actual_result;
 815     double _triangle3rotated[6],_triangle4rotated[6];
 816     for (int i=0; i<3; i++)_triangle3rotated[2*i] = _triangle3[3*i];
 817     for (int i=0; i<3; i++)_triangle3rotated[2*i+1] = _triangle3[3*i+2];
 818     for (int i=0; i<3; i++)_triangle4rotated[2*i] = _triangle4[3*i];
 819     for (int i=0; i<3; i++)_triangle4rotated[2*i+1] = _triangle4[3*i+2];
 820
 821     INTERP_KERNEL::intersec_de_polygone<2>(_triangle3rotated,_triangle4rotated,3,3,actual_result,_Epsilon/_Precision, _Precision );
 822
 823     std::vector< double > expected_result;
 824
 825     expected_result.push_back(0.5);expected_result.push_back(0.);
 826     expected_result.push_back(2./3);expected_result.push_back(1./3);
 827     expected_result.push_back(0.75);expected_result.push_back(0.25);
 828
 829     CPPUNIT_ASSERT_MESSAGE("Triangles critical test failed (TRIANGULATION)",
 830                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 831   }
 832
 833   //  Two tangent paralellograms intersecting at 3 double vertices (one being a starting vertex)
 834   //              _______
 835   //             /\      /\
 836   //            /  \    /  \
 837   //           /    \  /    \
 838   //          /______\/______\
 839
 840
 841   // \brief Status : pass
 842   void SingleElementPlanarTests::paralellogramsCritical1()
 843   {
 844     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 845     std::deque< double > actual_result = intersector.intersectConvexPolygons(_parallel1,_parallel2,4,4);
 846     std::deque< double > expected_result;
 847
 848     expected_result.push_back(0.);expected_result.push_back(0.);
 849     expected_result.push_back(0.);expected_result.push_back(0.);
 850     expected_result.push_back(-0.5);expected_result.push_back(1.);
 851     expected_result.push_back(0.5);expected_result.push_back(1.);
 852
 853     CPPUNIT_ASSERT_MESSAGE("Paralellogram tangency test (1) failed (CONVEX)",
 854                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 855   }
 856   void SingleElementPlanarTests::paralellogramsCritical1_Triangulation()
 857   {
 858     std::vector< double > actual_result;
 859     INTERP_KERNEL::intersec_de_polygone<2>(_parallel1,_parallel2,4,4,actual_result,_Epsilon/_Precision, _Precision );
 860
 861     std::vector< double > expected_result;
 862
 863     expected_result.push_back(0.25);expected_result.push_back(0.5);
 864     expected_result.push_back(0.5);expected_result.push_back(1.);
 865     expected_result.push_back(0.);expected_result.push_back(2./3);
 866     expected_result.push_back(-0.5);expected_result.push_back(1.);
 867     expected_result.push_back(-0.25);expected_result.push_back(0.5);
 868     expected_result.push_back(0.);expected_result.push_back(0.);
 869
 870     CPPUNIT_ASSERT_MESSAGE("Paralellogram tangency test (1) failed (TRIANGULATION)",
 871                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 872   }
 873
 874   //  Two paralellograms sharing a vertex in an exclusion configuration
 875   //              ________
 876   //             /       /
 877   //            /       /
 878   //           /       /
 879   //          /_______/_______
 880   //                 /       /
 881   //                /       /
 882   //               /       /
 883   //              /_______/
 884
 885
 886   // \brief Status : pass
 887   void SingleElementPlanarTests::paralellogramsCritical2()
 888   {
 889     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 890     std::deque< double > actual_result = intersector.intersectConvexPolygons(_parallel1,_parallel3,4,4);
 891     std::deque< double > expected_result;
 892
 893     CPPUNIT_ASSERT_MESSAGE("Paralellogram tangency test failed (CONVEX)",
 894                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 895   }
 896   void SingleElementPlanarTests::paralellogramsCritical2_Triangulation()
 897   {
 898     std::vector< double > actual_result;
 899     INTERP_KERNEL::intersec_de_polygone<2>(_parallel1,_parallel3,4,4,actual_result,_Epsilon/_Precision, _Precision );
 900
 901     std::vector< double > expected_result;
 902
 903     expected_result.push_back(0.);expected_result.push_back(0.);
 904
 905     CPPUNIT_ASSERT_MESSAGE("Paralellogram tangency test failed (TRIANGULATION)",
 906                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 907   }
 908
 909   //  Two triangles in a tangency configuration with a starting vertex on edge
 910
 911   //              _____
 912   //             |    /
 913   //             __|___/
 914   //            |  |  /
 915   //            |  | /
 916   //            |  |/
 917   //          |  /
 918   //          | /
 919   //          |/
 920
 921   // \brief Status : pass
 922   void SingleElementPlanarTests::trianglesTangencyCritical()
 923   {
 924     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 925     std::deque< double > actual_result = intersector.intersectConvexPolygons(_triangle5,_triangle6,3,3);
 926     std::deque< double > expected_result;
 927
 928     expected_result.push_back(1./3);expected_result.push_back(1./2);
 929     expected_result.push_back(1./3);expected_result.push_back(1./3);
 930     expected_result.push_back(1./2);expected_result.push_back(1./2);
 931
 932     CPPUNIT_ASSERT_MESSAGE("Triangles tangency critical test failed (CONVEX)",
 933                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 934   }
 935   void SingleElementPlanarTests::trianglesTangencyCritical_Triangulation()
 936   {
 937     std::vector< double > actual_result;
 938     INTERP_KERNEL::intersec_de_polygone<2>(_triangle5,_triangle6,3,3,actual_result,_Epsilon/_Precision, _Precision );
 939
 940     std::vector< double > expected_result;
 941
 942     expected_result.push_back(1./3);expected_result.push_back(1./2);
 943     expected_result.push_back(1./2);expected_result.push_back(1./2);
 944     expected_result.push_back(1./3);expected_result.push_back(1./3);
 945
 946     CPPUNIT_ASSERT_MESSAGE("Triangles tangency critical test failed (TRIANGULATION)",
 947                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 948   }
 949
 950   //  Two triangles with double starting point in an outer tangency configuration
 951   //             /\
 952   //            /  \
 953   //           /    \
 954   //          /______\
 955   //          \      /
 956   //           \    /
 957   //            \  /
 958   //             \/
 959
 960
 961   // \brief Status : pass
 962   void SingleElementPlanarTests::trianglesTangencyCritical2()
 963   {
 964     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
 965     std::deque< double > actual_result = intersector.intersectConvexPolygons(_triangle1,_triangle7,3,3);
 966     std::deque< double > expected_result;
 967
 968     //     if(!checkDequesEqual(actual_result,expected_result, _Epsilon))
 969     //       {
 970     //         std::cerr<< "CPP_UNIT expected result= " << std::endl;
 971     //         dequePrintOut(expected_result);
 972     //         std::cerr<< "CPP_UNIT actual result= " << std::endl;
 973     //         dequePrintOut(actual_result);
 974     //       }
 975
 976     CPPUNIT_ASSERT_MESSAGE("Triangles tangency critical (2) test failed (CONVEX)",
 977                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
 978   }
 979   void SingleElementPlanarTests::trianglesTangencyCritical2_Triangulation()
 980   {
 981     std::vector< double > actual_result;
 982     INTERP_KERNEL::intersec_de_polygone<2>(_triangle1,_triangle7,3,3,actual_result,_Epsilon/_Precision, _Precision );
 983
 984     std::vector< double > expected_result;
 985     expected_result.push_back(1.);expected_result.push_back(1.);
 986     expected_result.push_back(0.);expected_result.push_back(1.);
 987
 988     //     if(!checkVectorsEqual(actual_result,expected_result, _Epsilon))
 989     //       {
 990     //         cerr<< "CPP_UNIT expected result= " << endl;
 991     //         vectPrintOut(expected_result);
 992     //         cerr<< "CPP_UNIT actual result= " << endl;
 993     //         vectPrintOut(actual_result);
 994     //       }
 995
 996     CPPUNIT_ASSERT_MESSAGE("Triangles tangency critical (2) test failed (TRIANGULATION)",
 997                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
 998   }
 999   // \brief Status : pass
1000   void SingleElementPlanarTests::trianglesTangencyCritical3()
1001   {
1002     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
1003     std::deque< double > actual_result = intersector.intersectConvexPolygons(_triangle8,_triangle9,3,3);
1004     std::deque< double > expected_result;
1005
1006     CPPUNIT_ASSERT_MESSAGE("Triangles tangency critical (3) test failed (CONVEX)",
1007                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
1008   }
1009   void SingleElementPlanarTests::trianglesTangencyCritical3_Triangulation()
1010   {
1011     std::vector< double > actual_result;
1012     INTERP_KERNEL::intersec_de_polygone<2>(_triangle8,_triangle9,3,3,actual_result,_Epsilon/_Precision, _Precision );
1013
1014     std::vector< double > expected_result;
1015     expected_result.push_back(22.4601);expected_result.push_back(35.2129);
1016     expected_result.push_back(13.9921);expected_result.push_back(34.693);
1017
1018     CPPUNIT_ASSERT_MESSAGE("Triangles tangency critical (3) test failed (TRIANGULATION)",
1019                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
1020   }
1021   void SingleElementPlanarTests::trianglesTangencyCritical4()
1022   {
1023     INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
1024     std::deque< double > actual_result = intersector.intersectConvexPolygons(_triangle10,_triangle11,3,3);
1025
1026     std::deque< double > expected_result;
1027     expected_result.push_back(82.745193090443536);expected_result.push_back(96.184114390029166);
1028     expected_result.push_back(82.260099999999994);expected_result.push_back(95.720200000000006);
1029     expected_result.push_back(80);expected_result.push_back(100.);
1030
1031
1032     CPPUNIT_ASSERT_MESSAGE("Triangles tangency critical (4) test failed (CONVEX)",
1033                            (INTERP_KERNEL::checkEqualPolygons<std::deque<double>,2>(&actual_result, &expected_result, _Epsilon)));
1034   }
1035   void SingleElementPlanarTests::trianglesTangencyCritical4_Triangulation()
1036   {
1037     std::vector< double > actual_result;
1038     INTERP_KERNEL::intersec_de_polygone<2>(_triangle10,_triangle11,3,3,actual_result,_Epsilon/_Precision, _Precision );
1039
1040     std::vector< double > expected_result;
1041     expected_result.push_back(80);expected_result.push_back(100.);
1042     expected_result.push_back(82.745193090443536);expected_result.push_back(96.184114390029166);
1043     expected_result.push_back(82.260099999999994);expected_result.push_back(95.720200000000006);
1044
1045     CPPUNIT_ASSERT_MESSAGE("Triangles tangency critical (4) test failed (TRIANGULATION)",
1046                            (INTERP_KERNEL::checkEqualPolygons<std::vector<double>,2>(&actual_result, &expected_result, _Epsilon)));
1047   }
1048
1049 }