src/INTERP_KERNELTest/QuadraticPlanarInterpTest4.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 "QuadraticPlanarInterpTest.hxx"
  21 #include "InterpKernelGeo2DQuadraticPolygon.hxx"
  22 #include "InterpKernelGeo2DElementaryEdge.hxx"
  23 #include "InterpKernelGeo2DEdgeArcCircle.hxx"
  24 #include "InterpKernelGeo2DEdgeLin.hxx"
  25
  26 #include <cmath>
  27 #include <sstream>
  28 #include <iostream>
  29 #include <iterator>
  30
  31 using namespace INTERP_KERNEL;
  32
  33 namespace INTERP_TEST
  34 {
  35
  36 void QuadraticPlanarInterpTest::checkPolygonsIntersection1()
  37 {
  38   //The "most" basic test1
  39   Node *n1=new Node(0.,0.);                Node *n4=new Node(0.,-0.3);
  40   Node *n2=new Node(1.,0.);                Node *n5=new Node(1.,-0.3);
  41   Node *n3=new Node(0.5,1.);               Node *n6=new Node(0.5,0.7);
  42   EdgeLin *e1_2=new EdgeLin(n1,n2);        EdgeLin *e4_5=new EdgeLin(n4,n5);
  43   EdgeLin *e2_3=new EdgeLin(n2,n3);        EdgeLin *e5_6=new EdgeLin(n5,n6);
  44   EdgeLin *e3_1=new EdgeLin(n3,n1);        EdgeLin *e6_4=new EdgeLin(n6,n4);
  45   //
  46   std::vector<QuadraticPolygon *> result;
  47   for(int k=0;k<2;k++)
  48     for(int i=0;i<3;i++)
  49       {
  50         for(int j=0;j<1;j++)
  51           {
  52             e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_4->incrRef();
  53             QuadraticPolygon pol1; pol1.circularPermute(); pol1.pushBack(e1_2); pol1.pushBack(e2_3); pol1.pushBack(e3_1);
  54             for(int i1=0;i1<i;i1++) pol1.circularPermute(); if(k==1) pol1.reverse();
  55             QuadraticPolygon pol2; pol2.pushBack(e4_5); pol2.pushBack(e5_6); pol2.pushBack(e6_4);
  56             for(int j1=0;j1<j;j1++) pol2.circularPermute();
  57             result=pol1.intersectMySelfWith(pol2);
  58             CPPUNIT_ASSERT_EQUAL(1,(int)result.size()); checkBasicsOfPolygons(*result[0],*result[0],false);
  59             CPPUNIT_ASSERT_EQUAL(3,result[0]->recursiveSize());
  60             double tmp1=0.,tmp2=0.,tmp3=0.;
  61             pol1.intersectForPerimeter(pol2,tmp1,tmp2,tmp3);
  62             std::vector<double> v1,v2;
  63             std::vector<int> v3;
  64             pol1.intersectForPerimeterAdvanced(pol2,v1,v2);//no common edge
  65             pol1.intersectForPoint(pol2,v3);
  66             CPPUNIT_ASSERT_EQUAL(3,(int)v1.size());
  67             CPPUNIT_ASSERT_EQUAL(3,(int)v2.size());
  68             CPPUNIT_ASSERT_EQUAL(3,(int)v3.size());
  69             if(k==0)
  70               {
  71                 CPPUNIT_ASSERT_EQUAL(2,v3[(3-i)%3]);
  72                 CPPUNIT_ASSERT_EQUAL(0,v3[(4-i)%3]);
  73                 CPPUNIT_ASSERT_EQUAL(0,v3[(5-i)%3]);
  74                 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.7,v1[(3-i)%3],1.e-14);
  75                 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,v1[(4-i)%3],1.e-14);
  76                 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,v1[(5-i)%3],1.e-14);
  77                 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,v2[0],1.e-14);
  78                 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.78262379212492639,v2[1],1.e-14);
  79                 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.78262379212492639,v2[2],1.e-14);
  80               }
  81             CPPUNIT_ASSERT_DOUBLES_EQUAL(0.7,tmp1,1.e-14);
  82             CPPUNIT_ASSERT_DOUBLES_EQUAL(1.5652475842498528,tmp2,1.e-14);
  83             CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,tmp3,1.e-14);//no common edge
  84             delete result[0];
  85           }
  86       }
  87   //clean-up for test1
  88   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef(); e4_5->decrRef(); e5_6->decrRef(); e6_4->decrRef();
  89   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
  90
  91   //Deeper test some extremities of pol2 are on edges of pol1.
  92
  93   n1=new Node(0.,0.);                n4=new Node(1.5,-0.5);
  94   n2=new Node(1.,0.);                n5=new Node(0.5,0.);
  95   n3=new Node(0.5,1.);               n6=new Node(0.75,0.5); Node *n7=new Node(2.,0.5);
  96   e1_2=new EdgeLin(n1,n2); e2_3=new EdgeLin(n2,n3); e3_1=new EdgeLin(n3,n1);
  97   EdgeLin *e5_4=new EdgeLin(n5,n4); EdgeLin *e4_7=new EdgeLin(n4,n7); EdgeLin *e7_6=new EdgeLin(n7,n6); EdgeLin *e6_5=new EdgeLin(n6,n5);
  98   //
  99   for(int k=0;k<2;k++)
 100     for(int i=0;i<3;i++)
 101       {
 102         for(int j=0;j<4;j++)
 103           {
 104             e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e5_4->incrRef(); e4_7->incrRef(); e7_6->incrRef(); e6_5->incrRef();
 105             QuadraticPolygon pol3; pol3.pushBack(e1_2); pol3.pushBack(e2_3); pol3.pushBack(e3_1);
 106             for(int i1=0;i1<i;i1++) pol3.circularPermute(); if(k==1) pol3.reverse();
 107             QuadraticPolygon pol4; pol4.pushBack(e5_4); pol4.pushBack(e4_7); pol4.pushBack(e7_6); pol4.pushBack(e6_5);
 108             for(int j1=0;j1<j;j1++) pol4.circularPermute();
 109             result=pol3.intersectMySelfWith(pol4);
 110             CPPUNIT_ASSERT_EQUAL(1,(int)result.size()); checkBasicsOfPolygons(*result[0],*result[0],false);
 111             CPPUNIT_ASSERT_EQUAL(3,result[0]->recursiveSize());
 112             delete result[0];
 113           }
 114       }
 115   //clean-up for test2
 116   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef(); e5_4->decrRef(); e4_7->decrRef(); e7_6->decrRef(); e6_5->decrRef();
 117   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef(); n7->decrRef();
 118
 119   //Test with one edge of pol2 is included in pol1.
 120
 121   n1=new Node(0.,0.);                n4=new Node(-0.5,0.);
 122   n2=new Node(1.,0.);                n5=new Node(0.,-1.);
 123   n3=new Node(0.5,1.);               n6=new Node(0.5,0.);
 124   e1_2=new EdgeLin(n1,n2); e2_3=new EdgeLin(n2,n3); e3_1=new EdgeLin(n3,n1);
 125   e4_5=new EdgeLin(n4,n5); e5_6=new EdgeLin(n5,n6); e6_4=new EdgeLin(n6,n4);
 126   for(int k=0;k<2;k++)
 127     for(int i=0;i<3;i++)
 128       {
 129         for(int j=0;j<3;j++)
 130           {
 131             e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_4->incrRef();
 132             QuadraticPolygon pol5; pol5.pushBack(e1_2); pol5.pushBack(e2_3); pol5.pushBack(e3_1);
 133             for(int i1=0;i1<i;i1++) pol5.circularPermute(); if(k==1) pol5.reverse();
 134             QuadraticPolygon pol6; pol6.pushBack(e4_5); pol6.pushBack(e5_6); pol6.pushBack(e6_4);
 135             for(int j1=0;j1<j;j1++) pol6.circularPermute();
 136             result=pol5.intersectMySelfWith(pol6);
 137             CPPUNIT_ASSERT_EQUAL(0,(int)result.size());
 138           }
 139       }
 140   //clean-up test3
 141   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef(); e4_5->decrRef(); e5_6->decrRef(); e6_4->decrRef();
 142   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
 143
 144   //Test of full overlapped polygons.
 145
 146   n1=new Node(0.,0.);                n4=new Node(0.,0.);
 147   n2=new Node(1.,0.);                n5=new Node(1.,0.);
 148   n3=new Node(0.5,1.);               n6=new Node(0.5,1.);
 149   e1_2=new EdgeLin(n1,n2); e2_3=new EdgeLin(n2,n3); e3_1=new EdgeLin(n3,n1);
 150   e4_5=new EdgeLin(n4,n5); e5_6=new EdgeLin(n5,n6); e6_4=new EdgeLin(n6,n4);
 151   for(int k=0;k<2;k++)
 152     for(int i=0;i<3;i++)
 153       {
 154         for(int j=0;j<3;j++)
 155           {
 156             e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_4->incrRef();
 157             QuadraticPolygon pol7; pol7.pushBack(e1_2); pol7.pushBack(e2_3); pol7.pushBack(e3_1);
 158             for(int i1=0;i1<i;i1++) pol7.circularPermute(); if(k==1) pol7.reverse();
 159             QuadraticPolygon pol8; pol8.pushBack(e4_5); pol8.pushBack(e5_6); pol8.pushBack(e6_4);
 160             for(int j1=0;j1<j;j1++) pol8.circularPermute();
 161             result=pol7.intersectMySelfWith(pol8);
 162             CPPUNIT_ASSERT_EQUAL(1,(int)result.size()); checkBasicsOfPolygons(*result[0],*result[0],false);
 163             CPPUNIT_ASSERT_EQUAL(3,result[0]->recursiveSize());
 164             delete result[0];
 165             double tmp1=0.,tmp2=0.,tmp3=0.;
 166             pol7.intersectForPerimeter(pol8,tmp1,tmp2,tmp3);
 167             std::vector<double> v1,v2;
 168             pol7.intersectForPerimeterAdvanced(pol8,v1,v2);//only common edges.
 169             CPPUNIT_ASSERT_DOUBLES_EQUAL(3.2360679774997898,v1[0]+v1[1]+v1[2],1.e-14);
 170             CPPUNIT_ASSERT_DOUBLES_EQUAL(3.2360679774997898,v2[0]+v2[1]+v2[2],1.e-14);
 171             CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,tmp1,1.e-14);
 172             CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,tmp2,1.e-14);
 173             CPPUNIT_ASSERT_DOUBLES_EQUAL(3.2360679774997898,tmp3,1.e-14);
 174           }
 175       }
 176   //clean-up test4
 177   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef(); e4_5->decrRef(); e5_6->decrRef(); e6_4->decrRef();
 178   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
 179
 180   //Test of closing process
 181
 182   n1=new Node(0.,0.);                n4=new Node(0.539,-0.266);
 183   n2=new Node(1.,0.);                n5=new Node(1.039,0.6);
 184   n3=new Node(0.5,1.);               n6=new Node(-0.077,0.667);
 185   e1_2=new EdgeLin(n1,n2); e2_3=new EdgeLin(n2,n3); e3_1=new EdgeLin(n3,n1);
 186   e4_5=new EdgeLin(n4,n5); e5_6=new EdgeLin(n5,n6); e6_4=new EdgeLin(n6,n4);
 187   for(int k=0;k<2;k++)
 188     for(int i=0;i<3;i++)
 189       {
 190         for(int j=0;j<3;j++)
 191           {
 192             e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_4->incrRef();
 193             QuadraticPolygon pol9; pol9.pushBack(e1_2); pol9.pushBack(e2_3); pol9.pushBack(e3_1);
 194             for(int i1=0;i1<i;i1++) pol9.circularPermute(); if(k==1) pol9.reverse();
 195             QuadraticPolygon pol10; pol10.pushBack(e5_6); pol10.pushBack(e6_4); pol10.pushBack(e4_5);
 196             for(int j1=0;j1<j;j1++) pol10.circularPermute();
 197             result=pol9.intersectMySelfWith(pol10);
 198             CPPUNIT_ASSERT_EQUAL(1,(int)result.size()); checkBasicsOfPolygons(*result[0],*result[0],false);
 199             CPPUNIT_ASSERT_EQUAL(6,result[0]->recursiveSize());
 200             delete result[0];
 201           }
 202       }
 203   //clean-up test5
 204   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef(); e4_5->decrRef(); e5_6->decrRef(); e6_4->decrRef();
 205   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
 206
 207   // Full in case
 208
 209   n1=new Node(0.,0.);                n4=new Node(0.3,0.1);
 210   n2=new Node(1.,0.);                n5=new Node(0.7,0.1);
 211   n3=new Node(0.5,1.);               n6=new Node(0.5,0.7);
 212   e1_2=new EdgeLin(n1,n2); e2_3=new EdgeLin(n2,n3); e3_1=new EdgeLin(n3,n1);
 213   e4_5=new EdgeLin(n4,n5); e5_6=new EdgeLin(n5,n6); e6_4=new EdgeLin(n6,n4);
 214   for(int k=0;k<2;k++)
 215     for(int i=0;i<3;i++)
 216       {
 217         for(int j=0;j<3;j++)
 218           {
 219             e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_4->incrRef();
 220             QuadraticPolygon pol11; pol11.pushBack(e1_2); pol11.pushBack(e2_3); pol11.pushBack(e3_1);
 221             for(int i1=0;i1<i;i1++) pol11.circularPermute(); if(k==1) pol11.reverse();
 222             QuadraticPolygon pol12; pol12.pushBack(e5_6); pol12.pushBack(e6_4); pol12.pushBack(e4_5);
 223             for(int j1=0;j1<j;j1++) pol12.circularPermute();
 224             result=pol11.intersectMySelfWith(pol12);
 225             CPPUNIT_ASSERT_EQUAL(1,(int)result.size()); checkBasicsOfPolygons(*result[0],*result[0],false);
 226             CPPUNIT_ASSERT_EQUAL(3,result[0]->recursiveSize());
 227             delete result[0];
 228           }
 229       }
 230   //clean-up test6
 231   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef(); e4_5->decrRef(); e5_6->decrRef(); e6_4->decrRef();
 232   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
 233
 234   // Full out case
 235
 236   n1=new Node(0.,0.);                n4=new Node(-2,0.);
 237   n2=new Node(1.,0.);                n5=new Node(-1.,0.);
 238   n3=new Node(0.5,1.);               n6=new Node(-1.5,1.);
 239   e1_2=new EdgeLin(n1,n2); e2_3=new EdgeLin(n2,n3); e3_1=new EdgeLin(n3,n1);
 240   e4_5=new EdgeLin(n4,n5); e5_6=new EdgeLin(n5,n6); e6_4=new EdgeLin(n6,n4);
 241   for(int k=0;k<2;k++)
 242     for(int i=0;i<3;i++)
 243       {
 244         for(int j=0;j<3;j++)
 245           {
 246             e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_4->incrRef();
 247             QuadraticPolygon pol13; pol13.pushBack(e1_2); pol13.pushBack(e2_3); pol13.pushBack(e3_1);
 248             for(int i1=0;i1<i;i1++) pol13.circularPermute(); if(k==1) pol13.reverse();
 249             QuadraticPolygon pol14; pol14.pushBack(e5_6); pol14.pushBack(e6_4); pol14.pushBack(e4_5);
 250             for(int j1=0;j1<j;j1++) pol14.circularPermute();
 251             result=pol13.intersectMySelfWith(pol14);
 252             CPPUNIT_ASSERT_EQUAL(0,(int)result.size());
 253           }
 254       }
 255   //clean-up test7
 256   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef(); e4_5->decrRef(); e5_6->decrRef(); e6_4->decrRef();
 257   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
 258
 259   //Multi polygons
 260
 261   n1=new Node(0.,0.);
 262   n2=new Node(1.,0.);
 263   n3=new Node(1.,1.);
 264   n4=new Node(0.,1.);
 265   //
 266   n5=new Node(0.2,0.7);
 267   n6=new Node(0.4,0.7);
 268   n7=new Node(0.4,1.3);
 269   Node *n8=new Node(0.6,1.3);
 270   Node *n9=new Node(0.6,0.7);
 271   Node *n10=new Node(0.9,0.7);
 272   Node *n11=new Node(0.9,2.);
 273   Node *n12=new Node(0.2,2.);
 274   //
 275   e1_2=new EdgeLin(n1,n2); e2_3=new EdgeLin(n2,n3); Edge *e3_4=new EdgeLin(n3,n4); Edge *e4_1=new EdgeLin(n4,n1);
 276   e5_6=new EdgeLin(n5,n6); Edge *e6_7=new EdgeLin(n6,n7); Edge *e7_8=new EdgeLin(n7,n8); Edge *e8_9=new EdgeLin(n8,n9); Edge *e9_10=new EdgeLin(n9,n10); Edge *e10_11=new EdgeLin(n10,n11);
 277   Edge *e11_12=new EdgeLin(n11,n12); Edge *e12_1=new EdgeLin(n12,n5);
 278   //
 279   for(int k=0;k<2;k++)
 280     for(int i=0;i<4;i++)
 281       {
 282         for(int j=0;j<8;j++)
 283           {
 284             e1_2->incrRef(); e2_3->incrRef(); e3_4->incrRef(); e4_1->incrRef(); e5_6->incrRef(); e6_7->incrRef(); e7_8->incrRef(); e8_9->incrRef(); e9_10->incrRef(); e10_11->incrRef(); e11_12->incrRef(); e12_1->incrRef();
 285             QuadraticPolygon pol15; pol15.pushBack(e1_2); pol15.pushBack(e2_3); pol15.pushBack(e3_4); pol15.pushBack(e4_1);
 286             for(int i1=0;i1<i;i1++) pol15.circularPermute(); if(k==1) pol15.reverse();
 287             QuadraticPolygon pol16; pol16.pushBack(e5_6); pol16.pushBack(e6_7); pol16.pushBack(e7_8); pol16.pushBack(e8_9); pol16.pushBack(e9_10); pol16.pushBack(e10_11); pol16.pushBack(e11_12); pol16.pushBack(e12_1);
 288             for(int j1=0;j1<j;j1++) pol16.circularPermute();
 289             result=pol15.intersectMySelfWith(pol16);
 290             CPPUNIT_ASSERT_EQUAL(2,(int)result.size());
 291             checkBasicsOfPolygons(*result[0],*result[1],false);
 292             CPPUNIT_ASSERT_EQUAL(4,result[0]->recursiveSize()); CPPUNIT_ASSERT_EQUAL(4,result[1]->recursiveSize());
 293             CPPUNIT_ASSERT_DOUBLES_EQUAL(0.15,result[0]->getArea()+result[1]->getArea(),1e-10);
 294             CPPUNIT_ASSERT_DOUBLES_EQUAL(0.03,fabs(result[0]->getArea()-result[1]->getArea()),1e-10);
 295             CPPUNIT_ASSERT_DOUBLES_EQUAL(0.15,pol15.intersectWith(pol16),1e-10);
 296             delete result[0]; delete result[1];
 297           }
 298       }
 299   //clean-up test8
 300   e1_2->decrRef(); e2_3->decrRef(); e3_4->decrRef(); e4_1->decrRef(); e5_6->decrRef(); e6_7->decrRef(); e7_8->decrRef(); e8_9->decrRef(); e9_10->decrRef(); e10_11->decrRef(); e11_12->decrRef(); e12_1->decrRef();
 301   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef(); n7->decrRef(); n8->decrRef(); n9->decrRef(); n10->decrRef(); n11->decrRef(); n12->decrRef();
 302 }
 303
 304 /*!
 305  * Testing case where a polygon pol1 is included in an onother polygon pol2.
 306  */
 307 void QuadraticPlanarInterpTest::checkPolygonsIntersection2()
 308 {
 309   Node *n1=new Node(0.,0.);          Node *n4=new Node(0.2,0.2);
 310   Node *n2=new Node(1.,0.);          Node *n5=new Node(0.8,0.2);
 311   Node *n3=new Node(0.5,1.);         Node *n6=new Node(0.5,0.8);
 312   Edge *e1_2=new EdgeLin(n1,n2);     Edge *e4_5=new EdgeLin(n4,n5);
 313   Edge *e2_3=new EdgeLin(n2,n3);     Edge *e5_6=new EdgeLin(n5,n6);
 314   Edge *e3_1=new EdgeLin(n3,n1);     Edge *e6_4=new EdgeLin(n6,n4);
 315   //
 316   QuadraticPolygon pol1; pol1.pushBack(e1_2); pol1.pushBack(e2_3); pol1.pushBack(e3_1);
 317   QuadraticPolygon pol2; pol2.pushBack(e4_5); pol2.pushBack(e5_6); pol2.pushBack(e6_4);
 318   std::vector<QuadraticPolygon *> result=pol1.intersectMySelfWith(pol2);
 319   CPPUNIT_ASSERT_EQUAL(1,(int)result.size());
 320   CPPUNIT_ASSERT_EQUAL(3,result[0]->recursiveSize());
 321   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.18,result[0]->getArea(),1e-10);
 322   delete result[0];
 323   result.clear();
 324   pol1.initLocations();
 325   pol2.initLocations();
 326   result=pol2.intersectMySelfWith(pol1);
 327   CPPUNIT_ASSERT_EQUAL(1,(int)result.size());
 328   CPPUNIT_ASSERT_EQUAL(3,result[0]->recursiveSize());
 329   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.18,result[0]->getArea(),1e-10);
 330   delete result[0];
 331   //clean-up
 332   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
 333 }
 334
 335 void QuadraticPlanarInterpTest::checkAreasCalculations()
 336 {
 337   Node *n1=new Node(0.,0.);
 338   Node *n2=new Node(1.,0.);
 339   Node *n3=new Node(0.5,1.);
 340   Edge *e1_2=new EdgeLin(n1,n2);
 341   Edge *e2_3=new EdgeLin(n2,n3);
 342   Edge *e3_1=new EdgeLin(n3,n1);
 343   //
 344   e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef();
 345   QuadraticPolygon pol1; pol1.pushBack(e1_2); pol1.pushBack(e2_3); pol1.pushBack(e3_1);
 346   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.5,pol1.getArea(),1e-10);
 347   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.2360679774997898,pol1.getPerimeter(),1e-10);
 348   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.61803398874989479,pol1.getHydraulicDiameter(),1e-10);
 349   pol1.reverse();
 350   CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.5,pol1.getArea(),1e-10);
 351   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.2360679774997898,pol1.getPerimeter(),1e-10);
 352   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.61803398874989479,pol1.getHydraulicDiameter(),1e-10);
 353   //clean-up
 354   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef();
 355   n1->decrRef(); n2->decrRef(); n3->decrRef();
 356
 357   //case 2
 358
 359   n1=new Node(0.,0.);
 360   n2=new Node(1.,0.);
 361   Node *n3m=new Node(1.5,0.5);
 362   n3=new Node(1.,1.);
 363   Node *n4=new Node(0.,1.);
 364   e1_2=new EdgeLin(n1,n2);
 365   e2_3=new EdgeArcCircle(n2,n3m,n3);
 366   Edge *e3_4=new EdgeLin(n3,n4);
 367   Edge *e4_1=new EdgeLin(n4,n1);
 368   //
 369   for(int k=0;k<8;k++)
 370     {
 371       n2->setNewCoords(cos(k*M_PI/4),sin(k*M_PI/4));
 372       n3->setNewCoords(sqrt(2.)*cos((k+1)*M_PI/4),sqrt(2.)*sin((k+1)*M_PI/4));
 373       n3m->setNewCoords(1.5811388300841898*cos(0.3217505543966423+k*M_PI/4),1.5811388300841898*sin(0.3217505543966423+k*M_PI/4));
 374       n4->setNewCoords(cos(k*M_PI/4+M_PI/2),sin(k*M_PI/4+M_PI/2));
 375       e1_2->update(n3m); e2_3->update(n3m); e3_4->update(n3m); e4_1->update(n3m);
 376       e1_2->incrRef(); e2_3->incrRef(); e3_4->incrRef(); e4_1->incrRef();
 377       QuadraticPolygon pol2; pol2.pushBack(e1_2); pol2.pushBack(e2_3); pol2.pushBack(e3_4); pol2.pushBack(e4_1);
 378       CPPUNIT_ASSERT_DOUBLES_EQUAL(1.3926990816987241,pol2.getArea(),1e-6);
 379       CPPUNIT_ASSERT_DOUBLES_EQUAL(4.5707963267948966,pol2.getPerimeter(),1e-6);
 380       pol2.reverse();
 381       CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.3926990816987241,pol2.getArea(),1e-6);
 382       CPPUNIT_ASSERT_DOUBLES_EQUAL(4.5707963267948966,pol2.getPerimeter(),1e-6);
 383     }
 384   //clean-up case2
 385   e1_2->decrRef(); e2_3->decrRef(); e3_4->decrRef(); e4_1->decrRef();
 386   n1->decrRef(); n2->decrRef(); n3->decrRef(); n3m->decrRef(); n4->decrRef();
 387
 388   //case 3
 389
 390   const double radius1=0.7;
 391   const double radius2=0.9;
 392   n1=new Node(1.+radius1*cos(-2.*M_PI/3.),1.+radius1*sin(-2.*M_PI/3.));
 393   n2=new Node(1.+radius1*cos(-M_PI/3.),1.+radius1*sin(-M_PI/3.));
 394   Node *n2m=new Node(1.+radius1*cos(M_PI/2.),1.+radius1*sin(M_PI/2.));
 395   n3=new Node(1.+radius2*cos(-M_PI/3.),1.+radius2*sin(-M_PI/3.));
 396   n3m=new Node(1.+radius2*cos(M_PI/2.),1.+radius2*sin(M_PI/2.));
 397   n4=new Node(1.+radius2*cos(-2.*M_PI/3.),1.+radius2*sin(-2.*M_PI/3.));
 398   e1_2=new EdgeArcCircle(n1,n2m,n2);
 399   e2_3=new EdgeLin(n2,n3);
 400   e3_4=new EdgeArcCircle(n3,n3m,n4);
 401   e4_1=new EdgeLin(n4,n1);
 402   //
 403   e1_2->incrRef(); e2_3->incrRef(); e3_4->incrRef(); e4_1->incrRef();
 404   QuadraticPolygon pol3; pol3.pushBack(e1_2); pol3.pushBack(e2_3); pol3.pushBack(e3_4); pol3.pushBack(e4_1);
 405   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.83775804095727857,pol3.getArea(),1e-10);
 406   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.7775804095727832,pol3.getPerimeter(),1e-10);
 407   pol3.reverse();
 408   CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.83775804095727857,pol3.getArea(),1e-10);
 409   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.7775804095727832,pol3.getPerimeter(),1e-10);
 410   //clean-up case3
 411   e1_2->decrRef(); e2_3->decrRef(); e3_4->decrRef(); e4_1->decrRef();
 412   n1->decrRef(); n2->decrRef(); n2m->decrRef(); n3->decrRef(); n3m->decrRef(); n4->decrRef();
 413 }
 414
 415 void QuadraticPlanarInterpTest::checkBarycenterCalculations()
 416 {
 417   Node *n1=new Node(3.,7.);
 418   Node *n2=new Node(5.,7.);
 419   Node *n3=new Node(4.,8.);
 420   Edge *e1_2=new EdgeLin(n1,n2);
 421   Edge *e2_3=new EdgeLin(n2,n3);
 422   Edge *e3_1=new EdgeLin(n3,n1);
 423   //
 424   double bary[2];
 425   e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef();
 426   QuadraticPolygon pol1; pol1.pushBack(e1_2); pol1.pushBack(e2_3); pol1.pushBack(e3_1);
 427   bary[0]=0.; bary[1]=0.;
 428   e1_2->getBarycenterOfZone(bary);
 429   CPPUNIT_ASSERT_DOUBLES_EQUAL(-56.,bary[0],1.e-10);
 430   bary[0]=0.; bary[1]=0.;
 431   e2_3->getBarycenterOfZone(bary);
 432   CPPUNIT_ASSERT_DOUBLES_EQUAL(33.66666666666667,bary[0],1.e-10);
 433   CPPUNIT_ASSERT_DOUBLES_EQUAL(28.16666666666667,bary[1],1.e-10);
 434   bary[0]=0.; bary[1]=0.;
 435   e3_1->getBarycenterOfZone(bary);
 436   CPPUNIT_ASSERT_DOUBLES_EQUAL(26.333333333333336,bary[0],1.e-10);
 437   CPPUNIT_ASSERT_DOUBLES_EQUAL(28.1666666666667,bary[1],1.e-10);
 438   CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,pol1.getArea(),1e-10);
 439   pol1.getBarycenter(bary);
 440   CPPUNIT_ASSERT_DOUBLES_EQUAL(4.,bary[0],1.e-10);
 441   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.333333333333333,bary[1],1.e-10);
 442   //
 443   e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef();
 444   QuadraticPolygon pol4; pol4.pushBack(e3_1,false); pol4.pushBack(e2_3,false); pol4.pushBack(e1_2,false);
 445   CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.,pol4.getArea(),1e-10);
 446   pol4.getBarycenter(bary);
 447   CPPUNIT_ASSERT_DOUBLES_EQUAL(4.,bary[0],1.e-10);
 448   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.333333333333333,bary[1],1.e-10);
 449   //clean-up
 450   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef();
 451   n1->decrRef(); n2->decrRef(); n3->decrRef();
 452   //Inverting polygon
 453   n1=new Node(3.,7.);
 454   n2=new Node(5.,7.);
 455   n3=new Node(4.,8.);
 456   e1_2=new EdgeLin(n1,n3);
 457   e2_3=new EdgeLin(n3,n2);
 458   e3_1=new EdgeLin(n2,n1);
 459   e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef();
 460   QuadraticPolygon pol3; pol3.pushBack(e1_2); pol3.pushBack(e2_3); pol3.pushBack(e3_1);
 461   bary[0]=0.; bary[1]=0.;
 462   pol3.getBarycenter(bary);
 463   CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.,pol3.getArea(),1e-10);
 464   CPPUNIT_ASSERT_DOUBLES_EQUAL(4.,bary[0],1.e-10);
 465   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.333333333333333,bary[1],1.e-10);
 466   //clean-up
 467   e1_2->decrRef(); e2_3->decrRef(); e3_1->decrRef();
 468   n1->decrRef(); n2->decrRef(); n3->decrRef();
 469   //
 470   double center[2]={3.,7.};
 471   e1_2=buildArcOfCircle(center,4.,M_PI/3.,4.*M_PI/3.);
 472   bary[0]=0.; bary[1]=0.;
 473   e1_2->getBarycenterOfZone(bary);
 474   CPPUNIT_ASSERT_DOUBLES_EQUAL(131.685410765053,bary[0],1.e-10);
 475   CPPUNIT_ASSERT_DOUBLES_EQUAL(303.262521934362,bary[1],1.e-10);
 476   n1=new Node(0.99999999999999822,3.5358983848622465);
 477   n2=new Node(5.,10.4641016151377544);
 478   Edge *e2_1=new EdgeLin(n1,n2);
 479   //
 480   e1_2->incrRef(); e2_1->incrRef();
 481   QuadraticPolygon pol2; pol2.pushBack(e1_2); pol2.pushBack(e2_1);
 482   pol2.getBarycenter(bary);
 483   CPPUNIT_ASSERT_DOUBLES_EQUAL(25.132741228718345,pol2.getArea(),1e-10);
 484   //4*radius/(3.*pi)
 485   CPPUNIT_ASSERT_DOUBLES_EQUAL(1.5297896122085546,bary[0],1.e-10);
 486   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.8488263631567756,bary[1],1.e-10);
 487   //clean-up
 488   e1_2->decrRef(); e2_1->decrRef();
 489   n1->decrRef(); n2->decrRef();
 490 }
 491
 492 /*!
 493  * Testing user interface high level function.
 494  */
 495 void QuadraticPlanarInterpTest::checkHighLevelFunctionTest1()
 496 {
 497   QUADRATIC_PLANAR::setPrecision(1e-12);
 498   QUADRATIC_PLANAR::setArcDetectionPrecision(1e-9);
 499   double coords[]={
 500     8.8334591186000004, 5.0999999999999996,
 501     7.1014083111000001, 6.0999999999999996,
 502     7.8334591186000004, 6.8320508074999999,
 503     7.9674337149000003, 5.5999999999999996,
 504     7.4192455562999999, 6.5142135623000001,
 505     8.3334591186000004, 5.9660254036999998
 506   };
 507   std::vector<Node *> nodes;
 508   nodes.push_back(new Node(coords));
 509   nodes.push_back(new Node(coords+2));
 510   nodes.push_back(new Node(coords+4));
 511   nodes.push_back(new Node(coords+6));
 512   nodes.push_back(new Node(coords+8));
 513   nodes.push_back(new Node(coords+10));
 514   QuadraticPolygon *pol=QuadraticPolygon::BuildArcCirclePolygon(nodes);
 515   CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.04719755,pol->getArea(),1e-5);
 516   CPPUNIT_ASSERT_EQUAL(3,pol->size());
 517   ElementaryEdge *e0=dynamic_cast<ElementaryEdge *>((*pol)[0]);
 518   ElementaryEdge *e1=dynamic_cast<ElementaryEdge *>((*pol)[1]);
 519   ElementaryEdge *e2=dynamic_cast<ElementaryEdge *>((*pol)[0]);
 520   CPPUNIT_ASSERT(e0); CPPUNIT_ASSERT(e1); CPPUNIT_ASSERT(e2);
 521   CPPUNIT_ASSERT(dynamic_cast<EdgeLin *>(e0->getPtr()));//<- testing detection of colinearity
 522   CPPUNIT_ASSERT(dynamic_cast<EdgeArcCircle *>(e1->getPtr()));
 523   CPPUNIT_ASSERT(dynamic_cast<EdgeLin *>(e2->getPtr()));//<- testing detection of colinearity
 524   nodes.clear();
 525   delete pol;
 526   nodes.push_back(new Node(coords));
 527   nodes.push_back(new Node(coords+4));
 528   nodes.push_back(new Node(coords+2));
 529   nodes.push_back(new Node(coords+10));
 530   nodes.push_back(new Node(coords+8));
 531   nodes.push_back(new Node(coords+6));
 532   pol=QuadraticPolygon::BuildArcCirclePolygon(nodes);
 533   CPPUNIT_ASSERT_DOUBLES_EQUAL(1.04719755,pol->getArea(),1e-5);
 534   CPPUNIT_ASSERT_EQUAL(3,pol->size());
 535   e0=dynamic_cast<ElementaryEdge *>((*pol)[0]);
 536   e1=dynamic_cast<ElementaryEdge *>((*pol)[1]);
 537   e2=dynamic_cast<ElementaryEdge *>((*pol)[0]);
 538   CPPUNIT_ASSERT(e0); CPPUNIT_ASSERT(e1); CPPUNIT_ASSERT(e2);
 539   CPPUNIT_ASSERT(dynamic_cast<EdgeLin *>(e0->getPtr()));//<- testing detection of colinearity
 540   CPPUNIT_ASSERT(dynamic_cast<EdgeArcCircle *>(e1->getPtr()));
 541   CPPUNIT_ASSERT(dynamic_cast<EdgeLin *>(e2->getPtr()));//<- testing detection of colinearity
 542   delete pol;
 543   const double coords2[]={
 544     0.,0.,
 545     1.5,0.,
 546     1.5,1.,
 547     0.,1.
 548   };
 549   nodes.clear();
 550   nodes.push_back(new Node(coords2));
 551   nodes.push_back(new Node(coords2+2));
 552   nodes.push_back(new Node(coords2+4));
 553   nodes.push_back(new Node(coords2+6));
 554   pol=QuadraticPolygon::BuildLinearPolygon(nodes);
 555   CPPUNIT_ASSERT_DOUBLES_EQUAL(1.5,pol->getArea(),1e-12);
 556   double tmp[2],tmp2;
 557   pol->getBarycenter(tmp,tmp2);
 558   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.75,tmp[0],1e-12);
 559   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.5,tmp[1],1e-12);
 560   delete pol;
 561   const double coords3[]={
 562     1.0999999999000001, -1.9052558882999999,
 563     1.9052558881999999, -1.0999999999000001,
 564     1.7320508075000001, -0.99999999989999999,
 565     0.99999999989999999, -1.7320508075000001,
 566     1.5556349186, -1.5556349185,
 567     1.8186533478, -1.0499999999,
 568     1.4142135623000001, -1.4142135623000001,
 569     1.0499999999, -1.8186533479
 570   };
 571   nodes.clear();
 572   nodes.push_back(new Node(coords3));
 573   nodes.push_back(new Node(coords3+2));
 574   nodes.push_back(new Node(coords3+4));
 575   nodes.push_back(new Node(coords3+6));
 576   nodes.push_back(new Node(coords3+8));
 577   nodes.push_back(new Node(coords3+10));
 578   nodes.push_back(new Node(coords3+12));
 579   nodes.push_back(new Node(coords3+14));
 580   pol=QuadraticPolygon::BuildArcCirclePolygon(nodes);
 581   pol->getBarycenter(tmp,tmp2);
 582   delete pol;
 583   QUADRATIC_PLANAR::setPrecision(1e-14);
 584 }
 585
 586 void QuadraticPlanarInterpTest::check1DInterpLin()
 587 {
 588   QUADRATIC_PLANAR::setPrecision(1e-7);
 589   QUADRATIC_PLANAR::setArcDetectionPrecision(1e-9);
 590   const int NB_OF_CELL_AXIAL_1=30;
 591   static const double Z_VALS_1[NB_OF_CELL_AXIAL_1+1]=
 592     { -0.1550 , -0.1356, -0.1162, -0.0969, -0.0775 ,-0.0581, -0.0387, -0.0194,  0.0000 , 0.0500,
 593       0.1000 , 0.1500 , 0.2000 , 0.2500,  0.3000,  0.3500,  0.4000,  0.4500,  0.5000,  0.5500,
 594       0.6000,  0.6500,  0.7000,  0.7194,  0.7388,  0.7581,  0.7775,  0.7969,  0.8163,  0.8356,
 595       0.8550};
 596   std::vector<double> zLev1(Z_VALS_1,Z_VALS_1+NB_OF_CELL_AXIAL_1+1);
 597
 598   const int NB_OF_CELL_AXIAL_2=46;
 599   static const double Z_VALS_2[NB_OF_CELL_AXIAL_2+1]=
 600     { -0.3050 ,-0.2863,-0.2675,-0.2488,-0.2300,-0.2113,-0.1925,-0.1738,-0.1550,-0.1356
 601       , -0.1162,-0.0969,-0.0775,-0.0581,-0.0387,-0.0194,0.0000, 0.0500, 0.1 ,0.15
 602       ,  0.20,  0.25, 0.30, 0.350 ,0.40 ,0.450 ,0.500 , 0.550, 0.600 ,0.650 ,0.700
 603       , 0.7194 ,0.7388 ,0.7581 ,0.7775 ,0.7969 ,0.8163 ,0.8356, 0.8550
 604       ,  0.8738 ,0.8925 ,0.9113 ,0.9300 ,0.9488 ,0.9675 ,0.9863, 1.0050};
 605   std::vector<double> zLev2(Z_VALS_2,Z_VALS_2+NB_OF_CELL_AXIAL_2+1);
 606   std::map<int,std::map<int,double> > m;
 607   Edge::Interpolate1DLin(zLev1,zLev2,m);
 608   CPPUNIT_ASSERT_EQUAL(30,(int)m.size());
 609   double ret=0;
 610   for(int i=0;i<30;i++)
 611     {
 612       CPPUNIT_ASSERT_EQUAL(1,(int)m[i].size());
 613       CPPUNIT_ASSERT(m[i][8+i] > 0.15);
 614       ret+=m[i][8+i];
 615     }
 616   CPPUNIT_ASSERT_DOUBLES_EQUAL(ret,30.,1e-12);
 617   //
 618   m.clear();
 619   const int NB_OF_CELL_AXIAL_3=13;
 620   static const double Z_VALS_3[NB_OF_CELL_AXIAL_3+1]={
 621     0.,0.01,0.05,0.10,0.15,0.20,0.25,0.30,
 622     0.35,0.40,0.45,0.50,0.55,0.60 };
 623   std::vector<double> zLev3(Z_VALS_3,Z_VALS_3+NB_OF_CELL_AXIAL_3+1);
 624   Edge::Interpolate1DLin(zLev3,zLev1,m);
 625   CPPUNIT_ASSERT_EQUAL(13,(int)m.size());
 626   CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,m[0][8],1e-12);
 627   CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,m[1][8],1e-12);
 628   for(int i=0;i<11;i++)
 629     {
 630       CPPUNIT_ASSERT_EQUAL(1,(int)m[i+2].size());
 631       CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,m[i+2][i+9],1e-12);
 632     }
 633   QUADRATIC_PLANAR::setPrecision(1e-14);
 634 }
 635
 636 /*!
 637  * This test looks if intersectors are in coherency.
 638  */
 639 void QuadraticPlanarInterpTest::checkEpsilonCoherency1()
 640 {
 641   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-12);
 642   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-5);
 643
 644   const double pol1[]={
 645     -2.1083388455000001, 1.2172499999999999,
 646     -1.7320508075000001, 1,
 647     -1.9201948265, 1.108625
 648   };
 649
 650   const double pol2[]={
 651     -2.2379999998, 0,
 652     -1.9381648534, 1.1189999998,
 653     -2.1617419990000002, 0.57923702298000002,
 654     -1.9381648534, 1.1189999998,
 655     -1.9909924031999999, 1.1494999999,
 656     -1.9645786283, 1.1342499998
 657   };
 658   //
 659   Node *n1=new Node(pol1[0],pol1[1]);
 660   Node *n2=new Node(pol1[2],pol1[3]);
 661   Node *n3;
 662   //
 663   Edge *e1=new EdgeLin(n1,n2); n1->decrRef(); n2->decrRef();
 664   n1=new Node(pol2[0],pol2[1]);
 665   n2=new Node(pol2[4],pol2[5]);
 666   n3=new Node(pol2[2],pol2[3]);
 667   Edge *e2=new EdgeArcCircle(n1,n2,n3); n1->decrRef(); n2->decrRef(); n3->decrRef();
 668   e2->decrRef();
 669   e1->decrRef();
 670 }
 671
 672 /*!
 673  * Tests to avoid regressions : Basic one.
 674  */
 675 void QuadraticPlanarInterpTest::checkNonRegression1()
 676 {
 677   const double coords1[]=
 678     {
 679       16.1732057215, -25.110999999800001,
 680       16.02555485246479, -25.340997988918762
 681     };
 682   Node *nS1=new Node(coords1);
 683   Node *nE1=new Node(coords1+2);
 684   const double radius1=2.902;
 685   const double angleS1=-0.49999999950907054; const double angleL1=-0.0942156629996692;
 686   const double center1[2]={13.66, -23.66};
 687   EdgeArcCircle *e1=new EdgeArcCircle(nS1,nE1,center1,radius1,angleS1,angleL1);
 688   //
 689   const double coords2[]=
 690     {
 691       16.041579804000001, -25.350249998999999,
 692       16.367740958999999, -24.132999999999999
 693     };
 694   Node *nS2=new Node(coords2);
 695   Node *nE2=new Node(coords2+2);
 696   const double radius2=2.4345;
 697   const double angleS2=-0.523598776190207; const double angleL2=0.5235987755846041;
 698   const double center2[]={ 13.933240960547204, -24.132999998525658 };
 699   EdgeArcCircle *e2=new EdgeArcCircle(nS2,nE2,center2,radius2,angleS2,angleL2);
 700   MergePoints merge;
 701   QuadraticPolygon c1,c2;
 702   e1->intersectWith(e2,merge,c1,c2);
 703   CPPUNIT_ASSERT_EQUAL(2,c1.size()); CPPUNIT_ASSERT_EQUAL(2,c2.size());
 704   CPPUNIT_ASSERT_DOUBLES_EQUAL(e1->getCurveLength(),c1.getPerimeter(),1e-5);
 705   //clean-up
 706   nS1->decrRef(); nE1->decrRef(); nS2->decrRef(); nE2->decrRef(); e1->decrRef(); e2->decrRef();
 707 }
 708
 709 void QuadraticPlanarInterpTest::checkNonRegression2()
 710 {
 711   QUADRATIC_PLANAR::setPrecision(1e-12);
 712   QUADRATIC_PLANAR::setArcDetectionPrecision(1e-9);
 713   double coords1[]=
 714     {
 715       15.141499999899999, -26.226033271399999,
 716       16.226033271199999, -25.141499999800001,
 717       16.1732057215, -25.110999999800001,
 718       15.110999999899999, -26.1732057217,
 719       15.755157392699999, -25.755157392499999,
 720       16.199619496299999, -25.126249999799999,
 721       15.7120238788, -25.712023879099998,
 722       15.126249999899999, -26.199619496499999
 723     };
 724   double coords2[]=
 725     {
 726       15.933240959000001, -24.132999999999999,
 727       15.665291765999999, -25.132999998999999,
 728       16.041579804000001, -25.350249998999999,
 729       16.367740958999999, -24.132999999999999,
 730       15.865092611, -24.650638091000001,
 731       15.853435785, -25.241624998999999,
 732       16.284787383000001, -24.763094964,
 733       16.150490958999999, -24.132999999999999
 734     };
 735   std::vector<Node *> nodes1;
 736   nodes1.push_back(new Node(coords1));
 737   nodes1.push_back(new Node(coords1+2));
 738   nodes1.push_back(new Node(coords1+4));
 739   nodes1.push_back(new Node(coords1+6));
 740   nodes1.push_back(new Node(coords1+8));
 741   nodes1.push_back(new Node(coords1+10));
 742   nodes1.push_back(new Node(coords1+12));
 743   nodes1.push_back(new Node(coords1+14));
 744   QuadraticPolygon *pol1=QuadraticPolygon::BuildArcCirclePolygon(nodes1);
 745   std::vector<Node *> nodes2;
 746   nodes2.push_back(new Node(coords2));
 747   nodes2.push_back(new Node(coords2+2));
 748   nodes2.push_back(new Node(coords2+4));
 749   nodes2.push_back(new Node(coords2+6));
 750   nodes2.push_back(new Node(coords2+8));
 751   nodes2.push_back(new Node(coords2+10));
 752   nodes2.push_back(new Node(coords2+12));
 753   nodes2.push_back(new Node(coords2+14));
 754   QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
 755   std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
 756   CPPUNIT_ASSERT_EQUAL(1,(int)v.size());
 757   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.00173945,v[0]->getArea(),1e-7);
 758   delete v[0];
 759   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.00173945,pol1->intersectWith(*pol2),1e-7);
 760   delete pol1;
 761   delete pol2;
 762 }
 763
 764 /*!
 765  * Tests to avoid regressions : Basic one.
 766  */
 767 void QuadraticPlanarInterpTest::checkNonRegression3()
 768 {
 769   const double coords1[]=
 770     {
 771       10.962340811000001, -22.417749999000002,
 772       12.217990959, -21.162099852000001
 773     };
 774   Node *nS1=new Node(coords1);
 775   Node *nE1=new Node(coords1+2);
 776   const double radius1=3.4304999897666599;
 777   const double angleS1=2.6179938783536514; const double angleL1=-0.52359877711901204;
 778   const double center1[2]={13.933240950441375, -24.132999992807399};
 779   EdgeArcCircle *e1=new EdgeArcCircle(nS1,nE1,center1,radius1,angleS1,angleL1);
 780   //
 781   const double coords2[]=
 782     {
 783       11.1467942784, -22.2090000002,
 784       11.0939667286, -22.178500000099998
 785     };
 786   Node *nS2=new Node(coords2);
 787   Node *nE2=new Node(coords2+2);
 788   EdgeLin *e2=new EdgeLin(nS2,nE2);
 789   MergePoints merge;
 790   QuadraticPolygon c1,c2;
 791   CPPUNIT_ASSERT(e1->intersectWith(e2,merge,c1,c2));
 792   CPPUNIT_ASSERT_EQUAL(2,c1.size());
 793   CPPUNIT_ASSERT_EQUAL(2,c2.size());
 794   ElementaryEdge *tmp1=dynamic_cast<ElementaryEdge *>(c1.front()); CPPUNIT_ASSERT(tmp1);
 795   EdgeArcCircle *tmp2=dynamic_cast<EdgeArcCircle *>(tmp1->getPtr()); CPPUNIT_ASSERT(tmp2);
 796   CPPUNIT_ASSERT_DOUBLES_EQUAL(2.6179938783536514,tmp2->getAngle0(),1e-14);
 797   //clean-up
 798   nS1->decrRef(); nE1->decrRef(); nS2->decrRef(); nE2->decrRef(); e1->decrRef(); e2->decrRef();
 799 }
 800
 801 void QuadraticPlanarInterpTest::checkNonRegression4()
 802 {
 803   QUADRATIC_PLANAR::setPrecision(1e-12);
 804   QUADRATIC_PLANAR::setArcDetectionPrecision(1e-9);
 805   double coords1[]=
 806     {
 807       10.962340811000001, -22.417749999000002,
 808       12.217990959, -21.162099852000001,
 809       12.051990958999999, -20.874579418,
 810       10.674820377, -22.251749999000001,
 811       11.507511146000001, -21.707270185999999,
 812       12.134990959, -21.018339635,
 813       11.272751694, -21.472510735,
 814       10.818580594, -22.334749999
 815     };
 816
 817   double coords2[]=
 818     {
 819       10.758000000199999, -23.66,
 820       11.1467942784, -22.2090000002,
 821       11.0939667286, -22.178500000099998,
 822       10.696999999999999, -23.66,
 823       10.856883252299999, -22.908907131159999,
 824       11.1203805035, -22.1937500001,
 825       10.797961776699999, -22.893119169449999,
 826       10.727500000099999, -23.66
 827     };
 828   std::vector<Node *> nodes1;
 829   nodes1.push_back(new Node(coords1));
 830   nodes1.push_back(new Node(coords1+2));
 831   nodes1.push_back(new Node(coords1+4));
 832   nodes1.push_back(new Node(coords1+6));
 833   nodes1.push_back(new Node(coords1+8));
 834   nodes1.push_back(new Node(coords1+10));
 835   nodes1.push_back(new Node(coords1+12));
 836   nodes1.push_back(new Node(coords1+14));
 837   QuadraticPolygon *pol1=QuadraticPolygon::BuildArcCirclePolygon(nodes1);
 838   std::vector<Node *> nodes2;
 839   nodes2.push_back(new Node(coords2));
 840   nodes2.push_back(new Node(coords2+2));
 841   nodes2.push_back(new Node(coords2+4));
 842   nodes2.push_back(new Node(coords2+6));
 843   nodes2.push_back(new Node(coords2+8));
 844   nodes2.push_back(new Node(coords2+10));
 845   nodes2.push_back(new Node(coords2+12));
 846   nodes2.push_back(new Node(coords2+14));
 847   QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
 848   std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
 849   CPPUNIT_ASSERT_EQUAL(1,(int)v.size());
 850   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.00164773941455998,v[0]->getArea(),1e-7);
 851   delete v[0];
 852   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.00164773941455998,pol1->intersectWith(*pol2),1e-7);
 853   delete pol1;
 854   delete pol2;
 855 }
 856
 857 void QuadraticPlanarInterpTest::checkNonRegression5()
 858 {
 859   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-12);
 860   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-5);
 861   double coords1[]=
 862     {
 863       -1.7320508075000001, 1,
 864       -1, 1.7320508075000001 ,
 865       -1.2172499999999999, 2.1083388455000001,
 866       -2.1083388455000001, 1.2172499999999999,
 867       -1.4142135623000001, 1.4142135623000001,
 868       -1.108625, 1.9201948265,
 869       -1.7214514588000001, 1.7214514588000001,
 870       -1.9201948265, 1.108625};
 871
 872   double coords2[]=
 873     {
 874       -2.2379999998, 0,
 875       -1.9381648534, 1.1189999998,
 876       -1.9909924031999999, 1.1494999999,
 877       -2.2989999998999999, 0,
 878       -2.1617419990000002, 0.57923702298000002,
 879       -1.9645786283, 1.1342499998,
 880       -2.2206634745999998, 0.59502498461999997,
 881       -2.2684999997999999, 0};
 882   //Edge1_of_pol2 inter Edge4_of_pol1 = {-1.9381648533711939, 1.1189999998498941}
 883   //Edge4_of_pol1 _angle = -0.523598775922546, _angle0 = -3.1415926535897931, _radius = 2.2379999983074721, _center = {-1.4925279436059493e-09, 1.3300635705141101e-10}}
 884   std::vector<Node *> nodes1;
 885   nodes1.push_back(new Node(coords1));
 886   nodes1.push_back(new Node(coords1+2));
 887   nodes1.push_back(new Node(coords1+4));
 888   nodes1.push_back(new Node(coords1+6));
 889   nodes1.push_back(new Node(coords1+8));
 890   nodes1.push_back(new Node(coords1+10));
 891   nodes1.push_back(new Node(coords1+12));
 892   nodes1.push_back(new Node(coords1+14));
 893   QuadraticPolygon *pol1=QuadraticPolygon::BuildArcCirclePolygon(nodes1);
 894   std::vector<Node *> nodes2;
 895   nodes2.push_back(new Node(coords2));
 896   nodes2.push_back(new Node(coords2+2));
 897   nodes2.push_back(new Node(coords2+4));
 898   nodes2.push_back(new Node(coords2+6));
 899   nodes2.push_back(new Node(coords2+8));
 900   nodes2.push_back(new Node(coords2+10));
 901   nodes2.push_back(new Node(coords2+12));
 902   nodes2.push_back(new Node(coords2+14));
 903   QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
 904   std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
 905   CPPUNIT_ASSERT_EQUAL(0,(int)v.size());
 906   //CPPUNIT_ASSERT_DOUBLES_EQUAL(0.00164773941455998,v[0]->getArea(),1e-7);
 907   //delete v[0];
 908   //CPPUNIT_ASSERT_DOUBLES_EQUAL(0.00164773941455998,pol1->intersectWith(*pol2),1e-7);
 909   delete pol1;
 910   delete pol2;
 911 }
 912
 913 void QuadraticPlanarInterpTest::checkNonRegression6()
 914 {
 915   QUADRATIC_PLANAR::setPrecision(1e-12);
 916   QUADRATIC_PLANAR::setArcDetectionPrecision(1e-5);
 917   double coords1[]=
 918     {
 919       10.962340811000001, -22.417749999000002,
 920       12.217990959, -21.162099852000001,
 921       12.051990958999999, -20.874579418,
 922       10.674820377, -22.251749999000001,
 923       11.507511146000001, -21.707270185999999,
 924       12.134990959, -21.018339635,
 925       11.272751694, -21.472510735,
 926       10.818580594, -22.334749999
 927     };
 928   double coords2[]=
 929     { 10.426, -23.66,
 930       10.859273844199999, -22.043000000100001,
 931       10.806446294799999, -22.012500000199999,
 932       10.3650000002, -23.66,
 933       10.536195877799999, -22.822979208099998,
 934       10.832860069499999, -22.027750000200001,
 935       10.477274402499999, -22.80719124657,
 936       10.3955000001, -23.66};
 937   std::vector<Node *> nodes1;
 938   nodes1.push_back(new Node(coords1));
 939   nodes1.push_back(new Node(coords1+2));
 940   nodes1.push_back(new Node(coords1+4));
 941   nodes1.push_back(new Node(coords1+6));
 942   nodes1.push_back(new Node(coords1+8));
 943   nodes1.push_back(new Node(coords1+10));
 944   nodes1.push_back(new Node(coords1+12));
 945   nodes1.push_back(new Node(coords1+14));
 946   QuadraticPolygon *pol1=QuadraticPolygon::BuildArcCirclePolygon(nodes1);
 947   std::vector<Node *> nodes2;
 948   nodes2.push_back(new Node(coords2));
 949   nodes2.push_back(new Node(coords2+2));
 950   nodes2.push_back(new Node(coords2+4));
 951   nodes2.push_back(new Node(coords2+6));
 952   nodes2.push_back(new Node(coords2+8));
 953   nodes2.push_back(new Node(coords2+10));
 954   nodes2.push_back(new Node(coords2+12));
 955   nodes2.push_back(new Node(coords2+14));
 956   QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
 957   std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
 958   CPPUNIT_ASSERT_EQUAL(1,(int)v.size());
 959   CPPUNIT_ASSERT_DOUBLES_EQUAL(v[0]->getArea(),0.0150659,1e-7);
 960   delete v[0];
 961   delete pol1;
 962   delete pol2;
 963 }
 964
 965 void QuadraticPlanarInterpTest::checkNonRegression7()
 966 {
 967   QUADRATIC_PLANAR::setPrecision(1e-5);
 968   QUADRATIC_PLANAR::setArcDetectionPrecision(1e-5);
 969   double coords1[]=
 970     {
 971       -2., 0,
 972       -1.7320508075000001, 1,
 973       -2.1083388455000001, 1.2172499999999999,
 974       -2.4344999999999999, 0,
 975       -1.9318516525603098, 0.51763809027157182,
 976       -1.9201948265, 1.108625,
 977       -2.3515464241024469, 0.63009496529570408,
 978       -2.2172499999999999, 0
 979     };
 980   double coords2[]=
 981     { -2.3369999999000002, 0,
 982       -2.0239013684999998, 1.1684999999000001,
 983       -2.1927763221999998, 1.2659999998,
 984       -2.5319999998, 0,
 985       -2.2573686559260442, 0.60486010843437632,
 986       -2.1083388453499996, 1.2172499998499999,
 987       -2.445724191994314, 0.65532982205982326,
 988       -2.4344999998499999, 0 };
 989   std::vector<Node *> nodes1;
 990   nodes1.push_back(new Node(coords1));
 991   nodes1.push_back(new Node(coords1+2));
 992   nodes1.push_back(new Node(coords1+4));
 993   nodes1.push_back(new Node(coords1+6));
 994   nodes1.push_back(new Node(coords1+8));
 995   nodes1.push_back(new Node(coords1+10));
 996   nodes1.push_back(new Node(coords1+12));
 997   nodes1.push_back(new Node(coords1+14));
 998   QuadraticPolygon *pol1=QuadraticPolygon::BuildArcCirclePolygon(nodes1);
 999   std::vector<Node *> nodes2;
1000   nodes2.push_back(new Node(coords2));
1001   nodes2.push_back(new Node(coords2+2));
1002   nodes2.push_back(new Node(coords2+4));
1003   nodes2.push_back(new Node(coords2+6));
1004   nodes2.push_back(new Node(coords2+8));
1005   nodes2.push_back(new Node(coords2+10));
1006   nodes2.push_back(new Node(coords2+12));
1007   nodes2.push_back(new Node(coords2+14));
1008   QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
1009   std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
1010   CPPUNIT_ASSERT_EQUAL(1,(int)v.size());
1011   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.121795,v[0]->getArea(),1.e-6);
1012   delete v[0];
1013   delete pol1;
1014   delete pol2;
1015 }
1016
1017 void QuadraticPlanarInterpTest::checkNonRegression8()
1018 {
1019   QUADRATIC_PLANAR::setPrecision(1e-3);
1020   QUADRATIC_PLANAR::setArcDetectionPrecision(1e-5);
1021   double coords1[]=
1022     {
1023       -13.933240959000001, -28.559499999,
1024       -16.146490959000001, -27.966461449000001,
1025       -16.383240958999998, -28.376524478,
1026       -13.933240959000001, -29.032999999000001,
1027       -15.078903461873765, -28.408670669106311,
1028       -16.264865958999998, -28.1714929635,
1029       -15.201454280317435, -28.866036547696734,
1030       -13.933240959000001, -28.796249999 };
1031   double coords2[]=
1032     { -16.382999999950002, -28.376524478457149,
1033       -13.933000000014729, -29.03299999982551,
1034       -13.93300000006697, -28.793999999915993,
1035       -16.263500000000001, -28.169544407039268,
1036       -15.201213320921273, -28.866036548734634,
1037       -13.933000000040851, -28.913499999870751,
1038       -15.139355569325469, -28.635180276305853,
1039       -16.323249999975001, -28.273034442748209 };
1040   std::vector<Node *> nodes1;
1041   nodes1.push_back(new Node(coords1));
1042   nodes1.push_back(new Node(coords1+2));
1043   nodes1.push_back(new Node(coords1+4));
1044   nodes1.push_back(new Node(coords1+6));
1045   nodes1.push_back(new Node(coords1+8));
1046   nodes1.push_back(new Node(coords1+10));
1047   nodes1.push_back(new Node(coords1+12));
1048   nodes1.push_back(new Node(coords1+14));
1049   QuadraticPolygon *pol1=QuadraticPolygon::BuildArcCirclePolygon(nodes1);
1050   std::vector<Node *> nodes2;
1051   nodes2.push_back(new Node(coords2));
1052   nodes2.push_back(new Node(coords2+2));
1053   nodes2.push_back(new Node(coords2+4));
1054   nodes2.push_back(new Node(coords2+6));
1055   nodes2.push_back(new Node(coords2+8));
1056   nodes2.push_back(new Node(coords2+10));
1057   nodes2.push_back(new Node(coords2+12));
1058   nodes2.push_back(new Node(coords2+14));
1059   QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
1060   std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
1061   CPPUNIT_ASSERT_EQUAL(1,(int)v.size());
1062   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.598232,v[0]->getArea(),1.e-6);
1063   delete v[0];
1064   delete pol1;
1065   delete pol2;
1066 }
1067
1068 void QuadraticPlanarInterpTest::checkNonRegression9()
1069 {
1070   QUADRATIC_PLANAR::setPrecision(1e-7);
1071   QUADRATIC_PLANAR::setArcDetectionPrecision(1e-8);
1072   double coords1[]=
1073     {
1074       -0.04476229252902969, -0.085118027765365603,
1075       -0.046952683430894329, -0.085704941238358354,
1076       -0.046952683430894329, -0.088063823748058725,
1077       -0.043582851274179504, -0.087160879944491371,
1078       -0.045818853668170414, -0.085555669718918592,
1079       -0.046952683430894329, -0.086884382493208526,
1080       -0.045208329947517549, -0.087834175256748526,
1081       -0.044172571901604597, -0.086139453854928494 };
1082
1083   double coords2[]=
1084     { -0.05065868681155701, -0.087744551996665671,
1085       -0.046951871439587615, -0.088737790182236015,
1086       -0.046951871439683469, -0.088063823751059062,
1087       -0.050321703596054014, -0.087160879946116557,
1088       -0.0488706602695924, -0.08848517684025306,
1089       -0.046951871439635542, -0.088400806966647538,
1090       -0.048696224921445964, -0.087834175258503858,
1091       -0.050490195203805516, -0.087452715971391121};
1092
1093   std::vector<Node *> nodes1;
1094   nodes1.push_back(new Node(coords1));
1095   nodes1.push_back(new Node(coords1+2));
1096   nodes1.push_back(new Node(coords1+4));
1097   nodes1.push_back(new Node(coords1+6));
1098   nodes1.push_back(new Node(coords1+8));
1099   nodes1.push_back(new Node(coords1+10));
1100   nodes1.push_back(new Node(coords1+12));
1101   nodes1.push_back(new Node(coords1+14));
1102   QuadraticPolygon *pol1=QuadraticPolygon::BuildArcCirclePolygon(nodes1);
1103   std::vector<Node *> nodes2;
1104   nodes2.push_back(new Node(coords2));
1105   nodes2.push_back(new Node(coords2+2));
1106   nodes2.push_back(new Node(coords2+4));
1107   nodes2.push_back(new Node(coords2+6));
1108   nodes2.push_back(new Node(coords2+8));
1109   nodes2.push_back(new Node(coords2+10));
1110   nodes2.push_back(new Node(coords2+12));
1111   nodes2.push_back(new Node(coords2+14));
1112   QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
1113   std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
1114   CPPUNIT_ASSERT_EQUAL(0,(int)v.size());
1115   delete pol1;
1116   delete pol2;
1117 }
1118
1119 void QuadraticPlanarInterpTest::checkNonRegression10()
1120 {
1121   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-7);
1122   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-7);
1123   double coords1[]=
1124     { -0.002269581957210453, -0.09851030343724453,
1125       -0.004268022334182935, -0.1059685844580936,
1126       -0.002777851483521377, -0.1023709937816271};
1127   double coords2[]=
1128     { -0.004114727297178323, -0.1049870239624718,
1129       -0.003544545103522544, -0.1053162188055505};
1130   Node *n1_1=new Node(coords1);
1131   Node *n2_1=new Node(coords1+2);
1132   Node *n3_1=new Node(coords1+4);
1133   Node *n1_2=new Node(coords2);
1134   Node *n2_2=new Node(coords2+2);
1135   EdgeArcCircle *e1=new EdgeArcCircle(n1_1,n3_1,n2_1);
1136   EdgeLin *e2=new EdgeLin(n1_2,n2_2);
1137   MergePoints merge;
1138   ComposedEdge *c1=new ComposedEdge;
1139   ComposedEdge *c2=new ComposedEdge;
1140   CPPUNIT_ASSERT(e1->intersectWith(e2,merge,*c1,*c2));
1141   CPPUNIT_ASSERT_EQUAL(2,c1->size());
1142   CPPUNIT_ASSERT_EQUAL(2,c2->size());
1143   ComposedEdge::Delete(c1); ComposedEdge::Delete(c2);
1144   n1_1->decrRef(); n2_1->decrRef(); n3_1->decrRef();
1145   n1_2->decrRef(); n2_2->decrRef();
1146   e1->decrRef(); e2->decrRef();
1147 }
1148
1149 void QuadraticPlanarInterpTest::checkNonRegression11()
1150 {
1151   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-7);
1152   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-7);
1153   double coords1[]=
1154     { -0.002269581957210453, -0.09851030343724453,
1155       -0.004268022334182935, -0.1059685844580936,
1156       -0.002886178753789801, -0.1067663922211958,
1157       -0.0006739664310059821, -0.09851030343724453,
1158       -0.002777851483521377, -0.1023709937816271,
1159       -0.003577100543986368, -0.1063674883396447,
1160       -0.001236605237717319, -0.1027839694676665,
1161       -0.001471774194108217, -0.09851030343724453};
1162   double coords2[]=
1163     { -0.003544545103522544, -0.1053162188055505,
1164       -0.001941023322604723, -0.09851030343724451,
1165       -0.002598140593501099, -0.09851030343724451,
1166       -0.004114727297178323, -0.1049870239624718,
1167       -0.002347317802266182, -0.1020064358043286,
1168       -0.002269581958052911, -0.09851030343724451,
1169       -0.002982346712452072, -0.1018362598405457,
1170       -0.003829636200350435, -0.1051516213840111};
1171
1172   std::vector<Node *> nodes1;
1173   nodes1.push_back(new Node(coords1));
1174   nodes1.push_back(new Node(coords1+2));
1175   nodes1.push_back(new Node(coords1+4));
1176   nodes1.push_back(new Node(coords1+6));
1177   nodes1.push_back(new Node(coords1+8));
1178   nodes1.push_back(new Node(coords1+10));
1179   nodes1.push_back(new Node(coords1+12));
1180   nodes1.push_back(new Node(coords1+14));
1181   QuadraticPolygon *pol1=QuadraticPolygon::BuildArcCirclePolygon(nodes1);
1182   std::vector<Node *> nodes2;
1183   nodes2.push_back(new Node(coords2));
1184   nodes2.push_back(new Node(coords2+2));
1185   nodes2.push_back(new Node(coords2+4));
1186   nodes2.push_back(new Node(coords2+6));
1187   nodes2.push_back(new Node(coords2+8));
1188   nodes2.push_back(new Node(coords2+10));
1189   nodes2.push_back(new Node(coords2+12));
1190   nodes2.push_back(new Node(coords2+14));
1191   QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
1192   std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
1193   CPPUNIT_ASSERT_EQUAL(1,(int)v.size());
1194   CPPUNIT_ASSERT_DOUBLES_EQUAL(2.28973e-06,v[0]->getArea(),1.e-11);
1195   delete v[0];
1196   delete pol1;
1197   delete pol2;
1198 }
1199
1200 void QuadraticPlanarInterpTest::checkNonRegression12()
1201 {
1202   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-6);
1203   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-7);
1204   double coords1[]=
1205     { -0.5032251558760915, -0.8716087994449138,
1206       -0.4695268343089433, -0.8806382374805872,
1207       -0.4695268343089433, -0.8570494123835835,
1208       -0.4914307433275896, -0.8511802776536561,
1209       -0.4869703691141082, -0.8783417525751493,
1210       -0.4695268343089433, -0.8688438249320853,
1211       -0.480865131947653, -0.8555566971861125,
1212       -0.4973279496018406, -0.8613945385492849};
1213
1214   double coords2[]=
1215     { -0.5065868681155701, -0.8774455199666568,
1216       -0.4695187143958762, -0.8873779018223601,
1217       -0.4695187143968347, -0.8806382375105907,
1218       -0.5032170359605401, -0.8716087994611657,
1219       -0.488706602695924, -0.8848517684025307,
1220       -0.4695187143963554, -0.8840080696664754,
1221       -0.4869622492144596, -0.8783417525850385,
1222       -0.5049019520380551, -0.8745271597139112};
1223
1224   std::vector<Node *> nodes1;
1225   nodes1.push_back(new Node(coords1));
1226   nodes1.push_back(new Node(coords1+2));
1227   nodes1.push_back(new Node(coords1+4));
1228   nodes1.push_back(new Node(coords1+6));
1229   nodes1.push_back(new Node(coords1+8));
1230   nodes1.push_back(new Node(coords1+10));
1231   nodes1.push_back(new Node(coords1+12));
1232   nodes1.push_back(new Node(coords1+14));
1233   QuadraticPolygon *pol1=QuadraticPolygon::BuildArcCirclePolygon(nodes1);
1234   std::vector<Node *> nodes2;
1235   nodes2.push_back(new Node(coords2));
1236   nodes2.push_back(new Node(coords2+2));
1237   nodes2.push_back(new Node(coords2+4));
1238   nodes2.push_back(new Node(coords2+6));
1239   nodes2.push_back(new Node(coords2+8));
1240   nodes2.push_back(new Node(coords2+10));
1241   nodes2.push_back(new Node(coords2+12));
1242   nodes2.push_back(new Node(coords2+14));
1243   QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
1244   std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
1245   CPPUNIT_ASSERT_EQUAL(1,(int)v.size());
1246   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,v[0]->getArea(),1.e-6);
1247   delete v[0];
1248   delete pol1;
1249   delete pol2;
1250 }
1251
1252 void QuadraticPlanarInterpTest::checkNonRegression13()
1253 {
1254   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-7);
1255   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-6);
1256
1257   double coords_1[194]={
1258     0, 0, 0.304375, -7.454791178893722e-17, 0.2152256265236553, -0.2152256265236555, -5.591093384170291e-17, -0.304375,
1259     -0.2152256265236555, -0.2152256265236554, -0.304375, 3.727395589446861e-17, -0.2152256265236554, 0.2152256265236554, 1.86369779472343e-17, 0.304375,
1260     0.2152256265236554, 0.2152256265236554, 0.60875, -1.490958235778744e-16, 0.5624116654162459, -0.2329585394522483, 0.4304512530473107, -0.4304512530473109,
1261     0.2329585394522485, -0.5624116654162458, -1.118218676834058e-16, -0.60875, -0.2329585394522482, -0.5624116654162459, -0.4304512530473109, -0.4304512530473108,
1262     -0.5624116654162459, -0.2329585394522483, -0.60875, 7.454791178893722e-17, -0.5624116654162458, 0.2329585394522485, -0.4304512530473108, 0.4304512530473109,
1263     -0.2329585394522484, 0.5624116654162458, 3.727395589446861e-17, 0.60875, 0.2329585394522485, 0.5624116654162458, 0.4304512530473109, 0.4304512530473108,
1264     0.5624116654162458, 0.2329585394522484, 0.913125, -2.236437353668116e-16, 0.645676879570966, -0.6456768795709663, -1.677328015251087e-16, -0.913125,
1265     -0.6456768795709663, -0.6456768795709661, -0.913125, 1.118218676834058e-16, -0.6456768795709661, 0.6456768795709662, 5.591093384170291e-17, 0.913125,
1266     0.6456768795709662, 0.6456768795709661, 1.2175, -2.981916471557489e-16, 1.124823330832492, -0.4659170789044966, 0.8609025060946214, -0.8609025060946218,
1267     0.4659170789044971, -1.124823330832492, -2.236437353668116e-16, -1.2175, -0.4659170789044965, -1.124823330832492, -0.8609025060946218, -0.8609025060946216,
1268     -1.124823330832492, -0.4659170789044967, -1.2175, 1.490958235778744e-16, -1.124823330832492, 0.465917078904497, -0.8609025060946216, 0.8609025060946217,
1269     -0.4659170789044967, 1.124823330832492, 7.454791178893722e-17, 1.2175, 0.4659170789044969, 1.124823330832492, 0.8609025060946217, 0.8609025060946216,
1270     1.124823330832492, 0.4659170789044968, 1.521875, -3.727395589446861e-16, 1.076128132618277, -1.076128132618277, -2.795546692085146e-16, -1.521875,
1271     -1.076128132618277, -1.076128132618277, -1.521875, 1.86369779472343e-16, -1.076128132618277, 1.076128132618277, 9.318488973617152e-17, 1.521875,
1272     1.076128132618277, 1.076128132618277, 1.82625, -4.472874707336233e-16, 1.687234996248738, -0.6988756183567448, 1.291353759141932, -1.291353759141933,
1273     0.6988756183567456, -1.687234996248737, -3.354656030502175e-16, -1.82625, -0.6988756183567447, -1.687234996248738, -1.291353759141933, -1.291353759141932,
1274     -1.687234996248738, -0.6988756183567449, -1.82625, 2.236437353668116e-16, -1.687234996248737, 0.6988756183567454, -1.291353759141932, 1.291353759141932,
1275     -0.6988756183567451, 1.687234996248737, 1.118218676834058e-16, 1.82625, 0.6988756183567453, 1.687234996248737, 1.291353759141932, 1.291353759141932,
1276     1.687234996248737, 0.6988756183567452, 2.130625, -5.218353825225606e-16, 1.506579385665588, -1.506579385665588, -3.913765368919204e-16, -2.130625,
1277     -1.506579385665588, -1.506579385665588, -2.130625, 2.609176912612803e-16, -1.506579385665588, 1.506579385665588, 1.304588456306401e-16, 2.130625,
1278     1.506579385665588, 1.506579385665588, 2.435, -5.963832943114977e-16, 2.249646661664984, -0.9318341578089931, 1.721805012189243, -1.721805012189244,
1279     0.9318341578089941, -2.249646661664983, -4.472874707336233e-16, -2.435, -0.9318341578089929, -2.249646661664984, -1.721805012189244, -1.721805012189243,
1280     -2.249646661664984, -0.9318341578089934, -2.435, 2.981916471557489e-16, -2.249646661664983, 0.9318341578089939, -1.721805012189243, 1.721805012189243,
1281     -0.9318341578089935, 2.249646661664983, 1.490958235778744e-16, 2.435, 0.9318341578089938, 2.249646661664983, 1.721805012189243, 1.721805012189243,
1282     2.249646661664983, 0.9318341578089936 };
1283
1284   int tab6_1[48]={
1285     0, 9, 11, 1, 10, 2, 0, 11, 13, 2, 12, 3, 0, 13, 15, 3, 14, 4, 0, 15,
1286     17, 4, 16, 5, 0, 17, 19, 5, 18, 6, 0, 19, 21, 6, 20, 7, 0, 21, 23, 7,
1287     22, 8, 0, 23, 9, 8, 24, 1 };
1288
1289   int tab8_1[192]={
1290     9, 33, 35, 11, 25, 34, 26, 10, 11, 35, 37, 13, 26, 36, 27, 12, 13, 37, 39, 15,
1291     27, 38, 28, 14, 15, 39, 41, 17, 28, 40, 29, 16, 17, 41, 43, 19, 29, 42, 30, 18,
1292     19, 43, 45, 21, 30, 44, 31, 20, 21, 45, 47, 23, 31, 46, 32, 22, 23, 47, 33, 9,
1293     32, 48, 25, 24, 33, 57, 59, 35, 49, 58, 50, 34, 35, 59, 61, 37, 50, 60, 51, 36,
1294     37, 61, 63, 39, 51, 62, 52, 38, 39, 63, 65, 41, 52, 64, 53, 40, 41, 65, 67, 43,
1295     53, 66, 54, 42, 43, 67, 69, 45, 54, 68, 55, 44, 45, 69, 71, 47, 55, 70, 56, 46,
1296     47, 71, 57, 33, 56, 72, 49, 48, 57, 81, 83, 59, 73, 82, 74, 58, 59, 83, 85, 61,
1297     74, 84, 75, 60, 61, 85, 87, 63, 75, 86, 76, 62, 63, 87, 89, 65, 76, 88, 77, 64,
1298     65, 89, 91, 67, 77, 90, 78, 66, 67, 91, 93, 69, 78, 92, 79, 68, 69, 93, 95, 71,
1299     79, 94, 80, 70, 71, 95, 81, 57, 80, 96, 73, 72 };
1300
1301   double coords_2[20]={
1302     0.5159941860137611, 0, 0, -0.5159941860137611, -0.5159941860137611, 0, 0, 0.5159941860137611,
1303     0.6684941860137611, 0, 0, -0.6684941860137611, -0.6684941860137611, 0, 0, 0.6684941860137611,
1304     0.5922441860137611, 0, -0.5922441860137611, 0 };
1305
1306   int tab8_2[16]={
1307     0, 4, 6, 2, 8, 5, 9, 1, 2, 6, 4, 0, 9, 7, 8, 3 };
1308
1309   double perimeterFromPol1,perimeterFromPol2,perimeterFromPol1AndPol2;
1310
1311   const int *work1=tab6_1;
1312   for(int i=0;i<8;i++,work1+=6)
1313     {
1314       QuadraticPolygon *pol1=buildQuadraticPolygonCoarseInfo(coords_1,work1,6);
1315       const int *work2=tab8_2;
1316       for(int j=0;j<2;j++,work2+=8)
1317         {
1318           QuadraticPolygon *pol2=buildQuadraticPolygonCoarseInfo(coords_2,work2,8);
1319           //std::vector<int> tmp;
1320           //pol1->intersectForPoint(*pol2,tmp);
1321           pol1->intersectForPerimeter(*pol2,perimeterFromPol1,perimeterFromPol2,perimeterFromPol1AndPol2);
1322           //pol1->intersectMySelfWith(*pol2);
1323           delete pol2;
1324         }
1325       delete pol1;
1326     }
1327   work1=tab8_1;
1328   for(int i=0;i<24;i++,work1+=8)
1329     {
1330       QuadraticPolygon *pol1=buildQuadraticPolygonCoarseInfo(coords_1,work1,8);
1331       const int *work2=tab8_2;
1332       for(int j=0;j<2;j++,work2+=8)
1333         {
1334
1335           QuadraticPolygon *pol2=buildQuadraticPolygonCoarseInfo(coords_2,work2,8);
1336           //std::vector<int> tmp;
1337           //pol1->intersectForPoint(*pol2,tmp);
1338           pol1->intersectForPerimeter(*pol2,perimeterFromPol1,perimeterFromPol2,perimeterFromPol1AndPol2);
1339           delete pol2;
1340         }
1341       delete pol1;
1342     }
1343 }
1344
1345 /*!
1346   Some overlapping cases for intersectForPoint.
1347 */
1348 void QuadraticPlanarInterpTest::checkNonRegression14()
1349 {
1350   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-7);
1351   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-6);
1352
1353   double coords[72]={
1354     1.,0.,1.3,0.,-1.3,0.,-1.,0.,1.15,0.,0.,1.3,-1.15,0.,0.,1.,
1355     -0.91923881554251186,-0.91923881554251186,-0.91923881554251186,0.91923881554251186,-1.0606601717798214,1.0606601717798214,-1.0606601717798214,-1.0606601717798214,-1.5,0.,
1356     -0.98994949366116658,-0.98994949366116658,-0.98994949366116658,0.98994949366116658,
1357     0.91923881554251186,0.91923881554251186,1.0606601717798214,1.0606601717798214,0.98994949366116658,0.98994949366116658, 0., 1.5,
1358     -0.83562389259250125,0.99585777605467141, -0.65, 1.1258330249197703, -1.2216004070216808, 0.44462618632336953, -1.1258330249197703, 0.65,
1359     -0.74564936725635955, 1.0648976575756897, -1.6770646146510724, 1.4072242996141826, -1.1782001231476449, 0.54940374026290939, -1.5873847317707279, 0.74020965686300877,
1360     -1.1782001231476449, 0.54940374026290939, -1.0648976575756894, 0.74564936725635977, -1.2950531075192693, -0.11330246557195534, -1.2950531075192693, 0.11330246557195565,
1361     -1.1258330249197703, 0.65, -2.1146554070041046, 0.56662020857685746, -1.6918048488667423, 0.45331774300490169,
1362     0.,-1.3,0.,-1.5
1363   };
1364   int tab[48]={
1365     0,1,2,3,4,5,6,7,
1366     8,9,10,11,2,14,12,13,
1367     9,15,16,10,5,17,18,14,
1368     9,15,16,10,34,17,35,14,
1369     19,20,21,22,23,24,25,26,
1370     27,28,29,30,31,32,2,33
1371   };
1372   QuadraticPolygon *pol1,*pol2;
1373   std::vector<int> goalOfTest;
1374   //
1375   pol1=buildQuadraticPolygonCoarseInfo(coords,tab,8);
1376   // Level 1
1377   pol2=buildQuadraticPolygonCoarseInfo(coords,tab+8,8);
1378   pol1->intersectForPoint(*pol2,goalOfTest);
1379   const int res1[4]={0,1,0,0};
1380   CPPUNIT_ASSERT_EQUAL(4,(int)goalOfTest.size());
1381   CPPUNIT_ASSERT(equal(goalOfTest.begin(),goalOfTest.end(),res1));
1382   delete pol2;
1383   // Level 2
1384   pol2=buildQuadraticPolygonCoarseInfo(coords,tab+16,8);
1385   pol1->intersectForPoint(*pol2,goalOfTest);
1386   const int res2[4]={0,2,0,0};
1387   CPPUNIT_ASSERT_EQUAL(4,(int)goalOfTest.size());
1388   CPPUNIT_ASSERT(equal(goalOfTest.begin(),goalOfTest.end(),res2));
1389   delete pol2;
1390   //Level 2 bis
1391   pol2=buildQuadraticPolygonCoarseInfo(coords,tab+24,8);
1392   pol1->intersectForPoint(*pol2,goalOfTest);
1393   const int res2Bis[4]={0,2,0,0};
1394   CPPUNIT_ASSERT_EQUAL(4,(int)goalOfTest.size());
1395   CPPUNIT_ASSERT(equal(goalOfTest.begin(),goalOfTest.end(),res2Bis));
1396   delete pol2;
1397   // Level 3
1398   pol2=buildQuadraticPolygonCoarseInfo(coords,tab+40,8);
1399   pol1->intersectForPoint(*pol2,goalOfTest);
1400   const int res3[4]={0,3,0,0};
1401   CPPUNIT_ASSERT_EQUAL(4,(int)goalOfTest.size());
1402   CPPUNIT_ASSERT(equal(goalOfTest.begin(),goalOfTest.end(),res3));
1403   delete pol2;
1404   // Level 4
1405   pol2=buildQuadraticPolygonCoarseInfo(coords,tab+32,8);
1406   pol1->intersectForPoint(*pol2,goalOfTest);
1407   const int res4[4]={0,4,0,0};
1408   CPPUNIT_ASSERT_EQUAL(4,(int)goalOfTest.size());
1409   CPPUNIT_ASSERT(equal(goalOfTest.begin(),goalOfTest.end(),res4));
1410   delete pol2;
1411   //
1412   delete pol1;
1413 }
1414
1415 /*!
1416  * This test is one of the most complicated intersection configuration.
1417  */
1418 void QuadraticPlanarInterpTest::checkNonRegression15()
1419 {
1420   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-7);
1421   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-6);
1422
1423   double coords[72]={
1424     1.,0.,1.3,0.,-1.3,0.,-1.,0.,1.15,0.,0.,1.3,-1.15,0.,0.,1.,
1425     -0.91923881554251186,-0.91923881554251186,-0.91923881554251186,0.91923881554251186,-1.0606601717798214,1.0606601717798214,-1.0606601717798214,-1.0606601717798214,-1.5,0.,
1426     -0.98994949366116658,-0.98994949366116658,-0.98994949366116658,0.98994949366116658,
1427     0.91923881554251186,0.91923881554251186,1.0606601717798214,1.0606601717798214,0.98994949366116658,0.98994949366116658, 0., 1.5,
1428     -0.83562389259250125,0.99585777605467141, -0.65, 1.1258330249197703, -1.2216004070216808, 0.44462618632336953, -1.1258330249197703, 0.65,
1429     -0.74564936725635955, 1.0648976575756897, -1.6770646146510724, 1.4072242996141826, -1.1782001231476449, 0.54940374026290939, -1.5873847317707279, 0.74020965686300877,
1430     -1.1782001231476449, 0.54940374026290939, -1.0648976575756894, 0.74564936725635977, -1.2950531075192693, -0.11330246557195534, -1.2950531075192693, 0.11330246557195565,
1431     -1.1258330249197703, 0.65, -2.1146554070041046, 0.56662020857685746, -1.6918048488667423, 0.45331774300490169,
1432     0.,-1.3,0.,-1.5
1433   };
1434
1435   int tab[24]={
1436     0,1,2,3,4,5,6,7,
1437     9,15,16,10,7,17,5,14,
1438     9,10,16,15,14,5,17,7
1439   };
1440
1441   const double RefLgth=3.88995883524451;
1442   const double RefArea=0.383185168001075;
1443   //
1444   QuadraticPolygon *pol1,*pol2;
1445   //pol1 and pol2 in same orientation
1446   pol1=buildQuadraticPolygonCoarseInfo(coords,tab,8);
1447   pol2=buildQuadraticPolygonCoarseInfo(coords,tab+8,8);
1448   std::vector<QuadraticPolygon *> res=pol1->intersectMySelfWith(*pol2);
1449   CPPUNIT_ASSERT_EQUAL(1,(int)res.size());
1450   CPPUNIT_ASSERT_EQUAL(4,res[0]->recursiveSize());
1451   CPPUNIT_ASSERT_DOUBLES_EQUAL(RefLgth,res[0]->getPerimeter(),1e-12);
1452   CPPUNIT_ASSERT_DOUBLES_EQUAL(RefArea,res[0]->getArea(),1e-12);
1453   delete res[0];
1454   //pol1 and pol2 in same orientation but inversing intersection call pol1<->pol2
1455   res=pol2->intersectMySelfWith(*pol1);
1456   CPPUNIT_ASSERT_EQUAL(1,(int)res.size());
1457   CPPUNIT_ASSERT_EQUAL(4,res[0]->recursiveSize());
1458   CPPUNIT_ASSERT_DOUBLES_EQUAL(RefLgth,res[0]->getPerimeter(),1e-12);
1459   CPPUNIT_ASSERT_DOUBLES_EQUAL(RefArea,res[0]->getArea(),1e-12);
1460   delete res[0];
1461   delete pol2;
1462   //pol1 and pol2 in opposite orientation
1463   pol2=buildQuadraticPolygonCoarseInfo(coords,tab+16,8);
1464   res=pol1->intersectMySelfWith(*pol2);
1465   CPPUNIT_ASSERT_EQUAL(1,(int)res.size());
1466   CPPUNIT_ASSERT_EQUAL(4,res[0]->recursiveSize());
1467   CPPUNIT_ASSERT_DOUBLES_EQUAL(RefLgth,res[0]->getPerimeter(),1e-12);
1468   CPPUNIT_ASSERT_DOUBLES_EQUAL(-RefArea,res[0]->getArea(),1e-12);
1469   delete res[0];
1470   //pol1 and pol2 in opposite orientation but inversing intersection call pol1<->pol2
1471   res=pol2->intersectMySelfWith(*pol1);
1472   CPPUNIT_ASSERT_EQUAL(1,(int)res.size());
1473   CPPUNIT_ASSERT_EQUAL(4,res[0]->recursiveSize());
1474   CPPUNIT_ASSERT_DOUBLES_EQUAL(RefLgth,res[0]->getPerimeter(),1e-12);
1475   CPPUNIT_ASSERT_DOUBLES_EQUAL(RefArea,res[0]->getArea(),1e-12);
1476   delete res[0];
1477   delete pol2;
1478   //
1479   delete pol1;
1480 }
1481
1482 class DoubleEqual
1483 {
1484 public:
1485   DoubleEqual(double eps):_eps(eps) { }
1486   bool operator()(double x, double y) { return fabs(x-y)<_eps; }
1487 private:
1488   double _eps;
1489 };
1490
1491 /*!
1492  * This test is to see the reuse of a polygon in intersect* methods. initLocation needed ...
1493  */
1494 void QuadraticPlanarInterpTest::checkNonRegression16()
1495 {
1496   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-7);
1497   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-7);
1498   double coords1[194]={
1499     0, 0, 0.304375, 0, 0.2152256265236554, 0.2152256265236554, 1.86369779472343e-17, 0.304375,
1500     -0.2152256265236554, 0.2152256265236554, -0.304375, 3.727395589446861e-17, -0.2152256265236555, -0.2152256265236554, -5.591093384170291e-17, -0.304375,
1501     0.2152256265236553, -0.2152256265236555, 0.60875, 0, 0.5624116654162458, 0.2329585394522484, 0.4304512530473109, 0.4304512530473108,
1502     0.2329585394522485, 0.5624116654162458, 3.727395589446861e-17, 0.60875, -0.2329585394522484, 0.5624116654162458, -0.4304512530473108, 0.4304512530473109,
1503     -0.5624116654162458, 0.2329585394522485, -0.60875, 7.454791178893722e-17, -0.5624116654162459, -0.2329585394522483, -0.4304512530473109, -0.4304512530473108,
1504     -0.2329585394522482, -0.5624116654162459, -1.118218676834058e-16, -0.60875, 0.2329585394522485, -0.5624116654162458, 0.4304512530473107, -0.4304512530473109,
1505     0.5624116654162459, -0.2329585394522483, 0.913125, 0, 0.6456768795709662, 0.6456768795709661, 5.591093384170291e-17, 0.913125,
1506     -0.6456768795709661, 0.6456768795709662, -0.913125, 1.118218676834058e-16, -0.6456768795709663, -0.6456768795709661, -1.677328015251087e-16, -0.913125,
1507     0.645676879570966, -0.6456768795709663, 1.2175, 0, 1.124823330832492, 0.4659170789044968, 0.8609025060946217, 0.8609025060946216,
1508     0.4659170789044969, 1.124823330832492, 7.454791178893722e-17, 1.2175, -0.4659170789044967, 1.124823330832492, -0.8609025060946216, 0.8609025060946217,
1509     -1.124823330832492, 0.465917078904497, -1.2175, 1.490958235778744e-16, -1.124823330832492, -0.4659170789044967, -0.8609025060946218, -0.8609025060946216,
1510     -0.4659170789044965, -1.124823330832492, -2.236437353668116e-16, -1.2175, 0.4659170789044971, -1.124823330832492, 0.8609025060946214, -0.8609025060946218,
1511     1.124823330832492, -0.4659170789044966, 1.521875, 0, 1.076128132618277, 1.076128132618277, 9.318488973617152e-17, 1.521875,
1512     -1.076128132618277, 1.076128132618277, -1.521875, 1.86369779472343e-16, -1.076128132618277, -1.076128132618277, -2.795546692085146e-16, -1.521875,
1513     1.076128132618277, -1.076128132618277, 1.82625, 0, 1.687234996248737, 0.6988756183567452, 1.291353759141932, 1.291353759141932,
1514     0.6988756183567453, 1.687234996248737, 1.118218676834058e-16, 1.82625, -0.6988756183567451, 1.687234996248737, -1.291353759141932, 1.291353759141932,
1515     -1.687234996248737, 0.6988756183567454, -1.82625, 2.236437353668116e-16, -1.687234996248738, -0.6988756183567449, -1.291353759141933, -1.291353759141932,
1516     -0.6988756183567447, -1.687234996248738, -3.354656030502175e-16, -1.82625, 0.6988756183567456, -1.687234996248737, 1.291353759141932, -1.291353759141933,
1517     1.687234996248738, -0.6988756183567448, 2.130625, 0, 1.506579385665588, 1.506579385665588, 1.304588456306401e-16, 2.130625,
1518     -1.506579385665588, 1.506579385665588, -2.130625, 2.609176912612803e-16, -1.506579385665588, -1.506579385665588, -3.913765368919204e-16, -2.130625,
1519     1.506579385665588, -1.506579385665588, 2.435, 0, 2.249646661664983, 0.9318341578089936, 1.721805012189243, 1.721805012189243,
1520     0.9318341578089938, 2.249646661664983, 1.490958235778744e-16, 2.435, -0.9318341578089935, 2.249646661664983, -1.721805012189243, 1.721805012189243,
1521     -2.249646661664983, 0.9318341578089939, -2.435, 2.981916471557489e-16, -2.249646661664984, -0.9318341578089934, -1.721805012189244, -1.721805012189243,
1522     -0.9318341578089929, -2.249646661664984, -4.472874707336233e-16, -2.435, 0.9318341578089941, -2.249646661664983, 1.721805012189243, -1.721805012189244,
1523     2.249646661664984, -0.9318341578089931, };
1524
1525   int tab1_8[192]={
1526     11, 35, 33, 9, 26, 34, 25, 10, 13, 37, 35, 11, 27, 36, 26, 12, 15, 39, 37, 13,
1527     28, 38, 27, 14, 17, 41, 39, 15, 29, 40, 28, 16, 19, 43, 41, 17, 30, 42, 29, 18,
1528     21, 45, 43, 19, 31, 44, 30, 20, 23, 47, 45, 21, 32, 46, 31, 22, 9, 33, 47, 23,
1529     25, 48, 32, 24, 35, 59, 57, 33, 50, 58, 49, 34, 37, 61, 59, 35, 51, 60, 50, 36,
1530     39, 63, 61, 37, 52, 62, 51, 38, 41, 65, 63, 39, 53, 64, 52, 40, 43, 67, 65, 41,
1531     54, 66, 53, 42, 45, 69, 67, 43, 55, 68, 54, 44, 47, 71, 69, 45, 56, 70, 55, 46,
1532     33, 57, 71, 47, 49, 72, 56, 48, 59, 83, 81, 57, 74, 82, 73, 58, 61, 85, 83, 59,
1533     75, 84, 74, 60, 63, 87, 85, 61, 76, 86, 75, 62, 65, 89, 87, 63, 77, 88, 76, 64,
1534     67, 91, 89, 65, 78, 90, 77, 66, 69, 93, 91, 67, 79, 92, 78, 68, 71, 95, 93, 69,
1535     80, 94, 79, 70, 57, 81, 95, 71, 73, 96, 80, 72, };
1536
1537   double coords2[20]={
1538     2.435, 0, 0, -2.435, -2.435, 0, 0, 2.435,
1539     2.6925, 0, 0, -2.6925, -2.6925, 0, 0, 2.6925,
1540     2.56375, 0, -2.56375, 0, };
1541
1542   int tab2_8[16]={ 0, 4, 6, 2, 8, 5, 9, 1, 2, 6, 4, 0, 9, 7, 8, 3 };
1543
1544   QuadraticPolygon *pol1,*pol2;
1545   //pol1 and pol2 in same orientation
1546   std::vector<double> test1,test2;
1547   for(int ii=0;ii<24;ii++)
1548     {
1549       pol1=buildQuadraticPolygonCoarseInfo(coords1,tab1_8+8*ii,8);
1550       for(int jj=0;jj<2;jj++)
1551         {
1552           pol2=buildQuadraticPolygonCoarseInfo(coords2,tab2_8+jj*8,8);
1553           //
1554           std::vector<double> v1,v2;
1555           pol1->initLocations();
1556           pol1->intersectForPerimeterAdvanced(*pol2,v1,v2);
1557           if(ii==16 && jj==1)
1558             test1=v1;
1559           if(ii==20 && jj==1)
1560             test2=v1;
1561           delete pol2;
1562         }
1563       delete pol1;
1564     }
1565   const double test1_res[4]={0.,1.9124445278727873,0.,0.};
1566   CPPUNIT_ASSERT(std::equal(test1.begin(),test1.end(),test1_res,DoubleEqual(1e-10)));
1567   const double test2_res[4]={0.,0.,0.,0.};
1568   CPPUNIT_ASSERT(std::equal(test2.begin(),test2.end(),test2_res,DoubleEqual(1e-10)));
1569 }
1570
1571 /*!
1572  * This test checks overlapped intersections END-INSIDE and INSIDE-START with same and opposite orientation.
1573  */
1574 void QuadraticPlanarInterpTest::checkNonRegression17()
1575 {
1576   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-7);
1577   INTERP_KERNEL::QUADRATIC_PLANAR::setArcDetectionPrecision(1e-7);
1578   double coords[16]={
1579     -1., 0., 1., 0. , 1.5, 0., -1.5, 0.,
1580     0. , 1., 1.25, 0., 0., 1.5, -1.25, 0.};
1581
1582   double coords2[16]={
1583     0.70710678118654757, 0.70710678118654757, -1., 0., -1.25, 0.,  0.88388347648318444, 0.88388347648318444,
1584     0., -1., -1.125, 0., 0., -1.25, 0.79549512883486606, 0.79549512883486606 };
1585
1586   double coords3[16]={
1587     0.70710678118654757, 0.70710678118654757, 0.88388347648318444, 0.88388347648318444, -1.25, 0., -1., 0.,
1588     0.79549512883486606, 0.79549512883486606, 0., -1.25, -1.125, 0., 0., -1. };
1589
1590   int tab8[8]={
1591     0, 1, 2, 3, 4, 5, 6, 7 };
1592   QuadraticPolygon *pol1=buildQuadraticPolygonCoarseInfo(coords,tab8,8);
1593   QuadraticPolygon *pol2=buildQuadraticPolygonCoarseInfo(coords2,tab8,8);
1594   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.22089323345553233,pol1->intersectWith(*pol2),1.e-13);
1595   delete pol1;
1596   delete pol2;
1597   pol1=buildQuadraticPolygonCoarseInfo(coords,tab8,8);
1598   pol2=buildQuadraticPolygonCoarseInfo(coords2,tab8,8);
1599   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.22089323345553233,pol2->intersectWith(*pol1),1.e-13);
1600   delete pol1;
1601   delete pol2;
1602   pol1=buildQuadraticPolygonCoarseInfo(coords,tab8,8);
1603   pol2=buildQuadraticPolygonCoarseInfo(coords3,tab8,8);
1604   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.22089323345553233,pol1->intersectWith(*pol2),1.e-13);
1605   delete pol1;
1606   delete pol2;
1607   pol1=buildQuadraticPolygonCoarseInfo(coords,tab8,8);
1608   pol2=buildQuadraticPolygonCoarseInfo(coords3,tab8,8);
1609   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.22089323345553233,pol2->intersectWith(*pol1),1.e-13);
1610   delete pol1;
1611   delete pol2;
1612 }
1613
1614 void QuadraticPlanarInterpTest::checkNormalize()
1615 {
1616   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-14);
1617   Node *n1=new Node(0.,0.);                Node *n4=new Node(0.,-3.);
1618   Node *n2=new Node(10.,0.);               Node *n5=new Node(10.,-3.);
1619   Node *n3=new Node(5.,10.);               Node *n6=new Node(5.,7.);
1620   EdgeLin *e1_2=new EdgeLin(n1,n2);        EdgeLin *e4_5=new EdgeLin(n4,n5);
1621   EdgeLin *e2_3=new EdgeLin(n2,n3);        EdgeLin *e5_6=new EdgeLin(n5,n6);
1622   EdgeLin *e3_1=new EdgeLin(n3,n1);        EdgeLin *e6_4=new EdgeLin(n6,n4);
1623   //
1624   QuadraticPolygon pol1; pol1.pushBack(e1_2); pol1.pushBack(e2_3); pol1.pushBack(e3_1);
1625   QuadraticPolygon pol2; pol2.pushBack(e4_5); pol2.pushBack(e5_6); pol2.pushBack(e6_4);
1626   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
1627   double area1Start=pol1.getArea();
1628   double xb,yb;
1629   double fact=pol1.normalize(&pol2,xb,yb);
1630   double area1End=pol1.getArea();
1631   CPPUNIT_ASSERT_DOUBLES_EQUAL(area1Start,area1End*fact*fact,1e-14);
1632   CPPUNIT_ASSERT_DOUBLES_EQUAL(13.,fact,1.e-14);
1633   double area=pol1.intersectWith(pol2);
1634   CPPUNIT_ASSERT_DOUBLES_EQUAL(24.5,area*fact*fact,1e-14);
1635   //
1636   n1=new Node(0.,0.);  n4=new Node(0.,-3.);
1637   n2=new Node(10.,0.); n5=new Node(10.,-3.);
1638   n3=new Node(5.,10.); n6=new Node(5.,7.);
1639   e1_2=new EdgeLin(n1,n2);        e4_5=new EdgeLin(n4,n5);
1640   e2_3=new EdgeLin(n2,n3);        e5_6=new EdgeLin(n5,n6);
1641   e3_1=new EdgeLin(n3,n1);        e6_4=new EdgeLin(n6,n4);
1642   QuadraticPolygon pol3; pol3.pushBack(e1_2); pol3.pushBack(e2_3); pol3.pushBack(e3_1);
1643   QuadraticPolygon pol4; pol4.pushBack(e4_5); pol4.pushBack(e5_6); pol4.pushBack(e6_4);
1644   n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
1645   CPPUNIT_ASSERT_DOUBLES_EQUAL(24.5,pol3.intersectWithAbs(pol4),1.e-14);
1646   // Ok testing EdgeArcCircle update.
1647   double center[2]={5.,5.};
1648   double radius=300.;
1649   EdgeArcCircle *e1=buildArcOfCircle(center,radius,M_PI/4.,M_PI/3.);
1650   const Bounds& b=e1->getBounds();
1651   double x,y,fact2;
1652   fact2=b.getCaracteristicDim();
1653   b.getBarycenter(x,y);
1654   CPPUNIT_ASSERT_DOUBLES_EQUAL(78.539816339744817,e1->getCurveLength(),1e-13);
1655   CPPUNIT_ASSERT_DOUBLES_EQUAL(15106.061037591669,e1->getAreaOfZone(),1e-10);
1656   e1->getStartNode()->applySimilarity(x,y,fact2);
1657   e1->getEndNode()->applySimilarity(x,y,fact2);
1658   e1->applySimilarity(x,y,fact2);
1659   CPPUNIT_ASSERT_DOUBLES_EQUAL(62.132034355964237,fact2,1e-13);
1660   CPPUNIT_ASSERT_DOUBLES_EQUAL(1.2640792652913602,e1->getCurveLength(),1e-14);
1661   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.034741420428165526,e1->getAreaOfZone(),1e-13);
1662   e1->decrRef();
1663 }
1664
1665 void QuadraticPlanarInterpTest::checkMakePartitionAbs1()
1666 {
1667   INTERP_KERNEL::QUADRATIC_PLANAR::setPrecision(1e-14);
1668   Node *n0=new Node(0.,0.);                Node *n4=new Node(0.5,0.25);
1669   Node *n1=new Node(0.,0.5);               Node *n5=new Node(0.3,1.2);
1670   Node *n2=new Node(1.,0.5);               Node *n6=new Node(1.1,1.3);
1671   Node *n3=new Node(1.,0.);                Node *n7=new Node(-0.1,0.9);
1672   EdgeLin *e0_1=new EdgeLin(n0,n1);
1673   EdgeLin *e1_2=new EdgeLin(n1,n2);        EdgeLin *e4_5=new EdgeLin(n4,n5);
1674   EdgeLin *e2_3=new EdgeLin(n2,n3);        EdgeLin *e5_6=new EdgeLin(n5,n6);
1675   EdgeLin *e3_0=new EdgeLin(n3,n0);        EdgeLin *e6_4=new EdgeLin(n6,n4);
1676   EdgeLin *e4_7=new EdgeLin(n4,n7);        EdgeLin *e7_5=new EdgeLin(n7,n5);
1677   QuadraticPolygon pol1; pol1.pushBack(e0_1); pol1.pushBack(e1_2); pol1.pushBack(e2_3); pol1.pushBack(e3_0);
1678   QuadraticPolygon pol2; pol2.pushBack(e4_5); pol2.pushBack(e5_6); pol2.pushBack(e6_4);
1679   pol2.pushBack(e7_5); e4_5->incrRef(); pol2.pushBack(new ElementaryEdge(e4_5,false)); pol2.pushBack(e4_7);
1680   n0->decrRef(); n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef(); n7->decrRef();
1681   pol1.dumpInXfigFileWithOther(pol2,"tony.fig");
1682 }
1683
1684 }