def split_file(Start1_18 ,End2_18, Start1_17, End2_17,path_read_csv, name_of_dir):
name_of_dir17 = name_of_dir.replace('18', '17')
name_of_dir18 = 'temp'
common_os_helper.create_dir(path_read_csv+name_of_dir17)
common_os_helper.create_dir(path_read_csv+name_of_dir18)
Start1_18.replace(':', '.')
Start1_18 = Start1_18+'.0'
End2_18.replace(':', '.')
End2_18 = End2_18+'.0'
Start1_17.replace(':', '.')
Start1_17 = Start1_17+'.0'
End2_17.replace(':', '.')
End2_17 = End2_17+'.0'
files_read_csv = glob.glob(path_read_csv+name_of_dir+'*.csv')
for file_read_csv in files_read_csv:
file_to_read = open(file_read_csv, 'r')
read_values = file_to_read.readlines()
file_to_read.close()
file_to_write17 = open(file_read_csv.replace(name_of_dir, name_of_dir17), 'w')
file_to_write18 = open(file_read_csv, 'w')
for read_value in read_values:
time_str = read_value[3]+'.'+read_value[4]+'.'+read_value[5]
if self.time_comparision(time_str, Start1_18, End2_18, 300) == 0:
file_to_write18.write(read_value)
if self.time_comparision(time_str, Start1_17, End2_17, 300) == 0:
file_to_write17.write(read_value)
file_to_write17.close()
file_to_write18.close()
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 write_playing(self, players, path):
# 디렉토리가 없으면은 생성해준다.
common_os_helper.create_dir(path)
for p in players:
i = 0
filename = p[i][0][:len(p[i][0]) - 4] + '.txt'
pwrite = open(path + filename, 'w')
while i < len(p):
pwrite.write(
str(p[i][1]) + ',' + str(p[i][2]) + ',' + str(p[i][3]) +
'\n')
i = i + 1
def write_log_file(self, sub_list, path_to_save, time_list):
write_order = 'event,time,player_out,player_in'
start1_hour, start1_minute, end1_hour, end1_minute = time_list[
0], time_list[1], time_list[2], time_list[3]
start2_hour, start2_minute, end2_hour, end2_minute = time_list[
4], time_list[5], time_list[6], time_list[7]
pout_fh, pin_fh, pout_h = sub_list[0], sub_list[1], sub_list[2]
pin_h, pout_sh, pin_sh = sub_list[3], sub_list[4], sub_list[5]
# 디렉토리가 없으면은 생성해준다.
common_os_helper.create_dir(path_to_save)
file_to_write = open(path_to_save + 'log.csv', 'w')
file_to_write.write(write_order + '\n')
file_to_write.write('START1,' + str(start1_hour).zfill(2) + ':' +
str(start1_minute).zfill(2) + ':00' + '\n')
i = 0
while i < len(pout_fh):
file_to_write.write('SUB,' + str(pin_fh[i][1]).zfill(2) + ':' +
str(pin_fh[i][2]).zfill(2) + ':00,' +
pout_fh[i][0] + ',' + pin_fh[i][0] + '\n')
i = i + 1
file_to_write.write('END1,' + str(end1_hour).zfill(2) + ':' +
str(end1_minute).zfill(2) + ':00' + '\n')
i = 0
while i < len(pout_h):
file_to_write.write('SUB,' + str(pin_h[i][1]).zfill(2) + ':' +
str(pin_h[i][2]).zfill(2) + ':00,' +
pout_h[i][0] + ',' + pin_h[i][0] + '\n')
i = i + 1
file_to_write.write('START2,' + str(start2_hour).zfill(2) + ':' +
str(start2_minute).zfill(2) + ':00' + '\n')
i = 0
while i < len(pout_sh):
file_to_write.write('SUB,' + str(pin_sh[i][1]).zfill(2) + ':' +
str(pin_sh[i][2]).zfill(2) + ':00,' +
pout_sh[i][0] + ',' + pin_sh[i][0] + '\n')
i = i + 1
file_to_write.write('END2,' + str(end2_hour).zfill(2) + ':' +
str(end2_minute).zfill(2) + ':00' + '\n')
file_to_write.close()
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 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 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()