Ejemplo n.º 1
0
    def initialize(self):
        cap = cv2.VideoCapture(self.source)
        if not cap.isOpened():
            cap.open()

        # read a few frames to make sure the camera is self-calibrated
        for i in range(10):
            cap.read()

        # let user position camera
        print("Position the camera, then hit space.")
        while cv2.waitKey(20) != ord(' '):
            ret, img = cap.read()
            cv2.imshow(self.window_name, img)

        # find the board grid
        ret, img = cap.read()
        self.lines = find_grid.find_grid(img, self.board_size)
        self.grid = find_grid.get_grid_intersections(self.lines,
                                                     self.board_size)
        self.corners = util.get_board_corners(self.grid)
        rvec, tvec, inliners, t = pose.get_pose(self.corners, self.board_size,
                                                self.cam_mtx, self.distortion)
        self.offsets = pose.compute_offsets(self.grid, self.board_size, t,
                                            rvec, tvec, self.cam_mtx,
                                            self.distortion)

        self.corners = np.int32(self.corners)
        self.offsets = np.int32(self.offsets)
        board_mask = util.get_board_mask(img.shape[:2], self.corners)
        self.cap = select_frames.FrameSelector(cap)
        self.cap.set_roi(None, board_mask)
        self.cap.initialize()

        self.finder = find_stones.StoneFinder(self.board_size, self.lines,
                                              self.grid, self.black,
                                              self.white, self.offsets)
        self.finder.set_last_gray_image(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))

        if self.debug:
            self.finder.draw_stone_masks(img)

            for i, j in util.square(self.board_size):
                pt1, pt2 = tuple(self.grid[i,j,::-1].ravel()), \
                           tuple(self.offsets[i,j,::-1].ravel())
                cv2.line(img, pt1, pt2, (0, 255, 0), 2)
            cv2.imshow('pose', img)
            cv2.waitKey(0)
            cv2.destroyWindow('pose')

        return True
Ejemplo n.º 2
0
img = cv2.imread('tests/photos/1.jpg')
corners = np.array([[75, 251], [164, 542], [445, 383], [275, 51]],
                   dtype=np.int32)
board_size = 9

data = np.load('camera_params.npz')
mtx = data['mtx']
#dist = data['dist']
dist = None

rvec, tvec, inliers, t = pose.get_pose(corners, board_size, mtx, dist, True)
img = pose.draw_pose(img, board_size, corners, t, rvec, tvec, mtx, dist)

lines = find_grid.find_grid(img, board_size, corners)
grid = find_grid.get_grid_intersections(lines, board_size)
offsets = pose.compute_offsets(grid, board_size, t, rvec, tvec, mtx, dist)

finder = find_stones.StoneFinder(board_size, lines, grid,
                                 np.zeros((0, 2), dtype=np.int32),
                                 np.zeros((0, 2), dtype=np.int32), offsets)
finder.draw_stone_masks(img)

for i, j in util.square(board_size):
    pt1, pt2 = tuple(grid[i, j, ::-1].ravel()), tuple(offsets[i,
                                                              j, ::-1].ravel())
    cv2.line(img, pt1, pt2, (0, 255, 0), 2)

cv2.imshow('pose', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
Ejemplo n.º 3
0
        removed_loc = black[removed]

    #debug_img = img.copy()
    #debug_img = cv2.resize(debug_img, (500, 500))
    #cv2.imshow("original", debug_img)

    ##debug_img = img.copy()
    ##draw_lines(debug_img, lines)
    ##draw_stones(debug_img, grid.reshape((-1, 2)), (255, 255, 255), 2)
    ##debug_img = cv2.resize(debug_img, (500, 500))
    ##cv2.imshow('debug image', debug_img)

    finder = 0
    if removed_color == 1:
        finder = find_stones.StoneFinder(
            BOARDSIZE, lines, grid,
            np.append(white[0:removed], white[removed + 1:], axis=0), black)
    else:
        finder = find_stones.StoneFinder(
            BOARDSIZE, lines, grid, white,
            np.append(black[0:removed], black[removed + 1:], axis=0))

    finder.set_image(img)
    finder.calculate_features()
    stone, color = finder.find_next_stone()
    print('\nstone:', stone, ' color:', color)
    print('removed:', removed_loc, ' color:', removed_color)
    if removed_color == 1:
        if removed_color == color and \
           tuple(stone) == tuple(removed_loc):
            right += 1
Ejemplo n.º 4
0
white = np.zeros((0,2), dtype='int32')
black = np.zeros((0,2), dtype='int32')


lines = find_grid.find_grid(frame, BOARDSIZE,grid_corners)
grid = find_grid.get_grid_intersections(lines, BOARDSIZE)
grid = np.int32(grid)

cap = select_frames.FrameSelector(cap)
cap.initialize()

board_mask = np.zeros(frame.shape[0:2], dtype=np.uint8)
board_mask = cv2.fillConvexPoly(board_mask, board_corners[:,::-1], 1)
cap.set_roi(None, board_mask)

finder = find_stones.StoneFinder(BOARDSIZE, lines, grid,
                                white, black)
finder.set_last_gray_image(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY))

found_one = False
try:
    while cap.isOpened():
        found_one = False
        ret, frame = cap.check()
        
        if ret:
            finder.set_image(frame.copy())
            while True:
                finder.calculate_features()
                stone, color = finder.find_next_stone()
                print('found stone', stone, color, 'in frame',
                      cap.get(cv2.CAP_PROP_POS_FRAMES))
Ejemplo n.º 5
0
mtx, dist = pose.get_fake_camera(img)
rvec, tvec, inliers, t = pose.get_pose(corners, BOARDSIZE, mtx, dist)
offsets = pose.compute_offsets(grid, BOARDSIZE, t, rvec, tvec, mtx, dist)

##offsets = grid.copy()
##offsets[:,:,0] = offsets[:,:,0] - 2

#print('shape of image', img.shape)
#print('grid')
#print(grid)

finder = find_stones.StoneFinder(BOARDSIZE,
                                 img.shape,
                                 lines,
                                 grid,
                                 white,
                                 black,
                                 rvec=rvec,
                                 offsets=offsets)
finder.set_last_gray_image(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
finder.set_image(img)

#img = finder.img_bgr
#img = pose.draw_pose(img, BOARDSIZE, corners, t, rvec, tvec, mtx, dist)
#finder.draw_stone_masks(img)
##draw_stones(img, grid.reshape((-1,2)), (0, 255, 255), 2)
#cv2.imshow('game', img)
#cv2.waitKey(0)

cont = True