def setUp(self):
xs = [1, 2, 3]
ys = [2, 0, 7]
holes = [[[(1.5, 2), (2, 3), (1.6, 1.6)],
[(2.1, 4.5), (2.5, 5), (2.3, 3.5)]]]
self.single_poly = Polygons([{'x': xs, 'y': ys, 'holes': holes}])
xs = [1, 2, 3, np.nan, 6, 7, 3]
ys = [2, 0, 7, np.nan, 7, 5, 2]
holes = [[[(1.5, 2), (2, 3), (1.6, 1.6)],
[(2.1, 4.5), (2.5, 5), (2.3, 3.5)]], []]
self.multi_poly = Polygons([{'x': xs, 'y': ys, 'holes': holes}])
self.multi_poly_no_hole = Polygons([{'x': xs, 'y': ys}])
self.distinct_polys = Polygons([{
'x': xs,
'y': ys,
'holes': holes,
'value': 0
}, {
'x': [4, 6, 6],
'y': [0, 2, 1],
'value': 1
}],
vdims='value')
def test_image_contours_filled(self):
img = Image(np.array([[0, 1, 0], [3, 4, 5.], [6, 7, 8]]))
op_contours = contours(img, filled=True, levels=[2, 2.5])
data = [[(0., 0.166667, 2.25), (0.333333, 0.166667, 2.25), (0.333333, 0.2, 2.25), (0., 0.222222, 2.25),
(-0.333333, 0.111111, 2.25), (-0.333333, 0.055556, 2.25), (0., 0.166667, 2.25)]]
polys = Polygons(data, vdims=img.vdims[0].clone(range=(2, 2.5)))
self.assertEqual(op_contours, polys)
def test_image_contours_filled(self):
img = Image(np.array([[0, 1, 0], [3, 4, 5.], [6, 7, 8]]))
op_contours = contours(img, filled=True, levels=[2, 2.5])
data = [[(0., 0.333333, 2), (0.5, 0.3, 2), (0.5, 0.25, 2), (0., 0.25, 2),
(-0.5, 0.08333333, 2), (-0.5, 0.16666667, 2), (0., 0.33333333, 2)]]
polys = Polygons(data, vdims=img.vdims)
self.assertEqual(op_contours, polys)
def square_right(a=1):
a = a / 100.0
b = 1.0 - a
poly_5 = Polygons([rectangle(0, 0, a + b, b + a)]).options(color=col_rect)
poly_6 = Polygons(
[array([[a, 0], [a + b, a], [b, b + a], [0, b],
[a, 0]])]).options(color=col_sq_3)
text_1 = [(a / 2, -0.05, 'a'), (-0.05, b / 2, 'b'), (b / 2, 1.05, 'b'),
(1.05, a / 2, 'a'), (a + b / 2, -0.05, 'b'),
(-0.05, b + a / 2, 'a'), (b + a / 2, 1.05, 'a'),
(1.05, a + b / 2, 'b')]
text_2 = Text((b + a) / 2, (b + a) / 2, 'c\u00b2').options(color='white')
output = (poly_5 * poly_6 * hv.Labels(text_1) * text_2).options(opts)
output = output.relabel("c\u00b2: {}".format(
np.round((a) * 100)**2 + np.round((1 - a) * 100)**2))
return output
def test_image_contours_filled(self):
img = Image(np.array([[0, 1, 0], [3, 4, 5.], [6, 7, 8]]))
op_contours = contours(img, filled=True, levels=[2, 2.5])
ndoverlay = NdOverlay(None, kdims=['Levels'])
data = [[(0., 0.333333), (0.5, 0.3), (0.5, 0.25), (0., 0.25),
(-0.5, 0.08333333), (-0.5, 0.16666667), (0., 0.33333333)]]
ndoverlay[0.5] = Polygons(data,
group='Level',
level=2,
vdims=img.vdims)
self.assertEqual(op_contours, img * ndoverlay)
def square_left(a=1):
# we set a + b = 100 then convert to a + b = 1
a = a / 100.0
b = 1.0 - a
poly_1 = Polygons([rectangle(a, b, b, a),
rectangle(0, 0, a, b)]).options(color=col_rect)
poly_2 = Polygons([rectangle(0, b, a, a),
rectangle(a, 0, b, b)]).options(color=col_sq_1)
poly_3 = Polygons([line(0, 0, a, b), line(a, b, b, a)])
text_1 = [(a / 2, -0.05, 'a'), (-0.05, b / 2, 'b'), (a / 2, 1.05, 'a'),
(1.05, b / 2, 'b'), (a + b / 2, -0.05, 'b'),
(-0.05, b + a / 2, 'a'), (a + b / 2, 1.05, 'b'),
(1.05, b + a / 2, 'a'), (a / 2.5, (b + 0.1 / a) / 2.5, 'c'),
(a + (b - 0.082 / a) / 2, b + a / 2, 'c')]
text_2 = [(a / 2, b + a / 2, 'a\u00b2'), (a + b / 2, b / 2, 'b\u00b2')]
output = (poly_1 * poly_2 * poly_3 * hv.Labels(text_1) *
hv.Labels(text_2).options(text_color='white')).options(opts)
output = output.relabel("a\u00b2: {}".format(np.round((a) * 100)**2),
"b\u00b2: {}".format(np.round((1 - a) * 100)**2))
return output
def test_multi_poly_rasterize(self):
poly = Polygons([{
'x': [0, 1, 2, np.nan, 0, 0, 1],
'y': [0, 1, 0, np.nan, 0, 1, 1]
}],
datatype=['spatialpandas'])
agg = rasterize(poly, width=4, height=4, dynamic=False)
xs = [0.25, 0.75, 1.25, 1.75]
ys = [0.125, 0.375, 0.625, 0.875]
arr = np.array([[1, 1, 1, 1], [1, 1, 1, 0], [1, 1, 1, 0], [1, 1, 0,
0]])
expected = Image((xs, ys, arr), vdims='Count')
self.assertEqual(agg, expected)
def test_polygon_rasterize(self):
poly = Polygons([{
'x': [0, 1, 2],
'y': [0, 1, 0],
'holes': [[[(1.6, 0.2), (1, 0.8), (0.4, 0.2)]]]
}])
agg = rasterize(poly, width=6, height=6, dynamic=False)
xs = [0.166667, 0.5, 0.833333, 1.166667, 1.5, 1.833333]
ys = [0.083333, 0.25, 0.416667, 0.583333, 0.75, 0.916667]
arr = np.array([[1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0]])
expected = Image((xs, ys, arr), vdims='Count')
self.assertEqual(agg, expected)
def test_polygon_rasterize_mean_agg(self):
poly = Polygons([
{'x': [0, 1, 2], 'y': [0, 1, 0], 'z': 2.4},
{'x': [0, 0, 1], 'y': [0, 1, 1], 'z': 3.6}
], vdims='z')
agg = rasterize(poly, width=4, height=4, dynamic=False, aggregator='mean')
xs = [0.25, 0.75, 1.25, 1.75]
ys = [0.125, 0.375, 0.625, 0.875]
arr = np.array([
[ 2.4, 2.4, 2.4, 2.4],
[ 3.6, 2.4, 2.4, np.nan],
[ 3.6, 2.4, 2.4, np.nan],
[ 3.6, 3.6, np.nan, np.nan]])
expected = Image((xs, ys, arr), vdims='z')
self.assertEqual(agg, expected)
def test_polygons_string_signature(self):
polygons = Polygons([], ['a', 'b'])
self.assertEqual(polygons.kdims, [Dimension('a'), Dimension('b')])
class PolygonsTests(ComparisonTestCase):
def setUp(self):
xs = [1, 2, 3]
ys = [2, 0, 7]
holes = [[[(1.5, 2), (2, 3), (1.6, 1.6)], [(2.1, 4.5), (2.5, 5), (2.3, 3.5)]]]
self.single_poly = Polygons([{'x': xs, 'y': ys, 'holes': holes}])
xs = [1, 2, 3, np.nan, 6, 7, 3]
ys = [2, 0, 7, np.nan, 7, 5, 2]
holes = [
[[(1.5, 2), (2, 3), (1.6, 1.6)], [(2.1, 4.5), (2.5, 5), (2.3, 3.5)]],
[]
]
self.multi_poly = Polygons([{'x': xs, 'y': ys, 'holes': holes}])
self.multi_poly_no_hole = Polygons([{'x': xs, 'y': ys}])
self.distinct_polys = Polygons([
{'x': xs, 'y': ys, 'holes': holes, 'value': 0},
{'x': [4, 6, 6], 'y': [0, 2, 1], 'value': 1}], vdims='value')
def test_single_poly_holes_match(self):
self.assertTrue(self.single_poly.interface.has_holes(self.single_poly))
paths = self.single_poly.split(datatype='array')
holes = self.single_poly.interface.holes(self.single_poly)
self.assertEqual(len(paths), len(holes))
self.assertEqual(len(holes), 1)
self.assertEqual(len(holes[0]), 1)
self.assertEqual(len(holes[0][0]), 2)
def test_multi_poly_holes_match(self):
self.assertTrue(self.multi_poly.interface.has_holes(self.multi_poly))
paths = self.multi_poly.split(datatype='array')
holes = self.multi_poly.interface.holes(self.multi_poly)
self.assertEqual(len(paths), len(holes))
self.assertEqual(len(holes), 1)
self.assertEqual(len(holes[0]), 2)
self.assertEqual(len(holes[0][0]), 2)
self.assertEqual(len(holes[0][1]), 0)
def test_multi_poly_no_holes_match(self):
self.assertFalse(self.multi_poly_no_hole.interface.has_holes(self.multi_poly_no_hole))
paths = self.multi_poly_no_hole.split(datatype='array')
holes = self.multi_poly_no_hole.interface.holes(self.multi_poly_no_hole)
self.assertEqual(len(paths), len(holes))
self.assertEqual(len(holes), 1)
self.assertEqual(len(holes[0]), 2)
self.assertEqual(len(holes[0][0]), 0)
self.assertEqual(len(holes[0][1]), 0)
def test_distinct_multi_poly_holes_match(self):
self.assertTrue(self.distinct_polys.interface.has_holes(self.distinct_polys))
paths = self.distinct_polys.split(datatype='array')
holes = self.distinct_polys.interface.holes(self.distinct_polys)
self.assertEqual(len(paths), len(holes))
self.assertEqual(len(holes), 2)
self.assertEqual(len(holes[0]), 2)
self.assertEqual(len(holes[0][0]), 2)
self.assertEqual(len(holes[0][1]), 0)
self.assertEqual(len(holes[1]), 1)
self.assertEqual(len(holes[1][0]), 0)
def test_single_poly_hole_validation(self):
xs = [1, 2, 3]
ys = [2, 0, 7]
with self.assertRaises(DataError):
Polygons([{'x': xs, 'y': ys, 'holes': [[], []]}])
def test_multi_poly_hole_validation(self):
xs = [1, 2, 3, np.nan, 6, 7, 3]
ys = [2, 0, 7, np.nan, 7, 5, 2]
with self.assertRaises(DataError):
Polygons([{'x': xs, 'y': ys, 'holes': [[]]}])
def test_multi_poly_hole_validation(self):
xs = [1, 2, 3, np.nan, 6, 7, 3]
ys = [2, 0, 7, np.nan, 7, 5, 2]
with self.assertRaises(DataError):
Polygons([{'x': xs, 'y': ys, 'holes': [[]]}])
def test_single_poly_hole_validation(self):
xs = [1, 2, 3]
ys = [2, 0, 7]
with self.assertRaises(DataError):
Polygons([{'x': xs, 'y': ys, 'holes': [[], []]}])
def test_multi_poly_empty_holes(self):
poly = Polygons([])
self.assertFalse(poly.interface.has_holes(poly))
self.assertEqual(poly.interface.holes(poly), [])
