def test_270degRotation3D(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((4, 2))
highResCellGrid[3, :] = 0
highResCellGrid[1, 1] = 0
xs = np.array(range(2)) + xoff
ys = np.array(range(4)) + yoff
highResCellGrid = np.dstack(
(highResCellGrid, highResCellGrid, highResCellGrid))
freqs = np.array([.1, .2, .3])
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid, freqs=freqs)
lowresDx = 1.3
lowresDy = 3.3
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
direction = 290. / 180. * np.pi
trfrm = abFirstOctantTransformation(hiResAlphaMtx, cellPoly)
rtheta, rmtx, rcell = trfrm.transform(direction)
if plotResults:
plot('original', hiResAlphaMtx, direction)
plot('transformed', rmtx, rtheta)
plt.show()
expdir = 20. / 180. * np.pi
self.assertAlmostEqual(expdir, rtheta)
crds = list(cellPoly.boundary.coords)
expcoord = [(-c[1], c[0]) for c in crds]
rcellcoord = list(rcell.boundary.coords)
for ec, rc in zip(expcoord, rcellcoord):
self.assertAlmostEqual(ec, rc)
expalpha = highResCellGrid.transpose((1, 0, 2))
exprtmtx = alphaMtx(-ys, xs, expalpha, freqs=freqs)
exprtmtx.polygon = rcell
self.assertTrue(np.allclose(exprtmtx.alphas, rmtx.alphas))
self.assertIs(exprtmtx.polygon, rmtx.polygon)
self.assertTrue(np.allclose(exprtmtx.xs, rmtx.xs))
self.assertTrue(np.allclose(exprtmtx.ys, rmtx.ys))
self.assertEqual(exprtmtx.hasFreqs, rmtx.hasFreqs)
self.assertIs(freqs, rmtx.freqs)
def test3(self):
xoff = 30.
yoff = 40.
highResCellGrid = np.ones((5, 4))
highResCellGrid[0, 0] = 0
highResCellGrid[1, 1] = 0
highResCellGrid[2, 2] = 0
highResCellGrid[4, 3] = 0
xs = np.array(range(4)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
lowresDx = 4
lowresDy = 5
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
betaEst = be(cellPoly, hiResAlphaMtx, maxSubSections=100000)
dr = np.arctan(.5)
beta = betaEst.computeBeta(dr, .1)
expbeta = rotatingTestBeta
self.assertAlmostEqual(expbeta, beta, delta=.0001)
def test2(self):
xoff = 30.
yoff = 40.
highResCellGrid = np.ones((5, 4))
highResCellGrid[0, 0] = 0
highResCellGrid[1, 1] = 0
highResCellGrid[2, 2] = 0
highResCellGrid[4, 3] = 0
xs = np.array(range(4)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
lowresDx = 4
lowresDy = 5
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
betaEst = be(cellPoly, hiResAlphaMtx)
dr = np.pi / 4.
beta = betaEst.computeBeta(dr, .1)
expbeta = 0.72105087014725577
self.assertAlmostEqual(expbeta, beta, delta=.0001)
def test_concavePolygon(self):
xoff = 30.
yoff = 40.
highResCellGrid = np.ones((5, 4))
highResCellGrid[2, 1] = 0
xs = np.array(range(4)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
lowresDx = 4
lowresDy = 5
vrtxxs = np.array([1., 3., 3., 1., 1., 2., 2., 1., 1.]) + xoff
vrtxys = np.array([1., 1., 4., 4., 2.75, 2.75, 2.25, 2.25, 1.]) + yoff
cellPolyVrtxs = [[c[0], c[1]] for c in zip(vrtxxs, vrtxys)]
cellPoly = g.Polygon(cellPolyVrtxs)
hiResAlphaMtx.polygon = cellPoly
betaEst = be(cellPoly, hiResAlphaMtx)
dr = np.arctan(.5)
beta = betaEst.computeBeta(dr, .1)
expbeta = 0.67258992805755391
self.assertAlmostEqual(expbeta, beta, delta=.0001)
def test1(self):
xoff = 30.
yoff = 40.
highResCellGrid = np.ones((5, 4))
highResCellGrid[0, 0] = 0
highResCellGrid[1, 1] = 0
highResCellGrid[2, 2] = 0
highResCellGrid[4, 3] = 0
xs = np.array(range(4)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
lowresDx = 4
lowresDy = 5
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
betaEst = be(cellPoly, hiResAlphaMtx)
dr = 0
beta = betaEst.computeBeta(dr, .1)
alpha1 = .8
alpha2 = .6
alpha3 = .4
alpha4 = .2
expbeta = (alpha1 + alpha2 + alpha3 + alpha4) / 4
self.assertAlmostEqual(expbeta, beta, delta=.0001)
def test_forthQuarter(self):
xoff = 30.
yoff = 40.
highResCellGrid = np.ones((5, 4))
highResCellGrid[0, 0] = 0
highResCellGrid[1, 1] = 0
highResCellGrid[2, 2] = 0
highResCellGrid[4, 3] = 0
highResCellGrid = highResCellGrid.transpose()
highResCellGrid = highResCellGrid[:, ::-1]
xs = np.array(range(5)) + xoff
ys = np.array(range(4)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
lowresDx = 5
lowresDy = 4
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
betaEst = be(cellPoly, hiResAlphaMtx)
dr = np.arctan(-2.) + np.pi
beta = betaEst.computeBeta(dr, .1)
expbeta = rotatingTestBeta
self.assertAlmostEqual(expbeta, beta, delta=.0001)
def test2(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((4, 2))
highResCellGrid[0, :] = 0
highResCellGrid[2, 1] = 0
xs = np.array(range(2)) + xoff
ys = np.array(range(4)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
lowresDx = 1.3
lowresDy = 3.3
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
alphaEst = ae(cellPoly, hiResAlphaMtx)
direction = -20. / 180. * np.pi
alpha = alphaEst.computeAlpha(direction, .1)
self.assertTrue(alpha > 0)
obstrE = (2. + .3 * abs(np.tan(direction))) * abs(np.cos(direction))
obstrN = 1.3 * abs(np.sin(direction))
expalpha = 1 - (obstrE + obstrN) / (1.3 * abs(np.sin(direction)) +
3.3 * abs(np.cos(direction)))
self.assertAlmostEqual(expalpha, alpha, delta=.001)
def testConcavePolygonDoubleIntersectionHiResCell(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((5, 5))
highResCellGrid[1, 2] = 0
xs = np.array(range(5)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
xvtxs = [21., 22.25, 22.25, 22.75, 22.75, 24., 24., 21., 21.]
yvtxs = [11., 11., 12., 12., 11., 11., 13., 13., 11.]
xyvtxs = [xy for xy in zip(xvtxs, yvtxs)]
cellPoly = g.Polygon(xyvtxs)
hiResAlphaMtx.polygon = cellPoly
alphaEst = ae(cellPoly, hiResAlphaMtx)
direction = np.pi / 2
alpha = alphaEst.computeAlpha(direction, .1)
self.assertTrue(alpha > 0)
expalpha = 2.5 / 3.
self.assertAlmostEqual(expalpha, alpha, delta=0.001)
def testConcavePolygon1(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((5, 5))
highResCellGrid[1, 1] = 0
highResCellGrid[1, 3] = 0
xs = np.array(range(5)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
xvtxs = [21., 22., 22., 23., 23., 24., 24., 21., 21.]
yvtxs = [11., 11., 12., 12., 11., 11., 13., 13., 11.]
xyvtxs = [xy for xy in zip(xvtxs, yvtxs)]
cellPoly = g.Polygon(xyvtxs)
hiResAlphaMtx.polygon = cellPoly
alphaEst = ae(cellPoly, hiResAlphaMtx)
direction = np.arctan(2)
alpha = alphaEst.computeAlpha(direction, .1)
self.assertTrue(alpha > 0)
trndir = np.arctan(.5)
obstrE = 2. * np.cos(trndir)
obstrN = 2. * np.sin(trndir)
expalpha = 1 - (obstrE + obstrN) / (2. * abs(np.sin(trndir)) +
3. * abs(np.cos(trndir)))
self.assertAlmostEqual(expalpha, alpha, delta=0.001)
def testPentagonalCell1(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((5, 5))
highResCellGrid[1, 3] = 0
highResCellGrid[2, 1] = 0
highResCellGrid[3, 2] = 0
xs = np.array(range(5)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
xvtxs = [21.5, 22., 23.5, 23., 22.5]
yvtxs = [12.5, 12., 11.5, 13., 13.5]
xyvtxs = [xy for xy in zip(xvtxs, yvtxs)]
cellPoly = g.Polygon(xyvtxs)
hiResAlphaMtx.polygon = cellPoly
alphaEst = ae(cellPoly, hiResAlphaMtx)
direction = np.arctan(.5)
alpha = alphaEst.computeAlpha(direction, .1)
self.assertTrue(alpha > 0)
#total cross section of the cell with respect to direction:
ltot = (5.)**.5
#transparent section of the cell:
ltrs = (1. / 5.)**.5
expalpha = ltrs / ltot
self.assertAlmostEqual(expalpha, alpha, delta=0.001)
def testPentagonalCell(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((5, 5))
highResCellGrid[1, 3] = 0
highResCellGrid[2, 1] = 0
highResCellGrid[3, 2] = 0
xs = np.array(range(5)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
xvtxs = [21.5, 22., 23.5, 23., 22.5]
yvtxs = [12.5, 12., 11.5, 13., 13.5]
xyvtxs = [xy for xy in zip(xvtxs, yvtxs)]
cellPoly = g.Polygon(xyvtxs)
hiResAlphaMtx.polygon = cellPoly
alphaEst = ae(cellPoly, hiResAlphaMtx)
direction = np.pi / 4.
alpha = alphaEst.computeAlpha(direction, .1)
self.assertTrue(alpha > 0)
expalpha = 1. / 3.
self.assertAlmostEqual(expalpha, alpha, delta=0.001)
def testTriangularCell(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((5, 5))
highResCellGrid[1, 3] = 0
highResCellGrid[2, 1] = 0
highResCellGrid[3, 2] = 0
xs = np.array(range(5)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
xvtxs = [23.5, 24., 22.]
yvtxs = [11., 13., 14]
xyvtxs = [xy for xy in zip(xvtxs, yvtxs)]
cellPoly = g.Polygon(xyvtxs)
hiResAlphaMtx.polygon = cellPoly
alphaEst = ae(cellPoly, hiResAlphaMtx)
direction = np.pi / 4.
alpha = alphaEst.computeAlpha(direction, .1)
self.assertTrue(alpha > 0)
obstrE = 1.5 * np.cos(direction)
obstrN = 2. * np.sin(direction)
expalpha = 1 - (obstrE + obstrN) / (2.5 * abs(np.sin(direction)) +
2. * abs(np.cos(direction)))
self.assertAlmostEqual(expalpha, alpha, delta=0.001)
def testDifferentHighResDxDy_quadrant4(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((4, 2))
highResCellGrid[0, :] = 0
highResCellGrid[2, 1] = 0
highResCellGrid = highResCellGrid.transpose()[::-1, ::-1]
xs = np.array(range(4)) * .5 + xoff
ys = np.array(range(2)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
lowresDy = 1.3
lowresDx = 3.3 * .5
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
alphaEst = ae(cellPoly, hiResAlphaMtx)
direction = 20. / 180. * np.pi + np.pi * 3. / 2.
alpha = alphaEst.computeAlpha(direction, .1)
self.assertTrue(alpha > 0)
turneddir = 20. / 180. * np.pi
obstrE = (.65 + 2.3 * np.tan(turneddir)) * np.cos(turneddir)
obstrN = 0.
expalpha = 1 - (obstrE + obstrN) / (1.3 * abs(np.sin(turneddir)) +
3.3 * .5 * abs(np.cos(turneddir)))
self.assertAlmostEqual(expalpha, alpha, delta=0.001)
def test0radiants(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((5, 5))
highResCellGrid[1, 3] = 0.
highResCellGrid[2, 1] = 0.
highResCellGrid[3, 2] = 0.
xs = np.array(range(5)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
lowresDx = 5
lowresDy = 5
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
alphaEst = ae(cellPoly, hiResAlphaMtx)
direction = 0.
alpha = alphaEst.computeAlpha(direction, .1)
self.assertTrue(alpha > 0)
expalpha = 2. / 5.
self.assertEqual(expalpha, alpha, .001)
def testMultipleOverlaps(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((5, 5))
highResCellGrid[1, 1] = 0
highResCellGrid[1, 3] = 0
highResCellGrid[2, 1] = 0
highResCellGrid[2, 2] = 0
highResCellGrid[3, 2] = 0
highResCellGrid[3, 3] = 0
xs = np.array(range(5)) + xoff
ys = np.array(range(5)) + yoff
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid)
lowresDx = 5
lowresDy = 5
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
alphaEst = ae(cellPoly, hiResAlphaMtx)
direction = math.atan(.5)
alpha = alphaEst.computeAlpha(direction, .1)
self.assertTrue(alpha > 0)
obstrE = 3.5 * np.cos(direction)
obstrN = 1. * np.sin(direction)
expalpha = 1 - (obstrE + obstrN) / 5 / (abs(np.sin(direction)) +
abs(np.cos(direction)))
self.assertAlmostEqual(expalpha, alpha, delta=.001)
def test_noTransform2D(self):
xoff = 20.
yoff = 10.
highResCellGrid = np.ones((4, 2))
highResCellGrid[3, :] = 0
highResCellGrid[1, 1] = 0
xs = np.array(range(2)) + xoff
ys = np.array(range(4)) + yoff
freqs = None
hiResAlphaMtx = alphaMtx(xs, ys, highResCellGrid, freqs=freqs)
lowresDx = 1.3
lowresDy = 3.3
cellPoly = g.Polygon(\
[[xoff, yoff], [xoff + lowresDx, yoff],\
[xoff + lowresDx, yoff + lowresDy], [xoff, yoff + lowresDy]])
hiResAlphaMtx.polygon = cellPoly
direction = 20. / 180. * np.pi
trfrm = abFirstOctantTransformation(hiResAlphaMtx, cellPoly)
rtheta, rmtx, rcell = trfrm.transform(direction)
expdir = direction
self.assertAlmostEqual(expdir, rtheta)
expcoord = list(cellPoly.boundary.coords)
rcellcoord = list(rcell.boundary.coords)
for ec, rc in zip(expcoord, rcellcoord):
self.assertAlmostEqual(ec, rc)
exprtmtx = hiResAlphaMtx
self.assertTrue(np.allclose(exprtmtx.alphas, rmtx.alphas))
self.assertIs(exprtmtx.polygon, rmtx.polygon)
self.assertTrue(np.allclose(exprtmtx.xs, rmtx.xs))
self.assertTrue(np.allclose(exprtmtx.ys, rmtx.ys))
self.assertEqual(exprtmtx.hasFreqs, rmtx.hasFreqs)
self.assertIs(freqs, rmtx.freqs)
self.assertTrue(rmtx.xs[0] < rmtx.xs[-1])
self.assertTrue(rmtx.ys[0] < rmtx.ys[-1])
