Feature standardization minimap

cut-highlights/checker.txt

@@ -0,0 +1,11 @@
+[30.0, 0]
+[60.0, 0]
+[90.0, 0]
+[120.0, 0]
+[150.0, 0]
+[180.0, 0]
+[210.0, 0]
+[240.0, 0]
+[270.0, 0]
+[300.0, 0]
+[330.0, 0]

cut-highlights/cut_highlights.py

@@ -0,0 +1,186 @@
+#   File Name: cut_highlights.py
+#        Team: standardization
+#  Programmer: ssw03270
+#  Start Date: 07/08/20
+# Last Update: August 2, 2020
+#     Purpose: Almost highlight video has 3 game.
+#              So we have to cut it to compare with our highlights.
+#              This program help to do it.
+
+# 1620, 780 (1920, 1080) : minimap start point in edit video, raw video size
+# If you want to see visual working process, erase #(notes) under the code.
+
+import cv2 as cv
+import numpy as np
+import os
+from matplotlib import pyplot as plt
+
+
+def matching(video_file: str, video_capture: np.ndarray, video_path: str, compare_image: np.ndarray) -> None:
+    """
+        For comparing video's capture and image
+
+        Args:
+            video_capture: One frame of video for compare
+            video_path: Video's path that user input
+            compare_image: Image file for compare
+
+        Returns:
+            N/A
+
+        Raises:
+            N/A
+    """
+    checker = []
+    is_writing = False
+    game_set = ["_GAME1", "_GAME2", "_GAME3", "_GAME4", "_GAME5"]
+    game_num = -1
+
+    width = int(video_capture.get(cv.CAP_PROP_FRAME_WIDTH))
+    height = int(video_capture.get(cv.CAP_PROP_FRAME_HEIGHT))
+    fourcc = cv.VideoWriter_fourcc(*"mp4v")
+    fps = video_capture.get(cv.CAP_PROP_FPS)
+
+    sift_ans = False
+    while True:
+        if not sift_ans:
+            is_writing = False
+
+        else:
+            if not is_writing:
+                is_writing = True
+                game_num += 1
+                out = cv.VideoWriter(video_file + game_set[game_num] + ".mp4", fourcc, fps, (width, height), 1)
+
+            out.write(frame_color)
+            # cv.imshow("EditedFrame", frame_color)
+
+        ret, frame_color = video_capture.read()
+        if not ret:
+            break
+        frame_gray = cv.cvtColor(frame_color, cv.COLOR_BGR2GRAY)
+        width_end, height_end = frame_gray.shape
+
+        width_start = round(780 / 1080 * width_end)
+        height_start = round(1620 / 1920 * height_end)
+
+        frame_resize = frame_gray[width_start: width_end, height_start: height_end]
+
+        # Showing video.
+        # cv.imshow("VideoFrame", frame_gray)
+
+        if video_capture.get(cv.CAP_PROP_POS_FRAMES) % fps == 0:
+            print("start comparing..." + str(video_capture.get(cv.CAP_PROP_POS_FRAMES)))
+            sift_ans = sift_algorithm(frame_resize, compare_image)
+            checker.append([video_capture.get(cv.CAP_PROP_POS_FRAMES), sift_ans])
+
+        # Stopping video.
+        # if cv.waitKey(1) > 0:
+        #     break
+
+    # write_txt(checker)
+    out.release()
+    video_capture.release()
+    cv.destroyAllWindows()
+
+
+def sift_algorithm(frame_resize: np.ndarray, compare_image: np.ndarray) -> bool:
+    """
+        Using sift algorithm to compare video's capture and image
+
+        Args:
+            frame_resize: Resized frame for compare
+            compare_image: Image file for compare
+
+        Returns:
+            If list name of good has 30 or more values, returns 1. (It means this frame is ingame)
+            If not, returns 0. (It means this frame isn't ingame)
+
+        Raises:
+            N/A
+    """
+    sift = cv.xfeatures2d.SIFT_create()
+
+    keypoint_1, descriptor_1 = sift.detectAndCompute(frame_resize, None)
+    keypoint_2, descriptor_2 = sift.detectAndCompute(compare_image, None)
+
+    bf = cv.BFMatcher()
+    matches = bf.knnMatch(descriptor_1, descriptor_2, 2)
+
+    good = []
+    for m, n in matches:
+        if m.distance < 0.75 * n.distance:
+            good.append([m])
+
+    # Showing plt.
+    # plt_image = cv.drawMatchesKnn(frame_resize, keypoint_1, compare_image, keypoint_2, good, None, flags=2)
+    # plt.imshow(plt_image)
+    # plt.show()
+
+    if len(good) > 15:
+        print("this frame is ingame.")
+        return True
+    else:
+        print("this frame isn't ingame.")
+        return False
+
+
+def write_txt(checker: list) -> None:
+    """
+        Writing the value that the frame has.
+        Now, it wasn't needed - 2020/08/02
+
+        Args:
+            checker: This list has current frame number and that's status.
+
+        Returns:
+            N/A
+
+        Raises:
+            N/A
+    """
+    print("start writeing...")
+    f = open("checker.txt", "w")
+    for data in checker:
+        f.writelines(str(data) + "\n")
+    f.close()
+
+
+def make_resource(path: str, type: int) -> np.ndarray:
+    """
+        Making a resource with path, according to type.
+
+        Args:
+            path: File's local path.
+            type: File's type, 0 is video file, 1 is image file.
+
+        Returns:
+            If type is 0, returns video capture.
+            If type is 1, returns image which convert gray.
+
+        Raises:
+            N/A
+    """
+    if type == 0:
+        return cv.VideoCapture(path)
+    elif type == 1:
+        return cv.imread(path, cv.COLOR_BGR2GRAY)
+
+
+def main() -> None:
+    image_path = "../resources/standardization/sample_image"
+    video_path = "../resources/standardization/sample_video"
+
+    video_list = os.listdir(video_path)
+    for video_file in video_list:
+        new_video_path = video_path + "/" + video_file
+        video_capture = make_resource(new_video_path, 0)
+
+        minimap_file = image_path + "/minimap.png"
+        minimap_image = make_resource(minimap_file, 1)
+
+        matching(video_file[0:len(video_file) - 4], video_capture, video_path, minimap_image)
+
+
+if __name__ == '__main__':
+    main()

minimap/cognition_inGame.py

@@ -0,0 +1,127 @@
+"""
+#   File Name: cognition_inGame.py
+#        Team: standardization
+#  Programmer: tjswodud
+#  Start Date: 07/07/20
+# Last Update: September 28, 2020
+#     Purpose: Full video of LCK will be given in this program.
+#              And compare frame and minimap image (template) per frame, using sift_algorithm.
+#              (if it success for compare, that frame is ingame, if not, that frame is not ingame.)
+#              Finally, this program will return edited video, except for frame that is not ingame.
+"""
+
+import cognition_pause as pause
+import cv2 as cv
+import numpy as np
+import searching_upperleft_banner as upperleft
+
+def match_template(video_capture: np.ndarray, template: np.ndarray, pause_image: np.ndarray, compare_images: list, video_file: str, video_path: str) -> None:
+    """
+        Compare captured video and template image (minimap image) with sift_algorithm
+        , and then write video frame that is in_game
+        Args:
+            video_capture: captured video using VideoCapture in __main__
+            template: a template image (minimap image) to compare with video_capture
+            video_file: name of video file in string type
+            video_path: path of output_video (output_video will be stored this path)
+        Returns:
+            None
+        Raises:
+            N/A
+    """
+    is_writing = False
+
+    file_name = video_file.replace('.mp4', '')
+
+    width = int(video_capture.get(cv.CAP_PROP_FRAME_WIDTH))
+    height = int(video_capture.get(cv.CAP_PROP_FRAME_HEIGHT))
+    fourcc = cv.VideoWriter_fourcc(*"mp4v")
+    fps = video_capture.get(cv.CAP_PROP_FPS)
+    output = cv.VideoWriter((video_path + '/' + file_name + '_output' + '.mp4'), fourcc, fps, (width, height), 1)
+
+    # sift_ans = False
+    while True:
+        ret, frame = video_capture.read()
+        if not ret:
+            break
+
+        frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+        width_end, height_end = frame_gray.shape # 1080, 1920
+        # width_end_2, height_end_2 = 638, 1138
+
+        width_start = round(780 / 1080 * width_end) # 780
+        height_start = round(1620 / 1920 * height_end) # 1620
+        # width_start_2 = round(442 / 1080 * width_end) # 442
+        # height_start_2 = round(782 / 1920 * height_end) # 782
+
+        frame_resize = frame_gray[width_start: width_end, height_start: height_end]
+        frame_resize_center = frame_gray[442: 638, 782: 1138]
+
+        total_frames = int(video_capture.get(cv.CAP_PROP_FRAME_COUNT))
+
+        if video_capture.get(cv.CAP_PROP_POS_FRAMES) % int(fps) == 0:
+            current_frame = int(video_capture.get(cv.CAP_PROP_POS_FRAMES))
+            percentage = (current_frame / total_frames) * 100
+            # print('{}/{} - {}%'.format(current_frame, total_frames, percentage))
+            print(end='\r')
+            print('Processing... {}%\r'.format(round(percentage, 2)), end = '')
+
+            sift_ans = sift_algorithm(frame_resize, template)
+            pause_ans = pause.sift_algorithm(frame_resize_center, pause_image)
+            replay_ans = upperleft.check_algorithm(upperleft.frame_resize(frame_gray, 0), compare_images[0])
+            highlight_ans = upperleft.check_algorithm(upperleft.frame_resize(frame_gray, 1), compare_images[1])
+            proview_ans = upperleft.check_algorithm(upperleft.frame_resize(frame_gray, 2), compare_images[2])
+
+            if (sift_ans and pause_ans and replay_ans and highlight_ans and proview_ans):
+                is_writing = True
+            else:
+                is_writing = False
+
+        if is_writing:
+            output.write(frame)
+        else:
+            continue
+
+    output.release()
+    video_capture.release()
+    cv.destroyAllWindows()
+
+def sift_algorithm(frame_resize: np.ndarray, template: np.ndarray) -> bool:
+    """
+        Compare video's frame and template image, using sift_algorithm
+        Args:
+            frame_resize: each of video's frame that is resized to template image
+            template: a template image (minimap image) to compare with video_capture
+        Returns:
+            [bool type]
+            if frame_resize and template match more than 15 points, return True (this frame is ingame.)
+            if not, return False (this frame is not ingame.)
+        Raises:
+            N/A
+    """
+    sift = cv.xfeatures2d.SIFT_create()
+
+    keypoint_1, descriptor_1 = sift.detectAndCompute(frame_resize, None)
+    keypoint_2, descriptor_2 = sift.detectAndCompute(template, None)
+
+    bf_matcher = cv.BFMatcher()
+    match = bf_matcher.knnMatch(descriptor_1, descriptor_2, 2)
+
+    success_match = []
+    for m, n in match:
+        if m.distance < n.distance * 0.75:
+            success_match.append([m])
+
+    # plot_image = cv.drawMatchesKnn(frame_resize, keypoint_1, template, keypoint_2, success_match, None, flags=2)
+    # plot.imshow(plot_image)
+    # plot.show()
+
+    if len(success_match) > 15:
+        # print('this frame is ingame.')
+        return True
+    else:
+        # print('this frame is not ingame.')
+        return False
+
+def create_capture(path: str):
+    return cv.VideoCapture(path)

minimap/cognition_pause.py

@@ -0,0 +1,52 @@
+"""
+#   File Name: cognition_pause.py
+#        Team: standardization
+#  Programmer: tjswodud
+#  Start Date: 07/07/20
+# Last Update: September 28, 2020
+#     Purpose: This file will be used module of cognition_inGame.py.
+#              compare every frame and pause_image, and then cut the frame that has a pause_image.
+"""
+
+import cv2 as cv
+# import matplotlib.pyplot as plot
+import numpy as np
+
+
+def sift_algorithm(frame_resize: np.ndarray, pause_image: np.ndarray) -> bool:
+    """
+        Compare video's frame and pause image, using sift_algorithm
+
+        Args:
+            frame_resize: each of video's frame that is resized to template image
+            pause_image: a image (pause_image) to compare with video_capture
+
+        Returns:
+            [bool type]
+            if frame_resize and pause_image match more than 15 points, return False (this frame isn't ingame.)
+            if not, return True (this frame is ingame. -> match with template_image)
+
+        Raises:
+            N/A
+    """
+    sift = cv.xfeatures2d.SIFT_create()
+
+    keypoint_1, descriptor_1 = sift.detectAndCompute(frame_resize, None)
+    keypoint_2, descriptor_2 = sift.detectAndCompute(pause_image, None)
+
+    bf_matcher = cv.BFMatcher()
+    match = bf_matcher.knnMatch(descriptor_1, descriptor_2, 2)
+
+    success_match = []
+    for m, n in match:
+        if m.distance < n.distance * 0.75:
+            success_match.append([m])
+
+    # plot_image = cv.drawMatchesKnn(frame_resize, keypoint_1, pause_image, keypoint_2, success_match, None, flags=2)
+    # plot.imshow(plot_image)
+    # plot.show()
+
+    if len(success_match) > 15:
+        return False
+    else:
+        return True