src/MEDCoupling_Swig/MEDCouplingIntersectTest.py

   1 #  -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2016  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 testSwig2Intersect2DMeshesQuadra1(self):
 443         import cmath
 444         def createDiagCircle(lX, lY, R, cells=[0,1]):
 445             """ A circle in a square box, cut along the diagonal.
 446             """
 447             c = []
 448             for i in range(8):
 449               c.append(cmath.rect(R, i*pi/4))
 450
 451             coords = [0.0,0.0,          c[3].real,c[3].imag,       -lX/2.0, lY/2.0,
 452                       0.0, lY/2.0,      lX/2.0,lY/2.0,             lX/2.0,0.0,
 453                       #   6                  7                              8
 454                       lX/2.0,-lY/2.0,   c[7].real,c[7].imag,       c[1].real,c[1].imag,
 455                       #   9                  10                            11
 456                       c[5].real,c[5].imag,   -lX/2.0,-lY/2.0,      0.0, -lY/2.0,
 457                       #   12                  13                            14
 458                       -lX/2.0,0.0,         0.0,0.0,                  0.0, 0.0]
 459             # Points 13 (reps. 14) are average of points (6,7) (resp (1,2))
 460             coords[13*2]   = 0.5*(coords[6*2]+coords[7*2])
 461             coords[13*2+1] = 0.5*(coords[6*2+1]+coords[7*2+1])
 462             coords[14*2]   = 0.5*(coords[1*2]+coords[2*2])
 463             coords[14*2+1] = 0.5*(coords[1*2+1]+coords[2*2+1])
 464             connec  = [1,7,8,0]      # half circle up right
 465             connec3 = [6,7,1,2,4,13,8,14,3,5]
 466
 467             baseMesh = MEDCouplingUMesh.New("box_circle", 2)
 468             baseMesh.allocateCells(2)
 469             meshCoords = DataArrayDouble.New(coords, len(coords) // 2, 2)
 470             meshCoords.setInfoOnComponents(["X [au]", "Y [au]"])
 471             baseMesh.setCoords(meshCoords)
 472
 473             if 0 in cells:
 474               baseMesh.insertNextCell(NORM_QPOLYG, connec)
 475             if 1 in cells:
 476               baseMesh.insertNextCell(NORM_QPOLYG, connec3)
 477             baseMesh.finishInsertingCells()
 478             baseMesh.checkConsistencyLight()
 479             return baseMesh
 480
 481         eps = 1.0e-7
 482         m1 = createDiagCircle(1.0, 1.0, 0.5*0.90, cells=[0,1])
 483         m2 = createDiagCircle(1.0, 1.0, 0.5*0.95, cells=[0])
 484         m3, _, _= MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
 485         m3.mergeNodes(eps)
 486         m3.convertDegeneratedCells()
 487         m3.zipCoords()
 488         m4 = m3.deepCopy()
 489         m5, _, _ = MEDCouplingUMesh.Intersect2DMeshes(m3, m4, eps)
 490         m5.mergeNodes(eps)
 491         # Check coordinates:
 492         self.assertTrue(m3.getCoords().isEqual(m5.getCoords(), eps))
 493         pass
 494
 495     def testIntersect2DMeshesTmp7(self):
 496         eps = 1.0e-8
 497         coords = [-0.5,-0.5,   -0.5, 0.5, 0.5, 0.5,    0.5,-0.5]
 498         connec = list(range(4))
 499         m1 = MEDCouplingUMesh.New("box", 2)
 500         m1.allocateCells(1)
 501         meshCoords = DataArrayDouble.New(coords, len(coords) // 2, 2)
 502         m1.setCoords(meshCoords)
 503         m1.insertNextCell(NORM_POLYGON, connec)
 504         m1.finishInsertingCells()
 505
 506         m2 = MEDCouplingDataForTest.buildCircle(0.25, 0.2, 0.4)
 507         # Was looping indefinitely:
 508         m_intersec, resToM1, resToM2 = MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
 509         m_intersec.zipCoords()
 510         coo_tgt = DataArrayDouble([-0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.03284271247461901, 0.4828427124746191,
 511           -0.014575131106459124, 0.5000000000000001, 0.5, -0.11224989991991996, 0.24271243444677046, 0.5, 0.5, 0.19387505004004,
 512           -0.04799910280454185, -0.06682678787499614, -0.023843325638122054, 0.4915644577163915, 0.5, -0.30612494995996, 0.0, -0.5,
 513           -0.5, 0.0, -0.25728756555322957, 0.5, -0.023843325638122026, 0.49156445771639157, -0.04799910280454181, -0.06682678787499613], 17 ,2)
 514         conn_tgt = [32, 5, 2, 6, 4, 7, 8, 9, 10, 32, 6, 3, 0, 1, 5, 4, 11, 12, 13, 14, 15, 16]
 515         connI_tgt = [0, 9, 22]
 516         res1_tgt  = [0, 0]
 517         res2_tgt = [0, -1]
 518         self.assertTrue(coo_tgt.isEqualWithoutConsideringStr(m_intersec.getCoords(), 1e-12))
 519         self.assertEqual(conn_tgt, m_intersec.getNodalConnectivity().getValues())
 520         self.assertEqual(connI_tgt, m_intersec.getNodalConnectivityIndex().getValues())
 521         self.assertEqual(res1_tgt, resToM1.getValues())
 522         self.assertEqual(res2_tgt, resToM2.getValues())
 523         pass
 524
 525     def testIntersect2DMeshesTmp8(self):
 526         """ Arc of circle #5 in m2 was wrongly linearized and this was crashing the intersector. """
 527         m1 = MEDCouplingUMesh('mesh', 2)
 528         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)])
 529         m1.setCoords(coo)
 530         c = DataArrayInt([32, 0, 3, 4, 1, 7, 6, 5, 2])
 531         cI = DataArrayInt([0, 9])
 532         m1.setConnectivity(c, cI)
 533
 534         m2 = MEDCouplingUMesh('tool', 2)
 535         coo = DataArrayDouble([-18.863459, -13.933459, -18.71895791290684, -15.11832192648871, -18.76569937343606, -12.95654908944806, -9.00470518045063,
 536                                   -13.8226177338691, -17.88089225139922, -16.8868757883568, -18.3878542250287, -16.04610264700759, -18.71815899226182, -15.12154400708064,
 537                                   -18.83895821216178, -13.44256442936377, -18.15535493732867, -16.47914057756773, -18.57607919534293, -15.59206616319266, -18.82720039287268, -14.53027989414214, -18.71855872378567, -15.11993303402953,
 538                                   0.,0.,0.,0.], 14, 2)
 539         m2.setCoords(coo)
 540         c = DataArrayInt([32, 1, 0, 2, 4, 5, 6,      #  offset 8:  9, 8, 10, 12, 13, 14
 541                             10, 7, 3, 8, 9, 11])     #            18, 15, 11, 16, 17, 19
 542         cI = DataArrayInt([0, 13])
 543         m2.setConnectivity(c, cI)
 544         inter, map1, map2 = MEDCouplingUMesh.Intersect2DMeshes(m1, m2, 1.0e-8)
 545         self.assertEqual(inter.getNodalConnectivity().getValues(), [32, 13, 14, 9, 8, 4, 1, 0, 22, 23, 24, 25, 26, 27, 28])
 546         self.assertEqual(inter.getNodalConnectivityIndex().getValues(), [0,15])
 547         self.assertEqual(map1.getValues(), [0])
 548         self.assertEqual(map2.getValues(), [0])
 549         pass
 550
 551     def testIntersect2DMeshesTmp9(self):
 552         """ Tricky case: two triangular shapes intersecting, but not perfectly, at their tips. Several issues fixed:
 553             - Bug fix: seg seg intersector epsilon is to be taken absolutely for colinearity test (even for very small vectors
 554             we don't want to have false positive on colinearity. So go back to a comparison with an angle.)
 555             - when intersecting nodes are merged, they were not properly added on pol2.
 556             - bug fix in compute residual: the stop condition is really on pol1Zip only.
 557             - correcting polygons with flat corners, they were crashing residual computation
 558         """
 559         eps = 1.0e-6  # This is the key parameter. DO NOT CHANGE IT.
 560         back = MEDCouplingUMesh('crh8_rse3', 2)
 561         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)])
 562         back.setCoords(coo)
 563         c = DataArrayInt([32, 0, 3, 1, 5, 4, 2])
 564         cI = DataArrayInt([0, 7])
 565         back.setConnectivity(c, cI)
 566
 567         tool = MEDCouplingUMesh('TA-536193G_expl_20181022_merged', 2)
 568         coo = DataArrayDouble([(-29.918137808525149,-26.883223901634544),(-32.919909136264039,-26.939612990540404),(-27.866900000000001,-28.016680435212603),(-31.313800000000001,-32.512799999999999),(-27.866900000000001,-28.933918793630923)])
 569         tool.setCoords(coo)
 570         c = DataArrayInt([5, 1, 0, 3, 5, 0, 2, 3, 5, 4, 3, 2])
 571         cI = DataArrayInt([0, 4, 8, 12])
 572         tool.setConnectivity(c, cI)
 573
 574         inter, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 575
 576         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])
 577         self.assertEqual(inter.getNodalConnectivityIndex().getValues(), [0, 5, 9, 18, 22])
 578         self.assertEqual(res2Back.getValues(), [0, 0, 0, 0])
 579         self.assertEqual(res2Tool.getValues(), [0, 1, -1, -1])
 580         pass
 581
 582     def testSwig2Intersect2DMeshWith1DLine1(self):
 583         """A basic test with no colinearity between m1 and m2."""
 584         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 585         m1=i.buildUnstructured()
 586         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])
 587         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 588         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])))
 589         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,31,1,31,28,1,28,29,1,29,30,1,30,27,1,27,26])))
 590         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])))
 591         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18])))
 592         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 593         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 594         self.assertTrue(a.getCoords()[25:25+2].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 595         self.assertTrue(a.getCoords()[27:].isEqualWithoutConsideringStr(DataArrayDouble([(3.3214285714285716,2.),(1.6071428571428572,3.),(2.,2.7708333333333335),(3.,2.1875),(1.,3.354166666666667)]),1e-12))
 596         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])))
 597         self.assertTrue(d.isEqual(DataArrayInt([(10,10),(11,12),(13,14),(15,16),(17,18),(19,19)])))
 598         pass
 599
 600     def testSwig2Intersect2DMeshWith1DLine2(self):
 601         """A basic test with colinearity between m1 and m2 and the last cell of m2 outside m1."""
 602         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 603         m1=i.buildUnstructured()
 604         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()
 605         for i in range(6):
 606             m2.insertNextCell(NORM_SEG2,[i,i+1])
 607             pass
 608         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 609         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])))
 610         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,51,59,64,70,75,83,88])))
 611         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])))
 612         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
 613         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 614         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 615         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 616         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,12,13,14,15,4,5,6,7,8,9,10,11])))
 617         self.assertTrue(d.isEqual(DataArrayInt([(12,8),(13,9),(14,10),(14,10),(14,10),(14,10),(15,11),(-1,-1)])))
 618         pass
 619
 620     def testSwig2Intersect2DMeshWith1DLine3(self):
 621         """m2 fully included in cell #12. of m1"""
 622         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 623         m1=i.buildUnstructured()
 624         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(0.75,3.25),(0.5,3.5),(0.25,3.25)])) ; m2.allocateCells()
 625         for i in range(2):
 626             m2.insertNextCell(NORM_SEG2,[i,i+1])
 627             pass
 628         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 629         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])))
 630         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80])))
 631         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,26,1,26,27])))
 632         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
 633         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 634         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 635         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 636         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,13,14,15,12])))
 637         self.assertTrue(d.isEqual(DataArrayInt([(15,15),(15,15)])))
 638         pass
 639
 640     def testSwig2Intersect2DMeshWith1DLine4(self):
 641         """A special case where an edge is simultaneously a cut and colinear. This tests also checks negative values in descending edges of m1."""
 642         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 643         m1=i.buildUnstructured()
 644         part=DataArrayInt([0,1,2,3,4,7,8,11,12,13,14,15])
 645         m1_1=m1[part]
 646         m1_2=m1[part.buildComplement(m1.getNumberOfCells())]
 647         m1=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1_1,m1_2.buildSpreadZonesWithPoly())
 648         m1.zipCoords()
 649         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(3.5,2.),(0.5,2.)])) ; m2.allocateCells()
 650         m2.insertNextCell(NORM_SEG2,[0,1])
 651         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 652         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])))
 653         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,52,58,64,70,76])))
 654         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,24,12,1,12,11,1,11,25])))
 655         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9])))
 656         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 657         self.assertTrue(a.getCoords()[:24].isEqual(m1.getCoords(),1e-12))
 658         self.assertTrue(a.getCoords()[24:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 659         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,8,9,10,11,4,5,6,7,12,12])))
 660         self.assertTrue(d.isEqual(DataArrayInt([(9,11),(12,13),(8,10)])))
 661         pass
 662
 663     def testSwig2Intersect2DMeshWith1DLine5(self):
 664         """A test focusing on a special case for cut."""
 665         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 666         m1=i.buildUnstructured()
 667         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(1.,0.),(3.,2.),(1.,4.)])) ; m2.allocateCells()
 668         for i in range(2):
 669             m2.insertNextCell(NORM_SEG2,[i,i+1])
 670             pass
 671         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 672         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])))
 673         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])))
 674         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,1,7,1,7,13,1,13,17,1,17,21])))
 675         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12])))
 676         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 677         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 678         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 679         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])))
 680         self.assertTrue(d.isEqual(DataArrayInt([(12,13),(14,15),(16,17),(18,19)])))
 681         pass
 682
 683     def testIntersect2DMeshWith1DLine6(self):
 684         """ Basic test for Intersect2DMeshWith1DLine: a vertical line intersecting a square. """
 685         m1c = MEDCouplingCMesh()
 686         coordX = DataArrayDouble([-1., 1., 2])
 687         m1c.setCoordsAt(0,coordX)
 688         coordY = DataArrayDouble([0., 2.])
 689         m1c.setCoordsAt(1,coordY);
 690         m1 = m1c.buildUnstructured()
 691
 692         # A simple line:
 693         m2 = MEDCouplingUMesh("bla", 1)
 694         coord2 = DataArrayDouble([0.,-1.0,  0.,1.,  0.,3.,  0.5,2.2], 4, 2)
 695         conn2 = DataArrayInt([NORM_SEG2,0,1,NORM_SEG3,1,2,3])
 696         connI2 = DataArrayInt([0,3,7])
 697         m2.setCoords(coord2)
 698         m2.setConnectivity(conn2, connI2)
 699
 700         # End of construction of input meshes m1bis and m2 -> start of specific part of the test
 701         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 702         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])))
 703         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,16,27])))
 704         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,6,10,1,10,7,2,7,11,12,2,11,8,13])))
 705         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,14])))
 706         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 707         self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
 708         self.assertTrue(a.getCoords()[6:10].isEqual(m2.getCoords(),1e-12))
 709         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))
 710         self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
 711         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(-1,-1)])))
 712         pass
 713
 714     def testSwig2Intersect2DMeshWith1DLine7(self):
 715         """ Star pattern (a triangle intersecting another one upside down) """
 716         coords1 = DataArrayDouble([-2.,1.,   2.,1.,  0.,-2.], 3,2)
 717         coords2 = DataArrayDouble([0.,2.,   2.,-1.,  -2.,-1.,  0.,3.], 4,2)
 718         m1 = MEDCouplingUMesh("triangle", 2)
 719         m2 = MEDCouplingUMesh("tri_line", 1)
 720         m1.setCoords(coords1)
 721         m2.setCoords(coords2)
 722         m1.setConnectivity(DataArrayInt([NORM_TRI3, 0,1,2]), DataArrayInt([0,4]))
 723         m2.setConnectivity(DataArrayInt([NORM_SEG2,0,1,NORM_SEG2,1,2,NORM_SEG2,2,3]), DataArrayInt([0,3,6,9]))
 724     # End of construction of input meshes m1bis and m2 -> start of specific part of the test
 725         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 726         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])))
 727         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,19])))
 728         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])))
 729         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24,27])))
 730         self.assertTrue(a.getCoords()[:3].isEqual(m1.getCoords(),1e-12))
 731         self.assertTrue(a.getCoords()[3:7].isEqual(m2.getCoords(),1e-12))
 732         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))
 733         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 734         self.assertTrue(c.isEqual(DataArrayInt([0,0,0,0])))
 735         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,3),(-1,-1),(-1,-1),(1,3),(-1,-1),(-1,-1),(2,3),(-1,-1)])))
 736         pass
 737
 738     def testSwig2Intersect2DMeshWith1DLine8(self):
 739         """ Line pieces ending (or fully located) in the middle of a cell """
 740         m1c = MEDCouplingCMesh()
 741         m1c.setCoordsAt(0,DataArrayDouble([-1., 1.]))
 742         m1c.setCoordsAt(1,DataArrayDouble([-1., 1.]));
 743         m1 = m1c.buildUnstructured()
 744         coords2 = DataArrayDouble([0.,0.,  0.,1.5, -1.5,0.,  0.5,0.0,  0.0,-0.5, 1.1,-0.6], 6,2)
 745         m2 = MEDCouplingUMesh("piecewise_line", 1)
 746         m2.setCoords(coords2)
 747         c = DataArrayInt([NORM_SEG2,2,1, NORM_SEG2,1,4, NORM_SEG2,4,3,  NORM_SEG2,3,5])
 748         cI = DataArrayInt([0,3,6,9,12])
 749         m2.setConnectivity(c, cI)
 750         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 751         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])))
 752         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,10,19])))
 753         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])))
 754         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
 755         self.assertTrue(a.getCoords()[:4].isEqual(m1.getCoords(),1e-12))
 756         self.assertTrue(a.getCoords()[4:10].isEqual(m2.getCoords(),1e-12))
 757         self.assertTrue(a.getCoords()[10:].isEqual(DataArrayDouble([(-1.,0.5),(-0.5,1.),(0.,1.),(1.,-0.5)]),1e-12))
 758         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 759         self.assertTrue(c.isEqual(DataArrayInt([0,0,0])))
 760         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
 761         pass
 762
 763     def testSwig2Intersect2DMeshWith1DLine9(self):
 764         """ Intersection with a line whose connectivity is not consecutive """
 765         m1c = MEDCouplingCMesh()
 766         coordX = DataArrayDouble([-1., 1., 2])
 767         m1c.setCoordsAt(0,coordX)
 768         coordY = DataArrayDouble([0., 2.])
 769         m1c.setCoordsAt(1,coordY);
 770         m1 = m1c.buildUnstructured()
 771         # A simple line:
 772         m2 = MEDCouplingUMesh("bla", 1)
 773         coord2 = DataArrayDouble([0.,1.5,  0.5,1.,  0.0,0.5,  0.0,3.0,  0.0,-1.0], 5, 2)
 774         conn2 = DataArrayInt([NORM_SEG2,3,0,NORM_SEG3,0,2,1,NORM_SEG2,2,4])
 775         connI2 = DataArrayInt([0,3,7,10])
 776         m2.setCoords(coord2)
 777         m2.setConnectivity(conn2, connI2)
 778         # End of construction of input meshes m1bis and m2 -> start of specific part of the test
 779         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 780         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])))
 781         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,18,31])))
 782         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,9,12,1,12,6,2,6,8,13,1,8,11,1,11,10])))
 783         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,13,16])))
 784         self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
 785         self.assertTrue(a.getCoords()[6:11].isEqual(m2.getCoords(),1e-12))
 786         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))
 787         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 788         self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
 789         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
 790         pass
 791
 792     def testSwig2Intersect2DMeshWith1DLine10(self):
 793         """ Intersection between a circle and various lines """
 794         eps = 1.0e-8
 795         m_circ = MEDCouplingDataForTest.buildCircle2(0.0, 0.0, 2.0)
 796         coords = [0.0,3.0,0.0,-3.0]
 797         connec = [0,1]
 798         m_line = MEDCouplingUMesh("seg", 1)
 799         m_line.allocateCells(1)
 800         meshCoords = DataArrayDouble.New(coords, len(coords) // 2, 2)
 801         m_line.setCoords(meshCoords)
 802         m_line.insertNextCell(NORM_SEG2, connec)
 803         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m_circ, m_line, eps)
 804         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 805         self.assertTrue(a.getCoords()[:m_circ.getNumberOfNodes()].isEqual(m_circ.getCoords(),1e-12))
 806         self.assertTrue(a.getCoords()[m_circ.getNumberOfNodes():m_circ.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 807         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))
 808         self.assertEqual([32,1,7,10,11,12,13,14,15,32,5,3,11,10,16,17,18,19],a.getNodalConnectivity().getValues())
 809         self.assertEqual([0,9,18],  a.getNodalConnectivityIndex().getValues())
 810         self.assertEqual([1,8,11,1,11,10,1,10,9],b.getNodalConnectivity().getValues())
 811         self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
 812         self.assertTrue(a.getCoords()[:8].isEqual(m_circ.getCoords(),1e-12))
 813         self.assertTrue(a.getCoords()[8:10].isEqual(m_line.getCoords(),1e-12))
 814         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])
 815         self.assertTrue(a.getCoords().isEqualWithoutConsideringStr(coo_tgt,1.0e-12))
 816         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 817         self.assertEqual([0,0],c.getValues())
 818         self.assertEqual([-1,-1,0,1,-1,-1],d.getValues())
 819
 820     def testSwig2Intersect2DMeshWith1DLine11(self):
 821         """ Quad line re-entering a square cell """
 822         eps = 1.0e-8
 823         m = MEDCouplingUMesh("box", 2)
 824         m.setCoords(DataArrayDouble([-1., -1., -1., 1., 1., 1., 1., -1.0],4,2))
 825         c, cI = [NORM_POLYGON, 0, 1, 2, 3], [0, 5]
 826         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 827         m.checkConsistencyLight()
 828         coords2 = [0., 1.3, -1.3, 0., -0.6, 0.6, 0., -1.3, -0.5, -0.5]
 829         connec2, cI2 = [NORM_SEG3, 0, 1, 2, NORM_SEG3, 1, 3, 4], [0,4,8]
 830         m_line = MEDCouplingUMesh("seg", 1)
 831         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 832         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 833         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 834         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 835         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 836         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 837         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))
 838         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())
 839         self.assertEqual([0,13,20,27],a.getNodalConnectivityIndex().getValues())
 840         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())
 841         self.assertEqual([0,4,8,12,16,20,24],b.getNodalConnectivityIndex().getValues())
 842         self.assertTrue(a.getCoords()[:4].isEqual(m.getCoords(),1e-12))
 843         self.assertTrue(a.getCoords()[4:9].isEqual(m_line.getCoords(),1e-12))
 844         self.assertTrue(DataArrayInt([0,0,0]).isEqual(c))
 845         self.assertTrue(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(0,1),(-1,-1)]).isEqual(d))
 846         pass
 847
 848     def testSwig2Intersect2DMeshWith1DLine12(self):
 849         """ Two squares one in the other intersected by an horizontal line """
 850         eps = 1.0e-8
 851         m = MEDCouplingUMesh("boxbox", 2)
 852         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))
 853         c = [NORM_POLYGON, 4, 5, 6, 7, NORM_POLYGON, 0, 1, 5, 4, NORM_POLYGON, 1, 2, 3, 0, 4, 7, 6, 5]
 854         cI = [0, 5, 10, 19]
 855         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 856         m.checkConsistencyLight()
 857         coords2 = [-1., 0.25, 1., 0.25]
 858         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
 859         m_line = MEDCouplingUMesh.New("seg", 1)
 860         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 861         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 862         m_line2 = m_line.deepCopy()
 863         m2 = m.deepCopy()
 864         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 865         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 866         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 867         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 868         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))
 869         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())
 870         self.assertEqual([0,5,9,14,20,27],a.getNodalConnectivityIndex().getValues())
 871         self.assertEqual([1,8,10,1,10,5,1,5,6,1,6,11,1,11,9],b.getNodalConnectivity().getValues())
 872         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
 873         self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
 874         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
 875         pass
 876
 877     def testSwig2Intersect2DMeshWith1DLine13(self):
 878         """ A square (side length) in a circle intersected by a simple horizontal line """
 879         import math
 880         eps = 1.0e-8
 881         m = MEDCouplingUMesh("boxcircle", 2)
 882         sq2 = math.sqrt(2.0)
 883         soth = (sq2+1.0)/2.0
 884         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
 885          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
 886         coo = DataArrayDouble(coo); coo.rearrange(2)
 887         m.setCoords(coo)
 888         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]
 889         cI = [0, 9, 18, 35]
 890         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 891         m.checkConsistencyLight()
 892         coords2 = [-2., 1., 2., 1.0]
 893         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
 894         m_line = MEDCouplingUMesh("seg", 1)
 895         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 896         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 897         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 898         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 899         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 900         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 901         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))
 902         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())
 903         self.assertEqual([0,9,18,25,32,49],a.getNodalConnectivityIndex().getValues())
 904         self.assertEqual([1,18,21,1,21,9,1,9,10,1,10,20,1,20,19],b.getNodalConnectivity().getValues())
 905         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
 906         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
 907         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(3,4),(-1,-1)])))
 908         pass
 909
 910     def testSwig2Intersect2DMeshWith1DLine14(self):
 911         """ A circle in a circle intersected by a simple horizontal line, not tangent to the circles """
 912         eps = 1.0e-8
 913         m = MEDCouplingUMesh("boxcircle", 2)
 914         coo = [2.,0.,1.4142135623730951,1.414213562373095,0.,2.,-1.414213562373095,1.4142135623730951,-2.,0.,-1.4142135623730954,-1.414213562373095,0.,-2.,
 915                1.4142135623730947,-1.4142135623730954,1.,0.,0.7071067811865476,0.7071067811865475,0.,1.,-0.7071067811865475,0.7071067811865476,-1.,0.,-0.7071067811865477,-0.7071067811865475,
 916                0.,-1.,0.7071067811865474,-0.7071067811865477,1.060660171779821,-1.0606601717798214,-1.0606601717798214,-1.0606601717798212]
 917         coo = DataArrayDouble(coo); coo.rearrange(2)
 918         m.setCoords(coo)
 919         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]
 920         cI = [0, 9, 18, 35]
 921         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 922         m.checkConsistencyLight()
 923         coords2 = [-2., 0., 2., 0.]
 924         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
 925         m_line = MEDCouplingUMesh.New("seg", 1)
 926         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 927         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 928         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 929         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 930         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 931         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 932         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))
 933         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())
 934         self.assertEqual([0,9,26,35,44,53,62],a.getNodalConnectivityIndex().getValues())
 935         self.assertEqual([1,18,20,1,20,21,1,21,19],b.getNodalConnectivity().getValues())
 936         self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
 937         self.assertTrue(c.isEqual(DataArrayInt([1,2,2,2,0,0])))
 938         self.assertTrue(d.isEqual(DataArrayInt([(1,3),(4,5),(1,2)])))
 939         pass
 940
 941     def testSwig2Intersect2DMeshWith1DLine15(self):
 942         """ Same as testSwig2Intersect2DMeshWith1DLine13 except that the line is colinear AND splits on of the common edge of 2D mesh."""
 943         import math
 944         eps = 1.0e-8
 945         m = MEDCouplingUMesh("boxcircle", 2)
 946         sq2 = math.sqrt(2.0)
 947         soth = (sq2+1.0)/2.0
 948         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
 949          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
 950         coo = DataArrayDouble(coo); coo.rearrange(2)
 951         m.setCoords(coo)
 952         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]
 953         cI = [0, 9, 18, 35]
 954         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 955         m.checkConsistencyLight()
 956         coords2 = [(-2., 1.),(2.,1.),(0.,1)]
 957         connec2, cI2 = [NORM_SEG2, 0, 2, NORM_SEG2, 2, 1], [0,3,6]
 958         m_line = MEDCouplingUMesh("seg", 1)
 959         m_line.setCoords(DataArrayDouble(coords2))
 960         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 961         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 962         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 963         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 964         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 965         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))
 966         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())
 967         self.assertEqual([0,11,22,29,36,53],a.getNodalConnectivityIndex().getValues())
 968         self.assertEqual([1,18,22,1,22,9,1,9,20,1,20,10,1,10,21,1,21,19],b.getNodalConnectivity().getValues())
 969         self.assertEqual([0,3,6,9,12,15,18],b.getNodalConnectivityIndex().getValues())
 970         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
 971         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(1,0),(3,4),(-1,-1)])))
 972         pass
 973
 974     def testSwig2Intersect2DMeshWith1DLine16(self):
 975         """ Same than testSwig2Intersect2DMeshWith1DLine13 except it is a vertical line. Non regression test."""
 976         import math
 977         eps = 1.0e-8
 978         m = MEDCouplingUMesh("boxcircle", 2)
 979         sq2 = math.sqrt(2.0)
 980         soth = (sq2+1.0)/2.0
 981         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
 982          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
 983         coo = DataArrayDouble(coo); coo.rearrange(2)
 984         m.setCoords(coo)
 985         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]
 986         cI = [0, 9, 18, 35]
 987         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 988         m.checkConsistencyLight()
 989         coords2 = [1., 2., 1., -2.]
 990         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
 991         m_line = MEDCouplingUMesh("seg", 1)
 992         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 993         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 994         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 995         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 996         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 997         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 998         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))
 999         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())
1000         self.assertEqual([0,9,16,25,36,49],a.getNodalConnectivityIndex().getValues())
1001         self.assertEqual([1,18,20,1,20,10,1,10,11,1,11,21,1,21,19],b.getNodalConnectivity().getValues())
1002         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
1003         self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
1004         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
1005         pass
1006
1007     def testSwig2Intersect2DMeshWith1DLine17(self):
1008         """ Single colinear intersection - a deltaShiftIndex() was improperly tested. """
1009         eps = 1.0e-12
1010         mesh = MEDCouplingUMesh('dummy_layer', 2)
1011         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)])
1012         mesh.setCoords(coo)
1013         c = DataArrayInt([5, 4, 5, 6, 7, 5, 0, 1, 5, 4, 5, 1, 2, 3, 0, 4, 7, 6, 5])
1014         cI = DataArrayInt([0, 5, 10, 19])
1015         mesh.setConnectivity(c, cI)
1016         m_line = MEDCouplingUMesh('segment', 1)
1017         coo = DataArrayDouble([(-0.5,0.5),(-0.25,0.25)])
1018         m_line.setCoords(coo)
1019         c = DataArrayInt([1, 0, 1])
1020         cI = DataArrayInt([0, 3])
1021         m_line.setConnectivity(c, cI)
1022         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(mesh, m_line, eps)
1023         self.assertEqual(mesh.getNodalConnectivity().getValues(),a.getNodalConnectivity().getValues())
1024         self.assertEqual(mesh.getNodalConnectivityIndex().getValues(),a.getNodalConnectivityIndex().getValues())
1025         self.assertEqual([1,1,5],b.getNodalConnectivity().getValues())
1026         self.assertEqual(m_line.getNodalConnectivityIndex().getValues(),b.getNodalConnectivityIndex().getValues())
1027         self.assertTrue([0,1,2], c.getValues())
1028         self.assertEqual([2,1], d.getValues())
1029
1030     def testSwig2Intersect2DMeshWith1DLine18(self):
1031         """ Rare case: a *closed* line used as a tool, with the closing point inside a 2D cell ... """
1032         tool = MEDCouplingUMesh('circle', 1)
1033         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)])
1034         tool.setCoords(coo)
1035         c = DataArrayInt([2, 3, 5, 8,    2, 5, 3, 4])
1036         cI = DataArrayInt([0, 4, 8])
1037         tool.setConnectivity(c, cI)
1038
1039         meh = MEDCouplingUMesh('meh', 2)
1040         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)])
1041         meh.setCoords(coo)
1042         c = DataArrayInt([32, 0, 1, 3, 13, 11, 8, 9, 15, 10, 14,
1043                              32, 3, 4, 2, 0, 11, 13, 5, 6, 7, 14, 12, 15])
1044         cI = DataArrayInt([0, 11, 24])
1045         meh.setConnectivity(c, cI)
1046
1047         res2D, res1D, m1, m2 = MEDCouplingUMesh.Intersect2DMeshWith1DLine(meh, tool, 1e-12)
1048         self.assertEqual(4, res2D.getNumberOfCells())
1049         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,
1050                                                                    32, 4, 2, 0, 11, 13, 26, 27, 44, 45, 46, 47, 48, 49, 50, 32, 3, 27, 26, 51, 52, 53])
1051         self.assertEqual(res2D.getNodalConnectivityIndex().getValues(),[0, 15, 24, 39, 46])
1052         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])
1053         self.assertEqual(res1D.getNodalConnectivityIndex().getValues(),[0, 4, 8, 12, 16, 20])
1054         self.assertEqual(m1.getValues(), [0,0,1,1])
1055         self.assertEqual(m2.getValues(), [0,1,   -1,-1,  -1,-1,   2,3,  0,1])
1056
1057     def testSwig2Intersect2DMeshWith1DLine19(self):
1058         """ Intersection arc of circle / segment was not properly detecting tangent cases """
1059         eps=1.0e-5  # was working at 1.0e-8, but should also really work with 1.0e-5
1060         mesh = MEDCouplingUMesh('layer_1', 2)
1061         coo = DataArrayDouble([(55.4,3.7239),(61.4,7.188),(61.4,13.943),(49.55,7.1014),
1062                                   (61.4,10.5655),(58.4,5.45595),(52.475,5.41265),(55.475,10.5222),
1063                                   (56.9,9.34),(56.3343,7.97431),(56.9,7.74),(57.4657,7.97431),(59.4328,7.58116),
1064                                   (55.8672,5.84911),    (0.,0.)])
1065         mesh.setCoords(coo)
1066         c = DataArrayInt([32, 0, 3, 2, 1, 11, 9,     6, 7, 4, 12, 8, 13])
1067         cI = DataArrayInt([0, 13])
1068         mesh.setConnectivity(c, cI)
1069         tool = MEDCouplingUMesh('segment', 1)
1070         coo = DataArrayDouble([(-166.611,-119.951),(269.611,131.902)])
1071         tool.setCoords(coo)
1072         c = DataArrayInt([1, 0, 1])
1073         cI = DataArrayInt([0, 3])
1074         tool.setConnectivity(c, cI)
1075
1076         res2D, res1D, m1, m2 = MEDCouplingUMesh.Intersect2DMeshWith1DLine(mesh, tool, eps)
1077
1078         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])
1079         self.assertEqual(res2D.getNodalConnectivityIndex().getValues(),[0, 13, 22, 31])
1080         self.assertEqual(res1D.getNodalConnectivity().getValues(),[1, 15, 17, 1, 17, 19, 1, 19, 20, 1, 20, 18, 1, 18, 16])
1081         self.assertEqual(res1D.getNodalConnectivityIndex().getValues(),[0, 3, 6, 9, 12, 15])
1082         self.assertEqual(m1.getValues(), [0, 0, 0])
1083         self.assertEqual(m2.getValues(), [-1, -1, 0, 2, -1, -1, 0, 1, -1, -1])
1084
1085     def testSwig2Conformize2D1(self):
1086         eps = 1.0e-8
1087         coo = [0.,-0.5,0.,0.,0.5,0.,0.5,-0.5,0.25,
1088                -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]
1089         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]
1090         connI = [0,5,12,17,24]
1091         m = MEDCouplingUMesh("box",2)
1092         cooArr = DataArrayDouble(coo, len(coo) // 2, 2)
1093         m.setCoords(cooArr)
1094         m.setConnectivity(DataArrayInt(conn),DataArrayInt(connI))
1095         m.mergeNodes(eps)
1096         m.checkConsistencyLight()
1097         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([3])))
1098         self.assertEqual(m.getCoords().getHiddenCppPointer(),cooArr.getHiddenCppPointer()) # check that coordinates remain the same here
1099         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])))
1100         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,12,17,25])))
1101         pass
1102
1103     def testSwig2Conformize2D2(self):
1104         eps = 1.0e-8
1105         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)
1106         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])
1107         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
1108         m.setCoords(coo)
1109         m.setNodalConnectivity(conn)
1110         m=m.buildUnstructured()
1111         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
1112         self.assertEqual(m.getCoords().getHiddenCppPointer(),coo.getHiddenCppPointer()) # check that coordinates remain the same here
1113         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])))
1114         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,6,12,21,26,31,37,42])))
1115         pass
1116
1117     def testSwigSplit2DCells1(self):
1118         coo=DataArrayDouble([[0,0],[1,0],[1,1],[0,1],[0.5,0],[1,0.5],[0.5,1],[0.,0.5]])
1119         m=MEDCouplingUMesh("mesh",2)
1120         m.setCoords(coo)
1121         m.allocateCells()
1122         m.insertNextCell(NORM_QUAD8,[0,1,2,3,4,5,6,7])
1123         _,d,di,_,_=m.buildDescendingConnectivity()
1124         subb=DataArrayInt([5])
1125         subbi=DataArrayInt([0,0,1,1,1])
1126         mid=DataArrayInt([-1,-1])
1127         midi=DataArrayInt([0,0,2,2,2])
1128         self.assertEqual(2,m.split2DCells(d,di,subb,subbi,mid,midi))
1129         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,1,5,2,3,4,8,9,6,7])))
1130         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11])))
1131         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))
1132         pass
1133
1134     def testSwig2Conformize2D3(self):
1135         eps = 1.0e-8
1136         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)
1137         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])
1138         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
1139         m.setCoords(coo)
1140         m.setNodalConnectivity(conn)
1141         m=m.buildUnstructured()
1142         m.convertLinearCellsToQuadratic()
1143         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
1144         self.assertTrue(m.getCoords().getHiddenCppPointer()!=coo.getHiddenCppPointer()) # coordinates are not the same here contrary to testSwig2Conformize2D2 ...
1145         self.assertTrue(m.getCoords()[:18].isEqual(coo,1e-12)) # but the 18 first nodes are the same
1146         pass
1147
1148     def testSwig2Conformize2D4(self):
1149         eps = 1.0e-8
1150         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)
1151         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])
1152         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
1153         m.setCoords(coo)
1154         m.setNodalConnectivity(conn)
1155         m=m.buildUnstructured()
1156         m.convertLinearCellsToQuadratic()
1157         self.assertEqual(42,m.getNumberOfNodes())
1158         oldCoo=m.getCoords().deepCopy()
1159         m.conformize2D(eps)
1160         self.assertTrue(m.getCoords()[:42].isEqual(oldCoo,1e-12))
1161         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])))
1162         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11,22,39,48,57,68,77])))
1163         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))
1164         pass
1165
1166     def testSwig2Conformize2D5(self):
1167         eps=1e-8
1168         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]])
1169         m=MEDCouplingUMesh("mesh",2)
1170         m.allocateCells()
1171         m.setCoords(coo)
1172         m.insertNextCell(NORM_TRI6,[1,2,0,5,4,3])
1173         m.insertNextCell(NORM_TRI6,[8,6,0,12,7,13])
1174         m.insertNextCell(NORM_TRI6,[11,9,10,16,14,15])
1175         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0])))
1176         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))
1177         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])))
1178         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,13,20,27])))
1179         pass
1180
1181     def testSwig2Conformize2D6(self):
1182         """ Was raising an internal error on the tiny cell #1. SegSegIntersector was faulty (eps misinterpreted)."""
1183         eps=1.0e-6
1184         mesh = MEDCouplingUMesh('Intersect2D', 2)
1185         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)])
1186         mesh.setCoords(coo)
1187         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])
1188         cI = DataArrayInt([0, 9, 16, 25, 38])
1189         mesh.setConnectivity(c, cI)
1190
1191         mesh.conformize2D(eps)  # internal error was here
1192
1193         c2, cI2 = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
1194         self.assertEqual(c2, c.getValues())
1195         self.assertEqual(cI2, cI.getValues())
1196         pass
1197
1198     def testSwig2Conformize3D1(self):
1199         """ Simple test where no edge merge is required, only face merging (first part of the algo) """
1200         mesh = MEDCouplingUMesh('merge', 3)
1201         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),
1202                                (2,0,0),(2,1,0),(2,0,1),(2,1,1),(1,0,2),(2,0,2),(1,1,2),(2,1,2)])
1203         mesh.setCoords(coo)
1204         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,
1205                            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,
1206                            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,
1207                            14, 16, 15, 13, -1, 11, 14, 13, 5, -1, 5, 13, 15, 7, -1, 7, 15, 16, 12, -1, 12, 16, 14, 11])
1208         cI = DataArrayInt([0, 41, 71, 101])
1209         mesh.setConnectivity(c, cI)
1210         ret = mesh.conformize3D(1.0e-8)
1211
1212         mretDesc, _, _, _, _ = mesh.buildDescendingConnectivity()
1213         c, cI = mretDesc.getNodalConnectivity().getValues(), mretDesc.getNodalConnectivityIndex().getValues()
1214         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,
1215                 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,
1216                 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,
1217                 15, 16, 12, 5, 12, 16, 14, 11]
1218         cIRef = [0, 5, 10, 15, 20, 25, 29, 33, 37, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91]
1219         self.assertEqual(19, mretDesc.getNumberOfCells())
1220         self.assertEqual(cRef, c)
1221         self.assertEqual(cIRef, cI)
1222         self.assertEqual([1], ret.getValues())
1223         pass
1224
1225     def testSwig2Conformize3D2(self):
1226         """ More advanced test where edge merge is required. """
1227         mesh = MEDCouplingUMesh('merge', 3)
1228         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),
1229                                (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)])
1230         mesh.setCoords(coo)
1231         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,
1232                           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,
1233                           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,
1234                           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,
1235                           7, 11, 21, 19, -1, 19, 21, 20, 18])
1236         cI = DataArrayInt([0, 37, 74, 104, 134])
1237         mesh.setConnectivity(c, cI)
1238
1239         ret = mesh.conformize3D(1.0e-8)
1240
1241         mretDesc, _, _, _, _ = mesh.buildDescendingConnectivity()
1242         mretDesc2, _, _, _, _ = mretDesc.buildDescendingConnectivity()
1243         c0, cI0 = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
1244         c, cI = mretDesc.getNodalConnectivity().getValues(), mretDesc.getNodalConnectivityIndex().getValues()
1245         c2, cI2 = mretDesc2.getNodalConnectivity().getValues(), mretDesc2.getNodalConnectivityIndex().getValues()
1246         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]
1247         cIRef0 = [0, 39, 78, 117, 156]
1248         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]
1249         cIRef = [0, 6, 13, 18, 23, 28, 33, 39, 45, 50, 55, 60, 66, 71, 77, 84, 89, 94, 99, 105, 110, 115, 120]
1250         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]
1251         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]
1252         self.assertEqual(22, mretDesc.getNumberOfCells())
1253         self.assertEqual(39, mretDesc2.getNumberOfCells())
1254         self.assertEqual(cRef0, c0)
1255         self.assertEqual(cIRef0, cI0)
1256         self.assertEqual(cRef, c)
1257         self.assertEqual(cIRef, cI)
1258         self.assertEqual(cRef2, c2)
1259         self.assertEqual(cIRef2, cI2)
1260         self.assertEqual(set([0,1,2,3]), set(ret.getValues()))
1261         pass
1262
1263     def testSwig2Conformize3D3(self):
1264         """ LMEC's case (hexagonal prism) """
1265         eps = 1.0e-7   # 1.0e-8 is too fine
1266         mesh = MEDCouplingUMesh('merge', 3)
1267         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)])
1268         mesh.setCoords(coo)
1269         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])
1270         cI = DataArrayInt([0, 23, 46, 69, 92, 115, 138, 168, 198, 228, 258, 288, 318, 348, 378, 408, 438, 468, 498, 542])
1271         mesh.setConnectivity(c, cI)
1272         mesh.mergeNodes(eps) # the initial case has double nodes
1273
1274         ret = mesh.conformize3D(eps)
1275
1276         mretDesc, _, _, _, _ = mesh.buildDescendingConnectivity()
1277         mretDesc2, _, _, _, _ = mretDesc.buildDescendingConnectivity()
1278         c0, cI0 = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
1279         c, cI = mretDesc.getNodalConnectivity().getValues(), mretDesc.getNodalConnectivityIndex().getValues()
1280         c2, cI2 = mretDesc2.getNodalConnectivity().getValues(), mretDesc2.getNodalConnectivityIndex().getValues()
1281         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]
1282         cIRef0 = [0, 23, 46, 69, 92, 115, 138, 168, 198, 228, 258, 288, 318, 348, 378, 408, 438, 468, 498, 631]
1283         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]
1284         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]
1285         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]
1286         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]
1287         self.assertEqual(85, mretDesc.getNumberOfCells())
1288         self.assertEqual(121, mretDesc2.getNumberOfCells())
1289         self.assertEqual(cRef0, c0)
1290         self.assertEqual(cIRef0, cI0)
1291         self.assertEqual(cRef, c)
1292         self.assertEqual(cIRef, cI)
1293         self.assertEqual(cRef2, c2)
1294         self.assertEqual(cIRef2, cI2)
1295         self.assertEqual(set([18]), set(ret.getValues()))
1296         pass
1297
1298 if __name__ == '__main__':
1299     unittest.main()