ytcollector 1.1.1__py3-none-any.whl → 1.1.6__py3-none-any.whl

ytcollector/analyzer.py

@@ -1,25 +1,10 @@
-import re
-import threading
-from .config import LICENSE_PLATE_PATTERNS
-
-# 선택적 import
-try:
-    import cv2
-    CV2_AVAILABLE = True
-except ImportError:
-    CV2_AVAILABLE = False
-
 try:
-    import easyocr
-    EASYOCR_AVAILABLE = True
+    import torch
+    USE_GPU = torch.cuda.is_available()
 except ImportError:
-    EASYOCR_AVAILABLE = False
+    USE_GPU = False
 
-try:
-    import numpy as np
-    NUMPY_AVAILABLE = True
-except ImportError:
-    NUMPY_AVAILABLE = False
+from .config import LICENSE_PLATE_PATTERNS, YOLO_MODEL_NAME, YOLO_CONFIDENCE, YOLO_PROMPTS
 
 
 class VideoAnalyzer:
@@ -30,18 +15,32 @@ class VideoAnalyzer:
     def __init__(self):
         self.ocr_reader = None
         self.face_cascade = None
+        self.yolo_model = None
 
         if CV2_AVAILABLE:
             cascade_path = cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
             self.face_cascade = cv2.CascadeClassifier(cascade_path)
 
     def _init_ocr(self):
-        """OCR 리더 초기화 (필요할 때만, 스레드 안전)"""
+        """OCR 리더 초기화 (필요할 때만, 스레드 안전, GPU 가속 체크)"""
         if EASYOCR_AVAILABLE and self.ocr_reader is None:
             with self._ocr_lock:
                 if self.ocr_reader is None:
-                    print("  OCR 엔진 초기화 중...")
-                    self.ocr_reader = easyocr.Reader(['ko', 'en'], gpu=False, verbose=False)
+                    gpu_status = "사용" if USE_GPU else "미사용"
+                    print(f"  OCR 엔진 초기화 중... (GPU: {gpu_status})")
+                    self.ocr_reader = easyocr.Reader(['ko', 'en'], gpu=USE_GPU, verbose=False)
+
+    def _init_yolo(self):
+        """YOLO-World 모델 초기화 (필요할 때만, 스레드 안전, GPU 가속 체크)"""
+        if YOLO_AVAILABLE and self.yolo_model is None:
+            with self._ocr_lock:
+                if self.yolo_model is None:
+                    device = "cuda" if USE_GPU else "cpu"
+                    print(f"  YOLO-World 모델 로딩 중... (Device: {device})")
+                    self.yolo_model = YOLOWorld(YOLO_MODEL_NAME)
+                    self.yolo_model.to(device)
+                    # 감지할 클래스(프롬프트) 설정
+                    self.yolo_model.set_classes(YOLO_PROMPTS)
 
     def extract_frames(self, video_path, num_frames=10):
         """영상에서 균등 간격으로 프레임 추출"""
@@ -87,23 +86,92 @@ class VideoAnalyzer:
         self._init_ocr()
         try:
             h, w = frame.shape[:2]
-            if w > 640:
-                scale = 640 / w
-                frame = cv2.resize(frame, (640, int(h * scale)))
+            
+            # 가독성 개선을 위해 1080p 수준으로 리사이즈 (너무 작으면 인식률 저하)
+            if w > 1280:
+                scale = 1280 / w
+                frame = cv2.resize(frame, (1280, int(h * scale)), interpolation=cv2.INTER_LANCZOS4)
+            elif w < 640:
+                # 너무 작은 경우 확대
+                scale = 960 / w
+                frame = cv2.resize(frame, (960, int(h * scale)), interpolation=cv2.INTER_CUBIC)
+
+            # 전처리: 그레이스케일 및 대비 강화 (옵션)
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+            processed = clahe.apply(gray)
 
             with self._ocr_lock:
-                results = self.ocr_reader.readtext(frame)
-            return [r[1] for r in results if r[2] > 0.3]
-        except:
+                # 원본(컬러)과 전처리(그레이) 중 선택 가능하나 보통 EasyOCR은 컬러에서 잘 작동함
+                # 대비 강화된 그레이스케일을 사용해봄
+                results = self.ocr_reader.readtext(processed)
+            
+            # 신뢰도 임계값 0.25로 약간 하향 조정 (기존 0.3)
+            return [r[1] for r in results if r[2] > 0.25]
+        except Exception as e:
+            print(f"  ⚠ OCR 에러: {e}")
             return []
 
-    def detect_license_plate(self, texts):
-        """텍스트에서 번호판 패턴 감지"""
-        for text in texts:
-            text_clean = text.replace(' ', '').upper()
-            for pattern in LICENSE_PLATE_PATTERNS:
-                if re.search(pattern, text_clean):
-                    return True
+    def detect_license_plate(self, frame, texts=None):
+        """
+        ROI 기반 번호판 감지 (최적화 버전)
+        1. YOLO로 번호판 영역(ROI)을 먼저 찾음
+        2. 찾은 영역만 잘라서 OCR 수행 (속도 및 정확도 향상)
+        """
+        if not YOLO_AVAILABLE or frame is None:
+            return False
+
+        try:
+            self._init_yolo()
+            results = self.yolo_model(frame, verbose=False, conf=YOLO_CONFIDENCE)
+            
+            yolo_high_conf = False
+            roi_ocr_matched = False
+            
+            for r in results:
+                # 0: license plate
+                for box in r.boxes:
+                    if box.cls == 0:
+                        conf = float(box.conf)
+                        if conf > 0.8:
+                            yolo_high_conf = True
+                        
+                        # ROI 크로핑 및 타겟 OCR
+                        x1, y1, x2, y2 = map(int, box.xyxy[0])
+                        h, w = frame.shape[:2]
+                        # 패딩 10% 추가
+                        pad_w = int((x2 - x1) * 0.1)
+                        pad_h = int((y2 - y1) * 0.1)
+                        
+                        crop_x1 = max(0, x1 - pad_w)
+                        crop_y1 = max(0, y1 - pad_h)
+                        crop_x2 = min(w, x2 + pad_w)
+                        crop_y2 = min(h, y2 + pad_h)
+                        
+                        roi = frame[crop_y1:crop_y2, crop_x1:crop_x2]
+                        if roi.size > 0:
+                            # ROI에 대해서만 OCR 실행
+                            roi_texts = self.detect_text(roi)
+                            if roi_texts:
+                                combined_roi = "".join([re.sub(r'[^0-9가-힣]', '', t) for t in roi_texts])
+                                for pattern in LICENSE_PLATE_PATTERNS:
+                                    # 개별 텍스트 및 결합 텍스트 확인
+                                    if any(re.search(pattern, re.sub(r'[^0-9가-힣]', '', t)) for t in roi_texts) or \
+                                       re.search(pattern, combined_roi):
+                                        roi_ocr_matched = True
+                                        break
+                        
+                        if roi_ocr_matched: break
+                if roi_ocr_matched: break
+
+            # 최종 판정
+            if roi_ocr_matched or yolo_high_conf:
+                return True
+                
+        except Exception as e:
+            # print(f"  ⚠ 번호판 ROI 분석 에러: {e}")
+            pass
+
         return False
 
     def detect_tattoo(self, frame):
@@ -149,7 +217,7 @@ class VideoAnalyzer:
         except:
             return False
 
-    def analyze(self, video_path):
+    def analyze(self, video_path, target_category=None):
         """영상 전체 분석"""
         results = {
             'face': False,
@@ -175,7 +243,12 @@ class VideoAnalyzer:
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         cap.release()
 
-        num_analysis_frames = 10
+        # 분석 프레임 수 증가 (10 -> 20)
+        num_analysis_frames = 20
+        # 영상이 아주 긴 경우(10분 이상) 더 많은 프레임 추출
+        if total_frames / fps > 600:
+            num_analysis_frames = 30
+            
         frame_indices = [int(i * total_frames / (num_analysis_frames + 1)) for i in range(1, num_analysis_frames + 1)]
         
         all_texts = []
@@ -198,12 +271,26 @@ class VideoAnalyzer:
                 total_faces += len(faces)
                 detected_now = True
 
-            # 텍스트
-            texts = self.detect_text(frame)
-            if texts:
-                results['text'] = True
-                all_texts.extend(texts)
-                detected_now = True
+            # 번호판 감지 (타겟 카테고리가 번호판인 경우 우선 수행 - ROI 최적화)
+            if target_category == 'license_plate':
+                if self.detect_license_plate(frame):
+                    results['license_plate'] = True
+                    detected_now = True
+
+            # 텍스트 감지 (일반 텍스트 카테고리이거나 번호판 수집 중에도 텍스트 로그 기록을 위해 실행)
+            # 번호판 감지가 필요 없는 경우 전체 OCR을 건너뛰어 속도 향상 가능
+            if target_category == 'text' or (detected_now and target_category != 'license_plate'):
+                texts = self.detect_text(frame)
+                if texts:
+                    results['text'] = True
+                    all_texts.extend(texts)
+                    detected_now = True
+            elif target_category == 'license_plate' and not results['license_plate']:
+                # 번호판을 못 찾은 경우에만 전체 화면 OCR 한 번 더 시도 (보수적 접근)
+                texts = self.detect_text(frame)
+                if texts:
+                    all_texts.extend(texts)
+                    # 이미 detect_license_plate에서 결과가 안 나왔으므로 여기서는 텍스트만 수집
 
             # 타투
             if self.detect_tattoo(frame):
@@ -218,9 +305,7 @@ class VideoAnalyzer:
 
         cap.release()
 
-        # 번호판 (텍스트에서)
         if all_texts:
-            results['license_plate'] = self.detect_license_plate(all_texts)
             results['detected_texts'] = list(set(all_texts))[:10]
 
         results['face_count'] = total_faces

ytcollector/cli.py

@@ -74,7 +74,7 @@ def create_parser():
     parser.add_argument(
         '-v', '--version',
         action='version',
-        version='%(prog)s 1.1.1'
+        version='%(prog)s 1.1.6'
     )
     parser.add_argument(
         '--check-deps',

ytcollector/config.py

@@ -37,14 +37,10 @@ CATEGORY_QUERIES = {
     ],
     'text': [
         "SBS 런닝맨 레전드",
-        "SBS 미운우리새끼 명장면",
-        "SBS 동상이몽 클립",
-        "SBS 집사부일체 모음",
-        "SBS 골목식당 레전드",
-        "SBS 맛남의광장 클립",
-        "SBS 불타는청춘 명장면",
-        "SBS 정글의법칙 레전드",
-        "SBS 예능",
+        "SBS 예능 쇼츠",
+        "재미있는 자막 영상 쇼츠",
+        "SBS 파워FM 보이는 라디오",
+        "SBS 연예대상 소감",
     ],
 }
 
@@ -61,6 +57,9 @@ BLACKLIST_KEYWORDS = {
         "두피 문신", "두피문신",
         "눈썹 문신", "눈썹문신",
         "입술 문신", "입술문신",
+        "립타투", "립 타투",
+        "헤어타투", "헤어 타투",
+        "구레나룻문신", "구레나룻 문신",
         "틴트 입술",
         "반영구", "SMP"
     ],
@@ -69,12 +68,21 @@ BLACKLIST_KEYWORDS = {
     'text': []
 }
 
-# 번호판 정규식 패턴
+# YOLO 설정
+YOLO_MODEL_NAME = 'yolov8s-world.pt' # YOLO-World 모델 (Open Vocabulary)
+YOLO_CONFIDENCE = 0.3                # YOLO-World는 임계값을 약간 낮게 설정 가능
+YOLO_PROMPTS = ["license plate"]
+
+# 번호판 정규식 패턴 (한국 자동차 번호판 중심)
 LICENSE_PLATE_PATTERNS = [
-    r'\d{2,3}[가-힣]\d{4}',
-    r'[가-힣]{2}\d{2}[가-힣]\d{4}',
-    r'[A-Z]{2,3}[-\s]?\d{2,4}[-\s]?[A-Z]{0,3}',
-    r'\d{2,4}[-\s]?[A-Z]{2,3}[-\s]?\d{2,4}',
+    # 1. 신형/구형 번호판 (12가 3456, 123가 4567)
+    r'\d{2,3}[가-힣]{1}\d{4}',
+    # 2. 지역 포함 번호판 (서울 12 가 3456)
+    r'[가-힣]{2}\d{2}[가-힣]{1}\d{4}',
+    # 3. 전기차/외교/임시 등 특수 패턴 대응
+    r'[가-힣]{2,3}\d{4}', # (예: 외교 1234, 임시 1234)
+    # 4. 결합된 텍스트에서 숫자-글자-숫자 구성 포착
+    r'\d+[가-힣]+\d+',
 ]
 
 # 스킵할 에러 메시지

ytcollector/downloader.py

@@ -31,6 +31,29 @@ class YouTubeDownloader:
     def _get_ua(self):
         return random.choice(USER_AGENTS)
 
+    def _extract_vid(self, url):
+        """URL에서 비디오 ID 추출"""
+        if "v=" in url:
+            return url.split("v=")[1].split("&")[0]
+        return url.split("/")[-1]
+
+    def _load_processed_ids(self):
+        """모든 youtube_url_*.txt 파일에서 이미 처리된 비디오 ID 목록 로드"""
+        processed_ids = set()
+        for filename in os.listdir("."):
+            if filename.startswith("youtube_url_") and filename.endswith(".txt"):
+                try:
+                    with open(filename, 'r', encoding='utf-8') as f:
+                        for line in f:
+                            if line.strip() and not line.strip().startswith('#'):
+                                url = line.split(',')[0].strip()
+                                vid = self._extract_vid(url)
+                                if vid:
+                                    processed_ids.add(vid)
+                except:
+                    continue
+        return processed_ids
+
     def _get_query(self, category):
         """검색어 순환 반환"""
         if category not in self.query_index:
@@ -161,7 +184,7 @@ class YouTubeDownloader:
 
         if status == "ok" and filepath:
             print(f"  🔍 분석 중...")
-            analysis = self.analyzer.analyze(filepath)
+            analysis = self.analyzer.analyze(filepath, target_category=category)
 
             detected = []
             if analysis['face']:
@@ -243,10 +266,19 @@ class YouTubeDownloader:
 
         # 필터링
         filtered = []
+        processed_ids = self._load_processed_ids()
+        
         for entry in entries:
             if not entry: continue
 
             vid = entry.get('id')
+            if not vid: continue
+            
+            # 이미 처리된 영상은 즉시 패스
+            if vid in processed_ids:
+                print(f"  ⏭ [기록됨] {vid}")
+                continue
+
             title = entry.get('title', '')
             dur = entry.get('duration') or self._get_duration(vid)
 

{ytcollector-1.1.1.dist-info → ytcollector-1.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytcollector
-Version: 1.1.1
+Version: 1.1.6
 Summary: YouTube 콘텐츠 수집기 - 얼굴, 번호판, 타투, 텍스트 감지
 Author: YTCollector Team
 License: MIT
@@ -24,6 +24,7 @@ Provides-Extra: analysis
 Requires-Dist: opencv-python>=4.5.0; extra == "analysis"
 Requires-Dist: easyocr>=1.6.0; extra == "analysis"
 Requires-Dist: numpy>=1.20.0; extra == "analysis"
+Requires-Dist: ultralytics>=8.0.0; extra == "analysis"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=23.0.0; extra == "dev"
@@ -43,10 +44,14 @@ Requires-Dist: ytcollector[analysis,dev]; extra == "all"
 pip install yt-dlp
 ```
 
-### 분석 기능용 패키지 (권장)
+### 분석 기능용 패키지 (권장 - v1.1.6+)
+
+분석 기능을 원활하게 사용하려면 아래 패키지들이 필요합니다. GPU(CUDA)가 설치된 경우 자동으로 가속이 활성화됩니다.
 
 ```bash
-pip install opencv-python easyocr numpy
+pip install opencv-python easyocr numpy ultralytics
+# YOLO-World 기능을 사용하려면 아래 CLIP 라이브러리 수동 설치가 필요합니다.
+pip install "git+https://github.com/ultralytics/CLIP.git"
 ```
 
 ## 사용법
@@ -129,7 +134,7 @@ ytcollector -c face --proxy http://proxy.server:8080
 
 ## SBS Dataset 구축 (URL 리스트 기반)
 
-URL 리스트를 기반으로 영상을 수집하고 특정 시점을 기준으로 자동으로 클리핑(3분 미만)하는 기능입니다.
+URL 리스트를 기반으로 영상을 수집하고 특정 시점을 기준으로 자동으로 클리핑(3분 미만)하는 기능입니다. (v1.1.6에서 ROI 엔진 최적화 적용)
 
 ### 실행 방법
 
@@ -165,7 +170,8 @@ https://www.youtube.com/watch?v=aqz-KE-bpKQ, 00:10, sample_task
 ├── 번호판_미감지/     # 번호판 미감지 (수동 확인용)
 ├── 타투/              # 타투 감지된 영상
 ├── 텍스트/            # 텍스트 감지된 영상
-└── .archive.txt       # 다운로드 기록 (중복 방지)
+├── .archive.txt       # 기본 다운로드 기록
+└── youtube_url_*.txt  # 카테고리별 성공 로그 (v1.1.5+ 중복 체크에 활용)
 ```
 
 ## 파일 구조
@@ -184,9 +190,14 @@ https://www.youtube.com/watch?v=aqz-KE-bpKQ, 00:10, sample_task
 | 감지 항목 | 사용 기술 | 설명 |
 |-----------|-----------|------|
 | 얼굴 | OpenCV Haar Cascade | 정면 얼굴 감지 |
-| 텍스트 | EasyOCR | 한국어/영어 문자 인식 |
-| 번호판 | EasyOCR + 정규식 | 번호판 패턴 매칭 |
-| 타투 | OpenCV HSV 분석 | 피부 영역 내 잉크 패턴 |
+| 텍스트 | EasyOCR | 한국어/영어 문자 인식 (분석 품질 및 프레임 수 개선) |
+| 번호판 | YOLO-World + ROI OCR | v1.1.6: YOLO로 감지 후 해당 영역만 OCR (속도 2x, 정확도 향상) |
+| 타투 | OpenCV HSV 분석 | 피부 영역 내 잉크 패턴 감지 |
+
+### 주요 최적화 (v1.1.5~1.1.6)
+- **ROI 기반 감지**: 전체 화면이 아닌 YOLO가 지정한 영역만 OCR하여 속도와 정확도 대폭 향상
+- **GPU 가속 지원**: CUDA 사용 가능 시 YOLO 및 OCR 자동 가속
+- **로그 기반 중복 방지**: 로컬 파일이 없어도 `youtube_url_*.txt` 기록을 참조하여 중복 분석 방지
 
 ## 주의사항
 

ytcollector-1.1.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+ytcollector/__init__.py,sha256=OkibE8GYgt1qwOmkiBNXywkGVdnMj5sVpVzDVPSRXQg,1094
+ytcollector/analyzer.py,sha256=tQOeiH94Pdxmd41-6sI4qmQIV1B01urz9LFIJBeAkhY,12642
+ytcollector/cli.py,sha256=aHF4EuQRPLKh65lnkI_dZ0ResztlVjpHlS5iHfzmpig,5577
+ytcollector/config.py,sha256=ZjyDWQg4haJPwUlP-eW0hXa_I2g9wyNaI8y5mxEU0vc,3040
+ytcollector/dataset_builder.py,sha256=nfArEwszoCln48n3T0Eff_4OOaYv8FF0YH8cARBGMWQ,2608
+ytcollector/downloader.py,sha256=TeC6agUmSPHZSZ9jdoc42i8i_NobzTEkoRtAIgW80kI,14544
+ytcollector/utils.py,sha256=6XDif-e3GbMHmUvTsBT0YblxNxYnS-2I8HnmjMBZs-M,4254
+ytcollector-1.1.6.dist-info/METADATA,sha256=wdnOBAB-4PkJuVGuYNgXqoLTbFHXx0CrL8ITrMkINPo,7156
+ytcollector-1.1.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ytcollector-1.1.6.dist-info/entry_points.txt,sha256=waiVuSJJYt-6_DAal-T4JkHgejo7wKYLdKrEI7tZ-ms,127
+ytcollector-1.1.6.dist-info/top_level.txt,sha256=wozNyCUm0eMOm-9U81yTql6oGaM2O5rWVBXDb93zzyQ,12
+ytcollector-1.1.6.dist-info/RECORD,,

ytcollector-1.1.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-ytcollector/__init__.py,sha256=OkibE8GYgt1qwOmkiBNXywkGVdnMj5sVpVzDVPSRXQg,1094
-ytcollector/analyzer.py,sha256=d86jmykpLxZSv5lGsu642BUt1EQBJoiq9A-aIVP4RSo,7584
-ytcollector/cli.py,sha256=xbqcCivkiqA4ixa05WsbCkDtKUIX3XAm-9WwRBT40DA,5577
-ytcollector/config.py,sha256=WRy41EXDc5BFfN0jJmA0Xdt_YNTuSi0khka9_UL2Ktg,2561
-ytcollector/dataset_builder.py,sha256=nfArEwszoCln48n3T0Eff_4OOaYv8FF0YH8cARBGMWQ,2608
-ytcollector/downloader.py,sha256=ss6V3aBjNZkwLR6FRZuxAwrMkt86Xd6hZc6G2PrNt28,13253
-ytcollector/utils.py,sha256=6XDif-e3GbMHmUvTsBT0YblxNxYnS-2I8HnmjMBZs-M,4254
-ytcollector-1.1.1.dist-info/METADATA,sha256=2x-M9QYgRcGRMw_IaqnmJpf0qh5w_J7blLVU0IuTEkI,6169
-ytcollector-1.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ytcollector-1.1.1.dist-info/entry_points.txt,sha256=waiVuSJJYt-6_DAal-T4JkHgejo7wKYLdKrEI7tZ-ms,127
-ytcollector-1.1.1.dist-info/top_level.txt,sha256=wozNyCUm0eMOm-9U81yTql6oGaM2O5rWVBXDb93zzyQ,12
-ytcollector-1.1.1.dist-info/RECORD,,