def detect(self): faces = [] eyes = [] rgb_green = (0, 255, 0) rgb_blue = (0, 0, 255) detected_faces = self.__detect_faces() for (x, y, w, h) in detected_faces: face = Face(self.image, x, y, w, h, rgb_green) face.draw(2) faces.append(face) detected_eyes = self.__detect_eyes(face.data()) if len(detected_eyes) > 0: for(eye_x, eye_y, eye_w, eye_h) in detected_eyes: eye = Eye(self.image, face.x + eye_x, face.y + eye_y, eye_w, eye_h, rgb_blue) eye.draw(2) eyes.append(eye) detected_smile = self.__detect_smile(face.data()) if len(detected_smile) > 0: smileness = detected_smile[0][1] smile_text_position = ((x - 15), y + (h + 25)) if smileness >= 15: cv2.putText(self.image, "Smiling: Yes", smile_text_position, cv2.FONT_HERSHEY_DUPLEX, 1, (255,255,255)) else: cv2.putText(self.image, "Smiling: No", smile_text_position, cv2.FONT_HERSHEY_DUPLEX, 1, (255,255,255)) return { "faces" : faces, "eyes" : eyes}
def detect(self): faces = [] eyes = [] rgb_green = (0, 255, 0) rgb_blue = (0, 0, 255) detected_faces = self.__detect_faces() for (x, y, w, h) in detected_faces: face = Face(self.image, x, y, w, h, rgb_green) face.draw(2) faces.append(face) detected_eyes = self.__detect_eyes(face.data()) if len(detected_eyes) > 0: for (eye_x, eye_y, eye_w, eye_h) in detected_eyes: eye = Eye(self.image, face.x + eye_x, face.y + eye_y, eye_w, eye_h, rgb_blue) eye.draw(2) eyes.append(eye) detected_smile = self.__detect_smile(face.data()) if len(detected_smile) > 0: smileness = detected_smile[0][1] smile_text_position = ((x - 15), y + (h + 25)) if smileness >= 15: cv2.putText(self.image, "Smiling: Yes", smile_text_position, cv2.FONT_HERSHEY_DUPLEX, 1, (255, 255, 255)) else: cv2.putText(self.image, "Smiling: No", smile_text_position, cv2.FONT_HERSHEY_DUPLEX, 1, (255, 255, 255)) return {"faces": faces, "eyes": eyes}
def __init__(self, fill_color): Eye.__init__(self, fill_color) self._pixbufs = [] self._pixbufs.append(svg_str_to_pixbuf(lefteye_svg())) self._pixbufs.append(svg_str_to_pixbuf(centereye_svg())) self._pixbufs.append(svg_str_to_pixbuf(righteye_svg())) self._which_eye = 1
def __init__(self, fill_color): Eye.__init__(self, fill_color) self._pixbufs = [] self._pixbufs.append(svg_str_to_pixbuf(lefteye_svg())) self._pixbufs.append(svg_str_to_pixbuf(centereye_svg())) self._pixbufs.append(svg_str_to_pixbuf(righteye_svg())) self._which_eye = 2
def __init__(self, position, window): self.window = window self.position = position self.size = 10 self.view_angle = 0 self.eye = Eye(self.position) self.eye.color = BLUE self.color = WHITE self.speed = 4
def __init__(self, x, y, size): # Face position and size. self.x = x self.y = y self.size = size # Create the eyes. self.lefteye = Eye(x - 15, y - 15, 10) self.righteye = Eye(x + 15, y - 15, 10)
def __init__(self, face, frame): self.face = face self.frame = frame self.landmarks = predictor(frame, face) self.face_position = self.posit_predict() eye1 = np.array([[self.landmarks.part(mark).x, self.landmarks.part(mark).y] for mark in range(36, 42)]) eye2 = np.array([[self.landmarks.part(mark).x, self.landmarks.part(mark).y] for mark in range(42, 48)]) self.left_eye = Eye(eye1, self.frame, 'left') self.right_eye = Eye(eye2, self.frame, 'right')
def _analyze(self): frame = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY) faces = self._face_detector(frame) try: landmarks = self._predictor(frame, faces[0]) self.eye_left = Eye(frame, landmarks, 0, self.calibration) self.eye_right = Eye(frame, landmarks, 1, self.calibration) except IndexError: self.eye_left = None self.eye_right = None
def __init__(self, position, window): self.window = window self.position = position self.size = 20 self.view_angle = 0 self.left_eye_pos = Position(self.position.x + 20, self.position.y) self.right_eye_pos = Position(self.position.x - 20, self.position.y) self.left_eye = Eye(self.left_eye_pos) self.right_eye = Eye(self.right_eye_pos) self.left_eye.color = BLUE self.color = WHITE self.speed = 4 self.scene = []
class Face: def __init__(self, x, y, size): # Face position and size. self.x = x self.y = y self.size = size # Create the eyes. self.lefteye = Eye(x - 15, y - 15, 10) self.righteye = Eye(x + 15, y - 15, 10) # Make this Face look at location lx, ly. def look_at(self, lx, ly): self.lefteye.look_at(lx, ly) self.righteye.look_at(lx, ly) def draw(self): enable_stroke() set_fill_color(1, 1, 1) draw_circle(self.x, self.y, self.size) # draw face self.lefteye.draw() # draw eyes self.righteye.draw() # draw eyes draw_line(self.x, self.y, self.x, self.y + 15) # draw nose draw_line(self.x - 15, self.y + 20, self.x + 15, self.y + 20) # draw mouth
def computeBits(self): bits = [] self.eyes = [] self.faces = [] for image in self.images: face = Face(image) eye = Eye(face.frame, face.canvas, padding=10) eye.draw(face) eye.iris.normalizeIris() self.eyes.append(eye) self.faces.append(face) bits.append(eye.iris.bits_pattern) self.bits = np.array(bits)
def __init__(self,resolution,color=(0, 0, 0)): self.screen=pygame.display.set_mode(resolution) self.background = pygame.Surface(self.screen.get_size()) self.background = self.background.convert() self.background.fill(color) center_x=self.background.get_width()/2 self.left_eye=Eye(center_x-250,250) self.right_eye=Eye(center_x+250,250) self.mouth=Mouth(center_x,500) self.photo=Photo() self.draw()
def __init__(self, xy: XYPoint, ship_angle: float, width: int, height: int, n_sensors: int, sensor_resolution: int, sensor_length: int, sensor_width: float): self.xy = xy self.angle = ship_angle self.width = width self.height = height self.n_sensors = n_sensors self.sensor_resolution = sensor_resolution self.sensor_width = sensor_width self.step = 5 self.turn_angle = pi / 12 self.max_eye_length = distance(XYPoint(0, 0), XYPoint(width, height)) self.eye_length = min(sensor_length, self.max_eye_length) eye_max_angle = self.sensor_width if n_sensors > 1: eye_step = (eye_max_angle) / (n_sensors - 1) else: eye_step = 0 self.eyes = [] # add the leftmost eye first, working our way from +sensor_width/2 to -sensor_width/2 for i in range(0, n_sensors): if n_sensors == 1: angle = 0 else: angle = eye_max_angle / 2 - eye_step * i self.eyes.append( Eye(xy, ship_angle, angle, eye_step, self.eye_length, self.width, self.height))
def getMeanEyes(self, bufferLeftEye, bufferRightEye): """Smooth the eye detection by using a rolling mean window over the last detected best eyes. Args: bufferLeftEye (Buffer): Buffer for the last left best eyes chosen bufferRightEye (Buffer): Buffer for the last right best eyes chosen Returns: [Eye, Eye]: Mean best eyes """ # Mean position eyes = [self.best_eye_left, self.best_eye_right] for eye, buffer, type_, index in ((self.best_eye_left, bufferLeftEye, EyeType.LEFT, 0), (self.best_eye_right, bufferRightEye, EyeType.RIGHT, 1)): buffer.addLast(eye) lasts = [item for item in buffer.lasts if item] if lasts: xm = int(np.mean([eye.x for eye in lasts])) ym = int(np.mean([eye.y for eye in lasts])) wm = int(np.mean([eye.w for eye in lasts])) hm = int(np.mean([eye.h for eye in lasts])) if xm + wm < self.w and ym + hm < self.h: eyes[index] = Eye(self.frame, self.canvas, type_, xm, ym, wm, hm) return eyes
def detectEyes(self): """Uses classifiers to detect eyes in the face """ eyes = eye_cascade.detectMultiScale(self.gray, 1.3, 5) self.eyes = [ Eye(self.frame, self.canvas, x, y, w, h) for (x, y, w, h) in eyes ]
def __init__(self): self.capture = cv.CaptureFromCAM(0) cv.SetCaptureProperty(self.capture, cv.CV_CAP_PROP_FRAME_WIDTH, self.IMAGE_WIDTH) cv.SetCaptureProperty(self.capture, cv.CV_CAP_PROP_FRAME_HEIGHT, self.IMAGE_HEIGHT) # cv.NamedWindow("Target", 1) # cv.NamedWindow("Intermediate", 1) self.theGiantEye = Eye() self.interest = 0.0 # how interested we are, 0 - 100
def __init__(self): GPIO.setmode(GPIO.BOARD) self.platform = TurretPlatform() self.arm = LaserArm(INPUT_WINDOW_SIZE) self.root = Tk() self.eye = Eye(CAM_RES[0],CAM_RES[1],10) self.isTracking = False self.trackingHaar = cv2.CascadeClassifier('../CAM/haar/haarcascade_frontalface_default.xml')
class Eyes: def __init__(self): self.left_eye = Eye() self.right_eye = Eye() def display(self, x, y, direction): self.left_eye.look(direction) self.right_eye.look(direction) self.left_eye.display(x - 20, y) self.right_eye.display(x + 20, y)
def group_eye(self, x, y, w, h, now): found = False for group in self.eyeGroups: if group.update_group1(x, y, w, h, now): found = True break if not found: group = Eye(x + w / 2, y + h / 2, w, h, now) self.eyeGroups.append(group) return group
class Eyes: def __init__(self): """Eyes constructor""" self.left_eye = Eye() self.right_eye = Eye() def display(self, x, y, direction): """Display eyes direction""" self.left_eye.look(direction) self.right_eye.look(direction) self.left_eye.display(x-20, y) self.right_eye.display(x+20, y)
def __init__(self): """ コンストラクタが呼ばれた後に呼ばれるメソッド """ # Raspberry Pi pin configuration: RST = 24 # 128x64 display with hardware I2C: self.__disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST) # Initialize library. self.__disp.begin() # Get display width and height. self.__width = self.__disp.width self.__height = self.__disp.height # Clear display. self.__disp.clear() self.__disp.display() # Create image buffer. # Make sure to create image with mode '1' for 1-bit color. self.__image = Image.new('1', (self.__width, self.__height)) # Create drawing object. self.__draw = ImageDraw.Draw(self.__image) # Clear image buffer by drawing a black filled box. self.__draw.rectangle((0, 0, self.__width, self.__height), outline=0, fill=0) # Draw the image buffer. self.__disp.image(self.__image) self.__disp.display() # 左右の目のインスタンスを作成 # ここでの左右はディスプレイとしての左右であり、顔としての左右とは逆である self.__eye_l = Eye() self.__eye_r = Eye() self.set_nomal()
def _analyze(self, cntFace): """Detects the face and initialize Eye objects""" frame = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY) # cv2.imwrite("image.png",frame) # if cntFace == 0: # faces = self._face_detector(frame, 1) # self.gface = faces[0] if cntFace == 0: faces = self._face_detector(frame, 1) self.gface = faces[0] try: landmarks = self._predictor(frame, self.gface) # landmarks = face_utils.shape_to_np(landmarks) self.eye_left = Eye(frame, landmarks, 0, self.calibration) self.eye_right = Eye(frame, landmarks, 1, self.calibration) except IndexError: self.eye_left = None self.eye_right = None
class Cyclops(): def __init__(self, position, window): self.window = window self.position = position self.size = 10 self.view_angle = 0 self.eye = Eye(self.position) self.eye.color = BLUE self.color = WHITE self.speed = 4 def move(self, position): for element in self.scene: #on_line = (-3 < (distance(element.a, position) + distance(position, element.b) - distance(element.a, element.b)) < 3) if False: print("collision") return else: self.position.translate_to(position) def forward(self): direction = Position(math.sin(self.view_angle), math.cos(self.view_angle)) direction = direction.multipy(self.speed) self.move(self.position.plus(direction)) def backward(self): direction = Position(math.sin(self.view_angle), math.cos(self.view_angle)) direction = direction.multipy(self.speed) self.move(self.position.minus(direction)) def rotate(self, direction): self.eye.view_angle += direction self.view_angle += direction def show(self): #pygame.draw.circle(window, self.color, self.position.toTuple(), self.size, 1) self.eye.show(self.window) lineEnd = (self.position.x + math.sin(self.view_angle) * (self.size - 2), self.position.y + math.cos(self.view_angle) * (self.size - 2)) pygame.draw.line(self.window, (255, 255, 255), self.position.toTuple(), lineEnd, 2) def see(self): self.eye.update() self.eye.see(self.scene) self.render() def render(self): render = Image(self.eye.rays) render.draw2D(Position(0, MAP_HEIGHT), self.window)
def __init__(self): # Global variables for executions self._title_exam = '' self._path_dataset_out = '' # Dependences self._process = ProcessImage() self._pupil = Pupil() self._eye = Eye() # Limit cash dependences self._max_execution_with_cash = 20 # Directoris self._projects_path = '/media/marcos/Dados/Projects' self._dataset_path = '{}/Datasets/exams'.format(self._projects_path) self._dataset_out = '{}/Results/PupilDeep/Frames'.format( self._projects_path) self._dataset_label = '{}/Results/PupilDeep/Labels'.format( self._projects_path) # Stops and executions self._frame_stop = 150 self._frame_start = 100 self._movie_stop = 0 self._list_not_available = [] self._list_available = [ '25080325_08_2019_08_48_58', '25080425_08_2019_08_53_48' ] # self._list_available = ['25080325_08_2019_08_48_58', '25080425_08_2019_08_53_48', '25080425_08_2019_08_55_59', '25080425_08_2019_09_05_40', '25080425_08_2019_09_08_25'] # self._list_available = ['new_benchmark'] # Params color self._white_color = (255, 255, 0) self._gray_color = (170, 170, 0) # Params text and circle print image self._position_text = (30, 30) self._font_text = cv2.FONT_HERSHEY_DUPLEX self._size_point_pupil = 5 # Params dataset labels out self._title_label = 'frame,center_x,center_y,radius,flash,eye_size,img_mean,img_std,img_median'
class ChatConnection(tornadio2.conn.SocketConnection): # Class level variable participants = set() self.auto=Auto([29,31,33,35,38,40]) self.network = UnmannedNet(768,60,2) self.eye=Eye("192.168.10.1") def on_open(self, info): #当网页发起连接后发送 self.send("Welcome from the server.") self.participants.add(self) #保存客户端客户的信息 def on_message(self, message): #有消息进来后 # Pong message back #for p in self.participants: #进行广播 #p.send(message) value=message.split(",") alpha=int(float(value[0])) beta=int(float(value[1])) gamma=int(float(value[2])) self.auto.control(beta,gamma) self.network.adddata(self.eye.getResizeImage(),(beta,gamma)) def on_close(self): #连接关闭后删除信息 self.participants.remove(self) self.network.save_data()
def __init__(self): self.left_eye = Eye() self.right_eye = Eye()
def __init__(self, fill_color): Eye.__init__(self, fill_color) self._pixbuf = svg_str_to_pixbuf(eye_svg())
from eye import Eye pixel_pin = board.D18 nbPixelsPerRing = 16 nbRings = 2 nbPixels = nbRings * nbPixelsPerRing # The order of the pixel colors - RGB or GRB. Some NeoPixels have red and green reversed! # For RGBW NeoPixels, simply change the ORDER to RGBW or GRBW. ORDER = neopixel.GRB pixels = neopixel.NeoPixel(pixel_pin, nbPixels, brightness=0.2, auto_write=False, pixel_order=ORDER) rightEye = Eye(pixels, 0, nbPixelsPerRing, 0) #4 leftEye = Eye(pixels, 16, nbPixelsPerRing, 14) #2 def neopixelAllOff(): pixels.fill((0, 0, 0)) pixels.show() def neopixelAllOnWhite(): pixels.fill((255, 255, 255)) pixels.show()
class World(): ''' This class contains the eye, that is the point from where the world is seen, and the list of walls included in the world. ''' def __init__(self): # Initialize Wall list and Eye self.walls = [] self.eye = Eye(0, 0, Direction.North) def loadWalls(self, fname): # Manage loading of walls from file. f = open(fname, 'r') with f: self.walls = [] # Empty list from any existing walls. data = f.readline() # Read firs line, that should contain data for the eye. If this line does not exist, the file is not valid. eye = data.split(':') self.eye.setCoords([int(eye[0]), int(eye[1])], int(eye[2])) data = f.readline() # Read next line, walls should start here, if any exist. while data: # Add all wall to the wall list one by one until EOF is reached. wall = data.split(' ') coords1 = wall[0].split(':') coords2 = wall[1].split(':') self.addWall(Wall([int(coords1[0]), int(coords1[1])], [int(coords2[0]), int(coords2[1])])) data = f.readline() f.close() def sortWalls(self): # Sort walls by distance to eye for drawing. def keyfunc(wall): c1 = wall.getFirstCoords() c2 = wall.getSecondCoords() z1 = (c1[0] - self.eye.getX())**2 + (c1[1] - self.eye.getY())**2 z2 = (c2[0] - self.eye.getX())**2 + (c2[1] - self.eye.getY())**2 if z1 > z2: return z2 else: return z1 self.walls.sort(key=keyfunc, reverse=True) def drawWalls(self, painter): self.sortWalls() for wall in self.walls: wall.drawWall(painter, self.eye) def moveEye(self, key): # Move eye if move is allowed. Only necessary to check the eight closest walls for collision, # which is easy because the list is already sorted by distance. newcoors = self.eye.move(key) i = 1 for wall in reversed(self.walls): if wall.getFirstCoords() == [newcoors[0], newcoors[1]] or wall.getSecondCoords() == [newcoors[0], newcoors[1]]: return i += 1 if i > 8: break self.eye.setCoords([newcoors[0], newcoors[1]], newcoors[2]) def editWall(self, key): point = self.eye.getPoint() direction = point[2] coords2 = [point[0], point[1]] if direction == Direction.North: coords2[0] += 1 elif direction == Direction.East: coords2[1] -= 1 elif direction == Direction.South: coords2[0] -= 1 elif direction == Direction.West: coords2[1] += 1 for wall in self.walls: if wall.getFirstCoords() == [point[0], point[1]] or wall.getSecondCoords() == [point[0], point[1]]: if key == QtCore.Qt.Key_Backspace: self.rmWall(wall) return else: if wall.getFirstCoords() == coords2 or wall.getSecondCoords() == coords2: return self.addWall(Wall([point[0], point[1]], coords2)) def addWall(self, wall): self.walls.append(wall) def rmWall(self, wall): self.walls.remove(wall)
def __init__(self, fill_color): Eye.__init__(self, fill_color)
def __init__(self): # Initialize Wall list and Eye self.walls = [] self.eye = Eye(0, 0, Direction.North)
def run(self): """Main loop """ self.startCapture() data_collector = DataCollector(self.dataset) modeFullFace = 0 modeOneEye = 1 modePictures = 2 modeTwoEyes = 3 modeImgDB = 4 modeDemo = 5 mode = modeDemo keepLoop = True current_t = time.clock() previous_t = current_t while keepLoop: pressed_key = cv2.waitKey(1) current_t = time.clock() #print('\nclock : ', current_t - previous_t) previous_t = current_t img = self.getCameraImage() if(mode == modeOneEye): ex = 300 ey = 50 eh = 200 ew = 200 face = Face(img.frame, img.canvas, 0, 0, 640, 480) eye = Eye(face.frame, face.canvas, ex, ey, ew, eh) eye.draw(face) eye.iris.normalizeIris() elif(mode == modeTwoEyes): face = Face(img.frame, img.canvas, 0, 0, 640, 480) left_eye = Eye(face.frame, face.canvas, 50, 50, 200, 200, EyeType.LEFT) left_eye.draw(face) left_eye.iris.normalizeIris() right_eye = Eye(face.frame, face.canvas, 400, 50, 200, 200, EyeType.RIGHT) right_eye.draw(face) right_eye.iris.normalizeIris() elif(mode == modeFullFace): face, left_eye, right_eye = img.detectEyes(self.bufferFace, self.bufferLeftEye, self.bufferRightEye) if face: face.draw(img) if left_eye: left_eye.draw(face) left_eye.iris.normalizeIris() if right_eye: right_eye.draw(face) right_eye.iris.normalizeIris() elif(mode == modeImgDB): img_db = ImageDB("./IR_Database/MMU Iris Database/") print(img_db.estimateUser(img_db.bits[0])) exit() elif(mode == modeDemo): path = "./TB_Database/" face = Face(img.frame, img.canvas, 0, 0, 640, 480) left_eye = Eye(face.frame, face.canvas, 50, 50, 200, 200, EyeType.LEFT) left_eye.draw(face) left_eye.iris.normalizeIris() right_eye = Eye(face.frame, face.canvas, 400, 50, 200, 200, EyeType.RIGHT) right_eye.draw(face) right_eye.iris.normalizeIris() if(ord('0') <= pressed_key & 0xFF <= ord('9')): print('0-9') id_person = chr(pressed_key & 0xFF) while((pressed_key & 0xFF) not in [ord('a'), ord('p')]): pressed_key = cv2.waitKey(50) print(pressed_key & 0xFF) if(pressed_key & 0xFF == ord('a')): cv2.imwrite(path + id_person + '/left/' + str(int(time.time() * 1000)) + '.bmp', left_eye.frame) cv2.imwrite(path + id_person + '/right/' + str(int(time.time() * 1000)) + '.bmp', right_eye.frame) else: path = "./IR_Database/MMU Iris Database/" for dir in os.listdir(path): subpath = path + dir + '/' if(os.path.isdir(subpath)): print(dir) for subdir in os.listdir(subpath): subsubpath = subpath + subdir + '/' if(os.path.isdir(subsubpath)): print('\t', subdir) for fname in os.listdir(subsubpath): fpath = subsubpath + fname if(os.path.isfile(fpath) and os.path.splitext(fname)[1] == '.bmp'): print('\t\t', fname) img = Image(cv2.imread(fpath)) face = Face(img.frame, img.canvas) eye = Eye(face.frame, face.canvas, padding=10) eye.draw(face) eye.iris.normalizeIris() img.show() pressed_key = cv2.waitKey(1000) exit() # Controls if pressed_key & 0xFF == ord('q'): keepLoop = False #if pressed_key & 0xFF == ord('s'): # self.dataset.save() #if pressed_key & 0xFF == ord('l'): # self.dataset.load() #if pressed_key & 0xFF == ord('m'): # self.showMoments = not self.showMoments #if pressed_key & 0xFF == ord('e'): # self.showEvaluation = not self.showEvaluation #data_collector.step(img.canvas, pressed_key, left_eye, right_eye) #txt = 'Dataset: {} (s)ave - (l)oad'.format(len(self.dataset)) #cv2.putText(img.canvas, txt, (21, img.canvas.shape[0] - 29), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (32, 32, 32), 2) #cv2.putText(img.canvas, txt, (20, img.canvas.shape[0] - 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 126, 255), 2) #if left_eye and right_eye: # direction = self.dataset.estimateDirection(left_eye.computeMomentVectors(), right_eye.computeMomentVectors()) # txt = 'Estimated direction: {}'.format(direction.name) # cv2.putText(img.canvas, txt, (21, img.canvas.shape[0] - 49), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (32, 32, 32), 2) # cv2.putText(img.canvas, txt, (20, img.canvas.shape[0] - 50), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 126, 255), 2) img.show() #if self.showEvaluation: # fig = self.dataset.showValidationScoreEvolution() # plt.show() # self.showEvaluation = False #if self.showMoments: # fig = self.dataset.drawVectorizedMoments() # plt.show() # # cv2.imshow('moments', self.fig2cv(fig)) # # plt.close(fig) # self.showMoments = False self.stopCapture()
def __init__(self): """Eyes constructor""" self.left_eye = Eye() self.right_eye = Eye()
def test_look(): """Test look method""" e = Eye() e.look((1, 1)) assert e.direction == (1, 1)
class Face: def __init__(self,resolution,color=(0, 0, 0)): self.screen=pygame.display.set_mode(resolution) self.background = pygame.Surface(self.screen.get_size()) self.background = self.background.convert() self.background.fill(color) center_x=self.background.get_width()/2 self.left_eye=Eye(center_x-250,250) self.right_eye=Eye(center_x+250,250) self.mouth=Mouth(center_x,500) self.photo=Photo() self.draw() def draw(self): self.screen.blit(self.background,(0,0)) self.left_eye.draw(self.screen) self.right_eye.draw(self.screen) self.mouth.draw(self.screen) pygame.display.flip() def surprise(self): self.left_eye.draw(self.screen,"up") self.right_eye.draw(self.screen,"up") def sad(self): self.left_eye.draw(self.screen,"brownleft") self.right_eye.draw(self.screen,"brownright") self.mouth.draw(self.screen,"sad") def angry(self): self.left_eye.draw(self.screen,"brownright") self.right_eye.draw(self.screen,"brownleft") def look_left(self): self.left_eye.draw(self.screen,"left") self.right_eye.draw(self.screen,"left") def look_right(self): self.left_eye.draw(self.screen,"right") self.right_eye.draw(self.screen,"right") def blink_left(self): self.left_eye.blink(self.screen) def blink_right(self): self.right_eye.blink(self.screen) def close_both(self): self.left_eye.draw(self.screen,"close") self.right_eye.draw(self.screen,"close") def open_both(self): self.left_eye.status="open" self.right_eye.status="open" self.left_eye.draw(self.screen) self.right_eye.draw(self.screen) def blink_both(self): self.close_both() time.sleep(0.10) self.open_both()
def test_constructor(): """Test Eye constructor""" e = Eye() assert e.direction == (0, 0)
def __init__(self, fill_color): Eye.__init__(self, fill_color) self._pixbuf = svg_str_to_pixbuf(eyelashes_svg())
def analyze_color_unconditional_status(self, color): """1) List potential eyes (eyes: empty+opponent areas flood filled): all empty points must be adjacent to those neighbour blocks with given color it gives eye. 2) List all blocks with given color that have at least 2 of above mentioned areas adjacent and has empty point from it as liberty. 3) Go through all potential eyes. If there exists neighbour block with less than 2 eyes: remove this this eye from list. 4) If any changes in step 3, go back to step 2. 5) Remaining blocks of given color are unconditionally alive and and all opponent blocks inside eyes are unconditionally dead. 6) Finally update status of those blocks we know. 7) Analyse dead group status. See test.py for testcases """ #find potential eyes eye_list = [] not_ok_eye_list = [] #these might still contain dead groups if totally inside live group eye_colors = EMPTY + other_side[color] for block in self.iterate_blocks(EMPTY+WHITE+BLACK): block.eye = None for block in self.iterate_blocks(eye_colors): if block.eye: continue current_eye = Eye() eye_list.append(current_eye) blocks_to_process = [block] while blocks_to_process: block2 = blocks_to_process.pop() if block2.eye: continue block2.eye = current_eye current_eye.parts.append(block2) for pos in block2.neighbour: block3 = self.blocks[pos] if block3.color in eye_colors and not block3.eye: blocks_to_process.append(block3) #check that all empty points are adjacent to our color ok_eye_list = [] for eye in eye_list: prev_our_blocks = None eye_is_ok = False for stone in eye.iterate_stones(): if self.goban[stone]!=EMPTY: continue eye_is_ok = True our_blocks = [] for pos in self.iterate_neighbour(stone): block = self.blocks[pos] if block.color==color and block not in our_blocks: our_blocks.append(block) #list of blocks different than earlier if prev_our_blocks!=None and prev_our_blocks != our_blocks: ok_our_blocks = [] for block in our_blocks: if block in prev_our_blocks: ok_our_blocks.append(block) our_blocks = ok_our_blocks #this empty point was not adjacent to our block or there is no block that has all empty points adjacent to it if not our_blocks: eye_is_ok = False break prev_our_blocks = our_blocks if eye_is_ok: ok_eye_list.append(eye) eye.our_blocks = our_blocks else: not_ok_eye_list.append(eye) #remove reference to eye that is not ok for block in eye.parts: block.eye = None eye_list = ok_eye_list #first we assume all blocks to be ok for block in self.iterate_blocks(color): block.eye_count = 2 #main loop: at end of loop check if changes while True: changed_count = 0 for block in self.iterate_blocks(color): #not really needed but short and probably useful optimization if block.eye_count < 2: continue #count eyes block_eye_list = [] for stone in block.neighbour: eye = self.blocks[stone].eye if eye and eye not in block_eye_list: block_eye_list.append(eye) #count only those eyespaces which have empty point(s) adjacent to this block block.eye_count = 0 for eye in block_eye_list: if block in eye.our_blocks: block.eye_count = block.eye_count + 1 if block.eye_count < 2: changed_count = changed_count + 1 #check eyes for required all groups 2 eyes ok_eye_list = [] for eye in eye_list: eye_is_ok = True for block in self.iterate_neighbour_eye_blocks(eye): if block.eye_count < 2: eye_is_ok = False break if eye_is_ok: ok_eye_list.append(eye) else: changed_count = changed_count + 1 not_ok_eye_list.append(eye) #remove reference to eye that is not ok for block in eye.parts: block.eye = None eye_list = ok_eye_list if not changed_count: break #mark alive and dead blocks for block in self.iterate_blocks(color): if block.eye_count >= 2: block.status = UNCONDITIONAL_LIVE for eye in eye_list: eye.mark_status(color) #for heuristical death search if self.assumed_unconditional_alive_list: for pos in self.assumed_unconditional_alive_list: block = self.blocks[pos] block.status = UNCONDITIONAL_LIVE extend_color = block.color blocks2analyse = [] for block in self.iterate_blocks(extend_color): if block.status==UNCONDITIONAL_LIVE: blocks2analyse.append(block) while blocks2analyse: block1 = blocks2analyse.pop() for block2 in self.iterate_blocks(extend_color): if block2.status==UNCONDITIONAL_UNKNOWN and \ len(self.block_connection_status(block1.get_origin(), block2.get_origin()))>=2: blocks2analyse.append(block2) block2.status = UNCONDITIONAL_LIVE #Unconditional dead part: #Mark all groups with only 1 potential empty point and completely surrounded by live groups as dead. #All empty points adjacent to live group are not counted. for eye_group in not_ok_eye_list: eye_group.dead_analysis_done = False for eye_group in not_ok_eye_list: if eye_group.dead_analysis_done: continue eye_group.dead_analysis_done = True true_eye_list = [] false_eye_list = [] eye_block = Block(eye_colors) #If this is true then creating 2 eyes is impossible or we need to analyse false eye status. #If this is false, then we are unsure and won't mark it as dead. two_eyes_impossible = True has_unconditional_neighbour_block = False maybe_dead_group = Eye() blocks_analysed = [] blocks_to_analyse = eye_group.parts[:] while blocks_to_analyse and two_eyes_impossible: block = blocks_to_analyse.pop() if block.eye: block.eye.dead_analysis_done = True blocks_analysed.append(block) if block.status==UNCONDITIONAL_LIVE: if block.color==color: has_unconditional_neighbour_block = True else: two_eyes_impossible = False continue maybe_dead_group.parts.append(block) for pos in block.stones: eye_block.add_stone(pos) if block.color==EMPTY: eye_type = self.analyse_eye_point(pos, color) elif block.color==color: eye_type = self.analyse_opponent_stone_as_eye_point(pos) else: continue if eye_type==None: continue if eye_type==True: if len(true_eye_list) == 2: two_eyes_impossible = False break elif len(true_eye_list) == 1: if self.are_adjacent_points(pos, true_eye_list[0]): #Second eye point is adjacent to first one. true_eye_list.append(pos) else: #Second eye point is not adjacent to first one. two_eyes_impossible = False break else: #len(empty_list) == 0 true_eye_list.append(pos) else: #eye_type==False false_eye_list.append(pos) if two_eyes_impossible: #bleed to neighbour blocks that are at other side of blocking color block: #consider whole area surrounded by unconditional blocks as one group for pos in block.neighbour: block = self.blocks[pos] if block not in blocks_analysed and block not in blocks_to_analyse: blocks_to_analyse.append(block) #must be have some neighbour groups: #for example board that is filled with stones except for one empty point is not counted as unconditionally dead if two_eyes_impossible and has_unconditional_neighbour_block: if (true_eye_list and false_eye_list) or \ len(false_eye_list) >= 2: #Need to do false eye analysis to see if enough of them turn to true eyes. both_eye_list = true_eye_list + false_eye_list stone_block_list = [] #Add holes to eye points for eye in both_eye_list: eye_block.remove_stone(eye) #Split group by eyes. new_mark = 2 #When stones are added they get by default value True (==1) for eye in both_eye_list: for pos in self.iterate_neighbour(eye): if pos in eye_block.stones: self.flood_mark(eye_block, pos, new_mark) splitted_block = self.split_marked_group(eye_block, new_mark) stone_block_list.append(splitted_block) #Add eyes to block neighbour. for eye in both_eye_list: for pos in self.iterate_neighbour(eye): for block in stone_block_list: if pos in block.stones: block.neighbour[eye] = True #main false eye loop: at end of loop check if changes while True: changed_count = 0 #Remove actual false eyes from list. for block in stone_block_list: if len(block.neighbour)==1: neighbour_list = block.neighbour.keys() eye = neighbour_list[0] both_eye_list.remove(eye) #combine this block and eye into other blocks by 'filling' false eye block.add_stone(eye) for block2 in stone_block_list[:]: if block!=block2 and eye in block2.neighbour: block.add_block(block2) stone_block_list.remove(block2) del block.neighbour[eye] changed_count = changed_count + 1 break #we have changed stone_block_list, restart if not changed_count: break #Check if we have enough eyes. if len(both_eye_list) > 2: two_eyes_impossible = False elif len(both_eye_list) == 2: if not self.are_adjacent_points(both_eye_list[0], both_eye_list[1]): two_eyes_impossible = False #False eye analysis done: still surely dead if two_eyes_impossible: maybe_dead_group.mark_status(color)
class Target: IMAGE_WIDTH = 352 IMAGE_HEIGHT = 288 INITIAL_STARE_COUNT = 5 # how many frames without proximate movement before we start tracking a new blob TRACKING_PROXIMITY = 20.0 # blobs further away than this are considered not part of the tracked object def __init__(self): self.capture = cv.CaptureFromCAM(0) cv.SetCaptureProperty(self.capture, cv.CV_CAP_PROP_FRAME_WIDTH, self.IMAGE_WIDTH) cv.SetCaptureProperty(self.capture, cv.CV_CAP_PROP_FRAME_HEIGHT, self.IMAGE_HEIGHT) # cv.NamedWindow("Target", 1) # cv.NamedWindow("Intermediate", 1) self.theGiantEye = Eye() self.interest = 0.0 # how interested we are, 0 - 100 def drawRect(self, image, rect): pt1 = (rect[0], rect[1]) pt2 = (rect[0] + rect[2], rect[1] + rect[3]) cv.Rectangle(image, pt1, pt2, cv.CV_RGB(255,0,0), 1) def bullsEye(self, image, point): cv.Circle(image, point, 40, cv.CV_RGB(255, 255, 255), 1) cv.Circle(image, point, 30, cv.CV_RGB(255, 100, 0), 1) cv.Circle(image, point, 20, cv.CV_RGB(255, 255, 255), 1) cv.Circle(image, point, 10, cv.CV_RGB(255, 100, 0), 5) def calcAzimuth(self, point): xoffs = point[0] - self.image_centre[0] yoffs = point[1] - self.image_centre[1] return 180.0 - 180.0 * math.atan2(yoffs, xoffs) / math.pi def calcAltitude(self, point): # outside of image donut is horizontal-ish (-20 degrees) # inside of image dount is steeply down (-70) # for servo, 30 is steep down, 90 is horizontal d = self.distance(self.image_centre, point) inner_radius = 45.0 outer_radius = 120.0 angle_min = 60.0 # steep down angle_max = 90.0 # nearly horizontal if d < inner_radius: return angle_min elif d > outer_radius: return angle_max else: return (d - inner_radius) / (outer_radius - inner_radius) * (angle_max - angle_min) + angle_min def area(self, rect): return rect[2] * rect[3] def centre(self, rect): return (rect[0] + rect[2] / 2, rect[1] + rect[3] / 2) def distance(self, p1, p2): return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2) def chooseTrackingPoint(self, rectangles, last): if len(rectangles) == 0: return None # given non-empty list of rectangles # ideas: choose the rectangle closest to the last one; if no last one, choose the biggest # if all rectangles are too far away, return None # return the centre point of the chosen rectangle def proximity(rect): c = self.centre(rect) return self.distance(c, last) if last: choice = sorted(rectangles, key=proximity)[0] # we want the nearest if proximity(choice) > 50.0: # but forget it if too far away # print "ignoring blob at distance ", proximity(choice) choice = None # else: # print "tracking blob ", choice, "at distance ", proximity(choice) else: choice = sorted(rectangles, key=self.area)[0] # we want the biggest # print "biggest blob is ", choice return self.centre(choice) if choice else None def applyMask(self, image): cv.Circle(image, self.image_centre, 45, cv.CV_RGB(127, 127, 127), -1) cv.Circle(image, self.image_centre, 150, cv.CV_RGB(127, 127, 127), 100) def incInterest(self): if self.interest < 100.0: self.interest += 5.0 def decInterest(self): if self.interest > 0.0: self.interest -= 5.0 def loseInterest(self): self.interest = 0.0 def calibrate(self): # Set the servos to known positions so we can assemble the hardware # Set alt to level self.theGiantEye.setAltitude(90) #Set azimuth to straigh ahead self.theGiantEye.setAzimuth(90) # set the pupil to min interest, all the way out self.theGiantEye.setPupil(0) def run(self): # Capture first frame to get size frame = cv.QueryFrame(self.capture) frame_size = cv.GetSize(frame) self.image_centre = (frame_size[0] / 2, frame_size[1] / 2) self.applyMask(frame) difference = cv.CloneImage(frame) temp = cv.CloneImage(frame) grey_image = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 1) moving_average = cv.CreateImage(frame_size, cv.IPL_DEPTH_32F, 3) cv.ConvertScale(frame, moving_average, 1.0, 0.0) print 'Size: ', frame_size stare_count = self.INITIAL_STARE_COUNT tracking_point = None while True: # Capture frame from webcam color_image = cv.QueryFrame(self.capture) self.applyMask(frame) # Smooth to get rid of false positives # cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0) # third parameter is weight, originally 0.020 cv.RunningAvg(color_image, moving_average, 0.1, None) # Convert the scale of the moving average. cv.ConvertScale(moving_average, temp, 1.0, 0.0) # Minus the current frame from the moving average. cv.AbsDiff(color_image, temp, difference) # Convert the image to grayscale. cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY) # Convert the image to black and white. Threshold was originally 70 cv.Threshold(grey_image, grey_image, 30, 255, cv.CV_THRESH_BINARY) # cv.ShowImage("Intermediate", grey_image) # Dilate and erode to get object blobs cv.Dilate(grey_image, grey_image, None, 18) cv.Erode(grey_image, grey_image, None, 10) # Calculate movements storage = cv.CreateMemStorage(0) contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE) # contour is a CVSeq object: http://docs.opencv.org/modules/core/doc/dynamic_structures.html#cvseq # it represents a sequence of contours; each contour is a vector of points # cvseq object is itself an iterable over the first vector in the sequence rectangles = [] while contour: # Draw rectangles bound_rect = cv.BoundingRect(list(contour)) # bound_rect is (x, y, width, height) # print "Rectangle: ", bound_rect # move to next contour in the sequence contour = contour.h_next() self.drawRect(color_image, bound_rect) rectangles.append(bound_rect) candidate = self.chooseTrackingPoint(rectangles, tracking_point) if candidate: tracking_point = candidate stare_count = self.INITIAL_STARE_COUNT self.incInterest() else: # idea: count down a few frames before forgetting the tracking point if stare_count: stare_count -= 1 self.decInterest() else: tracking_point = None self.loseInterest() if tracking_point: # draw bull's eye self.bullsEye(color_image, tracking_point) azimuth = self.calcAzimuth(tracking_point) print "Azimuth: ", azimuth self.theGiantEye.setAzimuth(azimuth) altitude = self.calcAltitude(tracking_point) print "Altitude: ", altitude self.theGiantEye.setAltitude(altitude) # always display the interest level print "Interest: ", self.interest self.theGiantEye.setPupil(self.interest) # if lost interest, stare into the distance if self.interest < 5.0: self.theGiantEye.setAltitude(90.0) # Display frame to user # cv.ShowImage("Target", color_image) time.sleep(0.001) # Listen for ESC or ENTER key c = cv.WaitKey(7) % 0x100 if c == 27 or c == 10: break
class Agent: def __init__(self, queue_world, queue_monitor=None): self.queue_world = queue_world self.queue_monitor = queue_monitor def _init_model(self): self.eye = Eye() self.A = gnp.zeros((5000,5000)) def run_model(self, input_data): d_x = random.randint(-16, 16) d_y = random.randint(-16, 16) d_angle = random.randint(-15, 15) d_scale = 2**random.uniform(-0.5, 0.5) return (d_x, d_y, d_angle, d_scale) def move_eye(self, output_data): d_x, d_y, d_angle, d_scale = output_data self.eye_pos = (self.eye_pos[0] + d_x*self.eye_scale, self.eye_pos[1] + d_y*self.eye_scale) self.eye_scale *= d_scale self.eye_angle += d_angle self.eye_pos = \ (min(max(self.eye_pos[0], 0), self.world_size[0]-1), min(max(self.eye_pos[1], 0), self.world_size[1]-1)) self.eye_scale = min(self.eye_scale, 1.0*min(self.world_size[0], self.world_size[1])/self.eye.mask_size) self.eye_scale = min(max(self.eye_scale, 0.5), 4) self.eye_angle = min(max(self.eye_angle, -90), 90) def run(self): self._init_model() while 1: if not self.queue_world.empty(): world_data = self.queue_world.get() self.world_image, self.world_size = world_data['image_string'], world_data['size'] self.world_id = world_data['id'] break self.eye_pos = (self.world_size[0]/2, self.world_size[1]/2) self.eye_angle = 0.0 self.eye_scale = 1.0 while 1: if not self.queue_world.empty(): world_data = self.queue_world.get() self.world_image, self.world_size = world_data['image_string'], world_data['size'] self.world_id = world_data['id'] self.image = Image.fromstring("RGB", self.world_size, self.world_image) self.fovea = self.eye.img2fovea(self.image, self.eye_pos, self.eye_angle, self.eye_scale) self.move_eye(self.run_model(self.fovea)) self.fovea_img = self.eye.fovea2img() if self.queue_monitor != None and self.queue_monitor.empty(): monitor_data = { 'fovea_img': self.fovea_img.tostring(), 'fovea_size': self.fovea_img.size, 'eye_pos': self.eye_pos, 'eye_scale': self.eye_scale, 'eye_angle': self.eye_angle, } self.queue_monitor.put(monitor_data)
def analyze_color_unconditional_status(self, color): """1) List potential eyes (eyes: empty+opponent areas flood filled): all empty points must be adjacent to those neighbour blocks with given color it gives eye. 2) List all blocks with given color that have at least 2 of above mentioned areas adjacent and has empty point from it as liberty. 3) Go through all potential eyes. If there exists neighbour block with less than 2 eyes: remove this this eye from list. 4) If any changes in step 3, go back to step 2. 5) Remaining blocks of given color are unconditionally alive and and all opponent blocks inside eyes are unconditionally dead. 6) Finally update status of those blocks we know. 7) Analyse dead group status. See test.py for testcases """ #find potential eyes eye_list = [] not_ok_eye_list = [ ] #these might still contain dead groups if totally inside live group eye_colors = EMPTY + other_side[color] for block in self.iterate_blocks(EMPTY + WHITE + BLACK): block.eye = None for block in self.iterate_blocks(eye_colors): if block.eye: continue current_eye = Eye() eye_list.append(current_eye) blocks_to_process = [block] while blocks_to_process: block2 = blocks_to_process.pop() if block2.eye: continue block2.eye = current_eye current_eye.parts.append(block2) for pos in block2.neighbour: block3 = self.blocks[pos] if block3.color in eye_colors and not block3.eye: blocks_to_process.append(block3) #check that all empty points are adjacent to our color ok_eye_list = [] for eye in eye_list: prev_our_blocks = None eye_is_ok = False for stone in eye.iterate_stones(): if self.goban[stone] != EMPTY: continue eye_is_ok = True our_blocks = [] for pos in self.iterate_neighbour(stone): block = self.blocks[pos] if block.color == color and block not in our_blocks: our_blocks.append(block) #list of blocks different than earlier if prev_our_blocks != None and prev_our_blocks != our_blocks: ok_our_blocks = [] for block in our_blocks: if block in prev_our_blocks: ok_our_blocks.append(block) our_blocks = ok_our_blocks #this empty point was not adjacent to our block or there is no block that has all empty points adjacent to it if not our_blocks: eye_is_ok = False break prev_our_blocks = our_blocks if eye_is_ok: ok_eye_list.append(eye) eye.our_blocks = our_blocks else: not_ok_eye_list.append(eye) #remove reference to eye that is not ok for block in eye.parts: block.eye = None eye_list = ok_eye_list #first we assume all blocks to be ok for block in self.iterate_blocks(color): block.eye_count = 2 #main loop: at end of loop check if changes while True: changed_count = 0 for block in self.iterate_blocks(color): #not really needed but short and probably useful optimization if block.eye_count < 2: continue #count eyes block_eye_list = [] for stone in block.neighbour: eye = self.blocks[stone].eye if eye and eye not in block_eye_list: block_eye_list.append(eye) #count only those eyespaces which have empty point(s) adjacent to this block block.eye_count = 0 for eye in block_eye_list: if block in eye.our_blocks: block.eye_count = block.eye_count + 1 if block.eye_count < 2: changed_count = changed_count + 1 #check eyes for required all groups 2 eyes ok_eye_list = [] for eye in eye_list: eye_is_ok = True for block in self.iterate_neighbour_eye_blocks(eye): if block.eye_count < 2: eye_is_ok = False break if eye_is_ok: ok_eye_list.append(eye) else: changed_count = changed_count + 1 not_ok_eye_list.append(eye) #remove reference to eye that is not ok for block in eye.parts: block.eye = None eye_list = ok_eye_list if not changed_count: break #mark alive and dead blocks for block in self.iterate_blocks(color): if block.eye_count >= 2: block.status = UNCONDITIONAL_LIVE for eye in eye_list: eye.mark_status(color) #for heuristical death search if self.assumed_unconditional_alive_list: for pos in self.assumed_unconditional_alive_list: block = self.blocks[pos] block.status = UNCONDITIONAL_LIVE extend_color = block.color blocks2analyse = [] for block in self.iterate_blocks(extend_color): if block.status == UNCONDITIONAL_LIVE: blocks2analyse.append(block) while blocks2analyse: block1 = blocks2analyse.pop() for block2 in self.iterate_blocks(extend_color): if block2.status==UNCONDITIONAL_UNKNOWN and \ len(self.block_connection_status(block1.get_origin(), block2.get_origin()))>=2: blocks2analyse.append(block2) block2.status = UNCONDITIONAL_LIVE #Unconditional dead part: #Mark all groups with only 1 potential empty point and completely surrounded by live groups as dead. #All empty points adjacent to live group are not counted. for eye_group in not_ok_eye_list: eye_group.dead_analysis_done = False for eye_group in not_ok_eye_list: if eye_group.dead_analysis_done: continue eye_group.dead_analysis_done = True true_eye_list = [] false_eye_list = [] eye_block = Block(eye_colors) #If this is true then creating 2 eyes is impossible or we need to analyse false eye status. #If this is false, then we are unsure and won't mark it as dead. two_eyes_impossible = True has_unconditional_neighbour_block = False maybe_dead_group = Eye() blocks_analysed = [] blocks_to_analyse = eye_group.parts[:] while blocks_to_analyse and two_eyes_impossible: block = blocks_to_analyse.pop() if block.eye: block.eye.dead_analysis_done = True blocks_analysed.append(block) if block.status == UNCONDITIONAL_LIVE: if block.color == color: has_unconditional_neighbour_block = True else: two_eyes_impossible = False continue maybe_dead_group.parts.append(block) for pos in block.stones: eye_block.add_stone(pos) if block.color == EMPTY: eye_type = self.analyse_eye_point(pos, color) elif block.color == color: eye_type = self.analyse_opponent_stone_as_eye_point( pos) else: continue if eye_type == None: continue if eye_type == True: if len(true_eye_list) == 2: two_eyes_impossible = False break elif len(true_eye_list) == 1: if self.are_adjacent_points(pos, true_eye_list[0]): #Second eye point is adjacent to first one. true_eye_list.append(pos) else: #Second eye point is not adjacent to first one. two_eyes_impossible = False break else: #len(empty_list) == 0 true_eye_list.append(pos) else: #eye_type==False false_eye_list.append(pos) if two_eyes_impossible: #bleed to neighbour blocks that are at other side of blocking color block: #consider whole area surrounded by unconditional blocks as one group for pos in block.neighbour: block = self.blocks[pos] if block not in blocks_analysed and block not in blocks_to_analyse: blocks_to_analyse.append(block) #must be have some neighbour groups: #for example board that is filled with stones except for one empty point is not counted as unconditionally dead if two_eyes_impossible and has_unconditional_neighbour_block: if (true_eye_list and false_eye_list) or \ len(false_eye_list) >= 2: #Need to do false eye analysis to see if enough of them turn to true eyes. both_eye_list = true_eye_list + false_eye_list stone_block_list = [] #Add holes to eye points for eye in both_eye_list: eye_block.remove_stone(eye) #Split group by eyes. new_mark = 2 #When stones are added they get by default value True (==1) for eye in both_eye_list: for pos in self.iterate_neighbour(eye): if pos in eye_block.stones: self.flood_mark(eye_block, pos, new_mark) splitted_block = self.split_marked_group( eye_block, new_mark) stone_block_list.append(splitted_block) #Add eyes to block neighbour. for eye in both_eye_list: for pos in self.iterate_neighbour(eye): for block in stone_block_list: if pos in block.stones: block.neighbour[eye] = True #main false eye loop: at end of loop check if changes while True: changed_count = 0 #Remove actual false eyes from list. for block in stone_block_list: if len(block.neighbour) == 1: neighbour_list = block.neighbour.keys() eye = neighbour_list[0] both_eye_list.remove(eye) #combine this block and eye into other blocks by 'filling' false eye block.add_stone(eye) for block2 in stone_block_list[:]: if block != block2 and eye in block2.neighbour: block.add_block(block2) stone_block_list.remove(block2) del block.neighbour[eye] changed_count = changed_count + 1 break #we have changed stone_block_list, restart if not changed_count: break #Check if we have enough eyes. if len(both_eye_list) > 2: two_eyes_impossible = False elif len(both_eye_list) == 2: if not self.are_adjacent_points( both_eye_list[0], both_eye_list[1]): two_eyes_impossible = False #False eye analysis done: still surely dead if two_eyes_impossible: maybe_dead_group.mark_status(color)
def _init_model(self): self.eye = Eye() self.A = gnp.zeros((5000,5000))