src/MEDCoupling_Swig/MEDCouplingIntersectTest.py

   1 #  -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21
  22 import sys
  23 if sys.platform == "win32":
  24     from MEDCouplingCompat import *
  25 else:
  26     from medcoupling import *
  27 import unittest
  28 from math import pi,e,sqrt,cos,sin
  29 from datetime import datetime
  30 from MEDCouplingDataForTest import MEDCouplingDataForTest
  31 import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@edf.fr
  32
  33 class MEDCouplingIntersectTest(unittest.TestCase):
  34     def testSwig2NonRegressionBugIntersectMeshes1(self):
  35         src=MEDCouplingUMesh("src",2)
  36         src.setCoords(DataArrayDouble([-2.5,-3,-2.5,3,2.5,3],3,2))
  37         src.allocateCells()
  38         src.insertNextCell(NORM_TRI3,[0,1,2])
  39         #
  40         trg=MEDCouplingUMesh("trg",2)
  41         trg.setCoords(DataArrayDouble([-2.5,-3.,0.,-3.,0.,-2.,-2.,0.,-2.25,0.,-2.5,0.,-2.5,-1.5,0.,-2.5,-1.25,-3.,-1.414213562373095,-1.414213562373095],10,2))
  42         trg.allocateCells()
  43         trg.insertNextCell(NORM_QPOLYG,[2,1,0,5,3,7,8,6,4,9])
  44         #
  45         a,b,c=MEDCouplingUMesh.Intersect2DMeshes(src,trg,1.0e-8)
  46         a.mergeNodes(1e-8)
  47         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([-2.5,-3.,-2.5,3.,2.5,3.,0.,-3.,0.,-2.,-2.,0.,-2.25,0.,-2.5,0.,-2.5,-1.5,0.,-2.5,-1.25,-3.,-1.414213562373095,-1.414213562373095,-1.2803687993289596,-1.5364425591947515,-1.8901843996644798,-2.2682212795973755,-1.81117884244736,-0.8483107924994473,-2.5,1.5,0.,3.,0.6098156003355202,0.7317787204026243],18,2),1e-12))
  48         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([32,12,0,7,5,13,8,6,14,32,7,1,2,12,5,15,16,17,14,6])))
  49         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,9,20])))
  50         self.assertTrue(b.isEqual(DataArrayInt([0,0])))
  51         self.assertTrue(c.isEqual(DataArrayInt([0,-1])))
  52         pass
  53
  54     def testIntersect2DMeshesTmp1(self):
  55         m1c=MEDCouplingCMesh.New();
  56         coordsX=DataArrayDouble.New();
  57         arrX=[ -1., 1., 2., 4. ]
  58         coordsX.setValues(arrX,4,1);
  59         m1c.setCoordsAt(0,coordsX);
  60         coordsY=DataArrayDouble.New();
  61         arrY=[ -2., 2., 4., 8. ]
  62         coordsY.setValues(arrY,4,1);
  63         m1c.setCoordsAt(1,coordsY);
  64         m1=m1c.buildUnstructured()
  65         m1bis=m1.buildPartOfMySelf([3,4,5],False)
  66         m2=m1.deepCopy()
  67         m2=m2.buildPartOfMySelf([0,1,2],False)
  68         m2.translate([0.5,0.5])
  69         #
  70         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
  71         expected1=[0,0,1,1,1,2,2,2]
  72         expected2=[0,-1,0,1,-1,1,2,-1]
  73         self.assertEqual(8,d1.getNumberOfTuples());
  74         self.assertEqual(8,d2.getNumberOfTuples());
  75         self.assertEqual(8,m3.getNumberOfCells());
  76         self.assertEqual(22,m3.getNumberOfNodes());
  77         self.assertEqual(2,m3.getSpaceDimension());
  78         self.assertEqual(expected1,d1.getValues());
  79         self.assertEqual(expected2,d2.getValues());
  80         expected3=[5,17,1,16,12,5,16,0,4,5,17,12,5,18,1,17,13,5,19,2,18,13,5,17,5,6,19,13,5,20,2,19,14,5,21,3,20,14,5,19,6,7,21,14]
  81         expected4=[0,5,12,17,22,28,33,38,44]
  82         expected5=[-1.0,2.0,1.0,2.0,2.0,2.0,4.0,2.0,-1.0,4.0,1.0,4.0,2.0,4.0,4.0,4.0,-0.5,-1.5,1.5,-1.5,2.5,-1.5,4.5,-1.5,-0.5,2.5,1.5,2.5,2.5,2.5,4.5,2.5,-0.5,2.0,1.0,2.5,1.5,2.0,2.0,2.5,2.5,2.0,4.0,2.5]
  83         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
  84         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
  85         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
  86         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
  87         for i in range(44):
  88             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
  89             pass
  90         pass
  91
  92     def testIntersect2DMeshesTmp2(self):
  93         m1c=MEDCouplingCMesh.New();
  94         coordsX1=DataArrayDouble.New();
  95         arrX1=[ 0., 1., 1.5, 2. ]
  96         coordsX1.setValues(arrX1,4,1);
  97         m1c.setCoordsAt(0,coordsX1);
  98         coordsY1=DataArrayDouble.New();
  99         arrY1=[ 0., 1.5, 3.]
 100         coordsY1.setValues(arrY1,3,1);
 101         m1c.setCoordsAt(1,coordsY1);
 102         m1=m1c.buildUnstructured();
 103         m2c=MEDCouplingCMesh.New();
 104         coordsX2=DataArrayDouble.New();
 105         arrX2=[ 0., 1., 2. ]
 106         coordsX2.setValues(arrX2,3,1);
 107         m2c.setCoordsAt(0,coordsX2);
 108         coordsY2=DataArrayDouble.New();
 109         arrY2=[ 0., 1., 3.]
 110         coordsY2.setValues(arrY2,3,1);
 111         m2c.setCoordsAt(1,coordsY2);
 112         m2=m2c.buildUnstructured();
 113         #
 114         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
 115         #
 116         expected1=[0,0,1,1,2,2,3,4,5]
 117         expected2=[0,2,1,3,1,3,2,3,3]
 118         self.assertEqual(9,d1.getNumberOfTuples());
 119         self.assertEqual(9,d2.getNumberOfTuples());
 120         self.assertEqual(9,m3.getNumberOfCells());
 121         self.assertEqual(22,m3.getNumberOfNodes());
 122         self.assertEqual(2,m3.getSpaceDimension());
 123         self.assertEqual(expected1,d1.getValues());
 124         self.assertEqual(expected2,d2.getValues());
 125         expected3=[5,16,13,12,15,5,15,4,5,16,5,21,2,13,16,5,16,5,6,21,5,17,14,2,21,5,21,6,7,17,5,4,18,19,5,5,5,19,10,6,5,6,10,20,7]
 126         expected4=[0,5,10,15,20,25,30,35,40,45]
 127         expected5=[0.0,0.0,1.0,0.0,1.5,0.0,2.0,0.0,0.0,1.5,1.0,1.5,1.5,1.5,2.0,1.5,0.0,3.0,1.0,3.0,1.5,3.0,2.0,3.0,0.0,0.0,1.0,0.0,2.0,0.0,0.0,1.0,1.0,1.0,2.0,1.0,0.0,3.0,1.0,3.0,2.0,3.0,1.5,1.0]
 128         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
 129         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
 130         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
 131         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
 132         for i in range(44):
 133             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
 134             pass
 135         pass
 136
 137     def testIntersect2DMeshesTmp3(self):
 138         m1Coords=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1,0.,-1.5,0.5,0.,1.25,0.,0.70710678118654757,0.70710678118654757,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.70710678118654757,0.70710678118654757,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.70710678118654757,-0.70710678118654757,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.70710678118654757,-0.70710678118654757,1.0606601717798214,-1.0606601717798214];
 139         m1Conn=[0,3,1,13,11,9, 3,4,2,1,14,12,10,11, 5,3,0,15,13,17, 6,4,3,5,16,14,15,18, 5,0,7,17,21,19, 6,5,7,8,18,19,22,20, 0,1,7,9,23,21, 1,2,8,7,10,24,22,23];
 140         m1=MEDCouplingUMesh.New();
 141         m1.setMeshDimension(2);
 142         m1.allocateCells(8);
 143         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
 144         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
 145         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
 146         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
 147         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
 148         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
 149         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
 150         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
 151         m1.finishInsertingCells();
 152         myCoords1=DataArrayDouble.New();
 153         myCoords1.setValues(m1Coords,25,2);
 154         m1.setCoords(myCoords1);
 155         #
 156         m2Coords=[0.,0.,1.1,0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1,-1.1,-1.,0.,-1.,1.1,-1,1.7,-1.]
 157         m2Conn=[0,3,2,1, 1,2,5,4, 7,6,3,0, 8,9,6,7, 7,0,12,11, 8,7,11,10, 0,1,13,12, 1,4,14,13]
 158         m2=MEDCouplingUMesh.New();
 159         m2.setMeshDimension(2);
 160         m2.allocateCells(8);
 161         for i in range(8):
 162             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
 163             pass
 164         m2.finishInsertingCells();
 165         myCoords2=DataArrayDouble.New();
 166         myCoords2.setValues(m2Coords,15,2);
 167         m2.setCoords(myCoords2);
 168         #
 169         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
 170         m3.unPolyze()
 171         #
 172         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
 173         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
 174         self.assertEqual(16,d1.getNumberOfTuples());
 175         self.assertEqual(16,d2.getNumberOfTuples());
 176         self.assertEqual(16,m3.getNumberOfCells());
 177         self.assertEqual(104,m3.getNumberOfNodes());
 178         self.assertEqual(2,m3.getSpaceDimension());
 179         self.assertEqual(expected1,d1.getValues());
 180         self.assertEqual(expected2,d2.getValues());
 181         expected3=[6,28,1,25,44,45,46,8,26,1,28,27,47,48,49,50,8,40,2,26,27,51,52,53,54,8,28,4,40,27,55,56,57,58,6,28,25,5,59,60,61,8,28,5,32,31,62,63,64,65,8,32,6,41,31,66,67,68,69,8,41,4,28,31,70,71,72,73,6,25,37,5,74,75,76,8,32,5,37,36,77,78,79,80,8,42,6,32,36,81,82,83,84,8,37,8,42,36,85,86,87,88,6,1,37,25,89,90,91,8,37,1,26,38,92,93,94,95,8,26,2,43,38,96,97,98,99,8,43,8,37,38,100,101,102,103]
 182         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
 183         expected5=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1.,0.,-1.5,0.5,0.,1.25,0.,0.7071067811865476,0.7071067811865476,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.7071067811865476,0.7071067811865476,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.7071067811865476,-0.7071067811865476,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.7071067811865476,-0.7071067811865476,1.0606601717798214,-1.0606601717798214,0.,0.,1.1,0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1.,-1.1,-1.,0.,-1.,1.1,-1.,1.7,-1.,1.118033988749895,1.,-1.118033988749895,1.,-1.118033988749895,-1.,1.118033988749895,-1.,0.7071067811865477,0.7071067811865476,0.5,0.,0.,0.5,1.05,0.,0.7071067811865475,0.7071067811865477,0.55,1.,1.1,0.5,1.4012585384440737,0.535233134659635,1.3,0.,1.1,0.5,1.1090169943749475,1.,0.,1.25,0.6123724356957946,1.369306393762915,1.1090169943749475,1.,0.55,1.,0.,0.5,-0.5,0.,-0.7071067811865477,0.7071067811865476,-0.7071067811865475,0.7071067811865477,-1.05,0.,-1.1,0.5,-0.55,1.,-1.3,0.,-1.4012585384440737,0.5352331346596344,-1.1090169943749475,1.,-1.1,0.5,-0.6123724356957941,1.3693063937629155,0.,1.25,-0.55,1.,-1.1090169943749475,1.,0.,-0.5,-0.7071067811865475,-0.7071067811865477,-0.5,0.,-1.05,0.,-0.7071067811865478,-0.7071067811865475,-0.55,-1.,-1.1,-0.5,-1.4012585384440734,-0.5352331346596354,-1.3,0.,-1.1,-0.5,-1.1090169943749475,-1.,0.,-1.25,-0.6123724356957945,-1.369306393762915,-1.1090169943749475,-1.,-0.55,-1.,0.7071067811865475,-0.7071067811865477,0.,-0.5,0.5,0.,0.7071067811865477,-0.7071067811865475,1.05,0.,1.1,-0.5,0.55,-1.,1.3,0.,1.4012585384440737,-0.535233134659635,1.1090169943749475,-1.,1.1,-0.5,0.6123724356957946,-1.369306393762915,0.,-1.25,0.55,-1.,1.1090169943749475,-1.0]
 184         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
 185         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
 186         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
 187         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
 188         for i in range(208):
 189             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
 190             pass
 191         pass
 192
 193     def testIntersect2DMeshesTmp4(self):
 194         m1Coords=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1,0.,-1.5,0.5,0.,1.25,0.,0.70710678118654757,0.70710678118654757,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.70710678118654757,0.70710678118654757,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.70710678118654757,-0.70710678118654757,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.70710678118654757,-0.70710678118654757,1.0606601717798214,-1.0606601717798214];
 195         m1Conn=[0,3,1,13,11,9, 3,4,2,1,14,12,10,11, 5,3,0,15,13,17, 6,4,3,5,16,14,15,18, 5,0,7,17,21,19, 6,5,7,8,18,19,22,20, 0,1,7,9,23,21, 1,2,8,7,10,24,22,23];
 196         m1=MEDCouplingUMesh.New();
 197         m1.setMeshDimension(2);
 198         m1.allocateCells(8);
 199         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
 200         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
 201         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
 202         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
 203         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
 204         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
 205         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
 206         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
 207         m1.finishInsertingCells();
 208         myCoords1=DataArrayDouble.New();
 209         myCoords1.setValues(m1Coords,25,2);
 210         m1.setCoords(myCoords1);
 211         #
 212         m2Coords=[0.,0.,1.1,0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1,-1.1,-1.,0.,-1.,1.1,-1,1.7,-1.]
 213         m2Conn=[0,3,2,1, 1,2,5,4, 7,6,3,0, 8,9,6,7, 7,0,12,11, 8,7,11,10, 0,1,13,12, 1,4,14,13]
 214         m2=MEDCouplingUMesh.New();
 215         m2.setMeshDimension(2);
 216         m2.allocateCells(8);
 217         for i in range(8):
 218             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
 219             pass
 220         m2.finishInsertingCells();
 221         myCoords2=DataArrayDouble.New();
 222         myCoords2.setValues(m2Coords,15,2);
 223         m2.setCoords(myCoords2);
 224         #
 225         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
 226         m3.unPolyze()
 227         #
 228         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
 229         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
 230         self.assertEqual(16,d1.getNumberOfTuples());
 231         self.assertEqual(16,d2.getNumberOfTuples());
 232         self.assertEqual(16,m3.getNumberOfCells());
 233         self.assertEqual(104,m3.getNumberOfNodes());
 234         self.assertEqual(2,m3.getSpaceDimension());
 235         self.assertEqual(expected1,d1.getValues());
 236         self.assertEqual(expected2,d2.getValues());
 237         expected3=[6,16,15,18,44,45,46,8,18,2,1,16,47,48,49,50,8,17,1,2,40,51,52,53,54,8,40,5,4,17,55,56,57,58,6,18,15,20,59,60,61,8,20,7,6,18,62,63,64,65,8,41,6,7,21,66,67,68,69,8,21,8,9,41,70,71,72,73,6,20,15,22,74,75,76,8,22,11,7,20,77,78,79,80,8,21,7,11,42,81,82,83,84,8,42,10,8,21,85,86,87,88,6,22,15,16,89,90,91,8,16,1,13,22,92,93,94,95,8,43,13,1,17,96,97,98,99,8,17,4,14,43,100,101,102,103]
 238         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
 239         expected5=[0.,0.,1.1, 0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1.,-1.1,-1.,0.,-1.,1.1,-1.,1.7,-1.,0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1.,0.,-1.5,0.5,0.,1.25,0.,0.7071067811865476,0.7071067811865476,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.7071067811865476,0.7071067811865476,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.7071067811865476,-0.7071067811865476,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.7071067811865476,-0.7071067811865476,1.0606601717798214,-1.0606601717798214,1.1180339887498951,1.,-1.1180339887498951,1.,-1.1180339887498951,-1.,1.1180339887498951,-1.,0.5,0.,0.,0.5,0.7071067811865477,0.7071067811865476,0.55,1.,1.1,0.5,1.05,0.,0.7071067811865477,0.7071067811865475,1.3,0.,1.1,0.5,1.1090169943749475,1.,1.4012585384440737,0.535233134659635,1.4090169943749475,1.,1.7,0.5,1.6,0.,1.4012585384440737,0.535233134659635,0.,0.5,-0.5,0.,-0.7071067811865477,0.7071067811865476,-1.05,0.,-1.1,0.5,-0.55,1.,-0.7071067811865478,0.7071067811865475,-1.1090169943749475,1.,-1.1,0.5,-1.3,0.,-1.4012585384440737,0.5352331346596344,-1.6,0.,-1.7,0.5,-1.4090169943749475,1.,-1.4012585384440737,0.5352331346596344,-0.5,0.,0.,-0.5,-0.7071067811865475,-0.7071067811865477,-0.55,-1.,-1.1,-0.5,-1.05,0.,-0.7071067811865475,-0.7071067811865477,-1.3,0.,-1.1,-0.5,-1.1090169943749475,-1.,-1.4012585384440734,-0.5352331346596354,-1.4090169943749475,-1.,-1.7,-0.5,-1.6,0.,-1.4012585384440732,-0.5352331346596354,0.,-0.5,0.5,0.,0.7071067811865475,-0.7071067811865477,1.05,0.,1.1,-0.5,0.55,-1.,0.7071067811865475,-0.7071067811865477,1.1090169943749475,-1.,1.1,-0.5,1.3,0.,1.4012585384440737,-0.535233134659635,1.6,0.,1.7,-0.5,1.4090169943749475,-1.,1.4012585384440737,-0.535233134659635]
 240         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
 241         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
 242         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
 243         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
 244         for i in range(208):
 245             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
 246             pass
 247         pass
 248
 249     def testIntersect2DMeshesTmp5(self):
 250         coords=DataArrayDouble.New([41,0,42,0,0,42,0,41,41.5,0,29.698484809834998,29.698484809834994,0,41.5,28.991378028648452,28.991378028648445,-42,0,-41,0,-29.698484809834994,29.698484809834998,-41.5,0,-28.991378028648445,28.991378028648452,0,-42,0,-41,-29.698484809835001,-29.698484809834994,0,-41.5,-28.991378028648455,-28.991378028648445,29.698484809834987,-29.698484809835001,28.991378028648441,-28.991378028648455,43,0,0,43,42.5,0,30.405591591021544,30.40559159102154,0,42.5,-43,0,-30.40559159102154,30.405591591021544,-42.5,0,0,-43,-30.405591591021551,-30.40559159102154,0,-42.5,30.405591591021537,-30.405591591021551,44,0,0,44,43.5,0,31.112698372208094,31.112698372208087,0,43.5,-44,0,-31.112698372208087,31.112698372208094,-43.5,0,0,-44,-31.112698372208097,-31.112698372208087,0,-43.5,31.112698372208083,-31.112698372208097,45,0,0,45,44.5,0,31.81980515339464,31.819805153394636,0,44.5,-45,0,-31.819805153394636,31.81980515339464,-44.5,0,0,-45,-31.819805153394647,-31.819805153394636,0,-44.5,31.819805153394629,-31.819805153394647,47,0,0,47,46,0,33.234018715767739,33.234018715767732,0,46,-47,0,-33.234018715767732,33.234018715767739,-46,0,0,-47,-33.234018715767739,-33.234018715767732,0,-46,33.234018715767725,-33.234018715767739,49,0,0,49,48,0,34.648232278140831,34.648232278140824,0,48,-49,0,-34.648232278140824,34.648232278140831,-48,0,0,-49,-34.648232278140839,-34.648232278140824,0,-48,34.648232278140817,-34.648232278140839,51,0,0,51,50,0,36.062445840513924,36.062445840513924,0,50,-51,0,-36.062445840513924,36.062445840513924,-50,0,0,-51,-36.062445840513931,-36.062445840513924,0,-50,36.062445840513917,-36.062445840513931,53,0,0,53,52,0,37.476659402887023,37.476659402887016,0,52,-53,0,-37.476659402887016,37.476659402887023,-52,0,0,-53,-37.47665940288703,-37.476659402887016,0,-52,37.476659402887009,-37.47665940288703,55,0,0,55,54,0,38.890872965260115,38.890872965260108,0,54,-55,0,-38.890872965260108,38.890872965260115,-54,0,0,-55,-38.890872965260122,-38.890872965260108,0,-54,38.890872965260101,-38.890872965260122,59,0,0,59,57,0,41.719300090006307,41.7193000900063,0,57,-59,0,-41.7193000900063,41.719300090006307,-57,0,0,-59,-41.719300090006314,-41.7193000900063,0,-57,41.719300090006293,-41.719300090006314,63,0,0,63,61,0,44.547727214752499,44.547727214752491,0,61,-63,0,-44.547727214752491,44.547727214752499,-61,0,0,-63,-44.547727214752506,-44.547727214752491,0,-61,44.547727214752484,-44.547727214752506,67,0,0,67,65,0,47.37615433949869,47.376154339498683,0,65,-67,0,-47.376154339498683,47.37615433949869,-65,0,0,-67,-47.376154339498697,-47.376154339498683,0,-65,47.376154339498676,-47.376154339498697,71,0,0,71,69,0,50.204581464244875,50.204581464244868,0,69,-71,0,-50.204581464244868,50.204581464244875,-69,0,0,-71,-50.204581464244889,-50.204581464244868,0,-69,50.20458146424486,-50.204581464244889,75,0,0,75,73,0,53.033008588991066,53.033008588991059,0,73,-75,0,-53.033008588991059,53.033008588991066,-73,0,0,-75,-53.033008588991073,-53.033008588991059,0,-73,53.033008588991052,-53.033008588991073,80,0,0,80,77.5,0,56.568542494923804,56.568542494923797,0,77.5,-80,0,-56.568542494923797,56.568542494923804,-77.5,0,0,-80,-56.568542494923818,-56.568542494923797,0,-77.5,56.56854249492379,-56.568542494923818],188,2)
 251         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12,8,9,8,13,14,11,15,16,17,8,14,13,1,0,16,18,4,19,8,1,20,21,2,22,23,24,5,8,2,21,25,8,24,26,27,10,8,8,25,28,13,27,29,30,15,8,13,28,20,1,30,31,22,18,8,20,32,33,21,34,35,36,23,8,21,33,37,25,36,38,39,26,8,25,37,40,28,39,41,42,29,8,28,40,32,20,42,43,34,31,8,32,44,45,33,46,47,48,35,8,33,45,49,37,48,50,51,38,8,37,49,52,40,51,53,54,41,8,40,52,44,32,54,55,46,43,8,44,56,57,45,58,59,60,47,8,45,57,61,49,60,62,63,50,8,49,61,64,52,63,65,66,53,8,52,64,56,44,66,67,58,55,8,56,68,69,57,70,71,72,59,8,57,69,73,61,72,74,75,62,8,61,73,76,64,75,77,78,65,8,64,76,68,56,78,79,70,67,8,68,80,81,69,82,83,84,71,8,69,81,85,73,84,86,87,74,8,73,85,88,76,87,89,90,77,8,76,88,80,68,90,91,82,79,8,80,92,93,81,94,95,96,83,8,81,93,97,85,96,98,99,86,8,85,97,100,88,99,101,102,89,8,88,100,92,80,102,103,94,91,8,92,104,105,93,106,107,108,95,8,93,105,109,97,108,110,111,98,8,97,109,112,100,111,113,114,101,8,100,112,104,92,114,115,106,103,8,104,116,117,105,118,119,120,107,8,105,117,121,109,120,122,123,110,8,109,121,124,112,123,125,126,113,8,112,124,116,104,126,127,118,115,8,116,128,129,117,130,131,132,119,8,117,129,133,121,132,134,135,122,8,121,133,136,124,135,137,138,125,8,124,136,128,116,138,139,130,127,8,128,140,141,129,142,143,144,131,8,129,141,145,133,144,146,147,134,8,133,145,148,136,147,149,150,137,8,136,148,140,128,150,151,142,139,8,140,152,153,141,154,155,156,143,8,141,153,157,145,156,158,159,146,8,145,157,160,148,159,161,162,149,8,148,160,152,140,162,163,154,151,8,152,164,165,153,166,167,168,155,8,153,165,169,157,168,170,171,158,8,157,169,172,160,171,173,174,161,8,160,172,164,152,174,175,166,163,8,164,176,177,165,178,179,180,167,8,165,177,181,169,180,182,183,170,8,169,181,184,172,183,185,186,173,8,172,184,176,164,186,187,178,175],540)
 252         connI=DataArrayInt.New([0,9,18,27,36,45,54,63,72,81,90,99,108,117,126,135,144,153,162,171,180,189,198,207,216,225,234,243,252,261,270,279,288,297,306,315,324,333,342,351,360,369,378,387,396,405,414,423,432,441,450,459,468,477,486,495,504,513,522,531,540],61)
 253         #
 254         m1=MEDCouplingUMesh.New("Fix",2);
 255         m1.setCoords(coords);
 256         m1.setConnectivity(conn,connI,True);
 257         #
 258         coords=DataArrayDouble([46.5,-2.5,53.5,-2.5,53.5,2.5,46.5,2.5,50,-2.5,53.5,0,50,2.5,46.5,0,60.5,-2.5,60.5,2.5,57,-2.5,60.5,0,57,2.5,53.5,7.5,46.5,7.5,53.5,5,50,7.5,46.5,5,60.5,7.5,60.5,5,57,7.5,-2,47,2,47,2,53,-2,53,0,47,2,50,0,53,-2,50,6,47,6,53,4,47,6,50,4,53,2,59,-2,59,2,56,0,59,-2,56,6,59,6,56,4,59],42,2)
 259         # connectivity
 260         conn=DataArrayInt([8,0,1,2,3,4,5,6,7,8,1,8,9,2,10,11,12,5,8,3,2,13,14,6,15,16,17,8,2,9,18,13,12,19,20,15,8,21,22,23,24,25,26,27,28,8,22,29,30,23,31,32,33,26,8,24,23,34,35,27,36,37,38,8,23,30,39,34,33,40,41,36],72);
 261         conn.setName("");
 262         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
 263         m2=MEDCouplingUMesh.New("Mobile",2);
 264         m2.setCoords(coords);
 265         m2.setConnectivity(conn,connI,True);
 266         #
 267         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
 268         self.assertEqual(105,m3.getNumberOfCells());
 269         self.assertEqual(105,d1.getNumberOfTuples());
 270         self.assertEqual(105,d2.getNumberOfTuples());
 271         self.assertEqual(704,m3.getNumberOfNodes());
 272         #
 273         areaExpected=[-65.18804756198824,-65.18804756198824,-65.18804756198824,-65.18804756198824,-66.75884388878285,-66.75884388878285,-66.7588438887833,-66.75884388878308,-68.32964021557768,-68.32964021557768,-68.32964021557814,-68.32964021557791,-69.9004365423732,-69.9004365423732,-69.90043654237297,-69.90043654237297,-1.194568659706448,-1.0869994447159463,-142.2316939607081,-144.51326206513068,-144.5132620651309,-1.1945686597064424,-143.3186934054243,-5.002264310862817,-10.0261332846393,-3.9727823117092953,-7.290862524642649,-124.504404940456,-3.9727823117093237,-146.82366506060032,-150.79644737231024,-5.002264310862776,-145.79418306144626,-5.00208651738126,-10.054764051268958,-4.001067863263231,-8.027932154428669,-129.99378209314813,-4.001067863263216,-153.07856481622616,-157.0796326794898,-5.0020865173811915,-152.07754616210832,-5.001928880064381,-10.050590216368969,-4.00098721602491,-8.025810856794209,-136.28350081741684,-4.000987216024939,-159.36183077064402,-163.36281798667005,-5.0019288800643285,-158.36088910660442,-1.2991516319851801,-3.702636830195414,-3.7815130030068254,-6.265364371195623,-0.02516260900254963,-0.6553944641345026,-3.975752765070567,-7.368528340442765,-142.57249927881398,-0.02516260900254963,-3.9757527650706095,-165.64508791977525,-169.64600329384803,-1.299151631985167,-3.7026368301953885,-164.6442148316677,-10.00321285677458,-20.08414323176165,-8.001644468035863,-16.042954878437143,-304.0096070742277,-8.00164446803587,-350.1399180412005,-358.1415625092368,-10.003212856774468,-348.13834965246224,-3.794150313030109,-8.65049239704272,-0.02260276689354157,-0.5885167811200915,-370.2185414798688,-0.022602766893559393,-383.2517009710623,-383.2743037379555,-3.7941503130300576,-379.48015342492505,-408.40704496667513,-408.4070449666742,-408.4070449666742,-408.4070449666742,-433.53978619538975,-433.5397861953902,-433.5397861953911,-433.53978619539066,-458.67252742410983,-458.6725274241094,-458.67252742410983,-458.6725274241089,-608.6835766330232,-608.6835766330232,-608.6835766330232,-608.6835766330241]
 274         expected1=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,16,16,17,18,19,19,20,20,20,20,20,21,21,22,23,23,24,24,24,24,24,25,25,26,27,27,28,28,28,28,28,29,29,30,31,31,32,32,32,32,32,32,32,32,32,33,33,33,34,35,35,35,36,36,36,36,36,37,37,38,39,39,40,40,40,40,40,41,41,42,43,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59]
 275         expected2=[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,2,-1,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,1,2,3,4,5,6,7,-1,4,6,-1,-1,0,1,-1,1,3,6,7,-1,6,-1,-1,1,-1,1,3,6,7,-1,6,-1,-1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
 276         f3=m3.getMeasureField(False).getArray().getValues();
 277         for i in range(105):
 278             self.assertAlmostEqual(areaExpected[i],f3[i],10)
 279             pass
 280         self.assertEqual(expected1,d1.getValues())
 281         self.assertEqual(expected2,d2.getValues())
 282         pass
 283
 284     def testIntersect2DMeshesTmp6(self):
 285         # coordinates
 286         coords=DataArrayDouble.New([2.7554552980815448e-15,45,-45,5.5109105961630896e-15,-31.819805153394636,31.81980515339464,2.8779199779962799e-15,47,2.8166876380389124e-15,46,-47,5.7558399559925599e-15,-33.234018715767732,33.234018715767739,-46,5.6333752760778247e-15],8,2);
 287         # connectivity
 288         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
 289         connI=DataArrayInt.New([0,9]);
 290         m1=MEDCouplingUMesh.New("Fixe",2);
 291         m1.setCoords(coords);
 292         m1.setConnectivity(conn,connI,True);
 293         #
 294         coords=DataArrayDouble.New([-7.3800475508445391,41.854329503018846,-3.7041190667754655,42.338274668899189,-3.7041190667754655,45.338274668899189,-7.3800475508445382,44.854329503018839,-5.5473631693521845,42.136406608386956,-3.7041190667754655,43.838274668899189,-5.5420833088100014,45.09630208595901,-7.3800475508445382,43.354329503018839,-3.7041190667754651,52.338274668899189,-7.3800475508445382,51.854329503018839,-3.7041190667754655,48.838274668899189,-5.5420833088100014,52.09630208595901,-7.3800475508445382,48.354329503018839],13,2);
 295         # connectivity
 296         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
 297         connI=DataArrayInt.New([0,9,18]);
 298         #
 299         m2=MEDCouplingUMesh.New("Mobile",2);
 300         m2.setCoords(coords);
 301         m2.setConnectivity(conn,connI,True);
 302         #
 303         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
 304         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
 305         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
 306         self.assertEqual(4,m3.getNumberOfCells());
 307         self.assertEqual(4,d1.getNumberOfTuples());
 308         self.assertEqual(4,d2.getNumberOfTuples());
 309         self.assertEqual(43,m3.getNumberOfNodes());
 310         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
 311         self.assertEqual(35,m3.getNumberOfNodes());
 312         m3.zipCoords();
 313         self.assertEqual(23,m3.getNumberOfNodes());
 314         #
 315         f=m3.getMeasureField(True);
 316         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
 317         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
 318         pass
 319
 320     def testIntersect2DMeshes7(self):
 321         """ Quadratic precision values were improperly reset before testing colinearities """
 322         eps = 1.0e-08
 323         mesh1 = MEDCouplingUMesh('assemblyGrid_Pij', 2)
 324         coo = DataArrayDouble([(10.80630000000000,10.80630000000000),(9.48750000000000,10.80630000000000),(10.75250000000000,10.80630000000000),(9.48750000000000,9.48750000000000),(10.75250000000000,9.48750000000000),(10.80630000000000,9.48750000000000),(9.48750000000000,10.75250000000000),(10.75250000000000,10.75250000000000),(10.80630000000000,10.75250000000000)])
 325         mesh1.setCoords(coo)
 326         c = DataArrayInt([5, 4, 3, 6, 7, 5, 5, 4, 7, 8, 5, 1, 2, 7, 6, 5, 2, 0, 8, 7])
 327         cI = DataArrayInt([0, 5, 10, 15, 20])
 328         mesh1.setConnectivity(c, cI)
 329         mesh2 = MEDCouplingUMesh('merge', 2)
 330         coo = DataArrayDouble([(9.48750000000001,9.48750000000001),(10.75249999999975,9.48749999999955),(10.12000000000001,9.48750000000001),(10.80629999999976,9.48749999999955),(8.22250000000029,10.75250000000028),(9.48749999999961,10.75249999999971),(8.85500000000029,10.75250000000028),(9.48750000000001,10.12000000000001),(10.75249999999338,10.75249999999338),(10.41000000000001,10.12000000000001),(10.32506096654411,10.32506096654411),(10.12000000000001,10.41000000000001),(9.91493903345591,10.32506096654411),(9.83000000000001,10.12000000000001),(9.91493903345591,9.91493903345591),(10.12000000000001,9.83000000000001),(10.32506096654411,9.91493903345591),(10.11999999999961,10.75249999999971),(10.75249999999975,10.11999999999958),(10.49000000000001,10.12000000000001),(10.38162950903903,10.38162950903903),(10.12000000000001,10.49000000000001),(9.85837049096099,10.38162950903903),(9.75000000000001,10.12000000000001),(9.85837049096099,9.85837049096099),(10.12000000000001,9.75000000000001),(10.38162950903903,9.85837049096099),(9.88665476220845,10.35334523779157),(9.88665476220845,9.88665476220845),(9.67293524548050,9.67293524548050),(9.67293524548050,10.56706475451952),(10.80629999999339,10.75249999999338),(8.22250000000029,10.80630000000028),(9.48749999999961,10.80629999999971),(10.75249999999338,10.80629999999339),(10.80629999999339,10.80629999999339),(10.77939999999976,9.48749999999955),(10.77939999999339,10.75249999999338),(10.80629999999976,10.11999999999958),(8.22250000000029,10.77940000000028),(8.85500000000029,10.80630000000028),(9.48749999999961,10.77939999999971),(10.11999999999961,10.80629999999971),(10.75249999999338,10.77939999999339),(10.77939999999339,10.80629999999339),(10.80629999999339,10.77939999999339)])
 331         mesh2.setCoords(coo)
 332         c = DataArrayInt([32, 4, 32, 33, 5, 39, 40, 41, 6, 32, 5, 33, 34, 8, 41, 42, 43, 17, 32, 8, 34, 35, 31, 43, 44, 45, 37, 32, 14, 12, 10, 16, 13, 11, 9, 15, 32, 22, 12, 14, 24, 27, 13, 28, 23, 32, 24, 0, 5, 22, 29, 7, 30, 23, 32, 24, 14, 16, 10, 12, 22, 20, 26, 28, 15, 9, 11, 27, 21, 19, 25, 32, 22, 5, 8, 1, 0, 24, 26, 20, 30, 17, 18, 2, 29, 25, 19, 21, 32, 1, 8, 31, 3, 18, 37, 38, 36])
 333         cI = DataArrayInt([0, 9, 18, 27, 36, 45, 54, 71, 88, 97])
 334         mesh2.setConnectivity(c, cI)
 335         result, mapResToInit, mapResToRef = MEDCouplingUMesh.Intersect2DMeshes(mesh1, mesh2, eps)
 336         result.zipCoords()
 337         exp_coo = [9.48750000000001, 9.48750000000001, 10.75249999999975, 9.48749999999955, 10.80629999999976, 9.48749999999955, 9.48749999999961, 10.75249999999971, 10.75249999999338, 10.75249999999338, 10.32506096654411, 10.32506096654411, 9.91493903345591, 10.32506096654411, 9.91493903345591, 9.91493903345591, 10.32506096654411, 9.91493903345591, 10.38162950903903, 10.38162950903903, 9.85837049096099, 10.38162950903903, 9.85837049096099, 9.85837049096099, 10.38162950903903, 9.85837049096099, 10.80629999999339, 10.75249999999338, 9.48749999999961, 10.80629999999971, 10.75249999999338, 10.80629999999339, 10.80629999999339, 10.80629999999339, 9.830000000000023, 10.120000000000008, 10.120000000000008, 10.410000000000004, 10.41000000000001, 10.120000000000008, 10.120000000000008, 9.830000000000013, 9.886654762208451, 10.353345237791569, 9.830000000000023, 10.120000000000008, 9.886654762208451, 9.886654762208451, 9.750000000000005, 10.12000000000001, 9.487499999999809, 10.11999999999986, 9.6729352454803, 10.56706475451937, 9.750000000000005, 10.12000000000001, 9.672935245480499, 9.672935245480499, 9.886654762208451, 9.886654762208451, 10.120000000000008, 9.830000000000013, 10.41000000000001, 10.120000000000008, 10.120000000000008, 10.410000000000004, 9.886654762208451, 10.353345237791569, 10.120000000000013, 10.490000000000004, 10.489999999999988, 10.120000000000013, 10.120000000000017, 9.750000000000021, 10.119999999996494, 10.752499999996544, 10.752499999996566, 10.119999999996466, 10.11999999999988, 9.48749999999978, 9.672935245480499, 9.672935245480499, 10.120000000000017, 9.750000000000021, 10.489999999999988, 10.120000000000013, 10.120000000000013, 10.490000000000004, 9.6729352454803, 10.56706475451937]
 338         e1 = [0, 0, 0, 0, 0, 1, 2, 3]
 339         e2 = [3, 4, 5, 6, 7, 8, 1, 2]
 340         valuesExpected=DataArrayDouble(exp_coo, len(exp_coo)//2, 2)
 341         self.assertTrue(result.getCoords().isEqual(valuesExpected,1e-12))
 342         self.assertEqual(e1, mapResToInit.getValues())
 343         self.assertEqual(e2, mapResToRef.getValues())
 344         pass
 345
 346     def testIntersect2DMeshes8(self):
 347         """ Quadratic precision values were improperly reset before testing colinearities
 348         This was also impacting the mapping computation. """
 349         eps = 1.0e-8
 350         mesh1 = MEDCouplingUMesh('assemblyGrid_Pij', 2)
 351         coo = DataArrayDouble([(10.80630000000000,-10.80630000000000),(9.48750000000000,-10.80630000000000),(10.75250000000000,-10.80630000000000),(9.48750000000000,-10.75250000000000),(10.75250000000000,-10.75250000000000),(10.80630000000000,-10.75250000000000),(9.48750000000000,-9.48750000000000),(10.75250000000000,-9.48750000000000),(10.80630000000000,-9.48750000000000)])
 352         mesh1.setCoords(coo)
 353         c = DataArrayInt([5, 2, 1, 3, 4, 5, 0, 2, 4, 5, 5, 4, 3, 6, 7, 5, 5, 4, 7, 8])
 354         cI = DataArrayInt([0, 5, 10, 15, 20])
 355         mesh1.setConnectivity(c, cI)
 356         mesh2 = MEDCouplingUMesh('merge', 2)
 357         coo = DataArrayDouble([(9.48749999999998,-10.75249999999999),(9.48750000000018,-10.80629999999998),(10.75250000000047,-10.75250000000063),(10.75249999999318,-10.80629999999318),(10.80630000000048,-10.75250000000063),(10.80629999999318,-10.80629999999318),(9.48750000000001,-9.48750000000001),(9.48749999999998,-10.11999999999999),(10.75249999999975,-9.48750000000004),(10.40999999999999,-10.11999999999999),(10.32506096654408,-9.91493903345589),(10.11999999999999,-9.82999999999999),(9.91493903345589,-9.91493903345589),(9.82999999999998,-10.11999999999999),(9.91493903345589,-10.32506096654409),(10.11999999999999,-10.40999999999999),(10.32506096654408,-10.32506096654409),(10.12000000000001,-9.48750000000001),(10.75250000000047,-10.12000000000058),(10.12000000000018,-10.75249999999998),(9.70121951672794,-10.53878048327204),(9.70121951672794,-9.70121951672794),(10.80629999999976,-9.48750000000004),(9.48750000000018,-10.77939999999998),(10.75249999999318,-10.77939999999318),(10.12000000000018,-10.80629999999998),(10.77940000000048,-10.75250000000063),(10.80629999999318,-10.77939999999318),(10.77939999999318,-10.80629999999318),(10.77939999999976,-9.48750000000004),(10.80630000000048,-10.12000000000058)])
 358         mesh2.setCoords(coo)
 359         c = DataArrayInt([32, 1, 0, 2, 3, 23, 19, 24, 25, 32, 3, 2, 4, 5, 24, 26, 27, 28, 32, 16, 14, 12, 10, 15, 13, 11, 9, 32, 0, 6, 12, 14, 7, 21, 13, 20, 32, 6, 8, 2, 0, 14, 16, 10, 12, 17, 18, 19, 20, 15, 9, 11, 21, 32, 2, 8, 22, 4, 18, 29, 30, 26])
 360         cI = DataArrayInt([0, 9, 18, 27, 36, 53, 62])
 361         mesh2.setConnectivity(c, cI)
 362         result, mapResToInit, mapResToRef = MEDCouplingUMesh.Intersect2DMeshes(mesh1, mesh2, eps)
 363         result.zipCoords()
 364         exp_coo = [9.48749999999998, -10.75249999999999, 9.48750000000018, -10.80629999999998, 10.75250000000047, -10.75250000000063, 10.75249999999318, -10.80629999999318, 10.80630000000048, -10.75250000000063, 10.80629999999318, -10.80629999999318, 9.48750000000001, -9.48750000000001, 10.75249999999975, -9.48750000000004, 10.32506096654408, -9.91493903345589, 9.91493903345589, -9.91493903345589, 9.91493903345589, -10.32506096654409, 10.32506096654408, -10.32506096654409, 10.80629999999976, -9.48750000000004, 10.119999999999989, -10.409999999999961, 9.829999999999997, -10.11999999999999, 10.119999999999983, -9.830000000000005, 10.409999999999968, -10.119999999999987, 9.487499999999994, -10.120000000000001, 9.70121951672795, -9.70121951672795, 9.829999999999997, -10.11999999999999, 9.701219516727935, -10.53878048327204, 10.11999999999988, -9.487500000000026, 10.752500000000111, -10.120000000000335, 10.120000000000225, -10.75250000000031, 9.701219516727935, -10.53878048327204, 10.119999999999989, -10.409999999999961, 10.409999999999968, -10.119999999999987, 10.119999999999983, -9.830000000000005, 9.70121951672795, -9.70121951672795]
 365         e1 = [0, 1, 2, 2, 2, 3]
 366         e2 = [0, 1, 2, 3, 4, 5]
 367         valuesExpected=DataArrayDouble(exp_coo, len(exp_coo)//2, 2)
 368         self.assertTrue(result.getCoords().isEqual(valuesExpected,1e-10))
 369         self.assertEqual(e1, mapResToInit.getValues())
 370         self.assertEqual(e2, mapResToRef.getValues())
 371         pass
 372
 373     def testIntersect2DMeshes9(self):
 374         """ Last part of the intersection algorithm was not properly dealing with residual cells when
 375         it was a quad polygon just made of 2 edges. Was throwing an exception. """
 376         eps = 1e-6
 377         back = MEDCouplingUMesh('crh7_rse1', 2)
 378         coo = DataArrayDouble([(71.6187499999999915,-10.6521000000000008),(71.0937370510802538,-12.6114750000000022),(71.4852218317702608,-11.6663471329955062),(72.0541666666666600,-10.6521000000000008),(71.8364583333333258,-10.6521000000000008),(71.4708189456447371,-12.8291833333333365),(71.2822779983625026,-12.7203291666666694),(71.9058020353005816,-11.7790412588839590)])
 379         back.setCoords(coo)
 380         c = DataArrayInt([32, 1, 0, 3, 5, 2, 4, 7, 6])
 381         cI = DataArrayInt([0, 9])
 382         back.setConnectivity(c, cI)
 383         tool = MEDCouplingUMesh('merge', 2)
 384         coo = DataArrayDouble([(71.5737767246627783,-14.0122818133993299),(72.5920244490449136,-7.0390015370978469),(47.7780086628800404,-4.6328708831306278)])
 385         tool.setCoords(coo)
 386         c = DataArrayInt([5, 1, 0, 2])
 387         cI = DataArrayInt([0, 4])
 388         tool.setConnectivity(c, cI)
 389
 390         result, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 391         exp_coo = [71.61874999999999, -10.6521, 71.09373705108025, -12.611475000000002, 71.48522183177026, -11.666347132995506, 72.05416666666666, -10.6521, 71.83645833333333, -10.6521, 71.47081894564474, -12.829183333333336, 71.2822779983625, -12.72032916666667, 71.90580203530058, -11.779041258883959, 71.57377672466278, -14.01228181339933, 72.59202444904491, -7.039001537097847, 47.77800866288004, -4.632870883130628, 72.05352566581652, -10.726810361986129, 71.8931109163297, -11.825380957175156, 71.71347100577636, -12.340536509586565, 71.2822779983625, -12.72032916666667, 71.48522183177026, -11.666347132995508, 71.83645833333333, -10.6521, 72.0540064135051, -10.689456555884437, 71.97331829107311, -11.276095659580642, 72.0084757809432, -11.281229403333473, 71.97331829107311, -11.276095659580642]
 392         c = [32, 12, 5, 1, 0, 3, 11, 13, 14, 15, 16, 17, 18, 32, 11, 12, 19, 20]
 393         cI = [0, 13, 18]
 394         e1 = [0, 0]
 395         e2 = [0, -1]
 396         valuesExpected = DataArrayDouble(exp_coo, len(exp_coo)//2, 2)
 397         self.assertTrue(result.getCoords().isEqual(valuesExpected,1e-10))
 398         self.assertEqual(c, result.getNodalConnectivity().getValues())
 399         self.assertEqual(cI, result.getNodalConnectivityIndex().getValues())
 400         self.assertEqual(e1, res2Back.getValues())
 401         self.assertEqual(e2, res2Tool.getValues())
 402         pass
 403
 404     def testIntersect2DMeshes10(self):
 405         """ Edge::sortIdAbs() was merging points too agressively. This is not the job of the intersector,
 406         user should call mergeNodes afterwards. Was throwing an exception later in the algorithm because
 407         it had to deal with a degenerated cell.
 408         """
 409         eps = 1e-6
 410         back = MEDCouplingUMesh('crh7_rse1', 2)
 411         coo = DataArrayDouble([(-31.31375453845049250,-32.51281383633234157),(-31.69083643301495812,-32.73052216966566874),(-31.50229548573272353,-32.62166800299900871),(-31.53146287178381968,-32.88989573089681073),(-31.62164061609212951,-32.82069991397399633),(-31.42260870511715609,-32.70135478361457615)])
 412         back.setCoords(coo)
 413         c = DataArrayInt([32, 0, 3, 1, 5, 4, 2])
 414         cI = DataArrayInt([0, 7])
 415         back.setConnectivity(c, cI)
 416         tool = MEDCouplingUMesh('merge', 2)
 417         coo = DataArrayDouble([(-29.70769086373595513,-38.08598700945959337),(-27.13627518201525746,-36.53626696210140778),(-35.49132481798474714,-28.48933303789858940)])
 418         tool.setCoords(coo)
 419         c = DataArrayInt([5, 0, 2, 1])
 420         cI = DataArrayInt([0, 4])
 421         tool.setConnectivity(c, cI)
 422
 423         result, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 424 #         print result.getCoords().getValues()
 425 #         print result.getNodalConnectivity().getValues()
 426 #         print result.getNodalConnectivityIndex().getValues()
 427 #         print res2Back.getValues()
 428 #         print res2Tool.getValues()
 429         exp_coo = [-31.313754538450493, -32.51281383633234, -31.690836433014958, -32.73052216966567, -31.502295485732724, -32.62166800299901, -31.53146287178382, -32.88989573089681, -31.62164061609213, -32.820699913973996, -31.422608705117156, -32.701354783614576, -29.707690863735955, -38.08598700945959, -27.136275182015257, -36.53626696210141, -35.49132481798475, -28.48933303789859, -31.31376565042576, -32.51283308283808, -31.313773979690932, -32.51282506073775, -31.42261426110479, -32.70136440686744, -31.62164061609211, -32.82069991397398, -31.502305206352943, -32.62167361520171, -31.313769815058347, -32.51282907178791]
 430         c = [32, 9, 3, 1, 10, 11, 12, 13, 14, 5, 10, 0, 9]
 431         cI = [0, 9, 13]
 432         e1 = [0, 0]
 433         e2 = [0, -1]
 434         valuesExpected = DataArrayDouble(exp_coo, len(exp_coo)//2, 2)
 435         self.assertTrue(result.getCoords().isEqual(valuesExpected,1e-10))
 436         self.assertEqual(c, result.getNodalConnectivity().getValues())
 437         self.assertEqual(cI, result.getNodalConnectivityIndex().getValues())
 438         self.assertEqual(e1, res2Back.getValues())
 439         self.assertEqual(e2, res2Tool.getValues())
 440         pass
 441
 442     def testIntersect2DMeshes11(self):
 443         """ Dealing properly with respective polygon orientation in QuadraticPolygon::haveIAChanceToBeCompletedBy()
 444         The two polygons below have same orientation, but one edge of pol1 is colinear to pol2 in opposite directions.
 445         """
 446         eps = 1.0e-8
 447         back = MEDCouplingUMesh('lback', 2)
 448         coo = DataArrayDouble([(-2.5,-2.5),(-2.5,2.5),(2.5,2.5),(2.5,-2.5),(0,0),(0,1.66667),(1.66667,1.66667),(1.66667,0)])
 449         back.setCoords(coo)
 450         c = DataArrayInt([5, 6, 7, 4, 5, 2, 3, 7, 6, 5, 3, 0, 1, 2, 6, 4, 7])
 451         cI = DataArrayInt([0, 4, 9, 17])
 452         back.setConnectivity(c, cI)
 453
 454         tool = MEDCouplingUMesh('ltool', 2)
 455         coo = DataArrayDouble([(0,0),(0,2.5),(2.5,2.5),(2.5,0)])
 456         tool.setCoords(coo)
 457         c = DataArrayInt([5, 0, 1, 2, 3])
 458         cI = DataArrayInt([0, 5])
 459         tool.setConnectivity(c, cI)
 460
 461         result, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 462         self.assertEqual(result.getNodalConnectivity().getValues(), [5, 7, 8, 6, 5, 7, 6, 10, 11, 5, 11, 3, 7, 5, 9, 10, 6, 8, 5, 8, 7, 3, 0, 1, 9])
 463         self.assertEqual(result.getNodalConnectivityIndex().getValues(), [0, 4, 9, 13, 18, 25])
 464         self.assertEqual(res2Back.getValues(), [0, 1, 1, 2, 2])
 465         self.assertEqual(res2Tool.getValues(), [0, 0, -1, 0, -1])
 466         pass
 467
 468     def testSwig2Intersect2DMeshesQuadra1(self):
 469         import cmath
 470         def createDiagCircle(lX, lY, R, cells=[0,1]):
 471             """ A circle in a square box, cut along the diagonal.
 472             """
 473             c = []
 474             for i in range(8):
 475               c.append(cmath.rect(R, i*pi/4))
 476
 477             coords = [0.0,0.0,          c[3].real,c[3].imag,       -lX/2.0, lY/2.0,
 478                       0.0, lY/2.0,      lX/2.0,lY/2.0,             lX/2.0,0.0,
 479                       #   6                  7                              8
 480                       lX/2.0,-lY/2.0,   c[7].real,c[7].imag,       c[1].real,c[1].imag,
 481                       #   9                  10                            11
 482                       c[5].real,c[5].imag,   -lX/2.0,-lY/2.0,      0.0, -lY/2.0,
 483                       #   12                  13                            14
 484                       -lX/2.0,0.0,         0.0,0.0,                  0.0, 0.0]
 485             # Points 13 (reps. 14) are average of points (6,7) (resp (1,2))
 486             coords[13*2]   = 0.5*(coords[6*2]+coords[7*2])
 487             coords[13*2+1] = 0.5*(coords[6*2+1]+coords[7*2+1])
 488             coords[14*2]   = 0.5*(coords[1*2]+coords[2*2])
 489             coords[14*2+1] = 0.5*(coords[1*2+1]+coords[2*2+1])
 490             connec  = [1,7,8,0]      # half circle up right
 491             connec3 = [6,7,1,2,4,13,8,14,3,5]
 492
 493             baseMesh = MEDCouplingUMesh.New("box_circle", 2)
 494             baseMesh.allocateCells(2)
 495             meshCoords = DataArrayDouble.New(coords, len(coords) // 2, 2)
 496             meshCoords.setInfoOnComponents(["X [au]", "Y [au]"])
 497             baseMesh.setCoords(meshCoords)
 498
 499             if 0 in cells:
 500               baseMesh.insertNextCell(NORM_QPOLYG, connec)
 501             if 1 in cells:
 502               baseMesh.insertNextCell(NORM_QPOLYG, connec3)
 503             baseMesh.finishInsertingCells()
 504             baseMesh.checkConsistencyLight()
 505             return baseMesh
 506
 507         eps = 1.0e-7
 508         m1 = createDiagCircle(1.0, 1.0, 0.5*0.90, cells=[0,1])
 509         m2 = createDiagCircle(1.0, 1.0, 0.5*0.95, cells=[0])
 510         m3, _, _= MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
 511         m3.mergeNodes(eps)
 512         m3.convertDegeneratedCells()
 513         m3.zipCoords()
 514         m4 = m3.deepCopy()
 515         m5, _, _ = MEDCouplingUMesh.Intersect2DMeshes(m3, m4, eps)
 516         m5.mergeNodes(eps)
 517         # Check coordinates:
 518         self.assertTrue(m3.getCoords().isEqual(m5.getCoords(), eps))
 519         pass
 520
 521     def testIntersect2DMeshesTmp7(self):
 522         eps = 1.0e-8
 523         coords = [-0.5,-0.5,   -0.5, 0.5, 0.5, 0.5,    0.5,-0.5]
 524         connec = list(range(4))
 525         m1 = MEDCouplingUMesh.New("box", 2)
 526         m1.allocateCells(1)
 527         meshCoords = DataArrayDouble.New(coords, len(coords) // 2, 2)
 528         m1.setCoords(meshCoords)
 529         m1.insertNextCell(NORM_POLYGON, connec)
 530         m1.finishInsertingCells()
 531
 532         m2 = MEDCouplingDataForTest.buildCircle(0.25, 0.2, 0.4)
 533         # Was looping indefinitely:
 534         m_intersec, resToM1, resToM2 = MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
 535         m_intersec.zipCoords()
 536         coo_tgt = DataArrayDouble([-0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.03284271247461901, 0.4828427124746191,
 537           -0.014575131106459124, 0.5000000000000001, 0.5, -0.11224989991991996, 0.24271243444677046, 0.5, 0.5, 0.19387505004004,
 538           -0.04799910280454185, -0.06682678787499614, -0.023843325638122054, 0.4915644577163915, 0.5, -0.30612494995996, 0.0, -0.5,
 539           -0.5, 0.0, -0.25728756555322957, 0.5, -0.023843325638122026, 0.49156445771639157, -0.04799910280454181, -0.06682678787499613], 17 ,2)
 540         conn_tgt = [32, 5, 2, 6, 4, 7, 8, 9, 10, 32, 6, 3, 0, 1, 5, 4, 11, 12, 13, 14, 15, 16]
 541         connI_tgt = [0, 9, 22]
 542         res1_tgt  = [0, 0]
 543         res2_tgt = [0, -1]
 544         self.assertTrue(coo_tgt.isEqualWithoutConsideringStr(m_intersec.getCoords(), 1e-12))
 545         self.assertEqual(conn_tgt, m_intersec.getNodalConnectivity().getValues())
 546         self.assertEqual(connI_tgt, m_intersec.getNodalConnectivityIndex().getValues())
 547         self.assertEqual(res1_tgt, resToM1.getValues())
 548         self.assertEqual(res2_tgt, resToM2.getValues())
 549         pass
 550
 551     def testIntersect2DMeshesTmp8(self):
 552         """ Arc of circle #5 in m2 was wrongly linearized and this was crashing the intersector. """
 553         m1 = MEDCouplingUMesh('mesh', 2)
 554         coo = DataArrayDouble([(-18.20296424065728,-16.39845900000000),(-18.15483625715243,-16.37067229576792),(-18.17890024890485,-16.38456564788396),(-18.86345900000000,-13.93345900000000),(-18.80788559153584,-13.93345900000000),(-18.64179353311466,-15.19505343584364),(-18.83567229576791,-13.93345900000000),(-18.69547332360511,-15.20943689235543)])
 555         m1.setCoords(coo)
 556         c = DataArrayInt([32, 0, 3, 4, 1, 7, 6, 5, 2])
 557         cI = DataArrayInt([0, 9])
 558         m1.setConnectivity(c, cI)
 559
 560         m2 = MEDCouplingUMesh('tool', 2)
 561         coo = DataArrayDouble([-18.863459, -13.933459, -18.71895791290684, -15.11832192648871, -18.76569937343606, -12.95654908944806, -9.00470518045063,
 562                                   -13.8226177338691, -17.88089225139922, -16.8868757883568, -18.3878542250287, -16.04610264700759, -18.71815899226182, -15.12154400708064,
 563                                   -18.83895821216178, -13.44256442936377, -18.15535493732867, -16.47914057756773, -18.57607919534293, -15.59206616319266, -18.82720039287268, -14.53027989414214, -18.71855872378567, -15.11993303402953,
 564                                   0.,0.,0.,0.], 14, 2)
 565         m2.setCoords(coo)
 566         c = DataArrayInt([32, 1, 0, 2, 4, 5, 6,      #  offset 8:  9, 8, 10, 12, 13, 14
 567                             10, 7, 3, 8, 9, 11])     #            18, 15, 11, 16, 17, 19
 568         cI = DataArrayInt([0, 13])
 569         m2.setConnectivity(c, cI)
 570         inter, map1, map2 = MEDCouplingUMesh.Intersect2DMeshes(m1, m2, 1.0e-8)
 571         self.assertEqual(inter.getNodalConnectivity().getValues(), [32, 13, 14, 9, 8, 4, 1, 0, 22, 23, 24, 25, 26, 27, 28])
 572         self.assertEqual(inter.getNodalConnectivityIndex().getValues(), [0,15])
 573         self.assertEqual(map1.getValues(), [0])
 574         self.assertEqual(map2.getValues(), [0])
 575         pass
 576
 577     def testIntersect2DMeshesTmp9(self):
 578         """ Tricky case: two triangular shapes intersecting, but not perfectly, at their tips. Several issues fixed:
 579             - Bug fix: seg seg intersector epsilon is to be taken absolutely for colinearity test (even for very small vectors
 580             we don't want to have false positive on colinearity. So go back to a comparison with an angle.)
 581             - when intersecting nodes are merged, they were not properly added on pol2.
 582             - bug fix in compute residual: the stop condition is really on pol1Zip only.
 583             - correcting polygons with flat corners, they were crashing residual computation
 584         """
 585         eps = 1.0e-6  # This is the key parameter. DO NOT CHANGE IT.
 586         back = MEDCouplingUMesh('crh8_rse3', 2)
 587         coo = DataArrayDouble([(-31.313754538446631,-32.512813836330515),(-31.531462871779969,-32.135731941766032),(-31.422608705113298,-32.324272889048274),(-31.690836433011114,-32.295105502997181),(-31.621640616088342,-32.204927758688783),(-31.502295485728872,-32.403959669663848)])
 588         back.setCoords(coo)
 589         c = DataArrayInt([32, 0, 3, 1, 5, 4, 2])
 590         cI = DataArrayInt([0, 7])
 591         back.setConnectivity(c, cI)
 592
 593         tool = MEDCouplingUMesh('TA-536193G_expl_20181022_merged', 2)
 594         coo = DataArrayDouble([(-29.918137808525149,-26.883223901634544),(-32.919909136264039,-26.939612990540404),(-27.866900000000001,-28.016680435212603),(-31.313800000000001,-32.512799999999999),(-27.866900000000001,-28.933918793630923)])
 595         tool.setCoords(coo)
 596         c = DataArrayInt([5, 1, 0, 3, 5, 0, 2, 3, 5, 4, 3, 2])
 597         cI = DataArrayInt([0, 4, 8, 12])
 598         tool.setConnectivity(c, cI)
 599
 600         inter, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 601
 602         self.assertEqual(inter.getNodalConnectivity().getValues(), [5, 14, 13, 11, 12, 5, 13, 15, 11, 32, 12, 3, 1, 14, 16, 17, 18, 19, 5, 15, 0, 11])
 603         self.assertEqual(inter.getNodalConnectivityIndex().getValues(), [0, 5, 9, 18, 22])
 604         self.assertEqual(res2Back.getValues(), [0, 0, 0, 0])
 605         self.assertEqual(res2Tool.getValues(), [0, 1, -1, -1])
 606         pass
 607
 608     def testIntersect2DMeshesTmp10(self):
 609         """ Fixing issues when one of the quadratic point of the tool mesh also serves as a regular point somewhere else.
 610         WARNING : the tool mesh is not conform, but this was NOT the initial cause of the problem """
 611         eps = 1.0e-6
 612         back = MEDCouplingUMesh('layer_1', 2)
 613         coo = DataArrayDouble([(0.000000000000000,0.000000000000000),(0.000000000000007,113.449999999999960),(113.449999999999960,0.000000000000000),(80.221264325613788,80.221264325613788),(0.000000000000003,56.724999999999980),(56.724999999999980,0.000000000000000)])
 614         back.setCoords(coo)
 615         c = DataArrayInt([32, 0, 1, 2, 4, 3, 5])
 616         cI = DataArrayInt([0, 7])
 617         back.setConnectivity(c, cI)
 618
 619         tool = MEDCouplingUMesh('layer_2', 2)
 620         coo = DataArrayDouble([(35.499999704817512,0.000000000000011),(35.413523784223756,2.476354817916448),(35.478374361065050,1.238932132335084),(35.563158391762734,2.486818288978067),(35.649999999999999,0.000000000000000),(35.628282983230761,1.244167057444159),(35.488341087993248,2.481586553447257),(35.575000000000003,0.000000000000000),(35.154516440325750,4.940645084082323),(35.305526997492230,3.710760415787641),(35.154516440325743,-4.940645084082338),(34.960674956295250,-6.164510258681856),(35.413523784223763,-2.476354817916429),(35.305526997492230,-3.710760415787643),(35.563158391762734,-2.486818288978048),(35.488341087993248,-2.481586553447238),(35.478374361018354,-1.238932133672371),(35.628282983230761,-1.244167057444150)])
 621         tool.setCoords(coo)
 622         c = DataArrayInt([32, 0, 1, 3, 4, 2, 6, 5, 7,        # 32,  6, 7, 9, 10, 8, 12, 11, 13
 623                              32, 12, 0, 4, 14, 16, 7, 17, 15,   # 32,  18, 6, 10, 20, 22, 13, 23, 21
 624                              32, 8, 1, 12, 10, 9, 0, 13, 11])   # 32,  14, 7, 18, 16, 15, 6, 19, 17
 625         cI = DataArrayInt([0, 9, 18, 27])
 626         tool.setConnectivity(c, cI)
 627         result, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 628
 629         self.assertEqual(result.getNodalConnectivity().getValues(), [32, 10, 6, 7, 9, 25, 26, 27, 28 ,
 630                                                         32, 6, 0, 24, 14, 7, 29, 30, 31, 32, 33,
 631                                                         32, 24, 1, 2, 10, 9, 7,   14, 34, 35, 36, 37, 38, 39, 40])
 632         self.assertEqual(result.getNodalConnectivityIndex().getValues(), [0, 9, 20, 35])
 633         self.assertEqual(res2Back.getValues(), [0, 0, 0])
 634         self.assertEqual(res2Tool.getValues(), [0, 2, -1])
 635         pass
 636
 637     def testIntersect2DMeshesTmp11(self):
 638         """ BuildIntersectMeshes() was merging points too aggressively (again). """
 639         eps = 1.0e-6
 640         back = MEDCouplingUMesh('TA-536193G_expl_20180605_merged', 2)
 641         coo = DataArrayDouble([(10.19999332472057,-27.86690000000001),(12.56691001291914,-29.23343998708087),(13.93345000000000,-24.13344332472058)])
 642         back.setCoords(coo)
 643         c = DataArrayInt([5, 2, 1, 0])
 644         cI = DataArrayInt([0, 4])
 645         back.setConnectivity(c, cI)
 646
 647         tool = MEDCouplingUMesh('layer_1', 2)
 648         cooT = DataArrayDouble([(10.44742256875032,-27.61949543124968),(18.71050449103792,-25.35195658988450),(19.05428526420611,-25.33852836835490),(18.88239487762202,-25.34524247911970),(12.62880992941098,-19.37921975458838),(18.06779356578989,-20.52447528153846),(19.22203188321684,-22.45963506363725),(19.48103923179737,-24.51987105082425),(10.50946417376372,-28.13689270184920),(13.33582148027124,-18.82710073137066),(14.70572820761054,-18.80259652845168),(17.10708000587671,-19.67863183066471),(8.97033515262005,-22.58570640281439),(15.95921032839811,-19.09586394516776),(19.45191696393912,-23.47713337575327),(17.61005728815709,-20.07586106738862),(18.53287284946306,-21.55888206618472),(19.21102524614600,-24.89967567708313),(10.47844337125702,-27.87819406654944),(14.02163025718330,-18.86267048150560)])
 649         tool.setCoords(cooT)
 650         c = DataArrayInt([32, 2, 1, 0, 8, 9, 3, 4, 18, 12, 11])
 651         cI = DataArrayInt([0, 11])
 652         tool.setConnectivity(c, cI)
 653
 654         result, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 655         self.assertEqual(result.getNodalConnectivity().getValues(), [32, 26, 25, 3, 23, 24, 27, 28, 29, 30, 31, 32, 24, 0, 26, 32, 33, 34, 32, 25, 2, 1, 23, 3, 35, 36, 37, 38, 39])
 656         self.assertEqual(result.getNodalConnectivityIndex().getValues(), [0, 11, 18, 29])
 657         self.assertEqual(res2Back.getValues(), [0, 0, 0])
 658         self.assertEqual(res2Tool.getValues(), [0, -1, -1])
 659
 660         # Now the same with point #0 shifted so to almost match intersection point: the intersector should then merge
 661         # with point from mesh 1:
 662         cooT[0,:] = [10.44741058, -27.61948395]
 663         result, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 664         self.assertEqual(result.getNodalConnectivity().getValues(), [32, 25, 3, 23, 24, 26, 27, 28, 29, 32, 24, 0, 25, 30, 31, 32, 32, 3, 2, 1, 23, 33, 34, 35, 36])
 665         self.assertEqual(result.getNodalConnectivityIndex().getValues(), [0, 9, 16, 25])
 666         self.assertEqual(res2Back.getValues(), [0, 0, 0])
 667         self.assertEqual(res2Tool.getValues(), [0, -1, -1])
 668         pass
 669
 670     def testIntersect2DMeshesTmp12(self):
 671         """ Optimisation of SegSeg and ArcCSeg intersector which also allows to handle some degenerated cases.
 672         See method identifyEarlyIntersection() in C++ """
 673         eps = 1e-6
 674         back = MEDCouplingUMesh('merge', 2)
 675         coo = DataArrayDouble([(-22.20967875173176154,32.26829201778234335),(-16.84032124826824273,35.36829201778233767),(-19.52500000000000213,33.81829201778234051),(-22.09987113059642283,32.67809963891765790),(-17.25012886940356438,35.47809963891765506),(-19.67499999999999361,34.07809963891765648),(-16.98614843981577138,35.62087212266773406),(-22.46315640161999028,32.70732818597191027)])
 676         back.setCoords(coo)
 677         c = DataArrayInt([32, 1, 0, 3, 4,    2, 7, 5, 6])
 678         cI = DataArrayInt([0, 9])
 679         back.setConnectivity(c, cI)
 680         back.checkConsistency()
 681
 682         tool = MEDCouplingUMesh('layer_2', 2)
 683         coo = DataArrayDouble([(-16.84032124826824273,35.36829201778233767),(-19.52500000000000924,33.81829201778234051),(-19.46500000000013841,33.71436896932812743),(-22.58118035378681299,31.71175166763502418),(-16.17259236578203740,35.41175166763498083),(-21.04692233083152786,32.75014443326846703),(-17.83899589140436603,34.60224162661226899),(-19.49500000000007560,33.76633049355523042),(-22.64145235112855659,31.81614582930458823),(-16.23286436312378100,35.51614582930454134),(-21.10697925592403834,32.85419191960125573),(-17.89907519522208545,34.70627619258202401),(-22.61131635245768479,31.76394874846980798),(-16.20272836445290920,35.46394874846976109),(-19.07887754666707991,34.07586093630563795),(-19.52453703982536481,33.81855930796379539),(-19.93627714687611530,33.92725120783563142),(-19.50943608541021135,34.17368800957415687),(-17.95959939746765599,34.72207647704399136),(-16.53659280569601009,35.44221892354343595),(-19.30170729324622414,33.94721012213472022),(-19.72285661614316155,34.05046960870489414),(-19.29415681603864741,34.12477447293989741),(-19.73040709335074183,33.87290525789970985),(-19.52476851991268703,33.81842566287306795)])
 684         tool.setCoords(coo)
 685         c = DataArrayInt([8, 14, 15, 16, 17,   20, 23, 21, 22,
 686                              32, 2, 3, 8, 1,    5, 12, 10, 7,
 687                              32, 4, 2, 1, 9,    6, 7, 11, 13,
 688                              32, 9, 1, 15, 14, 0,     11, 24, 20, 18, 19])
 689         cI = DataArrayInt([0, 9, 18, 27, 38])
 690         tool.setConnectivity(c, cI)
 691
 692         result, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 693
 694         self.assertEqual(result.getNodalConnectivity().getValues(), [5, 24, 25, 22, 23, 32, 23, 9, 0, 3, 24, 33, 34, 35, 36, 37, 32, 25, 4, 8, 22, 38, 39, 40, 41])
 695         self.assertEqual(result.getNodalConnectivityIndex().getValues(), [0, 5, 16, 25])
 696         self.assertEqual(res2Back.getValues(), [0, 0, 0])
 697         self.assertEqual(res2Tool.getValues(), [0, -1, -1])
 698         pass
 699
 700     def testSwig2Intersect2DMeshWith1DLine1(self):
 701         """A basic test with no colinearity between m1 and m2."""
 702         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 703         m1=i.buildUnstructured()
 704         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([0.75,3.5,3.75,1.75],2,2)) ; m2.allocateCells() ; m2.insertNextCell(NORM_SEG2,[0,1])
 705         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 706         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,8,7,12,13,4,11,10,15,16,4,18,17,22,23,4,19,18,23,24,5,16,15,20,21,31,5,21,22,17,28,31,5,16,31,28,5,17,29,28,5,12,11,16,28,29,5,17,18,30,29,5,13,12,29,30,5,18,19,14,27,30,5,13,30,27,5,9,8,13,27,14])))
 707         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,31,1,31,28,1,28,29,1,29,30,1,30,27,1,27,26])))
 708         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,56,62,66,70,76,81,86,92,96,102])))
 709         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18])))
 710         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 711         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 712         self.assertTrue(a.getCoords()[25:25+2].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 713         self.assertTrue(a.getCoords()[27:].isEqualWithoutConsideringStr(DataArrayDouble([(3.3214285714285716,2.),(1.6071428571428572,3.),(2.,2.7708333333333335),(3.,2.1875),(1.,3.354166666666667)]),1e-12))
 714         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,4,5,6,8,14,15,12,13,13,9,9,10,10,11,11,7])))
 715         self.assertTrue(d.isEqual(DataArrayInt([(10,10),(11,12),(13,14),(15,16),(17,18),(19,19)])))
 716         pass
 717
 718     def testSwig2Intersect2DMeshWith1DLine2(self):
 719         """A basic test with colinearity between m1 and m2 and the last cell of m2 outside m1."""
 720         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 721         m1=i.buildUnstructured()
 722         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([0.5,2.,2.25,2.,2.5,2.,2.75,2.,3.,2.,4.,2.,5.,2.],7,2)) ; m2.allocateCells()
 723         for i in range(6):
 724             m2.insertNextCell(NORM_SEG2,[i,i+1])
 725             pass
 726         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 727         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,16,15,20,21,4,17,16,21,22,4,18,17,22,23,4,19,18,23,24,5,6,5,10,25,11,5,7,6,11,12,5,8,7,12,26,27,28,13,5,9,8,13,14,5,11,25,10,15,16,5,12,11,16,17,5,13,28,27,26,12,17,18,5,14,13,18,19])))
 728         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,51,59,64,70,75,83,88])))
 729         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,11,1,11,12,1,12,26,1,26,27,1,27,28,1,28,13,1,13,14,1,14,31])))
 730         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
 731         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 732         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 733         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 734         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,12,13,14,15,4,5,6,7,8,9,10,11])))
 735         self.assertTrue(d.isEqual(DataArrayInt([(12,8),(13,9),(14,10),(14,10),(14,10),(14,10),(15,11),(-1,-1)])))
 736         pass
 737
 738     def testSwig2Intersect2DMeshWith1DLine3(self):
 739         """m2 fully included in cell #12. of m1"""
 740         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 741         m1=i.buildUnstructured()
 742         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(0.75,3.25),(0.5,3.5),(0.25,3.25)])) ; m2.allocateCells()
 743         for i in range(2):
 744             m2.insertNextCell(NORM_SEG2,[i,i+1])
 745             pass
 746         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 747         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,8,7,12,13,4,9,8,13,14,4,11,10,15,16,4,12,11,16,17,4,13,12,17,18,4,14,13,18,19,4,17,16,21,22,4,18,17,22,23,4,19,18,23,24,5,16,15,20,21])))
 748         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80])))
 749         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,26,1,26,27])))
 750         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
 751         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 752         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 753         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 754         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,13,14,15,12])))
 755         self.assertTrue(d.isEqual(DataArrayInt([(15,15),(15,15)])))
 756         pass
 757
 758     def testSwig2Intersect2DMeshWith1DLine4(self):
 759         """A special case where an edge is simultaneously a cut and colinear. This tests also checks negative values in descending edges of m1."""
 760         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 761         m1=i.buildUnstructured()
 762         part=DataArrayInt([0,1,2,3,4,7,8,11,12,13,14,15])
 763         m1_1=m1[part]
 764         m1_2=m1[part.buildComplement(m1.getNumberOfCells())]
 765         m1=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1_1,m1_2.buildSpreadZonesWithPoly())
 766         m1.zipCoords()
 767         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(3.5,2.),(0.5,2.)])) ; m2.allocateCells()
 768         m2.insertNextCell(NORM_SEG2,[0,1])
 769         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 770         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,15,14,19,20,4,16,15,20,21,4,17,16,21,22,4,18,17,22,23,5,6,5,10,25,11,5,9,8,12,24,13,5,11,25,10,14,15,5,13,24,12,17,18,5,8,7,6,11,12,5,15,16,17,12,11])))
 771         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,52,58,64,70,76])))
 772         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,24,12,1,12,11,1,11,25])))
 773         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9])))
 774         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 775         self.assertTrue(a.getCoords()[:24].isEqual(m1.getCoords(),1e-12))
 776         self.assertTrue(a.getCoords()[24:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 777         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,8,9,10,11,4,5,6,7,12,12])))
 778         self.assertTrue(d.isEqual(DataArrayInt([(9,11),(12,13),(8,10)])))
 779         pass
 780
 781     def testSwig2Intersect2DMeshWith1DLine5(self):
 782         """A test focusing on a special case for cut."""
 783         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 784         m1=i.buildUnstructured()
 785         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(1.,0.),(3.,2.),(1.,4.)])) ; m2.allocateCells()
 786         for i in range(2):
 787             m2.insertNextCell(NORM_SEG2,[i,i+1])
 788             pass
 789         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 790         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,9,8,13,14,4,11,10,15,16,4,12,11,16,17,4,14,13,18,19,4,16,15,20,21,4,18,17,22,23,4,19,18,23,24,5,6,7,1,5,2,1,7,5,12,13,7,5,8,7,13,5,12,17,13,5,18,13,17,5,16,21,17,5,22,17,21])))
 791         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,64,68,72,76,80,84,88,92])))
 792         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,1,7,1,7,13,1,13,17,1,17,21])))
 793         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12])))
 794         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 795         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 796         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 797         self.assertTrue(c.isEqual(DataArrayInt([0,2,3,4,5,7,8,9,11,12,14,15,1,1,6,6,10,10,13,13])))
 798         self.assertTrue(d.isEqual(DataArrayInt([(12,13),(14,15),(16,17),(18,19)])))
 799         pass
 800
 801     def testIntersect2DMeshWith1DLine6(self):
 802         """ Basic test for Intersect2DMeshWith1DLine: a vertical line intersecting a square. """
 803         m1c = MEDCouplingCMesh()
 804         coordX = DataArrayDouble([-1., 1., 2])
 805         m1c.setCoordsAt(0,coordX)
 806         coordY = DataArrayDouble([0., 2.])
 807         m1c.setCoordsAt(1,coordY);
 808         m1 = m1c.buildUnstructured()
 809
 810         # A simple line:
 811         m2 = MEDCouplingUMesh("bla", 1)
 812         coord2 = DataArrayDouble([0.,-1.0,  0.,1.,  0.,3.,  0.5,2.2], 4, 2)
 813         conn2 = DataArrayInt([NORM_SEG2,0,1,NORM_SEG3,1,2,3])
 814         connI2 = DataArrayInt([0,3,7])
 815         m2.setCoords(coord2)
 816         m2.setConnectivity(conn2, connI2)
 817
 818         # End of construction of input meshes m1bis and m2 -> start of specific part of the test
 819         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 820         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,2,1,4,5,32,0,3,11,7,10,14,15,16,17,18,32,4,1,10,7,11,19,20,21,22,23])))
 821         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,16,27])))
 822         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,6,10,1,10,7,2,7,11,12,2,11,8,13])))
 823         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,14])))
 824         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 825         self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
 826         self.assertTrue(a.getCoords()[6:10].isEqual(m2.getCoords(),1e-12))
 827         self.assertTrue(a.getCoords()[10:].isEqual(DataArrayDouble([(0.,0.),(0.5164175471673584,2.),(0.3796918047064557,1.43726403104512),(0.3796918047064557,2.56273596895488),(-1.,1.),(-0.24179122641632078,2.),(0.3796918047064558,1.4372640310451201),(0.,0.5),(-0.5,0.),(1.,1.),(0.5,0.),(0.,0.5),(0.3796918047064558,1.4372640310451201),(0.7582087735836792,2.)]),1e-12))
 828         self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
 829         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(-1,-1)])))
 830         pass
 831
 832     def testSwig2Intersect2DMeshWith1DLine7(self):
 833         """ Star pattern (a triangle intersecting another one upside down) """
 834         coords1 = DataArrayDouble([-2.,1.,   2.,1.,  0.,-2.], 3,2)
 835         coords2 = DataArrayDouble([0.,2.,   2.,-1.,  -2.,-1.,  0.,3.], 4,2)
 836         m1 = MEDCouplingUMesh("triangle", 2)
 837         m2 = MEDCouplingUMesh("tri_line", 1)
 838         m1.setCoords(coords1)
 839         m2.setCoords(coords2)
 840         m1.setConnectivity(DataArrayInt([NORM_TRI3, 0,1,2]), DataArrayInt([0,4]))
 841         m2.setConnectivity(DataArrayInt([NORM_SEG2,0,1,NORM_SEG2,1,2,NORM_SEG2,2,3]), DataArrayInt([0,3,6,9]))
 842     # End of construction of input meshes m1bis and m2 -> start of specific part of the test
 843         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 844         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([5,1,9,7,5,2,11,10,5,0,8,12,5,7,9,10,11,12,8])))
 845         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,19])))
 846         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,3,7,1,7,9,1,9,4,1,4,10,1,10,11,1,11,5,1,5,12,1,12,8,1,8,6])))
 847         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24,27])))
 848         self.assertTrue(a.getCoords()[:3].isEqual(m1.getCoords(),1e-12))
 849         self.assertTrue(a.getCoords()[3:7].isEqual(m2.getCoords(),1e-12))
 850         self.assertTrue(a.getCoords()[7:].isEqual(DataArrayDouble([(0.6666666666666666,1.),(-1.,1.),(1.3333333333333333,1.1102230246251565e-16),(0.6666666666666665,-0.9999999999999996),(-0.6666666666666667,-1.),(-1.4285714285714284,0.14285714285714302)]),1e-12))
 851         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 852         self.assertTrue(c.isEqual(DataArrayInt([0,0,0,0])))
 853         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,3),(-1,-1),(-1,-1),(1,3),(-1,-1),(-1,-1),(2,3),(-1,-1)])))
 854         pass
 855
 856     def testSwig2Intersect2DMeshWith1DLine8(self):
 857         """ Line pieces ending (or fully located) in the middle of a cell """
 858         m1c = MEDCouplingCMesh()
 859         m1c.setCoordsAt(0,DataArrayDouble([-1., 1.]))
 860         m1c.setCoordsAt(1,DataArrayDouble([-1., 1.]));
 861         m1 = m1c.buildUnstructured()
 862         coords2 = DataArrayDouble([0.,0.,  0.,1.5, -1.5,0.,  0.5,0.0,  0.0,-0.5, 1.1,-0.6], 6,2)
 863         m2 = MEDCouplingUMesh("piecewise_line", 1)
 864         m2.setCoords(coords2)
 865         c = DataArrayInt([NORM_SEG2,2,1, NORM_SEG2,1,4, NORM_SEG2,4,3,  NORM_SEG2,3,5])
 866         cI = DataArrayInt([0,3,6,9,12])
 867         m2.setConnectivity(c, cI)
 868         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 869         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([5,2,11,10,5,3,13,7,8,12,5,1,0,10,11,12,8,7,13])))
 870         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,10,19])))
 871         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,6,10,1,10,11,1,11,5,1,5,12,1,12,8,1,8,7,1,7,13,1,13,9])))
 872         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
 873         self.assertTrue(a.getCoords()[:4].isEqual(m1.getCoords(),1e-12))
 874         self.assertTrue(a.getCoords()[4:10].isEqual(m2.getCoords(),1e-12))
 875         self.assertTrue(a.getCoords()[10:].isEqual(DataArrayDouble([(-1.,0.5),(-0.5,1.),(0.,1.),(1.,-0.5)]),1e-12))
 876         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 877         self.assertTrue(c.isEqual(DataArrayInt([0,0,0])))
 878         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
 879         pass
 880
 881     def testSwig2Intersect2DMeshWith1DLine9(self):
 882         """ Intersection with a line whose connectivity is not consecutive """
 883         m1c = MEDCouplingCMesh()
 884         coordX = DataArrayDouble([-1., 1., 2])
 885         m1c.setCoordsAt(0,coordX)
 886         coordY = DataArrayDouble([0., 2.])
 887         m1c.setCoordsAt(1,coordY);
 888         m1 = m1c.buildUnstructured()
 889         # A simple line:
 890         m2 = MEDCouplingUMesh("bla", 1)
 891         coord2 = DataArrayDouble([0.,1.5,  0.5,1.,  0.0,0.5,  0.0,3.0,  0.0,-1.0], 5, 2)
 892         conn2 = DataArrayInt([NORM_SEG2,3,0,NORM_SEG3,0,2,1,NORM_SEG2,2,4])
 893         connI2 = DataArrayInt([0,3,7,10])
 894         m2.setCoords(coord2)
 895         m2.setConnectivity(conn2, connI2)
 896         # End of construction of input meshes m1bis and m2 -> start of specific part of the test
 897         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 898         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,2,1,4,5,32,4,1,11,8,6,12,14,15,16,17,18,19,32,0,3,12,6,8,11,20,21,22,23,24,25])))
 899         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,18,31])))
 900         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,9,12,1,12,6,2,6,8,13,1,8,11,1,11,10])))
 901         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,13,16])))
 902         self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
 903         self.assertTrue(a.getCoords()[6:11].isEqual(m2.getCoords(),1e-12))
 904         self.assertTrue(a.getCoords()[11:].isEqual(DataArrayDouble([(0.,0.),(0.,2.),(0.5,1.),(1.,1.),(0.5,0.),(0.,0.25),(0.5,1.),(0.,1.75),(0.5,2.),(-1.,1.),(-0.5,2.),(0.,1.75),(0.5,1.),(0.,0.25),(-0.5,0.)]),1e-12))
 905         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 906         self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
 907         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
 908         pass
 909
 910     def testSwig2Intersect2DMeshWith1DLine10(self):
 911         """ Intersection between a circle and various lines """
 912         eps = 1.0e-8
 913         m_circ = MEDCouplingDataForTest.buildCircle2(0.0, 0.0, 2.0)
 914         coords = [0.0,3.0,0.0,-3.0]
 915         connec = [0,1]
 916         m_line = MEDCouplingUMesh("seg", 1)
 917         m_line.allocateCells(1)
 918         meshCoords = DataArrayDouble.New(coords, len(coords) // 2, 2)
 919         m_line.setCoords(meshCoords)
 920         m_line.insertNextCell(NORM_SEG2, connec)
 921         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m_circ, m_line, eps)
 922         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 923         self.assertTrue(a.getCoords()[:m_circ.getNumberOfNodes()].isEqual(m_circ.getCoords(),1e-12))
 924         self.assertTrue(a.getCoords()[m_circ.getNumberOfNodes():m_circ.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 925         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.414213562373095),(0.,2.),(-1.414213562373095,1.4142135623730951),(-2.,0.),(-1.4142135623730954,-1.414213562373095),(0.,-2.),(1.4142135623730947,-1.4142135623730954),(0.,3.),(0.,-3.),(0.,-2.),(0.,2.),(2.,0.),(0.7653668647301797,-1.8477590650225735),(0.,0.),(0.7653668647301797,1.8477590650225735),(-2,0.),(-0.7653668647301795,1.8477590650225735),(0.,0.),(-0.7653668647301795,-1.8477590650225735)]),1e-12))
 926         self.assertEqual([32,1,7,10,11,12,13,14,15,32,5,3,11,10,16,17,18,19],a.getNodalConnectivity().getValues())
 927         self.assertEqual([0,9,18],  a.getNodalConnectivityIndex().getValues())
 928         self.assertEqual([1,8,11,1,11,10,1,10,9],b.getNodalConnectivity().getValues())
 929         self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
 930         self.assertTrue(a.getCoords()[:8].isEqual(m_circ.getCoords(),1e-12))
 931         self.assertTrue(a.getCoords()[8:10].isEqual(m_line.getCoords(),1e-12))
 932         coo_tgt = DataArrayDouble([2.,0.,1.4142135623730951,1.414213562373095,1.2246467991473532e-16,2.,-1.414213562373095,1.4142135623730951,-2.,0.,-1.4142135623730954,-1.414213562373095,-3.6739403974420594e-16,-2.,1.4142135623730947,-1.4142135623730954,0.,3.,0.,-3.,0.,-2.,0.,2.,2.,0.,0.7653668647301797,-1.8477590650225735,0.,0.,0.7653668647301797,1.8477590650225735,-2.,0.,-0.7653668647301795,1.8477590650225735,0.,0.,-0.7653668647301795,-1.8477590650225735])
 933         self.assertTrue(a.getCoords().isEqualWithoutConsideringStr(coo_tgt,1.0e-12))
 934         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 935         self.assertEqual([0,0],c.getValues())
 936         self.assertEqual([-1,-1,0,1,-1,-1],d.getValues())
 937
 938     def testSwig2Intersect2DMeshWith1DLine11(self):
 939         """ Quad line re-entering a square cell """
 940         eps = 1.0e-8
 941         m = MEDCouplingUMesh("box", 2)
 942         m.setCoords(DataArrayDouble([-1., -1., -1., 1., 1., 1., 1., -1.0],4,2))
 943         c, cI = [NORM_POLYGON, 0, 1, 2, 3], [0, 5]
 944         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 945         m.checkConsistencyLight()
 946         coords2 = [0., 1.3, -1.3, 0., -0.6, 0.6, 0., -1.3, -0.5, -0.5]
 947         connec2, cI2 = [NORM_SEG3, 0, 1, 2, NORM_SEG3, 1, 3, 4], [0,4,8]
 948         m_line = MEDCouplingUMesh("seg", 1)
 949         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 950         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 951         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 952         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 953         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 954         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 955         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(0.,1.3),(-1.3,0.),(-0.6,0.6),(0.,-1.3),(-0.5,-0.5),(-1.,0.23453685964236054),(-1.,-0.13033276368660177),(-0.2345368596423598,1.),(-0.1303327636866019,-1.),(-0.11489196370692323,1.1481421036683868),(-0.6,0.6),(-1.1481421036683859,0.11489196370692323),(-1.147455889106615,-0.0593103465193594),(-0.5,-0.5),(-0.0593103465193594,-1.147455889106615),(1.,0.),(0.4348336181566991,-1.),(-0.5651663818433009,-1.),(-1.,-0.5651663818433009),(-1.,0.05210204797787939),(-0.6,0.6),(0.3827315701788201,1.),(-0.6172684298211799,1.),(-0.6,0.6),(-1.,0.6172684298211802),(-0.6,0.6),(0.3827315701788201,1.),(1.,0.),(0.4348336181566991,-1.),(-0.5,-0.5),(-1.,0.05210204797787939),(-1.,-0.5651663818433009),(-0.5,-0.5),(-0.5651663818433009,-1.)]),1e-12))
 956         self.assertEqual([32,9,11,2,3,12,10,29,30,31,32,33,34,32,0,10,12,35,36,37,32,1,11,9,26,27,28],a.getNodalConnectivity().getValues())
 957         self.assertEqual([0,13,20,27],a.getNodalConnectivityIndex().getValues())
 958         self.assertEqual([2,4,11,13,2,11,9,14,2,9,5,15,2,5,10,16,2,10,12,17,2,12,7,18],b.getNodalConnectivity().getValues())
 959         self.assertEqual([0,4,8,12,16,20,24],b.getNodalConnectivityIndex().getValues())
 960         self.assertTrue(a.getCoords()[:4].isEqual(m.getCoords(),1e-12))
 961         self.assertTrue(a.getCoords()[4:9].isEqual(m_line.getCoords(),1e-12))
 962         self.assertTrue(DataArrayInt([0,0,0]).isEqual(c))
 963         self.assertTrue(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(0,1),(-1,-1)]).isEqual(d))
 964         pass
 965
 966     def testSwig2Intersect2DMeshWith1DLine12(self):
 967         """ Two squares one in the other intersected by an horizontal line """
 968         eps = 1.0e-8
 969         m = MEDCouplingUMesh("boxbox", 2)
 970         m.setCoords(DataArrayDouble([-0.5,-0.5,-0.5,0.5,0.5,0.5,0.5,-0.5,-0.25,-0.25,-0.25,0.25,0.25,0.25,0.25,-0.25],8,2))
 971         c = [NORM_POLYGON, 4, 5, 6, 7, NORM_POLYGON, 0, 1, 5, 4, NORM_POLYGON, 1, 2, 3, 0, 4, 7, 6, 5]
 972         cI = [0, 5, 10, 19]
 973         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 974         m.checkConsistencyLight()
 975         coords2 = [-1., 0.25, 1., 0.25]
 976         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
 977         m_line = MEDCouplingUMesh.New("seg", 1)
 978         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 979         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 980         m_line2 = m_line.deepCopy()
 981         m2 = m.deepCopy()
 982         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 983         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 984         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 985         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 986         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(-0.5,-0.5),(-0.5,0.5),(0.5,0.5),(0.5,-0.5),(-0.25,-0.25),(-0.25,0.25),(0.25,0.25),(0.25,-0.25),(-1.,0.25),(1.,0.25),(-0.5,0.25),(0.5,0.25)]),1e-12))
 987         self.assertEqual([5,4,5,6,7,5,1,5,10,5,4,0,10,5,5,5,1,2,11,6,5,3,0,4,7,6,11],a.getNodalConnectivity().getValues())
 988         self.assertEqual([0,5,9,14,20,27],a.getNodalConnectivityIndex().getValues())
 989         self.assertEqual([1,8,10,1,10,5,1,5,6,1,6,11,1,11,9],b.getNodalConnectivity().getValues())
 990         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
 991         self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
 992         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
 993         pass
 994
 995     def testSwig2Intersect2DMeshWith1DLine13(self):
 996         """ A square (side length) in a circle intersected by a simple horizontal line """
 997         import math
 998         eps = 1.0e-8
 999         m = MEDCouplingUMesh("boxcircle", 2)
1000         sq2 = math.sqrt(2.0)
1001         soth = (sq2+1.0)/2.0
1002         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
1003          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
1004         coo = DataArrayDouble(coo); coo.rearrange(2)
1005         m.setCoords(coo)
1006         c = [NORM_QPOLYG, 8, 9, 10, 11, 12, 13, 14, 15, NORM_QPOLYG, 3, 1, 10, 9, 2, 17, 13, 16, NORM_QPOLYG, 1, 7, 5, 3, 9, 8, 11, 10, 0, 6, 4, 16, 12, 15, 14, 17]
1007         cI = [0, 9, 18, 35]
1008         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
1009         m.checkConsistencyLight()
1010         coords2 = [-2., 1., 2., 1.0]
1011         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
1012         m_line = MEDCouplingUMesh("seg", 1)
1013         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
1014         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
1015         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
1016         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
1017         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
1018         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
1019         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.4142135623730951),(0.,2.),(-1.4142135623730951,1.4142135623730951),(-2.,0.),(-1.4142135623730951,-1.4142135623730951),(0.,-2.),(1.4142135623730951,-1.4142135623730951),(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(-1.,0.),(0.,1.),(1.,0.),(0.,-1.),(-1.2071067811865475,1.2071067811865475),(1.2071067811865475,1.2071067811865475),(-2.,1.),(2.,1.),(1.7320508075688772,1.),(-1.7320508075688772,1.),(-1.2071067811865475,1.2071067811865475),(-1.3660254037844386,1.),(-1.58670668058247,1.2175228580174415),(0.,-1.),(1.,0.),(1.2071067811865475,1.2071067811865475),(1.5867066805824703,1.2175228580174413),(1.9828897227476205,-0.26105238444010315),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844386,1.),(-1.,0.),(1.5867066805824703,1.2175228580174413),(1.3660254037844386,1.),(1.2071067811865475,1.2071067811865475),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844386,1.),(-1.,0.),(0.,-1.),(1.,0.),(1.3660254037844386,1.),(1.9828897227476205,-0.26105238444010315)]),1e-12))
1020         self.assertEqual([32,8,9,10,11,12,13,14,15,32,3,1,10,9,2,17,13,16,32,3,9,21,22,23,24,32,1,20,10,34,35,36,32,7,5,21,9,8,11,10,20,37,38,39,40,41,42,43,44],a.getNodalConnectivity().getValues())
1021         self.assertEqual([0,9,18,25,32,49],a.getNodalConnectivityIndex().getValues())
1022         self.assertEqual([1,18,21,1,21,9,1,9,10,1,10,20,1,20,19],b.getNodalConnectivity().getValues())
1023         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
1024         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
1025         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(3,4),(-1,-1)])))
1026         pass
1027
1028     def testSwig2Intersect2DMeshWith1DLine14(self):
1029         """ A circle in a circle intersected by a simple horizontal line, not tangent to the circles """
1030         eps = 1.0e-8
1031         m = MEDCouplingUMesh("boxcircle", 2)
1032         coo = [2.,0.,1.4142135623730951,1.414213562373095,0.,2.,-1.414213562373095,1.4142135623730951,-2.,0.,-1.4142135623730954,-1.414213562373095,0.,-2.,
1033                1.4142135623730947,-1.4142135623730954,1.,0.,0.7071067811865476,0.7071067811865475,0.,1.,-0.7071067811865475,0.7071067811865476,-1.,0.,-0.7071067811865477,-0.7071067811865475,
1034                0.,-1.,0.7071067811865474,-0.7071067811865477,1.060660171779821,-1.0606601717798214,-1.0606601717798214,-1.0606601717798212]
1035         coo = DataArrayDouble(coo); coo.rearrange(2)
1036         m.setCoords(coo)
1037         c = [NORM_QPOLYG, 15, 13, 11, 9, 14, 12, 10, 8, NORM_QPOLYG, 7, 5, 13, 15, 6, 17, 14, 16, NORM_QPOLYG, 5, 3, 1, 7, 15, 9, 11, 13, 4, 2, 0, 16, 8, 10, 12, 17]
1038         cI = [0, 9, 18, 35]
1039         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
1040         m.checkConsistencyLight()
1041         coords2 = [-2., 0., 2., 0.]
1042         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
1043         m_line = MEDCouplingUMesh.New("seg", 1)
1044         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
1045         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
1046         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
1047         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
1048         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
1049         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
1050         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.414213562373095),(0.,2.),(-1.414213562373095,1.4142135623730951),(-2.,0.),(-1.4142135623730954,-1.414213562373095),(0.,-2.),(1.4142135623730947,-1.4142135623730954),(1.,0.),(0.7071067811865476,0.7071067811865475),(0.,1.),(-0.7071067811865475,0.7071067811865476),(-1.,0.),(-0.7071067811865477,-0.7071067811865475),(0.,-1.),(0.7071067811865474,-0.7071067811865477),(1.060660171779821,-1.0606601717798214),(-1.0606601717798214,-1.0606601717798212),(-2.,0.),(2.,0.),(-1.,0.),(1.,0.),(0.,2.),(1.8477590650225735,0.7653668647301795),(1.8477590650225735,-0.7653668647301797),(1.060660171779821,-1.0606601717798214),(0.9238795325112867,-0.38268343236508984),(0.9238795325112867,0.3826834323650897),(0.,1.),(-0.9238795325112867,0.3826834323650896),(-1.5,0.),(-1.8477590650225735,0.7653668647301792),(-1.0606601717798214,-1.0606601717798212),(-1.8477590650225733,-0.7653668647301799),(-1.5,0.),(-0.9238795325112866,-0.38268343236508995),(0.,1.),(-0.9238795325112867,0.3826834323650896),(-1.5,0.),(-1.8477590650225735,0.7653668647301792),(0.,2.),(1.8477590650225735,0.7653668647301795),(1.5,0.),(0.9238795325112867,0.3826834323650897),(1.060660171779821,-1.0606601717798214),(0.9238795325112867,-0.38268343236508984),(1.5,0.),(1.8477590650225735,-0.7653668647301797),(0.,1.),(0.9238795325112867,0.3826834323650897),(0.,0.),(-0.9238795325112867,0.3826834323650896),(0.,-1.),(-0.9238795325112866,-0.38268343236508995),(0.,0.),(0.9238795325112867,-0.38268343236508984)]),1e-12))
1051         self.assertEqual([32,7,5,13,15,6,17,14,16,32,9,11,20,18,3,1,19,21,36,37,38,39,40,41,42,43,32,7,15,21,19,44,45,46,47,32,13,5,18,20,32,33,34,35,32,11,9,21,20,48,49,50,51,32,15,13,20,21,52,53,54,55],a.getNodalConnectivity().getValues())
1052         self.assertEqual([0,9,26,35,44,53,62],a.getNodalConnectivityIndex().getValues())
1053         self.assertEqual([1,18,20,1,20,21,1,21,19],b.getNodalConnectivity().getValues())
1054         self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
1055         self.assertTrue(c.isEqual(DataArrayInt([1,2,2,2,0,0])))
1056         self.assertTrue(d.isEqual(DataArrayInt([(1,3),(4,5),(1,2)])))
1057         pass
1058
1059     def testSwig2Intersect2DMeshWith1DLine15(self):
1060         """ Same as testSwig2Intersect2DMeshWith1DLine13 except that the line is colinear AND splits on of the common edge of 2D mesh."""
1061         import math
1062         eps = 1.0e-8
1063         m = MEDCouplingUMesh("boxcircle", 2)
1064         sq2 = math.sqrt(2.0)
1065         soth = (sq2+1.0)/2.0
1066         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
1067          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
1068         coo = DataArrayDouble(coo); coo.rearrange(2)
1069         m.setCoords(coo)
1070         c = [NORM_QPOLYG, 8, 9, 10, 11, 12, 13, 14, 15, NORM_QPOLYG, 3, 1, 10, 9, 2, 17, 13, 16, NORM_QPOLYG, 1, 7, 5, 3, 9, 8, 11, 10, 0, 6, 4, 16, 12, 15, 14, 17]
1071         cI = [0, 9, 18, 35]
1072         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
1073         m.checkConsistencyLight()
1074         coords2 = [(-2., 1.),(2.,1.),(0.,1)]
1075         connec2, cI2 = [NORM_SEG2, 0, 2, NORM_SEG2, 2, 1], [0,3,6]
1076         m_line = MEDCouplingUMesh("seg", 1)
1077         m_line.setCoords(DataArrayDouble(coords2))
1078         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
1079         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
1080         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
1081         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
1082         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
1083         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.4142135623730951),(0.,2.),(-1.4142135623730951,1.4142135623730951),(-2.,0.),(-1.4142135623730951,-1.4142135623730951),(0.,-2.),(1.4142135623730951,-1.4142135623730951),(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(-1.,0.),(0.,1.),(1.,0.),(0.,-1.),(-1.2071067811865475,1.2071067811865475),(1.2071067811865475,1.2071067811865475),(-2.,1.),(2.,1.),(0.,1.),(1.7320508075688776,1.),(-1.7320508075688776,1.),(-0.5,1.),(0.5,1.),(0.5,1.),(-0.5,1.),(-1.2071067811865475,1.2071067811865475),(-1.3660254037844388,1.),(-1.58670668058247,1.2175228580174415),(0.,-1.),(1.,0.),(1.2071067811865475,1.2071067811865475),(1.5867066805824703,1.2175228580174413),(1.9828897227476205,-0.26105238444010315),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844388,1.),(-1.,0.),(1.5867066805824703,1.2175228580174413),(1.3660254037844388,1.),(1.2071067811865475,1.2071067811865475),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844388,1.),(-1.,0.),(0.,-1.),(1.,0.),(1.3660254037844388,1.),(1.9828897227476205,-0.26105238444010315)]),1e-12))
1084         self.assertEqual([32,8,9,20,10,11,12,23,24,14,15,32,3,1,10,20,9,2,17,25,26,16,32,3,9,22,27,28,29,32,1,21,10,39,40,41,32,7,5,22,9,8,11,10,21,42,43,44,45,46,47,48,49],a.getNodalConnectivity().getValues())
1085         self.assertEqual([0,11,22,29,36,53],a.getNodalConnectivityIndex().getValues())
1086         self.assertEqual([1,18,22,1,22,9,1,9,20,1,20,10,1,10,21,1,21,19],b.getNodalConnectivity().getValues())
1087         self.assertEqual([0,3,6,9,12,15,18],b.getNodalConnectivityIndex().getValues())
1088         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
1089         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(1,0),(3,4),(-1,-1)])))
1090         pass
1091
1092     def testSwig2Intersect2DMeshWith1DLine16(self):
1093         """ Same than testSwig2Intersect2DMeshWith1DLine13 except it is a vertical line. Non regression test."""
1094         import math
1095         eps = 1.0e-8
1096         m = MEDCouplingUMesh("boxcircle", 2)
1097         sq2 = math.sqrt(2.0)
1098         soth = (sq2+1.0)/2.0
1099         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
1100          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
1101         coo = DataArrayDouble(coo); coo.rearrange(2)
1102         m.setCoords(coo)
1103         c = [NORM_QPOLYG, 8, 9, 10, 11, 12, 13, 14, 15, NORM_QPOLYG, 3, 1, 10, 9, 2, 17, 13, 16, NORM_QPOLYG, 1, 7, 5, 3, 9, 8, 11, 10, 0, 6, 4, 16, 12, 15, 14, 17]
1104         cI = [0, 9, 18, 35]
1105         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
1106         m.checkConsistencyLight()
1107         coords2 = [1., 2., 1., -2.]
1108         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
1109         m_line = MEDCouplingUMesh("seg", 1)
1110         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
1111         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
1112         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
1113         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
1114         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
1115         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
1116         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2., 0.),(1.4142135623730951,1.4142135623730951),(0.,2.),(-1.4142135623730951,1.4142135623730951),(-2.,0.),(-1.4142135623730951,-1.4142135623730951),(0.,-2.),(1.4142135623730951,-1.4142135623730951),(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(-1.,0.),(0.,1.),(1.,0.),(0.,-1.),(-1.2071067811865475,1.2071067811865475),(1.2071067811865475,1.2071067811865475),(1.,2.),(1.,-2.),(1.,1.7320508075688772),(1.,-1.7320508075688772),(1.2071067811865475,1.2071067811865475),(1.,1.3660254037844386),(1.217522858017441,1.5867066805824703),(-1.2071067811865475,1.2071067811865475),(-0.2610523844401028,1.9828897227476208),(1.,1.3660254037844386),(0.,1.),(1.2071067811865475,1.2071067811865475),(2.,0.),(1.217522858017441,-1.5867066805824703),(1.,-1.3660254037844386),(1.,0.),(-2.,0.),(-1.2071067811865475,1.2071067811865475),(-1.,0.),(0.,-1.),(1.,-1.3660254037844386),(-0.2610523844401028,-1.9828897227476208)]),1e-12))
1117         self.assertEqual([32,8,9,10,11,12,13,14,15,32,1,10,20,22,23,24,32,9,3,20,10,25,26,27,28,32,10,1,7,21,11,29,30,31,32,33,32,5,3,9,8,11,21,34,35,36,37,38,39],a.getNodalConnectivity().getValues())
1118         self.assertEqual([0,9,16,25,36,49],a.getNodalConnectivityIndex().getValues())
1119         self.assertEqual([1,18,20,1,20,10,1,10,11,1,11,21,1,21,19],b.getNodalConnectivity().getValues())
1120         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
1121         self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
1122         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
1123         pass
1124
1125     def testSwig2Intersect2DMeshWith1DLine17(self):
1126         """ Single colinear intersection - a deltaShiftIndex() was improperly tested. """
1127         eps = 1.0e-12
1128         mesh = MEDCouplingUMesh('dummy_layer', 2)
1129         coo = DataArrayDouble([(-0.5,-0.5),(-0.5,0.5),(0.5,0.5),(0.5,-0.5),(-0.25,-0.25),(-0.25,0.25),(0.25,0.25),(0.25,-0.25)])
1130         mesh.setCoords(coo)
1131         c = DataArrayInt([5, 4, 5, 6, 7, 5, 0, 1, 5, 4, 5, 1, 2, 3, 0, 4, 7, 6, 5])
1132         cI = DataArrayInt([0, 5, 10, 19])
1133         mesh.setConnectivity(c, cI)
1134         m_line = MEDCouplingUMesh('segment', 1)
1135         coo = DataArrayDouble([(-0.5,0.5),(-0.25,0.25)])
1136         m_line.setCoords(coo)
1137         c = DataArrayInt([1, 0, 1])
1138         cI = DataArrayInt([0, 3])
1139         m_line.setConnectivity(c, cI)
1140         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(mesh, m_line, eps)
1141         self.assertEqual(mesh.getNodalConnectivity().getValues(),a.getNodalConnectivity().getValues())
1142         self.assertEqual(mesh.getNodalConnectivityIndex().getValues(),a.getNodalConnectivityIndex().getValues())
1143         self.assertEqual([1,1,5],b.getNodalConnectivity().getValues())
1144         self.assertEqual(m_line.getNodalConnectivityIndex().getValues(),b.getNodalConnectivityIndex().getValues())
1145         self.assertTrue([0,1,2], c.getValues())
1146         self.assertEqual([2,1], d.getValues())
1147
1148     def testSwig2Intersect2DMeshWith1DLine18(self):
1149         """ Rare case: a *closed* line used as a tool, with the closing point inside a 2D cell ... """
1150         tool = MEDCouplingUMesh('circle', 1)
1151         coo = DataArrayDouble([(39.35,0),(27.8247,27.8247),(2.40949e-15,39.35),(-27.8247,27.8247),(-39.35,4.81899e-15),(-27.8247,-27.8247),(-7.22848e-15,-39.35),(27.8247,-27.8247),(39.35,7.39805e-15)])
1152         tool.setCoords(coo)
1153         c = DataArrayInt([2, 3, 5, 8,    2, 5, 3, 4])
1154         cI = DataArrayInt([0, 4, 8])
1155         tool.setConnectivity(c, cI)
1156
1157         meh = MEDCouplingUMesh('meh', 2)
1158         coo = DataArrayDouble([(-26.4275,36.6199),(-23.5868,31.6996),(-34.1861,41.0993),(-30.3383,25.0214),(-40.1861,30.707),(-35.2622,27.8642),(-37.1861,35.9032),(-30.3068,38.8596),(-25.0071,34.1598),(-26.9625,28.3605),(-25.7138,32.5128),(-27.354,36.4726),(-36.9138,32.5128),(-27.354,28.553),(-26.8908,36.5462),(-28.8461,26.7872)])
1159         meh.setCoords(coo)
1160         c = DataArrayInt([32, 0, 1, 3, 13, 11, 8, 9, 15, 10, 14,
1161                              32, 3, 4, 2, 0, 11, 13, 5, 6, 7, 14, 12, 15])
1162         cI = DataArrayInt([0, 11, 24])
1163         meh.setConnectivity(c, cI)
1164
1165         res2D, res1D, m1, m2 = MEDCouplingUMesh.Intersect2DMeshWith1DLine(meh, tool, 1e-12)
1166         self.assertEqual(4, res2D.getNumberOfCells())
1167         self.assertEqual(res2D.getNodalConnectivity().getValues(),[32, 13, 11, 0, 1, 25, 19, 26, 33, 34, 35, 36, 37, 38, 39, 32, 3, 26, 19, 25, 40, 41, 42, 43,
1168                                                                    32, 4, 2, 0, 11, 13, 26, 27, 44, 45, 46, 47, 48, 49, 50, 32, 3, 27, 26, 51, 52, 53])
1169         self.assertEqual(res2D.getNodalConnectivityIndex().getValues(),[0, 15, 24, 39, 46])
1170         self.assertEqual(res1D.getNodalConnectivity().getValues(),[2, 19, 25, 28, 2, 25, 21, 29, 2, 21, 27, 30, 2, 27, 26, 31, 2, 26, 19, 32])
1171         self.assertEqual(res1D.getNodalConnectivityIndex().getValues(),[0, 4, 8, 12, 16, 20])
1172         self.assertEqual(m1.getValues(), [0,0,1,1])
1173         self.assertEqual(m2.getValues(), [0,1,   -1,-1,  -1,-1,   2,3,  0,1])
1174
1175     def testSwig2Intersect2DMeshWith1DLine19(self):
1176         """ Intersection arc of circle / segment was not properly detecting tangent cases """
1177         eps=1.0e-5  # was working at 1.0e-8, but should also really work with 1.0e-5
1178         mesh = MEDCouplingUMesh('layer_1', 2)
1179         coo = DataArrayDouble([(55.4,3.7239),(61.4,7.188),(61.4,13.943),(49.55,7.1014),
1180                                   (61.4,10.5655),(58.4,5.45595),(52.475,5.41265),(55.475,10.5222),
1181                                   (56.9,9.34),(56.3343,7.97431),(56.9,7.74),(57.4657,7.97431),(59.4328,7.58116),
1182                                   (55.8672,5.84911),    (0.,0.)])
1183         mesh.setCoords(coo)
1184         c = DataArrayInt([32, 0, 3, 2, 1, 11, 9,     6, 7, 4, 12, 8, 13])
1185         cI = DataArrayInt([0, 13])
1186         mesh.setConnectivity(c, cI)
1187         tool = MEDCouplingUMesh('segment', 1)
1188         coo = DataArrayDouble([(-166.611,-119.951),(269.611,131.902)])
1189         tool.setCoords(coo)
1190         c = DataArrayInt([1, 0, 1])
1191         cI = DataArrayInt([0, 3])
1192         tool.setConnectivity(c, cI)
1193
1194         res2D, res1D, m1, m2 = MEDCouplingUMesh.Intersect2DMeshWith1DLine(mesh, tool, eps)
1195
1196         self.assertEqual(res2D.getNodalConnectivity().getValues(),[32, 19, 17, 3, 2, 18, 20, 33, 34, 35, 36, 37, 38, 32, 1, 11, 20, 18, 39, 40, 41, 42, 32, 9, 0, 17, 19, 29, 30, 31, 32])
1197         self.assertEqual(res2D.getNodalConnectivityIndex().getValues(),[0, 13, 22, 31])
1198         self.assertEqual(res1D.getNodalConnectivity().getValues(),[1, 15, 17, 1, 17, 19, 1, 19, 20, 1, 20, 18, 1, 18, 16])
1199         self.assertEqual(res1D.getNodalConnectivityIndex().getValues(),[0, 3, 6, 9, 12, 15])
1200         self.assertEqual(m1.getValues(), [0, 0, 0])
1201         self.assertEqual(m2.getValues(), [-1, -1, 0, 2, -1, -1, 0, 1, -1, -1])
1202
1203     def testSwig2Intersect2DMeshWith1DLine20(self):
1204         """ A line intersecting a cell more than 3 times was triggering an internal error. """
1205         mesh = MEDCouplingUMesh('merge', 2)
1206         coo = DataArrayDouble([(0,0),(0,9),(3,9),(3,0),(0,1),(2,1),(0,2),(2,2),(3,3),(1,3),(3,4),(1,4),(0,5),(2,5),(0,6),(2,6),(3,7),(1,7),(3,8),(1,8)])
1207         mesh.setCoords(coo)
1208         c = DataArrayInt([5, 3, 0, 4, 5, 7, 6, 12, 13, 15, 14, 1, 2, 18, 19, 17, 16, 10, 11, 9, 8]) # offset 20
1209         cI = DataArrayInt([0, 21])
1210         mesh.setConnectivity(c, cI)
1211
1212         tool = MEDCouplingUMesh('tool', 1)
1213         coo = DataArrayDouble([(1.5, 9.5),  (1.5, 1.5)])  # line crossing 4 times
1214         tool.setCoords(coo)
1215         c = DataArrayInt([NORM_SEG2,0,1])
1216         cI = DataArrayInt([0, 3])
1217         tool.setConnectivity(c, cI)
1218
1219         eps=1.0e-4 # not the pb here
1220         res2D, res1D, resToSelf, mapLeftRight = MEDCouplingUMesh.Intersect2DMeshWith1DLine(mesh, tool, eps)
1221         self.assertEqual(res1D.getNodalConnectivity().getValues(),[1, 20, 25,   1, 25, 26,   1, 26, 27,   1, 27, 24,   1, 24, 23,   1, 23, 28,   1, 28, 29,   1, 29, 22,   1, 22, 21])
1222         self.assertEqual(res1D.getNodalConnectivityIndex().getValues(),[0, 3, 6, 9, 12, 15, 18, 21, 24, 27])
1223         self.assertEqual(res2D.getNodalConnectivity().getValues(),[5, 2, 18, 26, 25,   5, 13, 15, 24, 27, 16, 10, 28, 23,   5, 8, 3, 0, 4, 5, 7, 22, 29,   5, 6, 12, 23, 28, 11, 9, 29, 22,   5, 14, 1, 25, 26, 19, 17, 27, 24])
1224         self.assertEqual(res2D.getNodalConnectivityIndex().getValues(),[0, 5, 14, 23, 32, 41])
1225
1226         self.assertEqual(resToSelf.getValues(), [0, 0, 0, 0, 0])
1227         self.assertEqual(mapLeftRight.getValues(), [-1, -1, 0, 4, -1, -1, 1, 4, -1, -1, 1, 3, -1, -1, 2, 3, -1, -1])
1228         pass
1229
1230     def testSwig2Intersect2DMeshWith1DLine21(self):
1231         """ A line intersecting a cell very close to one of its node (collinearity not detected) """
1232         eps=1.0e-5  # was working at 1.0e-8, but should also really work with 1.0e-5
1233         mesh = MEDCouplingUMesh('mesh', 2)
1234         coo = DataArrayDouble([(110.65324,180.56968),(112.01128,182.78580),(113.36932,185.00192),(118.27200,181.90669),(118.27200,178.79852),(118.27200,175.67380)])
1235         mesh.setCoords(coo)
1236         c = DataArrayInt([NORM_QUAD4, 0, 1, 4, 5, NORM_QUAD4, 1, 2, 3, 4])
1237         cI = DataArrayInt([0, 5, 10])
1238         mesh.setConnectivity(c, cI)
1239
1240         tool = MEDCouplingUMesh('tool', 1)
1241         coo = DataArrayDouble([(0.0, 182.78400),  (182.78400, 182.78400)])
1242         tool.setCoords(coo)
1243         c = DataArrayInt([NORM_SEG2,0,1])
1244         cI = DataArrayInt([0, 3])
1245         tool.setConnectivity(c, cI)
1246
1247         res2D, res1D, resToSelf, mapLeftRight = MEDCouplingUMesh.Intersect2DMeshWith1DLine(mesh, tool, eps)
1248         self.assertEqual(res1D.getNodalConnectivity().getValues(), [1, 6, 1, 1, 1, 8, 1, 8, 9, 1, 9, 7])
1249         self.assertEqual(res1D.getNodalConnectivityIndex().getValues(),[0, 3, 6, 9, 12])
1250         self.assertEqual(res2D.getNodalConnectivity().getValues(), [5, 0, 1, 8, 4, 5, 5, 1, 2, 9, 8, 5, 3, 4, 8, 9])
1251         self.assertEqual(res2D.getNodalConnectivityIndex().getValues(),[0, 6, 11, 16])
1252
1253         self.assertEqual(resToSelf.getValues(), [0, 1, 1])
1254         self.assertEqual(mapLeftRight.getValues(), [-1, -1, 1, 0, 1, 2, -1, -1])
1255
1256
1257
1258     def testSwig2Conformize2D1(self):
1259         eps = 1.0e-8
1260         coo = [0.,-0.5,0.,0.,0.5,0.,0.5,-0.5,0.25,
1261                -0.1,0.25,0.,0.5,-0.1,0.,0.5,0.5,0.5,0.25,0.4,0.25,0.5,0.5,0.4]
1262         conn = [5,5,2,6,4,5,6,3,0,1,5,4,5,10,8,11,9,5,11,2,1,7,10,9]
1263         connI = [0,5,12,17,24]
1264         m = MEDCouplingUMesh("box",2)
1265         cooArr = DataArrayDouble(coo, len(coo) // 2, 2)
1266         m.setCoords(cooArr)
1267         m.setConnectivity(DataArrayInt(conn),DataArrayInt(connI))
1268         m.mergeNodes(eps)
1269         m.checkConsistencyLight()
1270         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([3])))
1271         self.assertEqual(m.getCoords().getHiddenCppPointer(),cooArr.getHiddenCppPointer()) # check that coordinates remain the same here
1272         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,5,2,6,4,5,6,3,0,1,5,4,5,10,8,11,9,5,11,2,5,1,7,10,9])))
1273         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,12,17,25])))
1274         pass
1275
1276     def testSwig2Conformize2D2(self):
1277         eps = 1.0e-8
1278         coo=DataArrayDouble([-10,-6,0,-6,0,0,7,0,-10,2,0,2,0,6,7,6,0,8,7,8,-10,12,-4,12,0,12,0,11,7,11,-4,16,0,16,7,16],18,2)
1279         conn=DataArrayInt([2,3,7,6, 13,16,17,14, 4,10,12,5, 9,14,13,8, 8,9,7,6, 5,4,0,1, 16,12,11,15])
1280         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
1281         m.setCoords(coo)
1282         m.setNodalConnectivity(conn)
1283         m=m.buildUnstructured()
1284         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
1285         self.assertEqual(m.getCoords().getHiddenCppPointer(),coo.getHiddenCppPointer()) # check that coordinates remain the same here
1286         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,2,3,7,6,5, 5,13,12,16,17,14, 5,4,10,11,12,13,8,6,5, 4,9,14,13,8, 4,8,9,7,6, 5,5,4,0,1,2, 4,16,12,11,15])))
1287         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,6,12,21,26,31,37,42])))
1288         pass
1289
1290     def testSwigSplit2DCells1(self):
1291         coo=DataArrayDouble([[0,0],[1,0],[1,1],[0,1],[0.5,0],[1,0.5],[0.5,1],[0.,0.5]])
1292         m=MEDCouplingUMesh("mesh",2)
1293         m.setCoords(coo)
1294         m.allocateCells()
1295         m.insertNextCell(NORM_QUAD8,[0,1,2,3,4,5,6,7])
1296         _,d,di,_,_=m.buildDescendingConnectivity()
1297         subb=DataArrayInt([5])
1298         subbi=DataArrayInt([0,0,1,1,1])
1299         mid=DataArrayInt([-1,-1])
1300         midi=DataArrayInt([0,0,2,2,2])
1301         self.assertEqual(2,m.split2DCells(d,di,subb,subbi,mid,midi))
1302         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,1,5,2,3,4,8,9,6,7])))
1303         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11])))
1304         self.assertTrue(m.getCoords().isEqual(DataArrayDouble([[0,0],[1,0],[1,1],[0,1],[0.5,0],[1,0.5],[0.5,1],[0.,0.5],[1.,0.25],[1.,0.75]]),1e-12))
1305         pass
1306
1307     def testSwig2Conformize2D3(self):
1308         eps = 1.0e-8
1309         coo=DataArrayDouble([-10,-6,0,-6,0,0,7,0,-10,2,0,2,0,6.5,7,6.5,0,8,7,8,-10,12,-4,12,0,12,0,11,7,11,-4,16,0,16,7,16],18,2)
1310         conn=DataArrayInt([2,3,7,6, 13,16,17,14, 4,10,12,5, 9,14,13,8, 8,9,7,6, 5,4,0,1, 16,12,11,15])
1311         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
1312         m.setCoords(coo)
1313         m.setNodalConnectivity(conn)
1314         m=m.buildUnstructured()
1315         m.convertLinearCellsToQuadratic()
1316         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
1317         self.assertTrue(m.getCoords().getHiddenCppPointer()!=coo.getHiddenCppPointer()) # coordinates are not the same here contrary to testSwig2Conformize2D2 ...
1318         self.assertTrue(m.getCoords()[:18].isEqual(coo,1e-12)) # but the 18 first nodes are the same
1319         pass
1320
1321     def testSwig2Conformize2D4(self):
1322         eps = 1.0e-8
1323         coo=DataArrayDouble([-10,-6,0,-6,0,0,7,0,-10,2,0,2,0,6.5,7,6.5,0,8,7,8,-10,12,-4,12,0,12,0,11,7,11,-4,16,0,16,7,16],18,2)
1324         conn=DataArrayInt([2,3,7,6, 13,16,17,14, 4,10,12,5, 9,14,13,8, 8,9,7,6, 5,4,0,1, 16,12,11,15])
1325         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
1326         m.setCoords(coo)
1327         m.setNodalConnectivity(conn)
1328         m=m.buildUnstructured()
1329         m.convertLinearCellsToQuadratic()
1330         self.assertEqual(42,m.getNumberOfNodes())
1331         oldCoo=m.getCoords().deepCopy()
1332         m.conformize2D(eps)
1333         self.assertTrue(m.getCoords()[:42].isEqual(oldCoo,1e-12))
1334         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,2,3,7,6,5,18,19,20,42,43,32,13,12,16,17,14,44,38,23,24,25,32,4,10,11,12,13,8,6,5,26,45,39,44,31,34,42,29,8,9,14,13,8,30,25,31,32,8,8,9,7,6,32,33,20,34,32,5,4,0,1,2,29,35,36,46,43,8,16,12,11,15,38,39,40,41])))
1335         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11,22,39,48,57,68,77])))
1336         self.assertTrue(m.getCoords().isEqual(DataArrayDouble([[-10.,-6.0],[0.,-6.0],[0.,0.0],[7.,0.0],[-10.,2.0],[0.,2.0],[0.,6.5],[7.,6.5],[0.,8.0],[7.,8.0],[-10.,12.0],[-4.,12.0],[0.,12.0],[0.,11.0],[7.,11.0],[-4.,16.0],[0.,16.0],[7.,16.0],[3.5, 0.0],[7.,3.25],[3.5, 6.5],[0.,3.25],[0.,13.5],[3.5, 16.0],[7.,13.5],[3.5, 11.0],[-10.,7.0],[-5.,12.0],[0.,7.0],[-5.,2.0],[7.,9.5],[0.,9.5],[3.5, 8.0],[7.,7.25],[0.,7.25],[-10.,-2.0],[-5.,-6.0],[0.,-2.0],[0.,14.0],[-2.,12.0],[-4.,14.0],[-2.,16.0],[0.,4.25],[0.,1.0],[0.,11.5],[-7.,12.0],[0.,-3.]]),1e-12))
1337         pass
1338
1339     def testSwig2Conformize2D5(self):
1340         eps=1e-8
1341         coo=DataArrayDouble([[2,2],[2,-6],[10,-2],[-2,-2],[6,0],[6,-4],[2,7],[2,4.5],[-1.4641016151377544,0],[-1.950753362380551,-1.3742621398390762],[-7,-3],[-0.8284271247461898,-4.82842712474619],[0.26794919243112281,3.5],[0,1.4641016151377548],[-4.4753766811902755,-2.1871310699195381],[-3.9142135623730949,-3.9142135623730949],[-1.8042260651806146,-3.23606797749979]])
1342         m=MEDCouplingUMesh("mesh",2)
1343         m.allocateCells()
1344         m.setCoords(coo)
1345         m.insertNextCell(NORM_TRI6,[1,2,0,5,4,3])
1346         m.insertNextCell(NORM_TRI6,[8,6,0,12,7,13])
1347         m.insertNextCell(NORM_TRI6,[11,9,10,16,14,15])
1348         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0])))
1349         self.assertTrue(m.getCoords().isEqual(DataArrayDouble([2.,2.,2.,-6.,10.,-2.,-2.,-2.,6.,0.,6.,-4.,2.,7.,2.,4.5,-1.4641016151377544,0.,-1.950753362380551,-1.3742621398390762,-7.,-3.,-0.8284271247461898,-4.82842712474619,0.2679491924311228,3.5,8.881784197001252e-16,1.4641016151377548,-4.4753766811902755,-2.187131069919538,-3.914213562373095,-3.914213562373095,-1.8042260651806146,-3.236067977499789,-1.7705659643687133,-0.6647725630649153,0.46926627053963865,-5.695518130045146],19,2),1e-12))
1350         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,1,2,0,8,9,11,5,4,13,17,16,18,6,8,6,0,12,7,13,6,11,9,10,16,14,15])))
1351         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,13,20,27])))
1352         pass
1353
1354     def testSwig2Conformize2D6(self):
1355         """ Was raising an internal error on the tiny cell #1. SegSegIntersector was faulty (eps misinterpreted)."""
1356         eps=1.0e-6
1357         mesh = MEDCouplingUMesh('Intersect2D', 2)
1358         coo = DataArrayDouble([(-8.575398341058831,39.144034061751867),(-7.163839075265572,39.460696499553713),(-8.555240716524352,39.000452491656162),(-8.575381177420400,39.143911806168589),(-8.575389759239616,39.143972933960228),(-8.565310946972376,39.072182148912376),(-8.429007892596994,39.323429450193125),(-7.276475921428452,39.552916149667766),(-7.853580170499488,39.442382740946520),(-8.501337660834821,39.233025525494369),(-8.451698830704938,39.023021732647329),(-8.575293095466966,39.143931102458232),(-7.321160265208347,39.250835031152391),(-7.193377962393479,39.421292562742188),(-8.503477261299500,39.011771463728323),(-7.257269113800913,39.336063796947286),(-8.575337136449106,39.143921454338184),(-8.513495963085951,39.083476417552781),(-7.178608518829526,39.440994531147950),(-8.575345718262898,39.143982582105053),(-7.887252103212342,39.141010366774864),(-7.885555090015171,39.288688127112323),(-7.223911296170824,39.502221445493511)])
1359         mesh.setCoords(coo)
1360         c = DataArrayInt([32, 2, 3, 11, 10, 5, 16, 17, 14, 32, 3, 0, 11, 4, 19, 16, 32, 13, 12, 10, 11, 15, 20, 17, 21, 32, 7, 1, 13, 11, 0, 6, 22, 18, 21, 19, 9, 8])
1361         cI = DataArrayInt([0, 9, 16, 25, 38])
1362         mesh.setConnectivity(c, cI)
1363
1364         mesh.conformize2D(eps)  # internal error was here
1365
1366         c2, cI2 = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
1367         self.assertEqual(c2, c.getValues())
1368         self.assertEqual(cI2, cI.getValues())
1369         pass
1370
1371     def testSwig2Conformize3D1(self):
1372         """ Simple test where no edge merge is required, only face merging (first part of the algo) """
1373         mesh = MEDCouplingUMesh('merge', 3)
1374         coo = DataArrayDouble([(0,0,0),(1,0,0),(0,1,0),(1,1,0),(0,0,1),(1,0,1),(0,1,1),(1,1,1),(1,0.5,0.5),
1375                                (2,0,0),(2,1,0),(2,0,1),(2,1,1),(1,0,2),(2,0,2),(1,1,2),(2,1,2)])
1376         mesh.setCoords(coo)
1377         c = DataArrayInt([31, 1, 0, 2, 3, -1, 5, 7, 6, 4, -1, 1, 5, 4, 0, -1, 0, 4, 6, 2, -1, 2, 6, 7, 3, -1,
1378                            3, 7, 8, -1, 7, 5, 8, -1, 5, 1, 8, -1, 1, 3, 8, 31, 9, 1, 3, 10, -1, 11, 12, 7, 5, -1,
1379                            9, 11, 5, 1, -1, 1, 5, 7, 3, -1, 3, 7, 12, 10, -1, 10, 12, 11, 9, 31, 11, 5, 7, 12, -1,
1380                            14, 16, 15, 13, -1, 11, 14, 13, 5, -1, 5, 13, 15, 7, -1, 7, 15, 16, 12, -1, 12, 16, 14, 11])
1381         cI = DataArrayInt([0, 41, 71, 101])
1382         mesh.setConnectivity(c, cI)
1383         ret = mesh.conformize3D(1.0e-8)
1384
1385         mretDesc, _, _, _, _ = mesh.buildDescendingConnectivity()
1386         c, cI = mretDesc.getNodalConnectivity().getValues(), mretDesc.getNodalConnectivityIndex().getValues()
1387         cRef = [5, 1, 0, 2, 3, 5, 5, 7, 6, 4, 5, 1, 5, 4, 0, 5, 0, 4, 6, 2, 5, 2, 6, 7, 3, 5, 3, 7, 8, 5,
1388                 7, 5, 8, 5, 5, 1, 8, 5, 1, 3, 8, 5, 9, 1, 3, 10, 5, 11, 12, 7, 5, 5, 9, 11, 5, 1, 5, 3,
1389                 7, 12, 10, 5, 10, 12, 11, 9, 5, 14, 16, 15, 13, 5, 11, 14, 13, 5, 5, 5, 13, 15, 7, 5, 7,
1390                 15, 16, 12, 5, 12, 16, 14, 11]
1391         cIRef = [0, 5, 10, 15, 20, 25, 29, 33, 37, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91]
1392         self.assertEqual(19, mretDesc.getNumberOfCells())
1393         self.assertEqual(cRef, c)
1394         self.assertEqual(cIRef, cI)
1395         self.assertEqual([1], ret.getValues())
1396         pass
1397
1398     def testSwig2Conformize3D2(self):
1399         """ More advanced test where edge merge is required. """
1400         mesh = MEDCouplingUMesh('merge', 3)
1401         coo = DataArrayDouble([(0,0,0),(1,0,0),(0,1,0),(1,1,0),(0,0,1),(1,0,1),(0,1,1),(1,1,1),(0,0,2),(1,0,2),(0,1,2),
1402                                (1,1,2),(1,0.6,0),(1,0.6,1),(1,0.3,1),(1,0.3,2),(2,0,0),(2,1,0),(2,0,1),(2,1,1),(2,0,2),(2,1,2)])
1403         mesh.setCoords(coo)
1404         c = DataArrayInt([31, 1, 0, 2, 3, 12, -1, 5, 13, 7, 6, 4, -1, 1, 5, 4, 0, -1, 0, 4, 6, 2, -1, 2, 6, 7, 3, -1, 3, 7, 13, 12, -1,
1405                           5, 1, 12, 13, 31, 5, 4, 6, 7, 14, -1, 9, 15, 11, 10, 8, -1, 5, 9, 8, 4, -1, 4, 8, 10, 6, -1, 6, 10, 11, 7, -1,
1406                           7, 11, 15, 14, -1, 9, 5, 14, 15, 31, 16, 1, 3, 17, -1, 18, 19, 7, 5, -1, 16, 18, 5, 1, -1, 1, 5, 7, 3, -1,
1407                           3, 7, 19, 17, -1, 17, 19, 18, 16, 31, 18, 5, 7, 19, -1, 20, 21, 11, 9, -1, 18, 20, 9, 5, -1, 5, 9, 11, 7, -1,
1408                           7, 11, 21, 19, -1, 19, 21, 20, 18])
1409         cI = DataArrayInt([0, 37, 74, 104, 134])
1410         mesh.setConnectivity(c, cI)
1411
1412         ret = mesh.conformize3D(1.0e-8)
1413
1414         mretDesc, _, _, _, _ = mesh.buildDescendingConnectivity()
1415         mretDesc2, _, _, _, _ = mretDesc.buildDescendingConnectivity()
1416         c0, cI0 = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
1417         c, cI = mretDesc.getNodalConnectivity().getValues(), mretDesc.getNodalConnectivityIndex().getValues()
1418         c2, cI2 = mretDesc2.getNodalConnectivity().getValues(), mretDesc2.getNodalConnectivityIndex().getValues()
1419         cRef0 = [31, 1, 0, 2, 3, 12, -1, 5, 14, 13, 7, 6, 4, -1, 1, 5, 4, 0, -1, 0, 4, 6, 2, -1, 2, 6, 7, 3, -1, 3, 7, 13, 12, -1, 5, 1, 12, 13, 14, 31, 9, 15, 11, 10, 8, -1, 5, 9, 8, 4, -1, 4, 8, 10, 6, -1, 6, 10, 11, 7, -1, 7, 11, 15, 14, 13, -1, 9, 5, 14, 15, -1, 5, 14, 13, 7, 6, 4, 31, 16, 1, 12, 3, 17, -1, 18, 19, 7, 13, 14, 5, -1, 16, 18, 5, 1, -1, 3, 7, 19, 17, -1, 17, 19, 18, 16, -1, 5, 1, 12, 13, 14, -1, 3, 7, 13, 12, 31, 5, 14, 13, 7, 19, 18, -1, 20, 21, 11, 15, 9, -1, 18, 20, 9, 5, -1, 7, 11, 21, 19, -1, 19, 21, 20, 18, -1, 9, 5, 14, 15, -1, 7, 11, 15, 14, 13]
1420         cIRef0 = [0, 39, 78, 117, 156]
1421         cRef = [5, 1, 0, 2, 3, 12, 5, 5, 14, 13, 7, 6, 4, 5, 1, 5, 4, 0, 5, 0, 4, 6, 2, 5, 2, 6, 7, 3, 5, 3, 7, 13, 12, 5, 5, 1, 12, 13, 14, 5, 9, 15, 11, 10, 8, 5, 5, 9, 8, 4, 5, 4, 8, 10, 6, 5, 6, 10, 11, 7, 5, 7, 11, 15, 14, 13, 5, 9, 5, 14, 15, 5, 16, 1, 12, 3, 17, 5, 18, 19, 7, 13, 14, 5, 5, 16, 18, 5, 1, 5, 3, 7, 19, 17, 5, 17, 19, 18, 16, 5, 20, 21, 11, 15, 9, 5, 18, 20, 9, 5, 5, 7, 11, 21, 19, 5, 19, 21, 20, 18]
1422         cIRef = [0, 6, 13, 18, 23, 28, 33, 39, 45, 50, 55, 60, 66, 71, 77, 84, 89, 94, 99, 105, 110, 115, 120]
1423         cRef2 = [1, 1, 0, 1, 0, 2, 1, 2, 3, 1, 3, 12, 1, 12, 1, 1, 5, 14, 1, 14, 13, 1, 13, 7, 1, 7, 6, 1, 6, 4, 1, 4, 5, 1, 1, 5, 1, 4, 0, 1, 6, 2, 1, 7, 3, 1, 13, 12, 1, 9, 15, 1, 15, 11, 1, 11, 10, 1, 10, 8, 1, 8, 9, 1, 5, 9, 1, 8, 4, 1, 10, 6, 1, 11, 7, 1, 15, 14, 1, 16, 1, 1, 3, 17, 1, 17, 16, 1, 18, 19, 1, 19, 7, 1, 5, 18, 1, 16, 18, 1, 19, 17, 1, 20, 21, 1, 21, 11, 1, 9, 20, 1, 18, 20, 1, 21, 19]
1424         cIRef2 = [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99, 102, 105, 108, 111, 114, 117]
1425         self.assertEqual(22, mretDesc.getNumberOfCells())
1426         self.assertEqual(39, mretDesc2.getNumberOfCells())
1427         self.assertEqual(cRef0, c0)
1428         self.assertEqual(cIRef0, cI0)
1429         self.assertEqual(cRef, c)
1430         self.assertEqual(cIRef, cI)
1431         self.assertEqual(cRef2, c2)
1432         self.assertEqual(cIRef2, cI2)
1433         self.assertEqual(set([0,1,2,3]), set(ret.getValues()))
1434         pass
1435
1436     def testSwig2Conformize3D3(self):
1437         """ LMEC's case (hexagonal prism) """
1438         eps = 1.0e-7   # 1.0e-8 is too fine
1439         mesh = MEDCouplingUMesh('merge', 3)
1440         coo = DataArrayDouble([(0,0,0),(-0.0054,-0.00935307,0),(0.0054,-0.00935307,0),(0.0108,0,0),(0.0054,0.00935307,0),(-0.0054,0.00935307,0),(-0.0108,6.93889e-18,0),(-0.0054,-0.0153031,0),(0.0054,-0.0153031,0),(0.0105529,-0.0123281,0),(0.0159529,-0.002975,0),(0.0159529,0.002975,0),(0.0105529,0.0123281,0),(0.0054,0.0153031,0),(-0.0054,0.0153031,0),(-0.0105529,0.0123281,0),(-0.0159529,0.002975,0),(-0.0159529,-0.002975,0),(-0.0105529,-0.0123281,0),(-0.00883523,-0.0153031,0),(0.00883523,-0.0153031,0),(0.0176705,0,0),(0.00883523,0.0153031,0),(-0.00883523,0.0153031,0),(-0.0176705,2.16401e-18,0),(0,0,0.05),(-0.0054,-0.00935307,0.05),(0.0054,-0.00935307,0.05),(0.0108,0,0.05),(0.0054,0.00935307,0.05),(-0.0054,0.00935307,0.05),(-0.0108,6.93889e-18,0.05),(-0.0054,-0.0153031,0.05),(0.0054,-0.0153031,0.05),(0.0105529,-0.0123281,0.05),(0.0159529,-0.002975,0.05),(0.0159529,0.002975,0.05),(0.0105529,0.0123281,0.05),(0.0054,0.0153031,0.05),(-0.0054,0.0153031,0.05),(-0.0105529,0.0123281,0.05),(-0.0159529,0.002975,0.05),(-0.0159529,-0.002975,0.05),(-0.0105529,-0.0123281,0.05),(-0.00883523,-0.0153031,0.05),(0.00883523,-0.0153031,0.05),(0.0176705,0,0.05),(0.00883523,0.0153031,0.05),(-0.00883523,0.0153031,0.05),(-0.0176705,2.16401e-18,0.05),(0.0176705,0,0.05),(0.00883523,0.0153031,0.05),(-0.00883523,0.0153031,0.05),(-0.0176705,2.16401e-18,0.05),(-0.00883523,-0.0153031,0.05),(0.00883523,-0.0153031,0.05),(0.0176705,0,0.15),(0.00883523,0.0153031,0.15),(-0.00883523,0.0153031,0.15),(-0.0176705,2.16401e-18,0.15),(-0.00883523,-0.0153031,0.15),(0.00883523,-0.0153031,0.15)])
1441         mesh.setCoords(coo)
1442         c = DataArrayInt([31, 1, 0, 2, -1, 25, 26, 27, -1, 2, 27, 26, 1, -1, 0, 25, 27, 2, -1, 1, 26, 25, 0, 31, 2, 0, 3, -1, 25, 27, 28, -1, 3, 28, 27, 2, -1, 0, 25, 28, 3, -1, 2, 27, 25, 0, 31, 3, 0, 4, -1, 25, 28, 29, -1, 4, 29, 28, 3, -1, 0, 25, 29, 4, -1, 3, 28, 25, 0, 31, 4, 0, 5, -1, 25, 29, 30, -1, 5, 30, 29, 4, -1, 0, 25, 30, 5, -1, 4, 29, 25, 0, 31, 5, 0, 6, -1, 25, 30, 31, -1, 6, 31, 30, 5, -1, 0, 25, 31, 6, -1, 5, 30, 25, 0, 31, 6, 0, 1, -1, 25, 31, 26, -1, 1, 26, 31, 6, -1, 0, 25, 26, 1, -1, 6, 31, 25, 0, 31, 1, 2, 8, 7, -1, 27, 26, 32, 33, -1, 7, 32, 26, 1, -1, 8, 33, 32, 7, -1, 2, 27, 33, 8, -1, 1, 26, 27, 2, 31, 2, 3, 10, 9, -1, 28, 27, 34, 35, -1, 9, 34, 27, 2, -1, 10, 35, 34, 9, -1, 3, 28, 35, 10, -1, 2, 27, 28, 3, 31, 3, 4, 12, 11, -1, 29, 28, 36, 37, -1, 11, 36, 28, 3, -1, 12, 37, 36, 11, -1, 4, 29, 37, 12, -1, 3, 28, 29, 4, 31, 4, 5, 14, 13, -1, 30, 29, 38, 39, -1, 13, 38, 29, 4, -1, 14, 39, 38, 13, -1, 5, 30, 39, 14, -1, 4, 29, 30, 5, 31, 5, 6, 16, 15, -1, 31, 30, 40, 41, -1, 15, 40, 30, 5, -1, 16, 41, 40, 15, -1, 6, 31, 41, 16, -1, 5, 30, 31, 6, 31, 6, 1, 18, 17, -1, 26, 31, 42, 43, -1, 17, 42, 31, 6, -1, 18, 43, 42, 17, -1, 1, 26, 43, 18, -1, 6, 31, 26, 1, 31, 19, 18, 1, 7, -1, 43, 44, 32, 26, -1, 7, 32, 44, 19, -1, 1, 26, 32, 7, -1, 18, 43, 26, 1, -1, 19, 44, 43, 18, 31, 20, 8, 2, 9, -1, 33, 45, 34, 27, -1, 9, 34, 45, 20, -1, 2, 27, 34, 9, -1, 8, 33, 27, 2, -1, 20, 45, 33, 8, 31, 21, 10, 3, 11, -1, 35, 46, 36, 28, -1, 11, 36, 46, 21, -1, 3, 28, 36, 11, -1, 10, 35, 28, 3, -1, 21, 46, 35, 10, 31, 22, 12, 4, 13, -1, 37, 47, 38, 29, -1, 13, 38, 47, 22, -1, 4, 29, 38, 13, -1, 12, 37, 29, 4, -1, 22, 47, 37, 12, 31, 23, 14, 5, 15, -1, 39, 48, 40, 30, -1, 15, 40, 48, 23, -1, 5, 30, 40, 15, -1, 14, 39, 30, 5, -1, 23, 48, 39, 14, 31, 24, 16, 6, 17, -1, 41, 49, 42, 31, -1, 17, 42, 49, 24, -1, 6, 31, 42, 17, -1, 16, 41, 31, 6, -1, 24, 49, 41, 16, 31, 50, 51, 52, 53, 54, 55, -1, 56, 61, 60, 59, 58, 57, -1, 50, 56, 57, 51, -1, 51, 57, 58, 52, -1, 52, 58, 59, 53, -1, 53, 59, 60, 54, -1, 54, 60, 61, 55, -1, 55, 61, 56, 50])
1443         cI = DataArrayInt([0, 23, 46, 69, 92, 115, 138, 168, 198, 228, 258, 288, 318, 348, 378, 408, 438, 468, 498, 542])
1444         mesh.setConnectivity(c, cI)
1445         mesh.mergeNodes(eps) # the initial case has double nodes
1446
1447         ret = mesh.conformize3D(eps)
1448
1449         mretDesc, _, _, _, _ = mesh.buildDescendingConnectivity()
1450         mretDesc2, _, _, _, _ = mretDesc.buildDescendingConnectivity()
1451         c0, cI0 = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
1452         c, cI = mretDesc.getNodalConnectivity().getValues(), mretDesc.getNodalConnectivityIndex().getValues()
1453         c2, cI2 = mretDesc2.getNodalConnectivity().getValues(), mretDesc2.getNodalConnectivityIndex().getValues()
1454         cRef0 = [31, 1, 0, 2, -1, 25, 26, 27, -1, 2, 27, 26, 1, -1, 0, 25, 27, 2, -1, 1, 26, 25, 0, 31, 2, 0, 3, -1, 25, 27, 28, -1, 3, 28, 27, 2, -1, 0, 25, 28, 3, -1, 2, 27, 25, 0, 31, 3, 0, 4, -1, 25, 28, 29, -1, 4, 29, 28, 3, -1, 0, 25, 29, 4, -1, 3, 28, 25, 0, 31, 4, 0, 5, -1, 25, 29, 30, -1, 5, 30, 29, 4, -1, 0, 25, 30, 5, -1, 4, 29, 25, 0, 31, 5, 0, 6, -1, 25, 30, 31, -1, 6, 31, 30, 5, -1, 0, 25, 31, 6, -1, 5, 30, 25, 0, 31, 6, 0, 1, -1, 25, 31, 26, -1, 1, 26, 31, 6, -1, 0, 25, 26, 1, -1, 6, 31, 25, 0, 31, 1, 2, 8, 7, -1, 27, 26, 32, 33, -1, 7, 32, 26, 1, -1, 8, 33, 32, 7, -1, 2, 27, 33, 8, -1, 1, 26, 27, 2, 31, 2, 3, 10, 9, -1, 28, 27, 34, 35, -1, 9, 34, 27, 2, -1, 10, 35, 34, 9, -1, 3, 28, 35, 10, -1, 2, 27, 28, 3, 31, 3, 4, 12, 11, -1, 29, 28, 36, 37, -1, 11, 36, 28, 3, -1, 12, 37, 36, 11, -1, 4, 29, 37, 12, -1, 3, 28, 29, 4, 31, 4, 5, 14, 13, -1, 30, 29, 38, 39, -1, 13, 38, 29, 4, -1, 14, 39, 38, 13, -1, 5, 30, 39, 14, -1, 4, 29, 30, 5, 31, 5, 6, 16, 15, -1, 31, 30, 40, 41, -1, 15, 40, 30, 5, -1, 16, 41, 40, 15, -1, 6, 31, 41, 16, -1, 5, 30, 31, 6, 31, 6, 1, 18, 17, -1, 26, 31, 42, 43, -1, 17, 42, 31, 6, -1, 18, 43, 42, 17, -1, 1, 26, 43, 18, -1, 6, 31, 26, 1, 31, 19, 18, 1, 7, -1, 43, 44, 32, 26, -1, 7, 32, 44, 19, -1, 1, 26, 32, 7, -1, 18, 43, 26, 1, -1, 19, 44, 43, 18, 31, 20, 8, 2, 9, -1, 33, 45, 34, 27, -1, 9, 34, 45, 20, -1, 2, 27, 34, 9, -1, 8, 33, 27, 2, -1, 20, 45, 33, 8, 31, 21, 10, 3, 11, -1, 35, 46, 36, 28, -1, 11, 36, 46, 21, -1, 3, 28, 36, 11, -1, 10, 35, 28, 3, -1, 21, 46, 35, 10, 31, 22, 12, 4, 13, -1, 37, 47, 38, 29, -1, 13, 38, 47, 22, -1, 4, 29, 38, 13, -1, 12, 37, 29, 4, -1, 22, 47, 37, 12, 31, 23, 14, 5, 15, -1, 39, 48, 40, 30, -1, 15, 40, 48, 23, -1, 5, 30, 40, 15, -1, 14, 39, 30, 5, -1, 23, 48, 39, 14, 31, 24, 16, 6, 17, -1, 41, 49, 42, 31, -1, 17, 42, 49, 24, -1, 6, 31, 42, 17, -1, 16, 41, 31, 6, -1, 24, 49, 41, 16, 31, 50, 55, 54, 53, 52, 51, -1, 46, 50, 51, 47, 37, 36, -1, 47, 51, 52, 48, 39, 38, -1, 48, 52, 53, 49, 41, 40, -1, 49, 53, 54, 44, 43, 42, -1, 44, 54, 55, 45, 33, 32, -1, 45, 55, 50, 46, 35, 34, -1, 25, 26, 27, -1, 25, 31, 26, -1, 27, 26, 32, 33, -1, 26, 31, 42, 43, -1, 43, 44, 32, 26, -1, 41, 49, 42, 31, -1, 25, 29, 30, -1, 25, 30, 31, -1, 30, 29, 38, 39, -1, 31, 30, 40, 41, -1, 39, 48, 40, 30, -1, 25, 27, 28, -1, 28, 27, 34, 35, -1, 33, 45, 34, 27, -1, 35, 46, 36, 28, -1, 25, 28, 29, -1, 29, 28, 36, 37, -1, 37, 47, 38, 29]
1455         cIRef0 = [0, 23, 46, 69, 92, 115, 138, 168, 198, 228, 258, 288, 318, 348, 378, 408, 438, 468, 498, 631]
1456         cRef = [5, 1, 0, 2, 5, 25, 26, 27, 5, 2, 27, 26, 1, 5, 0, 25, 27, 2, 5, 1, 26, 25, 0, 5, 2, 0, 3, 5, 25, 27, 28, 5, 3, 28, 27, 2, 5, 0, 25, 28, 3, 5, 3, 0, 4, 5, 25, 28, 29, 5, 4, 29, 28, 3, 5, 0, 25, 29, 4, 5, 4, 0, 5, 5, 25, 29, 30, 5, 5, 30, 29, 4, 5, 0, 25, 30, 5, 5, 5, 0, 6, 5, 25, 30, 31, 5, 6, 31, 30, 5, 5, 0, 25, 31, 6, 5, 6, 0, 1, 5, 25, 31, 26, 5, 1, 26, 31, 6, 5, 1, 2, 8, 7, 5, 27, 26, 32, 33, 5, 7, 32, 26, 1, 5, 8, 33, 32, 7, 5, 2, 27, 33, 8, 5, 2, 3, 10, 9, 5, 28, 27, 34, 35, 5, 9, 34, 27, 2, 5, 10, 35, 34, 9, 5, 3, 28, 35, 10, 5, 3, 4, 12, 11, 5, 29, 28, 36, 37, 5, 11, 36, 28, 3, 5, 12, 37, 36, 11, 5, 4, 29, 37, 12, 5, 4, 5, 14, 13, 5, 30, 29, 38, 39, 5, 13, 38, 29, 4, 5, 14, 39, 38, 13, 5, 5, 30, 39, 14, 5, 5, 6, 16, 15, 5, 31, 30, 40, 41, 5, 15, 40, 30, 5, 5, 16, 41, 40, 15, 5, 6, 31, 41, 16, 5, 6, 1, 18, 17, 5, 26, 31, 42, 43, 5, 17, 42, 31, 6, 5, 18, 43, 42, 17, 5, 1, 26, 43, 18, 5, 19, 18, 1, 7, 5, 43, 44, 32, 26, 5, 7, 32, 44, 19, 5, 19, 44, 43, 18, 5, 20, 8, 2, 9, 5, 33, 45, 34, 27, 5, 9, 34, 45, 20, 5, 20, 45, 33, 8, 5, 21, 10, 3, 11, 5, 35, 46, 36, 28, 5, 11, 36, 46, 21, 5, 21, 46, 35, 10, 5, 22, 12, 4, 13, 5, 37, 47, 38, 29, 5, 13, 38, 47, 22, 5, 22, 47, 37, 12, 5, 23, 14, 5, 15, 5, 39, 48, 40, 30, 5, 15, 40, 48, 23, 5, 23, 48, 39, 14, 5, 24, 16, 6, 17, 5, 41, 49, 42, 31, 5, 17, 42, 49, 24, 5, 24, 49, 41, 16, 5, 50, 55, 54, 53, 52, 51, 5, 46, 50, 51, 47, 37, 36, 5, 47, 51, 52, 48, 39, 38, 5, 48, 52, 53, 49, 41, 40, 5, 49, 53, 54, 44, 43, 42, 5, 44, 54, 55, 45, 33, 32, 5, 45, 55, 50, 46, 35, 34]
1457         cIRef = [0, 4, 8, 13, 18, 23, 27, 31, 36, 41, 45, 49, 54, 59, 63, 67, 72, 77, 81, 85, 90, 95, 99, 103, 108, 113, 118, 123, 128, 133, 138, 143, 148, 153, 158, 163, 168, 173, 178, 183, 188, 193, 198, 203, 208, 213, 218, 223, 228, 233, 238, 243, 248, 253, 258, 263, 268, 273, 278, 283, 288, 293, 298, 303, 308, 313, 318, 323, 328, 333, 338, 343, 348, 353, 358, 363, 368, 373, 378, 385, 392, 399, 406, 413, 420, 427]
1458         cRef2 = [1, 1, 0, 1, 0, 2, 1, 2, 1, 1, 25, 26, 1, 26, 27, 1, 27, 25, 1, 2, 27, 1, 26, 1, 1, 0, 25, 1, 0, 3, 1, 3, 2, 1, 27, 28, 1, 28, 25, 1, 3, 28, 1, 0, 4, 1, 4, 3, 1, 28, 29, 1, 29, 25, 1, 4, 29, 1, 0, 5, 1, 5, 4, 1, 29, 30, 1, 30, 25, 1, 5, 30, 1, 0, 6, 1, 6, 5, 1, 30, 31, 1, 31, 25, 1, 6, 31, 1, 1, 6, 1, 31, 26, 1, 2, 8, 1, 8, 7, 1, 7, 1, 1, 26, 32, 1, 32, 33, 1, 33, 27, 1, 7, 32, 1, 8, 33, 1, 3, 10, 1, 10, 9, 1, 9, 2, 1, 27, 34, 1, 34, 35, 1, 35, 28, 1, 9, 34, 1, 10, 35, 1, 4, 12, 1, 12, 11, 1, 11, 3, 1, 28, 36, 1, 36, 37, 1, 37, 29, 1, 11, 36, 1, 12, 37, 1, 5, 14, 1, 14, 13, 1, 13, 4, 1, 29, 38, 1, 38, 39, 1, 39, 30, 1, 13, 38, 1, 14, 39, 1, 6, 16, 1, 16, 15, 1, 15, 5, 1, 30, 40, 1, 40, 41, 1, 41, 31, 1, 15, 40, 1, 16, 41, 1, 1, 18, 1, 18, 17, 1, 17, 6, 1, 31, 42, 1, 42, 43, 1, 43, 26, 1, 17, 42, 1, 18, 43, 1, 19, 18, 1, 7, 19, 1, 43, 44, 1, 44, 32, 1, 44, 19, 1, 20, 8, 1, 9, 20, 1, 33, 45, 1, 45, 34, 1, 45, 20, 1, 21, 10, 1, 11, 21, 1, 35, 46, 1, 46, 36, 1, 46, 21, 1, 22, 12, 1, 13, 22, 1, 37, 47, 1, 47, 38, 1, 47, 22, 1, 23, 14, 1, 15, 23, 1, 39, 48, 1, 48, 40, 1, 48, 23, 1, 24, 16, 1, 17, 24, 1, 41, 49, 1, 49, 42, 1, 49, 24, 1, 50, 55, 1, 55, 54, 1, 54, 53, 1, 53, 52, 1, 52, 51, 1, 51, 50, 1, 46, 50, 1, 51, 47, 1, 52, 48, 1, 53, 49, 1, 54, 44, 1, 55, 45]
1459         cIRef2 = [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99, 102, 105, 108, 111, 114, 117, 120, 123, 126, 129, 132, 135, 138, 141, 144, 147, 150, 153, 156, 159, 162, 165, 168, 171, 174, 177, 180, 183, 186, 189, 192, 195, 198, 201, 204, 207, 210, 213, 216, 219, 222, 225, 228, 231, 234, 237, 240, 243, 246, 249, 252, 255, 258, 261, 264, 267, 270, 273, 276, 279, 282, 285, 288, 291, 294, 297, 300, 303, 306, 309, 312, 315, 318, 321, 324, 327, 330, 333, 336, 339, 342, 345, 348, 351, 354, 357, 360, 363]
1460         self.assertEqual(85, mretDesc.getNumberOfCells())
1461         self.assertEqual(121, mretDesc2.getNumberOfCells())
1462         self.assertEqual(cRef0, c0)
1463         self.assertEqual(cIRef0, cI0)
1464         self.assertEqual(cRef, c)
1465         self.assertEqual(cIRef, cI)
1466         self.assertEqual(cRef2, c2)
1467         self.assertEqual(cIRef2, cI2)
1468         self.assertEqual(set([18]), set(ret.getValues()))
1469         pass
1470
1471 if __name__ == '__main__':
1472     unittest.main()