स्थानीय डेप्थ वीडियो कन्वर्टर बनाएं - Gradio के साथ

निम्नलिखित एक पूर्ण Python Depth वीडियो कनवर्टर है जो Windows और macOS पर स्थानीय रूप से चलता है, बिना किसी मौजूदा प्रोजेक्ट कोड पर निर्भर हुए: ## 1. मुख्य Python स्क्रिप्ट (`depth_converter.py`) ```python import os import subprocess import tempfile import shutil import numpy as np import cv2 import gradio as gr from PIL import Image import torch from transformers import pipeline from transformers import AutoModelForDepthEstimation, AutoProcessor import platform import json # सिस्टम जानकारी IS_WINDOWS = platform.system() == "Windows" IS_MACOS = platform.system() == "Darwin" class DepthVideoConverter: def __init__(self): self.device = self._get_device() self.models = {} self.current_model_size = "small" def _get_device(self): """स्वचालित रूप से सर्वोत्तम उपलब्ध डिवाइस चुनें""" if torch.cuda.is_available() and IS_WINDOWS: print("CUDA उपलब्ध है - GPU का उपयोग कर रहे हैं") return "cuda" elif IS_MACOS and torch.backends.mps.is_available(): print("Apple Silicon उपलब्ध है - MPS का उपयोग कर रहे हैं") return "mps" else: print("CPU का उपयोग कर रहे हैं") return "cpu" def _load_model(self, model_size): """मॉडल को लोड करें और कैश करें""" if model_size == self.current_model_size and self.models.get(model_size): return self.models[model_size] model_map = { "small": "depth-anything/Depth-Anything-V2-Small", "base": "depth-anything/Depth-Anything-V2-Base", "large": "depth-anything/Depth-Anything-V2-Large" } model_name = model_map.get(model_size, model_map["small"]) if self.models.get(self.current_model_size): del self.models[self.current_model_size] torch.cuda.empty_cache() if self.device == "cuda" else None print(f"मॉडल लोड हो रहा है: {model_name}") try: # समकालिक पाइपलाइन का उपयोग करें pipe = pipeline( "depth-estimation", model=model_name, device=self.device ) self.models[model_size] = pipe self.current_model_size = model_size return pipe except Exception as e: print(f"मॉडल लोडिंग में त्रुटि: {e}") raise def process_frame(self, frame, model_size, invert=False, temporal_smoothing=0): """एक फ्रेम को डेप्थ मैप में बदलें""" # फ्रेम को RGB में बदलें rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) pil_image = Image.fromarray(rgb_frame) # डेप्थ अनुमान pipe = self._load_model(model_size) result = pipe(pil_image) # डेप्थ मैप निकालें depth_map = np.array(result["depth"]) # सामान्यीकरण (0-255) depth_map = (depth_map - depth_map.min()) / (depth_map.max() - depth_map.min() + 1e-8) depth_map = (depth_map * 255).astype(np.uint8) # समयिक स्मूथिंग (सरल फ्रेम औसत) if temporal_smoothing > 0: if not hasattr(self, '_prev_depth'): self._prev_depth = depth_map.astype(np.float32) else: alpha = 1.0 / (1.0 + temporal_smoothing) self._prev_depth = alpha * depth_map.astype(np.float32) + (1.0 - alpha) * self._prev_depth depth_map = self._prev_depth.astype(np.uint8) # काले/सफेद उलटना if invert: depth_map = 255 - depth_map return depth_map def process_video(self, input_path, model_size, output_resolution, invert, temporal_smoothing, preserve_audio): """पूरे वीडियो को प्रोसेस करें""" # आउटपुट फ़ाइल नाम तैयार करें output_path = os.path.join( os.path.dirname(input_path), "depth_" + os.path.basename(input_path) ) # टेम्पोरेरी फ़ाइलें temp_dir = tempfile.mkdtemp() temp_video = os.path.join(temp_dir, "temp_video.mp4") try: # वीडियो खोलें cap = cv2.VideoCapture(input_path) if not cap.isOpened(): raise Exception("वीडियो नहीं खोला जा सका") # वीडियो जानकारी प्राप्त करें fps = int(cap.get(cv2.CAP_PROP_FPS)) frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) # आउटपुट रिज़ोल्यूशन निर्धारित करें if output_resolution == "मूल": out_width, out_height = frame_width, frame_height elif output_resolution == "1280x720": out_width, out_height = 1280, 720 elif output_resolution == "1920x1080": out_width, out_height = 1920, 1080 elif output_resolution == "848x480": out_width, out_height = 848, 480 else: out_width, out_height = frame_width, frame_height # वीडियो राइटर बनाएं fourcc = cv2.VideoWriter_fourcc(*'mp4v') out = cv2.VideoWriter(temp_video, fourcc, fps, (out_width, out_height)) # फ़्रेम प्रोसेसिंग frame_count = 0 while True: ret, frame = cap.read() if not ret: break # फ्रेम को डेप्थ मैप में बदलें depth_map = self.process_frame(frame, model_size, invert, temporal_smoothing) # रिज़ोल्यूशन बदलें depth_resized = cv2.resize(depth_map, (out_width, out_height), interpolation=cv2.INTER_LINEAR) # ग्रेस्केल से BGR में बदलें depth_bgr = cv2.cvtColor(depth_resized, cv2.COLOR_GRAY2BGR) # वीडियो में लिखें out.write(depth_bgr) frame_count += 1 print(f"\rप्रगति: {frame_count}/{total_frames} ({frame_count/total_frames*100:.1f}%)", end="") print("\nप्रोसेसिंग पूर्ण!") cap.release() out.release() # ऑडियो जोड़ें if preserve_audio: self._preserve_audio(input_path, temp_video, output_path) else: shutil.move(temp_video, output_path) return output_path finally: # सफाई if os.path.exists(temp_dir): shutil.rmtree(temp_dir) def _preserve_audio(self, input_path, temp_video, output_path): """ffmpeg का उपयोग करके ऑडियो संरक्षित करें""" try: cmd = [ "ffmpeg", "-i", input_path, "-i", temp_video, "-map", "0:a", "-map", "1:v", "-c:a", "aac", "-c:v", "libx264", "-preset", "medium", "-crf", "23", "-shortest", output_path ] result = subprocess.run(cmd, capture_output=True, text=True, check=True) except subprocess.CalledProcessError as e: print(f"ffmpeg त्रुटि: {e}") print(f"ffmpeg आउटपुट: {e.stdout}") print(f"ffmpeg stderr: {e.stderr}") # फ़ॉलबैक: बिना ऑडियो के कॉपी करें shutil.copy(temp_video, output_path) print("चेतावनी: ऑडियो जोड़ने में विफल। बिना ऑडियो के सहेजा गया।") # UI इंटरफ़ेस def create_ui(): converter = DepthVideoConverter() def process_video_ui(video_file, model_size, output_resolution, invert, temporal_smoothing, preserve_audio): if video_file is None: return "कृपया एक वीडियो फ़ाइल चुनें", None # प्रोसेस करें output_path = converter.process_video( video_file.name if hasattr(video_file, 'name') else video_file, model_size, output_resolution, invert, temporal_smoothing, preserve_audio ) return "प्रोसेसिंग पूर्ण!", output_path with gr.Blocks(title="Depth वीडियो कनवर्टर") as demo: gr.Markdown("# डेप्थ वीडियो कनवर्टर") gr.Markdown("Depth Anything V2 का उपयोग करके साधारण वीडियो को डेप्थ मैप वीडियो में बदलें") with gr.Row(): with gr.Column(scale=1): video_input = gr.Video(label="वीडियो अपलोड करें (MP4/MOV)") model_size = gr.Dropdown( choices=["small", "base", "large"], value="small", label="मॉडल आकार", info="छोटे मॉडल तेज़ हैं, बड़े मॉडल अधिक सटीक हैं" ) output_resolution = gr.Dropdown( choices=["मूल", "848x480", "1280x720", "1920x1080"], value="मूल", label="आउटपुट रिज़ोल्यूशन" ) invert = gr.Checkbox(label="काले/सफेद उलटें", value=False) temporal_smoothing = gr.Slider( minimum=0, maximum=10, value=0, step=1, label="समयिक स्मूथिंग", info="फ़्लिकर कम करने के लिए (उच्च मान अधिक स्मूथ)" ) preserve_audio = gr.Checkbox(label="ऑडियो संरक्षित करें", value=True) process_btn = gr.Button("वीडियो बदलें", variant="primary") with gr.Column(scale=1): status = gr.Textbox(label="स्थिति", interactive=False) video_output = gr.Video(label="आउटपुट वीडियो") process_btn.click( process_video_ui, inputs=[video_input, model_size, output_resolution, invert, temporal_smoothing, preserve_audio], outputs=[status, video_output] ) return demo if __name__ == "__main__": demo = create_ui() print(f"डिवाइस: {torch.cuda.is_available() if torch.cuda.is_available() else 'CPU/MPS'}") demo.launch(server_name="127.0.0.1", server_port=7860, share=False) ``` ## 2. `requirements.txt` ``` gradio>=4.0.0 opencv-python>=4.8.0 numpy>=1.24.0 torch>=2.0.0 transformers>=4.35.0 pillow>=10.0.0 ffmpeg-python>=0.2.0 ``` ## 3. `README.md` # Depth वीडियो कनवर्टर Depth Anything V2 का उपयोग करके साधारण वीडियो को डेप्थ मैप वीडियो में बदलें। ## विशेषताएँ - 🚀 तीन डेप्थ मॉडल विकल्प (छोटा, मध्यम, बड़ा) - ⚡ NVIDIA CUDA, Apple Silicon, या CPU स्वचालित चयन - 🖥️ ग्रैडियो आधारित सरल वेब UI - 🔄 काले/सफेद उलटने का विकल्प - 📊 फ़्लिकर कम करने के लिए समयिक स्मूथिंग - 🔊 ffmpeg के साथ ऑडियो संरक्षण - 📐 कई आउटपुट रिज़ोल्यूशन ## सिस्टम आवश्यकताएँ - Python 3.9 या उच्चतर - 8 GB RAM (16 GB अनुशंसित) - GPU (वैकल्पिक लेकिन अनुशंसित) ## इंस्टॉलेशन ### Windows के लिए: ```bash # Python 3.9+ स्थापित करें এবং निम्न चलाएँ: python -m venv venv venv\Scripts\activate pip install -r requirements.txt ``` ### macOS के लिए: ```bash # Python 3.9+ स्थापित करें और निम्न चलाएँ: python3 -m venv venv source venv/bin/activate pip install -r requirements.txt ``` ### Apple Silicon (M1/M2/M3) के लिए: ```bash # Metal MPS समर्थन के लिए: pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu # या Apple Metal के लिए: pip install torch torchvision ``` ### ffmpeg इंस्टॉलेशन: **Windows:** ```bash # choco का उपयोग करके: choco install ffmpeg # या प्रिंगल विंडोज़ इंस्टॉलर डाउनलोड करें और पथ जोड़ें ``` **macOS:** ```bash brew install ffmpeg ``` ## उपयोग ### वेब UI लॉन्च करें: ```bash python depth_converter.py ``` फिर ब्राउज़र में खोलें: `http://127.0.0.1:7860` ### उड़ान विकल्प: 1. **वीडियो अपलोड करें** - MP4 या MOV फ़ाइल चुनें 2. **मॉडल आकार चुनें** - ज़रूरत के अनुसार small/base/large चुनें 3. **रिज़ोल्यूशन चुनें** - आउटपुट रिज़ोल्यूशन चुनें 4. **सेटिंग समायोजित करें** - इनवर्ट, स्मूथिंग, ऑडियो 5. **वीडियो बदलें** - कनवर्ट पर क्लिक करें ## उदाहरण आउटपुट वीडियो फ़्रेम → ग्रेस्केल डेप्थ मैप वीडियो जहां प्रत्येक पिक्सेल मान दृश्य की गहराई दर्शाता है। ## पथ समस्या निवारण ### GPU पहचान नहीं हुई: - CUDA के लिए: `pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118` - Apple Silicon के लिए: सुनिश्चित करें कि PyTorch संस्करण MPS समर्थन करता है ### ffmpeg त्रुटियाँ: - सुनिश्चित करें कि ffmpeg आपके PATH में है - `ffmpeg -version` चलाकर जाँचें ### कम मेमोरी त्रुटियाँ: - छोटे मॉडल आकार का उपयोग करें - कम रिज़ोल्यूशन आउटपुट चुनें ## लाइसेंस MIT ## क्रेडिट - Depth Anything V2 के लिए @LiheYoung और GenAI Team को धन्यवाद - Hugging Face Transformers ## 4. लॉन्च के लिए स्पष्ट इंस्टॉलेशन और निर्देश ### Windows इंस्टॉलेशन और लॉन्च: ```bash # 1. Python 3.9+ इंस्टॉल करें # https://www.python.org/downloads/windows/ # 2. प्रोजेक्ट डायरेक्टरी बनाएं mkdir depth-converter cd depth-converter # 3. स्क्रिप्ट और requirements.txt फ़ाइलें डालें # 4. वर्चुअल एनवायरनमेंट बनाएं python -m venv venv venv\Scripts\activate # 5. डिपेंडेंसीज़ इंस्टॉल करें pip install -r requirements.txt # 6. ffmpeg इंस्टॉल करें winget install ffmpeg # 7. एप्लिकेशन लॉन्च करें python depth_converter.py ``` ### macOS इंस्टॉलेशन और लॉन्च: ```bash # 1. Homebrew इंस्टॉल करें (यदि नहीं है) /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" # 2. Python इंस्टॉल करें brew install python@3.11 # 3. प्रोजेक्ट डायरेक्टरी बनाएं mkdir depth-converter cd depth-converter # 4. स्क्रिप्ट और requirements.txt फ़ाइलें डालें # 5. वर्चुअल एनवायरनमेंट बनाएं python3 -m venv venv source venv/bin/activate # 6. डिपेंडेंसीज़ इंस्टॉल करें pip install -r requirements.txt # 7. ffmpeg इंस्टॉल करें brew install ffmpeg # 8. एप्लिकेशन लॉन्च करें python depth_converter.py ``` ### GPU त्वरण विकल्प: **Windows (NVIDIA GPU के साथ):** ```bash pip uninstall torch torchvision pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118 ``` **macOS (Apple Silicon के साथ):** कोई अतिरिक्त कार्रवाई आवश्यक नहीं; MPS स्वचालित रूप से उपयोग किया जाएगा।