ytcollector 1.0.9__py3-none-any.whl → 1.1.2__py3-none-any.whl

ytcollector/analyzer.py

@@ -1,4 +1,5 @@
 import re
+import threading
 from .config import LICENSE_PLATE_PATTERNS
 
 # 선택적 import
@@ -20,23 +21,47 @@ try:
 except ImportError:
     NUMPY_AVAILABLE = False
 
+try:
+    from ultralytics import YOLOWorld
+    YOLO_AVAILABLE = True
+except ImportError:
+    YOLOWorld = None
+    YOLO_AVAILABLE = False
+
+from .config import LICENSE_PLATE_PATTERNS, YOLO_MODEL_NAME, YOLO_CONFIDENCE, YOLO_PROMPTS
+
 
 class VideoAnalyzer:
     """영상 분석 클래스 - 얼굴, 텍스트, 번호판, 타투 감지"""
 
+    _ocr_lock = threading.Lock()
+
     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 리더 초기화 (필요할 때만, 스레드 안전)"""
         if EASYOCR_AVAILABLE and self.ocr_reader is None:
-            print("  OCR 엔진 초기화 중...")
-            self.ocr_reader = easyocr.Reader(['ko', 'en'], gpu=False, verbose=False)
+            with self._ocr_lock:
+                if self.ocr_reader is None:
+                    print("  OCR 엔진 초기화 중...")
+                    self.ocr_reader = easyocr.Reader(['ko', 'en'], gpu=False, verbose=False)
+
+    def _init_yolo(self):
+        """YOLO-World 모델 초기화 (필요할 때만, 스레드 안전)"""
+        if YOLO_AVAILABLE and self.yolo_model is None:
+            with self._ocr_lock:
+                if self.yolo_model is None:
+                    print(f"  YOLO-World 모델({YOLO_MODEL_NAME}) 로딩 중...")
+                    self.yolo_model = YOLOWorld(YOLO_MODEL_NAME)
+                    # 감지할 클래스(프롬프트) 설정
+                    self.yolo_model.set_classes(YOLO_PROMPTS)
 
     def extract_frames(self, video_path, num_frames=10):
         """영상에서 균등 간격으로 프레임 추출"""
@@ -75,29 +100,75 @@ class VideoAnalyzer:
         )
 
     def detect_text(self, frame):
-        """EasyOCR로 텍스트 감지"""
+        """EasyOCR로 텍스트 감지 (스레드 안전)"""
         if not EASYOCR_AVAILABLE:
             return []
 
         self._init_ocr()
         try:
             h, w = frame.shape[:2]
-            if w > 640:
-                scale = 640 / w
-                frame = cv2.resize(frame, (640, int(h * scale)))
-
-            results = self.ocr_reader.readtext(frame)
-            return [r[1] for r in results if r[2] > 0.3]
-        except:
+            
+            # 가독성 개선을 위해 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:
+                # 원본(컬러)과 전처리(그레이) 중 선택 가능하나 보통 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):
-        """텍스트에서 번호판 패턴 감지"""
+    def detect_license_plate(self, texts, frame=None):
+        """텍스트에서 번호판 패턴 감지 및 YOLO-World 보조 감지"""
+        # 1. YOLO-World로 번호판 영역 확인
+        if YOLO_AVAILABLE and frame is not None:
+            try:
+                self._init_yolo()
+                if self.yolo_model:
+                    results = self.yolo_model(frame, verbose=False, conf=YOLO_CONFIDENCE)
+                    for r in results:
+                        # YOLO-World 클래스 인덱스는 YOLO_PROMPTS 순서와 같음
+                        # 0: license plate, 1: tattoo, 2: face (config 기준)
+                        if any(box.cls == 0 for box in r.boxes):
+                            # 번호판이 감지됨 -> 텍스트가 조금이라도 있으면 통과
+                            if texts: return True
+                            # 텍스트가 없어도 신뢰도가 높으면 감지된 것으로 간주 (옵션)
+                            if any(box.conf > 0.5 for box in r.boxes if box.cls == 0):
+                                return True
+            except:
+                pass
+
+        if not texts:
+            return False
+            
+        # 2. 개별 텍스트 박스 체크
         for text in texts:
-            text_clean = text.replace(' ', '').upper()
+            text_clean = re.sub(r'[^0-9가-힣]', '', text)
             for pattern in LICENSE_PLATE_PATTERNS:
                 if re.search(pattern, text_clean):
                     return True
+        
+        # 3. 프레임 내 모든 텍스트 결합 후 체크 (번호판이 쪼개진 경우 대응)
+        combined_text = "".join([re.sub(r'[^0-9가-힣]', '', t) for t in texts])
+        for pattern in LICENSE_PLATE_PATTERNS:
+            if re.search(pattern, combined_text):
+                return True
+                
         return False
 
     def detect_tattoo(self, frame):
@@ -151,42 +222,77 @@ class VideoAnalyzer:
             'license_plate': False,
             'tattoo': False,
             'face_count': 0,
-            'detected_texts': []
+            'detected_texts': [],
+            'first_detection_sec': None,
+            'first_detection_ts': None
         }
 
         if not CV2_AVAILABLE:
             print("  ⚠ OpenCV 미설치")
             return results
 
-        frames = self.extract_frames(video_path, num_frames=8)
-        if not frames:
-            print("  ⚠ 프레임 추출 실패")
+        # 영상 정보 가져오기
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
             return results
+        
+        fps = cap.get(cv2.CAP_PROP_FPS) or 30
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        cap.release()
 
+        # 분석 프레임 수 증가 (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 = []
         total_faces = 0
 
-        for i, frame in enumerate(frames):
+        cap = cv2.VideoCapture(video_path)
+        for idx in frame_indices:
+            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+            ret, frame = cap.read()
+            if not ret: continue
+
+            # 현재 프레임의 시간(초)
+            current_sec = idx / fps
+            detected_now = False
+
             # 얼굴
             faces = self.detect_faces(frame)
             if len(faces) > 0:
                 results['face'] = True
                 total_faces += len(faces)
-
-            # 텍스트 (일부 프레임만)
-            if i % 2 == 0 and EASYOCR_AVAILABLE:
-                texts = self.detect_text(frame)
-                if texts:
-                    results['text'] = True
-                    all_texts.extend(texts)
+                detected_now = True
+
+            # 텍스트 및 번호판
+            texts = self.detect_text(frame)
+            if texts:
+                results['text'] = True
+                all_texts.extend(texts)
+                detected_now = True
+                
+                # 번호판 감지 (프레임별로 결합 텍스트 및 YOLO 확인)
+                if self.detect_license_plate(texts, frame=frame):
+                    results['license_plate'] = True
 
             # 타투
             if self.detect_tattoo(frame):
                 results['tattoo'] = True
+                detected_now = True
+
+            # 첫 감지 시점 기록
+            if detected_now and results['first_detection_sec'] is None:
+                results['first_detection_sec'] = current_sec
+                m, s = int(current_sec // 60), int(current_sec % 60)
+                results['first_detection_ts'] = f"{m:02d}:{s:02d}"
+
+        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

@@ -51,8 +51,8 @@ def create_parser():
     parser.add_argument(
         '-o', '--output',
         type=str,
-        default=os.path.expanduser("~/youtube"),
-        help='저장 경로 (기본: ~/youtube)'
+        default=".",
+        help='저장 경로 (기본: 현재 폴더)'
     )
     parser.add_argument(
         '--fast',
@@ -74,7 +74,7 @@ def create_parser():
     parser.add_argument(
         '-v', '--version',
         action='version',
-        version='%(prog)s 1.0.9'
+        version='%(prog)s 1.1.2'
     )
     parser.add_argument(
         '--check-deps',
@@ -115,7 +115,7 @@ def run(
         categories = ['face']
     
     if output is None:
-        output = os.path.expanduser("~/youtube")
+        output = "."
     
     # 의존성 체크
     missing = check_dependencies()

ytcollector/config.py

@@ -37,14 +37,10 @@ CATEGORY_QUERIES = {
     ],
     'text': [
         "SBS 런닝맨 레전드",
-        "SBS 미운우리새끼 명장면",
-        "SBS 동상이몽 클립",
-        "SBS 집사부일체 모음",
-        "SBS 골목식당 레전드",
-        "SBS 맛남의광장 클립",
-        "SBS 불타는청춘 명장면",
-        "SBS 정글의법칙 레전드",
-        "SBS 예능",
+        "SBS 예능 쇼츠",
+        "재미있는 자막 영상 쇼츠",
+        "SBS 파워FM 보이는 라디오",
+        "SBS 연예대상 소감",
     ],
 }
 
@@ -55,12 +51,38 @@ CATEGORY_NAMES = {
     'text': '텍스트'
 }
 
-# 번호판 정규식 패턴
+# 카테고리별 제외 키워드 (제목에 포함 시 스킵)
+BLACKLIST_KEYWORDS = {
+    'tattoo': [
+        "두피 문신", "두피문신",
+        "눈썹 문신", "눈썹문신",
+        "입술 문신", "입술문신",
+        "립타투", "립 타투",
+        "헤어타투", "헤어 타투",
+        "구레나룻문신", "구레나룻 문신",
+        "틴트 입술",
+        "반영구", "SMP"
+    ],
+    'face': [],
+    'license_plate': [],
+    '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/dataset_builder.py

@@ -1,25 +1,7 @@
 import os
 import subprocess
 from yt_dlp import YoutubeDL
-
-def get_url_list(file_path):
-    if not os.path.exists(file_path):
-        return []
-    
-    urls = []
-    with open(file_path, 'r', encoding='utf-8') as f:
-        for line in f:
-            line = line.strip()
-            if not line or line.startswith('#'):
-                continue
-            parts = [p.strip() for p in line.split(',')]
-            if len(parts) >= 3:
-                urls.append({
-                    'url': parts[0],
-                    'timestamp': parts[1],
-                    'task': parts[2]
-                })
-    return urls
+from .utils import clip_video, get_url_list, get_video_duration, timestamp_to_seconds
 
 def download_videos(url_list, output_dir):
     os.makedirs(output_dir, exist_ok=True)
@@ -46,57 +28,9 @@ def download_videos(url_list, output_dir):
         except Exception as e:
             print(f"[{index_str}] Failed: {e}")
 
-def get_video_duration(file_path):
-    cmd = [
-        'ffprobe', '-v', 'error', '-show_entries', 'format=duration',
-        '-of', 'default=noprint_wrappers=1:nokey=1', file_path
-    ]
-    try:
-        output = subprocess.check_output(cmd).decode('utf-8').strip()
-        return float(output)
-    except:
-        return 0.0
-
-def timestamp_to_seconds(timestamp):
-    try:
-        parts = timestamp.split(':')
-        if len(parts) == 2:
-            return int(parts[0]) * 60 + int(parts[1])
-        return 0.0
-    except:
-        return 0.0
-
-def clip_video(input_path, output_path, center_timestamp, window_seconds=90):
-    duration = get_video_duration(input_path)
-    if duration == 0: return False
-    
-    center_sec = timestamp_to_seconds(center_timestamp)
-    start_sec = max(0, center_sec - window_seconds)
-    end_sec = min(duration, start_sec + (window_seconds * 2))
-    
-    if (end_sec - start_sec) < (window_seconds * 2) and start_sec > 0:
-        start_sec = max(0, end_sec - (window_seconds * 2))
-    
-    actual_duration = end_sec - start_sec
-    
-    cmd = [
-        'ffmpeg', '-y', '-ss', str(start_sec), '-t', str(actual_duration),
-        '-i', input_path, '-c', 'copy', output_path
-    ]
-    try:
-        subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        return True
-    except:
-        cmd[7:9] = ['-c:v', 'libx264', '-crf', '23', '-c:a', 'aac']
-        try:
-            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            return True
-        except:
-            return False
-
 def build_dataset(url_file, output_root="."):
-    video_dir = os.path.join(output_root, "video")
-    clip_dir = os.path.join(output_root, "video_clips")
+    video_dir = os.path.abspath(os.path.join(output_root, "video"))
+    clip_dir = os.path.abspath(os.path.join(output_root, "video_clips"))
     
     urls = get_url_list(url_file)
     if not urls:
@@ -119,9 +53,10 @@ def build_dataset(url_file, output_root="."):
         if os.path.exists(output_file): continue
             
         print(f"[{index_str}] Clipping: {files[0]}")
-        clip_video(input_file, output_file, item['timestamp'])
+        center_sec = timestamp_to_seconds(item['timestamp'])
+        clip_video(input_file, output_file, center_sec)
 
-    print(f"\nDone! Clips saved in: {os.path.abspath(clip_dir)}")
+    print(f"\nDone! Clips saved in: {clip_dir}")
 
 def main():
     import argparse

ytcollector/downloader.py

@@ -2,20 +2,24 @@ import os
 import time
 import random
 import shutil
+import threading
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from yt_dlp import YoutubeDL
 
-from .config import USER_AGENTS, CATEGORY_QUERIES, CATEGORY_NAMES, SKIP_ERRORS
+from .config import USER_AGENTS, CATEGORY_QUERIES, CATEGORY_NAMES, SKIP_ERRORS, BLACKLIST_KEYWORDS
 from .analyzer import VideoAnalyzer
+from .utils import clip_video, append_to_url_list, get_video_duration, get_next_index
 
 
 class YouTubeDownloader:
     """YouTube 다운로더 클래스"""
+    
+    _file_lock = threading.Lock()
 
     def __init__(self, output_path, max_duration=180, proxy=None, fast_mode=False, workers=3):
         self.output_path = output_path
-        self.max_duration = max_duration
+        self.max_duration = max_duration # 기본 180초(3분)
         self.proxy = proxy
         self.fast_mode = fast_mode
         self.workers = workers
@@ -146,7 +150,7 @@ class YouTubeDownloader:
             return None
 
     def _process_video(self, entry, category, cat_name):
-        """단일 영상 처리 (다운로드 + 분석)"""
+        """단일 영상 처리 (다운로드 + 분석 + 자동 트리밍 + URL 기록)"""
         vid = entry.get('id')
         url = f"https://www.youtube.com/watch?v={vid}"
         title = entry.get('title', '?')[:45]
@@ -156,6 +160,7 @@ class YouTubeDownloader:
         result_info = {'title': title, 'status': status, 'saved': False}
 
         if status == "ok" and filepath:
+            print(f"  🔍 분석 중...")
             analysis = self.analyzer.analyze(filepath)
 
             detected = []
@@ -171,12 +176,34 @@ class YouTubeDownloader:
             result_info['detected'] = detected
 
             if analysis.get(category):
+                # 1. 태스크별 전용 youtube_url_{category}.txt 업데이트
+                url_file_path = f"youtube_url_{category}.txt"
+                ts = analysis.get('first_detection_ts', '00:00')
+                append_to_url_list(url_file_path, url, ts, category)
+                
+                # 2. 결과 폴더 이동 및 파일명 변경 (category_0001.mp4 형식)
                 dest_dir = os.path.join(self.output_path, cat_name)
                 os.makedirs(dest_dir, exist_ok=True)
-                dest = os.path.join(dest_dir, os.path.basename(filepath))
-                if not os.path.exists(dest):
-                    shutil.move(filepath, dest)
+                
+                # 파일명 접두어 결정 (license_plate -> license)
+                prefix = category.replace('license_plate', 'license')
+                
+                with self._file_lock:
+                    idx = get_next_index(dest_dir, prefix)
+                    new_filename = f"{prefix}_{idx:04d}.mp4"
+                    dest = os.path.join(dest_dir, new_filename)
+                
+                # 원본 길이가 3분(180초) 초과면 감지 시점 기준 트리밍
+                duration = get_video_duration(filepath)
+                if duration > 180:
+                    print(f"  ✂ 3분 초과 영상 자동 트리밍 ({self._format_duration(duration)} -> 3:00)")
+                    clip_video(filepath, dest, analysis.get('first_detection_sec', 0))
+                else:
+                    if not os.path.exists(dest):
+                        shutil.move(filepath, dest)
+                
                 result_info['saved'] = True
+                result_info['new_path'] = dest
             else:
                 if category == 'license_plate':
                     dest_dir = os.path.join(self.output_path, "번호판_미감지")
@@ -201,7 +228,9 @@ class YouTubeDownloader:
         print(f"\n{'='*60}")
         print(f"[{cat_name}] 검색: {query}")
         mode = "⚡ 고속" if self.fast_mode else "일반"
-        print(f"목표: {max_videos}개 | 최대길이: {self._format_duration(self.max_duration)} | {mode}")
+        # 검색 시에는 제한을 20분(1200초)으로 완화하여 더 많은 영상 확보
+        search_limit = 1200 
+        print(f"목표: {max_videos}개 | 검색제한: {self._format_duration(search_limit)} | {mode}")
         print('='*60)
 
         # 검색
@@ -212,23 +241,29 @@ class YouTubeDownloader:
 
         print(f"검색됨: {len(entries)}개")
 
-        # 길이 필터링
+        # 필터링
         filtered = []
         for entry in entries:
-            if not entry:
-                continue
+            if not entry: continue
 
             vid = entry.get('id')
-            title = entry.get('title', '?')[:40]
+            title = entry.get('title', '')
             dur = entry.get('duration') or self._get_duration(vid)
 
-            if dur and dur < self.max_duration:
+            # 블랙리스트 키워드 체크
+            blacklist = BLACKLIST_KEYWORDS.get(category, [])
+            if any(kw in title for kw in blacklist):
+                print(f"  ✗ [제외] {title[:40]}...")
+                continue
+
+            # 너무 긴 영상(예: 20분 초과) 제외
+            if dur and dur < search_limit:
                 filtered.append(entry)
                 print(f"  ✓ [{self._format_duration(dur)}] {title}")
                 if len(filtered) >= max_videos:
                     break
             elif dur:
-                print(f"  ✗ [{self._format_duration(dur)}] {title}")
+                print(f"  ✗ [{self._format_duration(dur)}] (너무 filter됨)")
 
             if not self.fast_mode:
                 time.sleep(0.3)
@@ -237,30 +272,27 @@ class YouTubeDownloader:
             print("조건 맞는 영상 없음")
             return 0
 
-        print(f"\n다운로드: {len(filtered)}개" + (" (병렬)" if self.fast_mode else ""))
+        print(f"\n다운로드 및 분석: {len(filtered)}개" + (" (병렬)" if self.fast_mode else ""))
         success = 0
 
         if self.fast_mode and self.workers > 1:
-            # 병렬 다운로드
             with ThreadPoolExecutor(max_workers=self.workers) as executor:
                 futures = {
                     executor.submit(self._process_video, entry, category, cat_name): entry
                     for entry in filtered
                 }
-
                 for i, future in enumerate(as_completed(futures)):
                     entry = futures[future]
                     title = entry.get('title', '?')[:45]
-
                     try:
                         result = future.result()
                         print(f"\n[{i+1}/{len(filtered)}] {title}")
-
                         if result['status'] == "ok":
                             if result.get('detected'):
                                 print(f"  감지: {', '.join(result['detected'])}")
                             if result['saved']:
-                                print(f"  ✅ 저장: {cat_name}/")
+                                new_name = os.path.basename(result['new_path'])
+                                print(f"  ✅ 저장: {cat_name}/{new_name}")
                                 success += 1
                             elif result.get('undetected_saved'):
                                 print("  📁 미감지 보관")
@@ -276,61 +308,26 @@ class YouTubeDownloader:
                         print(f"\n[{i+1}/{len(filtered)}] {title}")
                         print(f"  ✗ 에러: {e}")
         else:
-            # 순차 다운로드
             for i, entry in enumerate(filtered):
                 vid = entry.get('id')
-                url = f"https://www.youtube.com/watch?v={vid}"
                 title = entry.get('title', '?')[:45]
-
                 print(f"\n[{i+1}/{len(filtered)}] {title}")
 
-                status, filepath, _ = self._download_one(url)
-                if not self.fast_mode:
-                    print()
-
-                if status == "ok" and filepath:
-                    print("  🔍 분석...")
-                    result = self.analyzer.analyze(filepath)
-
-                    detected = []
-                    if result['face']:
-                        detected.append(f"얼굴({result['face_count']})")
-                    if result['text']:
-                        detected.append("텍스트")
-                    if result['license_plate']:
-                        detected.append("번호판")
-                    if result['tattoo']:
-                        detected.append("타투")
-
-                    if detected:
-                        print(f"  감지: {', '.join(detected)}")
-
-                    if result.get(category):
-                        dest_dir = os.path.join(self.output_path, cat_name)
-                        os.makedirs(dest_dir, exist_ok=True)
-                        dest = os.path.join(dest_dir, os.path.basename(filepath))
-                        if not os.path.exists(dest):
-                            shutil.move(filepath, dest)
-                        print(f"  ✅ 저장: {cat_name}/")
+                result = self._process_video(entry, category, cat_name)
+                if result['status'] == "ok":
+                    if result.get('detected'):
+                        print(f"  감지: {', '.join(result['detected'])}")
+                    if result['saved']:
+                        new_name = os.path.basename(result['new_path'])
+                        print(f"  ✅ 저장: {cat_name}/{new_name}")
                         success += 1
+                    elif result.get('undetected_saved'):
+                        print("  📁 미감지 보관")
                     else:
-                        if category == 'license_plate':
-                            dest_dir = os.path.join(self.output_path, "번호판_미감지")
-                            os.makedirs(dest_dir, exist_ok=True)
-                            dest = os.path.join(dest_dir, os.path.basename(filepath))
-                            if not os.path.exists(dest):
-                                shutil.move(filepath, dest)
-                            print("  📁 미감지 보관")
-                        else:
-                            try:
-                                os.remove(filepath)
-                            except:
-                                pass
-                            print("  ❌ 미감지 삭제")
-
-                elif status == "skipped":
+                        print("  ❌ 미감지 삭제")
+                elif result['status'] == "skipped":
                     print("  ⏭ 이미 있음")
-                elif status == "unavailable":
+                elif result['status'] == "unavailable":
                     print("  ⏭ 사용불가")
                 else:
                     print("  ✗ 실패")

ytcollector/utils.py

@@ -0,0 +1,126 @@
+import os
+import subprocess
+
+def get_video_duration(file_path):
+    """영상 전체 길이를 초 단위로 반환"""
+    cmd = [
+        'ffprobe', '-v', 'error', '-show_entries', 'format=duration',
+        '-of', 'default=noprint_wrappers=1:nokey=1', file_path
+    ]
+    try:
+        output = subprocess.check_output(cmd).decode('utf-8').strip()
+        return float(output)
+    except:
+        return 0.0
+
+def timestamp_to_seconds(timestamp):
+    """MM:SS 또는 SS 형식을 초 단위로 변환"""
+    if isinstance(timestamp, (int, float)):
+        return float(timestamp)
+    try:
+        parts = str(timestamp).split(':')
+        if len(parts) == 2:
+            return int(parts[0]) * 60 + int(parts[1])
+        return float(parts[0])
+    except:
+        return 0.0
+
+def seconds_to_timestamp(seconds):
+    """초 단위를 MM:SS 형식으로 변환"""
+    m = int(seconds // 60)
+    s = int(seconds % 60)
+    return f"{m:02d}:{s:02d}"
+
+def clip_video(input_path, output_path, center_sec, window_seconds=90):
+    """center_sec를 기준으로 앞뒤 window_seconds만큼 자름"""
+    duration = get_video_duration(input_path)
+    if duration == 0:
+        return False
+    
+    start_sec = max(0, center_sec - window_seconds)
+    end_sec = min(duration, start_sec + (window_seconds * 2))
+    
+    if (end_sec - start_sec) < (window_seconds * 2) and start_sec > 0:
+        start_sec = max(0, end_sec - (window_seconds * 2))
+    
+    actual_duration = end_sec - start_sec
+
+    # 임시 파일 경로
+    temp_output = output_path + ".tmp.mp4"
+    
+    cmd = [
+        'ffmpeg', '-y', '-ss', f"{start_sec:.2f}", '-t', f"{actual_duration:.2f}",
+        '-i', input_path, '-c', 'copy', temp_output
+    ]
+    
+    try:
+        subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        if os.path.exists(output_path):
+            os.remove(output_path)
+        os.rename(temp_output, output_path)
+        return True
+    except:
+        # copy 실패 시 재인코딩
+        cmd[7:9] = ['-c:v', 'libx264', '-crf', '23', '-c:a', 'aac']
+        try:
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            if os.path.exists(temp_output):
+                if os.path.exists(output_path): os.remove(output_path)
+                os.rename(temp_output, output_path)
+            return True
+        except:
+            if os.path.exists(temp_output): os.remove(temp_output)
+            return False
+
+def append_to_url_list(file_path, url, timestamp, task):
+    """youtube_url.txt에 데이터 추가"""
+    line = f"{url}, {timestamp}, {task}\n"
+    # 파일이 없으면 헤더 추가
+    exists = os.path.exists(file_path)
+    with open(file_path, 'a', encoding='utf-8') as f:
+        if not exists:
+            f.write("# URL, MM:SS, TaskName\n")
+        f.write(line)
+
+def get_url_list(file_path):
+    """youtube_url.txt 파일을 읽어서 리스트로 반환"""
+    if not os.path.exists(file_path):
+        return []
+    
+    urls = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            parts = [p.strip() for p in line.split(',')]
+            if len(parts) >= 3:
+                urls.append({
+                    'url': parts[0],
+                    'timestamp': parts[1],
+                    'task': parts[2]
+                })
+    return urls
+
+def get_next_index(directory, prefix):
+    """
+    directory 내에서 {prefix}_{index:04d}.mp4 형식의 파일들을 찾아 
+    가장 높은 index + 1을 반환함. 파일이 없으면 1 반환.
+    """
+    if not os.path.exists(directory):
+        return 1
+    
+    max_idx = 0
+    pattern = f"{prefix}_"
+    for filename in os.listdir(directory):
+        if filename.startswith(pattern) and filename.endswith(".mp4"):
+            try:
+                # {prefix}_0001.mp4 -> 0001 추출
+                idx_part = filename[len(pattern):].split('.')[0]
+                idx = int(idx_part)
+                if idx > max_idx:
+                    max_idx = idx
+            except (ValueError, IndexError):
+                continue
+                
+    return max_idx + 1

{ytcollector-1.0.9.dist-info → ytcollector-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytcollector
-Version: 1.0.9
+Version: 1.1.2
 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"
@@ -46,7 +47,9 @@ pip install yt-dlp
 ### 분석 기능용 패키지 (권장)
 
 ```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"
 ```
 
 ## 사용법
@@ -54,7 +57,7 @@ pip install opencv-python easyocr numpy
 ### 기본 실행
 
 ```bash
-python main.py
+ytcollector
 ```
 
 기본값: 얼굴 카테고리 5개, 최대 3분 영상
@@ -66,7 +69,7 @@ python main.py
 | `-c`, `--categories` | 수집할 카테고리 | `face` |
 | `-n`, `--count` | 카테고리당 다운로드 수 | `5` |
 | `-d`, `--duration` | 최대 영상 길이(분) | `3` |
-| `-o`, `--output` | 저장 경로 | `~/Downloads/youtube_collection` |
+| `-o`, `--output` | 저장 경로 | `.` (현재 폴더) |
 | `--fast` | 고속 모드 (병렬 다운로드) | 비활성화 |
 | `-w`, `--workers` | 병렬 다운로드 수 | `3` |
 | `--proxy` | 프록시 주소 | 없음 |
@@ -86,45 +89,45 @@ python main.py
 
 ```bash
 # 얼굴 영상 10개 수집
-python main.py -c face -n 10
+ytcollector -c face -n 10
 
 # 번호판 영상 수집 (최대 5분)
-python main.py -c license_plate -d 5
+ytcollector -c license_plate -d 5
 
 # 타투 영상 수집
-python main.py -c tattoo -n 5
+ytcollector -c tattoo -n 5
 ```
 
 ### 여러 카테고리
 
 ```bash
 # 얼굴과 텍스트 각 10개씩
-python main.py -c face text -n 10
+ytcollector -c face text -n 10
 
 # 모든 카테고리 수집
-python main.py -c face license_plate tattoo text -n 5
+ytcollector -c face license_plate tattoo text -n 5
 ```
 
 ### 고속 모드
 
 ```bash
 # 병렬 다운로드 (기본 3개 동시)
-python main.py -c face -n 10 --fast
+ytcollector -c face -n 10 --fast
 
 # 5개 동시 다운로드
-python main.py -c face -n 10 --fast -w 5
+ytcollector -c face -n 10 --fast -w 5
 ```
 
 ### 저장 경로 지정
 
 ```bash
-python main.py -c face -o /path/to/save
+ytcollector -c face -o /path/to/save
 ```
 
 ### 프록시 사용
 
 ```bash
-python main.py -c face --proxy http://proxy.server:8080
+ytcollector -c face --proxy http://proxy.server:8080
 ```
 
 ## SBS Dataset 구축 (URL 리스트 기반)
@@ -184,9 +187,9 @@ https://www.youtube.com/watch?v=aqz-KE-bpKQ, 00:10, sample_task
 | 감지 항목 | 사용 기술 | 설명 |
 |-----------|-----------|------|
 | 얼굴 | OpenCV Haar Cascade | 정면 얼굴 감지 |
-| 텍스트 | EasyOCR | 한국어/영어 문자 인식 |
-| 번호판 | EasyOCR + 정규식 | 번호판 패턴 매칭 |
-| 타투 | OpenCV HSV 분석 | 피부 영역 내 잉크 패턴 |
+| 텍스트 | EasyOCR | 한국어/영어 문자 인식 (분석 품질 및 프레임 수 개선) |
+| 번호판 | YOLO-World + OCR | YOLO-World 기반 시각적 감지 + OCR 매칭 |
+| 타투 | OpenCV HSV 분석 | 피부 영역 내 잉크 패턴 감지 |
 
 ## 주의사항
 

ytcollector-1.1.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+ytcollector/__init__.py,sha256=OkibE8GYgt1qwOmkiBNXywkGVdnMj5sVpVzDVPSRXQg,1094
+ytcollector/analyzer.py,sha256=wrTSjvo1g6OKYlXcTWEDqZImbafTketf2zkW62Ojf-I,11115
+ytcollector/cli.py,sha256=gccaMLEyJm_DIpFaW3hyDzluUXCOHGgHxOR-XryLUGc,5577
+ytcollector/config.py,sha256=ZjyDWQg4haJPwUlP-eW0hXa_I2g9wyNaI8y5mxEU0vc,3040
+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.2.dist-info/METADATA,sha256=Wok3o3YiMOC3VrlyjPabZK4IYEGD_LmlP9RQ9KU38Hs,6464
+ytcollector-1.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ytcollector-1.1.2.dist-info/entry_points.txt,sha256=waiVuSJJYt-6_DAal-T4JkHgejo7wKYLdKrEI7tZ-ms,127
+ytcollector-1.1.2.dist-info/top_level.txt,sha256=wozNyCUm0eMOm-9U81yTql6oGaM2O5rWVBXDb93zzyQ,12
+ytcollector-1.1.2.dist-info/RECORD,,

ytcollector-1.0.9.dist-info/RECORD

@@ -1,11 +0,0 @@
-ytcollector/__init__.py,sha256=OkibE8GYgt1qwOmkiBNXywkGVdnMj5sVpVzDVPSRXQg,1094
-ytcollector/analyzer.py,sha256=JvppXAcoZ43lXJnGRX-dVGTSZ0QQ-IxBzF6ljT1BjJQ,6388
-ytcollector/cli.py,sha256=zOwnHs7kClOkcWHSUPXrVIPaZYKADMNCBsIosZEzmYc,5629
-ytcollector/config.py,sha256=w5Sx-jKdp4R-rCncDdOXc3WfSuH5OXkVRMIeMXL48VU,2216
-ytcollector/dataset_builder.py,sha256=HGVX_mR1W7_wBl2C5C6Cj43OCVseAGIYmg3-n8WLKuo,4598
-ytcollector/downloader.py,sha256=yQGGTR9ErjHlXHp_RXIDD3Zbl9geTyTHGROPO0nuxV8,12794
-ytcollector-1.0.9.dist-info/METADATA,sha256=bIEbwbhupi-Eo6HQ_4KCPRsM_09d6QK6HAnq2aMiNdM,6212
-ytcollector-1.0.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ytcollector-1.0.9.dist-info/entry_points.txt,sha256=waiVuSJJYt-6_DAal-T4JkHgejo7wKYLdKrEI7tZ-ms,127
-ytcollector-1.0.9.dist-info/top_level.txt,sha256=wozNyCUm0eMOm-9U81yTql6oGaM2O5rWVBXDb93zzyQ,12
-ytcollector-1.0.9.dist-info/RECORD,,