def detect_playing(self, path_csv_folder, path_field_info, path_to_save,
path_statu_player, name):
players = []
time_table = []
time_list = []
sub_list = []
p = []
i = 0
while i < 6:
sub_list.append(p)
i = i + 1
# 필요한 리스트들을 선언하고 초기화해준다.
# 파일과 폴더 경로이름을 지정해주는 부분
path_csv_folder = path_csv_folder + name
path_field_info = path_field_info + name + '/fieldmatch.txt'
path_csv_folder = common_os_helper.check_slash(path_csv_folder)
files_csv = glob.glob(path_csv_folder + '*.csv')
path_to_save = path_to_save + name
path_to_save = common_os_helper.check_slash(path_to_save)
path_statu_player = path_statu_player + name
path_statu_player = common_os_helper.check_slash(path_statu_player)
for f in files_csv:
f = f.replace('\\', '/')
players = self.read_csv_files(players, files_csv, path_csv_folder,
path_field_info)
time_table = self.find_time_table(time_table, players)
time_table = self.check_number_playing_in_time_table(
time_table, players)
self.write_playing(players, path_statu_player)
time_list = self.detect_start_end_time(time_table, time_list)
sub_list = self.find_sub_list(players, sub_list, time_list)
self.write_log_file(sub_list, path_to_save, time_list)
def detect_games(self, path_read_csv, path_read_xl, name_of_dir):
path_read_csv = common_os_helper.check_slash(path_read_csv)
path_read_xl = common_os_helper.check_slash(path_read_xl)
name_of_dir = common_os_helper.check_slash(name_of_dir)
try:
file_read_xl = openpyxl.load_workbook(
path_read_xl + self.find_file_name(name_of_dir, 'H', 'xlsx'))
file_read_xl17 = openpyxl.load_workbook(
path_read_xl +
self.find_file_name(name_of_dir, 'H', 'xlsx', '17'))
except FileNotFoundError:
try:
file_read_xl = openpyxl.load_workbook(
path_read_xl +
self.find_file_name(name_of_dir, 'A', 'xlsx'))
file_read_xl17 = openpyxl.load_workbook(
path_read_xl +
self.find_file_name(name_of_dir, 'A', 'xlsx', '17'))
except FileNotFoundError:
return
active_sheet18 = file_read_xl.active
active_sheet17 = file_read_xl17.active
Start1_18 = active_sheet18['A7'].value
End2_18 = active_sheet18['E7'].value
Start1_17 = active_sheet17['A7'].value
End2_17 = active_sheet17['E7'].value
object_edit_data = EditData()
object_edit_data.split_file(Start1_18, End2_18, Start1_17, End2_17,
path_read_csv, name_of_dir)
def convert_och_to_csv(self, path_och, path_csv, name_of_dir):
# path_och 읽을 och파일이 저장된 path를 string으로 저장
# path_csv csv파일을 쓰고자 하는 path를 string으로 저장
# name_of_dir 읽을 csv파일과 och파일을 쓰고자 하는 dir name을 string으로 저장
path_och = common_os_helper.check_slash(path_och)
path_csv = common_os_helper.check_slash(path_csv)
name_of_dir = common_os_helper.check_slash(name_of_dir)
path_och = path_och + name_of_dir + '*.och'
path_csv = path_csv + name_of_dir
common_os_helper.create_dir(path_csv)
files_och = glob.glob(path_och)
# .csv의 경우 가장 첫번째 줄에 이후 정보들의 저장 순서를 저장함
write_order = 'year,month,day,hour,minute,second,point_second,longitude,latitude,speed'
for file_och in files_och:
# .och파일과 같은 이름을 가진 .csv파일명 생성
file_csv = path_csv + file_och[len(path_och) - 5:]
file_csv = file_csv[:len(file_csv) - 3] + 'csv'
file_to_read = open(file_och, 'r')
file_to_write = open(file_csv, 'w')
file_to_write.writelines(write_order + '\n')
# 한 줄씩 .och파일을 읽으며 .csv파일에 적절히 변환하여 저장
read_values = file_to_read.readlines()
for read_value in read_values:
try:
value_och_list = read_value.split(' ')
if len(value_och_list) < 4:
raise IndexError
value_time_list = value_och_list[0].split('.')
if len(value_time_list) < 7:
raise IndexError
# 시간과 관련된 정보는 '.'으로 이어져 있는 것을 ','로 연결
data_to_write = value_time_list[0]
for time_string in value_time_list[1:]:
data_to_write = data_to_write + ',' + time_string
# 이외의 정보는 ' '로 이어져 있는 것을 ','로 연결
for value_och_string in value_och_list[1:]:
data_to_write = data_to_write + ',' + value_och_string
file_to_write.write(data_to_write)
except IndexError:
# .och 파일에 의미없는 정보가 저장된 줄은 pass
pass
file_to_write.close()
file_to_read.close()
def look_up_player(self, path_read_xl, path_raw_data, path_write, name_of_dir):
# excel file에 뛰었다고 기록된 선수가 log.csv에 뛰었다고 기록되어 있고, 데이터도 있는지 확인, 기록
path_read_xl = common_os_helper.check_slash(path_read_xl)
path_raw_data = common_os_helper.check_slash(path_raw_data)
path_write = common_os_helper.check_slash(path_write)
name_of_dir = common_os_helper.check_slash(name_of_dir)
path_raw_data = path_raw_data+name_of_dir
path_write = path_write+name_of_dir
files_raw = glob.glob(path_raw_data+'*.csv')
player_raw = []
error_list = []
for player in files_raw:
player = player.replace('\\', '/')
player = player.replace(path_raw_data, '')
player = player.replace('.csv', '')
# player의 등번호가 시리얼 번호와 맞지않아 번환되지 않았다면 NoMatch error
if '_' in player or '(' in player:
error_list.append("NoMatch,"+str(player)+",There is no player_num")
else:
player_raw.append([int(player), 0])
# 경기가 home인지 away인지 모르기 때문에 둘 다 시도
try:
file_to_read_xl = openpyxl.load_workbook(path_read_xl+self.find_file_name(name_of_dir,'H'))
except:
file_to_read_xl = openpyxl.load_workbook(path_read_xl+self.find_file_name(name_of_dir, 'A'))
active_sheet = file_to_read_xl.active
player_info = active_sheet['F11':'F28']
player_num = []
for player in player_info:
if player[0].value:
player_num.append([int(player[0].value),0])
# excel file에 기록된 선수들의 데이터가 있는지 raw data로 확인, 기록
error_code = [["NoData,", ",Can't find data"], ["NoPlayer,", ",Can't find Player"]]
error_list = self.list_compare(player_num, player_raw, error_list, error_code, False)
# error file에 기록
write_order = "ErrorCode,ErrorValue,Detail\n"
self.write_error(path_write, 'player_difference.txt', write_order, error_list)
def convert_csv_to_och(self, path_csv, path_och, name_of_dir):
# path_csv 읽을 csv파일이 저장된 path를 string으로 저장
# path_och och파일을 쓰고자 하는 path를 string으로 저장
# name_of_dir 읽을 csv파일과 och파일을 쓰고자 하는 dir name을 string으로 저장
path_och = common_os_helper.check_slash(path_och)
path_csv = common_os_helper.check_slash(path_csv)
name_of_dir = common_os_helper.check_slash(name_of_dir)
path_och = path_och + name_of_dir
path_csv = path_csv + name_of_dir + '*.csv'
common_os_helper.create_dir(path_och)
files_csv = glob.glob(path_csv)
for file_csv in files_csv:
# .csv파일과 같은 이름을 가진 .och파일명 생성
file_och = path_och + file_csv[len(path_csv) - 5:]
file_och = file_och[:len(file_och) - 3] + 'och'
file_to_read = open(file_csv, 'r')
file_to_write = open(file_och, 'w')
# 한 줄씩 .csv파일을 읽으며 .och파일에 적절히 변환하여 저장
read_values = file_to_read.readlines()
for read_value in read_values[1:]:
value_csv_list = read_value.split(',')
# 시간과 관련된 정보는 ','로 이어져 있는 것을 '.'로 연결
data_to_write = value_csv_list[0]
for time_csv_string in value_csv_list[1:7]:
data_to_write = data_to_write + '.' + time_csv_string
# 이외의 정보는 ','로 이어져 있는 것을 ' '로 연결
for value_csv_string in value_csv_list[7:]:
data_to_write = data_to_write + ' ' + value_csv_string
file_to_write.write(data_to_write)
file_to_write.close()
file_to_read.close()
def convert_gp_to_och(self, path_gp, path_och, name_of_dir):
# path_gp 읽을 gp파일이 저장된 path를 string으로 저장
# path_och och파일을 쓰고자 하는 path를 string으로 저장
# name_of_dir 읽을 csv파일과 och파일을 쓰고자 하는 dir name을 string으로 저장
path_gp = common_os_helper.check_slash(path_gp)
path_och = common_os_helper.check_slash(path_och)
name_of_dir = common_os_helper.check_slash(name_of_dir)
path_gp = path_gp + name_of_dir + '*.gp'
path_och = path_och + name_of_dir
common_os_helper.create_dir(path_och)
files_gp = glob.glob(path_gp)
for file_gp in files_gp:
file_och = path_och + file_gp[len(path_gp) - 4:]
file_och = file_och[:len(file_och) - 2] + 'och'
# 각 파일 마다 initialize 하여 GpToOchConvert Object를 생성 후 convert 실행
GpToOchConverterObject = GpToOchConverter()
GpToOchConverterObject.convertToOchFile(file_gp, file_och)
# .och파일에 내용이 없으면 제거
if os.path.getsize(file_och) < 1000:
os.remove(file_och)
def look_up_files_stable(self, path_raw_data, path_write, name_of_dir):
# 기기로부터 안정적으로 정보를 받아오지 않았다면 error로 판단, 기록
path_raw_data = common_os_helper.check_slash(path_raw_data)
path_write = common_os_helper.check_slash(path_write)
name_of_dir = common_os_helper.check_slash(name_of_dir)
path_raw_data = path_raw_data + name_of_dir
path_write = path_write + name_of_dir
error_list = []
for player in self.Players:
file = open(path_raw_data+str(player[0])+'.csv', 'r')
read_values = file.readlines()
valid_count = 0.0
in_time = player[1].split(':')
out_time = player[2].split(':')
total_count = float(out_time[0])*60+float(out_time[1])-float(in_time[0])*60-float(in_time[1])
for i in range(1, len(read_values), 600):
time_str = read_values[i].split(',')[3:5]
time_str = time_str[0]+':'+time_str[1]
if (self.time_comparision(time_str, player[1], 1) >= 0) and (
self.time_comparision(time_str, player[2], 1) <= 0):
valid_count += 1.0
# player가 뛴 시간의 90% 이하로 정보가 있다면 불안정하다고 판단
if valid_count/total_count <= 0.8:
error_list.append("Unstable,"+str(player[0])+",Input value lost")
elif valid_count/total_count <= 0.95:
error_list.append("Unstable,"+str(player[0])+",Some input value lost")
else:
error_list.append("Stable,"+str(player[0]))
# error file에 기록
write_order = "ErrorCode,ErrorValue,Detail\n"
self.write_error(path_write, "device_stability.txt", write_order, error_list)
def read_csv_files(self, players, files_csv, path_csv_folder,
path_field_info):
# csvfolder에 있는 csvfile들을 읽어들여서 활동 여부를 판단해주는 리스트를 만든다.
path_csv_folder = common_os_helper.check_slash(path_csv_folder)
file_read = open(path_field_info, 'r', encoding="utf-8")
fields_info = file_read.readlines()
for id, file_csv in enumerate(files_csv):
field_info_list = fields_info[id + 1].split(',')
player = []
file_csv = file_csv.replace('\\', '/')
filename = file_csv.replace(path_csv_folder, '')
file_to_read = open(file_csv, 'r')
read_values = file_to_read.readlines()
data = read_values[1].split(',')
check_time_temp = data[3:5]
check_time_temp[0] = int(check_time_temp[0]) # hour
check_time_temp[1] = int(check_time_temp[1]) # minute
value_temp = data[6:9]
value_temp[0] = float(value_temp[0]) # longitude
value_temp[1] = float(value_temp[1]) # latitude
value_temp[2] = float(value_temp[2]) # speed
longi = value_temp[0]
lati = value_temp[1]
count = 1
for read_value in read_values[2:]:
data = read_value.split(
',') # csv형식의 파일을 ','단위로 parsing한 자료를 가진다.
check_time = data[3:5]
check_time[0] = int(check_time[0]) # hour
check_time[1] = int(check_time[1]) # minute
value = data[6:9]
value[0] = float(value[0]) # longitude
value[1] = float(value[1]) # latitude
value[2] = float(value[2]) # speed
if check_time == check_time_temp: # 분단위가 같으면 계속 longi,lati,speed값을 더해나가고
for i, v in enumerate(value):
value_temp[i] = value_temp[i] + v
count = count + 1
else: # 만약 분단위가 달라지게 될 경우, 1분간 모은 자료에 대한 평균치의 위치와 속도로 활동여부를 판단해준다.
longi = float(value_temp[0]) / count
lati = float(value_temp[1]) / count
speed = float(value_temp[2]) / count
playing = self.check_activation(speed)
infield = self.check_in_field(longi, lati, field_info_list)
# 만약 속도와 위치 모두가 활동성이 있다고 확인되면 True고 아니면 False이다.
if playing and infield:
check = True
else:
check = False
player.append([
filename, check_time_temp[0], check_time_temp[1], check
])
# 매 분마다 활동중인지 여부를 검사한 후 이를 배열로저장
check_time_temp = check_time
value_temp = value
count = 1
players.append(
player) # 이렇게 읽어드린csv파일들을 player라는 형태의 list로 players에 저장
return players
def rename_csv_file(self, path_target_folder, path_read_info_folder,
path_read_xl, name_of_dir):
# path_target_folder 이름을 변경하고자하는 target이 있는 folder path를 string으로 저장
# path_read_info_folder serial_num,back_num으로 이루어진 .csv file이 있는 path를 string으로 저장
# name_of_dir 파일을 읽고 쓸 dir name을 string으로 저장
path_target_folder = common_os_helper.check_slash(path_target_folder)
path_read_info_folder = common_os_helper.check_slash(
path_read_info_folder)
name_of_dir = common_os_helper.check_slash(name_of_dir)
path_target_folder = path_target_folder + name_of_dir
common_os_helper.create_dir(path_target_folder + 'noneed/')
# 현재 target인 팀이 home인지 away인지 모르기 때문에 두가지 경우 모두 시도
try:
file_read_info = open(
path_read_info_folder + self.find_file_name(name_of_dir, 'H'),
'r')
except FileNotFoundError:
file_read_info = open(
path_read_info_folder + self.find_file_name(name_of_dir, 'A'),
'r')
info_values = file_read_info.readlines()
info_values.sort()
index = -1
serial_num = -1
last = -1
count = 0
files_target = glob.glob(path_target_folder + '*.csv')
for file_target in files_target:
try:
file_target = file_target.replace('\\', '/')
name_list = file_target.split('/')
target_num = int(name_list[len(name_list) - 1].split('_')[0])
except:
# filename이 변환되어 있는 경우 continue
continue
try:
# target_num과 serial_num이 모두 정렬되어 있기 때문에 단순비교가 가능
while target_num > serial_num:
index = index + 1
serial_num = int(info_values[index].split(',')[0])
back_num = info_values[index].split(',')[1]
back_num = back_num[:len(back_num) - 1]
# 정렬된 상황에서 target_num < serial_num은 같은 번호를 가진 serial_num이 없다는 뜻이므로 noneed로 이동
if target_num < serial_num:
shutil.move(
file_target, path_target_folder + 'noneed/' +
name_list[len(name_list) - 1])
continue
except IndexError:
shutil.move(
file_target, path_target_folder + 'noneed/' +
name_list[len(name_list) - 1])
continue
# 같은 serial number를 가진 파일이 여러개일 경우 (count)의 형식으로 이름에 추가
if last == target_num:
count = count + 1
re_num = back_num + '(' + str(count) + ')'
else:
count = 0
re_num = back_num
last = target_num
name_list[len(name_list) - 1] = re_num + '.csv'
new_name = path_target_folder + name_list[len(name_list) - 1]
os.rename(file_target, new_name)
def cut_error(self, path_read_csv_folder, path_read_error_folder, path_write_folder, name_of_dir, ck_field=True, ck_dist=True, ck_speed=True):
# path_read_csv_folder 읽을 .csv파일이 저장된 폴더 경로를 string으로 저장
# path_read_error_folder 읽을 error.csv파일이 저장된 폴더 경로를 string으로 저장
# path_write_folder error범위를 제외한 부분을 .csv로 저장할 폴더 경로를 string으로 저장
# name_of_dir 파일을 읽고 쓸 dir name을 string으로 저장
# 경로의 예외처리와 최종 경로 지정
path_read_csv_folder = common_os_helper.check_slash(path_read_csv_folder)
path_read_error_folder = common_os_helper.check_slash(path_read_error_folder)
path_write_folder = common_os_helper.check_slash(path_write_folder)
name_of_dir = common_os_helper.check_slash(name_of_dir)
path_read_csv_folder = path_read_csv_folder + name_of_dir + '*.csv'
path_read_error_folder = path_read_error_folder + name_of_dir + 'error.csv'
path_write_folder = path_write_folder + name_of_dir
# 파일을 쓸 위치에 폴더를 만들고 error.csv 열기
common_os_helper.create_dir(path_write_folder)
file_to_error_read = open(path_read_error_folder, 'r')
read_error_values = file_to_error_read.readlines()
index_error = 1
read_error_value = read_error_values[index_error].split(',')
files_read_csv = glob.glob(path_read_csv_folder)
for file_read_csv in files_read_csv:
file_name = file_read_csv[len(path_read_csv_folder) - 5:]
file_write_csv = path_write_folder + file_name
file_to_csv_read = open(file_read_csv, 'r')
file_to_write = open(file_write_csv, 'w')
read_csv_values = file_to_csv_read.readlines()
file_to_write.write(read_csv_values[0])
index_csv = 1
while index_csv < len(read_csv_values):
if read_error_value[1] == file_name and index_error < len(read_error_values):
csv_value_list = read_csv_values[index_csv].split(',')
time_str = csv_value_list[0]
for time_value in csv_value_list[1:6]:
time_str = time_str + '.' + time_value
term_int = -1
if read_error_value[4] == 'OverSpeed\n' and ck_speed:
term_int = 1
if read_error_value[4] == 'OverDist\n' and ck_dist:
term_int = 1
if read_error_value[4] == 'OutOfField\n' and ck_field:
term_int = 2
comp_result = self.time_comparision(time_str, read_error_value[2], read_error_value[3], term_int)
# 현재 읽은 줄의 시간이 error의 범위보다 큰쪽으로 벗어났다면 다음 error line에 대해 현재 읽은 줄을 확인
if comp_result == 1:
try:
index_csv = index_csv - 1
index_error = index_error + 1
read_error_value = read_error_values[index_error].split(',')
except IndexError:
# 마지막 error의 범위를 벗어났을 경우 .csv 파일의 나머지를 모두 출력
file_to_write.write(read_csv_values[index_csv])
if comp_result == -1:
file_to_write.write(read_csv_values[index_csv])
# error의 정보가 현재 읽는 중인 file_name보다 작다면 error의 index를 증가시킨다.
elif read_error_value[1] < file_name and index_error < len(read_error_values):
try:
index_csv = index_csv - 1
index_error = index_error + 1
read_error_value = read_error_values[index_error].split(',')
except IndexError:
# 마지막 error의 범위를 벗어났을 경우 .csv 파일의 나머지를 모두 출력
file_to_write.write(read_csv_values[index_csv])
else:
file_to_write.write(read_csv_values[index_csv])
index_csv = index_csv + 1
file_to_csv_read.close()
file_to_write.close()
file_to_error_read.close()
def summarize_csv(self, path_csv_folder, path_output_folder):
#디렉토리가 없으면은 생성해준다.
try:
if not os.path.exists(path_output_folder):
os.makedirs(path_output_folder)
except OSError:
print('Error: Creating directory.' + path_output_folder)
path_csv_folder = common_os_helper.check_slash(path_csv_folder)
path_output_folder = common_os_helper.check_slash(path_output_folder)
files_csv = glob.glob(path_csv_folder + '*.csv')
# csv파일의 첫줄에 들어갈 정보들을 순서대로 입력해주는 write_order
write_order = 'year,month,day,hour,minute,second,longitude,latitude,speed,distance'
for file_csv in files_csv:
file_csv.replace('\\', '')
file_summarized = path_output_folder + file_csv[len(path_csv_folder
):]
file_summarized = file_summarized[:len(file_summarized) -
3] + 'csv'
file_to_read = open(file_csv, 'r')
file_to_write = open(file_summarized, 'w')
file_to_write.writelines(write_order + '\n')
read_values = file_to_read.readlines()
data = read_values[1].split(',')
#checktime은 초까지의 시간이 동일한 경우를 check하기 위해 0.1초단위는 버리고 초단위의 시간만 기록한다.
check_time_temp = data[0:6]
value_temp = data[7:10]
value_temp.append(0)
value_temp[0] = float(value_temp[0]) #longitude
value_temp[1] = float(value_temp[1]) #latitude
value_temp[2] = float(value_temp[2])
count = 1
# distance를 계산해주기 위한 좌표의 초기값 설정
last_longi = value_temp[0]
last_lati = value_temp[1]
# csv파일을 읽어들이는 부분이다.
for read_value in read_values[2:]:
data = read_value.split(',')
check_time = data[0:6]
value = data[7:10]
value.append(0)
value[0] = float(value[0]) #longitude
value[1] = float(value[1]) #latitude
value[2] = float(value[2])
if check_time == check_time_temp: #만약 초단위까지의 시간이 같다면 그 값을 저장하고 계속해서 더해나간다.
for i, v in enumerate(value):
value_temp[i] = value_temp[i] + v
count = count + 1
#이 부분은 마지막 정보, 즉 최하단의 줄을 읽어드린 후의 값을 안적고 fileclose하는 것을 방지하기 위해 distance값을 보유하게 하는 것
value_temp[3] = self.measure_position(
last_lati, last_longi, value_temp[1] / count,
value_temp[0] / count)
else: #초단위까지의시간이 같지 않은경우, 즉 초가 바뀌었을때 연산 후 파일에다가 기록해준다.
value_temp[0] = float(value_temp[0]) / count # longitude
value_temp[1] = float(value_temp[1]) / count # latitude
value_temp[2] = float(value_temp[2]) / count
value_temp[3] = self.measure_position(
last_lati, last_longi, value_temp[1], value_temp[0])
last_longi = value_temp[0]
last_lati = value_temp[1]
# last,즉 이전 위도 경도 값을 남김으로서 다음에 들어온 값을 가지고 연산을 실행한다.
#현재의 시간정보를 기록
for time_idx, time_string in enumerate(
check_time_temp[:6]):
if time_idx == 0:
file_to_write.write(time_string)
else:
file_to_write.write(',' + time_string)
# write함수를 쓰기위해 value값들을 string으로 다시 형변환해준다.
value_temp[0] = str(value_temp[0])
value_temp[1] = str(value_temp[1])
value_temp[2] = str(value_temp[2])
value_temp[3] = str(value_temp[3])
# 이 후 value값들을 기록하고 temp들을 초기화 해준다.
for value_string in value_temp:
file_to_write.write(',' + value_string)
file_to_write.write('\n')
check_time_temp = check_time
value_temp = value
count = 1
# 이부분은 반복문 안과 같지만 마지막 줄을 적어주기 위해 한줄을 추가하여 마지막줄의 연산까지 하는 것이다.
for time_idx, time_string in enumerate(check_time_temp[:6]):
if time_idx == 0:
file_to_write.write(time_string)
else:
file_to_write.write(',' + time_string)
value_temp[0] = value_temp[0] / count
value_temp[1] = value_temp[1] / count
value_temp[2] = value_temp[2] / count
value_temp[0] = str(value_temp[0])
value_temp[1] = str(value_temp[1])
value_temp[2] = str(value_temp[2])
value_temp[3] = str(value_temp[3])
for value_string in value_temp:
file_to_write.write(',' + value_string)
file_to_write.write('\n')
file_to_read.close()
def find_noise_in_data(self, path_read_folder, path_read_field_folder, path_write_folder, name_of_dir):
# path_read_folder 읽을 파일이 저장된 path를 string으로 저장
# path_write_folder 파일을 쓰고자 하는 path를 string으로 저장
# nmae_of_dir 읽을 파일과 쓰고자 하는 파일의 dir name을 string으로 저장
path_read_folder = common_os_helper.check_slash(path_read_folder)
path_read_field_folder = common_os_helper.check_slash(path_read_field_folder)
path_write_folder = common_os_helper.check_slash(path_write_folder)
name_of_dir = common_os_helper.check_slash(name_of_dir)
path_read_folder = path_read_folder+name_of_dir
path_read_field_folder = path_read_field_folder+name_of_dir
path_write_folder = path_write_folder+name_of_dir
file_to_read_field = open(path_read_field_folder+'fieldmatch.txt', 'r', encoding="utf-8")
read_field = file_to_read_field.readline()
common_os_helper.create_dir(path_write_folder)
file_to_write = open(path_write_folder+'error.csv', 'w')
write_order = 'path,filename,start_time,end_time,error_code\n'
file_to_write.write(write_order)
read_values_list = []
read_files_name = []
min_time = math.inf
max_time = 0
files_read = glob.glob(path_read_folder+'*.csv')
for file_read in files_read:
file_read = file_read.replace('\\','/')
file_to_read = open(file_read, 'r')
read_values = file_to_read.readlines()
read_values_list.append(read_values[1:])
error_list = []
last_speed = 0
id_speed = -1
last_dist = 0
id_dist = -1
last_field = 0
id_field = -1
ck_field = 1
try:
read_field = file_to_read_field.readline()
read_field_list = read_field.split(',')
lonA, latA, lonB, latB, lonC, latC, lonD, latD = read_field_list[4:]
pointA = (float(lonA[1:]), float(latA[1:]))
pointB = (float(lonB[1:]), float(latB[1:]))
pointC = (float(lonC[1:]), float(latC[1:]))
pointD = (float(lonD[1:]), float(latD[1:len(latD)-2]))
find_object = Find_field_csv()
pointA, pointB, pointC, pointD = find_object.expand_field(pointA, pointB, pointC, pointD, 1.2)
except:
ck_field = 0
value_csv_list = read_values[1].split(',')
time_str = self.str_to_time(value_csv_list[:6])
if self.time_to_second(time_str) < min_time:
min_time = self.time_to_second(time_str)
for value_list in read_values[1:]:
value_csv_list = value_list.split(',')
time_str = self.str_to_time(value_csv_list[:6])
if self.time_to_second(time_str) < min_time:
min_time = self.time_to_second(time_str)
speed_float = float(value_csv_list[8])
# speed가 35보다 크게 변경된 순간에는 순간에는 list 형태로 start_time append
# speed가 35보다 작게 변경된 순간에는 start_time을 append한 위치에 end_time과 error_code 작성
if speed_float >= 35.0 and value_list != read_values[len(read_values)-1]:
if last_speed == 0:
last_speed = 1
error_list.append(time_str)
id_speed = len(error_list)-1
else:
if last_speed == 1:
last_speed = 0
error_list[id_speed] = error_list[id_speed] + ',' + time_str + ',OverSpeed'
dist_float = float(value_csv_list[9])
# 1초에 이동한 dist가 15m보다 크게 변경된 순간에는 list 형태로 start_time append
# 1초에 이동한 dist가 15m보다 작게 변경된 순간에는 start_time을 append한 위치에 end_time과 error_code 작성
if dist_float >= 15 and value_list != read_values[len(read_values)-1]:
if last_dist == 0:
last_dist = 1
error_list.append(time_str)
id_dist = len(error_list)-1
else:
if last_dist == 1:
last_dist = 0
error_list[id_dist] = error_list[id_dist] + ',' + time_str + ',OverDist'
# field의 1.2배 크기 밖으로 나간 순간에는 list 형태로 start_time append
# field의 1.2배 크기 안으로 들어간 순간에는 start_time을 append한 위치에 end_time과 error_code 작성
longitude_float = float(value_csv_list[6])
latitude_float = float(value_csv_list[7])
pointP = (longitude_float, latitude_float)
if (ck_field and find_object.checkPointInRectangle(pointP, pointA, pointB, pointC, pointD)) \
and value_list != read_values[len(read_values) - 1]:
if last_field == 0:
last_field = 1
error_list.append(time_str)
id_field = len(error_list)-1
else:
if last_field == 1:
last_field = 0
error_list[id_field] = error_list[id_field] + ',' + time_str + ',OutOfField'
if self.time_to_second(time_str) > max_time:
max_time = self.time_to_second(time_str)
file_list = file_read.split('/')
file_name = file_list[len(file_list)-1]
read_files_name.append(file_name[:len(file_name)-4])
# file에서 읽어온 정보를 이용해 speed_error를 찾고 error.csv에 쓰기
for error_str in error_list:
file_to_write.write(path_read_folder+','+file_name+','+error_str+'\n')
file_to_read.close()
file_to_read_field.close()
file_to_write.close()
file_to_write_info = open(path_write_folder+'notice_device_info.txt', 'w', encoding="utf-8")
write_order_info = 'player,state\n'
file_to_write_info.write(write_order_info)
state_list = self.check_gps_error(read_values_list, max_time, min_time)
for id in range(len(read_files_name)):
if state_list[id] == 0:
state = ', Normal\n'
elif state_list[id] <= 3:
state = ', Doubt\n'
else:
state = ', Abnormal\n'
file_to_write_info.write(read_files_name[id]+state)
file_to_write_info.close()
def find_diff_log(self, path_read_xl_folder, path_read_log_folder, path_write_folder, name_of_dir):
# excel file과 log.csv의 다른 부분을 error로 판단하여 file에 기록
path_read_xl_folder = common_os_helper.check_slash(path_read_xl_folder)
path_read_log_folder = common_os_helper.check_slash(path_read_log_folder)
path_write_folder = common_os_helper.check_slash(path_write_folder)
name_of_dir = common_os_helper.check_slash(name_of_dir)
path_write_folder = path_write_folder+name_of_dir
file_to_read_log = open(path_read_log_folder+name_of_dir+'log.csv')
log_info_lists = file_to_read_log.readlines()
# 경기가 home인지, away인지 모르기 때문에 둘 다 시행
try:
file_to_read_xl = openpyxl.load_workbook(path_read_xl_folder+self.find_file_name(name_of_dir,'H'))
except:
file_to_read_xl = openpyxl.load_workbook(path_read_xl_folder+self.find_file_name(name_of_dir, 'A'))
active_sheet = file_to_read_xl.active
player_sub = active_sheet['A11':'C17']
start_time1 = active_sheet['A7'].value
end_time1 = active_sheet['B7'].value
start_time2 = active_sheet['D7'].value
end_time2 = active_sheet['E7'].value
start1 = log_info_lists[1].split(',')[1]
self.START1 = start1
error = self.time_comparision(start1, start_time1, 3)
error_list = []
if error != 0:
error_list.append('TimeDiff,START1,incorrect')
sub_in_list = []
sub_out_list = []
for row in player_sub:
if row[0].value != row[1].value:
time_list = row[0].value.split('+')
time_int = 0
for time_val in time_list:
time_int += int(time_val)
if int(time_list[0]) <= 45:
time_str = self.time_calculate(start_time1, time_int, False)
else:
time_str = self.time_calculate(start_time2, time_int-45, False)
sub_in_list.append([int(row[1].value), time_str])
sub_out_list.append([int(row[2].value), time_str])
# log.csv에서 읽어온 내용과 excel file의 내용 비교
sub_log_in_list = []
sub_log_out_list = []
for log_info in log_info_lists[2:]:
log_list = log_info.split(',')
if log_list[0] == 'END1':
self.END1 = log_list[1]
if self.time_comparision(log_list[1], end_time1, 3) != 0:
error_list.append('TimeDiff,END1,incorrect')
if log_list[0] == 'START2':
self.START2 = log_list[1]
if self.time_comparision(log_list[1], start_time2, 3) != 0:
error_list.append('TimeDiff,START2,incorrect')
if log_list[0] == 'END2':
self.END2 = log_list[1]
if self.time_comparision(log_list[1], end_time2, 3) != 0:
error_list.append('TimeDiff,END2,incorrect')
if log_list[0] == 'SUB':
try:
sub_log_in_list.append([int(log_list[3]), log_list[1]])
sub_log_out_list.append([int(log_list[2]), log_list[1]])
except:
try:
sub_log_out_list.append([int(log_list[2]), log_list[1]])
except:
continue
self.set_players_runtime(sub_log_in_list, sub_log_out_list)
# sub된 선수들에 대해 log.csv와 excel file이 다른 부분이 있는지 확인, 기록
error_code = [["Sub_InPlayerDiff,", ",Can't find at log"], ["Sub_InPlayerDiff,", "Can't find at info"],
["Sub_InTimeDiff,", ",incorrect"]]
error_list = self.list_compare(sub_in_list, sub_log_in_list, error_list, error_code)
error_code = [["Sub_OutPlayerDiff,", ",Can't find at log"], ["Sub_OutPlayerDiff,", "Can't find at info"],
["Sub_OutTimeDiff,", ",incorrect"]]
error_list = self.list_compare(sub_out_list, sub_log_out_list, error_list, error_code)
# error file에 기록
write_order = 'ErrorCode,ErrorValue,Detail\n'
self.write_error(path_write_folder, 'data_difference.txt', write_order, error_list)