Contour Based Game- Break The Bricks(codes only).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-06T06:19:22.403519Z",
     "start_time": "2020-10-06T06:19:21.324579Z"
    },
    "code_folding": [
     7,
     14,
     27
    ]
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import numpy as np\n",
    "import imutils\n",
    "\n",
    "def running_average(bg_img, image, aweight):\n",
    "    if bg_img is None:\n",
    "        bg_img = image.copy().astype(\"float\")\n",
    "    else:\n",
    "        cv2.accumulateWeighted(image, bg_img, aweight)    \n",
    "    return bg_img\n",
    "\n",
    "def get_contours(bg_img, image, threshold=10):\n",
    "    \n",
    "    # abs diff betn img and bg\n",
    "    diff = cv2.absdiff(bg_img.astype(\"uint8\"), image)    \n",
    "    _, th = cv2.threshold(diff, threshold, 255, cv2.THRESH_BINARY)\n",
    "    (cnts, _) = cv2.findContours(th.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    \n",
    "    if len(cnts) == 0:\n",
    "        return None\n",
    "    else:\n",
    "        max_cnt = max(cnts, key=cv2.contourArea)\n",
    "        return th, max_cnt\n",
    "\n",
    "def show(img, figsize=(10, 10)):\n",
    "    figure = plt.figure(figsize=figsize)\n",
    "    plt.imshow(img)\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-06T06:19:42.096386Z",
     "start_time": "2020-10-06T06:19:23.074750Z"
    },
    "code_folding": [
     2,
     24,
     61,
     99,
     122,
     145,
     180,
     202,
     221,
     257,
     282
    ]
   },
   "outputs": [],
   "source": [
    "# latest\n",
    "class Ball:\n",
    "    def __init__(self, window_size=(525, 700, 3), rad=30, position=(255, 300), color=[10, 210, 100], extreme_pos=None):\n",
    "        \"\"\"\n",
    "            window_size: Default viewport\n",
    "            rad: radius of ball\n",
    "            position: center of circle\n",
    "            color: color of the circle\n",
    "            extreme_pos: to prevent flow from boundary\n",
    "                    \n",
    "        \"\"\"\n",
    "        \n",
    "        self.window_size = window_size\n",
    "        self.rad = rad\n",
    "        self.position = position\n",
    "        self.color = color\n",
    "        self.direction = -90/180 * np.pi # 90 degree\n",
    "        self.speed = 8 # px per frame on that dirn\n",
    "        self.hit = False\n",
    "        self.extreme_pos = extreme_pos\n",
    "        self.ball_stat = \"pause\"\n",
    "        if extreme_pos is None:\n",
    "            self.extreme_pos = ((15, 15), (window_size[0]-15, window_size[1]-15))\n",
    "        \n",
    "    def get_ball(self):\n",
    "        self.set_ball_position()\n",
    "        ball_img = np.zeros(self.window_size).astype(np.uint8)\n",
    "        cv2.circle(ball_img, self.position, self.rad, self.color, -3)\n",
    "        \n",
    "        return ball_img\n",
    "    \n",
    "    def set_direction(self, p1=None, p2=None, direction=None, kind=\"h\"):\n",
    "        \"\"\"\n",
    "            Used to set direction.\n",
    "            p1: point position of ball\n",
    "            p2: position of striking object\n",
    "            kind: type of strike, horizontal/vertical\n",
    "            direction: angle with striking body\n",
    "            \n",
    "            direction: is none whil usinge p1, p2\n",
    "        \"\"\"\n",
    "        \n",
    "        if direction is not None:\n",
    "            if kind == \"v\":\n",
    "                self.direction = np.pi-self.direction\n",
    "            else:\n",
    "                self.direction = 2*np.pi-self.direction\n",
    "                \n",
    "            \n",
    "        if p1 is not None and p2 is not None:\n",
    "            if kind == \"v\":\n",
    "                self.direction = np.pi-self.direction\n",
    "            else:\n",
    "                self.direction = 2*np.pi-self.direction\n",
    "            \n",
    "            if p1[1] <= p2[1]:\n",
    "                self.direction /= 2\n",
    "            if p1[1] > p2[1]:\n",
    "                self.direction += self.direction/2\n",
    "            \n",
    "        \n",
    "    def set_ball_position(self):\n",
    "        extreme_pos = self.extreme_pos\n",
    "        npos = [int(self.position[1] + np.sin(self.direction)*self.speed), \n",
    "                 int(self.position[0] + np.cos(self.direction)*self.speed)]\n",
    "        npos1 = npos.copy()\n",
    "        strike_pos=None\n",
    "        strike_kind = \"h\"\n",
    "        if npos[0] <= extreme_pos[0][0]:\n",
    "            npos[0] = extreme_pos[0][0]\n",
    "            strike_pos = (extreme_pos[0][0], npos[1])\n",
    "            strike_kind = \"h\"\n",
    "        elif npos[0] >= extreme_pos[1][0]:\n",
    "            npos[0] = extreme_pos[1][0]\n",
    "            strike_pos = (extreme_pos[1][0], npos[1])\n",
    "            strike_kind = \"h\"\n",
    "            self.ball_stat = \"over\"\n",
    "            #print(self.ball_stat)\n",
    "            \n",
    "        if npos[1] <= extreme_pos[0][1]:\n",
    "            npos[1] = extreme_pos[0][1]\n",
    "            strike_pos = (npos[0], extreme_pos[0][1])\n",
    "            strike_kind = \"v\"\n",
    "            \n",
    "        elif npos[1] >= extreme_pos[1][1]:\n",
    "            npos[1] = extreme_pos[1][1]\n",
    "            strike_pos = (npos[0], extreme_pos[1][1])\n",
    "            strike_kind = \"v\"\n",
    "            \n",
    "        if npos != npos1:\n",
    "            self.set_direction(p1=strike_pos, p2=self.position, direction=self.direction, kind=strike_kind)\n",
    "        self.position = (npos[1], npos[0])\n",
    "        \n",
    "# ball = Ball()\n",
    "# ball.get_ball()\n",
    "# ball.set_ball_position()\n",
    "# ball.get_ball()\n",
    "\n",
    "\n",
    "class Pad:\n",
    "    def __init__(self, window_size=(525, 700, 3), num_pad = 1, position=(470, 270), lengths=(50, 200), color=[120, 100, 100]):\n",
    "        self.window_size = window_size\n",
    "        self.num_pad = num_pad\n",
    "        self.position = position\n",
    "        self.lengths = lengths\n",
    "        self.color = color\n",
    "        self.mid_point = (int(position[0]+self.lengths[0])/2, int(position[1]+self.lengths[1])/2)\n",
    "         \n",
    "    def init_pad(self):\n",
    "        position = self.position\n",
    "        lengths = self.lengths\n",
    "        color = self.color\n",
    "        pad_img = np.zeros(self.window_size).astype(np.uint8)\n",
    "        pad_img[position[0]:position[0]+lengths[0], position[1]:position[1]+lengths[1]] = color\n",
    "        #show(pad_img)\n",
    "        return pad_img\n",
    "    \n",
    "    def get_pad(self, position):\n",
    "        self.position = position\n",
    "        \n",
    "        return self.init_pad()\n",
    "\n",
    "class Brick:\n",
    "    def __init__(self, size=(525, 700, 3), num_bricks=50, \n",
    "                 extreme_lengths=(10, 0), \n",
    "                 pbc=10, brick_part=40, bpr=10):\n",
    "        \"\"\"\n",
    "            size: window size\n",
    "            num_bricks: how many bricks total?\n",
    "            extreme_lengths: minimum length and maximum length of single brick. Will be factored later.\n",
    "            pbc: pixel per column\n",
    "            brick_part: how many of the total size is used for brick region. 40 means 40% or rows from top.\n",
    "            bpr: brick per row. 10 means 10 bricks will be used. \n",
    "        \"\"\"\n",
    "        self.num_bricks=num_bricks\n",
    "        self.brick_part = int(brick_part/100 * size[0])\n",
    "        self.extreme_lengths = (int(size[1]/bpr)-extreme_lengths[0], int(size[1]/bpr))\n",
    "        self.brick_height = int(self.brick_part/bpr)\n",
    "        self.bpr = bpr\n",
    "        self.current_bricks = None\n",
    "        self.size = size\n",
    "        self.pbc = pbc\n",
    "        self.init_bricks()\n",
    "        \n",
    "        \n",
    "    def init_bricks(self):\n",
    "        extreme_lengths = self.extreme_lengths\n",
    "        num_bricks = self.num_bricks\n",
    "        brick_height = self.brick_height\n",
    "        \n",
    "        bricks = np.random.randint(extreme_lengths[0], extreme_lengths[1], (int(num_bricks/self.bpr), self.bpr))\n",
    "        colors = np.array([[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 225, 0], [0, 255, 225], [255, 0, 255]])\n",
    "        colors = colors[np.random.randint(0, len(colors), num_bricks)]\n",
    "        brick_colors = {}\n",
    "        bricks_group = []\n",
    "        c=0\n",
    "        for i, row in enumerate(bricks):\n",
    "            for j, brick in enumerate(row):\n",
    "                bricks_group.append([(brick_height*i, brick_height*(i+1)), (row[:j].sum(), row[:j].sum()+brick)])\n",
    "                brick_colors[(brick_height*i, brick_height*(i+1), row[:j].sum(), row[:j].sum()+brick)] = colors[c]\n",
    "                c+= 1\n",
    "        bricks_group = np.array(bricks_group).reshape(bricks.shape[0], bricks.shape[1], -1)\n",
    "        brick_img = np.zeros((bricks.shape[0]*brick_height, bricks.sum(axis=1).max(), 3))\n",
    "        c = 0\n",
    "        for row in bricks_group:\n",
    "            for col in row:\n",
    "                brick_img[col[0]:col[1], col[2]:col[3]] = brick_colors[(col[0], col[1], col[2], col[3])]\n",
    "                c+=1\n",
    "        brick_img = brick_img.astype(np.uint8)\n",
    "        self.bricks_group = bricks_group\n",
    "        self.colors = brick_colors\n",
    "        self.current_bricks = self.bricks_group.tolist()\n",
    "        self.current_brick_img = brick_img\n",
    "        #print(self.colors)\n",
    "        #show(brick_img)\n",
    "        \n",
    "        #return brick_img\n",
    "    \n",
    "    def set_bricks(self):\n",
    "        return self.current_brick_img\n",
    "    def check_hit(self, ball_pos, ball):\n",
    "        score = 0\n",
    "        new_bricks = []\n",
    "        for i, rows in enumerate(self.current_bricks[::-1]):\n",
    "            #print(brick)\n",
    "            #break\n",
    "            new_row=[]\n",
    "            for j, brick in enumerate(rows):\n",
    "                #print(brick, ball_pos)\n",
    "                if brick[0]<=ball_pos[0]<brick[1] and brick[2]<=ball_pos[1]<brick[3]:\n",
    "                    self.colors[(brick[0], brick[1], brick[2], brick[3])] = np.uint8([0, 0, 0])\n",
    "                    self.current_brick_img[brick[0]:brick[1], brick[2]:brick[3]] = np.uint8([0, 0, 0])\n",
    "                    p2 = (int((brick[0]+brick[1])/2), int((brick[2]+brick[3])/2))\n",
    "                    ball.set_direction(p1=ball_pos, p2=p2, kind=\"h\")\n",
    "                    score += 1\n",
    "                else:\n",
    "                    new_row.append(brick)\n",
    "            new_bricks.append(new_row)\n",
    "        self.current_bricks = new_bricks\n",
    "        return score\n",
    "        \n",
    "class Game:\n",
    "    def __init__(self,roi=None, game_window_size = (525, 700, 3), \n",
    "                 pad_position=(470, 270), lengths=(50, 200), avg_frames=100):\n",
    "        \"\"\"\n",
    "            roi: required for contour region preparation\n",
    "            game_window_size: window size\n",
    "            pad_position: where should pad be initially?\n",
    "            lengths: pad lengths on both coordinates\n",
    "            avg_frames: how many frames to take running average?\n",
    "        \"\"\"\n",
    "        self.pad_pointer = None\n",
    "        self.roi = roi\n",
    "        self.game_window_size = game_window_size\n",
    "        self.pad_position = pad_position\n",
    "        self.lengths = lengths\n",
    "        self.ball = Ball(extreme_pos=((15, 15), (game_window_size[0]-15, game_window_size[1]-15)))\n",
    "        self.pad = Pad()\n",
    "        self.brick = Brick()\n",
    "        self.score = 0\n",
    "        self.avg_frames = avg_frames\n",
    "    def get_game_window(self, pad_pointer):\n",
    "        \"\"\"\n",
    "            Returns game window.\n",
    "            pad_pointer: current position of pad\n",
    "        \"\"\"\n",
    "        self.roi = self.roi\n",
    "        # convert pad_pos equivalent to new window.\n",
    "        game_window = np.zeros(self.game_window_size).astype(np.uint8)\n",
    "        top, right, bottom, left = self.roi\n",
    "        m = pad_pointer # c, r\n",
    "        h = bottom - top\n",
    "        l = left - right\n",
    "\n",
    "        # use pad position instead of shape\n",
    "        #pshape = (pad_pos[0][1]-pad_pos[0][0], pad_pos[1][1]-pad_pos[1][0])\n",
    "        pshape = game_window.shape\n",
    "\n",
    "        m = (int((m[0]/l)*pshape[1]), int((m[1]/h)*pshape[0]))    \n",
    "        cv2.circle(game_window, (m[0], self.pad_position[0]), 5, [255, 255, 0], -3)\n",
    "\n",
    "        # clip the position of pad only withing boundries\n",
    "        position = (self.pad_position[0],  np.clip(m[0], 0, self.game_window_size[1]-self.lengths[1]))\n",
    "        pad = self.pad.get_pad(position=position)\n",
    "        \n",
    "        bricks = self.brick.current_brick_img\n",
    "        bshape = bricks.shape\n",
    "        game_window[:bshape[0], :bshape[1]] = bricks\n",
    "        \n",
    "        ball = self.ball.get_ball()\n",
    "        self.check_collision()\n",
    "        window = game_window+pad+ball\n",
    "        ball_stat = self.ball.ball_stat\n",
    "        #print(self.game_stat)\n",
    "        return window\n",
    "    \n",
    "    def check_collision(self):\n",
    "        \"\"\"\n",
    "            Check collision with bricks/boundaries\n",
    "        \"\"\"\n",
    "        ball = self.ball\n",
    "        brick = self.brick\n",
    "        pad = self.pad\n",
    "        \n",
    "        # check collision of pad and ball first\n",
    "        if pad.position[0] <= ball.position[1]+ball.rad:\n",
    "            #print(ball.position, pad.position)\n",
    "            \n",
    "            if pad.position[1] <= ball.position[0]-ball.rad <= int((pad.position[0]+pad.lengths[1])):\n",
    "                # ball has hitted the pad now bounce the ball\n",
    "                # hit on left side\n",
    "                p2 = (int((pad.position[0]+pad.mid_point[0])/2), int((pad.position[1]+pad.mid_point[1])/2))\n",
    "                ball.set_direction(p1=(ball.position[1]+ball.rad, \n",
    "                                       ball.position[0]-ball.rad), p2=p2, kind=\"h\")            \n",
    "            elif pad.position[1] <= ball.position[0]+ball.rad <= int((pad.position[0]+pad.lengths[1])):\n",
    "                # ball has hitted the pad now bounce the ball\n",
    "                # hit on right side\n",
    "                p2 = (int((pad.lengths[0]+pad.position[0]+pad.mid_point[0])/2), int((pad.lengths[1]+pad.position[1]+pad.mid_point[1])/2))\n",
    "                ball.set_direction(p1=(ball.position[1]+ball.rad, \n",
    "                                       ball.position[0]+ball.rad), p2=p2, kind=\"h\")\n",
    "            else:\n",
    "                #if pad.position[1]+pad.lengths[1] < ball.position[0] or ball.position[0] < pad.position[1]-pad.lengths[1]:\n",
    "                self.game_stat = \"over\"\n",
    "            \n",
    "        elif ball.position[1]+ball.rad <= brick.brick_part:\n",
    "            # check if ball pos lies within brick\n",
    "            score = brick.check_hit((ball.position[1]-ball.rad, ball.position[0]), ball)\n",
    "            \n",
    "            self.score += score\n",
    "        \n",
    "            \n",
    "    def main(self):\n",
    "        cam = cv2.VideoCapture(0)\n",
    "        top, right, bottom, left = self.roi\n",
    "        num_frames = 0\n",
    "        avg_frames = self.avg_frames\n",
    "        move_bg = None\n",
    "        aweight = 0.5\n",
    "        pointer_color = [100, 100, 100]\n",
    "        rd = 5\n",
    "        cd = 15\n",
    "        game_window = None\n",
    "#         game = Game(roi = [top, right, bottom, left])\n",
    "        frames = 0\n",
    "        self.game_stat = \"pause\"\n",
    "        while True:\n",
    "            # read the camera result\n",
    "            (ret, frame) = cam.read()\n",
    "            # if camera has read frame\n",
    "            if ret:\n",
    "                key = cv2.waitKey(1) & 0xFF\n",
    "                frame = imutils.resize(frame, width=700)\n",
    "                # flip to remove mirror effect\n",
    "                frame = cv2.flip(frame, 1)\n",
    "                # clone it to not mess with real frame\n",
    "                clone = frame.copy()\n",
    "                gray = cv2.cvtColor(clone, cv2.COLOR_BGR2GRAY)\n",
    "                h, w = frame.shape[:2]\n",
    "                move_gray = gray[top:bottom, right:left]\n",
    "                move_gray = cv2.GaussianBlur(move_gray, (7, 7), 0)\n",
    "                if num_frames<avg_frames:\n",
    "                    move_bg = running_average(move_bg, move_gray, aweight)                \n",
    "                    # put frame number on frame\n",
    "                    cv2.putText(clone, str(num_frames), (100, 100),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 1)\n",
    "                    num_frames+=1\n",
    "                    if num_frames > avg_frames-2:\n",
    "                        self.game_stat = \"play\"\n",
    "                if game_window is None:\n",
    "                    game_window = self.get_game_window(pad_pointer = self.pad.mid_point)\n",
    "                else:                    \n",
    "                    move_hand = get_contours(move_bg, move_gray)\n",
    "                    if move_hand is not None:\n",
    "                        mthresholded, msegmented = move_hand\n",
    "                        sshape = msegmented.shape\n",
    "                        new_segmented = msegmented.reshape(sshape[0], sshape[-1])\n",
    "                        m = new_segmented.min(axis=0)\n",
    "                        cv2.drawContours(clone, [msegmented+(right, top)], -1, (0, 0, 255))\n",
    "                        cv2.circle(clone, (right+m[0], top+m[1]), 5, pointer_color, -3)\n",
    "                        cv2.rectangle(clone, (int((right+m[0]))-cd, int((top+bottom)/2)-rd), \n",
    "                                      (int((right+m[0]))+cd, int((top+bottom)/2)+rd), (255, 0, 0), 2)\n",
    "                        \n",
    "                        if self.game_stat == \"play\":\n",
    "                            game_window = game.get_game_window(pad_pointer = m)\n",
    "                if game_window is not None:\n",
    "                    if self.game_stat != \"over\":\n",
    "                        cv2.putText(game_window, str(self.score), (10, 500),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 5, (255, 255, 255), 5)\n",
    "                        if self.game_stat == \"pause\":\n",
    "                            cv2.putText(game_window, str(self.game_stat), (250, 400),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 2)\n",
    "                        frames+=1\n",
    "                    elif self.game_stat == \"over\":\n",
    "                        cv2.putText(game_window, \"Over Score: \" + str(self.score), (30, 300),\n",
    "                                       cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 4)\n",
    "                    cv2.imshow(\"Break the Brick\", game_window)\n",
    "                    \n",
    "                cv2.rectangle(clone, (left, top), (right, bottom), (0, 255, 0), 2)\n",
    "                cv2.imshow(\"Running Frame\", clone)\n",
    "                if chr(key)=='r':\n",
    "                    self.game_stat = \"pause\"\n",
    "                    num_frames=0\n",
    "                if key==27:\n",
    "                    break\n",
    "        cam.release()\n",
    "        cv2.destroyAllWindows()\n",
    "game = Game(roi = [400, 400, 500, 681])\n",
    "game.main()\n",
    "\n",
    "    \n",
    "brick = Brick()\n",
    "#show(brick.current_brick_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}