def output_result(ub_data, ub_data_value, characters_find):
# 結果を出力
debuff_value = ac.make_ub_value_list(ub_data_value, characters_find)
# 結果表示
print("---------- タイムライン ----------\n")
for index, rec in enumerate(ub_data):
print(rec)
if debuff_value is not []:
print("↓" + debuff_value[index])
return
def analyze_movie(movie_path, file_type, self):
global RESULT_FILE_DIR
# 動画解析し結果をリストで返す
start_time = tm.time()
result_name = datetime.datetime.fromtimestamp(start_time)
result_name = result_name.strftime('%Y-%m-%d_%H-%M-%S')
result_file_dir = result_dir + result_name + "/"
if not os.path.exists(result_file_dir):
os.mkdir(result_file_dir)
RESULT_FILE_DIR = result_file_dir
# 動画の確認
video_type = movie_check(movie_path)[1]
video = cv2.VideoCapture(movie_path)
frame_count = int(video.get(7)) # フレーム数を取得
frame_rate = int(video.get(5)) # フレームレート(1フレームの時間単位はミリ秒)の取得
model_init(video_type)
roi_init(video_type)
n = 0.34 # n秒ごと*
ub_interval = 0
time_min = "1"
time_sec10 = "3"
time_sec1 = "0"
menu_check = False
min_roi = MIN_ROI
tensec_roi = TEN_SEC_ROI
onesec_roi = ONE_SEC_ROI
ub_roi = UB_ROI
score_roi = SCORE_ROI
damage_data_roi = DAMAGE_DATA_ROI
detail_report_roi = DETAIL_REPORT_ROI
crown_data_roi = CROWN_DATA_ROI
ub_data = []
ub_data_value = []
time_data = []
characters_find = []
tmp_damage = []
total_damage = False
cap_interval = int(frame_rate * n)
skip_frame = 5 * cap_interval
for i in range(frame_count): # 動画の秒数を取得し、回す
ret = video.grab()
if ret is False:
break
# VIEWからのスレッド一時停止
if ANALYZE_STATUS is ANALYZE_PENDING:
while True:
if ANALYZE_STATUS is ANALYZE_PENDING:
tm.sleep(0.2)
else:
break
# VIEWからのスレッド停止
if ANALYZE_STATUS is ANALYZE_STOP:
break
# VIEWからのスレッド途中完了
if ANALYZE_STATUS is ANALYZE_END:
break
if i % cap_interval is 0:
if ((i - ub_interval) > skip_frame) or (ub_interval == 0):
ret, original_frame = video.read()
if ret is False:
break
work_frame = edit_frame(original_frame)
if menu_check is False:
menu_check, menu_loc = analyze_item_frame(work_frame, MENU_DATA, MENU_ROI)
if menu_check is True:
loc_diff = np.array(MENU_LOC) - np.array(menu_loc)
roi_diff = (loc_diff[0], loc_diff[1], loc_diff[0], loc_diff[1])
min_roi = np.array(MIN_ROI) - np.array(roi_diff)
tensec_roi = np.array(TEN_SEC_ROI) - np.array(roi_diff)
onesec_roi = np.array(ONE_SEC_ROI) - np.array(roi_diff)
ub_roi = np.array(UB_ROI) - np.array(roi_diff)
score_roi = np.array(SCORE_ROI) - np.array(roi_diff)
damage_data_roi = np.array(DAMAGE_DATA_ROI) - np.array(roi_diff)
detail_report_roi = np.array(DETAIL_REPORT_ROI) - np.array(roi_diff)
crown_data_roi = np.array(CROWN_DATA_ROI) - np.array(roi_diff)
analyze_anna_icon_frame(work_frame, CHARACTER_ICON_ROI, characters_find)
# 検出状況を初期化
tmp_damage = []
total_damage = False
elif total_damage is not False:
# ダメージレポート表示中
# 王冠の有無を確認
ret = analyze_item_frame(work_frame, CROWN_DATA, crown_data_roi)[0]
if ret is True:
# ダメージレポートの有無を確認
ret = analyze_item_frame(work_frame, DETAIL_REPORT_DATA, detail_report_roi)[0]
if ret is True:
# ダメージレポートが開かれている場合
# 検出時の画像をviewに渡す
send_capture_frame(original_frame, self)
save_capture_frame(original_frame, result_file_dir, "damage_report")
# 検出状況を初期化
tmp_damage = []
total_damage = False
else:
# UB 検出処理
# 時間を判定
time_min = analyze_timer_frame(work_frame, min_roi, 2, time_min)
time_sec10 = analyze_timer_frame(work_frame, tensec_roi, 6, time_sec10)
time_sec1 = analyze_timer_frame(work_frame, onesec_roi, 10, time_sec1)
# UB文字を判定
ub_result = analyze_ub_frame(work_frame, ub_roi, time_min, time_sec10, time_sec1,
ub_data, ub_data_value, characters_find, self)
if ub_result is FOUND:
ub_interval = i
# 検出時の画像をviewに渡す
send_capture_frame(original_frame, self)
save_txt(ub_data[-1], result_file_dir)
# 総ダメージ検出処理
# スコア表示の有無を確認
ret = analyze_item_frame(work_frame, SCORE_DATA, score_roi)[0]
if ret is True:
# 総ダメージ解析
ret = analyze_damage_frame(original_frame, damage_data_roi, tmp_damage)
if ret is True:
# 総ダメージ表示が存在の場合
total_damage = "総ダメージ\n" + ''.join(tmp_damage)
input_txt_damage = "\n\n" + total_damage + "\n"
save_txt(input_txt_damage, result_file_dir)
view.set_ub_text(self, input_txt_damage)
# 検出時の画像をviewに渡す
send_capture_frame(original_frame, self)
save_capture_frame(original_frame, result_file_dir, "total_damage")
# 検出状況を初期化
menu_check = False
video.release()
# TLに対する後処理
debuff_value = ac.make_ub_value_list(ub_data_value, characters_find)
time_result = tm.time() - start_time
time_data.append("動画時間 : {:.3f}".format(frame_count / frame_rate) + " sec")
time_data.append("処理時間 : {:.3f}".format(time_result) + " sec")
# YOUTUBEから取得した動画の場合削除
if file_type is YOUTUBE:
clear_path(movie_path)
# VIEWへの終了通知
if ANALYZE_STATUS is not ANALYZE_STOP:
view.set_result_frame(self)
return ub_data, time_data, total_damage, debuff_value, NO_ERROR
def analyze_movie(movie_path):
# 動画解析し結果をリストで返す
start_time = tm.time()
video = cv2.VideoCapture(movie_path)
frame_count = int(video.get(7)) # フレーム数を取得
frame_rate = int(video.get(5)) # フレームレート(1フレームの時間単位はミリ秒)の取得
frame_width = int(video.get(3)) # フレームの幅
frame_height = int(video.get(4)) # フレームの高さ
try:
video_type = FRAME_RESOLUTION.index((frame_width, frame_height))
except ValueError:
video.release()
return None, None, None, None, ERROR_NOT_SUPPORTED
CHARACTERS_DATA, SEC_DATA, MENU_DATA, SCORE_DATA, DAMAGE_DATA, ICON_DATA = model_init(
video_type)
UB_ROI, MIN_ROI, TEN_SEC_ROI, ONE_SEC_ROI, MENU_ROI, SCORE_ROI, DAMAGE_DATA_ROI, CHARACTER_ICON_ROI, MENU_LOC, FRAME_THRESH = roi_init(
video_type)
n = 0.34 # n秒ごと*
ub_interval = 0
time_min = "1"
time_sec10 = "3"
time_sec1 = "0"
menu_check = False
min_roi = MIN_ROI
tensec_roi = TEN_SEC_ROI
onesec_roi = ONE_SEC_ROI
ub_roi = UB_ROI
score_roi = SCORE_ROI
damage_data_roi = DAMAGE_DATA_ROI
ub_data = []
ub_data_value = []
time_data = []
characters_find = []
tmp_damage = []
total_damage = False
cap_interval = int(frame_rate * n)
skip_frame = 5 * cap_interval
if (frame_count / frame_rate) < 600: # 10分未満の動画しか見ない
for i in range(frame_count): # 動画の秒数を取得し、回す
ret = video.grab()
if ret is False:
break
if i % cap_interval == 0:
if ((i - ub_interval) > skip_frame) or (ub_interval == 0):
ret, original_frame = video.read()
if ret is False:
break
work_frame = edit_frame(original_frame)
if menu_check is False:
menu_check, menu_loc = analyze_menu_frame(
work_frame, MENU_DATA, MENU_ROI)
if menu_check is True:
loc_diff = np.array(MENU_LOC) - np.array(menu_loc)
roi_diff = (loc_diff[0], loc_diff[1], loc_diff[0],
loc_diff[1])
min_roi = np.array(MIN_ROI) - np.array(roi_diff)
tensec_roi = np.array(TEN_SEC_ROI) - np.array(
roi_diff)
onesec_roi = np.array(ONE_SEC_ROI) - np.array(
roi_diff)
ub_roi = np.array(UB_ROI) - np.array(roi_diff)
score_roi = np.array(SCORE_ROI) - np.array(
roi_diff)
damage_data_roi = np.array(
DAMAGE_DATA_ROI) - np.array(roi_diff)
analyze_anna_icon_frame(work_frame,
CHARACTER_ICON_ROI,
characters_find)
else:
if time_min == "1":
time_min = analyze_timer_frame(
work_frame, min_roi, 2, time_min)
time_sec10 = analyze_timer_frame(
work_frame, tensec_roi, 6, time_sec10)
time_sec1 = analyze_timer_frame(
work_frame, onesec_roi, 10, time_sec1)
ub_result = analyze_ub_frame(work_frame, ub_roi,
time_min, time_sec10,
time_sec1, ub_data,
ub_data_value,
characters_find)
if ub_result is FOUND:
ub_interval = i
# スコア表示の有無を確認
ret = analyze_score_frame(work_frame, SCORE_DATA,
score_roi)
if ret is True:
# 総ダメージ解析
ret = analyze_damage_frame(original_frame,
damage_data_roi,
tmp_damage)
if ret is True:
total_damage = "総ダメージ " + ''.join(tmp_damage)
break
video.release()
# TLに対する後処理
debuff_value = ac.make_ub_value_list(ub_data_value, characters_find)
time_result = tm.time() - start_time
time_data.append("動画時間 : {:.3f}".format(frame_count / frame_rate) +
" sec")
time_data.append("処理時間 : {:.3f}".format(time_result) + " sec")
return ub_data, time_data, total_damage, debuff_value, NO_ERROR
def analyze_movie(movie_path):
"""analyze movie main
check movie frames and find ub frame
check frame: 0.34 sec (20 frames)
Args
movie_path (string): movie save path
Returns
ub_data (list): found ub data
ub_data_enemy (list): found ub data with enemy ub
time_data (list): spend time while analyze
total_damage (string): total damage
debuff_value (list): ub timing debuff values
status (int): analyze status 200 (HD analyze) or 301 (SD analyze)
"""
start_time = tm.time()
video = cv2.VideoCapture(movie_path)
frame_count = int(video.get(7)) # get total frame
frame_rate = int(video.get(5)) # get frame rate
frame_width = int(video.get(3)) # get frame width
frame_height = int(video.get(4)) # get frame height
try:
video_type = FRAME_RESOLUTION.index((frame_width, frame_height))
except ValueError:
video.release()
cm.clear_path(movie_path)
return None, None, None, None, None, state.ERR_BAD_RESOLUTION
model_init(video_type)
roi_init(video_type)
n = 0.34
time_min = "1"
time_sec10 = "3"
time_sec1 = "0"
menu_check = False
min_roi = MIN_ROI
tensec_roi = TEN_SEC_ROI
onesec_roi = ONE_SEC_ROI
ub_roi = UB_ROI
score_roi = SCORE_ROI
damage_data_roi = DAMAGE_DATA_ROI
speed_roi = SPEED_ICON_ROI
ub_data = []
ub_data_enemy = []
ub_data_value = []
time_data = []
characters_find = []
tmp_damage = []
total_damage = False
cap_interval = int(frame_rate * n)
past_time = 90
time_count = 0
find_id = -1
find_count = 0
if (frame_count / frame_rate) < 600: # only check less than 10 min movie
for i in range(frame_count): # cycle check movie per frame
ret = video.grab()
if ret is False:
break
if i % cap_interval is 0:
ret, original_frame = video.read()
if ret is False:
break
if video_type is RESOLUTION_16_9_SD:
original_frame = expand_frame(original_frame)
work_frame = edit_frame(original_frame)
if menu_check is False:
menu_check, menu_loc = analyze_menu_frame(work_frame, MENU_DATA, MENU_ROI)
if menu_check is True:
loc_diff = np.array(MENU_LOC) - np.array(menu_loc)
roi_diff = (loc_diff[0], loc_diff[1], loc_diff[0], loc_diff[1])
min_roi = np.array(MIN_ROI) - np.array(roi_diff)
tensec_roi = np.array(TEN_SEC_ROI) - np.array(roi_diff)
onesec_roi = np.array(ONE_SEC_ROI) - np.array(roi_diff)
ub_roi = np.array(UB_ROI) - np.array(roi_diff)
score_roi = np.array(SCORE_ROI) - np.array(roi_diff)
damage_data_roi = np.array(DAMAGE_DATA_ROI) - np.array(roi_diff)
speed_roi = np.array(SPEED_ICON_ROI) - np.array(roi_diff)
analyze_anna_icon_frame(work_frame, CHARACTER_ICON_ROI, characters_find)
else:
if time_min is "1":
time_min = analyze_timer_frame(work_frame, min_roi, 2, time_min)
time_sec10 = analyze_timer_frame(work_frame, tensec_roi, 6, time_sec10)
time_sec1 = analyze_timer_frame(work_frame, onesec_roi, 10, time_sec1)
find_time = time_min + ":" + time_sec10 + time_sec1
now_time, is_same_time = time_check(time_min, time_sec10, time_sec1, past_time)
is_normal_speed = analyze_speed(original_frame, speed_roi)
if is_same_time:
# count up if normal speed, neither, reset count
if is_normal_speed:
time_count += 1
else:
time_count = 0
else:
time_count = 0
past_time = now_time
if time_count >= 0:
# check friendly ub
ub_result, find_id, find_count = analyze_ub_frame(work_frame, ub_roi, time_min, time_sec10,
time_sec1,
ub_data, ub_data_enemy, ub_data_value,
characters_find, find_id, find_count)
if ub_result:
# update count
time_count = update_count(frame_rate, find_id, cap_interval)
elif is_normal_speed:
# check enemy ub
analyze_enemy_ub(time_count, work_frame, find_time, ub_data_enemy)
# check score existence
ret = analyze_score_frame(work_frame, SCORE_DATA, score_roi)
if ret is True:
# analyze total damage
ret = analyze_damage_frame(original_frame, damage_data_roi, tmp_damage)
if ret is True:
total_damage = "".join(tmp_damage)
break
video.release()
cm.clear_path(movie_path)
# post-processing to timeline
if len(ub_data_enemy) != 0 and ENEMY_UB in ub_data_enemy[-1]:
ub_data_enemy.pop()
debuff_value = ac.make_ub_value_list(ub_data_value, characters_find)
time_result = tm.time() - start_time
time_data.append("動画時間 : {:.3f}".format(frame_count / frame_rate) + " sec")
time_data.append("処理時間 : {:.3f}".format(time_result) + " sec")
status = get_analyze_status(ub_data, video_type)
if status is not state.DONE:
ub_data_enemy = False
return ub_data, ub_data_enemy, time_data, total_damage, debuff_value, status
def analyze_movie(movie_path):
"""analyze movie main
check movie frames and find ub frame
check frame: 0.34 sec (20 frames)
Args
movie_path (string): movie save path
Returns
ub_data (list): found ub data
time_data (list): spend time while analyze
total_damage (string): total damage
debuff_value (list): ub timing debuff values
status (int): analyze status 200 (HD analyze) or 301 (SD analyze)
"""
start_time = tm.time()
video = cv2.VideoCapture(movie_path)
frame_count = int(video.get(7)) # get total frame
frame_rate = int(video.get(5)) # get frame rate
frame_width = int(video.get(3)) # get frame width
frame_height = int(video.get(4)) # get frame height
try:
video_type = FRAME_RESOLUTION.index((frame_width, frame_height))
except ValueError:
video.release()
cm.clear_path(movie_path)
return None, None, None, None, el.ERR_BAD_RESOLUTION
if video_type is RESOLUTION_16_9_SD:
status = el.TMP_DONE_IN_SD
else:
status = el.DONE
model_init(video_type)
roi_init(video_type)
n = 0.34
ub_interval = 0
time_min = "1"
time_sec10 = "3"
time_sec1 = "0"
menu_check = False
min_roi = MIN_ROI
tensec_roi = TEN_SEC_ROI
onesec_roi = ONE_SEC_ROI
ub_roi = UB_ROI
score_roi = SCORE_ROI
damage_data_roi = DAMAGE_DATA_ROI
ub_data = []
ub_data_value = []
time_data = []
characters_find = []
tmp_damage = []
total_damage = False
cap_interval = int(frame_rate * n)
skip_frame = 5 * cap_interval
if (frame_count / frame_rate) < 600: # only check less than 10 min movie
for i in range(frame_count): # cycle check movie per frame
ret = video.grab()
if ret is False:
break
if i % cap_interval is 0:
if ((i - ub_interval) > skip_frame) or (ub_interval == 0):
ret, original_frame = video.read()
if ret is False:
break
if video_type is RESOLUTION_16_9_SD:
original_frame = expand_frame(original_frame)
work_frame = edit_frame(original_frame)
if menu_check is False:
menu_check, menu_loc = analyze_menu_frame(
work_frame, MENU_DATA, MENU_ROI)
if menu_check is True:
loc_diff = np.array(MENU_LOC) - np.array(menu_loc)
roi_diff = (loc_diff[0], loc_diff[1], loc_diff[0],
loc_diff[1])
min_roi = np.array(MIN_ROI) - np.array(roi_diff)
tensec_roi = np.array(TEN_SEC_ROI) - np.array(
roi_diff)
onesec_roi = np.array(ONE_SEC_ROI) - np.array(
roi_diff)
ub_roi = np.array(UB_ROI) - np.array(roi_diff)
score_roi = np.array(SCORE_ROI) - np.array(
roi_diff)
damage_data_roi = np.array(
DAMAGE_DATA_ROI) - np.array(roi_diff)
analyze_anna_icon_frame(work_frame,
CHARACTER_ICON_ROI,
characters_find)
else:
if time_min is "1":
time_min = analyze_timer_frame(
work_frame, min_roi, 2, time_min)
time_sec10 = analyze_timer_frame(
work_frame, tensec_roi, 6, time_sec10)
time_sec1 = analyze_timer_frame(
work_frame, onesec_roi, 10, time_sec1)
ub_result = analyze_ub_frame(work_frame, ub_roi,
time_min, time_sec10,
time_sec1, ub_data,
ub_data_value,
characters_find)
if ub_result is FOUND:
ub_interval = i
# check score existence
ret = analyze_score_frame(work_frame, SCORE_DATA,
score_roi)
if ret is True:
# analyze total damage
ret = analyze_damage_frame(original_frame,
damage_data_roi,
tmp_damage)
if ret is True:
total_damage = "".join(tmp_damage)
break
video.release()
cm.clear_path(movie_path)
# post-processing to timeline
debuff_value = ac.make_ub_value_list(ub_data_value, characters_find)
time_result = tm.time() - start_time
time_data.append("動画時間 : {:.3f}".format(frame_count / frame_rate) +
" sec")
time_data.append("処理時間 : {:.3f}".format(time_result) + " sec")
return ub_data, time_data, total_damage, debuff_value, status
def analyze_movie(movie_path):
# 動画解析し結果をリストで返す
start_time = tm.time()
video = cv2.VideoCapture(movie_path)
frame_count = int(video.get(7)) # フレーム数を取得
frame_rate = int(video.get(5)) # フレームレート(1フレームの時間単位はミリ秒)の取得
frame_width = int(video.get(3)) # フレームの幅
frame_height = int(video.get(4)) # フレームの高さ
if frame_width != int(FRAME_COLS) or frame_height != int(FRAME_ROWS):
video.release()
os.remove(movie_path)
return None, None, None, None
n = 0.34 # n秒ごと*
ub_interval = 0
time_min = "1"
time_sec10 = "3"
time_sec1 = "0"
menu_check = False
min_roi = MIN_ROI
tensec_roi = TEN_SEC_ROI
onesec_roi = ONE_SEC_ROI
ub_roi = UB_ROI
damage_menu_roi = DAMAGE_MENU_ROI
damage_data_roi = DAMAGE_DATA_ROI
ub_data = []
ub_data_value = []
time_data = []
characters_find = []
tmp_damage = ["0", "0", "0", "0", "0", "0", "0"]
total_damage = False
cap_interval = int(frame_rate * n)
skip_frame = 5 * cap_interval
if (frame_count / frame_rate) < 600: # 10分未満の動画しか見ない
for i in range(frame_count): # 動画の秒数を取得し、回す
ret = video.grab()
if ret is False:
break
if i % cap_interval is 0:
if ((i - ub_interval) > skip_frame) or (ub_interval == 0):
ret, work_frame = video.read()
if ret is False:
break
work_frame = edit_frame(work_frame)
if menu_check is False:
menu_check, menu_loc = analyze_menu_frame(
work_frame, menu_data, MENU_ROI)
if menu_check is True:
loc_diff = np.array(MENU_LOC) - np.array(menu_loc)
roi_diff = (loc_diff[0], loc_diff[1], loc_diff[0],
loc_diff[1])
min_roi = np.array(MIN_ROI) - np.array(roi_diff)
tensec_roi = np.array(TEN_SEC_ROI) - np.array(
roi_diff)
onesec_roi = np.array(ONE_SEC_ROI) - np.array(
roi_diff)
ub_roi = np.array(UB_ROI) - np.array(roi_diff)
damage_menu_roi = np.array(
DAMAGE_MENU_ROI) - np.array(roi_diff)
damage_data_roi = np.array(
DAMAGE_DATA_ROI) - np.array(roi_diff)
analyze_anna_icon_frame(work_frame,
CHARACTER_ICON_ROI,
characters_find)
else:
if time_min is "1":
time_min = analyze_timer_frame(
work_frame, min_roi, 2, time_min)
time_sec10 = analyze_timer_frame(
work_frame, tensec_roi, 6, time_sec10)
time_sec1 = analyze_timer_frame(
work_frame, onesec_roi, 10, time_sec1)
ub_result = analyze_ub_frame(work_frame, ub_roi,
time_min, time_sec10,
time_sec1, ub_data,
ub_data_value,
characters_find)
if ub_result is FOUND:
ub_interval = i
ret = analyze_menu_frame(work_frame, damage_menu_data,
damage_menu_roi)[0]
if ret is True:
ret, end_frame = video.read()
if ret is False:
break
ret = analyze_damage_frame(end_frame,
damage_data_roi,
tmp_damage)
if ret is True:
total_damage = "総ダメージ " + ''.join(tmp_damage)
else:
ret = analyze_damage_frame(
end_frame, DAMAGE_DATA_ROI, tmp_damage)
if ret is True:
total_damage = "総ダメージ " + ''.join(
tmp_damage)
break
video.release()
os.remove(movie_path)
# TLに対する後処理
debuff_value = ac.make_ub_value_list(ub_data_value, characters_find)
time_result = tm.time() - start_time
time_data.append("動画時間 : {:.3f}".format(frame_count / frame_rate) +
" sec")
time_data.append("処理時間 : {:.3f}".format(time_result) + " sec")
return ub_data, time_data, total_damage, debuff_value