Upload 16 files

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/.ipynb_checkpoints/office-checkpoint.jpg filter=lfs diff=lfs merge=lfs -text
+data/.ipynb_checkpoints/table-checkpoint.jpg filter=lfs diff=lfs merge=lfs -text
+data/breakfast.mp4 filter=lfs diff=lfs merge=lfs -text
+data/classroom.jpg filter=lfs diff=lfs merge=lfs -text
+data/office.jpg filter=lfs diff=lfs merge=lfs -text
+data/table.jpg filter=lfs diff=lfs merge=lfs -text

data/breakfast.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c72555727af845f336b68f204186b8012781979dafa7e7abb3a4671590f4049c
+size 1396102

models/yolov8n.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f59b3d833e2ff32e194b5bb8e08d211dc7c5bdf144b90d2c8412c47ccfc83b36
+size 6549796

models/yolov8n_openvino_model/metadata.yaml

@@ -0,0 +1,98 @@
+description: Ultralytics YOLOv8n model trained on coco.yaml
+author: Ultralytics
+date: '2025-03-05T09:38:49.501129'
+version: 8.3.62
+license: AGPL-3.0 License (https://ultralytics.com/license)
+docs: https://docs.ultralytics.com
+stride: 32
+task: detect
+batch: 1
+imgsz:
+- 640
+- 640
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+args:
+  batch: 1
+  half: false
+  int8: false
+  dynamic: false

models/yolov8n_openvino_model/yolov8n.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48b86fce278a5a6833dc015b7af8cbcb7174004a5f9b6ff7ec724f753f361681
+size 12708656

streamlit_app.py

@@ -0,0 +1,61 @@
+import streamlit as st
+from utils import object_detection_brainai as odb
+object_detection = odb.ObjectDetectionModel()
+
+st.set_page_config(
+    page_title = "객체 인식", 
+    page_icon = ":black_cat:",
+    layout = "wide")
+
+st.title(":blue[Object Detection] :black_cat:")
+
+st.sidebar.header("메뉴")
+source_radio = st.sidebar.radio("선택하세요", ["IMAGE", "VIDEO", "GAME", "WEBCAM"])
+
+if source_radio == "IMAGE":
+    st.write(":green[왼쪽 메뉴 'Browse files' 버튼을 클릭하여 이미지 파일을 선택하면 AI 추론이 시작됩니다.]")
+    st.sidebar.header("이미지 파일 업로드")
+    input_img = st.sidebar.file_uploader("이미지 파일을 선택하세요.", type=("jpg", "png"))
+
+    if input_img is not None:
+        result_img, detected_object = object_detection.process(input_img)
+        col1, col2 = st.columns(2)
+        with col1:
+            st.image(result_img)
+        with col2:
+            st.header(detected_object)
+
+    else:
+        col1, col2 = st.columns(2)
+        with col1:
+            st.image("data/table.jpg")
+        with col2:
+            st.header("Objected detected: chair, potted plant, vase, dining table")
+
+if source_radio == "VIDEO":
+    st.write(":green[왼쪽 메뉴 'Browse files' 버튼을 클릭하여 비디오 파일을 선택하면 AI 추론이 시작됩니다.]")
+    st.sidebar.header("비디오 파일 업로드")
+    input_video = st.sidebar.file_uploader("비디오 파일을 선택하세요.", type=("mp4"))
+    if input_video is not None:
+        output_video_path = object_detection.play_video(input_video)
+        st.video(output_video_path)
+    else:
+        st.video("data/breakfast.mp4")
+ 
+         
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

utils/.ipynb_checkpoints/object_detection_brainai-checkpoint.py

@@ -0,0 +1,99 @@
+import cv2
+from ultralytics import YOLO
+import numpy as np
+import PIL
+import streamlit as st
+import io
+
+class ObjectDetectionModel():
+    def __init__(self):
+        self.model = YOLO("models/yolov8n_openvino_model", task = "detect")
+        self.class_names = self.model.names
+
+    def process(self, img):
+        if isinstance(img, np.ndarray):
+            uploaded_img_cv = img
+        else:
+            uploaded_img = PIL.Image.open(img)
+            uploaded_img_cv = np.array(uploaded_img)
+            if uploaded_img_cv.shape[-1] == 4:
+                uploaded_img_cv = cv2.cvtColor(uploaded_img_cv, cv2.COLOR_RGBA2RGB)
+        
+        result = self.model(uploaded_img_cv)
+        img_plot = result[0].plot()
+
+        detected_classes = set()
+        for cls in result[0].boxes.cls:
+            class_id = int(box.cls[0])
+            class_name = self.class_names[class_id]
+            detected_classes.add(class_name)
+        detected_objects = f'Objects Detected: {", ".join(detected_classes) if detected_classes else "No objects detected"}'
+
+        return img_plot, detected_objects
+    
+    def play_video(self, video_path):
+
+        uploaded_video = io.BytesIO(video_path.read())
+        temporary_location = "upload.mp4"
+        with open(temporary_location, "wb") as temp_out:
+            temp_out.write(uploaded_video.read())
+        temp_out.close()
+        
+        camera = cv2.VideoCapture(temporary_location)
+        frame_width = int(camera.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(camera.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = camera.get(cv2.CAP_PROP_FPS)
+
+        fourcc = cv2.VideoWriter_fourcc(*'X264')
+        output_video_path = 'output_video.mp4'
+        out = cv2.VideoWriter(output_video_path,fourcc,fps, (frame_width,frame_height))
+        processed_frames = []
+
+        total_frames = int(camera.get(cv2.CAP_PROP_FRAME_COUNT))
+        frame_count = 0
+        progress_bar = st.progress(0)
+        st_frame = st.empty()
+        
+        while(True):
+            ret, frame = camera.read()
+            if not ret:
+                break
+    
+            result = self.model(frame, verbose=False)
+            img_plot = result[0].plot()
+            processed_frames.append(img_plot)
+
+            st_frame.image(img_plot, channels = "BGR")
+            frame_count +=1
+            progress_bar.progress(frame_count/total_frames, text = None)
+            
+        camera.release()
+        for frame in processed_frames:
+             out.write(frame)
+        out.release()
+
+        st_frame.empty()
+        progress_bar.empty()
+
+        return output_video_path
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

utils/.ipynb_checkpoints/object_detection_brainai_gradio-checkpoint.py

@@ -0,0 +1,60 @@
+import cv2
+from ultralytics import YOLO
+
+class ObjectDetectionModel():
+    def __init__(self):
+        self.model = YOLO("models/yolov8n_openvino_model", task = "detect")
+
+    def process(self, img):
+        result = self.model(img)
+        img_plot = result[0].plot()
+
+        return img_plot
+
+    def play_video(self, video_path):
+        camera = cv2.VideoCapture(video_path)
+        frame_width = int(camera.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(camera.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = camera.get(cv2.CAP_PROP_FPS)
+
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        output_video_path = 'output_video.mp4'
+        out = cv2.VideoWriter(output_video_path,fourcc,fps, (frame_width,frame_height))
+        processed_frames = []
+        
+        while(True):
+            ret, frame = camera.read()
+            if not ret:
+                break
+    
+            result = self.model(frame, verbose=False)
+            img_plot = result[0].plot()
+            processed_frames.append(img_plot)
+        camera.release()
+        for frame in processed_frames:
+             out.write(frame)
+        out.release()
+
+        return output_video_path
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

utils/object_detection_brainai.py

@@ -0,0 +1,99 @@
+import cv2
+from ultralytics import YOLO
+import numpy as np
+import PIL
+import streamlit as st
+import io
+
+class ObjectDetectionModel():
+    def __init__(self):
+        self.model = YOLO("models/yolov8n_openvino_model", task = "detect")
+        self.class_names = self.model.names
+
+    def process(self, img):
+        if isinstance(img, np.ndarray):
+            uploaded_img_cv = img
+        else:
+            uploaded_img = PIL.Image.open(img)
+            uploaded_img_cv = np.array(uploaded_img)
+            if uploaded_img_cv.shape[-1] == 4:
+                uploaded_img_cv = cv2.cvtColor(uploaded_img_cv, cv2.COLOR_RGBA2RGB)
+        
+        result = self.model(uploaded_img_cv)
+        img_plot = result[0].plot()
+
+        detected_classes = set()
+        for cls in result[0].boxes.cls:
+            class_id = int(box.cls[0])
+            class_name = self.class_names[class_id]
+            detected_classes.add(class_name)
+        detected_objects = f'Objects Detected: {", ".join(detected_classes) if detected_classes else "No objects detected"}'
+
+        return img_plot, detected_objects
+    
+    def play_video(self, video_path):
+
+        uploaded_video = io.BytesIO(video_path.read())
+        temporary_location = "upload.mp4"
+        with open(temporary_location, "wb") as temp_out:
+            temp_out.write(uploaded_video.read())
+        temp_out.close()
+        
+        camera = cv2.VideoCapture(temporary_location)
+        frame_width = int(camera.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(camera.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = camera.get(cv2.CAP_PROP_FPS)
+
+        fourcc = cv2.VideoWriter_fourcc(*'X264')
+        output_video_path = 'output_video.mp4'
+        out = cv2.VideoWriter(output_video_path,fourcc,fps, (frame_width,frame_height))
+        processed_frames = []
+
+        total_frames = int(camera.get(cv2.CAP_PROP_FRAME_COUNT))
+        frame_count = 0
+        progress_bar = st.progress(0)
+        st_frame = st.empty()
+        
+        while(True):
+            ret, frame = camera.read()
+            if not ret:
+                break
+    
+            result = self.model(frame, verbose=False)
+            img_plot = result[0].plot()
+            processed_frames.append(img_plot)
+
+            st_frame.image(img_plot, channels = "BGR")
+            frame_count +=1
+            progress_bar.progress(frame_count/total_frames, text = None)
+            
+        camera.release()
+        for frame in processed_frames:
+             out.write(frame)
+        out.release()
+
+        st_frame.empty()
+        progress_bar.empty()
+
+        return output_video_path
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

utils/object_detection_brainai_gradio.py

@@ -0,0 +1,60 @@
+import cv2
+from ultralytics import YOLO
+
+class ObjectDetectionModel():
+    def __init__(self):
+        self.model = YOLO("models/yolov8n_openvino_model", task = "detect")
+
+    def process(self, img):
+        result = self.model(img)
+        img_plot = result[0].plot()
+
+        return img_plot
+
+    def play_video(self, video_path):
+        camera = cv2.VideoCapture(video_path)
+        frame_width = int(camera.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(camera.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = camera.get(cv2.CAP_PROP_FPS)
+
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        output_video_path = 'output_video.mp4'
+        out = cv2.VideoWriter(output_video_path,fourcc,fps, (frame_width,frame_height))
+        processed_frames = []
+        
+        while(True):
+            ret, frame = camera.read()
+            if not ret:
+                break
+    
+            result = self.model(frame, verbose=False)
+            img_plot = result[0].plot()
+            processed_frames.append(img_plot)
+        camera.release()
+        for frame in processed_frames:
+             out.write(frame)
+        out.release()
+
+        return output_video_path
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+