# la siguiente matriz representa los caminos, no las paredes del laberinto

example1 = [

u"┐ ┌──┐┌───┐ ┌──┐ ┌┐ ┌┐ ┌────┐ ┌─────┐ ",

u"└┐ └─┐└┘ │ ┌┐│ └┐┌─┐ ┌┘└┐││ ┌┐ │┌─┐ └┐└─┐ ┌┘ ",

u"┌┘ ┌┘ └───┘││ └┘ │ │ ││└┐│└─────┐└┘ │ ┌┘ ┌┘┌─┘ ",

u"└─┐┌──┘┌─┐ ┌──┘│ ╶┬┘ │┌─┘└┐││ ┌──┐ │ ┌─┘┌┘ │ └┐ ┌─┐",

u" └┘ ┌┘ └──┐ └┐ ┌┘ │ ┌──┐ ┌┘└──┐│└┘┌┘┌─┘ └┐│ └─┐┌┘┌┐│ │ │",

u" ┌────┘┌┐ │ ┌─┘ │ ┌┘ │┌┐│ └──┐ └┘┌┐│┌┘┌┐╷ └┘ └┘ │└┘ │ │",

u" │ ┌─┘└─┐ │ └─┐ │┌┐ └┐ └┘││ ┌┐ │┌┐ │└┘│ │├┘ ┌──┐│┌┐ │ │",

u"┌┘┌──┘┌┐ ┌┘┌┘ ┌┘ └┘│┌┐ ┌┘┌──┘│┌┘│ └┘│ │ │┌┘│ │┌┐│└┘│ │ │",

u"└┐│ ┌┘└┐└┐│ ┌┐└─┐ └┘│ │ │ ┌┐└┘ └─┐ └─┘ └┘ └┐ ┌──┐ ││└┘ └─┘ │",

u" ││ └─┐│┌┘└─┘└──┘ ┌┘ │ │ │└┐ └┐┌──┐ ┌┘┌┘ ┌┘┌┘│┌┐ ┌─┐ │",

u" └┘┌───┘└┘┌──┐┌┐┌────┘ │ │ └┐│ ┌┘│ │ │ └┐ │ │┌┘│└┐│ └──┘",

u" └┐┌──┐┌┘┌─┘│││ │ │ ┌┘└┐┌┐ └┐│┌┐│ │ │ └─┘│┌┘ │└┐ ",

u"┌┐ ││ ││ └──┘││ ┌─┐ │ │ │ └┘│ │└┘││ ┌─┘ │┌─┐┌┘│ └┐│ ",

u"│└──┘└┐ ││┌┐ └┤ │┌┘ │┌┴─┘ ┌┐│ │┌─┘└──┘ ╷ │└┐│└─┘ └┘┌──┐",

u"│ ┌───┘ │└┘│ │ │└┐┌┬─┼┘ ┌─┐││└──┘│ ╶┼╴ ├┐│└┐ ┌┐┌┘┌─┘",

u"└─┘ └──┘ └─┘ └┘└─┴───┘╶┼┘└────┘ ╵ ╵└┘ └────┘└┘ └──",

]

example2 = [

u"┬─┬─┬───┬───┐",

u"│ │ │┌┐ │┌┐ │",

u"└┬┘ └┘│ └┘└─┘",

u" └────┴──────"

]

example3 = [

u"─┬──┬───┐",

u"┌┴┐ │┌┐ │",

u"│ │ └┘└─┘",

u"├─┼─┐ ",

u"│ ├─┘ ╶┐",

u"└┬┘ │",

u" └──────┴"

]

example = example1

def pathToWalls(s):

if s == u" ": return 15 # LEFT & UP & RIGHT & DOWN

elif s == u"╴": return 14 # UP & RIGHT & DOWN

elif s == u"╵": return 13 # LEFT & RIGHT & DOWN

elif s == u"╶": return 11 # LEFT & UP & DOWN

elif s == u"╷": return 7 # LEFT & UP & RIGHT

elif s == u"─": return 10 # UP & DOWN

elif s == u"│": return 5 # LEFT & RIGHT

elif s == u"┌": return 3 # LEFT & UP

elif s == u"┐": return 6 # UP & RIGHT

elif s == u"┘": return 12 # RIGHT & DOWN

elif s == u"└": return 9 # LEFT & & DOWN

elif s == u"├": return 1 # LEFT

elif s == u"┬": return 2 # UP

elif s == u"┤": return 4 # RIGHT

elif s == u"┴": return 8 # DOWN

elif s == u"┼": return 0 # NOTHING

exampleWalls = map(lambda x: map(pathToWalls, x), example)

simple = simplifyMaze(exampleWalls)

#print '\n'.join([' '.join([str(c).rjust(2) for c in x]) for x in simple])

import pypng.png as png

s = createPNGfromMazeAndPaths(exampleWalls)

printMazePNG(s, "png1.png")

s = createPNGfromMazeAndPaths(simple)

import pypng.png as png

n, m = 30, 40

maze = createRandomMaze(n, m)

mazeSimple = simplifyMaze(maze)

s = createPNGfromMazeAndPaths(maze)

printMazePNG(s, "png2.png")

s = createPNGfromMazeAndPaths(mazeSimple)

n, m = 100, 120

if True:

mazePerfect = createRandomMaze(n, m)

maze = deleteWalls(mazePerfect, 0.10)

# maze without dead-ends

mazeSimple = simplifyMaze(maze)

from random import random

mazeWeight = [[random() for j in range(m)] for i in range(n)]

sol = findPath(maze)

sol2 = findPath(maze)

# Saving

import pickle

o = open('test.bin', 'wb')

#pickle.dump(mazePerfect, o)

pickle.dump(maze, o)

pickle.dump(mazeSimple, o)

pickle.dump(mazeWeight, o)

# this is a simple save, without using the optimized procedure

# savePath from src.savePaths

pickle.dump(sol, o)

pickle.dump(sol2, o)

else:

# Loading

import pickle

o = open('test.bin', 'rb')

#mazePerfect = pickle.load(o)

maze = pickle.load(o)

mazeSimple = pickle.load(o)

mazeWeight = pickle.load(o)

sol = pickle.load(o)

sol2 = pickle.load(o)

# saving

# maze clean

#s = createPNGfromMazeAndPaths(mazePerfect)

#printMazePNG(s, "test3-Perfect.png")

#s = createPNGfromMazeAndPaths(maze)

#printMazePNG(s, "test3.png")

#s = createPNGfromMazeAndPaths(maze, [sol, sol2])

#printMazePNG(s, "test3-paths.png")

#s = createPNGfromMazeAndPaths(mazeSimple)

#printMazePNG(s, "test3-simple.png")

#solSon,k,l = crossingPaths(n, m, sol, sol2)

#s = createPNGfromMazeAndPaths(maze, [solSon])

#printMazePNG(s, "test3-son.png")

# mutating

solMut, p1, p2 = mutatePath(maze, sol)

s = createPNGfromMazeAndPaths(maze, [sol, solMut], [[p1,p1], [p2, p2]])

printMazePNG(s, "test3-original-and-mutated.png")

# finding shortest path

#from src.shortestPath import shortestPath

#solMut = shortestPath(maze, mazeWeight)

#s = createPNGfromMazeAndPaths(maze, [sol, solMut])

import pypng.png as png

n, m = 30, 40

entrance, exit = (12,0, LEFT), (21,m-1, RIGHT)

maze = createRandomMaze(n, m, entrance, exit)

sol = findPath(maze, entrance, exit)

s = createPNGfromMazeAndPaths(maze, [sol])

writterPNG = png.Writer(len(s[0]), len(s), palette=palette, bitdepth=2)

f = open('png4.png', 'wb')

writterPNG.write(f, s)

import pypng.png as png

n, m = 30, 40

entrance, exit = (5,10, NOTHING), (21,37, NOTHING)

maze = createRandomMaze(n, m, entrance, exit)

sol = findPath(maze, entrance, exit)

s = createPNGfromMazeAndPaths(maze, [sol])

writterPNG = png.Writer(len(s[0]), len(s), palette=palette, bitdepth=4)

f = open('png5.png', 'wb')

writterPNG.write(f, s)

n, m = 300,400

if True:

mazePerfect = createRandomMaze(n, m)

maze = deleteWalls(mazePerfect, 0.07)

mazeSimple, per = simplifyMaze(maze)

from src.createMazes import createRandomWeight

mazeWeight, mask = createRandomWeight(n, m, 70)

# Saving

import pickle

o = open('test.bin', 'wb')

pickle.dump(maze, o)

pickle.dump(mazeWeight, o)

# outdated

#else:

## Loading

#import pickle

#o = open('test.bin', 'rb')

##mazePerfect = pickle.load(o)

#maze = pickle.load(o)

#mazeWeight = pickle.load(o)

print per # total unrearcheable cells

# finding shortest path

from src.shortestPath import shortestPath

sol = shortestPath(maze, mazeWeight)

s = createPNGfromMazeAndPaths(mazeSimple, [sol])

printMazePNG(s, "test5.png")

toPNG = [[int(255*(1-j)) for j in i] for i in mask]

import pypng.png as png

writterPNG = png.Writer( len(toPNG[0]), len(toPNG)

, greyscale=True

, bitdepth=8)

f = open("testing.png", 'wb')

writterPNG.write(f, toPNG)