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