def test_pp_merge(self):
self.start()
plinelist = [[110, 5], [120, 20], [130, 15]]
plinelst2 = [[150, 50], [160, 70]]
plinelst3 = (190, 65, 4)
pm = gxgeo.PPoint.merge((plinelist, plinelst2, [plinelst3]))
self.assertEqual(pm.length, 6)
self.assertEqual(tuple(pm[0]), (110, 5, 0))
self.assertEqual(tuple(pm[4]), (160, 70, 0))
self.assertEqual(tuple(pm[5]), (190, 65, 4))
pm = gxgeo.PPoint.merge(
(gxgeo.PPoint(plinelist), gxgeo.Point2(plinelst2),
gxgeo.Point(plinelst3)))
self.assertEqual(pm.length, 6)
self.assertEqual(tuple(pm[0]), (110, 5, 0))
self.assertEqual(tuple(pm[4]), (160, 70, 0))
self.assertEqual(tuple(pm[5]), (190, 65, 4))
center = gxgeo.Point((550000, 6000000))
a = gxgeo.PPoint(plinelist) + center
b = gxgeo.Point2(plinelst2,
coordinate_system="NAD83 / UTM zone 15N") + center
c = gxgeo.Point(plinelst3,
coordinate_system="NAD27 / UTM zone 15N") + center
pm = gxgeo.PPoint.merge((a, b, c))
self.assertEqual(pm.length, 6)
self.assertTrue(pm.coordinate_system == b.coordinate_system)
self.assertEqual(tuple(pm[0]), (550110., 6000005., 0.))
self.assertEqual(tuple(pm[4]), (550160., 6000070., 0.))
self.assertEqual(str(pm[5]),
'_point_(550173.9373550161, 6000287.416398498, 4.0)')
def test_fetch_point(self):
self.start()
with gxdap.DapClient() as dap:
# some point data
dataset = dap['Kimberlite Indicator Mineral Grain Chemistry']
extent = gxgeo.Point2(((-112, 65), (-111, 65.5)),
coordinate_system='NAD83')
data_file = dap.fetch_data(dataset, extent=extent, progress=print)
self.assertEqual(os.path.splitext(data_file)[1], '.csv')
extent = gxgeo.Point2(((-80, 65), (-70, 65.5)),
coordinate_system='NAD83')
self.assertRaises(gxdap.DapClientException, dap.fetch_data,
dataset, None, extent)
def test_fetch_grid(self):
self.start()
with gxdap.DapClient() as dap:
# get a grid
dataset = dap['SRTM1 Canada']
extent = gxgeo.Point2(((-79.8, 43.5), (-79.25, 43.8)),
coordinate_system='NAD83')
extent = gxgeo.Point2(extent,
coordinate_system='NAD83 / UTM zone 17N')
data_file = dap.fetch_data(dataset,
extent=extent,
progress=print,
resolution=500)
with gxgrd.Grid.open(data_file) as grd:
self.assertEqual(grd.nx, 115)
def test_names(self):
self.start()
self.assertEqual(gxgeo.Point((1, 2)).name, '_point_')
self.assertEqual(gxgeo.Point((1, 2), name='maki').name, 'maki')
self.assertTrue(
gxgeo.Point((1, 2)) == gxgeo.Point((1, 2), name='maki'))
self.assertEqual(gxgeo.Point(gxgeo.Point((1, 2))).name, '_point_')
self.assertEqual(
gxgeo.Point(gxgeo.Point((1, 2)), name='maki').name, 'maki')
p1 = (1, 2)
p2 = (2, 3)
self.assertEqual(gxgeo.Point2((p1, p2)).name, '_point2_')
self.assertEqual(gxgeo.Point2((p1, p2), name='maki').name, 'maki')
self.assertTrue(
gxgeo.Point2((p1, p2)) == gxgeo.Point2((p1, p2), name='maki'))
pp = ((1, 2), (3, 2), (4, 5))
self.assertEqual(gxgeo.PPoint(pp).name, '_ppoint_')
self.assertEqual(gxgeo.PPoint(pp, name='maki').name, 'maki')
self.assertTrue(gxgeo.PPoint(pp) == gxgeo.PPoint(pp, name='maki'))
def test_cs_math(self):
self.start()
p = gxgeo.Point((5, 10))
self.assertTrue(p == p)
self.assertTrue(
gxgeo.Point((1, 2), coordinate_system="WGS 84") == gxgeo.Point(
(1, 2), coordinate_system="WGS 84"))
self.assertTrue(
gxgeo.Point((1,
2), coordinate_system="WGS 84") == gxgeo.Point((1,
2)))
self.assertTrue(gxgeo.Point((1, 2)) == gxgeo.Point((1, 2)))
cs = "NAD83 / UTM zone 32N>"
p = gxgeo.Point((500000, 6000000), coordinate_system=cs)
self.assertEqual(str(p.coordinate_system), "NAD83 / UTM zone 32N")
p27 = gxgeo.Point(p, "NAD27 / UTM zone 32N")
self.assertEqual(str(p27.coordinate_system), "NAD27 / UTM zone 32N")
self.assertAlmostEqual(p27.x, 499840.780459, 3)
self.assertAlmostEqual(p27.y, 5999920.58165, 3)
self.assertFalse(p == p27)
p27 = gxgeo.Point(p, "NAD27 / UTM zone 32N")
self.assertEqual(str(p27.coordinate_system), "NAD27 / UTM zone 32N")
self.assertAlmostEqual(p27.x, 499840.780459, 3)
self.assertAlmostEqual(p27.y, 5999920.58165, 3)
self.assertFalse(p == p27)
pd = p - p27
self.assertEqual(str(pd.coordinate_system), "NAD83 / UTM zone 32N")
self.assertAlmostEqual(pd.x, 0., 2)
self.assertAlmostEqual(pd.y, 0., 2)
pd = p27 - p
self.assertEqual(str(pd.coordinate_system), "NAD27 / UTM zone 32N")
self.assertAlmostEqual(pd.x, 0., 2)
self.assertAlmostEqual(pd.y, 0., 2)
pp = p + (10, 5)
self.assertEqual(str(pp.coordinate_system), "NAD83 / UTM zone 32N")
self.assertEqual(pp.xy, (500010, 6000005))
p = gxgeo.Point2(((500000, 6000000), (500001, 6000001)),
coordinate_system=cs)
self.assertEqual(str(p.coordinate_system), "NAD83 / UTM zone 32N")
p27 = gxgeo.Point2(p, "NAD27 / UTM zone 32N")
self.assertEqual(str(p27.coordinate_system), "NAD27 / UTM zone 32N")
self.assertAlmostEqual(p27.p0.x, 499840.780459, 3)
self.assertAlmostEqual(p27.p0.y, 5999920.58165, 3)
self.assertAlmostEqual(p27.p1.x, 499841.780459, 3)
self.assertAlmostEqual(p27.p1.y, 5999921.58165, 3)
self.assertFalse(p == p27)
pp = p / 2
self.assertEqual(pp[1].xyz, (250000.5, 3000000.5, 0.0))
pp = p / gxgeo.Point(2)
self.assertEqual(pp[1].xyz, (250000.5, 3000000.5, 0.0))
pp = p / gxgeo.Point2((gxgeo.Point(2), gxgeo.Point(3)))
self.assertEqual(pp[0].xyz, (250000.0, 3000000.0, 0.0))
self.assertEqual(pp[1].xyz, (166667.0, 2000000.3333333333, 0.0))
p27 = gxgeo.Point2(p, "NAD27 / UTM zone 32N")
self.assertEqual(str(p27.coordinate_system), "NAD27 / UTM zone 32N")
self.assertAlmostEqual(p27.p0.x, 499840.780459, 3)
self.assertAlmostEqual(p27.p0.y, 5999920.58165, 3)
self.assertAlmostEqual(p27.p1.x, 499841.780459, 3)
self.assertAlmostEqual(p27.p1.y, 5999921.58165, 3)
self.assertEqual(tuple(p27[0]),
(499840.78045944084, 5999920.5816528751, 0.0))
self.assertEqual(tuple(p27[1]),
(499841.7804697603, 5999921.5816632193, 0.0))
for pp in p27:
self.assertTrue(isinstance(pp, gxgeo.Point))
self.assertFalse(p == p27)
pp = p + p27
self.assertEqual(tuple(pp[0]),
(999999.99835706223, 12000000.002281997, 0.0))
self.assertEqual(tuple(pp[1]),
(1000001.9983570619, 12000002.002281997, 0.0))
pp = pp - p27[0]
self.assertEqual(tuple(pp[0]), (500000.0, 6000000.0000000009, 0.0))
self.assertEqual(tuple(pp[1]),
(500001.99999999965, 6000002.0000000009, 0.0))
pd = p - p27
self.assertEqual(str(pd.coordinate_system), "NAD83 / UTM zone 32N")
self.assertAlmostEqual(pd.p0.x, 0., 2)
self.assertAlmostEqual(pd.p0.y, 0., 2)
self.assertAlmostEqual(pd.p1.x, 0., 2)
self.assertAlmostEqual(pd.p1.y, 0., 2)
pp = pd + 1
self.assertAlmostEqual(pp.p0.x, 1., 2)
self.assertAlmostEqual(pp.p0.y, 1., 2)
self.assertAlmostEqual(pp.p1.x, 1., 2)
self.assertAlmostEqual(pp.p1.y, 1., 2)
pp = pd + gxgeo.Point(1)
self.assertAlmostEqual(pp.p0.x, 1., 2)
self.assertAlmostEqual(pp.p0.y, 1., 2)
self.assertAlmostEqual(pp.p1.x, 1., 2)
self.assertAlmostEqual(pp.p1.y, 1., 2)
pp = -pp
self.assertAlmostEqual(pp.p0.x, -1., 2)
self.assertAlmostEqual(pp.p0.y, -1., 2)
self.assertAlmostEqual(pp.p1.x, -1., 2)
self.assertAlmostEqual(pp.p1.y, -1., 2)
pp = -pp - 1
self.assertAlmostEqual(pd.p0.x, 0., 2)
self.assertAlmostEqual(pd.p0.y, 0., 2)
self.assertAlmostEqual(pd.p1.x, 0., 2)
self.assertAlmostEqual(pd.p1.y, 0., 2)
pz = gxgeo.Point2(((0, 1, 2), (1, 2, 3)))
pp = (pz + 1) * 5
self.assertEqual(tuple(pp[0]), (5., 10., 15.))
self.assertEqual(tuple(pp[1]), (10., 15., 20.))
pp = (pz + 1) * gxgeo.Point((2, 5, 10))
self.assertEqual(tuple(pp[0]), (2., 10., 30.))
self.assertEqual(tuple(pp[1]), (4., 15., 40.))
pp = (pz + 1) * gxgeo.Point2(((2, 5, 10), (1, 2, 3)))
self.assertEqual(tuple(pp[0]), (2., 10., 30.))
self.assertEqual(tuple(pp[1]), (2.0, 6.0, 12.0))
pd = p27 - p
self.assertEqual(str(pd.coordinate_system), "NAD27 / UTM zone 32N")
self.assertAlmostEqual(pd.p0.x, 0., 2)
self.assertAlmostEqual(pd.p0.y, 0., 2)
self.assertAlmostEqual(pd.p1.x, 0., 2)
self.assertAlmostEqual(pd.p1.y, 0., 2)
pp = p + (10, 5)
self.assertEqual(str(pp.coordinate_system), "NAD83 / UTM zone 32N")
self.assertEqual(pp.p0.xy, (500010, 6000005))
self.assertEqual(pp.p1.xy, (500011, 6000006))
pp.x2 = (1, 2)
pp.y2 = (3, 4)
pp.z2 = (5, 6)
self.assertEqual(pp.p0.xyz, (1, 3, 5))
self.assertEqual(pp.p1.xyz, (2, 4, 6))
def test_p2(self):
self.start()
b1 = gxgeo.Point2((gxgeo.Point((0, 1)), (10, 20, -1)))
self.assertEqual(len(b1), 2)
self.assertEqual(tuple(b1.pp[0]), (0, 1, 0))
self.assertEqual(tuple(b1.pp[1]), (10, 20, -1))
self.assertEqual(b1.centroid.xyz, (5.0, 10.5, -0.5))
self.assertEqual(len(b1), 2)
self.assertEqual('_point2_[(0.0, 1.0, 0.0) (10.0, 20.0, -1.0)]',
str(b1))
self.assertEqual(b1.x2, (0., 10.))
self.assertEqual(b1.y2, (1., 20.))
self.assertEqual(b1.z2, (0, -1.))
b2 = gxgeo.Point2(((0, 1), (10, 20, -1)))
self.assertTrue(b1 == b2)
b1 = gxgeo.Point2((gxgeo.Point((0, 1, -20)), (10, 20, -1)))
self.assertEqual('_point2_[(0.0, 1.0, -20.0) (10.0, 20.0, -1.0)]',
str(b1))
self.assertEqual(b1.x2, (0., 10.))
self.assertEqual(b1.y2, (1., 20.))
self.assertEqual(b1.z2, (-20., -1.))
b2 = gxgeo.Point2((gxgeo.Point((b1.x2[0], b1.y2[0], b1.z2[0])),
gxgeo.Point((b1.x2[1], b1.y2[1], b1.z2[1]))))
self.assertTrue(b1 == b2)
b2 = gxgeo.Point2((gxgeo.Point((b1.x2[1], b1.y2[1], b1.z2[1])),
gxgeo.Point((b1.x2[0], b1.y2[0], b1.z2[0]))),
coordinate_system="WGS 84")
self.assertTrue(b1 == b2)
b2 = gxgeo.Point2(
((b1.x2[1], b1.y2[1], b1.z2[1]), (b1.x2[0], b1.y2[0], b1.z2[0])),
coordinate_system="WGS 84")
self.assertTrue(b1 == b2)
b2 = gxgeo.Point2(
(b1.x2[1], b1.y2[1], b1.z2[1], b1.x2[0], b1.y2[0], b1.z2[0]),
coordinate_system="WGS 84")
self.assertTrue(b1 == b2)
c = gxgeo.Point(((b2.p0.x + b2.p1.x) * 0.5, (b2.p0.y + b2.p1.y) * 0.5,
(b2.p0.z + b2.p1.z) * 0.5))
self.assertEqual(b2.centroid, c)
self.assertEqual(b2.dimension,
(abs(b2.p1.x - b2.p0.x), abs(b2.p1.y - b2.p0.y),
abs(b2.p1.z - b2.p0.z)))
self.assertEqual(b2.dimension_xy,
(abs(b2.p1.x - b2.p0.x), abs(b2.p1.y - b2.p0.y)))
self.assertEqual(b2.extent_xyz, (0.0, 1.0, -20.0, 10.0, 20.0, -1.0))
self.assertEqual(b2.extent_xy, (0.0, 1.0, 10.0, 20.0))
b = gxgeo.Point2(5)
self.assertEqual(b[0].xyz, (5, 5, 5))
self.assertEqual(b[1].xyz, (5, 5, 5))
b = gxgeo.Point2((5, 6))
self.assertEqual(b[0].xyz, (5, 6, 0))
self.assertEqual(b[1].xyz, (5, 6, 0))
b = gxgeo.Point2((5, 6, 7))
self.assertEqual(b[0].xyz, (5, 6, 7))
self.assertEqual(b[1].xyz, (5, 6, 7))
b = gxgeo.Point2((5, 6, 7, 8))
self.assertEqual(b[0].xyz, (5, 6, 0))
self.assertEqual(b[1].xyz, (7, 8, 0))
b = gxgeo.Point2((5, 6, 7, 8, 9, 0))
self.assertEqual(b[0].xyz, (5, 6, 7))
self.assertEqual(b[1].xyz, (8, 9, 0))
self.assertRaises(gxgeo.GeometryException, gxgeo.Point2,
(2, 3, 4, 5, 6))
def test_image_file(self):
self.start()
image_file = ''
try:
with gxagg.Aggregate_image.new(self.g3f,
shade=True,
color_map='elevation.tbl',
contour=20) as agg:
image_file = agg.image_file(image_type=gxmap.RASTER_FORMAT_PNG,
pix_width=None)
with gxgrid.Grid.open(image_file + '(IMG,t=png)') as g:
nx, ny, x0, y0, dx, dy, rot = agg.spatial_properties
self.assertEqual(g.coordinate_system,
agg.coordinate_system)
self.assertEqual(g.nx, nx)
self.assertEqual(g.ny, ny)
self.assertEqual(g.x0, x0)
self.assertEqual(g.y0, y0)
self.assertAlmostEqual(g.dx, dx)
self.assertAlmostEqual(g.dy, dy)
self.assertAlmostEqual(g.rot, rot)
finally:
gxu.delete_file(image_file)
try:
with gxagg.Aggregate_image.new(self.g3f,
shade=True,
color_map='elevation.tbl',
contour=20) as agg:
display_area = gxgm.Point2(
((336000, 6160000, 0.0), (338000, 6161500, 0.0)))
image_file = agg.image_file(image_type=gxmap.RASTER_FORMAT_PNG,
pix_width=800,
display_area=display_area)
with gxgrid.Grid.open(image_file + '(IMG,t=png)') as g:
self.assertEqual(g.coordinate_system,
agg.coordinate_system)
self.assertEqual(g.nx, 800)
self.assertEqual(g.ny, 600)
self.assertEqual(g.extent_xy, display_area.extent_xy)
self.assertEqual(g.extent_minimum_xy,
display_area.extent_minimum_xy)
self.assertEqual(g.extent_maximum_xy,
display_area.extent_maximum_xy)
finally:
gxu.delete_file(image_file)
try:
with gxagg.Aggregate_image.new(self.g3f,
shade=True,
color_map='elevation.tbl',
contour=20) as agg:
display_area = gxgm.Point2(
agg.extent, coordinate_system='AGD66 / AMG zone 53')
image_file = agg.image_file(image_type=gxmap.RASTER_FORMAT_PNG,
pix_width=800,
display_area=display_area)
with gxgrid.Grid.open(image_file + '(IMG,t=png)') as g:
self.assertEqual(g.coordinate_system,
display_area.coordinate_system)
self.assertEqual(g.nx, 800)
self.assertEqual(g.ny, 602)
finally:
gxu.delete_file(image_file)