def test_meshPlaneClipping():
mesh = loadLargeBunny()
half = pgf.var_float(0.5)
plane = pgf.plane(pgf.vec3(half, half, half), pgf.vec3(half, half, half))
clipped = pgf.clipMesh(mesh, plane)
area = pgf.read(pgf.area(clipped))
nfaces = pgf.read(pgf.numFaces(clipped))
nverts = pgf.read(pgf.numVertices(clipped))
assert tu.equalf(area, 19.79486274)
assert nfaces == 59387
assert nverts == 30013
def test_rectangleMesh():
plane = pgf.plane(pgf.var_vec3((0., 0., 0.)), pgf.var_vec3((1., 1., 0.)))
box = pgf.box2(pgf.var_vec2((0., 0.)), pgf.var_vec2((15., 12.)))
edgeLn = pgf.var_float(1.)
rect = pgf.rectangleMesh(plane, box, edgeLn)
area = pgf.area(rect)
nfaces = pgf.numFaces(rect)
nverts = pgf.numVertices(rect)
assert 360 == pgf.read(nfaces)
assert 208 == pgf.read(nverts)
assert tu.equalf(180., pgf.read(area))
def test_meshSphereQuery():
mesh = pgf.scale(loadSmallBunny(), pgf.var_float(10.0))
zero = pgf.var_float(0.)
center = pgf.vec3(zero, zero, zero)
radius = pgf.var_float(.5)
sphere = pgf.sphere(center, radius)
rmesh, rindices, rcount = pgf.meshSphereQuery(mesh, sphere)
nfaces = pgf.read(rcount)
area = pgf.read(pgf.area(rmesh))
assert tu.equalf(area, 0.4436888098716736)
assert nfaces == 292
def test_flatten():
random.seed(42)
intree = pgf.var_int()
outtree = pgf.flatten(intree)
for _ in range(5):
vals = [[random.randint(23, 234)] for __ in range(10)]
pgf.assign(intree, vals)
expected = [item for subl in vals for item in subl]
assert tu.equal(expected, pgf.read(outtree))
vals = [[[random.randint(23, 234) for __ in range(5)]
for ___ in range(5)] for _____ in range(5)]
pgf.assign(intree, vals)
expected = [item for l0 in vals for l1 in l0 for item in l1]
assert tu.equal(expected, pgf.read(outtree))
def unaryFloatOpTest(expFn, pgfn, minval=0., maxval=9.):
random.seed(42)
x = pgf.var_float()
s = pgfn(x)
for _ in range(20):
vx = random.uniform(minval, maxval)
expected = expFn(vx)
pgf.assign(x, vx)
tu.assertEqualf(expected, pgf.read(s), 1e-3)
vxs = [random.uniform(minval, maxval) for _ in range(20)]
expectedvals = [expFn(v) for v in vxs]
pgf.assign(x, vxs)
tu.assertEqualf(expectedvals, pgf.read(s), 1e-3)
def test_scaleMesh():
mesh = loadLargeBunny()
factor = 10.0
scaled = pgf.scale(mesh, pgf.var_float(factor))
meshes = [mesh, scaled]
areas = [pgf.read(pgf.area(m)) for m in meshes]
volumes = [pgf.read(pgf.volume(m)) for m in meshes]
vcounts = [pgf.read(pgf.numVertices(m)) for m in meshes]
fcounts = [pgf.read(pgf.numFaces(m)) for m in meshes]
assert (abs(areas[1] - pow(factor, 2) * areas[0]) / areas[1]) < 1e-5
assert (abs(volumes[1] - pow(factor, 3) * volumes[0]) / volumes[1]) < 1e-5
assert vcounts[0] == vcounts[1]
assert fcounts[0] == fcounts[1]
def test_graft():
random.seed(42)
intree = pgf.var_int()
out = pgf.graft(intree)
for _ in range(5):
vals = [random.randint(23, 345) for __ in range(10)]
expected = [[v] for v in vals]
pgf.assign(intree, vals)
assert tu.equal(expected, pgf.read(out))
for _ in range(5):
vals = [[random.randint(23, 345) for __ in range(5)]
for ___ in range(5)]
expected = [[[v] for v in vl] for vl in vals]
pgf.assign(intree, vals)
assert tu.equal(expected, pgf.read(out))
def test_closestPointsOnMesh():
mesh = pgf.scale(loadSmallBunny(), pgf.var_float(10.))
inpts = pgf.var_vec3([
(0.359824538230896, -0.012389957904815674, 0.3581507205963135),
(-0.3318827152252197, 0.1699751615524292, 0.7063822150230408),
(0.27124643325805664, -0.14796850085258484, 0.5440048575401306),
(0.2950490713119507, 0.0309564471244812, 1.5690069198608398),
(0.470700740814209, 0.559279203414917, 0.5738930106163025),
(-0.6372849941253662, 0.5158957242965698, 0.9492948055267334),
(-0.42367517948150635, 0.17821109294891357, 0.5325688719749451),
(0.24817490577697754, 0.27643465995788574, 0.5003229975700378),
(-0.5128110647201538, -0.4166657030582428, 1.868307113647461),
(-0.08426868915557861, 0.14360648393630981, 0.6685295104980469)
])
outpts = pgf.closestPoints(mesh, inpts)
expected = [
(0.35241958498954773, -0.022721359506249428, 0.3823484480381012),
(-0.3473210334777832, 0.18098655343055725, 0.6997533440589905),
(0.22252899408340454, -0.13979701697826385, 0.36583301424980164),
(0.1671879142522812, -0.029879290610551834, 1.274683952331543),
(0.22475071251392365, 0.2590671181678772, 0.5857457518577576),
(-0.5479510426521301, 0.21973726153373718, 0.9220386743545532),
(-0.423895001411438, 0.11360426992177963, 0.5336558818817139),
(0.21963083744049072, 0.23689928650856018, 0.5136839151382446),
(-0.6122115254402161, -0.3117043375968933, 1.5369797945022583),
(-0.03959565982222557, 0.34772586822509766, 0.666935384273529)
]
assert tu.equalf(expected, pgf.read(outpts))
def repeatGenericTest(val, pgvarfn, comparefn):
random.seed(42)
count = random.randint(23, 345)
vals = [val for _ in range(count)]
rval = pgvarfn(val)
result = pgf.repeat(rval, pgf.var_int(count))
assert comparefn(vals, pgf.read(result))
def test_listSumFloat():
random.seed(42)
valrange = (22.345, 223.66)
vals = [random.uniform(valrange[0], valrange[1]) for _ in range(25)]
lst = pgf.var_float(vals)
result = pgf.listSum(lst)
assert tu.equalf(sum(vals), pgf.read(result), 1e-3)
def test_listSumInt():
random.seed(42)
valrange = (23, 345)
vals = [random.randint(valrange[0], valrange[1]) for _ in range(25)]
lst = pgf.var_int(vals)
result = pgf.listSum(lst)
assert tu.equal(sum(vals), pgf.read(result))
def test_treeInputs():
random.seed(42)
vals = [[random.randint(23, 345) for _ in range(10)] for _ in range(10)]
rvals = pgf.var_int()
rsum = pgf.treeSum(rvals)
expected = sum([sum(v) for v in vals])
pgf.assign(rvals, vals)
assert tu.equal(expected, pgf.read(rsum))
def test_meshBounds():
assetFiles = ["bunny_large.obj", "bunny.obj"]
fpaths = pgf.var_string("")
pgf.assign(fpaths, [tu.assetPath(a) for a in assetFiles])
meshes = pgf.loadObjFile(fpaths)
bounds = pgf.bounds(meshes)
pmins, pmaxs = pgf.boxPoints(bounds)
vpmins = pgf.read(pmins)
vpmaxs = pgf.read(pmaxs)
assert tu.equalf(
vpmins,
[[-1.8937978744506836, -1.1759940385818481, -0.3402520418167114],
[-0.09438041597604752, -0.058714643120765686, 0.033309899270534515]])
assert tu.equalf(
vpmaxs,
[[1.2201818227767944, 1.2374719381332397, 2.746419906616211],
[0.060778796672821045, 0.061679162085056305, 0.18699601292610168]])
def test_heterogenousTrees():
random.seed(42)
vals1 = [[2], [3]]
vals2 = [4, 5]
expected = [[8, 10], [12, 15]]
rvals1 = pgf.var_int(vals1)
rvals2 = pgf.var_int(vals2)
prod = pgf.mul(rvals1, rvals2)
assert tu.equal(expected, pgf.read(prod))
def listItemGenericTest(vals, pgvarfn, comparefn):
rvals = pgvarfn(vals)
rindex = pgf.var_int()
result = pgf.listItem(rvals, rindex)
random.seed(42)
for _ in range(25):
index = random.randint(0, len(vals) - 1)
pgf.assign(rindex, index)
assert comparefn(vals[index], pgf.read(result))
def binaryFloatOpTest(expFn, pgfn, minval=2., maxval=124.5):
random.seed(42)
a = pgf.var_float()
b = pgf.var_float()
r = pgfn(a, b)
for _ in range(20):
va = random.uniform(minval, maxval)
vb = random.uniform(minval, maxval)
expected = expFn(va, vb)
pgf.assign(a, va)
pgf.assign(b, vb)
assert tu.equalf(expected, pgf.read(r), 1e-3)
vas = [random.uniform(minval, maxval) for _ in range(20)]
vbs = [random.uniform(minval, maxval) for _ in range(20)]
expectedVals = [expFn(va, vb) for va, vb in zip(vas, vbs)]
pgf.assign(a, vas)
pgf.assign(b, vbs)
assert tu.equalf(expectedVals, pgf.read(r), 1e-3)
def binaryIntOpTest(expFn, pgfn, minval=2, maxval=124):
random.seed(42)
a = pgf.var_int()
b = pgf.var_int()
r = pgfn(a, b)
for _ in range(20):
va = random.randint(minval, maxval)
vb = random.randint(minval, maxval)
expected = expFn(va, vb)
pgf.assign(a, va)
pgf.assign(b, vb)
assert tu.equal(expected, pgf.read(r))
vas = [random.randint(minval, maxval) for _ in range(20)]
vbs = [random.randint(minval, maxval) for _ in range(20)]
expectedVals = [expFn(va, vb) for va, vb in zip(vas, vbs)]
pgf.assign(a, vas)
pgf.assign(b, vbs)
assert tu.equal(expectedVals, pgf.read(r))
def test_distance2():
p1 = pgf.var_vec2()
p2 = pgf.var_vec2()
dist = pgf.distance(p1, p2)
for _ in range(20):
val1 = (random.uniform(1.2, 12.5), random.uniform(2.5, 15.6))
val2 = (random.uniform(1.26, 22.5), random.uniform(1.5, 13.9))
dval = math.sqrt(
math.pow(val1[0] - val2[0], 2.) + math.pow(val1[1] - val2[1], 2.))
pgf.assign(p1, val1)
pgf.assign(p2, val2)
assert tu.equalf(pgf.read(dist), dval)
def test_dispatch():
random.seed(42)
valrange = (23, 345)
rvals = pgf.var_int()
rpattern = pgf.var_bool()
rtvals, rfvals = pgf.dispatch(rvals, rpattern)
for _ in range(20):
nItems = 25
vals = [
random.randint(valrange[0], valrange[1]) for _ in range(nItems)
]
pattern = [
random.randint(valrange[0], valrange[1]) % 2 == 0
for _ in range(nItems)
]
tvals = [v for v, p in zip(vals, pattern) if p]
fvals = [v for v, p in zip(vals, pattern) if not p]
pgf.assign(rvals, vals)
pgf.assign(rpattern, pattern)
assert tu.equal(tvals, pgf.read(rtvals))
assert tu.equal(fvals, pgf.read(rfvals))
def test_itemListMapping():
random.seed(42)
singleval = 42
single = pgf.var_int(singleval)
lst = pgf.var_int()
out = pgf.add(single, lst)
for _ in range(10):
vals = list(range(12))
random.shuffle(vals)
expected = [singleval + v for v in vals]
pgf.assign(lst, vals)
assert tu.equal(expected, pgf.read(out))
def test_seriesInt():
random.seed(42)
valrange = (23, 256)
steprange = (2, 9)
valstart = random.randint(valrange[0], valrange[1])
valstep = random.randint(steprange[0], steprange[1])
valcount = random.randint(valrange[0], valrange[1])
valstop = valstart + valstep * valcount
start = pgf.var_int(valstart)
step = pgf.var_int(valstep)
count = pgf.var_int(valcount)
series = pgf.series(start, step, count)
assert tu.equal(range(valstart, valstop, valstep), pgf.read(series))
def test_seriesFloat():
random.seed(42)
valrange = (22.345, 223.66)
steprange = (1.778, 9.56)
valstart = random.uniform(valrange[0], valrange[1])
valstep = random.uniform(steprange[0], steprange[1])
valcount = random.randint(25, 98)
valstop = valstart + valstep * valcount
start = pgf.var_float(valstart)
step = pgf.var_float(valstep)
count = pgf.var_int(valcount)
series = pgf.series(start, step, count)
expected = [(valstart + i * valstep) for i in range(valcount)]
tu.assertEqualf(expected, pgf.read(series), 1e-3)
def test_cachedOffsetDataRegression():
# This tests for a regression (lack of) happened while working on PR # 53.
pt = pgf.var_vec3((0., 0., 0.))
norm = pgf.var_vec3((0., 0., 1.))
plane = pgf.plane(pt, norm)
minpt = pgf.var_vec3((-.5, -.5, 0.))
maxpt = pgf.var_vec3((.5, .5, 0.))
box2 = pgf.box2(pgf.var_vec2((-.5, -.5)), pgf.var_vec2((.5, .5)))
box3 = pgf.box3(minpt, maxpt)
npts = pgf.var_int(4)
cloud = pgf.randomPointsInBox(box3, npts)
edgeLen = pgf.var_float(1)
rect = pgf.rectangleMesh(plane, box2, edgeLen)
distances = pgf.distance(pgf.graft(pgf.vertices(rect)), cloud)
pdists = pgf.read(pgf.flatten(distances))
assert len(pdists) == 16
def test_combinations():
random.seed(42)
valrange = (23, 345)
rvals = pgf.var_int()
rnumc = pgf.var_int()
rcombs = pgf.combinations(rvals, rnumc)
for _ in range(5):
nItems = random.randint(23, 29)
numc = random.randint(3, 5)
vals = [
random.randint(valrange[0], valrange[1]) for _ in range(nItems)
]
combs = list(itertools.combinations(vals, numc))
pgf.assign(rvals, vals)
pgf.assign(rnumc, numc)
assert tu.equal(combs, pgf.read(rcombs))
def test_listLength():
random.seed(42)
valrange = (23, 345)
rvals = pgf.var_int()
rstart = pgf.var_int()
rstop = pgf.var_int()
slist = pgf.subList(rvals, rstart, rstop)
for _ in range(20):
vals = [random.randint(valrange[0], valrange[1]) for _ in range(25)]
irange = (random.randint(0,
len(vals) - 1),
random.randint(0,
len(vals) - 1))
irange = sorted(irange)
expected = vals[irange[0]:irange[1]]
# print(len(vals), irange[0], irange[1])
pgf.assign(rvals, vals)
pgf.assign(rstart, irange[0])
pgf.assign(rstop, irange[1])
tu.assertEqual(expected, pgf.read(slist))
def test_meshCentroid():
mesh = loadLargeBunny()
centroid = pgf.read(pgf.centroid(mesh))
assert tu.equalf(
centroid,
[-0.46018099784851074, -0.17610645294189453, 0.8226389288902283])
def test_meshCentroid():
mesh = loadLargeBunny()
centroid = pgf.read(pgf.centroid(mesh))
assert tu.equalf(
centroid,
[-0.4187779128551483, -0.21727733314037323, 0.7404823899269104])
