def test_dim(self):
self.start()
data = np.array(range(1000), dtype=np.float64).reshape((500, 2))
with gxvv.GXvv(data) as vv:
self.assertEqual(vv.dim, 2)
self.assertEqual(vv.np.shape, (500, 2))
self.assertEqual(tuple(vv.np[499, :]), (998., 999.))
data = np.array(range(300), dtype=np.float64).reshape((100, 3))
with gxvv.GXvv(data) as vv:
self.assertEqual(vv.dim, 3)
self.assertEqual(vv.np.shape, (100, 3))
self.assertEqual(tuple(vv.np[99, :]), (297., 298., 299.))
with gxvv.GXvv(dim=3) as vv:
vv.set_data(np.array(range(300), dtype=np.float64))
self.assertEqual(vv.dim, 3)
self.assertEqual(vv.np.shape, (100, 3))
self.assertEqual(tuple(vv.np[99, :]), (297., 298., 299.))
with gxvv.GXvv(dim=3) as vv:
data = np.array(range(300), dtype=np.float64)
data[1] = data[299] = np.nan
vv.set_data(data)
self.assertTrue(np.isnan(data[299]))
self.assertEqual(vv.dim, 3)
self.assertEqual(vv.np.shape, (100, 3))
self.assertEqual(tuple(vv.np[99, :2]), (297., 298.))
self.assertTrue(np.isnan(vv.np[99, 2]))
def test_strings(self):
self.start(gsys.func_name())
fidvv = (99, 0.1)
npdata = np.array(["name", "maki", "neil", "rider"])
with gxvv.GXvv(npdata, fid=fidvv) as vv:
self.assertEqual(vv.fid, fidvv)
self.assertEqual(vv.length, len(npdata))
self.assertEqual(vv.gxtype, -5)
self.assertTrue(vv.dtype.type is np.str_)
self.assertEqual(str(vv.dtype), '<U5')
npd, fid = vv.get_np(vv.dtype)
self.assertEqual(npd[0], "name")
self.assertEqual(npd[1], "maki")
self.assertEqual(npd[2], "neil")
self.assertEqual(npd[3], "rider")
npd, fid = vv.get_np(vv.dtype, start=2, n=2)
self.assertEqual(npd[0], "neil")
self.assertEqual(npd[1], "rider")
self.assertEqual(fid, (99.2, 0.1))
npdata = np.array(["1", "2", "3", "4000", "*"])
with gxvv.GXvv(npdata, fid=fid) as vv:
npd, fid = vv.get_np(np.float)
self.assertEqual(npd[0], 1.0)
self.assertEqual(npd[1], 2.0)
self.assertEqual(npd[2], 3.0)
self.assertEqual(npd[3], 4000.0)
self.assertEqual(npd[4], gxapi.rDUMMY)
npdata = np.array(["1", "2", "3", "4000", "40000", "*"])
with gxvv.GXvv(npdata, fid=fid) as vv:
npd, fid = vv.get_np(np.int)
self.assertEqual(npd[0], 1)
self.assertEqual(npd[1], 2)
self.assertEqual(npd[2], 3)
self.assertEqual(npd[3], 4000)
self.assertEqual(npd[4], 40000)
self.assertEqual(npd[5], gxapi.iDUMMY)
npdata = np.array(["1", "2", "3", "4000", "40000", "*"])
with gxvv.GXvv(npdata, fid=fid) as vv:
npd, fid = vv.get_np(np.int, start=2, n=3)
self.assertEqual(npd[0], 3)
self.assertEqual(npd[1], 4000)
self.assertEqual(npd[2], 40000)
npdata = np.array(["make_it_big enough"])
with gxvv.GXvv(npdata, fid=fid) as vv:
npd, fid = vv.get_np(np.int, start=0, n=1)
self.assertEqual(npd[0], gxapi.iDUMMY)
npdata = np.array([1., 2., -30., -87.66662])
vv.set_np(npdata)
npd, fid = vv.get_np(start=0, n=4)
self.assertEqual(npd[0], "1.0")
self.assertEqual(npd[2], "-30.0")
self.assertEqual(npd[3], "-87.66662")
def test_vv(self):
self.start(gsys.func_name())
self.assertEqual(gxvv.__version__, geosoft.__version__)
with gxvv.GXvv(dtype=np.float) as vv:
self.assertEqual(vv.fid, (0.0, 1.0))
fid = (10.1, 0.99)
with gxvv.GXvv(dtype=np.float, fid=fid) as vv:
self.assertEqual(vv.fid, fid)
self.assertEqual(vv.length, 0)
fid = (-45, 7)
vv.fid = fid
self.assertEqual(vv.fid, fid)
vv.reFid((-40, 8), 4)
self.assertEqual(vv.fid, (-40, 8))
self.assertEqual(vv.length, 4)
with gxvv.GXvv([1, 2, 3, 4, 5, 6]) as vv:
self.assertEqual(vv.fid, (0.0, 1.0))
self.assertEqual(vv.length, 6)
self.assertEqual(vv.dtype, np.int32)
self.assertEqual(vv.gxtype, gxu.gx_dtype(np.int32))
with gxvv.GXvv([1, 2, 3, 4, 5, 6], dtype=np.int64) as vv:
self.assertEqual(vv.fid, (0.0, 1.0))
self.assertEqual(vv.length, 6)
self.assertEqual(vv.dtype, np.int64)
self.assertEqual(vv.gxtype, gxu.gx_dtype(np.int64))
def test_vv(self):
self.start()
self.assertEqual(gxvv.__version__, geosoft.__version__)
with gxvv.GXvv(dtype=np.float) as vv:
self.assertTrue(vv.gxvv, gxapi.GXVV)
self.assertEqual(vv.fid, (0.0, 1.0))
fid = (10.1, 0.99)
with gxvv.GXvv(dtype=np.float, fid=fid) as vv:
self.assertTrue(vv.is_float)
self.assertFalse(vv.is_int)
self.assertFalse(vv.is_string)
self.assertEqual(vv.fid, fid)
self.assertEqual(vv.length, 0)
fid = (-45, 7)
vv.fid = fid
self.assertEqual(vv.fid, fid)
vv.refid((-40, 8), 4)
self.assertEqual(vv.fid, (-40, 8))
self.assertEqual(vv.length, 4)
self.assertEqual(len(vv.np), 4)
vv.length = 16
self.assertEqual(vv.fid, (-40, 8))
self.assertEqual(vv.length, 16)
self.assertEqual(len(vv.np), 16)
self.assertEqual(vv.dim, 1)
vv.refid((-38, 1.5))
self.assertEqual(vv.fid, (-38, 1.5))
self.assertEqual(vv.length, 80)
vv.refid((1000, 50))
self.assertEqual(vv.fid, (1000., 50.))
self.assertEqual(vv.length, 0)
self.assertRaises(gxvv.VVException, vv.refid, (1, 0))
self.assertRaises(gxvv.VVException, vv.refid, (1, -1))
with gxvv.GXvv([1, 2, 3, 4, 5, 6]) as vv:
self.assertTrue(vv.is_int)
self.assertFalse(vv.is_float)
self.assertFalse(vv.is_string)
self.assertEqual(vv.fid, (0.0, 1.0))
self.assertEqual(vv.length, 6)
self.assertEqual(vv.dtype, np.int32)
self.assertEqual(vv.gxtype, gxu.gx_dtype(np.int32))
with gxvv.GXvv([1, 2, 3, 4, 5, 6], dtype=np.int64) as vv:
self.assertEqual(vv.fid, (0.0, 1.0))
self.assertEqual(vv.length, 6)
self.assertEqual(vv.dtype, np.int64)
self.assertEqual(vv.gxtype, gxu.gx_dtype(np.int64))
def test_draw_surface_3d(self):
verts = np.array([[0, 0, 0],
[5, 0, 0],
[5, 5, 0],
[0, 3, 5],
[2.5, 2, 10],
[-3, 6, 8],
[-4, 0, 12]], dtype=np.float64)
faces = np.array([[0, 1, 2],
[0, 2, 3],
[3, 2, 4],
[1, 2, 4],
[3, 4, 5],
[6, 4, 5]], dtype=np.int32)
with gxv.View_3d.new() as v3d:
v3d_file = v3d.file_name
with gxg.Draw_3d(v3d, 'Surface') as g:
verts = verts[faces].reshape(-1, 3)
vx, vy, vz = gxvv.vvset_from_np(verts)
vf1, vf2, vf3 = gxvv.vvset_from_np(faces)
normals = gxg.vertex_normals_np(faces, verts)
nx, ny, nz = gxvv.vvset_from_np(normals[faces].reshape(-1, 3))
# using a constant color does not complain
v3d.gxview.draw_surface_3d_ex('test',
vx.gxvv, vy.gxvv, vz.gxvv,
nx.gxvv, ny.gxvv, nz.gxvv,
gxapi.GXVV.null(), gxg.C_GREY,
vf1.gxvv, vf2.gxvv, vf3.gxvv,
v3d.coordinate_system.gxipj)
# using an array color raises invalid number of colour if we pass colours/vertex
color = np.array([gxg.C_GREY for i in range(vx.length)])
color_vv = gxvv.GXvv(color, dtype=np.int32)
try:
v3d.gxview.draw_surface_3d_ex('test2',
vx.gxvv, vy.gxvv, vz.gxvv,
nx.gxvv, ny.gxvv, nz.gxvv,
color_vv.gxvv, gxg.C_GREY,
vf1.gxvv, vf2.gxvv, vf3.gxvv,
v3d.coordinate_system.gxipj)
except gxapi.GXAPIError as e:
print(str(e))
# and if pass colours/face it asserts
color = np.array([gxg.C_GREY for i in range(faces.shape[0])])
color_vv = gxvv.GXvv(color, dtype=np.int32)
v3d.gxview.draw_surface_3d_ex('test2',
vx.gxvv, vy.gxvv, vz.gxvv,
nx.gxvv, ny.gxvv, nz.gxvv,
color_vv.gxvv, gxg.C_GREY,
vf1.gxvv, vf2.gxvv, vf3.gxvv,
v3d.coordinate_system.gxipj)
def test_string(self):
self.start(gsys.func_name())
l = [1, 2, 3]
with gxvv.GXvv(l, dtype='U45') as vv:
self.assertEqual(vv.list(), ['1', '2', '3'])
l = [1, 2, "abcdefg"]
with gxvv.GXvv(l, dtype='U4') as vv:
self.assertEqual(vv.list(), ['1', '2', 'abcd'])
def test_list(self):
self.start(gsys.func_name())
l = [1, 2, 3]
with gxvv.GXvv(l) as vv:
self.assertEqual(vv.list(), l)
l = [1., 2., 3.]
with gxvv.GXvv(l) as vv:
self.assertEqual(vv.list(), l)
l = ["a", "b", "abc"]
with gxvv.GXvv(l) as vv:
self.assertEqual(vv.list(), l)
def test_write_vv_GDB(self):
self.start(gsys.func_name())
with gxgdb.GXdb.open(self.gdb_name) as gdb:
gdb.delete_channel('test')
gdb.new_channel('test')
vv = gxvv.GXvv(np.array([1.0, 2.0, 3.0, 4.0]))
gdb.write_channel_vv('D590875', 'test', vv)
npd, ch, fid = gdb.read_line('D590875', channels=['test'])
self.assertEqual(npd.shape, (4, 1))
self.assertEqual(npd[:, 0].tolist(), [1.0, 2.0, 3.0, 4.0])
gdb.delete_channel('test')
gdb.new_channel('test', np.float64)
vv = gxvv.GXvv(dtype=np.float64)
vv.set_np(np.array([1, 2, 3, 4], dtype=np.int64))
gdb.write_channel_vv('D590875', 'test', vv)
npd, ch, fid = gdb.read_line('D590875',
channels=['test'],
dtype=np.int)
self.assertEqual(npd.shape, (4, 1))
self.assertEqual(npd[:, 0].tolist(), [1, 2, 3, 4])
gdb.delete_channel('test')
gdb.new_channel('test', np.int32)
gdb.write_channel_vv('D590875', 'test', vv)
npd, ch, fid = gdb.read_line('D590875', 'test')
self.assertEqual(npd.shape, (4, 1))
self.assertEqual(npd[:, 0].tolist(), [1.0, 2.0, 3.0, 4.0])
gdb.delete_channel('test')
gdb.new_channel('test', dtype=np.int32)
vv.fid = (3, 2)
gdb.write_channel_vv('D590875', 'test', vv)
npd, ch, fid = gdb.read_line('D590875', 'test', dtype=int)
self.assertEqual(npd.shape, (4, 1))
self.assertEqual(npd[:, 0].tolist(), [1, 2, 3, 4])
self.assertEqual(fid[0], 3.0)
self.assertEqual(fid[1], 2.0)
gdb.new_channel('test', np.int32)
vv = gxvv.GXvv(np.array([1, 2, 3, 4], dtype=np.int32),
fid=(2.5, 0.33))
gdb.write_channel_vv('D590875', 'test', vv)
npd, ch, fid = gdb.read_line('D590875', channels=['test'])
self.assertEqual(npd.shape, (4, 1))
self.assertEqual(npd[:, 0].tolist(), [1, 2, 3, 4])
self.assertEqual(fid[0], 2.5)
self.assertEqual(fid[1], 0.33)
gdb.discard()
def read_grid_we_just_made_as_type(gstype):
# open the grid with specified type
img = gxapi.GXIMG.create_file(gstype, 'test.grd',
gxapi.IMG_FILE_READORWRITE)
self.assertTrue(img.e_type() == gstype)
# read the 10'th row as int
vv = gxvv.GXvv(dtype=int)
img.read_v(10, 0, 0, vv.gxvv)
self.assertEqual(vv[10][0], 1)
# read as float
vv = gxvv.GXvv(dtype=float)
img.read_v(10, 0, 0, vv.gxvv)
self.assertEqual(vv[10][0], 1.)
def test_read_write_channel_vv_va(self):
self.start(gsys.func_name())
with gxgdb.GXdb.open(self.gdb_name) as gdb:
gdb.delete_channel('test_chan_vv')
vv = gxvv.GXvv(np.array([1., 2., 3.]), fid=(-10, 2.5))
gdb.write_channel_vv('T46', 'test_chan_vv', vv)
vv = gdb.read_channel_vv('T46', 'test_chan_vv')
self.assertEqual(vv.length, 3)
self.assertEqual(vv.fid, (-10.0, 2.5))
va = gdb.read_channel_va('T46', 'test_chan_vv')
self.assertEqual(va.width, 1)
self.assertEqual(va.length, 3)
self.assertEqual(va.fid, (-10.0, 2.5))
gdb.delete_channel('test_chan_vv')
va = gxva.GXva(np.array([[1., 2., 3.], [8, 9, 10]]),
fid=(-10, 2.5))
gdb.write_channel_va('T46', 'test_chan_va', va)
self.assertRaises(gxgdb.GDBException, gdb.read_channel_vv, 'T46',
'test_chan_va')
va = gdb.read_channel_va('T46', 'test_chan_va')
self.assertEqual(va.width, 3)
self.assertEqual(va.length, 2)
self.assertEqual(va.fid, (-10.0, 2.5))
gdb.delete_channel('test_chan_va')
def test_empty(self):
self.start()
empty = np.array([])
vv = gxvv.GXvv(empty)
self.assertEqual(len(vv), 0)
self.assertEqual(vv.np.size, 0)
def test_uom(self):
self.start()
with gxvv.GXvv(range(1000), unit_of_measure='maki') as vv:
self.assertEqual(vv.unit_of_measure, 'maki')
vv.unit_of_measure = 'nT'
self.assertEqual(vv.unit_of_measure, 'nT')
def test_pj(self):
self.start()
with gxcs.Coordinate_system('DHDN / Okarito 2000') as cs:
with gxcs.Coordinate_system('DHDN') as csll:
with gxcs.Coordinate_translate(cs, csll) as pj:
lon, lat = pj.convert((500000, 6500000))
self.assertAlmostEqual(lon, 171)
self.assertAlmostEqual(lat, 8)
lon, lat = pj.convert((500000., 6500000.))
self.assertAlmostEqual(lon, 171.168823147)
self.assertAlmostEqual(lat, 8.36948254242)
ll = pj.convert(
np.array([500000., 6500000.], dtype=np.float32))
self.assertAlmostEqual(ll[0], 171.16882, 5)
self.assertAlmostEqual(ll[1], 8.36948, 5)
lon, lat, z = pj.convert((500000., 6500000., 50.))
self.assertAlmostEqual(lon, 171.168823147)
self.assertAlmostEqual(lat, 8.36948254242)
self.assertAlmostEqual(z, 50)
ll = pj.convert([[500000., 6500000.], [505000., 6510000.]])
self.assertAlmostEqual(ll[0][0], 171.168823147)
self.assertAlmostEqual(ll[0][1], 8.36948254242)
self.assertAlmostEqual(ll[1][0], 171.214439577)
self.assertAlmostEqual(ll[1][1], 8.45978927383)
ll = pj.convert(
np.array([[500000., 6500000.], [505000., 6510000.]]))
self.assertTrue(type(ll) is np.ndarray)
self.assertAlmostEqual(ll[0][0], 171.168823147)
self.assertAlmostEqual(ll[0][1], 8.36948254242)
self.assertAlmostEqual(ll[1][0], 171.214439577)
self.assertAlmostEqual(ll[1][1], 8.45978927383)
vvx = gxvv.GXvv([500000., 505000.])
vvy = gxvv.GXvv([6500000., 6510000.])
pj.convert_vv(vvx, vvy)
self.assertAlmostEqual(vvx[0][0], 171.168823147)
self.assertAlmostEqual(vvy[0][0], 8.36948254242)
self.assertAlmostEqual(vvx[1][0], 171.214439577)
self.assertAlmostEqual(vvy[1][0], 8.45978927383)
def test_vv_creation(self):
self.start()
vv = gxvv.GXvv(range(6),
fid=(-0.5, 2),
dtype=np.float32,
unit_of_measure='maki')
vv2 = gxvv.GXvv(vv)
self.assertTrue(vv == vv2)
self.assertEqual(tuple(vv2.np), tuple(vv.np))
self.assertEqual(vv.fid, vv2.fid)
self.assertEqual(vv.dim, vv2.dim)
self.assertEqual(vv.unit_of_measure, vv2.unit_of_measure)
self.assertEqual(vv.dtype, vv2.dtype)
vv.fid = (0., 1.)
self.assertFalse(vv == vv2)
vv2 = gxvv.GXvv(vv, unit_of_measure='maki2')
self.assertFalse(vv == vv2)
vv2 = gxvv.GXvv(vv, dim=1)
self.assertTrue(vv == vv2)
vv2 = gxvv.GXvv(vv, dim=2)
self.assertFalse(vv == vv2)
vv2 = gxvv.GXvv(vv, dim=3)
self.assertFalse(vv == vv2)
vv3 = gxvv.GXvv(vv2, dim=1)
self.assertTrue(vv == vv3)
def read_grid_we_just_made_as_default():
# open the grid with default type, which I expect will be GS_LONG
img = gxapi.GXIMG.create_file(gxapi.GS_TYPE_DEFAULT, 'test.grd',
gxapi.IMG_FILE_READORWRITE)
# !!!! - the grid is GS_FLOAT, but I expected GS_LONG
self.assertTrue(img.e_type() == gxapi.GS_LONG)
# read the 10'th row as int, we get the right data
vv = gxvv.GXvv(dtype=int)
img.read_v(10, 0, 0, vv.gxvv)
self.assertEqual(vv[10][0], 1)
# try as float, also correct
vv = gxvv.GXvv(dtype=float)
img.read_v(10, 0, 0, vv.gxvv)
self.assertEqual(vv[10][0], 1.)
def test_voxel(self):
self.start()
if self.skip():
name = 'voxel.geosoft_voxel'
gxapi.GXVOX.generate_constant_value(name,
1.0,
5,
0, 0, 0,
1, 1, 1,
300, 200, 50,
gxcs.Coordinate_system().gxipj,
gxmeta.Metadata().gxmeta)
gxvox = gxapi.GXVOX.create(name)
minx = gxapi.float_ref()
miny = gxapi.float_ref()
minz = gxapi.float_ref()
maxx = gxapi.float_ref()
maxy = gxapi.float_ref()
maxz = gxapi.float_ref()
gxvox.get_area(minx, miny, minz, maxx, maxy, maxz)
self.assertEqual(minx.value, -0.5)
self.assertEqual(maxz.value, 49.5)
vvx = gxvv.GXvv()
vvy = gxvv.GXvv()
vvz = gxvv.GXvv()
gxvox.get_location_points(vvx.gxvv, vvy.gxvv, vvz.gxvv)
gxvoxe = gxapi.GXVOXE.create(gxvox)
vvd = gxvv.GXvv([float(n) for n in range(500)])
gxvoxe.vector(0., 0., 0., 1.5, 1.5, 0.5, vvd.gxvv, gxapi.VOXE_EVAL_INTERP)
self.assertEqual(vvd.length, 500)
self.assertEqual(vvd[0][0], 1.0)
self.assertTrue(np.isnan(vvd[499][0]))
gxvoxe = None
gxvox = None
try:
os.remove(name)
os.remove(name + '.xml')
except:
pass
def test_ppoint_constructors(self):
self.start()
def verify():
self.assertEqual(pp.x.tolist(), [1., 4., 7., 10., 13.])
self.assertEqual(pp.z.tolist(), [3., 6., 9., 12., 15.])
self.assertEqual(pp.xy.tolist(), nppp[:, :2].tolist())
lpp = ((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12), (13, 14, 15))
nppp = np.array(lpp)
pp = gxgeo.PPoint(lpp)
verify()
nppp = np.array(lpp)
pp = gxgeo.PPoint(nppp)
verify()
vvx = gxvv.GXvv(nppp[:, 0])
vvy = gxvv.GXvv(nppp[:, 1])
vvz = gxvv.GXvv(nppp[:, 2])
pp = gxgeo.PPoint((vvx, vvy, vvz))
verify()
pp = gxgeo.PPoint((vvx, vvy), z=5)
self.assertEqual(pp.x.tolist(), [1., 4., 7., 10., 13.])
self.assertEqual(pp.z.tolist(), [5, 5, 5, 5, 5])
vvx, vvy, vvz = pp.make_xyz_vv()
self.assertEqual(tuple(vvx),
((1, 0.0), (4, 1.0), (7, 2.0), (10, 3.0), (13, 4.0)))
self.assertEqual(tuple(vvy),
((2, 0.0), (5, 1.0), (8, 2.0), (11, 3.0), (14, 4.0)))
self.assertEqual(tuple(vvz), ((5.0, 0.0), (5.0, 1.0), (5.0, 2.0),
(5.0, 3.0), (5.0, 4.0)))
pps = []
for xyz in lpp:
pps.append(gxgeo.Point(xyz))
pp = gxgeo.PPoint(pps)
verify()
e = pp.extent
self.assertTrue(e[0] == gxgeo.Point((1, 2, 3)))
self.assertTrue(e[1] == gxgeo.Point((13, 14, 15)))
def test_string(self):
self.start()
l = [1, 2, 3]
with gxvv.GXvv(l, dtype='U2') as vv:
self.assertEqual(list(vv.np), ['1', '2', '3'])
# Since we are using UTF-8 internally characters can take anywhere between 1 and 4 bytes.
# Specifying a numpy dtype to instantiate VV will ensure the internal space is enough to allocate up to
# that 4 times the Unicode characters, however any Numpy arrays will limit the characters to the passed dtype.
l = [1, 2, "abcdefghijklmnopqrstuvxyz"]
with gxvv.GXvv(l, dtype='U4') as vv:
self.assertEqual(list(vv.np), ['1', '2', 'abcd'])
# The following 4-byte UTF-8 characters can be correctly extracted (to limits of what is specified).
# Characters from http://www.i18nguy.com/unicode/supplementary-test.html
l = [1, 2, "𠜎𠜱𠝹𠱓𠱸𠲖"]
with gxvv.GXvv(l, dtype='U4') as vv:
self.assertEqual(list(vv.np), ['1', '2', '𠜎𠜱𠝹𠱓'])
with gxvv.GXvv(l, dtype='U2') as vv:
self.assertEqual(list(vv.np), ['1', '2', '𠜎𠜱'])
def test_iterator(self):
self.start()
with gxvv.GXvv(range(1000)) as vv:
l2 = [v for v in vv]
self.assertEqual(len(l2), 1000)
self.assertEqual(l2[0], (0., 0))
self.assertEqual(l2[999], (999., 999))
vvlist = vv.list()
self.assertEqual(len(vvlist), 1000)
self.assertEqual(vvlist[0], 0.0)
self.assertEqual(vvlist[999], 999.)
def test_ppoint_constructors(self):
self.start(gsys.func_name())
def verify():
self.assertEqual(pp.x.tolist(), [1., 4., 7., 10., 13.])
self.assertEqual(pp.z.tolist(), [3., 6., 9., 12., 15.])
self.assertEqual(pp.xy.tolist(), nppp[:, :2].tolist())
lpp = ((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12), (13, 14, 15))
nppp = np.array(lpp)
pp = gxgm.PPoint(lpp)
verify()
nppp = np.array(lpp)
pp = gxgm.PPoint(nppp)
verify()
vvx = gxvv.GXvv(nppp[:, 0])
vvy = gxvv.GXvv(nppp[:, 1])
vvz = gxvv.GXvv(nppp[:, 2])
pp = gxgm.PPoint((vvx, vvy, vvz))
verify()
def test_vv(self):
self.start()
max = gxapi.iMAX // 16
npdata = np.empty(max)
with gxvv.GXvv(npdata) as vv:
self.assertTrue(vv.length, max)
del npdata
gc.collect()
npdata = np.empty(gxapi.iMAX + 1)
self.assertRaises(gxvv.VVException, gxvv.GXvv, npdata)
del npdata
gc.collect()
def make_int32_grid():
# create an int32 grid
img = gxapi.GXIMG.create_new_file(3, 1, 50, 20, 'test.grd')
# read 10 row, test that it is dummy
vv = gxvv.GXvv(dtype=int)
img.read_v(10, 0, 0, vv.gxvv)
self.assertEqual(vv[10][0], gxapi.GS_S4DM)
# fill 10'th row with 1, test that it is 1.
vv.fill(1)
img.write_v(10, 0, 0, vv.gxvv)
img.read_v(10, 0, 0, vv.gxvv)
self.assertEqual(vv[10][0], 1)
# OK, grid is as expected, close
img = None
verts = verts[faces].reshape(-1, 3)
vx, vy, vz = gxvv.vvset_from_np(verts)
vf1, vf2, vf3 = gxvv.vvset_from_np(faces)
normals = gxg.vertex_normals_np(faces, verts)
nx, ny, nz = gxvv.vvset_from_np(normals[faces].reshape(-1, 3))
# using a constant color does not complain
v3d.gxview.draw_surface_3d_ex('test', vx.gxvv, vy.gxvv, vz.gxvv,
nx.gxvv, ny.gxvv, nz.gxvv,
gxapi.GXVV.null(), gxg.C_GREY, vf1.gxvv,
vf2.gxvv, vf3.gxvv,
v3d.coordinate_system.gxipj)
# using an array color raises invalid number of colour if we pass colours/vertex
color = np.array([gxg.C_GREY for i in range(vx.length)])
color_vv = gxvv.GXvv(color, dtype=np.int32)
try:
v3d.gxview.draw_surface_3d_ex('test2', vx.gxvv, vy.gxvv, vz.gxvv,
nx.gxvv, ny.gxvv, nz.gxvv,
color_vv.gxvv, gxg.C_GREY, vf1.gxvv,
vf2.gxvv, vf3.gxvv,
v3d.coordinate_system.gxipj)
except gxapi.GXAPIError as e:
print(str(e))
# and if pass colours/face it asserts
color = np.array([gxg.C_GREY for i in range(faces.shape[0])])
color_vv = gxvv.GXvv(color, dtype=np.int32)
v3d.gxview.draw_surface_3d_ex('test2', vx.gxvv, vy.gxvv, vz.gxvv,
nx.gxvv, ny.gxvv, nz.gxvv,
def test_np(self):
self.start(gsys.func_name())
fid = (99, 0.1)
npdata = np.array([1, 2, 3, 4, 5, 6, 7])
with gxvv.GXvv(npdata, fid=fid) as vv:
self.assertEqual(vv.fid, fid)
self.assertEqual(vv.length, len(npdata))
np2 = vv.get_np(vv.dtype)
self.assertEqual(np2[0].shape, (7, ))
np2, fid2 = vv.get_np(vv.dtype, start=1)
self.assertEqual(fid2, (99.1, .1))
self.assertEqual(np2.shape, (6, ))
self.assertEqual(vv.get_np(vv.dtype, start=6)[0].shape, (1, ))
self.assertRaises(gxvv.VVException, vv.get_np, vv.dtype, start=7)
np3, fid3 = vv.get_np(np.int)
self.assertEqual(fid3, fid)
self.assertEqual(np3[0], 1)
self.assertEqual(np3[6], 7)
self.assertEqual(vv.get_float(6), 7.0)
self.assertEqual(vv.get_int(6), 7)
self.assertEqual(vv.get_string(6), "7")
npdata = np.array([1, 2, 3, 4, 5, 6, 7], dtype=np.int)
with gxvv.GXvv(npdata, fid=fid) as vv:
np3 = vv.get_np(dtype=np.int64)
self.assertEqual(np3[0][0], 1)
self.assertEqual(np3[0][6], 7)
np3 = vv.get_np(np.float)
self.assertEqual(np3[0][0], 1.)
self.assertEqual(np3[0][6], 7.)
vv.set_np(np.array([4, 5, 6, 7], dtype=np.int))
np3, fid = vv.get_np(dtype=np.int64)
self.assertEqual(len(np3), 4)
self.assertEqual(np3[0], 4)
self.assertEqual(np3[3], 7)
np3, fid = vv.get_np(np.float)
self.assertEqual(np3[0], 4.)
self.assertEqual(np3[3], 7.)
npdata = np.array(['4', '5', '6', '7'])
vv3 = gxvv.GXvv(npdata, fid=fid)
np3, fid = vv3.get_np()
self.assertEqual(len(np3), 4)
self.assertEqual(np3[0], '4')
self.assertEqual(np3[3], '7')
np3, fid = vv.get_np(np.float)
self.assertEqual(np3[0], 4.)
self.assertEqual(np3[3], 7.)
npdata = np.array(['4000', '50', '60', '-70'])
vv3 = gxvv.GXvv(npdata, fid=fid)
np3, fid = vv3.get_np()
self.assertEqual(len(np3), 4)
self.assertEqual(np3[0], '4000')
self.assertEqual(np3[3], '-70')
np3, fid = vv3.get_np(np.float)
self.assertEqual(np3[0], 4000.)
self.assertEqual(np3[3], -70.)
def test_mesh(self):
self.start()
v = list(np.array(range(27), dtype=np.float).reshape(-1, 3))
f = list(np.array(range(len(v))).reshape(-1, 3))
m = gxgeo.Mesh((f, v))
self.assertEqual(len(m.faces), len(f))
self.assertEqual(len(m.verticies), len(v))
self.assertEqual(tuple(m[2][2]), (24., 25., 26.))
self.assertEqual(tuple(m.extent_minimum), (0, 1, 2))
m2 = m + 1.5
self.assertEqual(tuple(m2[2][2]), (25.5, 26.5, 27.5))
self.assertEqual(tuple(m2.extent_minimum), (1.5, 2.5, 3.5))
m2 = m2 - 1.5
self.assertEqual(tuple(m2[2][2]), (24., 25., 26.))
self.assertEqual(tuple(m2.extent_minimum), (0, 1, 2))
m2 = m + (1, 10, 50)
self.assertEqual(tuple(m2[2][2]), (25., 35., 76.))
self.assertEqual(tuple(m2.extent_minimum), (1, 11, 52))
m2 = m2 - (1, 10, 50)
self.assertEqual(tuple(m2[2][2]), (24., 25., 26.))
self.assertEqual(tuple(m2.extent_minimum), (0, 1, 2))
m2 = m + (m + (1, 10, 50))
self.assertEqual(tuple(m2.extent_maximum), (25., 35., 76.))
self.assertEqual(m2.extent_maximum_xyz, (25., 35., 76.))
self.assertEqual(m2.extent_minimum_xyz, (0, 1, 2))
self.assertEqual(m2.extent_maximum_xy, (25., 35.))
self.assertEqual(m2.extent_minimum_xy, (0, 1))
self.assertEqual(m2.centroid_xyz, (12.5, 18.0, 39.0))
self.assertEqual(m2.centroid_xy, (12.5, 18.0))
self.assertEqual(len(m2), 2 * len(m))
mm = gxgeo.Mesh((np.append(m2.faces, m2.faces, axis=0), m2.verticies))
self.assertEqual(len(mm), 12)
self.assertEqual(len(mm.verticies), 18)
mp = mm.point_array()
self.assertEqual(len(mp), 18)
mp = mm.point_array(unique=False)
self.assertEqual(len(mp), 36)
v = np.array(v)
v[:, 0] += 500000
v[:, 1] += 6000000
m = gxgeo.Mesh((f, v), coordinate_system="NAD83 / UTM zone 17N")
m = gxgeo.Mesh(m, coordinate_system="NAD27 / UTM zone 17N")
self.assertEqual(str(m.coordinate_system), "NAD27 / UTM zone 17N")
self.assertEqual(tuple(m[2][2]),
(500006.87887296296, 5999802.6514122421, 26.0))
m83 = gxgeo.Mesh(m, coordinate_system="NAD83 / UTM zone 17N")
self.assertEqual(m83.coordinate_system, "NAD83 / UTM zone 17N")
self.assertEqual(tuple(m[2][2]),
(500006.87887296296, 5999802.6514122421, 26.0))
self.assertEqual(tuple(m83[2][2]),
(500024.00010005565, 6000025.0009018015, 26.0))
f = np.array(f)
f1vv = gxvv.GXvv(f[:, 0])
f2vv = gxvv.GXvv(f[:, 1])
f3vv = gxvv.GXvv(f[:, 2])
xvv = gxvv.GXvv(v[:, 0])
yvv = gxvv.GXvv(v[:, 1])
zvv = gxvv.GXvv(v[:, 2])
m = gxgeo.Mesh(((f1vv, f2vv, f3vv), (xvv, yvv, zvv)),
coordinate_system="NAD83 / UTM zone 17N",
name='vv')
self.assertEqual(m.name, 'vv')
mm = gxgeo.Mesh(m, coordinate_system="NAD27 / UTM zone 17N")
self.assertEqual(mm.name, '_mesh_')
m2 = gxgeo.Mesh(mm,
coordinate_system="NAD27 / UTM zone 17N",
name='vv_copy')
self.assertEqual(m2.name, 'vv_copy')
self.assertEqual(str(m2.coordinate_system), "NAD27 / UTM zone 17N")
self.assertEqual(tuple(m2[2][2]),
(500006.87887296296, 5999802.6514122421, 26.0))
self.assertEqual(str(m2), 'vv_copy(3 faces)')
self.assertTrue(mm == m2)
self.assertEqual(len(list(m2)), 3)
self.assertFalse(m == m2)
m3 = m + m2
self.assertEqual(len(m3), 6)
self.assertEqual(m3.length, 6)
f1vv, f2vv, f3vv = m3.faces_vv()
self.assertEqual(tuple(f1vv.np), (0, 3, 6, 9, 12, 15))
self.assertEqual(tuple(f2vv.np), (1, 4, 7, 10, 13, 16))
self.assertEqual(tuple(f3vv.np), (2, 5, 8, 11, 14, 17))
xvv, yvv, zvv = m3.verticies_vv()
self.assertEqual(tuple(xvv.np[:3]), (500000.0, 500003.0, 500006.0))
self.assertEqual(tuple(yvv.np[:3]), (6000001.0, 6000004.0, 6000007.0))
self.assertEqual(tuple(zvv.np[:3]), (2.0, 5.0, 8.0))
def test_strings(self):
self.start()
fidvv = (99, 0.1)
npdata = np.array(["name", "maki", "neil", "rider"])
with gxvv.GXvv(npdata, fid=fidvv) as vv:
self.assertTrue(vv.is_string)
self.assertFalse(vv.is_int)
self.assertFalse(vv.is_float)
self.assertEqual(vv.fid, fidvv)
self.assertEqual(vv.length, len(npdata))
self.assertEqual(vv.gxtype, -20)
self.assertTrue(vv.dtype.type is np.str_)
self.assertEqual(str(vv.dtype), '<U5')
npd, fid = vv.get_data(vv.dtype)
self.assertEqual(npd[0], "name")
self.assertEqual(npd[1], "maki")
self.assertEqual(npd[2], "neil")
self.assertEqual(npd[3], "rider")
npd, fid = vv.get_data(vv.dtype, start=2, n=2)
self.assertEqual(npd[0], "neil")
self.assertEqual(npd[1], "rider")
self.assertEqual(fid, (99.2, 0.1))
vv.fill(2.5)
self.assertEqual(vv[0][0], '2.5')
self.assertEqual(vv[len(vv) - 1][0], '2.5')
npdata = np.array(["1", "2", "3", "4000", "*"])
with gxvv.GXvv(npdata, fid=fid) as vv:
npd, fid = vv.get_data(np.float)
self.assertEqual(npd[0], 1.0)
self.assertEqual(npd[1], 2.0)
self.assertEqual(npd[2], 3.0)
self.assertEqual(npd[3], 4000.0)
self.assertTrue(np.isnan(npd[4]))
npdata = np.array(["1", "2", "3", "4000", "40000", "*"])
with gxvv.GXvv(npdata, fid=fid) as vv:
npd, fid = vv.get_data(np.int)
self.assertEqual(npd[0], 1)
self.assertEqual(npd[1], 2)
self.assertEqual(npd[2], 3)
self.assertEqual(npd[3], 4000)
self.assertEqual(npd[4], 40000)
self.assertEqual(npd[5], gxapi.iDUMMY)
with gxvv.GXvv(npdata, fid=fid, dtype=np.float) as vv:
npd, fid = vv.get_data(np.int)
self.assertEqual(npd[0], 1)
self.assertEqual(npd[1], 2)
self.assertEqual(npd[2], 3)
self.assertEqual(npd[3], 4000)
self.assertEqual(npd[4], 40000)
self.assertEqual(npd[5], gxapi.iDUMMY)
npd, fid = vv.get_data(np.int32)
self.assertEqual(npd[5], gxapi.GS_S4DM)
npd, fid = vv.get_data(np.int64)
self.assertEqual(npd[5], gxapi.GS_S8DM)
npd, fid = vv.get_data(np.float)
self.assertTrue(np.isnan(npd[5]))
npd, fid = vv.get_data(np.float32)
self.assertTrue(np.isnan(npd[5]))
npd, fid = vv.get_data(np.float64)
self.assertTrue(np.isnan(npd[5]))
with gxvv.GXvv(npdata, fid=fid, dtype=np.float32) as vv:
npd, fid = vv.get_data(np.float)
self.assertTrue(np.isnan(npd[5]))
npd, fid = vv.get_data(np.float32)
self.assertTrue(np.isnan(npd[5]))
npd, fid = vv.get_data(np.float64)
self.assertTrue(np.isnan(npd[5]))
with gxvv.GXvv(npdata, fid=fid, dtype=np.int64) as vv:
npd, fid = vv.get_data(np.float)
self.assertTrue(np.isnan(npd[5]))
npdata = np.array(["1", "2", "3", "4000", "40000", "*"])
with gxvv.GXvv(npdata, fid=fid) as vv:
npd, fid = vv.get_data(np.int, start=2, n=3)
self.assertEqual(npd[0], 3)
self.assertEqual(npd[1], 4000)
self.assertEqual(npd[2], 40000)
npdata = np.array(["make_it_big enough"])
with gxvv.GXvv(npdata, fid=fid) as vv:
npd, fid = vv.get_data(np.int, start=0, n=1)
self.assertEqual(npd[0], gxapi.iDUMMY)
npdata = np.array([1., 2., -30., -87.66662])
vv.set_data(npdata)
npd, fid = vv.get_data(start=0, n=4)
self.assertEqual(npd[0], "1.0")
self.assertEqual(npd[2], "-30.0")
self.assertEqual(npd[3], "-87.66662")
npdata = np.array([1, 2, 3])
with gxvv.GXvv(npdata, fid=fid) as vv:
npd = vv.np
self.assertEqual(npd[1], 2)
npdata = np.array([1., 2., -30., -87.66662])
vv.set_data(npdata)
npd, fid = vv.get_data(start=0, n=4)
self.assertEqual(npd[0], 1)
self.assertEqual(npd[2], -30)
self.assertEqual(npd[3], -88)
def test_init_len(self):
self.start()
with gxvv.GXvv(dtype=np.float, len=10) as vv:
self.assertEqual(vv.length, 10)
def test_np(self):
self.start()
fid = (99, 0.1)
npdata = np.array([1, 2, 3, 4, 5, 6, 7])
with gxvv.GXvv(npdata, fid=fid) as vv:
self.assertEqual(vv.fid, fid)
self.assertEqual(vv.length, len(npdata))
np2 = vv.get_data(vv.dtype)
self.assertEqual(np2[0].shape, (7, ))
np2, fid2 = vv.get_data(vv.dtype, start=1)
self.assertEqual(fid2, (99.1, .1))
self.assertEqual(np2.shape, (6, ))
self.assertEqual(vv.get_data(vv.dtype, start=6)[0].shape, (1, ))
self.assertRaises(gxvv.VVException, vv.get_data, vv.dtype, start=7)
np3, fid3 = vv.get_data(np.int)
self.assertEqual(fid3, fid)
self.assertEqual(np3[0], 1)
self.assertEqual(np3[6], 7)
self.assertEqual(float(vv.np[6]), 7.0)
self.assertEqual(int(vv.np[6]), 7)
self.assertEqual(str(vv.np[6]), "7")
npdata = np.array([1, 2, 3, 4, 5, 6, 7], dtype=np.int)
with gxvv.GXvv(npdata, fid=fid) as vv:
np3 = vv.get_data(dtype=np.int64)
self.assertEqual(np3[0][0], 1)
self.assertEqual(np3[0][6], 7)
np3 = vv.get_data(np.float)
self.assertEqual(np3[0][0], 1.)
self.assertEqual(np3[0][6], 7.)
vv.set_data(np.array([4, 5, 6, 7], dtype=np.int))
np3, fid = vv.get_data(dtype=np.int64)
self.assertEqual(len(np3), 4)
self.assertEqual(np3[0], 4)
self.assertEqual(np3[3], 7)
np3, fid = vv.get_data(np.float)
self.assertEqual(np3[0], 4.)
self.assertEqual(np3[3], 7.)
npdata = np.array(['4', '5', '6', '7'])
with gxvv.GXvv(npdata, fid=fid) as vv3:
np3, fid = vv3.get_data()
self.assertEqual(len(np3), 4)
self.assertEqual(np3[0], '4')
self.assertEqual(np3[3], '7')
np3, fid = vv3.get_data(np.float)
self.assertEqual(np3[0], 4.)
self.assertEqual(np3[3], 7.)
npdata = np.array(['4000', '50', '60', '-70'])
with gxvv.GXvv(npdata, fid=fid) as vv3:
self.assertTrue(vv3.is_string)
self.assertFalse(vv3.is_int)
self.assertFalse(vv3.is_float)
npf = vv3.np
self.assertEqual(len(npf), 4)
self.assertEqual(npf[0], '4000')
self.assertEqual(npf[3], '-70')
npf, fid = vv3.get_data(np.float)
self.assertEqual(npf[0], 4000.)
self.assertEqual(npf[3], -70.)
self.assertEqual(vv3.min_max(), (-70., 4000.))
with gxvv.GXvv(['maki', 'bob']) as vv:
self.assertEqual(vv.min_max(), (None, None))
self.assertEqual(gxvv.GXvv(['*', 1]).min_max(), (1., 1.))
