Related
I have a recursive maze solver with one image (PNG, 200x200) I have tried using try/except to print an exception but nothing prints.
Recursive function
def solveRecursiveMaze(arr,x,y):
successful = False
if (x,y) == getExitPoint():
successful = True
elif isValid(arr,x,y):
arr[x][y] = "V" #set to V to show it's a visited path
successful = solveRecursiveMaze(arr, x-1, y)
if not successful:
successful = solveRecursiveMaze(arr, x, y+1)
if not successful:
successful = solveRecursiveMaze(arr, x+1, y)
if not successful:
successful = solveRecursiveMaze(arr, x, y-1)
if successful:
arr[x][y] = "P" #Mark as P to show it's a valid pa
return successful
isValid checks to see if the 2D array has a "W" (for White pixel) at the position passed in, and it is within bounds of the array
def isValid(arr,x,y):
if x < len(arr) and y < len(arr) and x >= 0 and y >= 0:
if arr[x][y] == "W":
return True
return False
getExitPoint returns an x,y (pixel) of the point that is found for the exit of the maze
def getExitPoint():
x = crop.size[0] - 1
for y in range(0, crop.size[1]):
if(crop.getpixel((x,y)) == (255,255,255)):
return x,y
if(crop.getpixel((y,x)) == (255,255,255)):
return y,x
this is how I convert my image to a 2D array
maze = []
width,height = crop.size
for x in range(0, width):
mazeX = []
for y in range(0, height):
if(crop.getpixel((x,y)) == (0,0,0)):
mazeX.append("B")
elif(crop.getpixel((x,y)) == (255,255,255)):
mazeX.append("W")
maze.append(mazeX)
What it is supposed to do, is convert the image into a 2D array, which gets traversed recursively (using backtracking) looking for a successful path, then draws a red line over the path.
The script does not work on this image, it stops at pixel X=76, y=153 every time, and i am not sure what to do/what I'm doing wrong
The borders are 1px and the path is 1px. There are not any errors, stack-traces, exceptions, or anything thrown. The recursion just stops and the program quits. Any Ideas?
There are some various problems with your code, but I think what is happening is that you are running over the recursion limit. Your maze is fairly large and complex. I needed to use 4000 (For me, 1000 is the default, and 3000 wasn't large enough).
Not sure what image library you're using; I used PIL.Image
Your input image is actually 203x203, and there is a challenge to locate the entrance and exit. I assumed the entrance is at the top or on the left side, and the exit is on the right side or along the bottom.
import sys
import argparse
import PIL.Image
import os
colors = {
'white' : (255, 255, 255),
'black' : (0, 0, 0),
'red' : (128, 0, 0),
'green' : (0, 255, 0) }
def isValid(image, x, y):
if x < image.size[0] and y < image.size[1] and x >= 0 and y >= 0:
if image.getpixel((x, y)) == colors['white']:
return True
return False
def getEntryPoint(image):
# Search along top.
for x in range(1, image.size[0] - 1):
if image.getpixel((x, 1)) == colors['white']:
return x, 1
# Search along left side.
for y in range(1, image.size[1] - 1):
if image.getpixel((1, y)) == colors['white']:
return 1, y
# Maze is invalid if there is no entry point.
raise Exception('No entry point found!')
def getExitPoint(image):
# Search along bottom.
for x in range(1, image.size[0] - 1):
if image.getpixel((x, image.size[1] - 2)) == colors['white']:
return x, image.size[1] - 2
# Search along right side.
for y in range(1, image.size[1] - 1):
if image.getpixel((image.size[0] - 2, y)) == colors['white']:
return image.size[0] - 2, y
# Maze is invalid if there is no exit point.
raise Exception('No exit point found!')
def solveRecursiveMaze(image, x, y):
successful = False
if (x, y) == getExitPoint(image):
successful = True
elif isValid(image, x, y):
# set to show it's a visited path
image.putpixel((x, y), colors['red'])
successful = solveRecursiveMaze(image, x-1, y)
if not successful:
successful = solveRecursiveMaze(image, x, y+1)
if not successful:
successful = solveRecursiveMaze(image, x+1, y)
if not successful:
successful = solveRecursiveMaze(image, x, y-1)
if successful:
# Mark to show it's a valid path.
image.putpixel((x, y), colors['green'])
return successful
def main(options):
solved = False
if options.depth:
sys.setrecursionlimit(options.depth)
try:
image = PIL.Image.open(options.filename)
except:
print('ERROR: Could not open %s' % (options.filename))
else:
image = image.convert('RGB')
x, y = getEntryPoint(image)
print('Entering maze at x = %d, y = %d' % (x, y))
solved = solveRecursiveMaze(image, x, y)
if not solved:
print('No solution exists.')
else:
print('Solved maze.')
basename = os.path.splitext(options.filename)[0]
image.save(basename + '_solution' + '.png', 'PNG')
return 0 if solved else 1
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'--d',
'-depth',
dest='depth',
type=int,
help='Set Python recursion limit with sys.setrecursionlimit()')
parser.add_argument(
'filename',
help='Image containing the maze.')
options = parser.parse_args()
sys.exit(main(options))
the code below is to detect the objects in images. The code can detect the objects, count the number of detected objects, drawing rectangles to label the objects. Is there any way to extract and save each detected objects? For example; if there are 20 objects detected in an image, I would like to extract and save these 20 objects seperately. I would be appreciated for any help..
from PIL import Image
class TheOutliner(object):
''' takes a dict of xy points and
draws a rectangle around them '''
def __init__(self):
self.outlineColor = 255, 0, 0
self.pic = None
self.picn = None
self.minX = 0
self.minY = 0
self.maxX = 0
self.maxY = 0
def doEverything(self, imgPath, dictPoints, theoutfile):
self.loadImage(imgPath)
self.loadBrightPoints(dictPoints)
self.drawBox()
self.saveImg(theoutfile)
def loadImage(self, imgPath):
self.pic = Image.open(imgPath)
self.picn = self.pic.load()
def loadBrightPoints(self, dictPoints):
'''iterate through all points and
gather max/min x/y '''
# an x from the pool (the max/min
# must be from dictPoints)
self.minX = dictPoints.keys()[0][0]
self.maxX = self.minX
self.minY = dictPoints.keys()[0][1]
self.maxY = self.minY
for point in dictPoints.keys():
if point[0] < self.minX:
self.minX = point[0]
elif point[0] > self.maxX:
self.maxX = point[0]
if point[1]< self.minY:
self.minY = point[1]
elif point[1] > self.maxY:
self.maxY = point[1]
def drawBox(self):
# drop box around bright points
for x in xrange(self.minX, self.maxX):
# top bar
self.picn[x, self.minY] = self.outlineColor
# bottom bar
self.picn[x, self.maxY] = self.outlineColor
for y in xrange(self.minY, self.maxY):
# left bar
self.picn[self.minX, y] = self.outlineColor
# right bar
self.picn[self.maxX, y] = self.outlineColor
def saveImg(self, theoutfile):
self.pic.save(theoutfile, "JPEG")
class ObjectDetector(object):
''' returns a list of dicts representing
all the objects in the image '''
def __init__(self):
self.detail = 4
self.objects = []
self.size = 1000
self.no = 255
self.close = 100
self.pic = None
self.picn = None
self.brightDict = {}
def loadImage(self, imgPath):
self.pic = Image.open(imgPath)
self.picn = self.pic.load()
self.picSize = self.pic.size
self.detail = (self.picSize[0] + self.picSize[1])/2000
self.size = (self.picSize[0] + self.picSize[1])/8
# each must be at least 1 -- and the larger
# the self.detail is the faster the analyzation will be
self.detail += 1
self.size += 1
def getSurroundingPoints(self, xy):
''' returns list of adjoining point '''
x = xy[0]
y = xy[1]
plist = (
(x-self.detail, y-self.detail), (x, y-self.detail),
(x+self.detail, y-self.detail),
(x-self.detail, y),(x+self.detail, y),
(x-self.detail, y+self.detail),(x, y+self.detail),
(x+self.detail,y+self.detail)
)
return (plist)
def getRGBFor(self, x, y):
try:
return self.picn[x,y]
except IndexError as e:
return 255,255,255
def readyToBeEvaluated(self, xy):
try:
r,g,b = self.picn[xy[0],xy[1]]
if r==255 and g==255 and b==255:
return False
except:
return False
return True
def markEvaluated(self, xy):
try:
self.picn[xy[0],xy[1]] = self.no, self.no, self.no
except:
pass
def collectAllObjectPoints(self):
for x in xrange(self.pic.size[0]):
if x % self.detail == 0:
for y in xrange(self.pic.size[1]):
if y % self.detail == 0:
r,g,b = self.picn[x,y]
if r == self.no and \
g == self.no and \
b == self.no:
# then no more
pass
else:
ol = {}
ol[x,y] = "go"
pp = []
pp.append((x,y))
stillLooking = True
while stillLooking:
if len(pp) > 0:
xe, ye = pp.pop()
# look for adjoining points
for p in
self.getSurroundingPoints((xe,ye)
if self.readyToBeEvaluated((p[0],
p[1])):
r2,g2,b2 = self.getRGBFor(p[0],
p[1])
if abs(r-r2) < self.close and \
abs(g-g2) < self.close and \
abs(b-b2) < self.close:
# then its close enough
ol[p[0],p[1]] = "go"
pp.append((p[0],p[1]))
self.markEvaluated((p[0],p[1]))
self.markEvaluated((xe,ye))
else:
# done expanding that point
stillLooking = False
if len(ol) > self.size:
self.objects.append(ol)
if __name__ == "__main__":
print "Start Process";
# assumes that the .jpg files are in
# working directory
theFile = "new2"
theOutFile = "new2.output"
import os
os.listdir('.')
for f in os.listdir('.'):
if f.find(".jpg") > 0:
theFile = f
print "working on " + theFile + "..."
theOutFile = theFile + ".out.jpg"
bbb = ObjectDetector()
bbb.loadImage(theFile)
print " analyzing.."
print " file dimensions: " + str(bbb.picSize)
print " this files object weight: " + str(bbb.size)
print " this files analyzation detail: " +
str(bbb.detail)
bbb.collectAllObjectPoints()
print " objects detected: " +str(len(bbb.objects))
drawer = TheOutliner()
print " loading and drawing rectangles.."
drawer.loadImage(theFile)
for o in bbb.objects:
drawer.loadBrightPoints(o)
drawer.drawBox()
print "saving image..."
drawer.saveImg(theOutFile)
print "Process complete"
You can use crop() method :
add new method after drawBox():
def saveBox(self,filename):
# Create Box
box = (self.minX, self.minY, self.maxX, self.maxY)
# Crop Image
self.pic.crop(box).save(filename)
change the main code :
drawer.loadImage(theFile)
idBox=0
for o in bbb.objects:
drawer.loadBrightPoints(o)
drawer.drawBox()
idBox=idBox+1
drawer.saveBox("box_"+str(idBox)+"_"+theOutFile)
print "saving image..."
drawer.saveImg(theOutFile)
Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 7 years ago.
Improve this question
I was working on my AI pathfinding(which you don't need to understand),
for some reason, my On[3] list was expanding when I did this in the shell:
tempList.append([On[1]-1])
(After the program messed up.) WHY?
The program didn't crash, but that isn't my question.
A screenshot(Ignore the extra prints, I was trying to narrow down the code that was causing it.)
On[1] was my Y coordinates.
The code in question is at # Find Path
(Under the bottom section.)
My code(Over 200 lines long. :/)
# Setup Python ----------------------------------------------- #
import pygame, sys, random, time, webbrowser, os
from datetime import datetime
# Version ---------------------------------------------------- #
Version = '1.0'
# Setup pygame/window ---------------------------------------- #
x = 100
y = 100
import os
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (x,y)
mainClock = pygame.time.Clock()
from pygame.locals import *
pygame.init()
pygame.display.set_caption('Pathfinding '+(Version)+'')
WINDOWWIDTH = 200
WINDOWHEIGHT = 200
screen = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT),pygame.NOFRAME)
# Font ------------------------------------------------------- #
basicFont = pygame.font.SysFont(None, 20)
# Images ----------------------------------------------------- #
# Audio ------------------------------------------------------ #
# Colors ----------------------------------------------------- #
WHITE = (255,255,255)
BLACK = (0,0,0)
GRAY3 = (105,105,105)
GRAY = (195,195,195)
GRAY2 = (127,127,127)
RED = (255,0,0)
GREEN = (0,255,0)
BLUE = (0,0,255)
GOLD = (255,215,0)
PURPLE = (115,0,242)
# Variables -------------------------------------------------- #
Map = ['0000000000',
'0300000000',
'0000000000',
'0200000000',
'0000000000',
'0000000000',
'0000000000',
'0000000000',
'0000000000',
'0000000000']
Column = 0
Row = 0
Nodes = {}
for whatevs in Map:
for whatevs2 in Map[Row]:
Nodes[''+(str(Column))+','+(str(Row))+''] = [Column,Row,int(whatevs2)]
if whatevs2 == '3':
On = [Column,Row,[[Column,Row]]]
Column += 1
if Column == 10:
Column = 0
Row += 1
Open = {}
Closed = {}
# Rects ------------------------------------------------------ #
# Defenitions ------------------------------------------------ #
def Distance(Location,End):
if Location != []:
if int(Location[0]) < End[0]:
Dist = End[0] - int(Location[0])
else:
Dist = int(Location[0]) - End[0]
if int(Location[1]) < End[1]:
Dist2 = End[1] - int(Location[1])
else:
Dist2 = int(Location[1]) - End[1]
Dist += Dist2
if Location[2] == 1:
return 100000
elif Location[2] == 2:
return 0
else:
return Dist
else:
return 100000
# FPS -------------------------------------------------------- #
FPS = 80
TrueFPSCount = 0
TrueFPS = 0
fpsOn = False
PrevNow = 0
# Text -------------------------------------------------------- #
def drawText(text, font, color, surface, x, y):
textobj = font.render(text, 1, color)
textrect = textobj.get_rect()
textrect.topleft = (x, y)
screen.blit(textobj, textrect)
# Loop ------------------------------------------------------- #
while True:
# Black Screen ------------------------------------------- #
screen.fill(BLACK)
# Show Nodes --------------------------------------------- #
for Node in Nodes:
Rect = pygame.Rect(Nodes[Node][0]*20,Nodes[Node][1]*20,20,20)
if Nodes[Node][2] == 0:
pygame.draw.rect(screen,WHITE,Rect)
elif Nodes[Node][2] == 1:
pygame.draw.rect(screen,BLUE,Rect)
elif Nodes[Node][2] == 2:
pygame.draw.rect(screen,GREEN,Rect)
End = [Nodes[Node][0],Nodes[Node][1]]
else:
pygame.draw.rect(screen,RED,Rect)
for Node in Closed:
Rect = pygame.Rect(Closed[Node][0]*20,Closed[Node][1]*20,20,20)
pygame.draw.rect(screen,(0,100,200),Rect)
Rect2 = pygame.Rect(On[0]*20,On[1]*20,20,20)
pygame.draw.rect(screen,(0,200,100),Rect2)
if [On[0],On[1]] == End:
print('Completed.')
print(On[2])
input()
time.sleep(3)
pygame.quit()
sys.exit()
# Find Path ---------------------------------------------- #
Top = []
Bottom = []
Right = []
Left = []
Closed[''+(str(On[0]))+','+(str(On[1]))+''] = [On[0],On[1]]
try:
Top.append(Nodes[''+(str(On[0]))+','+(str(On[1]-1))+''][0])
Top.append(Nodes[''+(str(On[0]))+','+(str(On[1]-1))+''][1])
Top.append(Nodes[''+(str(On[0]))+','+(str(On[1]-1))+''][2])
tempList = []
tempList = On[2]
print(On)
tempList.append([On[0],On[1]-1])
print(On)
Top.append(tempList)
for item in Closed:
if Top != []:
if item == ''+(str(Top[0]))+','+(str(Top[1]))+'':
Top = []
except NameError:
pass
except KeyError:
pass
try:
Bottom.append(Nodes[''+(str(On[0]))+','+(str(On[1]+1))+''][0])
Bottom.append(Nodes[''+(str(On[0]))+','+(str(On[1]+1))+''][1])
Bottom.append(Nodes[''+(str(On[0]))+','+(str(On[1]+1))+''][2])
tempList = []
tempList = On[2]
print('?')
print(On)
tempList.append([On[0],On[1]+1])
print(On)
print()
Bottom.append(tempList)
print('On')
print(On)
for item in Closed:
if Bottom != []:
if item == ''+(str(Bottom[0]))+','+(str(Bottom[1]))+'':
Bottom = []
except NameError:
pass
except KeyError:
pass
try:
Right.append(Nodes[''+(str(On[0]+1))+','+(str(On[1]))+''][0])
Right.append(Nodes[''+(str(On[0]+1))+','+(str(On[1]))+''][1])
Right.append(Nodes[''+(str(On[0]+1))+','+(str(On[1]))+''][2])
tempList = []
tempList = On[2]
tempList.append([On[0]+1,On[1]])
Right.append(tempList)
for item in Closed:
if Right != []:
if item == ''+(str(Right[0]))+','+(str(Right[1]))+'':
Right = []
except NameError:
pass
except KeyError:
pass
try:
Left.append(Nodes[''+(str(On[0]-1))+','+(str(On[1]))+''][0])
Left.append(Nodes[''+(str(On[0]-1))+','+(str(On[1]))+''][1])
Left.append(Nodes[''+(str(On[0]-1))+','+(str(On[1]))+''][2])
tempList = []
tempList = On[2]
tempList.append([On[0]-1,On[1]])
Left.append(tempList)
for item in Closed:
if Left != []:
if item == ''+(str(Left[0]))+','+(str(Left[1]))+'':
Left = []
except NameError:
pass
except KeyError:
pass
if Top != []:
Open[''+(str(Top[0]))+','+(str(Top[1]))+''] = [Distance(Top,End),Top[0],Top[1],Top[3]]
if Bottom != []:
print(':D')
print(On)
Open[''+(str(Bottom[0]))+','+(str(Bottom[1]))+''] = [Distance(Bottom,End),Bottom[0],Bottom[1],Bottom[3]]
if Right != []:
Open[''+(str(Right[0]))+','+(str(Right[1]))+''] = [Distance(Right,End),Right[0],Right[1],Right[3]]
if Left != []:
Open[''+(str(Left[0]))+','+(str(Left[1]))+''] = [Distance(Left,End),Left[0],Left[1],Left[3]]
Lowest = [0,0]
LowestNum = 100000
try:
del Open[''+(str(On[0]))+','+(str(On[1]))+'']
except KeyError:
pass
for Place in Open:
if Open[Place][0] < LowestNum:
LowestNum = Open[Place][0]
Lowest = [Open[Place][1],Open[Place][2],Open[Place][3]]
On = Lowest
# FPS ---------------------------------------------------- #
NewSec = False
TrueFPSCount += 1
now = datetime.now()
now = now.second
if PrevNow != now:
PrevNow = now
NewSec = True
TrueFPS = TrueFPSCount
TrueFPSCount = 0
TrueFPS = str(TrueFPS)
# Buttons ------------------------------------------------ #
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
pygame.quit()
sys.exit()
if event.key == ord('x'):
if fpsOn == True:
fpsOn = False
elif fpsOn == False:
fpsOn = True
# Update ------------------------------------------------- #
if fpsOn == True:
drawText('FPS:'+(TrueFPS)+'', basicFont, WHITE, screen, 500,12)
pygame.display.update()
mainClock.tick(10)
I don't use classes or sprites. :P
Thanks for taking a look!
Because your On[-1] and tempList are the same object. And this is how it works with same objects:
>>> x=[1,2,3]
>>> y=x
>>> y.append(10)
>>> x
[1, 2, 3, 10]
>>> y
[1, 2, 3, 10]
>>>
The following script comes from http://projectproto.blogspot.co.uk/2014/07/opencv-python-2048-game-solver.html
import cv2
import numpy as np
import win32api, win32gui, win32ui, win32con, win32com.client
from PIL import Image, ImageFont, ImageDraw, ImageOps
# create training model based on the given TTF font file
# http://projectproto.blogspot.com/2014/07/opencv-python-digit-recognition.html
def createDigitsModel(fontfile, digitheight):
font = ImageFont.truetype(fontfile, digitheight)
samples = np.empty((0,digitheight*(digitheight/2)))
responses = []
for n in range(10):
pil_im = Image.new("RGB", (digitheight, digitheight*2))
ImageDraw.Draw(pil_im).text((0, 0), str(n), font=font)
pil_im = pil_im.crop(pil_im.getbbox())
pil_im = ImageOps.invert(pil_im)
#pil_im.save(str(n) + ".png")
# convert to cv image
cv_image = cv2.cvtColor(np.array( pil_im ), cv2.COLOR_RGBA2BGRA)
gray = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray,(5,5),0)
thresh = cv2.adaptiveThreshold(blur,255,1,1,11,2)
roi = cv2.resize(thresh,(digitheight,digitheight/2))
responses.append( n )
sample = roi.reshape((1,digitheight*(digitheight/2)))
samples = np.append(samples,sample,0)
samples = np.array(samples,np.float32)
responses = np.array(responses,np.float32)
model = cv2.KNearest()
model.train(samples,responses)
return model
class Board(object):
UP, DOWN, LEFT, RIGHT = 1, 2, 3, 4
FONT = "font/ClearSans-Bold.ttf"
def __init__(self, clientwindowtitle):
self.hwnd = self.getClientWindow(clientwindowtitle)
if not self.hwnd:
return
self.hwndDC = win32gui.GetWindowDC(self.hwnd)
self.mfcDC = win32ui.CreateDCFromHandle(self.hwndDC)
self.saveDC = self.mfcDC.CreateCompatibleDC()
self.cl, self.ct, right, bot = win32gui.GetClientRect(self.hwnd)
self.cw, self.ch = right-self.cl, bot-self.ct
self.cl += win32api.GetSystemMetrics(win32con.SM_CXSIZEFRAME)
self.ct += win32api.GetSystemMetrics(win32con.SM_CYSIZEFRAME)
self.ct += win32api.GetSystemMetrics(win32con.SM_CYCAPTION)
self.ch += win32api.GetSystemMetrics(win32con.SM_CYSIZEFRAME)*2
self.saveBitMap = win32ui.CreateBitmap()
self.saveBitMap.CreateCompatibleBitmap(self.mfcDC, self.cw, self.ch)
self.saveDC.SelectObject(self.saveBitMap)
self.tiles, self.tileheight, self.contour = self.findTiles(self.getClientFrame())
if not len(self.tiles):
return
self.digitheight = self.tileheight / 2
self.digitsmodel = createDigitsModel(self.FONT, self.digitheight)
self.update()
def getClientWindow(self, windowtitle):
toplist, winlist = [], []
def enum_cb(hwnd, results):
winlist.append((hwnd, win32gui.GetWindowText(hwnd)))
win32gui.EnumWindows(enum_cb, toplist)
window = [(hwnd, title) for hwnd, title in winlist if windowtitle.lower() in title.lower()]
if not len(window):
return 0
return window[0][0]
def getClientFrame(self):
self.saveDC.BitBlt((0, 0), (self.cw, self.ch),
self.mfcDC, (self.cl, self.ct), win32con.SRCCOPY)
bmpinfo = self.saveBitMap.GetInfo()
bmpstr = self.saveBitMap.GetBitmapBits(True)
pil_img = Image.frombuffer( 'RGB',
(bmpinfo['bmWidth'], bmpinfo['bmHeight']),
bmpstr, 'raw', 'BGRX', 0, 1)
array = np.array( pil_img )
cvimage = cv2.cvtColor(array, cv2.COLOR_RGBA2BGRA)
return cvimage
def findTiles(self, cvframe):
tiles, avgh = [], 0
gray = cv2.cvtColor(cvframe,cv2.COLOR_BGRA2GRAY)
thresh = cv2.adaptiveThreshold(gray,255,1,1,11,2)
contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
def findBoard(contours): # get largest square
ww, sqcnt = 10, None
for cnt in contours:
x,y,w,h = cv2.boundingRect(cnt)
if w>ww and abs(w-h)<w/10:
ww = w
sqcnt = cnt
return sqcnt
board = findBoard(contours)
if board==None:
print 'board not found!'
return tiles, avgh, board
bx,by,bw,bh = cv2.boundingRect(board)
#cv2.rectangle(cvframe,(bx,by),(bx+bw,by+bh),(0,255,0),2)
#cv2.imshow('board',cvframe)
#cv2.waitKey(0)
#cv2.destroyWindow( 'board' )
maxh = bh/4
minh = (maxh*4)/5
count = 0
for contour in contours:
x,y,w,h = cv2.boundingRect(contour)
if y>by and w>minh and w<maxh and h>minh and h<maxh:
avgh += h
count += 1
if not count:
print 'no tile found!'
return tiles, avgh, board
avgh = avgh / count
margin = (bh-avgh*4)/5
for row in range(4):
for col in range(4):
x0 = bx + avgh*col + margin*(col+1)
x1 = x0 + avgh
y0 = by + avgh*row + margin*(row+1)
y1 = y0 + avgh
tiles.append([x0, y0, x1, y1])
#cv2.rectangle(cvframe,(x0,y0),(x1,y1),(0,255,0),2)
#cv2.imshow('tiles',cvframe)
#cv2.waitKey(0)
#cv2.destroyWindow( 'tiles' )
return tiles, avgh, board
def getTileThreshold(self, tileimage):
gray = cv2.cvtColor(tileimage,cv2.COLOR_BGR2GRAY)
row, col = gray.shape
tmp = gray.copy().reshape(1, row*col)
counts = np.bincount(tmp[0])
sort = np.sort(counts)
modes, freqs = [], []
for i in range(len(sort)):
freq = sort[-1-i]
if freq < 4:
break
mode = np.where(counts==freq)[0][0]
modes.append(mode)
freqs.append(freq)
bg, fg = modes[0], modes[0]
for i in range(len(modes)):
fg = modes[i]
#if abs(bg-fg)>=48:
if abs(bg-fg)>32 and abs(fg-150)>4: # 150?!
break
#print bg, fg
if bg>fg: # needs dark background ?
tmp = 255 - tmp
bg, fg = 255-bg, 255-fg
tmp = tmp.reshape(row, col)
ret, thresh = cv2.threshold(tmp,(bg+fg)/2,255,cv2.THRESH_BINARY)
return thresh
def getTileNumbers(self, cvframe):
numbers = []
outframe = np.zeros(cvframe.shape,np.uint8)
def guessNumber(digits):
for i in range(1,16):
nn = 2**i
ss = str(nn)
dd = [int(c) for c in ss]
if set(digits) == set(dd):
return nn
return 0
for tile in self.tiles:
x0,y0,x1,y1 = tile
tileimage = cvframe[y0:y1,x0:x1]
cv2.rectangle(cvframe,(x0,y0),(x1,y1),(0,255,0),2)
cv2.rectangle(outframe,(x0,y0),(x1,y1),(0,255,0),1)
thresh = self.getTileThreshold(tileimage)
contours,hierarchy = cv2.findContours(thresh.copy(),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
dh = self.digitheight
digits = []
for cnt in contours:
x,y,w,h = cv2.boundingRect(cnt)
if h>w and h>(dh*1)/5 and h<(dh*6)/5:
cv2.rectangle(cvframe,(x0+x,y0+y),(x0+x+w,y0+y+h),(0,0,255),1)
roi = thresh[y:y+h,x:x+w]
roi = cv2.resize(roi,(dh,dh/2))
roi = roi.reshape((1,dh*(dh/2)))
roi = np.float32(roi)
retval, results, neigh_resp, dists = self.digitsmodel.find_nearest(roi, k=1)
digit = int((results[0][0]))
string = str(digit)
digits.append(digit)
cv2.putText(outframe,string,(x0+x,y0+y+h),0,float(h)/24,(0,255,0))
numbers.append(guessNumber(digits))
return numbers, outframe
def getWindowHandle(self):
return self.hwnd
def getBoardContour(self):
return self.contour
def update(self):
frame = self.getClientFrame()
self.tilenumbers, outframe = self.getTileNumbers(frame)
return self.tilenumbers, frame, outframe
def copyTileNumbers(self):
return self.tilenumbers[:]
def getCell(self, tiles, x, y):
return tiles[(y*4)+x]
def setCell(self, tiles, x, y, v):
tiles[(y*4)+x] = v
return tiles
def getCol(self, tiles, x):
return [self.getCell(tiles, x, i) for i in range(4)]
def setCol(self, tiles, x, col):
for i in range(4):
self.setCell(tiles, x, i, col[i])
return tiles
def getLine(self, tiles, y):
return [self.getCell(tiles, i, y) for i in range(4)]
def setLine(self, tiles, y, line):
for i in range(4):
self.setCell(tiles, i, y, line[i])
return tiles
def validMove(self, tilenumbers, direction):
if direction == self.UP or direction == self.DOWN:
for x in range(4):
col = self.getCol(tilenumbers, x)
for y in range(4):
if(y < 4-1 and col[y] == col[y+1] and col[y]!=0):
return True
if(direction == self.DOWN and y > 0 and col[y] == 0 and col[y-1]!=0):
return True
if(direction == self.UP and y < 4-1 and col[y] == 0 and col[y+1]!=0):
return True
if direction == self.LEFT or direction == self.RIGHT:
for y in range(4):
line = self.getLine(tilenumbers, y)
for x in range(4):
if(x < 4-1 and line[x] == line[x+1] and line[x]!=0):
return True
if(direction == self.RIGHT and x > 0 and line[x] == 0 and line[x-1]!=0):
return True
if(direction == self.LEFT and x < 4-1 and line[x] == 0 and line[x+1]!=0):
return True
return False
def moveTileNumbers(self, tilenumbers, direction):
def collapseline(line, direction):
if (direction==self.LEFT or direction==self.UP):
inc = 1
rg = xrange(0, 4-1, inc)
else:
inc = -1
rg = xrange(4-1, 0, inc)
pts = 0
for i in rg:
if line[i] == 0:
continue
if line[i] == line[i+inc]:
v = line[i]*2
line[i] = v
line[i+inc] = 0
pts += v
return line, pts
def moveline(line, directsion):
nl = [c for c in line if c != 0]
if directsion==self.UP or directsion==self.LEFT:
return nl + [0] * (4 - len(nl))
return [0] * (4 - len(nl)) + nl
score = 0
if direction==self.LEFT or direction==self.RIGHT:
for i in range(4):
origin = self.getLine(tilenumbers, i)
line = moveline(origin, direction)
collapsed, pts = collapseline(line, direction)
new = moveline(collapsed, direction)
tilenumbers = self.setLine(tilenumbers, i, new)
score += pts
elif direction==self.UP or direction==self.DOWN:
for i in range(4):
origin = self.getCol(tilenumbers, i)
line = moveline(origin, direction)
collapsed, pts = collapseline(line, direction)
new = moveline(collapsed, direction)
tilenumbers = self.setCol(tilenumbers, i, new)
score += pts
return score, tilenumbers
# AI based on "term2048-AI"
# https://github.com/Nicola17/term2048-AI
class AI(object):
def __init__(self, board):
self.board = board
def nextMove(self):
tilenumbers = self.board.copyTileNumbers()
m, s = self.nextMoveRecur(tilenumbers[:],3,3)
return m
def nextMoveRecur(self, tilenumbers, depth, maxDepth, base=0.9):
bestMove, bestScore = 0, -1
for m in range(1,5):
if(self.board.validMove(tilenumbers, m)):
score, newtiles = self.board.moveTileNumbers(tilenumbers[:], m)
score, critical = self.evaluate(newtiles)
newtiles = self.board.setCell(newtiles,critical[0],critical[1],2)
if depth != 0:
my_m,my_s = self.nextMoveRecur(newtiles[:],depth-1,maxDepth)
score += my_s*pow(base,maxDepth-depth+1)
if(score > bestScore):
bestMove = m
bestScore = score
return bestMove, bestScore
def evaluate(self, tilenumbers, commonRatio=0.25):
maxVal = 0.
criticalTile = (-1, -1)
for i in range(8):
linearWeightedVal = 0
invert = False if i<4 else True
weight = 1.
ctile = (-1,-1)
cond = i%4
for y in range(4):
for x in range(4):
if cond==0:
b_x = 4-1-x if invert else x
b_y = y
elif cond==1:
b_x = x
b_y = 4-1-y if invert else y
elif cond==2:
b_x = 4-1-x if invert else x
b_y = 4-1-y
elif cond==3:
b_x = 4-1-x
b_y = 4-1-y if invert else y
currVal=self.board.getCell(tilenumbers,b_x,b_y)
if(currVal == 0 and ctile == (-1,-1)):
ctile = (b_x,b_y)
linearWeightedVal += currVal*weight
weight *= commonRatio
invert = not invert
if linearWeightedVal > maxVal:
maxVal = linearWeightedVal
criticalTile = ctile
return maxVal, criticalTile
def solveBoard(self, moveinterval=500):
boardHWND = self.board.getWindowHandle()
if not boardHWND:
return False
bx, by, bw, bh = cv2.boundingRect(self.board.getBoardContour())
x0, x1, y0, y1 = bx, bx+bw, by, by+bh
win32gui.SetForegroundWindow(boardHWND)
shell = win32com.client.Dispatch('WScript.Shell')
print 'Set the focus to the Game Window, and the press this arrow key:'
keymove = ['UP', 'DOWN', 'LEFT', 'RIGHT']
delay = moveinterval / 3 # milliseconds delay to cancel board animation effect
prev_numbers = []
while True:
numbers, inframe, outframe = self.board.update()
if numbers != prev_numbers:
cv2.waitKey(delay)
numbers, inframe, outframe = self.board.update()
if numbers == prev_numbers: # recheck if has changed
continue
prev_numbers = numbers
move = ai.nextMove()
if move:
key = keymove[move-1]
shell.SendKeys('{%s}'%key)
print key
cv2.waitKey(delay)
cv2.imshow('CV copy',inframe[y0:y1,x0:x1])
cv2.imshow('CV out', outframe[y0:y1,x0:x1])
cv2.waitKey(delay)
cv2.destroyWindow( 'CV copy' )
cv2.destroyWindow( 'CV out' )
# http://gabrielecirulli.github.io/2048/
# http://ov3y.github.io/2048-AI/
board = Board("2048 - Google Chrome")
#board = Board("2048 - Mozilla Firefox")
ai = AI(board)
ai.solveBoard(360)
print 'stopped.'
I have Google Chrome open with the example URL http://ov3y.github.io/2048-AI/ open, running the script has the following error:
20.py:109: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
if board==None:
no tile found!
Set the focus to the Game Window, and the press this arrow key:
Then nothing, it just sits there. So the part I'm concerned with most is no tile found!. Un commenting the lines:
#cv2.rectangle(cvframe,(bx,by),(bx+bw,by+bh),(0,255,0),2)
#cv2.imshow('board',cvframe)
#cv2.waitKey(0)
#cv2.destroyWindow( 'board' )
Shows the following window on screen:
Can anyone explain why OpenCV is failing to detect the grid, or how to go about debugging this?
Most likely it is not a problem with detecting grid, but with capturing browser window - you are trying to find grid on an empty image which of course fails. First make sure that you have grabbed firefox/chrome/opera screen window correctly - in function getClientFrame(self) put this code:
cv2.imshow('browser window', cvimage)
cv2.waitKey(10000)
just before the final return cvimage. It should show you the browser window for 10 seconds. If it doesn't than it will 100% sure that problem is with capturing browser window, not with detecting grid. To check what's wrong with capturing browser window use win32api.GetLastError() function (you can check error codes here).
Of course there is a chance that i'm wrong and it's a problem with detecting grid - if so, please provide a sample image (just save the image displayed by the code i provided) so we can test it.
\\edit:
I've just noticed the second part of your post - so most likely i'm wrong, but you can test it anyway. It seems that you are capturing one chrome window and part of some other window - try to make your browser window fullscreen.
\\edit2:
After closer look at you image i realised strange thing - capture image has vertical lines and has width (without repeated part onthe right side) smaller than the original window(but height seems to be fine). Width seems to be 75% of original width so i guess that PIL treats every 4 bytes as one pixel, but it should use only 3 bytes per pixel. It's hard to test it, because on my system (win 8.1 64bit) it's working fine. Possible solutions (i can't test them, so you need to check which one will work.. sory :) ):
Try to change this line:
pil_img = Image.frombuffer( 'RGB', (bmpinfo['bmWidth'], bmpinfo['bmHeight']), bmpstr, 'raw', 'BGRX', 0, 1)
to something like this:
pil_img = Image.frombuffer( 'RGB', (bmpinfo['bmWidth'], bmpinfo['bmHeight']), bmpstr, 'raw', 'BGR', 0, 1)
generally you need to change value of fifth parameter from BGRX to something else - most likely to 'BGR', full list of options is here. If it won't work try to play with different values of first and fifth parameters.
On the screenshot it looks like you have some quite old version of Windows or at least you are using old gui (which is great btw!). If - except for setting gui style to "old style" - you've set (or windows've done it for you) your color quality to something else than "Highest (32bit)" it may cause your problem as well. Try to set it to "Highest (32 bit)". To be clear - i'm talking about settings from this window:
(on the right side, near bottom and color palette).
If you have 2 (or more) screens, test you program while using only one. Also if you are using some alternative window manager (or some other weird extension like something for multiple desktops) turn it off and try again.
i am a beginner to Python and i'm having some problem with a project.
My grid looks like this :
class World(object):
def __init__(self):
self.grid = []
xsize = 20
ysize = 20
self.maxX = xsize
self.maxY = ysize
for irow in range(self.maxY):
row = []
for icol in range(self.maxX):
row.append(None)
self.grid.append(row)
positions = []
for i in range(self.maxX):
for j in range(self.maxY):
positions.append((i,j))
numteam1 = 0
numteam2 = 0
numrobot = 0
randpos = random.sample(positions, numteam1 + numteam2)
team1 = randpos[0:numrobot-1]
team2 = randpos[numrobot:]
for point in team1:
x = point[0]
y = point[1]
self.grid[y][x] = AttackRobot(1, x, y, self)
self.grid[y][x] = MedicRobot(1, x, y, filename)
for point in team2:
x = point[0]
y = point[1]
self.grid[y][x] = AttackRobot(2,x,y,self)
self.grid[y][x] = MedicRobot(2,x,y,self, filename)
and then i have this method:
def test_position(self, x, y):
if x <0 or x >= 20:
return None
if y <0 or y >= 20:
return None
else:
return ( self.grid[y][x] = Robot)
this fonction is supposed to return element at (x,y) on the grid
Then i use this method in this method :
def print_board(w):
print "-" * 60
for y in range(19,-1,-1):
line = ""
for x in range(0,20):
r = w.test_position(x, y)
if r == None:
line += ".... "
else:
if isinstance(r, AttackRobot):
rtype = "A"
elif isinstance(r, MedicRobot):
rtype = "M"
else:
rtype = "!"
if r.get_team() == 1:
line += "%s%02i%s " % (rtype, r.get_health(), r.get_direction())
else:
line += "%s%02i%s " % (rtype.lower(), r.get_health(), r.get_direction())
print line
print "-" * 60
and i get an error.
Traceback (most recent call last):
File "T05.py", line 10, in <module>
print_board(world)
File "/Users/quentindumoulin/Desktop/test.py", line 19, in print_board
if r.get_team() == 1:
AttributeError: 'bool' object has no attribute 'get_team'
return ( self.grid[y][x] = Robot)
What is it? Maybe you want
return self.grid[y][x]
?