def test_multi_segment(self):
'''
what if we break it down into smaller segments?
'''
img = Image(10, 10)
val = int(2 ** 30) # should work
coords = np.linspace(-val, val, 100000)
rev_coords = np.flipud(coords)
diag = np.c_[coords, coords]
bottom = np.c_[rev_coords, np.ones_like(coords) * val]
side = np.c_[np.ones_like(coords) * -val, rev_coords, ]
points = np.r_[diag, bottom, side]
img.draw_polygon(points, line_color='black', fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
print arr
print self.arr
# this is expected to not be equal -- we've found a too-big value
assert np.array_equal(arr, self.arr)
def test_init_simple_add_rgba():
"""
simplest possible initilization -- no preset color palette
"""
img = Image(width=400, height=400, preset_colors=None)
img.add_color('white', (255, 255, 255, 127))
def test_multi_segment(self):
'''
what if we break it down into smaller segments?
'''
img = Image(10, 10)
val = int(2**30) # should work
coords = np.linspace(-val, val, 100000)
rev_coords = np.flipud(coords)
diag = np.c_[coords, coords]
bottom = np.c_[rev_coords, np.ones_like(coords) * val]
side = np.c_[np.ones_like(coords) * -val, rev_coords, ]
points = np.r_[diag, bottom, side]
img.draw_polygon(points,
line_color='black',
fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
print arr
print self.arr
# this is expected to not be equal -- we've found a too-big value
assert np.array_equal(arr, self.arr)
def test_overflow(self):
'''
Big enough to overflow an 32 bit int
'''
img = Image(10, 10)
val = int(2**33)
with pytest.raises(OverflowError):
img.draw_line((-val, -val), (val, val), 'white', line_width=2)
def test_inside(self):
'''just to make sure the comparing is working'''
img = Image(10, 10)
img.draw_line((0, 0), (10, 10), 'white', line_width=2)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.line_arr)
def test_negative(self):
'''negative coords value too large'''
img = Image(10, 10)
img.draw_line((-100, -100), (10, 10), 'white', line_width=2)
# save this as an array
arr = np.array(img)
assert np.array_equal(arr, self.line_arr)
def test_outside(self):
'''second value too large'''
img = Image(10, 10)
img.draw_line((0, 0), (100, 100), 'white', line_width=2)
# save this as an array
arr = np.array(img)
assert np.array_equal(arr, self.line_arr)
def test_outside(self):
'''second value too large'''
img = Image(10, 10)
img.draw_line((0, 0), (100, 100), 'white', line_width=2)
# save this as an array
arr = np.array(img)
assert np.array_equal(arr, self.line_arr)
def test_negative(self):
'''negative coords value too large'''
img = Image(10, 10)
img.draw_line((-100, -100), (10, 10), 'white', line_width=2)
# save this as an array
arr = np.array(img)
assert np.array_equal(arr, self.line_arr)
def test_inside(self):
'''just to make sure the comparing is working'''
img = Image(10, 10)
img.draw_line((0, 0), (10, 10), 'white', line_width=2)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.line_arr)
def test_overflow(self):
'''
Big enough to overflow an 32 bit int
'''
img = Image(10, 10)
val = int(2 ** 33)
with pytest.raises(OverflowError):
img.draw_line((-val, -val), (val, val), 'white', line_width=2)
def test_init2():
_img = Image(width=400, height=400)
_img = Image(400, 400)
# need to pass in width and height
with pytest.raises(TypeError):
Image()
with pytest.raises(TypeError):
Image(200)
def test_rectangles():
img = Image(100, 200)
img.draw_rectangle((10, 10), (30, 40), fill_color='blue')
img.draw_rectangle((20, 50), (40, 70), line_color='blue', line_width=5)
img.draw_rectangle((40, 80), (90, 220),
fill_color='white',
line_color='green',
line_width=2)
img.save(outfile("test_image_rectangle.bmp"))
def test_array():
img = Image(10, 5)
img.draw_line((0, 0), (9, 4), 'black', line_width=1)
print "result from __array__", img.__array__()
arr = np.asarray(img)
assert np.array_equal(
arr,
[[1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 1, 0, 0, 0],
[0, 0, 1, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 1, 0],
[0, 0, 0, 0, 1], [0, 0, 0, 0, 1]])
def test_draw_dots_wrong_shape():
"""
test passing in a wrong-shaped points
"""
w, h, = 1000, 500
img = Image(w, h)
points = [(1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12)]
with pytest.raises(ValueError):
img.draw_dots(points, diameter=2, color='red')
assert True
def test_clip_deleter():
img = Image(100, 100)
# set to a non-default
img.clip_rect = ((20, 20), (79, 79))
assert img.clip_rect == ((20, 20), (79, 79))
# delete it
del img.clip_rect
# it should be re-set to the image size.
assert img.clip_rect == ((0, 0), (img.width - 1, img.height - 1))
def test_big(self):
'''
really big values, negative and positive, but not quite enough
to overflow an integer
'''
img = Image(10, 10)
val = int(2**30)
img.draw_line((-val, -val), (val, val), 'white', line_width=2)
# save this as an array
arr = np.array(img)
assert np.array_equal(arr, self.line_arr)
def test_mem_limit():
"""
test the limit for largest image.
note that the 1GB max is arbitrary -- youc an change it iin the code.
But my system, at least, will try to allocate much more memory that
you'd want, bringing the system to an almost halt, before raising
a memory error, so I sete a limit.
"""
_img = Image(32768, 32768) # 1 GB image
with pytest.raises(MemoryError):
_img = Image(32768, 32769) # > 1 GB image
def test_inside(self):
'''just to make sure the comparing is working'''
img = Image(10, 10)
# a triangle that divides the image
points = ((-1, -1), (11, 11), (-1, 11))
img.draw_polygon(points, line_color='black', fill_color=None,
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_outside(self):
'''second value too large'''
img = Image(10, 10)
# a triangle that divides the image
points = ((-1, -1), (100, 100), (-1, 100))
img.draw_polygon(points, line_color='black', fill_color=None,
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_static_animation():
img1 = Image(200, 200)
img2 = Image(200, 200)
endpoints = np.array(((-100, 0), (100, 0)))
offset = np.array((100, 100))
fname = "test_animation.gif"
anim = Animation(outfile(fname))
anim.begin_anim(img1, 0)
for ang in range(0, 360, 10):
rad = np.deg2rad(ang)
rot_matrix = [(np.cos(rad), np.sin(rad)), (-np.sin(rad), np.cos(rad))]
points = np.dot(endpoints, rot_matrix).astype(np.int32) + offset
img1.draw_line(points[0], points[1], 'red')
img2.draw_line(points[0], points[1], 'red')
assert img1 == img2
anim.add_frame(img1)
anim.add_frame(img2)
anim.close_anim()
print anim.frames_written
def test_set_pixel_value():
"""
test if setting the pixel value directly works.
"""
img = Image(4, 5)
for i in range(4):
for j in range(5):
img.set_pixel_value((i, j), i)
# check:
for i in range(4):
for j in range(5):
assert img.get_pixel_value((i, j)) == i
def test_big(self):
'''
really big values, negative and positive, but not quite enough
to overflow an integer
'''
img = Image(10, 10)
val = int(2 ** 30)
img.draw_line((-val, -val), (val, val), 'white', line_width=2)
# save this as an array
arr = np.array(img)
assert np.array_equal(arr, self.line_arr)
def test_negative(self):
'''negative coords value too large'''
img = Image(10, 10)
# a triangle that divides the image
points = ((-100, -100), (10, 10), (-100, 10))
img.draw_polygon(points, line_color='black', fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_draw_dots3():
img = Image(20, 20)
img.draw_dots(((2, 2), (2, 18), (10, 10)), diameter=3)
img.draw_dots(((18, 18), (18, 2)), diameter=4, color='red')
img.save(outfile("test_image_points3.png"), "png")
def test_clip_draw():
img = Image(100, 100)
img.clip_rect = ((20, 20), (80, 80))
img.draw_line((0, 0), (100, 100), color='red', line_width=4)
img.draw_line((0, 100), (100, 0), color='blue', line_width=4)
fname = "image_clip.bmp"
img.save(outfile(fname))
assert check_file(fname)
def test_size():
"""
test the size property
"""
img = Image(10, 15)
assert img.size == (10, 15)
def test_negative(self):
'''negative coords value too large'''
img = Image(10, 10)
# a triangle that divides the image
points = ((-100, -100), (10, 10), (-100, 10))
img.draw_polygon(points,
line_color='black',
fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_outside(self):
'''second value too large'''
img = Image(10, 10)
# a triangle that divides the image
points = ((-1, -1), (100, 100), (-1, 100))
img.draw_polygon(points,
line_color='black',
fill_color=None,
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_inside(self):
'''just to make sure the comparing is working'''
img = Image(10, 10)
# a triangle that divides the image
points = ((-1, -1), (11, 11), (-1, 11))
img.draw_polygon(points,
line_color='black',
fill_color=None,
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_polyline():
img = Image(100, 200)
points = ((10, 10), (20, 190), (90, 10), (50, 50))
img.draw_polyline(points, 'red', line_width=3)
points = ((50, 50), (90, 190), (10, 10))
img.draw_polyline(points, 'blue', line_width=5)
with pytest.raises(ValueError):
# can't accept just one point
img.draw_polyline(((10, 10), ), 'blue')
img.save(outfile("test_image_polyline.bmp"))
def test_set_size():
"""
you should not be able to set the size or width or height
"""
img = Image(40, 30)
assert img.size == (40, 30)
assert img.height == 30
assert img.width == 40
with pytest.raises(AttributeError):
img.size = (50, 60)
with pytest.raises(AttributeError):
img.height = 100
with pytest.raises(AttributeError):
img.width = 100
def test_huge(self):
'''
really big values, negative and positive, but not quite enough
to overflow an integer
'''
img = Image(10, 10)
val = int(2 ** 30)
# a triangle that divides the image
points = ((-val, -val), (val, val), (-val, val))
img.draw_polygon(points, line_color='black', fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_large(self):
'''
large values, negative and positive
just less than sqrt(max_int32)
this seems to confirm that that's the limit
'''
img = Image(10, 10)
val = int(2 ** 14)
# a triangle that divides the image
points = ((-val, -val), (val, val), (-val, val))
img.draw_polygon(points, line_color='black', fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_huge(self):
'''
really big values, negative and positive, but not quite enough
to overflow an integer
'''
img = Image(10, 10)
val = int(2**30)
# a triangle that divides the image
points = ((-val, -val), (val, val), (-val, val))
img.draw_polygon(points,
line_color='black',
fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_too_large(self):
'''
large values, negative and positive
just more than sqrt(max_int32)
this seems to confirm that that's the limit
'''
img = Image(10, 10)
val = int(2 ** 15)
# a triangle that divides the image
points = ((-val, -val), (val, val), (-1, val))
img.draw_polygon(points, line_color='black', fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
# this is expected to not be equal -- we've found a too-big value
assert not np.array_equal(arr, self.arr)
def test_large(self):
'''
large values, negative and positive
just less than sqrt(max_int32)
this seems to confirm that that's the limit
'''
img = Image(10, 10)
val = int(2**14)
# a triangle that divides the image
points = ((-val, -val), (val, val), (-val, val))
img.draw_polygon(points,
line_color='black',
fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
assert np.array_equal(arr, self.arr)
def test_overflow(self):
'''
Big enough to overflow an 32 bit int
'''
img = Image(10, 10)
val = int(2 ** 33)
# with pytest.raises(OverflowError):
# img.draw_line( (-val, -val), (val, val), 'white', line_width=2)
# a triangle that divides the image
points = ((-val, -val), (val, val), (-val, val))
img.draw_polygon(points, line_color='black', fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
# This isn't expect to draw correctly
assert not np.array_equal(arr, self.arr)
def test_polygon_clip():
img = Image(100, 200)
points = ((-20, 10), (20, 250), (120, 10), (50, 50))
img.draw_polygon(points, fill_color='blue', line_color='red')
img.save(outfile("test_image_polygon_clip.bmp"))
def test_Polygon3():
img = Image(100, 200)
points = ((10, 10), (20, 190), (90, 10), (50, 50))
img.draw_polygon(points, fill_color='blue', line_color='red', line_width=4)
img.save(outfile("test_image_poly3.bmp"))
def test_Polygon1():
img = Image(100, 200)
points = ((10, 10), (20, 190), (90, 10), (50, 50))
img.draw_polygon(points, 'red')
img.save(outfile("test_image_poly1.bmp"))
def test_save_image(filetype):
img = Image(400, 300)
img.draw_line((0, 0), (399, 299), 'white', line_width=4)
img.draw_line((0, 299), (399, 0), 'green', line_width=4)
fname = "test_image_save." + filetype
img.save(outfile(fname), filetype)
if filetype is not "jpg": # jpeg is lossy and thus inconsistent
assert check_file(fname)
with pytest.raises(ValueError):
img.save(outfile("test_image1.something"), "random_string")
def test_too_large(self):
'''
large values, negative and positive
just more than sqrt(max_int32)
this seems to confirm that that's the limit
'''
img = Image(10, 10)
val = int(2**15)
# a triangle that divides the image
points = ((-val, -val), (val, val), (-1, val))
img.draw_polygon(points,
line_color='black',
fill_color='red',
line_width=1)
# save this one as an array
arr = np.array(img)
# this is expected to not be equal -- we've found a too-big value
assert not np.array_equal(arr, self.arr)
