SAM3 ट्यूटोरियल (Segment Everything Model 3): प्राइवेसी फ़िल्टर बनाएं

SAM 3, Meta का नया “segment anything” मॉडल है जो छोटे टेक्स्ट प्रॉम्प्ट्स या उदाहरणों के जरिए किसी भी कॉन्सेप्ट की हर इंस्टैंस को ढूंढ सकता है और छवियों व वीडियो में पिक्सल-एक्युरेट मास्क लौटाता है। यह चेहरों, लाइसेंस प्लेट्स या स्क्रीन जैसी चीज़ों को बिना हाथ से सेलेक्शन बनाए या पारम्परिक डिटेक्टर्स लिखे ब्लर करने जैसे प्रैग्मैटिक प्राइवेसी कार्यों के लिए बेहतरीन है।

इस ट्यूटोरियल में, हम SAM3 प्राइवेसी फ़िल्टर कोलैब में Gradio UI के साथ बनाएँगे। बस कोई इमेज या वीडियो अपलोड करें, एक प्रॉम्प्ट टाइप करें (जैसे faces, license plates), और SAM3 प्रति-ऑब्जेक्ट मास्क लौटाएगा ताकि हम सिर्फ़ उन्हीं पिक्सल्स को ब्लर कर सकें। हम सेटअप, मास्क जनरेशन, Gaussian ब्लर लगाना, और Gradio ऐप से फाइनल फ़ाइलें एक्सपोर्ट करने तक की पूरी प्रक्रिया समझेंगे।

SAM3 क्या है?

Segment Anything Model 3 (SAM 3) छवियों और वीडियो में ओपन-वोकैबुलरी डिटेक्शन, सेगमेंटेशन और ट्रैकिंग के लिए Meta का एकीकृत मॉडल है। हर क्लास के लिए अलग डिटेक्टर कॉन्फ़िगर करने के बजाय, आप छोटे वाक्यांशों या उदाहरणों से प्रॉम्प्ट करते हैं, और SAM 3 प्रति-इंस्टैंस मास्क लौटाता है।

बैकएंड में, SAM 3 एक टेक्स्ट एनकोडर और इमेज एनकोडर को DETR-स्टाइल डिटेक्टर और मेमोरी बैंक वाले SAM-2–व्युत्पन्न ट्रैकर के साथ फ़्यूज़ करता है। हर फ़्रेम पर, यह आपके प्रॉम्प्ट से कॉन्सेप्ट के मास्क डिटेक्ट करता है, ट्रैकर के ज़रिए मास्क को आगे प्रोपेगेट करता है, और नए डिटेक्टेड व ट्रैक्ड मास्क को उस फ़्रेम के फ़ाइनल आउटपुट में मर्ज करता है। 

स्रोत: SAM3 GitHub

SAM 3 मॉडल वेट्स, फ़ाइन-ट्यूनिंग कोड और इवैल्युएशन डेटा के साथ जारी किया गया है, जिसमें प्रॉम्प्टेबल कॉन्सेप्ट सेगमेंटेशन के लिए SA-Co बेंचमार्क शामिल है। 

Meta की रिपोर्ट्स में, यह ओपन-वोकैबुलरी सेगमेंटेशन पर छवियों और वीडियो में सशक्त बेसलाइन्स की तुलना में लगभग 2 गुना बेहतर प्रदर्शन दिखाता है, साथ ही SAM-2 की इंटरेक्टिव क्षमताएँ बनाए रखता है। 

इस ट्यूटोरियल में, हम उन्हीं SAM 3 मास्क को लेकर इमेज और वीडियो दोनों के लिए Gaussian-ब्लर वाला कंपोज़िट बनाएँगे, और इसे Gradio UI में रैप करेंगे। 

SAM3 उदाहरण: इमेज और वीडियो के लिए प्राइवेसी फ़िल्टर बनाना

इस सेक्शन में, हम एक साधारण Gradio UI में एम्बेडेड इमेज और वीडियो के लिए SAM3 के साथ प्राइवेसी फ़िल्टर बनाएँगे।

यह ऐसे काम करता है:

• सबसे पहले लक्ष्य टाइप करें, जैसे faces, license plates, computer screens, आदि
• SAM3 आपके टेक्स्ट प्रॉम्प्ट से मेल खाने वाली इंस्टैंसेज़ को सेगमेंट करता है और प्रति-ऑब्जेक्ट मास्क लौटाता है
• फिर हम उन मास्क का यूनियन लेते हैं और सिर्फ़ मास्क किए गए पिक्सल्स को ब्लर करते हैं
• इसके बाद Gradio UI कंपोनेंट से इमेज या वीडियो अपलोड करते हैं, ब्लर स्ट्रेंथ और कॉन्फिडेंस एडजस्ट करते हैं, और फिर प्रीव्यू व डाउनलोड करते हैं।

हम पूरी इम्प्लिमेंटेशन को छोटे-छोटे स्टेप्स में समझेंगे।

चरण 1:  निर्भरताएँ इंस्टॉल करें

डेमो चलाने से पहले, सुनिश्चित करें कि सभी प्रीरेक्विज़िट्स मौजूद हैं। Colab में SAM3 प्राइवेसी फ़िल्टर चलाने के लिए नवीनतम Transformers लाइब्रेरी के साथ UI, टेन्सर ऑप्स, इमेज और वीडियो I/O के लिए कुछ रनटाइम लाइब्रेरीज़ चाहिए। नीचे दिया स्निपेट एक ही बार में सब कुछ इंस्टॉल कर देता है।

import subprocess
import sys
import os
def install(package):
    subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", package])
print(" Installing latest Transformers")
install("git+https://github.com/huggingface/transformers.git")
pkgs = [
    "accelerate",
    "gradio",
    "numpy",
    "pillow",
    "torch",
    "torchvision",
    "imageio[ffmpeg]" 
]
for p in pkgs:
    install(p)संचालित द्वारा

प्रत्येक प्रीरेक्विज़िट क्या करता है, यह रहा:

• git+https://github.com/huggingface/transformers.git: यह सोर्स से नवीनतम Transformers लाइब्रेरी लाता है, ताकि Sam3Processor और Sam3Model क्लास उपलब्ध हों।
• torch और torchvision: ये टेन्सर कम्प्यूट और इमेज यूटिलिटीज़ हैं जो SAM3 का फॉरवर्ड पास चलाती हैं
• accelerate: यह Transformers द्वारा उपयोग किया जाने वाला इन्फ़रेंस हेल्पर है।
• gradio: मीडिया अपलोड करने और ब्लर्ड रिज़ल्ट्स का प्रीव्यू देखने के लिए हल्का वेब UI।
• numpy, pillow: ये मास्क/ब्लर कंपोज़िशन के लिए इमेज एरेज़ और PIL इमेज ऑप्स प्रदान करते हैं।
• imageio[ffmpeg]: यह वीडियो पढ़ता/लिखता है और वीडियो टैब के लिए MP4 (FFmpeg) एन्कोड करता है।

एक बार वातावरण सेट हो जाने और facebook/sam3 लोड हो जाने के बाद, डेमो आपको छोटे टेक्स्ट प्रॉम्प्ट्स के साथ सेगमेंट करने और साधारण Gradio ऐप के माध्यम से इमेज या वीडियो में प्राप्त मास्क को ब्लर करने देता है। 

नोट: यदि आप Colab में GPU का उपयोग करना चाहते हैं, तो इंस्टॉलेशन से पहले रनटाइम को GPU (T4/A100) पर सेट करें। तेज़ अनुभव के लिए मैंने Colab पर A100 GPU का उपयोग किया।

चरण 2:  इम्पोर्ट्स

वातावरण तैयार होने के साथ, उन लाइब्रेरीज़ को इम्पोर्ट करें जो UI, मॉडल इन्फ़रेंस, इमेज/वीडियो हैंडलिंग और टाइमिंग को पावर देती हैं। SAM3 प्राइवेसी फ़िल्टर के लिए आपको सिर्फ़ यही मॉड्यूल्स चाहिए।

import gradio as gr
import torch
import numpy as np
import imageio
from PIL import Image, ImageFilter
from transformers import Sam3Processor, Sam3Model
import timeसंचालित द्वारा

अब, Gradio वेब इंटरफ़ेस देता है, transformers लाइब्रेरी SAM3 चलाती है, और PyTorch GPU या CPU पर इन्फ़रेंस एक्ज़िक्यूट करता है। PIL इमेज लोड और एडिट करता है (Gaussian ब्लर सहित), NumPy मास्क एरेज़ मैनेज करता है, और imageio वीडियो फ़ाइलें पढ़ता और लिखता है।

अगले चरण में, हम मॉडल लोड करेंगे और एक छोटा इंजन बनाएँगे जो टेक्स्ट प्रॉम्प्ट्स को ऐसे मास्क में बदलेगा जिन्हें आप ब्लर कर सकें।

चरण 3: SAM3 लोड करें और मास्क प्रेडिक्ट करें

अब जबकि वातावरण तैयार है, आइए SAM3 को एक छोटे इंजन में रैप करें जो मॉडल को एक बार लोड करता है, मांग पर टेक्स्ट-प्रॉम्प्टेड इंस्टैंस सेगमेंटेशन चलाता है, और ब्लरिंग के लिए उपयोग होने वाले बाइनरी मास्क लौटाता है।

class Sam3PrivacyEngine:
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model = None
        self.processor = None
        print(f"Initializing SAM3 on {self.device}")
        try:
            self.model = Sam3Model.from_pretrained("facebook/sam3").to(self.device)
            self.processor = Sam3Processor.from_pretrained("facebook/sam3")
            print("SAM3 Loaded Successfully!")
        except Exception as e:
            print(f"Error loading SAM3: {e}")
    def predict_masks(self, image_pil, text_prompt, threshold=0.4):
        if self.model is None: return []
        inputs = self.processor(
            images=image_pil,
            text=text_prompt,
            return_tensors="pt"
        ).to(self.device)
        with torch.no_grad():
            outputs = self.model(**inputs)
        results = self.processor.post_process_instance_segmentation(
            outputs, 
            threshold=threshold, 
            mask_threshold=0.5, 
            target_sizes=inputs["original_sizes"].tolist()
        )[0]
        masks = []
        if "masks" in results:
            for i, mask_tensor in enumerate(results["masks"]):
                mask_np = (mask_tensor.cpu().numpy() * 255).astype(np.uint8)
                mask_pil = Image.fromarray(mask_np)
                masks.append(mask_pil)
        return masks
engine = Sam3PrivacyEngine()संचालित द्वारा

यह इंजन पाइपलाइन में कैसे फ़िट बैठता है, समझें:

• Sam3PrivacyEngine.init(): यह इनिशियलाइज़र सर्वश्रेष्ठ डिवाइस चुनता है (उपलब्ध होने पर CUDA, अन्यथा CPU), facebook/sam3 वेट्स और पेयर्ड Sam3Processor लोड करता है, और मॉडल को चुने गए डिवाइस पर मूव करता है ताकि इन्फ़रेंस कुशलता से चले।
• Sam3PrivacyEngine.predict_masks(): यह मेथड PIL इमेज और टेक्स्ट प्रॉम्प्ट से मॉडल इनपुट बनाता है, ग्रेडिएंट ओवरहेड से बचने के लिए torch.no_grad() के तहत फॉरवर्ड इन्फ़रेंस चलाता है, और post_process_instance_segmentation के साथ आउटपुट को पोस्ट-प्रोसेस करता है दे गए डिटेक्शन और मास्क थ्रेशहोल्ड्स तथा सही स्केलिंग के लिए ओरिजिनल टार्गेट साइज़ का उपयोग करते हुए। यह प्रति-इंस्टैंस सेगमेंटेशन मास्क लौटाता है जिन्हें टेन्सर से NumPy एरेज़ और फिर PIL “L” मास्क (8-बिट ग्रेस्केल इमेजेज़, मोड "L", जहाँ हर पिक्सल 0–255 का मान होता है) में कन्वर्ट किया जाता है, ताकि कंपोज़िटिंग हो सके।
• engine = Sam3PrivacyEngine(): यह लाइन एक सिंगल, रीउज़ेबल इंजन इंस्टैंस बनाती है ताकि SAM3 मॉडल एक बार लोड हो और इमेज या वीडियो फ़्रेम्स के लिए बिना री-इनिशियलाइज़ेशन के बार-बार कॉल किया जा सके।

इस सेल्फ-कॉन्टेन्ड इंजन के इनिशियलाइज़ होने के बाद, आप किसी भी इमेज और टेक्स्ट प्रॉम्प्ट को इंस्टैंस मास्क में बदल सकते हैं। अगले चरण में, हम इन्हीं मास्क का इस्तेमाल कर चयनित रूप से ब्लर लगाएंगे और सबकुछ Gradio UI में एम्बेड करेंगे।

चरण 4: ब्लरिंग लॉजिक

इस सेक्शन में, हम SAM3 के मास्क लेकर प्राइवेसी लागू करते हैं। यह सिर्फ़ मास्क की गई जगहों को ब्लर करता है और बाकी सब वैसा ही रखता है। हम एक रीउज़ेबल Gaussian ब्लर फ़ंक्शन से शुरू करेंगे, फिर इसे दो पाइपलाइन्स—एक इमेज के लिए और एक वीडियो के लिए—से जोड़ेंगे।

चरण 4.1: Gaussian ब्लर

यह हेल्पर एक इमेज और एक या अधिक PIL "L" मास्क लेता है, उन्हें एक सिंगल कंपोज़िट मास्क में ब्लेंड करता है, और इमेज की ब्लर्ड कॉपी को सिर्फ़ वहीं पेस्ट करता है जहाँ मास्क सफ़ेद (255) हो। 

def apply_blur_pure(image_pil, masks, blur_strength):
    if not masks:
        return image_pil
    radius = blur_strength
    blurred_image = image_pil.filter(ImageFilter.GaussianBlur(radius=radius))
    composite_mask = Image.new("L", image_pil.size, 0)
    for mask in masks:
        composite_mask.paste(255, (0, 0), mask=mask)
    final_image = image_pil.copy()
    final_image.paste(blurred_image, (0, 0), mask=composite_mask)
    return final_imageसंचालित द्वारा

यह फ़ंक्शन ऐसे काम करता है:

• GaussianBlur() पहले इमेज का पूरी तरह ब्लर्ड वर्ज़न बनाता है। वहीं composite_mask एक “L” (ग्रेस्केल) मास्क है जो काले रंग (0 = ओरिजिनल बनाए रखें) से इनिशियलाइज़ होता है। 
• हर SAM3 मास्क के लिए, हम उसे इस कंपोज़िट में पेस्ट करते हैं ताकि सफ़ेद पिक्सल्स (255) वहाँ इकट्ठे हों जहाँ ब्लर दिखना चाहिए। 
• आखिर में, हम composite_mask का उपयोग करके ब्लर्ड इमेज को ओरिजिनल पर पेस्ट करते हैं, ताकि सिर्फ़ सफ़ेद क्षेत्रों में ब्लर हो।
• final_image.paste() मेथड सिर्फ़ मास्क किए गए पिक्सल्स को बदलता है, बाकी को अनछुआ छोड़ देता है ताकि विज़ुअल क्वालिटी बनी रहे।

सिर्फ़ एक कॉल में, आप चेहरों, स्क्रीन, प्लेट्स जैसी किसी भी रीजन को ब्लर कर सकते हैं, जबकि बैकग्राउंड जैसा है वैसा रहता है।

चरण 4.2: इमेज पाइपलाइन

यह सब-स्टेप एंड-टू-एंड इमेज फ़्लो को कवर करता है—इनपुट नॉर्मलाइज़ करने से लेकर SAM3 से मास्क पाने, फिर मास्क किए पिक्सल्स को ब्लर करने और अंत में परिणाम लौटाने तक।

def process_image(input_img, text_prompt, blur_strength, confidence):
    if input_img is None: return None, None
    if isinstance(input_img, np.ndarray):
        image_pil = Image.fromarray(input_img).convert("RGB")
    else:
        image_pil = input_img.convert("RGB")
    masks = engine.predict_masks(image_pil, text_prompt, confidence)
    result_pil = apply_blur_pure(image_pil, masks, blur_strength)
    output_path = "privacy_image.png"
    result_pil.save(output_path)
    return np.array(result_pil), output_pathसंचालित द्वारा

हम इमेजेज़ को निम्नलिखित स्टेप-बाय-स्टेप पाइपलाइन से हैंडल करते हैं:

• सबसे पहले किसी भी Gradio NumPy एरे को PIL RGB इमेज में कन्वर्ट करते हैं ताकि प्रोसेसिंग सुसंगत रहे।
• फिर, दिए गए text_prompt के लिए SAM3 इंस्टैंस मास्क पाने को engine.predict_masks() कॉल करते हैं।
• apply_blur_pure() फ़ंक्शन को चुनी हुई blur_strength के साथ लागू करते हैं, ताकि सिर्फ़ मास्क्ड रीजन ही ब्लर हों।
• प्रोसेसिंग के बाद, परिणाम को png में सेव करते हैं और एक NumPy एरे तथा डाउनलोडेबल फ़ाइल दोनों लौटाते हैं।

इमेज फ़्लो पूरा होने के साथ, अब हम वीडियो पाइपलाइन पर चलते हैं।

चरण 4.3: वीडियो पाइपलाइन

वीडियो फ़्लो इमेज पथ का ही प्रतिबिंब है, लेकिन imageio के साथ फ़्रेम-बाय-फ़्रेम स्ट्रीम होता है। हर फ़्रेम के लिए, हम सेगमेंट करते हैं, मास्क्ड क्षेत्रों को ब्लर करते हैं, और H.264-एन्कोडेड MP4 फ़ाइल में लिखते हैं।

def process_video(video_path, text_prompt, blur_strength, confidence, max_frames):
    if not video_path: return None, None
    try:
        reader = imageio.get_reader(video_path)
        meta = reader.get_meta_data()
        fps = meta.get('fps', 24)  
        output_path = "privacy_video.mp4"
        writer = imageio.get_writer(
            output_path, 
            fps=fps, 
            codec='libx264', 
            pixelformat='yuv420p',
            macro_block_size=1
        )  
        print("Starting video processing...")
        for i, frame in enumerate(reader):
            if i >= max_frames:
                break  
            frame_pil = Image.fromarray(frame).convert("RGB")
            masks = engine.predict_masks(frame_pil, text_prompt, confidence)
            processed_pil = apply_blur_pure(frame_pil, masks, blur_strength)
            writer.append_data(np.array(processed_pil))
            if i % 10 == 0:
                print(f"Processed frame {i}...")
        writer.close()
        reader.close()
        print("Video processing complete.")
        return output_path, output_path
    except Exception as e:
        print(f"Error: {e}")
        return None, Noneसंचालित द्वारा

हम वीडियो को निम्नलिखित पाइपलाइन से हैंडल करते हैं:

• पहले imageio.get_reader() से फ़ाइल खोलते हैं, फिर फ़्रेम्स पर इटरेट करते हैं, और मेटाडेटा से FPS पढ़ते हैं (न मिलने पर 24 डिफ़ॉल्ट)।
• इसके बाद, हर फ़्रेम को PIL इमेज में कन्वर्ट करते हैं, engine.predict_masks() के जरिए SAM3 से मास्क प्रेडिक्ट करते हैं, और apply_blur_pure() से मास्क्ड रीजन को ब्लर करते हैं।
• फिर हर प्रोसेस्ड फ़्रेम को MP4 राइटर में अपेंड करते हैं, जिसे pixelformat='yuv420p' (विस्तृत कम्पैटिबिलिटी) और macro_block_size=1 (एलाइनमेंट आर्टिफ़ैक्ट्स से बचने) के साथ कॉन्फ़िगर किया गया है।
• प्रोसेसिंग के बाद, हम जान-बूझकर आउटपुट को कुछ फ़्रेम्स पर रोकते हैं, जो डिफ़ॉल्ट रूप से 60 फ़्रेम्स (~2 सेकंड) है, जिससे Colab पर तेज़ टेस्ट हों और टाइमआउट से बचा जा सके।

इस वीडियो फ़्लो के साथ, आप मीटिंग रिकॉर्डिंग्स, डैशकैम क्लिप्स या स्क्रीन कैप्चर्स में संवेदनशील क्षेत्रों को सिर्फ़ एक साधारण टेक्स्ट प्रॉम्प्ट से ब्लर कर सकते हैं।

चरण 5: Gradio इन्फ़रेंस

अब जब मास्किंग और ब्लरिंग तैयार है, तो हम सबकुछ एक हल्के Gradio UI में रैप करेंगे ताकि कोई भी इमेज या वीडियो अपलोड कर सके, टेक्स्ट प्रॉम्प्ट दे सके और आउटपुट डाउनलोड कर सके।

with gr.Blocks(title="SAM3 Privacy Filter", theme=gr.themes.Soft()) as demo:
    gr.Markdown("# SAM3 Privacy Filter")
    gr.Markdown("Auto-detect and blur faces/objects.")
    with gr.Tabs():
        with gr.Tab("Image"):
            with gr.Row():
                with gr.Column():
                    im_input = gr.Image(label="Input Image", type="numpy")
                    im_prompt = gr.Textbox(label="Text Prompt", value="faces")
                    im_blur = gr.Slider(5, 100, value=30, label="Blur Strength")
                    im_conf = gr.Slider(0.1, 1.0, value=0.4, label="Confidence")
                    im_btn = gr.Button("Blur Image", variant="primary")
                with gr.Column():
                    im_output = gr.Image(label="Preview")
                    im_dl = gr.File(label="Download Image")   
            im_btn.click(process_image, [im_input, im_prompt, im_blur, im_conf], [im_output, im_dl])
        with gr.Tab("Video"):
            with gr.Row():
                with gr.Column():
                    vid_input = gr.Video(label="Input Video")
                    vid_prompt = gr.Textbox(label="Text Prompt", value="faces")
                    vid_blur = gr.Slider(5, 100, value=30, label="Blur Strength")
                    vid_conf = gr.Slider(0.1, 1.0, value=0.4, label="Confidence")
                    vid_limit = gr.Slider(10, 300, value=60, step=10, label="Max Frames")
                    vid_btn = gr.Button("Blur Video", variant="primary")
                with gr.Column():
                    vid_output = gr.Video(label="Preview")
                    vid_dl = gr.File(label="Download Video")
            vid_btn.click(process_video, [vid_input, vid_prompt, vid_blur, vid_conf, vid_limit], [vid_output, vid_dl])
demo.launch(share=True, debug=True)संचालित द्वारा

Gradio ऐप SAM3 मास्किंग और ब्लरिंग पाइपलाइन को एक साधारण वेब UI में एम्बेड करता है, इस तरह:

• ऐप शेल (gr.Blocks): यह ब्लॉक एक सिंगल-पेज Gradio ऐप बनाता है जिसमें एक शीर्षक और दो टैब होते हैं—एक इमेज के लिए और एक वीडियो के लिए—ताकि उपयोगकर्ता पेज छोड़े बिना मोड बदल सकें।
• इमेज टैब: इनपुट्स में इमेज अपलोडर, टेक्स्ट प्रॉम्प्ट के लिए टेक्स्टबॉक्स, और ब्लर स्ट्रेंथ व कॉन्फिडेंस के लिए स्लाइडर्स शामिल हैं। आउटपुट फ़ील्ड्स प्रोसेस्ड प्रीव्यू और डाउनलोडेबल PNG दिखाते हैं, वहीं Blur Image बटन सबकुछ process_image तक रूट करता है, जो मास्क के लिए SAM3 को कॉल करता है और सिर्फ़ मास्क्ड पिक्सल्स पर Gaussian ब्लर लगाता है।
• वीडियो टैब: वीडियो ब्लरिंग के लिए, इनपुट्स में वीडियो अपलोडर, टेक्स्ट प्रॉम्प्ट के लिए टेक्स्टबॉक्स, ब्लर स्ट्रेंथ और कॉन्फिडेंस के स्लाइडर्स, और त्वरित डेमो के लिए मैक्स-फ़्रेम्स कैप शामिल है। आउटपुट फ़ील्ड्स इनलाइन प्रीव्यू और डाउनलोडेबल MP4 देते हैं, जबकि Blur Video बटन process_video को इन्कोक करता है, जो फ़्रेम्स पर इटरेट कर मास्क प्रेडिक्ट करता है, मास्क्ड रीजन ब्लर करता है, और H.264 वीडियो एन्कोड करता है।
• लॉन्च: demo.launch() मेथड ऐप शुरू करता है, शेयर करने योग्य लिंक बनाता है, और डिबगिंग सक्षम होने पर विस्तृत स्टैक ट्रेस दिखाता है।

अब हमारा SAM3 प्राइवेसी फ़िल्टर मीडिया (इमेज/वीडियो) अपलोड करने, प्रॉम्प्ट और थ्रेशहोल्ड सेट करने और ब्लर्ड आउटपुट्स एक्सपोर्ट करने के लिए तैयार है।

नोट: इस डेमो में सभी इमेज और वीडियो Pexels.com से लिए गए हैं और उपयोग के लिए निःशुल्क हैं।