def test_lemme_6_case_1_k_0_NWp_and_NNWp_white_but_NNWWp_black_and_NWW_white(
self):
img_depart = [[0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0,
0], [0, 1, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0,
0], [0, 1, 0, 1, 1, 0],
[0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(
img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
vert = BinaryImage.create_img_vertical(binary_image.size,
BLACK_CONNEXITY,
WHITE_CONNEXITY)
solver = B4W4_Solver(binary_image, vert)
solver.lemme_6(solver.imageElementsStart)
self.assertEqual(
img_soluce, binary_image.convert_pixels_to_img(),
"In case of lemma_6, if the lead elbow = p is not cut vertex and k=0 and NW(p) is black"
"then the interchange is <p, N(p)>")
self.assertEqual(2, len(solver.imageElementsStart.array_interchange),
"The number interchange should be 2")
def test_lemme_6_p_cut_into_not_cut(self):
img_depart = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 1, 0, 0, 0], [0, 1, 1, 1, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 1, 0], [0, 0, 0, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 1, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 1, 1, 0], [0, 0, 0, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(
img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
vert = BinaryImage.create_img_vertical(binary_image.size,
BLACK_CONNEXITY,
WHITE_CONNEXITY)
solver = B4W4_Solver(binary_image, vert)
solver.lemme_6(solver.imageElementsStart)
self.assertEqual(
img_soluce, binary_image.convert_pixels_to_img(),
"In case of lemma_6, if the lead elbow = p is cut vertex we're applying a k-diag interchange"
"on p. In this case p should not be cut vertex at the end of the interchanges"
)
self.assertEqual(2, len(solver.imageElementsStart.array_interchange),
"The number interchange should be 2")
def test_p_cut_Wp_white_not_cut(self):
img_depart = [[0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 1, 0],
[0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 0],
[0, 0, 0, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
solver = B8W4_Solver(binary_image, BinaryImage.create_img_vertical(binary_image.size))
solver.resolve_image(binary_image)
self.assertEqual(img_soluce,
binary_image.convert_pixels_to_img(),
"In case of p cut vertex and W(p) white not cut,"
" the interchange should be <p, W(p)>")
self.assertEqual(1,
len(solver.array_interchange),
"The number interchange should be 1")
def test_first_condition_cut_NWp1_cut(self):
img_depart = [[0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 1, 0, 0], [0, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0],
[0, 0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 0, 0], [0, 1, 1, 1, 0, 1, 0],
[0, 0, 0, 1, 0, 1, 0], [0, 0, 0, 1, 1, 1, 0],
[0, 0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(
img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
vert = BinaryImage.create_img_vertical(binary_image.size,
BLACK_CONNEXITY,
WHITE_CONNEXITY)
solver = B4W4_Solver(binary_image, vert)
solver.first_condition(solver.imageElementsStart)
self.assertEqual(
img_soluce, binary_image.convert_pixels_to_img(),
"In case of NNW(t) black and NW(t) white you need to apply a k-vertical interchange on NNW(t)."
"Here it's a 3 times a 1-diagonal interchange where p1 is cut vertex the first time"
"then not cut vertex twice. Note : the top pixel change once after the second interchange"
)
self.assertEqual(3, len(solver.imageElementsStart.array_interchange),
"The number interchange should be 3")
def test_p_cut_Wp_white_cut_G_through_Np_Sl_cut_SSWl_not_cut(self):
img_depart = [[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 0],
[0, 1, 0, 0, 1, 0],
[0, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 0],
[0, 1, 0, 1, 1, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
solver = B8W4_Solver(binary_image, BinaryImage.create_img_vertical(binary_image.size))
solver.resolve_image(binary_image)
self.assertEqual(img_soluce,
binary_image.convert_pixels_to_img(),
"In case of p cut vertex and W(p) white cut, g goes to p through N(p)"
"and l is cut vertex but SSW(l) is not cut the interchange should be <SSW(l), S(l)>")
self.assertEqual(1,
len(solver.array_interchange),
"The number interchange should be 1")
def test_p_cut_g_to_p_from_Np_NNWWp_white(self):
img_depart = [[0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 0],
[0, 1, 0, 1, 1, 0],
[0, 1, 1, 0, 1, 0],
[0, 0, 0, 1, 1, 0],
[0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 0, 0],
[0, 1, 0, 1, 1, 1, 0],
[0, 1, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
solver = B4W8_Solver(binary_image, BinaryImage.create_img_vertical(binary_image.size))
solver.resolve_image(binary_image)
self.assertEqual(img_soluce,
binary_image.convert_pixels_to_img(),
"In case of p cut vertex and g=NWW(p) black and path from g to p is through N(p) "
"and NNW(p) is black and NNWW(p) is white, "
"the interchanges should be <g, E(g)> and <N(p), NNE(p)>")
self.assertEqual(2,
len(solver.array_interchange),
"The number interchange should be 2")
def test_fct_image_expand(self):
binary_image = BinaryImage.create_img_from_array(
IMG_EXPAND_1, BLACK_CONNEXITY, WHITE_CONNEXITY)
self.assertEqual(
8, len(binary_image.white_pixels),
"[[1]] image should create 8 white pixels around the black pixel")
self.assertEqual(
1, len(binary_image.black_pixels),
"[[1]] should keep exactly 1 black pixel in its image")
self.assertEqual(
binary_image.get_pixel(1, 1).color, PixelColor.BLACK,
"Pixel(1,1) should be black")
binary_image = BinaryImage.create_img_from_array(
IMG_EXPAND_2, BLACK_CONNEXITY, WHITE_CONNEXITY)
self.assertEqual(
16, len(binary_image.white_pixels), "[[1, 1, 1],\
[0, 1, 0]] image should create 14 white pixels around the black (total = 16 because "
"already 2 white pixels in image)")
self.assertEqual(
4, len(binary_image.black_pixels), "[[1, 1, 1],\
[0, 1, 0]] should keep exactly 4 black pixel in its image"
)
self.assertEqual(
binary_image.get_pixel(2, 1).color, PixelColor.BLACK,
"Pixel(2,1) should be black")
self.assertEqual(
binary_image.get_pixel(2, 2).color, PixelColor.BLACK,
"Pixel(2,2) should be black")
self.assertEqual(
binary_image.get_pixel(2, 3).color, PixelColor.BLACK,
"Pixel(2,3) should be black")
self.assertEqual(
binary_image.get_pixel(1, 2).color, PixelColor.BLACK,
"Pixel(1,2) should be black")
def compute_l(self, p: Pixel, binary_image: BinaryImage) -> Pixel:
w_n = binary_image.get_pixel_directional(p, [Direction.W, Direction.N])
current_pixel = binary_image.get_pixel_adjacent(w_n, Direction.N)
while current_pixel.color != PixelColor.BLACK:
current_pixel = binary_image.get_pixel_adjacent(
current_pixel, Direction.N)
return current_pixel
def test_compute_height(self):
binary_image = BinaryImage.create_img_from_array(
IMG_ALGO_B4W4_ELEMENTS, BLACK_CONNEXITY, WHITE_CONNEXITY)
algo = B4W4_Elements(binary_image)
self.assertEqual(2, algo.height, "height should be -1")
binary_image = BinaryImage.create_img_from_array(
IMG_TEST_CASE_1, BLACK_CONNEXITY, WHITE_CONNEXITY)
algo = B4W4_Elements(binary_image)
self.assertEqual(None, algo.height,
"height should be 0 in vertical image")
def compute_h(self, g: Pixel,
binary_image: BinaryImage) -> (Pixel, [Pixel]):
pixels_between = [g]
current_pixel = g
while binary_image.get_pixel_adjacent(
current_pixel, Direction.N).color != PixelColor.WHITE:
current_pixel = binary_image.get_pixel_adjacent(
current_pixel, Direction.N)
pixels_between.append(current_pixel)
return current_pixel, pixels_between
def statistics_from_random_images(self,
black_connexity=4,
white_connexity=4,
nb_iter=10,
initial_size_image=50,
nb_tick=5,
incr_size_image=10,
seed_min=0,
seed_max=500000):
size_image = initial_size_image
for i in range(nb_iter):
total_interchange = 0
seeds = []
for j in range(nb_tick):
seed = random.randint(seed_min, seed_max)
binary_image = BinaryImage.create_random_img(
n=size_image,
black_connexity=black_connexity,
white_connexity=white_connexity,
seed=seed)
solver = None
if black_connexity == white_connexity == 4:
solver = B4W4_Solver(
binary_image,
BinaryImage.create_img_vertical(binary_image.size))
elif black_connexity == 4 and white_connexity == 8:
solver = B4W8_Solver(
binary_image,
BinaryImage.create_img_vertical(binary_image.size))
elif black_connexity == 8 and white_connexity == 4:
solver = B8W4_Solver(
binary_image,
BinaryImage.create_img_vertical(binary_image.size))
elif black_connexity == white_connexity == 8:
solver = B8W8_Solver(
binary_image,
BinaryImage.create_img_vertical(binary_image.size))
nb_interchange = solver.solve()
total_interchange += nb_interchange
seeds.append(seed)
average_tick_interchange = total_interchange / nb_tick
self.dic_interchanges[size_image] = [
seeds, average_tick_interchange
]
size_image += incr_size_image
print("Total average for solver B", black_connexity, "W",
white_connexity, " is ", self.dic_interchanges)
def test_compute_anchor(self):
binary_image = BinaryImage.create_img_from_array(IMG_ALGO_B4W4_ELEMENTS, BLACK_CONNEXITY, WHITE_CONNEXITY)
algo = B4W4_Elements(binary_image)
self.assertEqual(algo.binary_image.get_pixel(2, 4),
algo.compute_anchor(),
"Anchor should be (2, 4)")
binary_image = BinaryImage.create_img_from_array(IMG_TEST_CASE_1, BLACK_CONNEXITY, WHITE_CONNEXITY)
algo = B4W4_Elements(binary_image)
self.assertEqual(None,
algo.compute_anchor(),
"Anchor should be None on vertical image")
def test_number_elements_img(self):
binary_image = BinaryImage.create_random_img(SIZE_IMAGE,
BLACK_CONNEXITY,
WHITE_CONNEXITY, SEED)
total_pixels = binary_image.width * binary_image.height
self.assertEqual(
total_pixels,
len(binary_image.black_pixels) + len(binary_image.white_pixels))
binary_image = BinaryImage.create_img_from_array(
IMG_TEST_CASE_1, BLACK_CONNEXITY, WHITE_CONNEXITY)
self.assertEqual(
9,
len(binary_image.black_pixels) + len(binary_image.white_pixels))
def test_compute_top_pixel(self):
binary_image = BinaryImage.create_img_from_array(IMG_ALGO_B4W4_ELEMENTS, BLACK_CONNEXITY, WHITE_CONNEXITY)
algo = B4W4_Elements(binary_image)
self.assertEqual(algo.binary_image.get_pixel(5, 5),
algo.compute_top_pixel(),
"Anchor should be (5, 5)")
def test_first_condition_cut_NWp1_not_cut(self):
img_depart = [[0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
solver = B4W4_Elements(binary_image)
solver.first_condition()
self.assertEqual(img_soluce,
binary_image.convert_pixels_to_img(),
"In case of NNW(t) black and NW(t) white you need to apply a k-vertical interchange on NNW(t)."
"Here it's a 1-diagonal interchange where p1 is cut vertex.")
self.assertEqual(1,
len(solver.array_interchange),
"The number interchange should be 1")
def test_lemme_6_p_cut_into_white(self):
img_depart = [[0, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 1, 0, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 0, 0],
[0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
solver = B4W4_Elements(binary_image)
solver.lemme_6()
self.assertEqual(img_soluce,
binary_image.convert_pixels_to_img(),
"In case of lemma_6, if the lead elbow = p is cut vertex we're applying a k-diag interchange"
"on p. In this case p should become white")
self.assertEqual(1,
len(solver.array_interchange),
"The number interchange should be 1")
def test_lemme_6_case_1_k_superior_0(self):
img_depart = [[0, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 1, 0],
[0, 0, 1, 0],
[0, 1, 1, 0],
[0, 1, 1, 0],
[0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 1, 0],
[0, 0, 1, 0],
[0, 0, 1, 0],
[0, 1, 1, 0],
[0, 1, 0, 0],
[0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
solver = B4W4_Elements(binary_image)
solver.lemme_6()
self.assertEqual(img_soluce,
binary_image.convert_pixels_to_img(),
"In case of lemma_6, if the lead elbow = p is not cut vertex and k>0 we'll slide p upward the"
"east side of the frontier. The interchanges are is <p, NE(p)>, <NiE(p), Ni+1E(p)>"
"<NkE(p), Nk+1E(p)>")
self.assertEqual(5,
len(solver.array_interchange),
"The number interchange should be 5")
def find_path(g: Pixel,
p: Pixel,
img: BinaryImage,
connexity=4,
pixel_bridge=None) -> (bool, bool):
visited = [False] * len(img.black_pixels)
queue = [g]
visited[img.black_pixels.index(g)] = True
pixel_bridge_bool = False
while queue:
n = queue.pop(0)
if pixel_bridge is not None and n == pixel_bridge:
pixel_bridge_bool = True
if n == p:
return True, pixel_bridge_bool
ajd_pixels = img.get_neighbours(n,
connexity,
color=PixelColor.BLACK)
for i in ajd_pixels:
if not visited[img.black_pixels.index(i)]:
if i not in queue:
queue.append(i)
visited[img.black_pixels.index(n)] = True
print(visited)
return False, pixel_bridge_bool
def test_is_elbow(self):
binary_image = BinaryImage.create_img_from_array(IMG_ALGO_B4W4_ELEMENTS, BLACK_CONNEXITY, WHITE_CONNEXITY)
algo = B4W4_Elements(binary_image)
for pixel in algo.binary_image.get_black_pixels():
self.assertEqual(pixel in algo.compute_all_elbows(),
algo.is_elbow(pixel))
def direction_clear(p: Pixel,
direction: Direction,
img: BinaryImage,
p_included=False) -> bool:
if p_included:
current_pixel = p
else:
current_pixel = img.get_pixel_adjacent(p, direction)
while 0 < current_pixel.x < img.height and 0 < current_pixel.y < img.width:
if current_pixel.color != PixelColor.WHITE:
return False
else:
current_pixel = img.get_pixel_adjacent(current_pixel,
direction)
return True
def test_get_neighbours(self):
binary_image = BinaryImage.create_img_from_array(
IMG_B4W4, BLACK_CONNEXITY, WHITE_CONNEXITY)
neighbours = binary_image.get_neighbours(binary_image.get_pixel(1, 1),
8)
# Both pixel verification
verify_neighbours = binary_image.get_pixel(0, 0) in neighbours \
and binary_image.get_pixel(0, 1) in neighbours \
and binary_image.get_pixel(0, 2) in neighbours \
and binary_image.get_pixel(1, 0) in neighbours \
and binary_image.get_pixel(1, 2) in neighbours \
and binary_image.get_pixel(2, 0) in neighbours \
and binary_image.get_pixel(2, 1) in neighbours \
and binary_image.get_pixel(2, 2) in neighbours \
self.assertEqual(
True, verify_neighbours,
"8-neighbours with black and white pixels not working ")
# white pixels verification
neighbours = binary_image.get_neighbours(binary_image.get_pixel(1, 1),
4, PixelColor.WHITE)
verify_neighbours = binary_image.get_pixel(1, 0) in neighbours \
and binary_image.get_pixel(0, 1) in neighbours
self.assertEqual(True, verify_neighbours,
"4-neighbours with white pixels only not working")
not_neighbours = binary_image.get_pixel(0, 2) in neighbours and binary_image.get_pixel(0, 0) in neighbours \
and binary_image.get_pixel(1, 0) in neighbours \
and binary_image.get_pixel(1, 2) in neighbours \
and binary_image.get_pixel(2, 0) in neighbours \
and binary_image.get_pixel(2, 1) in neighbours \
and binary_image.get_pixel(2, 2) in neighbours \
self.assertEqual(False, not_neighbours,
"4-neighbours with white pixels only not working")
# black pixels verification
neighbours = binary_image.get_neighbours(binary_image.get_pixel(1, 1),
4, PixelColor.BLACK)
verify_neighbours = binary_image.get_pixel(1, 2) in neighbours \
and binary_image.get_pixel(2, 1) in neighbours
self.assertEqual(True, verify_neighbours,
"4-neighbours with white pixels only not working")
not_neighbours = binary_image.get_pixel(0, 2) in neighbours \
and binary_image.get_pixel(0, 0) in neighbours \
and binary_image.get_pixel(1, 0) in neighbours \
and binary_image.get_pixel(1, 0) in neighbours \
and binary_image.get_pixel(2, 0) in neighbours \
and binary_image.get_pixel(0, 1) in neighbours \
and binary_image.get_pixel(2, 2) in neighbours
self.assertEqual(False, not_neighbours,
"4-neighbours with white pixels only not working")
def get_p(img: BinaryImage) -> Pixel:
p = None
for pix in img.black_pixels:
s = img.get_pixel_directional(pix, [Direction.S])
if s.color == PixelColor.WHITE:
if p is None or pix.x >= p.x:
east_clear = B4W8_Solver.direction_clear(
pix, Direction.E, img)
north_clear = B4W8_Solver.direction_clear(
img.get_pixel_adjacent(pix, Direction.E),
Direction.N,
img,
p_included=True)
if east_clear and north_clear:
p = pix
return p
def statistics_spiral(self,
black_connexity=4,
white_connexity=4,
nb_iter=10,
initial_size_image=50,
nb_tick=5,
incr_size_image=10):
size_image = initial_size_image
for i in range(nb_iter):
total_interchange = 0
for j in range(nb_tick):
begin = time.time()
binary_image = BinaryImage.create_img_spiral(
size_image=size_image,
black_connexity=black_connexity,
white_connexity=white_connexity)
solver = None
if black_connexity == white_connexity == 4:
solver = B4W4_Solver(
binary_image,
BinaryImage.create_img_vertical(binary_image.size))
elif black_connexity == 4 and white_connexity == 8:
solver = B4W8_Solver(
binary_image,
BinaryImage.create_img_vertical(binary_image.size))
elif black_connexity == 8 and white_connexity == 4:
solver = B8W4_Solver(
binary_image,
BinaryImage.create_img_vertical(binary_image.size))
elif black_connexity == white_connexity == 8:
solver = B8W8_Solver(
binary_image,
BinaryImage.create_img_vertical(binary_image.size))
nb_interchange = solver.solve()
total_interchange += nb_interchange
print("size : ", size_image, ", timer : ", time.time() - begin)
self.dic_interchanges[size_image] = [i, total_interchange]
size_image += incr_size_image
print("Total average for solver B", black_connexity, "W",
white_connexity, " is ", self.dic_interchanges)
def create_gif(image: BinaryImage,
array_interchage: [(int, int), (int, int)],
name="GifInterchange.gif",
speed=2000) -> None:
fig, ax = pyplot.subplots()
M = image.convert_pixels_to_img()
matrice = ax.matshow(M, cmap='Greys')
# width = image.width
# height = image.height
p_bar = tqdm(total=len(array_interchage)) # progress bar in print
p_bar.set_description(
"Creating gif nb_interchange n = " +
str(len(array_interchage))) # Description for the loading bar
def init():
# Creates the lines of the grid
for i in range(image.height + 1):
BinaryImageDisplayer.__draw_line(-0.5, image.width - 0.5,
i - 0.5, i - 0.5)
# Creates the columns of the grid
for i in range(image.width + 1):
BinaryImageDisplayer.__draw_line(i - 0.5, i - 0.5, -0.5,
image.height - 0.5)
def update(i):
p, q = array_interchage[i - 1]
swap = image.swap_pixels(p, q)
if swap:
p_bar.update(1) # Adding the first pixel
M = image.convert_pixels_to_img()
matrice = ax.matshow(M, cmap='Greys')
matrice.set_array(image.convert_pixels_to_img())
ani = FuncAnimation(fig,
update,
frames=len(array_interchage) + 1,
interval=speed)
ani.save(name)
#
#
# def update():
# for p, q in array_interchage:
# image.swap_pixels(p, q)
# BinaryImageDisplayer.__draw_pixel(x=p.x, y=p.y, color="#FFFFFF")
# BinaryImageDisplayer.__draw_pixel(x=q.x, y=q.y, color=BinaryImageDisplayer.BLACK_PIXEL_COLOR)
return None
def test_get_pixel(self):
binary_image = BinaryImage.create_img_from_array(
IMG_B4W4, BLACK_CONNEXITY, WHITE_CONNEXITY)
height = random.randint(0, binary_image.height - 1)
width = random.randint(0, binary_image.width - 1)
pixel = binary_image.get_pixel(height, width)
self.assertEqual(
True, pixel.x == height and pixel.y == width,
"GetPixel coordinates (" + str(height) + ", " + str(width) + ")")
def test_p_cut_Wp_white_cut_G_through_Np_Sl_cut_SSWl_cut_z_no_exist_and_path_through_SWg(self):
img_depart = [[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 0, 0],
[0, 0, 1, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 1, 0],
[0, 0, 1, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0],
[0, 0, 1, 0, 0, 1, 0],
[0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 0, 0],
[0, 0, 1, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 1, 0],
[0, 0, 1, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 1, 0],
[0, 1, 0, 1, 1, 1, 0],
[0, 1, 0, 0, 0, 1, 0],
[0, 0, 1, 0, 0, 1, 0],
[0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
solver = B8W4_Solver(binary_image, BinaryImage.create_img_vertical(binary_image.size))
solver.resolve_image(binary_image)
self.assertEqual(img_soluce,
binary_image.convert_pixels_to_img(),
"In case of p cut vertex and W(p) white cut, g goes to p through N(p)"
"and l is cut vertex and SSW(l) is cut. all z exist such as w(z) is white"
"if g != h and path is through SW(g) then the interchange is"
"<g, NE(g)>")
self.assertEqual(1,
len(solver.array_interchange),
"The number interchange should be 1")
def compute_z(self, array_pixel: [Pixel],
binary_image: BinaryImage) -> Pixel or None:
current_pixel = None
min_x = float("inf")
for b in array_pixel:
if binary_image.get_pixel_adjacent(
b, Direction.W).color == PixelColor.BLACK:
if b.x < min_x:
current_pixel = b
return current_pixel
def test_p_cut_Wp_white_cut_G_through_Np_Sl_cut_SSWl_cut_z_exist_Nz_or_NNz_black_and_z_in_south_wssssl(self):
img_depart = [[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 0],
[0, 1, 0, 0, 1, 0],
[0, 0, 1, 0, 1, 0],
[0, 1, 0, 0, 1, 0],
[0, 1, 1, 0, 1, 0],
[0, 1, 1, 0, 1, 0],
[0, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 0, 0],
[0, 1, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 0, 0, 1, 0],
[0, 1, 1, 0, 1, 0, 0],
[0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
solver = B8W4_Solver(binary_image, BinaryImage.create_img_vertical(binary_image.size))
solver.resolve_image(binary_image)
self.assertEqual(img_soluce,
binary_image.convert_pixels_to_img(),
"In case of p cut vertex and W(p) white cut, g goes to p through N(p)"
"and l is cut vertex and SSW(l) is cut. z exist such as w(z) is black and N(z) or NN(z) is "
"black. If z == wssss+(l) the 4-vertical interchange should be "
"<EE(z), EEE(z)>, <NEE(z), ZEEE(z), <NNEE(z), NNEEE(z)>, <z, NE(z)>")
self.assertEqual(4,
len(solver.array_interchange),
"The number interchange should be 4")
def test_p_cut_Wp_white_cut_G_through_Np_Sl_cut_SSWl_cut_z_exist_Nz_and_NNz_white(self):
img_depart = [[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 0],
[0, 1, 0, 0, 1, 0],
[0, 0, 1, 0, 1, 0],
[0, 1, 0, 0, 1, 0],
[0, 1, 0, 0, 1, 0],
[0, 1, 1, 0, 1, 0],
[0, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0]]
img_soluce = [[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 0],
[0, 1, 0, 0, 1, 0],
[0, 0, 1, 0, 1, 0],
[0, 1, 0, 0, 1, 0],
[0, 1, 0, 1, 1, 0],
[0, 1, 0, 0, 1, 0],
[0, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0]]
binary_image = BinaryImage.create_img_from_array(img_depart, BLACK_CONNEXITY, WHITE_CONNEXITY)
solver = B8W4_Solver(binary_image, BinaryImage.create_img_vertical(binary_image.size))
solver.resolve_image(binary_image)
self.assertEqual(img_soluce,
binary_image.convert_pixels_to_img(),
"In case of p cut vertex and W(p) white cut, g goes to p through N(p)"
"and l is cut vertex and SSW(l) is cut. z exist such as w(z) is black and N(z) and NN(z) are "
"white, the interchange should be <z, NE(z)>")
self.assertEqual(1,
len(solver.array_interchange),
"The number interchange should be 1")
def test_compute_frontier(self):
binary_image = BinaryImage.create_img_from_array(IMG_ALGO_B4W4_ELEMENTS, BLACK_CONNEXITY, WHITE_CONNEXITY)
algo = B4W4_Elements(binary_image)
frontier_test = [algo.binary_image.get_pixel(1, 5),
algo.binary_image.get_pixel(2, 5),
algo.binary_image.get_pixel(4, 5),
algo.binary_image.get_pixel(5, 5)]
frontier_algo, temp = algo.compute_frontier()
self.assertEqual(frontier_test,
frontier_algo,
"Pixels that should be in frontier [(1, 5), (2, 5), (4, 5), (5, 5)]")
