def receiver(client, addr):
global num
global counter
counter += 1
frame_name = f'frame {counter}'
reader = client.makefile('rb')
# writer = client.makefile('wb')
data, data_len, fname, save = net.receive(reader)
print('-------수신 ')
if not data_len: return
# data : jpeg 이미지
# image : bgr 이미지
image, key = show_image(data, frame_name)
# AI 알고리즘 처리
if save == 1:
# now = datetime.datetime.now()
# fname = now.strftime("%y%m%d%H%M%S") + ".jpeg"
# 파일 경로
fname = fname.decode()
print(fname)
filepath = "C:/Users/wjdgo/iot_project/LockStop/python/image/" + fname + ".jpeg"
print(filepath)
# filename = "C:/Users/hongj/LockStop/python/image/"+fname
cv2.imwrite(filepath, image)
data_update(filepath)
# result = json.dumps({'result':'ok'})
# net.send(writer, result.encode())
cv2.destroyAllWindows()
print('exit receiver')
def receiver(client, addr):
reader = client.makefile('rb')
writer = client.makefile('wb')
while True:
data, data_len = net.receive(reader)
if not data:
break
print('received', data_len) # 이미지 처리
show_image(data)
result = json.dumps({'result':'ok'})
net.send(writer, result.encode())
print('exit receiver')
def receiver(client, addr):
reader = client.makefile('rb')
writer = client.makefile('wb')
while True:
data, data_len = net.receive(reader)
if not data:
break
data = np.frombuffer(data, dtype=np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
output_dict = detect(data)
result = json.dumps(output_dict, cls=NumpyEncoder)
net.send(writer, result.encode())
print('exit receiver')
def receiver(client, addr):
reader = client.makefile('rb')
writer = client.makefile('wb')
try:
data, data_len = net.receive(reader)
if not data:
print('no data')
print('received', data_len) # 이미지 처리
# print(location)
data = np.frombuffer(data, dtype=np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
ai(data, writer)
except Exception as e:
print('Error :', e)
print('exit receiver')
def receiver(client, addr):
global counter
counter += 1
frame_name = f'frame {counter}'
reader = client.makefile('rb')
writer = client.makefile('wb')
while True:
data, data_len = net.receive(reader)
if not data:
break
# print('received ', data_len) # 이미지 처리
# AI 알고리즘 처리
show_image(data, frame_name)
result = json.dumps({'result': 'ok'})
net.send(writer, result.encode())
print('exit receiver')
def server_adurl(reader):
request = net.receive(reader)[0]
if len(request) > 0:
request = json.loads(request.decode())
url = request['url'] # url 주소
filename = request['ad_file']
if url == '0':
print('detected nothing')
return False
# file_dir = f'C:/iot_workspace/project/input/video/ad_video/{filename}'
file_dir = f'/home/pi/iot_workspace/project/output/ad_video/{filename}'
if path.isfile(file_dir) == True:
Video.video_play(file_dir)
else:
Video.connect_url(url, filename) # url 접속 후 영상 다운로드
print('video start')
Video.video_play(file_dir) # file 실행
def receiver(client, addr):
try:
reader = client.makefile('rb')
reader1 = client.makefile('rb')
writer = client.makefile('wb')
# try:
data, data_len = net.receive(reader)
location = net.receive_str(reader)
print('received', data_len) # 이미지 처리
location = location.decode('cp949')
print('요청한 디바이스 : ', location)
data = np.frombuffer(data, dtype=np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
ai(data, writer, location)
except Exception as e:
result = json.dumps({'url':'0', 'ad_file' : '0'})
net.send(writer, result.encode())
print('Error :', e)
print('exit receiver')
def video_streaming():
with socket.socket() as s:
s.connect((HOST, PORT))
writer = s.makefile('wb')
reader = s.makefile('rb')
stream = io.BytesIO()
for _ in camera.capture_continuous(stream, 'jpeg', use_video_port = True):
image = stream.getvalue() # 스트림에서 byte 배열 얻기
net.send(writer, image)
result = net.receive(reader)[0]
# 다음 캡쳐를 위해 스트림을 리셋 - 파일의 기존 내용을 버림
stream.seek(0) # 파일 쓰기 위치를 맨 앞으로 이동
stream.truncate() # 기존 내용을 버리는 작업
if not motion.value:
writer.write(struct.pack('<L', 0)) # 스트리밍 끝
writer.flush()
break
def get_next_lsn():
while True:
resp = requests.get(LSN_URL)
current_lsn = int(resp.json()['node']['value'])
resp = requests.put(f"{LSN_URL}?prevValue={current_lsn}",
data={'value': current_lsn + 1})
if resp.status_code == 200:
return current_lsn + 1
s.listen(5)
while True:
(clientsocket, address) = s.accept()
req = receive(clientsocket)
# logging.info(f"request from {address}: {req}")
data = load_data(DATA_FILE)
if len(req) > KEY_LENGTH:
key = req[1:KEY_LENGTH + 1]
key_ports = get_ports(get_location(key))
if PORT not in key_ports:
msg = serialize_forward(key_ports)
clientsocket.send(msg)
logging.info(f"forwarding to {key_ports}")
elif req[0:1] == constants.SET:
value = req[KEY_LENGTH + 1:]
lsn = get_next_lsn()
def play_as_client(server):
if supports_ansi():
print('\x1b[3F\x1b[J', end='') # clear initial connection text
else:
print()
# CREATE CHARACTER #
client_element = pick_element()
client_stats = pick_stats()
# pick moveset from that elementalist's movelist of possible moves
if client_element == 'earth':
client_moveset = pick_moveset('earth')
elif client_element == 'fire':
client_moveset = pick_moveset('fire')
elif client_element == 'water':
client_moveset = pick_moveset('water')
elif client_element == 'wind':
client_moveset = pick_moveset('wind')
client_info = {
'element': client_element,
'stats': client_stats,
'moveset': client_moveset
}
send(server, client_info)
# BATTLE STAGE #
wait()
print('Let the battle commence!')
wait()
while True:
hp_info = receive(server)
print('Your HP: {} Opponent\'s HP: {}\n'.format(
hp_info['client_hp'], hp_info['server_hp']))
print('Your moves:\n')
for move in client_moveset:
print_move(move)
# push client for move until valid move entered
while True:
client_move = input('Choose your move: ').lower()
if client_move in client_moveset:
break
send(server, client_move)
wait() # wait before printing results for better user experience
# faster player's attack results
results = receive(server)
if results['attacker'] == 'server':
print_def_results(results)
else:
print_atk_results(results)
# check if game over
if knocked_out(results['client_hp'], results['server_hp']):
break
# slower player's attack results
results = receive(server)
if results['attacker'] == 'server':
print_def_results(results)
else:
print_atk_results(results)
# check if game over
if knocked_out(results['client_hp'], results['server_hp']):
break
# receive status info
status_info = receive(server)
if status_info['server_status'] == 'burned':
print('Your opponent loses 25 HP from burns.')
wait()
if status_info['client_status'] == 'burned':
print('You lose 25 HP from your burn.')
wait()
if knocked_out(status_info['client_hp'], status_info['server_hp']):
break
def play_as_server(client):
if supports_ansi():
print('\x1b[3F\x1b[J', end='') # clear initial connection text
else:
print()
# CREATE CHARACTERS #
server_element = pick_element()
# given the number stat chosen, get the map for those stats
server_stat_num = int(pick_stats()) - 1
server_stats = STAT_OPTIONS[server_stat_num]
# pick moveset from that elementalist's movelist of possible moves
if server_element == 'earth':
server_moveset = pick_moveset('earth')
elif server_element == 'fire':
server_moveset = pick_moveset('fire')
elif server_element == 'water':
server_moveset = pick_moveset('water')
elif server_element == 'wind':
server_moveset = pick_moveset('wind')
server_elementalist = Elementalist(server_element, server_stats['hp'],
server_stats['attack'],
server_stats['speed'], server_moveset)
client_info = receive(client)
# don't trust client: check info before instantiating elementalist
if client_info['element'] not in {'earth', 'fire', 'water', 'wind'}:
raise SystemExit(
'The client\'s element choice was invalid. Client may be tampering with'
+ ' the code. Exiting the program.')
# check that client chose one of the five stats options
if int(client_info['stats']) not in range(1, 6):
raise SystemExit(
'The client\'s stats choice was invalid. Client may be tampering with '
+ 'the code. Exiting the program.')
# check that the moveset is valid
for choice in client_info['moveset']:
# check that choice is a valid type for that elementalist
valid_choice = False
if client_info['element'] == 'earth':
if MOVES[choice]['type'] == 'earth':
valid_choice = True
elif client_info['element'] == 'fire':
if MOVES[choice]['type'] == 'fire':
valid_choice = True
elif client_info['element'] == 'water':
if MOVES[choice]['type'] == 'water':
valid_choice = True
elif client_info['element'] == 'wind':
if MOVES[choice]['type'] == 'wind':
valid_choice = True
# normal type moves are valid for all elementalists
if MOVES[choice]['type'] == 'normal':
valid_choice = True
# if one of the moves was not in the proper movelist
if not valid_choice:
raise SystemExit(
'The client\'s move choice was invalid. Client may be ' +
'tampering with the code. Exiting the program.')
# finished checking client_info
# Given the number stat chosen, get the map for those stats
client_stat_num = int(client_info['stats']) - 1
client_stats = STAT_OPTIONS[client_stat_num]
client_elementalist = Elementalist(client_info['element'],
client_stats['hp'],
client_stats['attack'],
client_stats['speed'],
client_info['moveset'])
# BATTLE STAGE #
wait()
print('Let the battle commence!')
wait()
while True:
hp_info = {
'server_hp': server_elementalist.hp,
'client_hp': client_elementalist.hp
}
send(client, hp_info)
print('Your HP: {} Opponent\'s HP: {}\n'.format(
server_elementalist.hp, client_elementalist.hp))
# choose a move
print('Your moves:\n')
for move in server_elementalist.moveset:
print_move(move)
while True:
server_move = input('Choose your move: ').lower()
if server_move in server_elementalist.moveset:
break
# receive and validate client's move
client_move = receive(client)
if client_move not in client_elementalist.moveset:
raise SystemExit(
'The client\'s move choice was invalid. Client may be tampering with '
+ 'the code. Exiting the program.')
wait() # call wait before printing results for nicer user experience
# evaluate speeds
if server_first(server_elementalist, server_move, client_elementalist,
client_move):
server_second = False
# if server's first, server attacks client
server_atk_results = attack(server_elementalist, server_move,
client_elementalist)
# let client know which results these are
server_atk_results['attacker'] = 'server'
# tell client the hp of each after the attack
server_atk_results['server_hp'] = server_elementalist.hp
server_atk_results['client_hp'] = client_elementalist.hp
send(client, server_atk_results)
print_atk_results(server_atk_results)
if knocked_out(server_elementalist.hp, client_elementalist.hp):
break
else:
server_second = True
# client attacks server
client_atk_results = attack(client_elementalist, client_move,
server_elementalist)
client_atk_results['attacker'] = 'client'
client_atk_results['server_hp'] = server_elementalist.hp
client_atk_results['client_hp'] = client_elementalist.hp
send(client, client_atk_results)
print_def_results(client_atk_results)
if knocked_out(server_elementalist.hp, client_elementalist.hp):
break
# if server hadn't been first, server attacks client
if server_second:
server_atk_results = attack(server_elementalist, server_move,
client_elementalist)
server_atk_results['attacker'] = 'server'
server_atk_results['server_hp'] = server_elementalist.hp
server_atk_results['client_hp'] = client_elementalist.hp
send(client, server_atk_results)
print_atk_results(server_atk_results)
if knocked_out(server_elementalist.hp, client_elementalist.hp):
break
# status conditions
if server_elementalist.status == 'burned':
print('You lose 25 HP from your burn.')
wait()
server_elementalist.hp -= 25
if client_elementalist.status == 'burned':
print('Your opponent loses 25 HP from burns.')
wait()
client_elementalist.hp -= 25
# send status condition info to client
status_info = {
'server_status': server_elementalist.status,
'client_status': client_elementalist.status,
'server_hp': server_elementalist.hp,
'client_hp': client_elementalist.hp
}
send(client, status_info)
# check that the status condition didn't knock one out
if knocked_out(server_elementalist.hp, client_elementalist.hp):
break
def server_msg(reader):
request = net.receive(reader)[0]
if len(request) > 0:
print(json.loads(request.decode())) # 전송 결과
from video import Video
from time import sleep
import socket, json, net
HOST = '218.38.254.30'
PORT = 5000
if __name__ == '__main__':
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((HOST, PORT))
writer = s.makefile('wb')
reader = s.makefile('rb')
with Video(device=0) as v:
for image in v:
image = Video.to_jpg(image, 80)
print('video send ', len(image))
net.send(writer, image)
result = net.receive(reader)[0]
print(json.loads(result.decode()))
import json
import net
import cv2
import numpy as np
from objdetect import ObjDetectApi, NumpyDecoder
PATH_TO_LABELS = 'data/mscoco_label_map.pbtxt'
MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17'
api = ObjDetectApi(MODEL_NAME, PATH_TO_LABELS)
HOST = '127.0.0.1'
PORT = 5000
if __name__ == '__main__':
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((HOST, PORT))
writer = s.makefile('wb')
reader = s.makefile('rb')
with Video(device=0) as v:
for image in v:
jpg = Video.to_jpg(image)
net.send(writer, jpg)
output_dict = net.receive(reader)[0].decode()
output_dict = json.loads(output_dict, cls=NumpyDecoder)
labeled_image = api.visualize(image, output_dict)
cv2.imshow('frame', labeled_image)
key = cv2.waitKey(1)
if key == 27:
break