/* x축 stepping motor 구동 code */
String sig;
char Ard1[3] = {0}; // 통신 받은 문자열 분할 처리를 위한 변수 선언
char Ard2[3] = {0}; // 통신 받은 문자열 분할 처리를 위한 변수 선언
char check[1];
int value_1 = 0; // x축 좌표값 받을 변수 선언
int value_2 = 0; // y축 좌표값 받을 변수 선언
int flag = 0; // 통신 데이터의 무한한 공급을 막기 위한 변수 선언

/* stepping motor pin설정 */
#define steps_x 5
#define dir_x 6
#define ms1_x 8
#define ms2_x 9
#define ms3_x 10
/* switch pin설정 */
#define sw_x 4

long long int i = 0; // for문에 사용할 변수
//long long int i_num = 5000+4000*value_1;
long long int delay_num = (6000+4000*value_2)*0.4;
int sn = 0; // stepping motor가 회전하는 바퀴수를 count하기 위한 변수

void setup()
{
// put your setup code here, to run once:
Serial.begin(9600);
// 신호보낼 핀 출력설정
pinMode(steps_x, OUTPUT); // stepping motor에 신호를 주기 위함
pinMode(dir_x, OUTPUT); // stepping motor 방향설정을 출력
pinMode(ms1_x, OUTPUT); // stepping motor 분주 설정 출력
pinMode(ms2_x, OUTPUT); // stepping motor 분주 설정 출력
pinMode(ms3_x, OUTPUT); // stepping motor 분주 설정 출력
/* 분주를 1/2로 설정했으므로 1 step당 0.9도씩 회전 */
digitalWrite(steps_x,LOW);
digitalWrite(dir_x, HIGH); // 초기 설정 : stepping motor 정방향 회전
digitalWrite(ms1_x, HIGH); // stepping motor 1/2분주 설정
digitalWrite(ms2_x, LOW); // 분주 비활성화
digitalWrite(ms3_x, LOW); // 분주 비활성화

pinMode(sw_x, INPUT_PULLUP); // pull_up저항으로 출력 설정

/* x축의 stepping motor회전으로 초기 좌표까지 이동 */
digitalWrite(dir_x, HIGH); // stepping motor 정회전
while(1)
{
if(digitalRead(sw_x) == HIGH)
{
goto kn_s; // switch인식할 경우 kn_s:로 이동 및 stepping motor 정지
}
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_x, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_x, LOW);
delayMicroseconds(200); // delay 2us
}
kn_s:
delay(200);
}

void loop() {
// put your main code here, to run repeatedly:
digitalWrite(dir_x, HIGH); // stepping motor 정회전
/* x축의 stepping motor회전으로 초기 좌표까지 이동 */
while(1)
{
//x좌표 switch가 인식될 경우에 초기 좌표로 인식
if(digitalRead(sw_x) == HIGH)
{
goto kn_s; // switch인식할 경우 kn_s:로 이동 및 stepping motor 정지
}
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_x, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_x, LOW);
delayMicroseconds(200); // delay 2us
}
kn_s:
delay(200);
kn_x:
/* 문자열로 저장*/
while(Serial.available())
{
char wait = Serial.read(); // python serial 통신으로 받을 문자열
sig.concat(wait); // python으로 통신받은 문자열을 sig라는 빈 문자열에 추가
}
/* 입력 문자열 슬라이싱 */
sig.substring(0,1).toCharArray(check,2);

if(check[0] == ‘Q’)
{
if (sig.length()==5)
{
sig.substring(1,3).toCharArray(Ard1,3); // x축에 해당하는 좌표 문자열
sig.substring(3,5).toCharArray(Ard2,3); // y축에 해당하는 좌표 문자열
value_1 = atoi(Ard1); // x축 좌표값
value_2 = atoi(Ard2); // y축 좌표값
sig = “”; // x,y 축의 좌표데이터를 연산처리 할 수 있게 int형으로 처리한 후 문자열을 다시 받기 위한 초기화
flag = 0;
}
else if(sig.length()>5)
{sig = “”;} // 문자열을 다시 받기 위한 초기화
}
else if(check[0] != ‘Q’)
{
sig = “”; // 문자열을 다시 받기 위한 초기화
}
if(value_1 > 0) // x축 좌표가 0이상일 때 동작하기 위한 조건문
{
if(flag == 0)
{
flag = 1; // 통신 데이터의 무한 공급으로 인한 무한루프의 시스템 처리를 막기 위해 초기화
digitalWrite(dir_x, LOW);
delay(500);
/* x축 초기 좌표 위치 설정 */
for(i=0; i<6500; i++)
{
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_x, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_x, LOW);
delayMicroseconds(200); // delay 2us
}
sn = 0; // count 변수 초기화
/* y축 좌표값까지 한 바퀴씩 회전하는 값을 카운트하여 조건을 만족하면 회전 정지 및 while문 탈출 */
while(1)
{
if(sn == value_1)
{
goto ksn; // count변수가 x축 좌표값이랑 같아지면 stepping motor 회전 중지
}
for(i=0; i<4000; i++)
{
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_x, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_x, LOW);
delayMicroseconds(200); // delay 2us
}
sn++; // count 1씩 증가
}
ksn:
delay(delay_num); // y축 stepping motor 회전 시간
delay(13000); // servo & linear 작동 시간동안 delay
//회전방향 출력 10000+2000*
digitalWrite(dir_x, HIGH);
delay(500);
for(i=0; i<6500; i++)
{
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_x, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_x, LOW);
delayMicroseconds(200); // delay 2us
}
while(1)
{
for(i=0; i<4000; i++)
{
if(digitalRead(sw_x) == HIGH)
{
goto kn_x;
}
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_x, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_x, LOW);
delayMicroseconds(200); // delay 2us
}
}
}
}
}

/* y축 stepping motor & servo motor & linear motor 구동 code */
#include <Servo.h>
Servo myservo_servo; // servo motor사용을 위한 모터이름 지정
Servo myservo_linear; // linear motor사용을 위한 모터이름 지정

String sig; // 통신받을 문자열을 추가해주기 위한 자리 변수 선언
char Ard1[3] = {0}; // 통신 받은 문자열 분할 처리를 위한 변수 선언
char Ard2[3] = {0}; // 통신 받은 문자열 분할 처리를 위한 변수 선언
char check[1];
int value_1 = 0; // x축 좌표값 받을 변수 선언
int value_2 = 0; // y축 좌표값 받을 변수 선언
int flag = 0; // 통신 데이터의 무한한 공급을 막기 위한 변수 선언

/* stepping motor pin설정 */
#define steps_y 5
#define dir_y 6
#define ms1_y 8
#define ms2_y 9
#define ms3_y 10
/* switch pin설정 */
#define sw_y 4
long long int j = 0; // for문에 사용할 변수
int angle_servo; // servo motor 각도변수
int angle_linear; // linear motor 출력변수
long long int delay_num = (6500+4000*value_1)*0.4; //x축의 stepping motor회전하는 동안 동작지연하기 위한 delay
int sn = 0; // stepping motor가 회전하는 바퀴수를 count하기 위한 변수

void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
// 신호보낼 핀 출력설정
pinMode(steps_y, OUTPUT); // stepping motor에 신호를 주기 위함
pinMode(dir_y, OUTPUT); // stepping motor 방향설정을 출력
pinMode(ms1_y, OUTPUT); // stepping motor 분주 설정 출력
pinMode(ms2_y, OUTPUT); // stepping motor 분주 설정 출력
pinMode(ms3_y, OUTPUT); // stepping motor 분주 설정 출력
/* 분주를 1/2로 설정했으므로 1 step당 0.9도씩 회전 */
digitalWrite(steps_y,LOW);
digitalWrite(dir_y, HIGH); // 초기 설정 : stepping motor 정방향 회전
digitalWrite(ms1_y, HIGH); // stepping motor 1/2분주 설정
digitalWrite(ms2_y, LOW); // 분주 비활성화
digitalWrite(ms3_y, LOW); // 분주 비활성화

myservo_servo.attach(11); // servo motor PIN설정
myservo_servo.write(0); // servo motor 초기 각도 0도로 설정
myservo_linear.attach(12); // linear motor PIN설정
myservo_linear.write(0); // linear motor 초기 각도 0도로 설정

pinMode(sw_y, INPUT_PULLUP); // pull_up저항으로 출력 설정

/* y축의 stepping motor회전으로 초기 좌표까지 이동 */
digitalWrite(dir_y, HIGH); // stepping motor 정방향 회전
while(1)
{
if(digitalRead(sw_y) == HIGH)
{
goto kn_s; // switch인식할 경우 kn_s:로 이동 및 stepping motor 정지
}
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_y, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_y, LOW);
delayMicroseconds(200); // delay 2us
}
kn_s:
delay(200);
}

void loop()
{
// put your main code here, to run repeatedly:
digitalWrite(dir_y, HIGH); // stepping motor 정회전
/* y축의 stepping motor회전으로 초기 좌표까지 이동 */
while(1)
{
if(digitalRead(sw_y) == HIGH)
{
goto kn_s;
}
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_y, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_y, LOW);
delayMicroseconds(200); // delay 2us
}
kn_s:
delay(200);
kn_y:
/* 문자열로 저장*/
while(Serial.available())
{
char wait = Serial.read(); // python serial 통신으로 받을 문자열
sig.concat(wait); // python으로 통신받은 문자열을 sig라는 빈 문자열에 추가
}
/* 입력 문자열 슬라이싱 */
sig.substring(0,1).toCharArray(check,2);

if(check[0] == ‘Q’)
{
if (sig.length()==5)
{
sig.substring(1,3).toCharArray(Ard1,3); // x축에 해당하는 좌표 문자열
sig.substring(3,5).toCharArray(Ard2,3); // y축에 해당하는 좌표 문자열
value_1 = atoi(Ard1); // x축 좌표값
value_2 = atoi(Ard2); // y축 좌표값
sig = “”; // x,y 축의 좌표데이터를 연산처리 할 수 있게 int형으로 처리한 후 문자열을 다시 받기 위한 초기화
flag = 0;
}
else if(sig.length()>5)
{sig = “”;} // 문자열을 다시 받기 위한 초기화
}
else if(check[0] != ‘Q’)
{
sig = “”; // 문자열을 다시 받기 위한 초기화
}
if(value_2 > 0) // y축 좌표가 0이상일 때 동작하기 위한 조건문
{
if(flag == 0)
{
flag = 1; // 통신 데이터의 무한 공급으로 인한 무한루프의 시스템 처리를 막기 위해 초기화
digitalWrite(dir_y, LOW);
delay(500);
delay(delay_num);
/* y축 초기 좌표 위치 설정 */
for(j=0; j<6000; j++)
{
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_y, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_y, LOW);
delayMicroseconds(200); // delay 2us
}
sn = 0; // count 변수 초기화
/* y축 좌표값까지 한 바퀴씩 회전하는 값을 카운트하여 조건을 만족하면 회전 정지 및 while문 탈출 */
while(1)
{
if(sn == value_2)
{
goto ksn; // count변수가 y축 좌표값이랑 같아지면 stepping motor 회전 중지
}
for(j=0; j<4000; j++)
{
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_y, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_y, LOW);
delayMicroseconds(200); // delay 2us
}
sn++; // count 1씩 증가
}
ksn:
delay(500);
/* 바둑돌이 정확한 위치로 낙하하기 위해 linear motor로 조준해주기 */
for(angle_linear = 0; angle_linear < 140; angle_linear++)
{
myservo_linear.write(angle_linear);
delay(20); // delay 10ms
}
/* 바둑돌 내려주기 위한 servo motor제어 0~180~0도 순으로 회전 */
delay(500);
for(angle_servo = 0; angle_servo <= 180; angle_servo++)
{
myservo_servo.write(angle_servo);
delay(10); // delay 10ms
}
delay(500);
for(angle_servo = 180; angle_servo >= 0; angle_servo–)
{
myservo_servo.write(angle_servo);
delay(10); // delay 10ms
}
delay(500);
/* 조준된 linear motor가 축이 움직일 때 다른 바둑돌을 건들지 않게 초기위치로 되돌림 */
for(angle_linear = 140; angle_linear > 0; angle_linear–)
{
myservo_linear.write(angle_linear);
delay(20); // delay 20ms
}
delay(delay_num);
digitalWrite(dir_y, HIGH); // stepping motor 정회전
delay(500);
for(j=0; j<6000; j++)
{
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_y, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_y, LOW);
delayMicroseconds(200); // delay 2us
}
while(1)
{
for(j=0; j<4000; j++)
{
if(digitalRead(sw_y) == HIGH)
{
goto kn_y; // y축의 switch가 눌리면 while문을 탈출하면서 stepping motor의 작동을 멈춤
}
/* stepping motor 1 step당 4us로 회전 */
digitalWrite(steps_y, HIGH);
delayMicroseconds(200); // delay 2us
digitalWrite(steps_y, LOW);
delayMicroseconds(200); // delay 2us
}
}
}

}
}

import numpy as np, cv2
import time
image = cv2.imread(‘images/go2.jpg’, cv2.IMREAD_COLOR)
capture = cv2.VideoCapture(0) #카메라 불러오는 함수
if capture.isOpened() == False: raise Exception(“카메라 연결 안됨”)
stone = [] final_stone = [] while(capture.isOpened()): # 카메라가 열려있을 때 ~
ret, image = capture.read() # image로 받아옴

mark = np.zeros(image.shape, image.dtype) # mark 라는 친구를 생성함
mark_1 = np.zeros(image.shape, image.dtype) # mark_1이라는 친구도 생성함함
blue_threshold = 70 # 흑백으로 바꾸는 기준 1
green_threshold = 70 # 흑백으로 바꾸는 기준 2
red_threshold = 70 # 흑백으로 바꾸는 기준 3
bgr_threshold = [blue_threshold, green_threshold, red_threshold] # 3차월 배열로 바꿔줌

for i in range(image.shape[0]):
for j in range(image.shape[1]):
if (image[i, j, 0] >= blue_threshold) and (image[i, j, 1] >= green_threshold) and image[i, j, 2] >= red_threshold:
mark_1[i, j ] = 255,255,255 # 검정
else :
mark_1[i, j ] = 0,0,0 # 하얀색

ju = cv2.imread(‘images/go2.jpg’, cv2.COLOR_BGR2GRAY) # 검출할 사진 불러옴
white_s = cv2.cvtColor(ju, cv2.COLOR_BGR2GRAY) # 불러온 친구의 색 공간을 바꿈
mark = cv2.cvtColor(mark_1 , cv2.COLOR_BGR2GRAY) # 위와 동문
template = white_s # template = 비교할 것
w, h =template.shape[:: -1] # 불러온 사진의 너비와 높이

res = cv2.matchTemplate(mark, template, cv2.TM_CCOEFF_NORMED) # 함수를 사용해서 비교함
threshold = 0.6 # 이 값보다 높을 때
loc = np.where(res > threshold) # 위치를 리턴함
for pt in zip(*loc[::-1]): # 위치의 가로 세로
if (image[pt[1], pt[0],2] != 255):
cv2.rectangle(image, pt , (pt[0]+w, pt[1]+h), (0,255,0),2) # 초록색으로 칠함
cv2.circle(image, (int(pt[0]+w*0.5), int(pt[1]+h*0.5)),1, (255,0,0)) # 중심에 파란 원
s_x = int(pt[0] + w * 0.5) # 중심 x
s_y = int(pt[1] + h * 0.5) # 중심 y
s_xy = str(s_x) + str(s_y) # str로 합침
s_xy = int(s_xy) # 다시 숫자로 바꿈
s_xy_dt = [] stone_dt = [] for i in range(0, 10): # 범위 내 값을 걸러줌
for j in range(0, 10):
s_xy_dt.append(s_xy – i*1000 – j)
s_xy_dt.append(s_xy – i*1000 + j)
s_xy_dt.append(s_xy + i*1000 – j)
s_xy_dt.append(s_xy + i*1000 + j)
xx = 0
for k in range(len(s_xy_dt)): ## 값이 같지 않으면 stack
if stone != s_xy_dt[k]:
xx += 1
yy = 0
if xx == len(s_xy_dt) : # stack 값이 다 같을 때 = 오차의 범위 값이 list에 없을 때
if s_xy < 99999 : # y축이 두자리 프레임일 때
for k in range(len(stone)):
if abs(stone[k] – s_xy) < 110: # 100의 자리 = x축 프레임 차이, 1의 자리 = y축 프레임
yy += 1
if yy == 0 :
stone.append(s_xy)

else : # x ,y 둘다 3자리 프레임일 때
for k in range(len(stone)):
if abs(stone[k] – s_xy) < 1010: # 1000의 자리 = x축, 1의자리 = y축의 차이
yy += 1
if yy == 0 :
stone.append(s_xy)

aa = len(final_stone)
for i in range(len(stone)):
stone_xx_1 = 0
stone_yy_1 = 0
if stone[i] < 99999 :
stone_x = stone[i] / 100 # 앞자리 3개
stone_y = stone[i] % 100 # 뒷자리 2개

stone_y = abs(stone_y) / 20 # 경험적 치수
stone_x = (abs((stone_x – 160) / 20) ) # 경험적 치수
else :
stone_x = stone[i] / 1000 # 앞자리 3개
stone_y = stone[i] % 1000 # 뒷자리 3개

stone_x = (abs((stone_x – 160) / 20)) # 경험적 치수
stone_y = (stone_y / 20 ) # 경험적 치수
ab = int(stone_x) *100 + int(stone_y)
if ab not in final_stone: # list에 없으면
final_stone.append(ab)

if aa != len(final_stone) : # 전의 길이와 다르면 = 새롭게 추가되면
print( int(final_stone[-1] % 100), int(final_stone[-1]/100))
print(‘——————’)
cv2.imshow(‘mm’, image) # 이미지 출력
cv2.imshow(‘aa’, ju) # 비교 이미지 출력
cv2.waitKey(150) # delay
5neck.py
import numpy as np, cv2
import time
image = cv2.imread(‘images/go2.jpg’, cv2.IMREAD_COLOR)
capture = cv2.VideoCapture(0) #카메라 불러오는 함수
if capture.isOpened() == False: raise Exception(“카메라 연결 안됨”)
stone = [] final_stone = [] while(capture.isOpened()): # 카메라가 열려있을 때 ~
ret, image = capture.read() # image로 받아옴

mark = np.zeros(image.shape, image.dtype) # mark 라는 친구를 생성함
mark_1 = np.zeros(image.shape, image.dtype) # mark_1이라는 친구도 생성함함
blue_threshold = 70 # 흑백으로 바꾸는 기준 1
green_threshold = 70 # 흑백으로 바꾸는 기준 2
red_threshold = 70 # 흑백으로 바꾸는 기준 3
bgr_threshold = [blue_threshold, green_threshold, red_threshold] # 3차월 배열로 바꿔줌

for i in range(image.shape[0]):
for j in range(image.shape[1]):
if (image[i, j, 0] >= blue_threshold) and (image[i, j, 1] >= green_threshold) and image[i, j, 2] >= red_threshold:
mark_1[i, j ] = 255,255,255
else :
mark_1[i, j ] = 0,0,0

#print(mark.shape)

ju = cv2.imread(‘images/go2.jpg’, cv2.COLOR_BGR2GRAY) # 검출할 사진 불러옴
white_s = cv2.cvtColor(ju, cv2.COLOR_BGR2GRAY) # 불러온 친구의 색 공간을 바꿈
mark = cv2.cvtColor(mark_1 , cv2.COLOR_BGR2GRAY) # 위와 동문
template = white_s # template = 비교할 것
w, h =template.shape[:: -1] # 불러온 사진의 너비와 높이
#stone = [] res = cv2.matchTemplate(mark, template, cv2.TM_CCOEFF_NORMED) # 함수를 사용해서 비교함
threshold = 0.6 # 이 값보다 높을 때
loc = np.where(res > threshold) # 위치를 리턴함
for pt in zip(*loc[::-1]): # 위치의 가로 세로
if (image[pt[1], pt[0],2] != 255):
cv2.rectangle(image, pt , (pt[0]+w, pt[1]+h), (0,255,0),2) # 초록색으로 칠함
cv2.circle(image, (int(pt[0]+w*0.5), int(pt[1]+h*0.5)),1, (255,0,0))
#print(int(pt[0]+w*0.5), int(pt[1]+h*0.5))
s_x = int(pt[0] + w * 0.5)
s_y = int(pt[1] + h * 0.5)
s_xy = str(s_x) + str(s_y)
s_xy = int(s_xy)
s_xy_dt = [] stone_dt = [] for i in range(0, 10):
for j in range(0, 10):
s_xy_dt.append(s_xy – i*1000 – j)
s_xy_dt.append(s_xy – i*1000 + j)
s_xy_dt.append(s_xy + i*1000 – j)
s_xy_dt.append(s_xy + i*1000 + j)
xx = 0
for k in range(len(s_xy_dt)):
if stone != s_xy_dt[k]:
xx += 1
yy = 0
if xx == len(s_xy_dt) :
if s_xy < 99999 :
for k in range(len(stone)):
if abs(stone[k] – s_xy) < 110:
yy += 1
if yy == 0 :
stone.append(s_xy)
else :
for k in range(len(stone)):
if abs(stone[k] – s_xy) < 1010:
yy += 1
if yy == 0 :
stone.append(s_xy)
#print(stone)
aa = len(final_stone)
for i in range(len(stone)):
stone_xx_1 = 0
stone_yy_1 = 0
if stone[i] < 99999 :
stone_x = stone[i] / 100
stone_y = stone[i] % 100
#print(stone_x)
#print(stone_y)
stone_y = abs(stone_y) / 20
stone_x = (abs((stone_x – 160) / 20) )
else :
stone_x = stone[i] / 1000
stone_y = stone[i] % 1000
#print(stone_x)
#print(stone_y)
stone_x = (abs((stone_x – 160) / 20))

stone_y = (stone_y / 20 )
ab = int(stone_x) *100 + int(stone_y)
if ab not in final_stone:
final_stone.append(ab)

#for k in range(len(final_stone)):
# print(int(final_stone[k] / 100) , int(final_stone[k] % 100))
if aa != len(final_stone) :
print( int(final_stone[-1] % 100), int(final_stone[-1]/100))
print(‘——————’)
cv2.imshow(‘mm’, image)
cv2.imshow(‘aa’, ju)
cv2.waitKey(150)

import numpy as np
from glob import glob
from tqdm import tqdm # for 문의 상태바를 나태내주는 라이브러리
import os

”’
Dataset from https://gomocup.org/results/
데이터셋을 얻는 프로그램
# 데이터 전처리 과정
game_rule = ‘Freestyle’ # 프리스타일(3×3가능 5개 이상만 돌을 연속으로 두면 승리)
base_path = ‘/omok_AI/gomocup2020results’ # 전처리전 데이터가 저장되어 있는 경로

output_path = os.path.join(‘dataset’, os.path.basename(base_path)) # dataset\gomocup2019results\
os.makedirs(output_path, exist_ok=True) # 디렉토리 생성

# 경로에 있는 모든 psq파일을 file_list에 저장
file_list = glob(os.path.join(base_path, ‘%s*/*.psq’ % (game_rule, )))

for index, file_path in enumerate(tqdm(file_list)):
with open(file_path, ‘r’) as f:
lines = f.read().splitlines()

w, h = lines[0].split(‘ ‘)[1].strip(‘,’).split(‘x’) # 가로 X 세로의 크기 추출
w, h = int(w), int(h) # 문자에서 인트형으로 형 변환

lines = lines[1:] # 첫번째 줄을 제외한 나머지 줄

inputs, outputs = [], [] board = np.zeros([h, w], dtype=np.int8)

for i, line in enumerate(lines):
if ‘,’ not in line:
break

x, y, t = np.array(line.split(‘,’), np.int8)
if i % 2 == 0: # 오목의 순서제
player = 1
else:
player = 2

input = board.copy().astype(np.int8)
input[(input != player) & (input != 0)] = -1
input[(input == player) & (input != 0)] = 1

output = np.zeros([h, w], dtype=np.int8)
output[y-1, x-1] = 1 # h w 순서

# augmentation
# rotate 4 x flip 3 = 12
# 데이터셋을 늘림
for k in range(4):
input_rot = np.rot90(input, k=k)
output_rot = np.rot90(output, k=k)
inputs.append(input_rot)
outputs.append(output_rot)
inputs.append(np.fliplr(input_rot))
outputs.append(np.fliplr(output_rot))
inputs.append(np.flipud(input_rot))
outputs.append(np.flipud(output_rot))
# update board
board[y-1, x-1] = player
# dataset 저장
np.savez_compressed(os.path.join(output_path, ‘%s.npz’ % (str(index).zfill(5))), inputs=inputs, outputs=outputs)

from ursina import *
import numpy as np
from tensorflow.keras.models import load_model
from omok import Board, Omok
import serial
import time
# from serial_arduino import coordinate_str

PORT = ‘COM13′
BaudRate = 9600
sendSerial = serial.Serial(‘COM13′, BaudRate) # x축
ardSerial = serial.Serial(‘COM11′, 9600) # y축

# sendSerial = serial.Serial(‘COM14′, BaudRate)

# 오목 6개 만들시에도 게임을 승리하는 부분 보완
model = load_model(‘models/20210307_232530.h5′)

app = Ursina()
window.borderless = False
window.color = color._50

w, h = 20, 20
camera.orthographic = True
camera.fov = 23
camera.position = (w//2, h//2)

board = Board(w=w, h=h)
board_buttons = [[None for x in range(w)] for y in range(h)] game = Omok(board=board)

Entity(model=Grid(w+1, h+1), scale=w+1, color=color.blue, x=w//2-0.5, y=h//2-0.5, z=0.1)

for y in range(h):
for x in range(w):
b = Button(parent=scene, position=(x, y), color=color.clear, model=’circle’, scale=0.9) # 마우스 왼쪽 클릭
board_buttons[y][x] = b

def on_mouse_enter(b=b):
if b.collision:
b.color = color._100
def on_mouse_exit(b=b):
if b.collision:
b.color = color.clear

b.on_mouse_enter = on_mouse_enter
b.on_mouse_exit = on_mouse_exit

def on_click(b=b):
# player turn
b.text = ’1′
b.color = color.black
b.collision = False

game.put(x=int(b.position.x), y=int(h – b.position.y – 1)) # start from top left
won_player = game.check_won()

if won_player > 0:
end_session(won_player)
game.next()

# cpu turn
input_o = game.board.board.copy()
input_o[(input_o != 1) & (input_o != 0)] = -1
input_o[(input_o == 1) & (input_o != 0)] = 1
input_o = np.expand_dims(input_o, axis=(0, -1)).astype(np.float32)

output = model.predict(input_o).squeeze()
output = output.reshape((h, w))
output_y, output_x = np.unravel_index(np.argmax(output), output.shape)
game.put(x=output_x, y=output_y)

data_x = str(output_x)
data_y = str(output_y)
print(data_x, data_y)

# 아두이노에 넘겨줄 데이터 정제
# 00/00 의 형태로 data_output 생성
if len(data_x) != 2:
data_x = ’0′ + data_x
if len(data_y) != 2:
data_y = ’0′ + data_y
data_output = “Q” + data_x + data_y
data_output = data_output.encode(‘utf-8′)

sendSerial.write(data_output)
ardSerial.write(data_output)

print(type(data_output))
print(data_output)

board_buttons[h - output_y - 1][output_x].text = ’2′
board_buttons[h - output_y - 1][output_x].text_color = color.black
board_buttons[h - output_y - 1][output_x].color = color.white
board_buttons[h - output_y - 1][output_x].collision = False

won_player = game.check_won()

if won_player > 0:
end_session(won_player)

game.next()
print(game.board)
b.on_click = on_click
def end_session(won_player):
Panel(z=1, scale=10, model=’quad’)
t = Text(f’Player {won_player} won!’, scale=3, origin=(0, 0), background=True)
t.create_background(padding=(.5,.25), radius=Text.size/2)

app.run()

import numpy as np, cv2
import time
image = cv2.imread(‘images/go2.jpg’, cv2.IMREAD_COLOR)
capture = cv2.VideoCapture(0) #카메라 불러오는 함수
if capture.isOpened() == False: raise Exception(“카메라 연결 안됨”)
stone = [] final_stone = [] while(capture.isOpened()): # 카메라가 열려있을 때 ~
ret, image = capture.read() # image로 받아옴

mark = np.zeros(image.shape, image.dtype) # mark 라는 친구를 생성함
mark_1 = np.zeros(image.shape, image.dtype) # mark_1이라는 친구도 생성함함
blue_threshold = 70 # 흑백으로 바꾸는 기준 1
green_threshold = 70 # 흑백으로 바꾸는 기준 2
red_threshold = 70 # 흑백으로 바꾸는 기준 3
bgr_threshold = [blue_threshold, green_threshold, red_threshold] # 3차월 배열로 바꿔줌

for i in range(image.shape[0]):
for j in range(image.shape[1]):
if (image[i, j, 0] >= blue_threshold) and (image[i, j, 1] >= green_threshold) and image[i, j, 2] >= red_threshold:
mark_1[i, j ] = 255,255,255 # 검정
else :
mark_1[i, j ] = 0,0,0 # 하얀색

ju = cv2.imread(‘images/go2.jpg’, cv2.COLOR_BGR2GRAY) # 검출할 사진 불러옴
white_s = cv2.cvtColor(ju, cv2.COLOR_BGR2GRAY) # 불러온 친구의 색 공간을 바꿈
mark = cv2.cvtColor(mark_1 , cv2.COLOR_BGR2GRAY) # 위와 동문
template = white_s # template = 비교할 것
w, h =template.shape[:: -1] # 불러온 사진의 너비와 높이

res = cv2.matchTemplate(mark, template, cv2.TM_CCOEFF_NORMED) # 함수를 사용해서 비교함
threshold = 0.6 # 이 값보다 높을 때
loc = np.where(res > threshold) # 위치를 리턴함
for pt in zip(*loc[::-1]): # 위치의 가로 세로
if (image[pt[1], pt[0],2] != 255):
cv2.rectangle(image, pt , (pt[0]+w, pt[1]+h), (0,255,0),2) # 초록색으로 칠함
cv2.circle(image, (int(pt[0]+w*0.5), int(pt[1]+h*0.5)),1, (255,0,0)) # 중심에 파란 원
s_x = int(pt[0] + w * 0.5) # 중심 x
s_y = int(pt[1] + h * 0.5) # 중심 y
s_xy = str(s_x) + str(s_y) # str로 합침
s_xy = int(s_xy) # 다시 숫자로 바꿈
s_xy_dt = [] stone_dt = [] for i in range(0, 10): # 범위 내 값을 걸러줌
for j in range(0, 10):
s_xy_dt.append(s_xy – i*1000 – j)
s_xy_dt.append(s_xy – i*1000 + j)
s_xy_dt.append(s_xy + i*1000 – j)
s_xy_dt.append(s_xy + i*1000 + j)
xx = 0
for k in range(len(s_xy_dt)): ## 값이 같지 않으면 stack
if stone != s_xy_dt[k]:
xx += 1
yy = 0
if xx == len(s_xy_dt) : # stack 값이 다 같을 때 = 오차의 범위 값이 list에 없을 때
if s_xy < 99999 : # y축이 두자리 프레임일 때
for k in range(len(stone)):
if abs(stone[k] – s_xy) < 110: # 100의 자리 = x축 프레임 차이, 1의 자리 = y축 프레임
yy += 1
if yy == 0 :
stone.append(s_xy)

else : # x ,y 둘다 3자리 프레임일 때
for k in range(len(stone)):
if abs(stone[k] – s_xy) < 1010: # 1000의 자리 = x축, 1의자리 = y축의 차이
yy += 1
if yy == 0 :
stone.append(s_xy)

aa = len(final_stone)
for i in range(len(stone)):
stone_xx_1 = 0
stone_yy_1 = 0
if stone[i] < 99999 :
stone_x = stone[i] / 100 # 앞자리 3개
stone_y = stone[i] % 100 # 뒷자리 2개

stone_y = abs(stone_y) / 20 # 경험적 치수
stone_x = (abs((stone_x – 160) / 20) ) # 경험적 치수
else :
stone_x = stone[i] / 1000 # 앞자리 3개
stone_y = stone[i] % 1000 # 뒷자리 3개

stone_x = (abs((stone_x – 160) / 20)) # 경험적 치수
stone_y = (stone_y / 20 ) # 경험적 치수
ab = int(stone_x) *100 + int(stone_y)
if ab not in final_stone: # list에 없으면
final_stone.append(ab)

if aa != len(final_stone) : # 전의 길이와 다르면 = 새롭게 추가되면
print( int(final_stone[-1] % 100), int(final_stone[-1]/100))
print(‘——————’)
cv2.imshow(‘mm’, image) # 이미지 출력
cv2.imshow(‘aa’, ju) # 비교 이미지 출력
cv2.waitKey(150) # delay
5neck.py
import numpy as np, cv2
import time
image = cv2.imread(‘images/go2.jpg’, cv2.IMREAD_COLOR)
capture = cv2.VideoCapture(0) #카메라 불러오는 함수
if capture.isOpened() == False: raise Exception(“카메라 연결 안됨”)
stone = [] final_stone = [] while(capture.isOpened()): # 카메라가 열려있을 때 ~
ret, image = capture.read() # image로 받아옴

mark = np.zeros(image.shape, image.dtype) # mark 라는 친구를 생성함
mark_1 = np.zeros(image.shape, image.dtype) # mark_1이라는 친구도 생성함함
blue_threshold = 70 # 흑백으로 바꾸는 기준 1
green_threshold = 70 # 흑백으로 바꾸는 기준 2
red_threshold = 70 # 흑백으로 바꾸는 기준 3
bgr_threshold = [blue_threshold, green_threshold, red_threshold] # 3차월 배열로 바꿔줌

for i in range(image.shape[0]):
for j in range(image.shape[1]):
if (image[i, j, 0] >= blue_threshold) and (image[i, j, 1] >= green_threshold) and image[i, j, 2] >= red_threshold:
mark_1[i, j ] = 255,255,255
else :
mark_1[i, j ] = 0,0,0

#print(mark.shape)

ju = cv2.imread(‘images/go2.jpg’, cv2.COLOR_BGR2GRAY) # 검출할 사진 불러옴
white_s = cv2.cvtColor(ju, cv2.COLOR_BGR2GRAY) # 불러온 친구의 색 공간을 바꿈
mark = cv2.cvtColor(mark_1 , cv2.COLOR_BGR2GRAY) # 위와 동문
template = white_s # template = 비교할 것
w, h =template.shape[:: -1] # 불러온 사진의 너비와 높이
#stone = [] res = cv2.matchTemplate(mark, template, cv2.TM_CCOEFF_NORMED) # 함수를 사용해서 비교함
threshold = 0.6 # 이 값보다 높을 때
loc = np.where(res > threshold) # 위치를 리턴함
for pt in zip(*loc[::-1]): # 위치의 가로 세로
if (image[pt[1], pt[0],2] != 255):
cv2.rectangle(image, pt , (pt[0]+w, pt[1]+h), (0,255,0),2) # 초록색으로 칠함
cv2.circle(image, (int(pt[0]+w*0.5), int(pt[1]+h*0.5)),1, (255,0,0))
#print(int(pt[0]+w*0.5), int(pt[1]+h*0.5))
s_x = int(pt[0] + w * 0.5)
s_y = int(pt[1] + h * 0.5)
s_xy = str(s_x) + str(s_y)
s_xy = int(s_xy)
s_xy_dt = [] stone_dt = [] for i in range(0, 10):
for j in range(0, 10):
s_xy_dt.append(s_xy – i*1000 – j)
s_xy_dt.append(s_xy – i*1000 + j)
s_xy_dt.append(s_xy + i*1000 – j)
s_xy_dt.append(s_xy + i*1000 + j)
xx = 0
for k in range(len(s_xy_dt)):
if stone != s_xy_dt[k]:
xx += 1
yy = 0
if xx == len(s_xy_dt) :
if s_xy < 99999 :
for k in range(len(stone)):
if abs(stone[k] – s_xy) < 110:
yy += 1
if yy == 0 :
stone.append(s_xy)
else :
for k in range(len(stone)):
if abs(stone[k] – s_xy) < 1010:
yy += 1
if yy == 0 :
stone.append(s_xy)
#print(stone)
aa = len(final_stone)
for i in range(len(stone)):
stone_xx_1 = 0
stone_yy_1 = 0
if stone[i] < 99999 :
stone_x = stone[i] / 100
stone_y = stone[i] % 100
#print(stone_x)
#print(stone_y)
stone_y = abs(stone_y) / 20
stone_x = (abs((stone_x – 160) / 20) )
else :
stone_x = stone[i] / 1000
stone_y = stone[i] % 1000
#print(stone_x)
#print(stone_y)
stone_x = (abs((stone_x – 160) / 20))

stone_y = (stone_y / 20 )
ab = int(stone_x) *100 + int(stone_y)
if ab not in final_stone:
final_stone.append(ab)

#for k in range(len(final_stone)):
# print(int(final_stone[k] / 100) , int(final_stone[k] % 100))
if aa != len(final_stone) :
print( int(final_stone[-1] % 100), int(final_stone[-1]/100))
print(‘——————’)
cv2.imshow(‘mm’, image)
cv2.imshow(‘aa’, ju)
cv2.waitKey(150)

import numpy as np
class Board():
def __init__(self, w, h):
self.w = w
self.h = h
self.board = np.zeros((self.h, self.w), dtype=np.int)
“”"
def __repr__(self):
string = ”
data1 = [] data2 = [] for y in range(self.h):
for x in range(self.w):
string += ‘%d ‘ % self.board[y][x] if self.board[y][x] == 2:
data1.append(x)
data2.append(y)
string += ‘\n’

return string
“”"

class Omok():
def __init__(self, board):
self.board = board
self.current_player = 1
self.won_player = 0

def reset(self):
self.board.board = 0
self.current_player = 1
self.won_player = 0

def put(self, x=None, y=None):
if x is None and y is None:
while True:
rand_x = np.random.randint(0, self.board.w)
rand_y = np.random.randint(0, self.board.h)

if self.board.board[rand_y][rand_x] == 0:
self.board.board[rand_y][rand_x] = self.current_player
break
else:
self.board.board[y][x] = self.current_player

def next(self):
if self.current_player == 1:
self.current_player = 2
else:
self.current_player = 1

def check_won(self):
player = self.current_player

for y in range(self.board.h):
for x in range(self.board.w):
try:
if self.board.board[y][x] == player and self.board.board[y + 1][x] == player and \
self.board.board[y + 2][x] == player and self.board.board[y + 3][x] == player and \
self.board.board[y + 4][x] == player:
self.won_player = player
break
except:
pass

try:
if self.board.board[y][x] == player and self.board.board[y][x + 1] == player and \
self.board.board[y][x + 2] == player and self.board.board[y][x + 3] == player and \
self.board.board[y][x + 4] == player:
self.won_player = player
break
except:
pass

try:
if self.board.board[y][x] == player and self.board.board[y + 1][x + 1] == player and \
self.board.board[y + 2][x + 2] == player and self.board.board[y + 3][x + 3] == player and \
self.board.board[y + 4][x + 4] == player:
self.won_player = player
break
except:
pass

try:
if x >= 4 and self.board.board[y][x] == player and self.board.board[y + 1][x - 1] == player and \
self.board.board[y + 2][x - 2] == player and self.board.board[y + 3][x - 3] == player and \
self.board.board[y + 4][x - 4] == player:
self.won_player = player
break
except:
pass
if self.won_player > 0:
break
return self.won_player

import numpy as np
import tensorflow as tf
import tensorflow.keras as keras
from tensorflow.keras import layers, models
from sklearn.model_selection import train_test_split
from glob import glob
from tqdm import tqdm
from datetime import datetime
from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
import os
w, h = 20, 20

file_list = glob(‘C:\JupyterProject\dataset_2020\*.npz’)

x_data, y_data = [], [] for file_path in tqdm(file_list):
data = np.load(file_path)
x_data.extend(data['inputs'])
y_data.extend(data['outputs'])
x_data = np.array(x_data, np.float32).reshape((-1, h, w, 1))
y_data = np.array(y_data, np.float32).reshape((-1, h * w))

x_train, x_val, y_train, y_val = train_test_split(x_data, y_data, test_size=0.2, random_state=2020)

del x_data, y_data

print(x_train.shape, y_train.shape)
print(x_val.shape, y_val.shape)
model = models.Sequential([
layers.Conv2D(64, 7, activation='relu', padding='same', input_shape=(h, w, 1)),
layers.Conv2D(128, 7, activation='relu', padding='same'),
layers.Conv2D(256, 7, activation='relu', padding='same'),
layers.Conv2D(128, 7, activation='relu', padding='same'),
layers.Conv2D(64, 7, activation='relu', padding='same'),
layers.Conv2D(1, 1, activation=None, padding='same'),
layers.Reshape((h * w,)),
layers.Activation('sigmoid')
])

model.compile(
optimizer=’adam’,
loss=’binary_crossentropy’,
metrics=['acc'] )
model.summary()

start_time = datetime.now().strftime(‘%Y%m%d_%H%M%S’)
os.makedirs(‘models’, exist_ok=True)

model.fit(
x=x_train,
y=y_train,
batch_size=256,
epochs=10,
callbacks=[
ModelCheckpoint('./models/%s.h5' % (start_time), monitor='val_acc', verbose=1, save_best_only=True, mode='auto'),
ReduceLROnPlateau(monitor='val_acc', factor=0.2, patience=5, verbose=1, mode='auto')
],
validation_data=(x_val, y_val),
use_multiprocessing=True,
workers=16
)