test/python/run_map.py

from esys.pyvisi import DataCollector, Scene, Map
from esys.pyvisi.constant import *
import unittest, os
from stat import ST_SIZE

PYVISI_TEST_MESHES_PATH = "data_meshes/"
PYVISI_TEST_MAP_IMAGES_PATH = "data_sample_images/map/"
MIN_IMAGE_SIZE = 100
FILE_2D = "interior_2D.xml"
FILE_3D = "interior_3D.xml"

X_SIZE = 400
Y_SIZE = 400

JPG_RENDERER = Renderer.OFFLINE_JPG
SCALAR_FIELD_CELL_DATA = "temperature_cell"
VECTOR_FIELD_CELL_DATA = "velocity_cell"
TENSOR_FIELD_CELL_DATA = "stress_cell"

class TestMap:
    def tearDown(self):
        self.scene
        self.data_collector
        self.map

    def render(self, file):
        self.scene.render(image_name = \
                PYVISI_TEST_MAP_IMAGES_PATH + file)

        self.failUnless(os.stat(PYVISI_TEST_MAP_IMAGES_PATH + \
                file)[ST_SIZE] > MIN_IMAGE_SIZE)

class TestMapOneViewport(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)
    
        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_2D)
        
        self.map = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

    def testSetOpacity(self):
        self.map.setOpacity(opacity = 0.5)
        self.render("TestMapOneViewport_testSetOpacity.jpg")    

    def testSetColor(self):
        self.map.setColor(color = Color.ORANGE)
        self.render("TestMapOneViewport_testSetColor.jpg")

    def testSetRepresentationToWireframe(self):
        self.map.setRepresentationToWireframe()
        self.render("TestMapOneViewport_testSetRepresentationToWireframe.jpg")

class TestMapFourViewports(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 4,
                x_size = X_SIZE, y_size = Y_SIZE)
    
        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_2D)
        
        self.map1 = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

        self.map2 = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.NORTH_WEST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

        self.map3 = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.NORTH_EAST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

        self.map4 = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_EAST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

    def tearDown(self):
        self.scene
        self.data_collector
        self.map1
        self.map2
        self.map3
        self.map4

    def testSetOpacity(self):
        self.map1.setOpacity(0.2)
        self.map2.setOpacity(0.4)
        self.map3.setOpacity(0.6)
        self.map4.setOpacity(0.8)
        self.render("TestMapFourViewports_testSetOpacity.jpg")  

    def testSetColor(self):
        self.map1.setColor(Color.GREY)
        self.map3.setColor(Color.YELLOW)
        self.render("TestMapFourViewports_testSetColor.jpg")

    def testSetRepresentationToWireframe(self):
        self.map2.setRepresentationToWireframe()
        self.map4.setRepresentationToWireframe()
        self.render("TestMapFourViewports_testSetRepresentationToWireframe.jpg")

class TestMap2DCellDataWithCellToPointConversion(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)
    
        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_2D)
        self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
        
        self.map = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = True, outline = True)

    def test2DCellDataWithCellToPointConversion(self):
        self.render("TestMap2DCellDataWithCellToPointConversion.jpg")

class TestMap2DCellDataWithoutCellToPointConversion(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)

        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_2D)
        self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
        
        self.map = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

    def test2DCellDataWithoutCellToPointConversion(self):
        self.render("TestMap2DCellDataWithoutCellToPointConversion.jpg")

class TestMap3DPointData(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)

        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_3D)
        
        self.map = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

    def test3DPointData(self):
        self.render("TestMap3DPointData.jpg")

class TestMap3DCellDataWithCellToPointConversion(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)

        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_3D)
        self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
        
        self.map = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = True, outline = True)

    def test3DCellDataWithCellToPointConversion(self):
        self.render("TestMap3DCellDataWithCellToPointConversion.jpg")

class TestMap3DCellDataWithoutCellToPointConversion(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)

        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_3D)
        self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
        
        self.map = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

    def test3DCellDataWithoutCellToPointConversion(self):
        self.render("TestMap3DCellDataWithoutCellToPointConversion.jpg")

class TestMapGreyScaleLut(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)

        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_2D)
        self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
        
        self.map = Map(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.GREY_SCALE,
                cell_to_point = False, outline = True)

    def testGreyScaleLut(self):
        self.render("TestMapGreyScaleLut.jpg")


###############################################################################


from esys.pyvisi import MapOnPlaneCut

class TestMapOnPlaneCut(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)
    
        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_3D)
        
        self.map = MapOnPlaneCut(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

    def testTranslate(self):
        self.map.setPlaneToXZ()
        self.map.translate(0, 0.3, 0)
        self.render("TestMapOnPlaneCut_testTranslate.jpg")
    
    def testRotate(self):
        self.map.setPlaneToXY()
        self.map.rotateX(20)
        self.map.rotateY(20)
        self.render("TestMapOnPlaneCut_testRotate.jpg") 


###############################################################################


from esys.pyvisi import MapOnPlaneClip

class TestMapOnPlaneClip(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)
    
        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_3D)
        
        self.map = MapOnPlaneClip(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

    def testSetInsideOutOff(self):
        self.map.setPlaneToYZ()
        self.map.rotateZ(20)
        self.map.setInsideOutOff()
        self.render("TestMapOnPlaneClip_testSetInsideOutOff.jpg")


###############################################################################
        

from esys.pyvisi import MapOnScalarClip

class TestMapOnScalarClip(unittest.TestCase, TestMap):
    def setUp(self):
        self.scene = \
                Scene(renderer = JPG_RENDERER, num_viewport = 1,
                x_size = X_SIZE, y_size = Y_SIZE)
    
        self.data_collector = DataCollector(source = Source.XML)
        self.data_collector.setFileName(file_name = \
                PYVISI_TEST_MESHES_PATH + FILE_3D)
        
        self.map = MapOnScalarClip(scene = self.scene, 
                data_collector = self.data_collector,
                viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
                cell_to_point = False, outline = True)

    def testSetClipValue(self):
        self.map.setClipValue(0)
        self.render("TestMapOnScalarClip_testSetClipValue.jpg")
        

###############################################################################


if __name__ == '__main__':
    suite = unittest.TestSuite()
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapOneViewport))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapFourViewports))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap2DCellDataWithCellToPointConversion))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap2DCellDataWithoutCellToPointConversion))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap3DPointData))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap3DCellDataWithCellToPointConversion))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap3DCellDataWithoutCellToPointConversion))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapGreyScaleLut))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapOnPlaneCut))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapOnPlaneClip))
    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapOnScalarClip))

    unittest.TextTestRunner(verbosity=2).run(suite)

1	from esys.pyvisi import DataCollector, Scene, Map
2	from esys.pyvisi.constant import *
3	import unittest, os
4	from stat import ST_SIZE
5
6	PYVISI_TEST_MESHES_PATH = "data_meshes/"
7	PYVISI_TEST_MAP_IMAGES_PATH = "data_sample_images/map/"
8	MIN_IMAGE_SIZE = 100
9	FILE_2D = "interior_2D.xml"
10	FILE_3D = "interior_3D.xml"
11
12	X_SIZE = 400
13	Y_SIZE = 400
14
15	JPG_RENDERER = Renderer.OFFLINE_JPG
16	SCALAR_FIELD_CELL_DATA = "temperature_cell"
17	VECTOR_FIELD_CELL_DATA = "velocity_cell"
18	TENSOR_FIELD_CELL_DATA = "stress_cell"
19
20	class TestMap:
21	def tearDown(self):
22	self.scene
23	self.data_collector
24	self.map
25
26	def render(self, file):
27	self.scene.render(image_name = \
28	PYVISI_TEST_MAP_IMAGES_PATH + file)
29
30	self.failUnless(os.stat(PYVISI_TEST_MAP_IMAGES_PATH + \
31	file)[ST_SIZE] > MIN_IMAGE_SIZE)
32
33	class TestMapOneViewport(unittest.TestCase, TestMap):
34	def setUp(self):
35	self.scene = \
36	Scene(renderer = JPG_RENDERER, num_viewport = 1,
37	x_size = X_SIZE, y_size = Y_SIZE)
38
39	self.data_collector = DataCollector(source = Source.XML)
40	self.data_collector.setFileName(file_name = \
41	PYVISI_TEST_MESHES_PATH + FILE_2D)
42
43	self.map = Map(scene = self.scene,
44	data_collector = self.data_collector,
45	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
46	cell_to_point = False, outline = True)
47
48	def testSetOpacity(self):
49	self.map.setOpacity(opacity = 0.5)
50	self.render("TestMapOneViewport_testSetOpacity.jpg")
51
52	def testSetColor(self):
53	self.map.setColor(color = Color.ORANGE)
54	self.render("TestMapOneViewport_testSetColor.jpg")
55
56	def testSetRepresentationToWireframe(self):
57	self.map.setRepresentationToWireframe()
58	self.render("TestMapOneViewport_testSetRepresentationToWireframe.jpg")
59
60	class TestMapFourViewports(unittest.TestCase, TestMap):
61	def setUp(self):
62	self.scene = \
63	Scene(renderer = JPG_RENDERER, num_viewport = 4,
64	x_size = X_SIZE, y_size = Y_SIZE)
65
66	self.data_collector = DataCollector(source = Source.XML)
67	self.data_collector.setFileName(file_name = \
68	PYVISI_TEST_MESHES_PATH + FILE_2D)
69
70	self.map1 = Map(scene = self.scene,
71	data_collector = self.data_collector,
72	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
73	cell_to_point = False, outline = True)
74
75	self.map2 = Map(scene = self.scene,
76	data_collector = self.data_collector,
77	viewport = Viewport.NORTH_WEST, lut = Lut.COLOR,
78	cell_to_point = False, outline = True)
79
80	self.map3 = Map(scene = self.scene,
81	data_collector = self.data_collector,
82	viewport = Viewport.NORTH_EAST, lut = Lut.COLOR,
83	cell_to_point = False, outline = True)
84
85	self.map4 = Map(scene = self.scene,
86	data_collector = self.data_collector,
87	viewport = Viewport.SOUTH_EAST, lut = Lut.COLOR,
88	cell_to_point = False, outline = True)
89
90	def tearDown(self):
91	self.scene
92	self.data_collector
93	self.map1
94	self.map2
95	self.map3
96	self.map4
97
98	def testSetOpacity(self):
99	self.map1.setOpacity(0.2)
100	self.map2.setOpacity(0.4)
101	self.map3.setOpacity(0.6)
102	self.map4.setOpacity(0.8)
103	self.render("TestMapFourViewports_testSetOpacity.jpg")
104
105	def testSetColor(self):
106	self.map1.setColor(Color.GREY)
107	self.map3.setColor(Color.YELLOW)
108	self.render("TestMapFourViewports_testSetColor.jpg")
109
110	def testSetRepresentationToWireframe(self):
111	self.map2.setRepresentationToWireframe()
112	self.map4.setRepresentationToWireframe()
113	self.render("TestMapFourViewports_testSetRepresentationToWireframe.jpg")
114
115	class TestMap2DCellDataWithCellToPointConversion(unittest.TestCase, TestMap):
116	def setUp(self):
117	self.scene = \
118	Scene(renderer = JPG_RENDERER, num_viewport = 1,
119	x_size = X_SIZE, y_size = Y_SIZE)
120
121	self.data_collector = DataCollector(source = Source.XML)
122	self.data_collector.setFileName(file_name = \
123	PYVISI_TEST_MESHES_PATH + FILE_2D)
124	self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
125
126	self.map = Map(scene = self.scene,
127	data_collector = self.data_collector,
128	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
129	cell_to_point = True, outline = True)
130
131	def test2DCellDataWithCellToPointConversion(self):
132	self.render("TestMap2DCellDataWithCellToPointConversion.jpg")
133
134	class TestMap2DCellDataWithoutCellToPointConversion(unittest.TestCase, TestMap):
135	def setUp(self):
136	self.scene = \
137	Scene(renderer = JPG_RENDERER, num_viewport = 1,
138	x_size = X_SIZE, y_size = Y_SIZE)
139
140	self.data_collector = DataCollector(source = Source.XML)
141	self.data_collector.setFileName(file_name = \
142	PYVISI_TEST_MESHES_PATH + FILE_2D)
143	self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
144
145	self.map = Map(scene = self.scene,
146	data_collector = self.data_collector,
147	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
148	cell_to_point = False, outline = True)
149
150	def test2DCellDataWithoutCellToPointConversion(self):
151	self.render("TestMap2DCellDataWithoutCellToPointConversion.jpg")
152
153	class TestMap3DPointData(unittest.TestCase, TestMap):
154	def setUp(self):
155	self.scene = \
156	Scene(renderer = JPG_RENDERER, num_viewport = 1,
157	x_size = X_SIZE, y_size = Y_SIZE)
158
159	self.data_collector = DataCollector(source = Source.XML)
160	self.data_collector.setFileName(file_name = \
161	PYVISI_TEST_MESHES_PATH + FILE_3D)
162
163	self.map = Map(scene = self.scene,
164	data_collector = self.data_collector,
165	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
166	cell_to_point = False, outline = True)
167
168	def test3DPointData(self):
169	self.render("TestMap3DPointData.jpg")
170
171	class TestMap3DCellDataWithCellToPointConversion(unittest.TestCase, TestMap):
172	def setUp(self):
173	self.scene = \
174	Scene(renderer = JPG_RENDERER, num_viewport = 1,
175	x_size = X_SIZE, y_size = Y_SIZE)
176
177	self.data_collector = DataCollector(source = Source.XML)
178	self.data_collector.setFileName(file_name = \
179	PYVISI_TEST_MESHES_PATH + FILE_3D)
180	self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
181
182	self.map = Map(scene = self.scene,
183	data_collector = self.data_collector,
184	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
185	cell_to_point = True, outline = True)
186
187	def test3DCellDataWithCellToPointConversion(self):
188	self.render("TestMap3DCellDataWithCellToPointConversion.jpg")
189
190	class TestMap3DCellDataWithoutCellToPointConversion(unittest.TestCase, TestMap):
191	def setUp(self):
192	self.scene = \
193	Scene(renderer = JPG_RENDERER, num_viewport = 1,
194	x_size = X_SIZE, y_size = Y_SIZE)
195
196	self.data_collector = DataCollector(source = Source.XML)
197	self.data_collector.setFileName(file_name = \
198	PYVISI_TEST_MESHES_PATH + FILE_3D)
199	self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
200
201	self.map = Map(scene = self.scene,
202	data_collector = self.data_collector,
203	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
204	cell_to_point = False, outline = True)
205
206	def test3DCellDataWithoutCellToPointConversion(self):
207	self.render("TestMap3DCellDataWithoutCellToPointConversion.jpg")
208
209	class TestMapGreyScaleLut(unittest.TestCase, TestMap):
210	def setUp(self):
211	self.scene = \
212	Scene(renderer = JPG_RENDERER, num_viewport = 1,
213	x_size = X_SIZE, y_size = Y_SIZE)
214
215	self.data_collector = DataCollector(source = Source.XML)
216	self.data_collector.setFileName(file_name = \
217	PYVISI_TEST_MESHES_PATH + FILE_2D)
218	self.data_collector.setActiveScalar(SCALAR_FIELD_CELL_DATA)
219
220	self.map = Map(scene = self.scene,
221	data_collector = self.data_collector,
222	viewport = Viewport.SOUTH_WEST, lut = Lut.GREY_SCALE,
223	cell_to_point = False, outline = True)
224
225	def testGreyScaleLut(self):
226	self.render("TestMapGreyScaleLut.jpg")
227
228
229	###############################################################################
230
231
232	from esys.pyvisi import MapOnPlaneCut
233
234	class TestMapOnPlaneCut(unittest.TestCase, TestMap):
235	def setUp(self):
236	self.scene = \
237	Scene(renderer = JPG_RENDERER, num_viewport = 1,
238	x_size = X_SIZE, y_size = Y_SIZE)
239
240	self.data_collector = DataCollector(source = Source.XML)
241	self.data_collector.setFileName(file_name = \
242	PYVISI_TEST_MESHES_PATH + FILE_3D)
243
244	self.map = MapOnPlaneCut(scene = self.scene,
245	data_collector = self.data_collector,
246	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
247	cell_to_point = False, outline = True)
248
249	def testTranslate(self):
250	self.map.setPlaneToXZ()
251	self.map.translate(0, 0.3, 0)
252	self.render("TestMapOnPlaneCut_testTranslate.jpg")
253
254	def testRotate(self):
255	self.map.setPlaneToXY()
256	self.map.rotateX(20)
257	self.map.rotateY(20)
258	self.render("TestMapOnPlaneCut_testRotate.jpg")
259
260
261	###############################################################################
262
263
264	from esys.pyvisi import MapOnPlaneClip
265
266	class TestMapOnPlaneClip(unittest.TestCase, TestMap):
267	def setUp(self):
268	self.scene = \
269	Scene(renderer = JPG_RENDERER, num_viewport = 1,
270	x_size = X_SIZE, y_size = Y_SIZE)
271
272	self.data_collector = DataCollector(source = Source.XML)
273	self.data_collector.setFileName(file_name = \
274	PYVISI_TEST_MESHES_PATH + FILE_3D)
275
276	self.map = MapOnPlaneClip(scene = self.scene,
277	data_collector = self.data_collector,
278	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
279	cell_to_point = False, outline = True)
280
281	def testSetInsideOutOff(self):
282	self.map.setPlaneToYZ()
283	self.map.rotateZ(20)
284	self.map.setInsideOutOff()
285	self.render("TestMapOnPlaneClip_testSetInsideOutOff.jpg")
286
287
288	###############################################################################
289
290
291	from esys.pyvisi import MapOnScalarClip
292
293	class TestMapOnScalarClip(unittest.TestCase, TestMap):
294	def setUp(self):
295	self.scene = \
296	Scene(renderer = JPG_RENDERER, num_viewport = 1,
297	x_size = X_SIZE, y_size = Y_SIZE)
298
299	self.data_collector = DataCollector(source = Source.XML)
300	self.data_collector.setFileName(file_name = \
301	PYVISI_TEST_MESHES_PATH + FILE_3D)
302
303	self.map = MapOnScalarClip(scene = self.scene,
304	data_collector = self.data_collector,
305	viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
306	cell_to_point = False, outline = True)
307
308	def testSetClipValue(self):
309	self.map.setClipValue(0)
310	self.render("TestMapOnScalarClip_testSetClipValue.jpg")
311
312
313	###############################################################################
314
315
316	if __name__ == '__main__':
317	suite = unittest.TestSuite()
318	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapOneViewport))
319	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapFourViewports))
320	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap2DCellDataWithCellToPointConversion))
321	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap2DCellDataWithoutCellToPointConversion))
322	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap3DPointData))
323	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap3DCellDataWithCellToPointConversion))
324	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMap3DCellDataWithoutCellToPointConversion))
325	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapGreyScaleLut))
326	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapOnPlaneCut))
327	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapOnPlaneClip))
328	suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMapOnScalarClip))
329
330	unittest.TextTestRunner(verbosity=2).run(suite)
331