MG8000 – Colocación de piezas en el tablero

El siguiente paso en el programa de detección de las piezas es ‘colocar’ o ‘situar’ las piezas detectadas en las casillas del tablero. Para ello vamos a realizar los siguientes pasos:

• Cera una variable tablero para contener las piezas detectadas
• Calcular los polígonos que formen cada casilla.
• Comprobar en cuál de las casillas está cada pieza

Una vez hecho esto lo que habrá que hacer es comparar el tablero detectado con el anterior y así saber cuál ha sido el movimiento hecho por el usuario.

El programa a continuación muestra un código intermedio con unos datos de prueba para comprobar que la detección y relleno del tablero son correctos.

import cv2
import numpy as np
from shapely.geometry import Point
from shapely.geometry.polygon import Polygon

#################################################################
def DibujaPuntos(frame,Puntos):
    for ii in range(9):
        for jj in range(9):
            cv2.circle(frame,(int(Puntos[ii][jj][0]),int(Puntos[ii][jj][1])),1,(0,20*ii,255),2)
    return frame

#################################################################
def ColocarPieza(Tablero,ListaPiezas):
    for hh in ListaPiezas:
        xmin=hh[0]
        ymin=hh[1]
        xmax=hh[2]
        ymax=hh[3]
        xp=((xmin+xmax)/2)
        Pieza=Point(xp,ymax)
        Pom=cv2.circle(img2,(int(xp),int(ymax)),1,(0,255,0),1)
        piezadetectada=hh[5]
        print("-"+str(piezadetectada))
        for ii in range(8):
            for jj in range(8):
                poligono=Polygon([Puntos[ii][jj],Puntos[ii][jj+1],Puntos[ii+1][jj+1],Puntos[ii+1][jj]])
                if poligono.contains(Pieza):
                    Tablero[ii][jj]=piezadetectada
                    print(piezadetectada)
                    break
            if piezadetectada==Tablero[ii][jj]:
                break
        cv2.imshow("fn2", img2)

#################################################################
# Load the image
img = cv2.imread("tablero.jpg")

# Color-segmentation to get binary mask
lwr = np.array([0, 0, 143])
upr = np.array([179, 61, 252])
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
msk = cv2.inRange(hsv, lwr, upr)

# Extract chess-board
krn = cv2.getStructuringElement(cv2.MORPH_RECT, (50, 30))
dlt = cv2.dilate(msk, krn, iterations=5)
res = 255 - cv2.bitwise_and(dlt, msk)

# Displaying chess-board features
res = np.uint8(res)
ret, corners = cv2.findChessboardCorners(res, (7, 7),
                                         flags=cv2.CALIB_CB_ADAPTIVE_THRESH +
                                               cv2.CALIB_CB_FAST_CHECK +
                                               cv2.CALIB_CB_NORMALIZE_IMAGE)
               
if ret:
    # Inicialización matriz de puntos del tablero
    Puntos=[]
    punto=[0,0]
    for ii in range(9):
        col = []
        for jj in range(9):
            col.append(punto)
        Puntos.append(col)

    #Lista de las piezas PRUEBA
    ListaPiezasPrueba=[[282.632660,  239.437256,  313.087311,  302.374268,    0.955954,      3],  
  [419.363403,  367.996490,  450.439392,  416.108429,    0.953193,      0],  
  [208.016174,  213.201538,  244.455139,  265.290833,    0.928033,      2],  
  [419.761841,  277.511200,  453.021118,  332.983612,    0.895914,      1],  
  [409.441101,  184.278534,  435.099976,  229.711426,    0.893048,      1]]

    # Inicialización matriz de Casillas del tablero
    Tablero=[]
    for ii in range(8):
        col=[]
        for jj in range(8):
            col.append(" ")
        Tablero.append(col)

    # Relleno de la matriz de puntos a partir de corners
    for ii in range(7):
        Puntos[1][7-ii]=corners[ii][0]
        Puntos[2][ii+1]=corners[7+ii][0]
        Puntos[3][7-ii]=corners[14+ii][0]
        Puntos[4][ii+1]=corners[21+ii][0]
        Puntos[5][7-ii]=corners[28+ii][0]
        Puntos[6][ii+1]=corners[35+ii][0]
        Puntos[7][7-ii]=corners[42+ii][0]
    #print(Puntos[2][7])

    # Distancias
    Db=(corners[48][0]-corners[40][0])
    Dsh=(corners[6][0]-corners[12][0])
    Ds=(corners[8][0]-corners[0][0])
    Dg=(corners[42][0]-corners[36][0])

    # Añade puntos exteriores
    Puntos[0][0]=(corners[6][0]+Dsh)
    for ii in range(7):
        Puntos[0][ii+1]=corners[6-ii][0]-(corners[13-ii][0]-corners[6-ii][0])
    Puntos[0][8]=(corners[0][0]-Ds)
    
    Puntos[8][0]=(corners[48][0]+Db)
    for ii in range(7):
        Puntos[8][ii+1]=corners[48-ii][0]+(corners[48-ii][0]-corners[41-ii][0])
    Puntos[8][8]=(corners[42][0]+Dg)

    for ii in range(7):
        Puntos[ii+1][0]=corners[(ii*7)+6][0]+(corners[(ii*7)+6][0]-corners[(ii*7)+5][0])

    for ii in range(7):
        Puntos[ii+1][8]=corners[ii*7][0]+(corners[ii*7][0]-corners[(ii*7)+1][0])

    img2=DibujaPuntos(img,Puntos)
    img2=cv2.resize(img2,(640,480))
    ColocarPieza(Tablero,ListaPiezasPrueba)
    
else:
    print("No Checkerboard Found")

La imagen de los puntos detectados en el tablero queda así: