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 testIntersect2DMeshesTmp10(self):
 583 #         """ Fixing issues when one of the quadratic point of the tool mesh also serves as a regular point somewhere else.
 584 #         WARNING : the tool mesh is not conform, but this was NOT the initial cause of the problem """
 585 #         eps = 1.0e-6
 586 #         back = MEDCouplingUMesh('layer_1', 2)
 587 #         coo = DataArrayDouble([(0.000000000000000,0.000000000000000),(0.000000000000007,113.449999999999960),(113.449999999999960,0.000000000000000),(80.221264325613788,80.221264325613788),(0.000000000000003,56.724999999999980),(56.724999999999980,0.000000000000000)])
 588 #         back.setCoords(coo)
 589 #         c = DataArrayInt([32, 0, 1, 2, 4, 3, 5])
 590 #         cI = DataArrayInt([0, 7])
 591 #         back.setConnectivity(c, cI)
 592 #
 593 #         tool = MEDCouplingUMesh('layer_2', 2)
 594 #         coo = DataArrayDouble([(35.499999704817512,0.000000000000011),(35.413523784223756,2.476354817916448),(35.478374361065050,1.238932132335084),(35.563158391762734,2.486818288978067),(35.649999999999999,0.000000000000000),(35.628282983230761,1.244167057444159),(35.488341087993248,2.481586553447257),(35.575000000000003,0.000000000000000),(35.154516440325750,4.940645084082323),(35.305526997492230,3.710760415787641),(35.154516440325743,-4.940645084082338),(34.960674956295250,-6.164510258681856),(35.413523784223763,-2.476354817916429),(35.305526997492230,-3.710760415787643),(35.563158391762734,-2.486818288978048),(35.488341087993248,-2.481586553447238),(35.478374361018354,-1.238932133672371),(35.628282983230761,-1.244167057444150)])
 595 #         tool.setCoords(coo)
 596 #         c = DataArrayInt([32, 0, 1, 3, 4, 2, 6, 5, 7,        # 32,  6, 7, 9, 10, 8, 12, 11, 13
 597 #                              32, 12, 0, 4, 14, 16, 7, 17, 15,   # 32,  18, 6, 10, 20, 22, 13, 23, 21
 598 #                              32, 8, 1, 12, 10, 9, 0, 13, 11])   # 32,  14, 7, 18, 16, 15, 6, 19, 17
 599 #         cI = DataArrayInt([0, 9, 18, 27])
 600 #         tool.setConnectivity(c, cI)
 601 #         result, res2Back, res2Tool = MEDCouplingUMesh.Intersect2DMeshes(back, tool, eps)
 602 #         result.writeVTK("/tmp/toto.vtu")
 603 #
 604 #         self.assertEqual(result.getNodalConnectivity().getValues(), [32, 10, 6, 7, 9, 25, 26, 27, 28, 32, 6, 0, 24, 14, 7, 29, 30, 31, 32, 33, 32, 24, 1, 2, 10, 9, 7, 6, 7, 14, 34, 35, 36, 37, 38, 39, 40, 41, 42])
 605 #         self.assertEqual(result.getNodalConnectivityIndex().getValues(), [0, 9, 20, 39])
 606 #         self.assertEqual(res2Back.getValues(), [0, 0, 0])
 607 #         self.assertEqual(res2Tool.getValues(), [0, 2, -1])
 608 #         pass
 609
 610     def testSwig2Intersect2DMeshWith1DLine1(self):
 611         """A basic test with no colinearity between m1 and m2."""
 612         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 613         m1=i.buildUnstructured()
 614         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])
 615         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 616         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])))
 617         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,31,1,31,28,1,28,29,1,29,30,1,30,27,1,27,26])))
 618         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])))
 619         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18])))
 620         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 621         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 622         self.assertTrue(a.getCoords()[25:25+2].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 623         self.assertTrue(a.getCoords()[27:].isEqualWithoutConsideringStr(DataArrayDouble([(3.3214285714285716,2.),(1.6071428571428572,3.),(2.,2.7708333333333335),(3.,2.1875),(1.,3.354166666666667)]),1e-12))
 624         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])))
 625         self.assertTrue(d.isEqual(DataArrayInt([(10,10),(11,12),(13,14),(15,16),(17,18),(19,19)])))
 626         pass
 627
 628     def testSwig2Intersect2DMeshWith1DLine2(self):
 629         """A basic test with colinearity between m1 and m2 and the last cell of m2 outside m1."""
 630         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 631         m1=i.buildUnstructured()
 632         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()
 633         for i in range(6):
 634             m2.insertNextCell(NORM_SEG2,[i,i+1])
 635             pass
 636         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 637         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])))
 638         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,51,59,64,70,75,83,88])))
 639         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])))
 640         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
 641         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 642         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 643         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 644         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,12,13,14,15,4,5,6,7,8,9,10,11])))
 645         self.assertTrue(d.isEqual(DataArrayInt([(12,8),(13,9),(14,10),(14,10),(14,10),(14,10),(15,11),(-1,-1)])))
 646         pass
 647
 648     def testSwig2Intersect2DMeshWith1DLine3(self):
 649         """m2 fully included in cell #12. of m1"""
 650         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 651         m1=i.buildUnstructured()
 652         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(0.75,3.25),(0.5,3.5),(0.25,3.25)])) ; m2.allocateCells()
 653         for i in range(2):
 654             m2.insertNextCell(NORM_SEG2,[i,i+1])
 655             pass
 656         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 657         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])))
 658         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80])))
 659         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,26,1,26,27])))
 660         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
 661         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 662         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 663         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 664         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,13,14,15,12])))
 665         self.assertTrue(d.isEqual(DataArrayInt([(15,15),(15,15)])))
 666         pass
 667
 668     def testSwig2Intersect2DMeshWith1DLine4(self):
 669         """A special case where an edge is simultaneously a cut and colinear. This tests also checks negative values in descending edges of m1."""
 670         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 671         m1=i.buildUnstructured()
 672         part=DataArrayInt([0,1,2,3,4,7,8,11,12,13,14,15])
 673         m1_1=m1[part]
 674         m1_2=m1[part.buildComplement(m1.getNumberOfCells())]
 675         m1=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1_1,m1_2.buildSpreadZonesWithPoly())
 676         m1.zipCoords()
 677         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(3.5,2.),(0.5,2.)])) ; m2.allocateCells()
 678         m2.insertNextCell(NORM_SEG2,[0,1])
 679         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 680         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])))
 681         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,52,58,64,70,76])))
 682         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,24,12,1,12,11,1,11,25])))
 683         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9])))
 684         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 685         self.assertTrue(a.getCoords()[:24].isEqual(m1.getCoords(),1e-12))
 686         self.assertTrue(a.getCoords()[24:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 687         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,8,9,10,11,4,5,6,7,12,12])))
 688         self.assertTrue(d.isEqual(DataArrayInt([(9,11),(12,13),(8,10)])))
 689         pass
 690
 691     def testSwig2Intersect2DMeshWith1DLine5(self):
 692         """A test focusing on a special case for cut."""
 693         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
 694         m1=i.buildUnstructured()
 695         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(1.,0.),(3.,2.),(1.,4.)])) ; m2.allocateCells()
 696         for i in range(2):
 697             m2.insertNextCell(NORM_SEG2,[i,i+1])
 698             pass
 699         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
 700         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])))
 701         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])))
 702         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,1,7,1,7,13,1,13,17,1,17,21])))
 703         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12])))
 704         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 705         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
 706         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
 707         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])))
 708         self.assertTrue(d.isEqual(DataArrayInt([(12,13),(14,15),(16,17),(18,19)])))
 709         pass
 710
 711     def testIntersect2DMeshWith1DLine6(self):
 712         """ Basic test for Intersect2DMeshWith1DLine: a vertical line intersecting a square. """
 713         m1c = MEDCouplingCMesh()
 714         coordX = DataArrayDouble([-1., 1., 2])
 715         m1c.setCoordsAt(0,coordX)
 716         coordY = DataArrayDouble([0., 2.])
 717         m1c.setCoordsAt(1,coordY);
 718         m1 = m1c.buildUnstructured()
 719
 720         # A simple line:
 721         m2 = MEDCouplingUMesh("bla", 1)
 722         coord2 = DataArrayDouble([0.,-1.0,  0.,1.,  0.,3.,  0.5,2.2], 4, 2)
 723         conn2 = DataArrayInt([NORM_SEG2,0,1,NORM_SEG3,1,2,3])
 724         connI2 = DataArrayInt([0,3,7])
 725         m2.setCoords(coord2)
 726         m2.setConnectivity(conn2, connI2)
 727
 728         # End of construction of input meshes m1bis and m2 -> start of specific part of the test
 729         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 730         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])))
 731         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,16,27])))
 732         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,6,10,1,10,7,2,7,11,12,2,11,8,13])))
 733         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,14])))
 734         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 735         self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
 736         self.assertTrue(a.getCoords()[6:10].isEqual(m2.getCoords(),1e-12))
 737         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))
 738         self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
 739         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(-1,-1)])))
 740         pass
 741
 742     def testSwig2Intersect2DMeshWith1DLine7(self):
 743         """ Star pattern (a triangle intersecting another one upside down) """
 744         coords1 = DataArrayDouble([-2.,1.,   2.,1.,  0.,-2.], 3,2)
 745         coords2 = DataArrayDouble([0.,2.,   2.,-1.,  -2.,-1.,  0.,3.], 4,2)
 746         m1 = MEDCouplingUMesh("triangle", 2)
 747         m2 = MEDCouplingUMesh("tri_line", 1)
 748         m1.setCoords(coords1)
 749         m2.setCoords(coords2)
 750         m1.setConnectivity(DataArrayInt([NORM_TRI3, 0,1,2]), DataArrayInt([0,4]))
 751         m2.setConnectivity(DataArrayInt([NORM_SEG2,0,1,NORM_SEG2,1,2,NORM_SEG2,2,3]), DataArrayInt([0,3,6,9]))
 752     # End of construction of input meshes m1bis and m2 -> start of specific part of the test
 753         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 754         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])))
 755         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,19])))
 756         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])))
 757         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24,27])))
 758         self.assertTrue(a.getCoords()[:3].isEqual(m1.getCoords(),1e-12))
 759         self.assertTrue(a.getCoords()[3:7].isEqual(m2.getCoords(),1e-12))
 760         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))
 761         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 762         self.assertTrue(c.isEqual(DataArrayInt([0,0,0,0])))
 763         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,3),(-1,-1),(-1,-1),(1,3),(-1,-1),(-1,-1),(2,3),(-1,-1)])))
 764         pass
 765
 766     def testSwig2Intersect2DMeshWith1DLine8(self):
 767         """ Line pieces ending (or fully located) in the middle of a cell """
 768         m1c = MEDCouplingCMesh()
 769         m1c.setCoordsAt(0,DataArrayDouble([-1., 1.]))
 770         m1c.setCoordsAt(1,DataArrayDouble([-1., 1.]));
 771         m1 = m1c.buildUnstructured()
 772         coords2 = DataArrayDouble([0.,0.,  0.,1.5, -1.5,0.,  0.5,0.0,  0.0,-0.5, 1.1,-0.6], 6,2)
 773         m2 = MEDCouplingUMesh("piecewise_line", 1)
 774         m2.setCoords(coords2)
 775         c = DataArrayInt([NORM_SEG2,2,1, NORM_SEG2,1,4, NORM_SEG2,4,3,  NORM_SEG2,3,5])
 776         cI = DataArrayInt([0,3,6,9,12])
 777         m2.setConnectivity(c, cI)
 778         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 779         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])))
 780         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,10,19])))
 781         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])))
 782         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
 783         self.assertTrue(a.getCoords()[:4].isEqual(m1.getCoords(),1e-12))
 784         self.assertTrue(a.getCoords()[4:10].isEqual(m2.getCoords(),1e-12))
 785         self.assertTrue(a.getCoords()[10:].isEqual(DataArrayDouble([(-1.,0.5),(-0.5,1.),(0.,1.),(1.,-0.5)]),1e-12))
 786         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 787         self.assertTrue(c.isEqual(DataArrayInt([0,0,0])))
 788         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
 789         pass
 790
 791     def testSwig2Intersect2DMeshWith1DLine9(self):
 792         """ Intersection with a line whose connectivity is not consecutive """
 793         m1c = MEDCouplingCMesh()
 794         coordX = DataArrayDouble([-1., 1., 2])
 795         m1c.setCoordsAt(0,coordX)
 796         coordY = DataArrayDouble([0., 2.])
 797         m1c.setCoordsAt(1,coordY);
 798         m1 = m1c.buildUnstructured()
 799         # A simple line:
 800         m2 = MEDCouplingUMesh("bla", 1)
 801         coord2 = DataArrayDouble([0.,1.5,  0.5,1.,  0.0,0.5,  0.0,3.0,  0.0,-1.0], 5, 2)
 802         conn2 = DataArrayInt([NORM_SEG2,3,0,NORM_SEG3,0,2,1,NORM_SEG2,2,4])
 803         connI2 = DataArrayInt([0,3,7,10])
 804         m2.setCoords(coord2)
 805         m2.setConnectivity(conn2, connI2)
 806         # End of construction of input meshes m1bis and m2 -> start of specific part of the test
 807         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
 808         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])))
 809         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,18,31])))
 810         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,9,12,1,12,6,2,6,8,13,1,8,11,1,11,10])))
 811         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,13,16])))
 812         self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
 813         self.assertTrue(a.getCoords()[6:11].isEqual(m2.getCoords(),1e-12))
 814         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))
 815         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 816         self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
 817         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
 818         pass
 819
 820     def testSwig2Intersect2DMeshWith1DLine10(self):
 821         """ Intersection between a circle and various lines """
 822         eps = 1.0e-8
 823         m_circ = MEDCouplingDataForTest.buildCircle2(0.0, 0.0, 2.0)
 824         coords = [0.0,3.0,0.0,-3.0]
 825         connec = [0,1]
 826         m_line = MEDCouplingUMesh("seg", 1)
 827         m_line.allocateCells(1)
 828         meshCoords = DataArrayDouble.New(coords, len(coords) // 2, 2)
 829         m_line.setCoords(meshCoords)
 830         m_line.insertNextCell(NORM_SEG2, connec)
 831         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m_circ, m_line, eps)
 832         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 833         self.assertTrue(a.getCoords()[:m_circ.getNumberOfNodes()].isEqual(m_circ.getCoords(),1e-12))
 834         self.assertTrue(a.getCoords()[m_circ.getNumberOfNodes():m_circ.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 835         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))
 836         self.assertEqual([32,1,7,10,11,12,13,14,15,32,5,3,11,10,16,17,18,19],a.getNodalConnectivity().getValues())
 837         self.assertEqual([0,9,18],  a.getNodalConnectivityIndex().getValues())
 838         self.assertEqual([1,8,11,1,11,10,1,10,9],b.getNodalConnectivity().getValues())
 839         self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
 840         self.assertTrue(a.getCoords()[:8].isEqual(m_circ.getCoords(),1e-12))
 841         self.assertTrue(a.getCoords()[8:10].isEqual(m_line.getCoords(),1e-12))
 842         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])
 843         self.assertTrue(a.getCoords().isEqualWithoutConsideringStr(coo_tgt,1.0e-12))
 844         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 845         self.assertEqual([0,0],c.getValues())
 846         self.assertEqual([-1,-1,0,1,-1,-1],d.getValues())
 847
 848     def testSwig2Intersect2DMeshWith1DLine11(self):
 849         """ Quad line re-entering a square cell """
 850         eps = 1.0e-8
 851         m = MEDCouplingUMesh("box", 2)
 852         m.setCoords(DataArrayDouble([-1., -1., -1., 1., 1., 1., 1., -1.0],4,2))
 853         c, cI = [NORM_POLYGON, 0, 1, 2, 3], [0, 5]
 854         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 855         m.checkConsistencyLight()
 856         coords2 = [0., 1.3, -1.3, 0., -0.6, 0.6, 0., -1.3, -0.5, -0.5]
 857         connec2, cI2 = [NORM_SEG3, 0, 1, 2, NORM_SEG3, 1, 3, 4], [0,4,8]
 858         m_line = MEDCouplingUMesh("seg", 1)
 859         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 860         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 861         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 862         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 863         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 864         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 865         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))
 866         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())
 867         self.assertEqual([0,13,20,27],a.getNodalConnectivityIndex().getValues())
 868         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())
 869         self.assertEqual([0,4,8,12,16,20,24],b.getNodalConnectivityIndex().getValues())
 870         self.assertTrue(a.getCoords()[:4].isEqual(m.getCoords(),1e-12))
 871         self.assertTrue(a.getCoords()[4:9].isEqual(m_line.getCoords(),1e-12))
 872         self.assertTrue(DataArrayInt([0,0,0]).isEqual(c))
 873         self.assertTrue(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(0,1),(-1,-1)]).isEqual(d))
 874         pass
 875
 876     def testSwig2Intersect2DMeshWith1DLine12(self):
 877         """ Two squares one in the other intersected by an horizontal line """
 878         eps = 1.0e-8
 879         m = MEDCouplingUMesh("boxbox", 2)
 880         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))
 881         c = [NORM_POLYGON, 4, 5, 6, 7, NORM_POLYGON, 0, 1, 5, 4, NORM_POLYGON, 1, 2, 3, 0, 4, 7, 6, 5]
 882         cI = [0, 5, 10, 19]
 883         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 884         m.checkConsistencyLight()
 885         coords2 = [-1., 0.25, 1., 0.25]
 886         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
 887         m_line = MEDCouplingUMesh.New("seg", 1)
 888         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 889         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 890         m_line2 = m_line.deepCopy()
 891         m2 = m.deepCopy()
 892         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 893         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 894         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 895         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 896         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))
 897         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())
 898         self.assertEqual([0,5,9,14,20,27],a.getNodalConnectivityIndex().getValues())
 899         self.assertEqual([1,8,10,1,10,5,1,5,6,1,6,11,1,11,9],b.getNodalConnectivity().getValues())
 900         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
 901         self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
 902         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
 903         pass
 904
 905     def testSwig2Intersect2DMeshWith1DLine13(self):
 906         """ A square (side length) in a circle intersected by a simple horizontal line """
 907         import math
 908         eps = 1.0e-8
 909         m = MEDCouplingUMesh("boxcircle", 2)
 910         sq2 = math.sqrt(2.0)
 911         soth = (sq2+1.0)/2.0
 912         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
 913          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
 914         coo = DataArrayDouble(coo); coo.rearrange(2)
 915         m.setCoords(coo)
 916         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]
 917         cI = [0, 9, 18, 35]
 918         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 919         m.checkConsistencyLight()
 920         coords2 = [-2., 1., 2., 1.0]
 921         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
 922         m_line = MEDCouplingUMesh("seg", 1)
 923         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 924         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 925         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 926         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 927         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 928         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 929         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))
 930         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())
 931         self.assertEqual([0,9,18,25,32,49],a.getNodalConnectivityIndex().getValues())
 932         self.assertEqual([1,18,21,1,21,9,1,9,10,1,10,20,1,20,19],b.getNodalConnectivity().getValues())
 933         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
 934         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
 935         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(3,4),(-1,-1)])))
 936         pass
 937
 938     def testSwig2Intersect2DMeshWith1DLine14(self):
 939         """ A circle in a circle intersected by a simple horizontal line, not tangent to the circles """
 940         eps = 1.0e-8
 941         m = MEDCouplingUMesh("boxcircle", 2)
 942         coo = [2.,0.,1.4142135623730951,1.414213562373095,0.,2.,-1.414213562373095,1.4142135623730951,-2.,0.,-1.4142135623730954,-1.414213562373095,0.,-2.,
 943                1.4142135623730947,-1.4142135623730954,1.,0.,0.7071067811865476,0.7071067811865475,0.,1.,-0.7071067811865475,0.7071067811865476,-1.,0.,-0.7071067811865477,-0.7071067811865475,
 944                0.,-1.,0.7071067811865474,-0.7071067811865477,1.060660171779821,-1.0606601717798214,-1.0606601717798214,-1.0606601717798212]
 945         coo = DataArrayDouble(coo); coo.rearrange(2)
 946         m.setCoords(coo)
 947         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]
 948         cI = [0, 9, 18, 35]
 949         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 950         m.checkConsistencyLight()
 951         coords2 = [-2., 0., 2., 0.]
 952         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
 953         m_line = MEDCouplingUMesh.New("seg", 1)
 954         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
 955         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 956         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 957         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 958         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 959         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 960         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))
 961         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())
 962         self.assertEqual([0,9,26,35,44,53,62],a.getNodalConnectivityIndex().getValues())
 963         self.assertEqual([1,18,20,1,20,21,1,21,19],b.getNodalConnectivity().getValues())
 964         self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
 965         self.assertTrue(c.isEqual(DataArrayInt([1,2,2,2,0,0])))
 966         self.assertTrue(d.isEqual(DataArrayInt([(1,3),(4,5),(1,2)])))
 967         pass
 968
 969     def testSwig2Intersect2DMeshWith1DLine15(self):
 970         """ Same as testSwig2Intersect2DMeshWith1DLine13 except that the line is colinear AND splits on of the common edge of 2D mesh."""
 971         import math
 972         eps = 1.0e-8
 973         m = MEDCouplingUMesh("boxcircle", 2)
 974         sq2 = math.sqrt(2.0)
 975         soth = (sq2+1.0)/2.0
 976         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
 977          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
 978         coo = DataArrayDouble(coo); coo.rearrange(2)
 979         m.setCoords(coo)
 980         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]
 981         cI = [0, 9, 18, 35]
 982         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
 983         m.checkConsistencyLight()
 984         coords2 = [(-2., 1.),(2.,1.),(0.,1)]
 985         connec2, cI2 = [NORM_SEG2, 0, 2, NORM_SEG2, 2, 1], [0,3,6]
 986         m_line = MEDCouplingUMesh("seg", 1)
 987         m_line.setCoords(DataArrayDouble(coords2))
 988         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
 989         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
 990         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
 991         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
 992         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
 993         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))
 994         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())
 995         self.assertEqual([0,11,22,29,36,53],a.getNodalConnectivityIndex().getValues())
 996         self.assertEqual([1,18,22,1,22,9,1,9,20,1,20,10,1,10,21,1,21,19],b.getNodalConnectivity().getValues())
 997         self.assertEqual([0,3,6,9,12,15,18],b.getNodalConnectivityIndex().getValues())
 998         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
 999         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(1,0),(3,4),(-1,-1)])))
1000         pass
1001
1002     def testSwig2Intersect2DMeshWith1DLine16(self):
1003         """ Same than testSwig2Intersect2DMeshWith1DLine13 except it is a vertical line. Non regression test."""
1004         import math
1005         eps = 1.0e-8
1006         m = MEDCouplingUMesh("boxcircle", 2)
1007         sq2 = math.sqrt(2.0)
1008         soth = (sq2+1.0)/2.0
1009         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
1010          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
1011         coo = DataArrayDouble(coo); coo.rearrange(2)
1012         m.setCoords(coo)
1013         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]
1014         cI = [0, 9, 18, 35]
1015         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
1016         m.checkConsistencyLight()
1017         coords2 = [1., 2., 1., -2.]
1018         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
1019         m_line = MEDCouplingUMesh("seg", 1)
1020         m_line.setCoords(DataArrayDouble(coords2, len(coords2) // 2, 2))
1021         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
1022         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
1023         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
1024         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
1025         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
1026         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))
1027         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())
1028         self.assertEqual([0,9,16,25,36,49],a.getNodalConnectivityIndex().getValues())
1029         self.assertEqual([1,18,20,1,20,10,1,10,11,1,11,21,1,21,19],b.getNodalConnectivity().getValues())
1030         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
1031         self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
1032         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
1033         pass
1034
1035     def testSwig2Intersect2DMeshWith1DLine17(self):
1036         """ Single colinear intersection - a deltaShiftIndex() was improperly tested. """
1037         eps = 1.0e-12
1038         mesh = MEDCouplingUMesh('dummy_layer', 2)
1039         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)])
1040         mesh.setCoords(coo)
1041         c = DataArrayInt([5, 4, 5, 6, 7, 5, 0, 1, 5, 4, 5, 1, 2, 3, 0, 4, 7, 6, 5])
1042         cI = DataArrayInt([0, 5, 10, 19])
1043         mesh.setConnectivity(c, cI)
1044         m_line = MEDCouplingUMesh('segment', 1)
1045         coo = DataArrayDouble([(-0.5,0.5),(-0.25,0.25)])
1046         m_line.setCoords(coo)
1047         c = DataArrayInt([1, 0, 1])
1048         cI = DataArrayInt([0, 3])
1049         m_line.setConnectivity(c, cI)
1050         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(mesh, m_line, eps)
1051         self.assertEqual(mesh.getNodalConnectivity().getValues(),a.getNodalConnectivity().getValues())
1052         self.assertEqual(mesh.getNodalConnectivityIndex().getValues(),a.getNodalConnectivityIndex().getValues())
1053         self.assertEqual([1,1,5],b.getNodalConnectivity().getValues())
1054         self.assertEqual(m_line.getNodalConnectivityIndex().getValues(),b.getNodalConnectivityIndex().getValues())
1055         self.assertTrue([0,1,2], c.getValues())
1056         self.assertEqual([2,1], d.getValues())
1057
1058     def testSwig2Intersect2DMeshWith1DLine18(self):
1059         """ Rare case: a *closed* line used as a tool, with the closing point inside a 2D cell ... """
1060         tool = MEDCouplingUMesh('circle', 1)
1061         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)])
1062         tool.setCoords(coo)
1063         c = DataArrayInt([2, 3, 5, 8,    2, 5, 3, 4])
1064         cI = DataArrayInt([0, 4, 8])
1065         tool.setConnectivity(c, cI)
1066
1067         meh = MEDCouplingUMesh('meh', 2)
1068         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)])
1069         meh.setCoords(coo)
1070         c = DataArrayInt([32, 0, 1, 3, 13, 11, 8, 9, 15, 10, 14,
1071                              32, 3, 4, 2, 0, 11, 13, 5, 6, 7, 14, 12, 15])
1072         cI = DataArrayInt([0, 11, 24])
1073         meh.setConnectivity(c, cI)
1074
1075         res2D, res1D, m1, m2 = MEDCouplingUMesh.Intersect2DMeshWith1DLine(meh, tool, 1e-12)
1076         self.assertEqual(4, res2D.getNumberOfCells())
1077         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,
1078                                                                    32, 4, 2, 0, 11, 13, 26, 27, 44, 45, 46, 47, 48, 49, 50, 32, 3, 27, 26, 51, 52, 53])
1079         self.assertEqual(res2D.getNodalConnectivityIndex().getValues(),[0, 15, 24, 39, 46])
1080         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])
1081         self.assertEqual(res1D.getNodalConnectivityIndex().getValues(),[0, 4, 8, 12, 16, 20])
1082         self.assertEqual(m1.getValues(), [0,0,1,1])
1083         self.assertEqual(m2.getValues(), [0,1,   -1,-1,  -1,-1,   2,3,  0,1])
1084
1085     def testSwig2Intersect2DMeshWith1DLine19(self):
1086         """ Intersection arc of circle / segment was not properly detecting tangent cases """
1087         eps=1.0e-5  # was working at 1.0e-8, but should also really work with 1.0e-5
1088         mesh = MEDCouplingUMesh('layer_1', 2)
1089         coo = DataArrayDouble([(55.4,3.7239),(61.4,7.188),(61.4,13.943),(49.55,7.1014),
1090                                   (61.4,10.5655),(58.4,5.45595),(52.475,5.41265),(55.475,10.5222),
1091                                   (56.9,9.34),(56.3343,7.97431),(56.9,7.74),(57.4657,7.97431),(59.4328,7.58116),
1092                                   (55.8672,5.84911),    (0.,0.)])
1093         mesh.setCoords(coo)
1094         c = DataArrayInt([32, 0, 3, 2, 1, 11, 9,     6, 7, 4, 12, 8, 13])
1095         cI = DataArrayInt([0, 13])
1096         mesh.setConnectivity(c, cI)
1097         tool = MEDCouplingUMesh('segment', 1)
1098         coo = DataArrayDouble([(-166.611,-119.951),(269.611,131.902)])
1099         tool.setCoords(coo)
1100         c = DataArrayInt([1, 0, 1])
1101         cI = DataArrayInt([0, 3])
1102         tool.setConnectivity(c, cI)
1103
1104         res2D, res1D, m1, m2 = MEDCouplingUMesh.Intersect2DMeshWith1DLine(mesh, tool, eps)
1105
1106         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])
1107         self.assertEqual(res2D.getNodalConnectivityIndex().getValues(),[0, 13, 22, 31])
1108         self.assertEqual(res1D.getNodalConnectivity().getValues(),[1, 15, 17, 1, 17, 19, 1, 19, 20, 1, 20, 18, 1, 18, 16])
1109         self.assertEqual(res1D.getNodalConnectivityIndex().getValues(),[0, 3, 6, 9, 12, 15])
1110         self.assertEqual(m1.getValues(), [0, 0, 0])
1111         self.assertEqual(m2.getValues(), [-1, -1, 0, 2, -1, -1, 0, 1, -1, -1])
1112
1113     def testSwig2Conformize2D1(self):
1114         eps = 1.0e-8
1115         coo = [0.,-0.5,0.,0.,0.5,0.,0.5,-0.5,0.25,
1116                -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]
1117         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]
1118         connI = [0,5,12,17,24]
1119         m = MEDCouplingUMesh("box",2)
1120         cooArr = DataArrayDouble(coo, len(coo) // 2, 2)
1121         m.setCoords(cooArr)
1122         m.setConnectivity(DataArrayInt(conn),DataArrayInt(connI))
1123         m.mergeNodes(eps)
1124         m.checkConsistencyLight()
1125         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([3])))
1126         self.assertEqual(m.getCoords().getHiddenCppPointer(),cooArr.getHiddenCppPointer()) # check that coordinates remain the same here
1127         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])))
1128         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,12,17,25])))
1129         pass
1130
1131     def testSwig2Conformize2D2(self):
1132         eps = 1.0e-8
1133         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)
1134         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])
1135         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
1136         m.setCoords(coo)
1137         m.setNodalConnectivity(conn)
1138         m=m.buildUnstructured()
1139         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
1140         self.assertEqual(m.getCoords().getHiddenCppPointer(),coo.getHiddenCppPointer()) # check that coordinates remain the same here
1141         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])))
1142         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,6,12,21,26,31,37,42])))
1143         pass
1144
1145     def testSwigSplit2DCells1(self):
1146         coo=DataArrayDouble([[0,0],[1,0],[1,1],[0,1],[0.5,0],[1,0.5],[0.5,1],[0.,0.5]])
1147         m=MEDCouplingUMesh("mesh",2)
1148         m.setCoords(coo)
1149         m.allocateCells()
1150         m.insertNextCell(NORM_QUAD8,[0,1,2,3,4,5,6,7])
1151         _,d,di,_,_=m.buildDescendingConnectivity()
1152         subb=DataArrayInt([5])
1153         subbi=DataArrayInt([0,0,1,1,1])
1154         mid=DataArrayInt([-1,-1])
1155         midi=DataArrayInt([0,0,2,2,2])
1156         self.assertEqual(2,m.split2DCells(d,di,subb,subbi,mid,midi))
1157         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,1,5,2,3,4,8,9,6,7])))
1158         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11])))
1159         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))
1160         pass
1161
1162     def testSwig2Conformize2D3(self):
1163         eps = 1.0e-8
1164         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)
1165         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])
1166         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
1167         m.setCoords(coo)
1168         m.setNodalConnectivity(conn)
1169         m=m.buildUnstructured()
1170         m.convertLinearCellsToQuadratic()
1171         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
1172         self.assertTrue(m.getCoords().getHiddenCppPointer()!=coo.getHiddenCppPointer()) # coordinates are not the same here contrary to testSwig2Conformize2D2 ...
1173         self.assertTrue(m.getCoords()[:18].isEqual(coo,1e-12)) # but the 18 first nodes are the same
1174         pass
1175
1176     def testSwig2Conformize2D4(self):
1177         eps = 1.0e-8
1178         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)
1179         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])
1180         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
1181         m.setCoords(coo)
1182         m.setNodalConnectivity(conn)
1183         m=m.buildUnstructured()
1184         m.convertLinearCellsToQuadratic()
1185         self.assertEqual(42,m.getNumberOfNodes())
1186         oldCoo=m.getCoords().deepCopy()
1187         m.conformize2D(eps)
1188         self.assertTrue(m.getCoords()[:42].isEqual(oldCoo,1e-12))
1189         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])))
1190         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11,22,39,48,57,68,77])))
1191         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))
1192         pass
1193
1194     def testSwig2Conformize2D5(self):
1195         eps=1e-8
1196         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]])
1197         m=MEDCouplingUMesh("mesh",2)
1198         m.allocateCells()
1199         m.setCoords(coo)
1200         m.insertNextCell(NORM_TRI6,[1,2,0,5,4,3])
1201         m.insertNextCell(NORM_TRI6,[8,6,0,12,7,13])
1202         m.insertNextCell(NORM_TRI6,[11,9,10,16,14,15])
1203         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0])))
1204         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))
1205         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])))
1206         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,13,20,27])))
1207         pass
1208
1209     def testSwig2Conformize2D6(self):
1210         """ Was raising an internal error on the tiny cell #1. SegSegIntersector was faulty (eps misinterpreted)."""
1211         eps=1.0e-6
1212         mesh = MEDCouplingUMesh('Intersect2D', 2)
1213         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)])
1214         mesh.setCoords(coo)
1215         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])
1216         cI = DataArrayInt([0, 9, 16, 25, 38])
1217         mesh.setConnectivity(c, cI)
1218
1219         mesh.conformize2D(eps)  # internal error was here
1220
1221         c2, cI2 = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
1222         self.assertEqual(c2, c.getValues())
1223         self.assertEqual(cI2, cI.getValues())
1224         pass
1225
1226     def testSwig2Conformize3D1(self):
1227         """ Simple test where no edge merge is required, only face merging (first part of the algo) """
1228         mesh = MEDCouplingUMesh('merge', 3)
1229         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),
1230                                (2,0,0),(2,1,0),(2,0,1),(2,1,1),(1,0,2),(2,0,2),(1,1,2),(2,1,2)])
1231         mesh.setCoords(coo)
1232         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,
1233                            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,
1234                            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,
1235                            14, 16, 15, 13, -1, 11, 14, 13, 5, -1, 5, 13, 15, 7, -1, 7, 15, 16, 12, -1, 12, 16, 14, 11])
1236         cI = DataArrayInt([0, 41, 71, 101])
1237         mesh.setConnectivity(c, cI)
1238         ret = mesh.conformize3D(1.0e-8)
1239
1240         mretDesc, _, _, _, _ = mesh.buildDescendingConnectivity()
1241         c, cI = mretDesc.getNodalConnectivity().getValues(), mretDesc.getNodalConnectivityIndex().getValues()
1242         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,
1243                 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,
1244                 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,
1245                 15, 16, 12, 5, 12, 16, 14, 11]
1246         cIRef = [0, 5, 10, 15, 20, 25, 29, 33, 37, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91]
1247         self.assertEqual(19, mretDesc.getNumberOfCells())
1248         self.assertEqual(cRef, c)
1249         self.assertEqual(cIRef, cI)
1250         self.assertEqual([1], ret.getValues())
1251         pass
1252
1253     def testSwig2Conformize3D2(self):
1254         """ More advanced test where edge merge is required. """
1255         mesh = MEDCouplingUMesh('merge', 3)
1256         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),
1257                                (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)])
1258         mesh.setCoords(coo)
1259         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,
1260                           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,
1261                           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,
1262                           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,
1263                           7, 11, 21, 19, -1, 19, 21, 20, 18])
1264         cI = DataArrayInt([0, 37, 74, 104, 134])
1265         mesh.setConnectivity(c, cI)
1266
1267         ret = mesh.conformize3D(1.0e-8)
1268
1269         mretDesc, _, _, _, _ = mesh.buildDescendingConnectivity()
1270         mretDesc2, _, _, _, _ = mretDesc.buildDescendingConnectivity()
1271         c0, cI0 = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
1272         c, cI = mretDesc.getNodalConnectivity().getValues(), mretDesc.getNodalConnectivityIndex().getValues()
1273         c2, cI2 = mretDesc2.getNodalConnectivity().getValues(), mretDesc2.getNodalConnectivityIndex().getValues()
1274         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]
1275         cIRef0 = [0, 39, 78, 117, 156]
1276         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]
1277         cIRef = [0, 6, 13, 18, 23, 28, 33, 39, 45, 50, 55, 60, 66, 71, 77, 84, 89, 94, 99, 105, 110, 115, 120]
1278         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]
1279         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]
1280         self.assertEqual(22, mretDesc.getNumberOfCells())
1281         self.assertEqual(39, mretDesc2.getNumberOfCells())
1282         self.assertEqual(cRef0, c0)
1283         self.assertEqual(cIRef0, cI0)
1284         self.assertEqual(cRef, c)
1285         self.assertEqual(cIRef, cI)
1286         self.assertEqual(cRef2, c2)
1287         self.assertEqual(cIRef2, cI2)
1288         self.assertEqual(set([0,1,2,3]), set(ret.getValues()))
1289         pass
1290
1291     def testSwig2Conformize3D3(self):
1292         """ LMEC's case (hexagonal prism) """
1293         eps = 1.0e-7   # 1.0e-8 is too fine
1294         mesh = MEDCouplingUMesh('merge', 3)
1295         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)])
1296         mesh.setCoords(coo)
1297         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])
1298         cI = DataArrayInt([0, 23, 46, 69, 92, 115, 138, 168, 198, 228, 258, 288, 318, 348, 378, 408, 438, 468, 498, 542])
1299         mesh.setConnectivity(c, cI)
1300         mesh.mergeNodes(eps) # the initial case has double nodes
1301
1302         ret = mesh.conformize3D(eps)
1303
1304         mretDesc, _, _, _, _ = mesh.buildDescendingConnectivity()
1305         mretDesc2, _, _, _, _ = mretDesc.buildDescendingConnectivity()
1306         c0, cI0 = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
1307         c, cI = mretDesc.getNodalConnectivity().getValues(), mretDesc.getNodalConnectivityIndex().getValues()
1308         c2, cI2 = mretDesc2.getNodalConnectivity().getValues(), mretDesc2.getNodalConnectivityIndex().getValues()
1309         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]
1310         cIRef0 = [0, 23, 46, 69, 92, 115, 138, 168, 198, 228, 258, 288, 318, 348, 378, 408, 438, 468, 498, 631]
1311         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]
1312         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]
1313         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]
1314         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]
1315         self.assertEqual(85, mretDesc.getNumberOfCells())
1316         self.assertEqual(121, mretDesc2.getNumberOfCells())
1317         self.assertEqual(cRef0, c0)
1318         self.assertEqual(cIRef0, cI0)
1319         self.assertEqual(cRef, c)
1320         self.assertEqual(cIRef, cI)
1321         self.assertEqual(cRef2, c2)
1322         self.assertEqual(cIRef2, cI2)
1323         self.assertEqual(set([18]), set(ret.getValues()))
1324         pass
1325
1326 if __name__ == '__main__':
1327     unittest.main()