Feature: Add professional video stabilization (2-pass Lucas-Kanade + Moving Average)

filters.py

@@ -959,6 +959,276 @@ def process_video_subtitle(video_path, output_path, progress_callback=None):
             try: os.remove(temp_audio_path)
             except: pass
 
+# ============================================================
+#  VIDEO STABILIZATSIYA (Professional 2-Pass)
+# ============================================================
+
+def process_video_stabilize(video_path, output_path, progress_callback=None, smoothing_radius=30):
+    """Titrovchi videoni barqarorlashtiradi (2-pass: motion analysis + smooth trajectory).
+    
+    Algoritm:
+    1-pass: Kadrlar orasidagi harakatni aniqlash (Lucas-Kanade Optical Flow + Affine)
+    2-pass: Harakatlar trajectoryasini moving-average bilan tekislash
+    Natija: Titrash yo'qoladi, video silliq ko'rinadi.
+    """
+    cap = None
+    writer = None
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            logger.error(f"Stabilize: Video ochilmadi: {video_path}")
+            return None
+        
+        fps = cap.get(cv2.CAP_PROP_FPS) or 24
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        if total_frames < 10:
+            logger.warning("Video juda qisqa — stabilizatsiya mumkin emas.")
+            cap.release()
+            return None
+        
+        logger.info(f"Stabilize: {total_frames} kadr, {fps} FPS, {width}x{height}")
+        
+        # ============= PASS 1: Motion Analysis =============
+        # Har bir kadr juftligi orasidagi siljish (dx, dy, da) ni hisoblash
+        
+        transforms = []  # [(dx, dy, da), ...]
+        
+        ret, prev_frame = cap.read()
+        if not ret:
+            cap.release()
+            return None
+        
+        prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
+        
+        # Feature detection parametrlari (Shi-Tomasi corners)
+        feature_params = dict(
+            maxCorners=200,
+            qualityLevel=0.01,
+            minDistance=30,
+            blockSize=3
+        )
+        
+        frame_idx = 0
+        while True:
+            ret, curr_frame = cap.read()
+            if not ret:
+                break
+            
+            frame_idx += 1
+            curr_gray = cv2.cvtColor(curr_frame, cv2.COLOR_BGR2GRAY)
+            
+            # Feature'larni oldingi kadrda topish
+            prev_pts = cv2.goodFeaturesToTrack(prev_gray, **feature_params)
+            
+            if prev_pts is None or len(prev_pts) < 10:
+                # Feature kam — oʻzgarishsiz deb belgilash
+                transforms.append((0, 0, 0))
+                prev_gray = curr_gray
+                continue
+            
+            # Lucas-Kanade optical flow
+            curr_pts, status, _ = cv2.calcOpticalFlowPyrLK(
+                prev_gray, curr_gray, prev_pts, None,
+                winSize=(21, 21),
+                maxLevel=3,
+                criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 30, 0.01)
+            )
+            
+            # Faqat muvaffaqiyatli aniqlangan nuqtalar
+            valid = status.flatten() == 1
+            prev_valid = prev_pts[valid]
+            curr_valid = curr_pts[valid]
+            
+            if len(prev_valid) < 4:
+                transforms.append((0, 0, 0))
+                prev_gray = curr_gray
+                continue
+            
+            # Affine transformatsiya (siljish + aylanish)
+            mat, inliers = cv2.estimateAffinePartial2D(prev_valid, curr_valid)
+            
+            if mat is not None:
+                dx = mat[0, 2]  # X siljishi
+                dy = mat[1, 2]  # Y siljishi
+                da = np.arctan2(mat[1, 0], mat[0, 0])  # Aylanish burchagi
+                transforms.append((dx, dy, da))
+            else:
+                transforms.append((0, 0, 0))
+            
+            prev_gray = curr_gray
+            
+            if progress_callback and frame_idx % 10 == 0:
+                progress_callback(min(40, int(frame_idx / total_frames * 40)))
+        
+        cap.release()
+        
+        if not transforms:
+            logger.warning("Stabilize: Hech qanday harakat aniqlanmadi.")
+            return None
+        
+        if progress_callback:
+            progress_callback(45)
+        
+        # ============= Trajectory hisoblash va tekislash =============
+        
+        # Kumulyativ trajectory (yig'indi)
+        trajectory = []
+        cum_x, cum_y, cum_a = 0.0, 0.0, 0.0
+        for (dx, dy, da) in transforms:
+            cum_x += dx
+            cum_y += dy
+            cum_a += da
+            trajectory.append((cum_x, cum_y, cum_a))
+        
+        # Moving Average bilan tekislash
+        def moving_average(values, radius):
+            """1D moving average filter."""
+            n = len(values)
+            smoothed = np.zeros(n)
+            for i in range(n):
+                start = max(0, i - radius)
+                end = min(n, i + radius + 1)
+                smoothed[i] = np.mean(values[start:end])
+            return smoothed
+        
+        traj_x = np.array([t[0] for t in trajectory])
+        traj_y = np.array([t[1] for t in trajectory])
+        traj_a = np.array([t[2] for t in trajectory])
+        
+        # Trajectoryani tekislash (smoothing_radius=30 kadr)
+        smooth_x = moving_average(traj_x, smoothing_radius)
+        smooth_y = moving_average(traj_y, smoothing_radius)
+        smooth_a = moving_average(traj_a, smoothing_radius)
+        
+        # Tuzatish = tekislangan - asl trajectory
+        diff_x = smooth_x - traj_x
+        diff_y = smooth_y - traj_y
+        diff_a = smooth_a - traj_a
+        
+        # Yangilangan transformatsiyalar
+        smooth_transforms = []
+        for i, (dx, dy, da) in enumerate(transforms):
+            smooth_transforms.append((
+                dx + diff_x[i],
+                dy + diff_y[i],
+                da + diff_a[i]
+            ))
+        
+        if progress_callback:
+            progress_callback(55)
+        
+        # ============= PASS 2: Stabilizatsiya qo'llash =============
+        
+        cap = cv2.VideoCapture(video_path)
+        
+        # Border crop (qora chetlarni yo'qotish uchun 5% qirqish)
+        crop_ratio = 0.05
+        crop_x = int(width * crop_ratio)
+        crop_y = int(height * crop_ratio)
+        out_w = width - 2 * crop_x
+        out_h = height - 2 * crop_y
+        
+        temp_video_path = output_path + "_stab_temp.avi"
+        fourcc = cv2.VideoWriter_fourcc(*'MJPG')
+        writer = cv2.VideoWriter(temp_video_path, fourcc, fps, (out_w, out_h))
+        
+        # Birinchi kadrni o'qib tashlash (prev_frame)
+        ret, _ = cap.read()
+        if not ret:
+            cap.release()
+            return None
+        
+        # Birinchi kadrni asl holida yozish
+        first_cropped = _[crop_y:crop_y+out_h, crop_x:crop_x+out_w]
+        writer.write(first_cropped)
+        
+        for i in range(len(smooth_transforms)):
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            dx, dy, da = smooth_transforms[i]
+            
+            # Affine matritsa yaratish
+            cos_a = np.cos(da)
+            sin_a = np.sin(da)
+            transform_mat = np.array([
+                [cos_a, -sin_a, dx],
+                [sin_a, cos_a, dy]
+            ], dtype=np.float64)
+            
+            # Transformatsiyani qo'llash
+            stabilized = cv2.warpAffine(
+                frame, transform_mat, (width, height),
+                borderMode=cv2.BORDER_REFLECT_101
+            )
+            
+            # Chetlarni qirqish (qora border yo'qotish)
+            cropped = stabilized[crop_y:crop_y+out_h, crop_x:crop_x+out_w]
+            writer.write(cropped)
+            
+            if progress_callback and i % 5 == 0:
+                progress_callback(min(95, 55 + int(i / len(smooth_transforms) * 40)))
+        
+        cap.release()
+        writer.release()
+        
+        if progress_callback:
+            progress_callback(96)
+        
+        # ============= Audio'ni biriktirish =============
+        try:
+            original = VideoFileClip(video_path)
+            processed = VideoFileClip(temp_video_path)
+            
+            if original.audio is not None:
+                final = processed.with_audio(original.audio)
+                final.write_videofile(
+                    output_path, codec="libx264", audio_codec="aac",
+                    preset="medium", bitrate="6000k",
+                    threads=4, logger=None
+                )
+                final.close()
+            else:
+                processed.write_videofile(
+                    output_path, codec="libx264",
+                    preset="medium", bitrate="6000k",
+                    threads=4, logger=None
+                )
+            
+            original.close()
+            processed.close()
+        except Exception as audio_err:
+            logger.warning(f"Stabilize audio biriktirish xatosi: {audio_err}")
+            import shutil
+            shutil.move(temp_video_path, output_path)
+        
+        # Temp faylni tozalash
+        if os.path.exists(temp_video_path):
+            try: os.remove(temp_video_path)
+            except: pass
+        
+        if progress_callback:
+            progress_callback(99)
+        
+        logger.info(f"Video stabilizatsiya muvaffaqiyatli: {len(transforms)} kadr qayta ishlandi.")
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"Video stabilizatsiya xatosi: {e}")
+        return None
+    finally:
+        if cap is not None:
+            try: cap.release()
+            except: pass
+        if writer is not None:
+            try: writer.release()
+            except: pass
 
 # ============================================================
 #  PHASE 13: GLITCH / MIRROR / WATERMARK / BG REMOVE / STYLE

main.py

@@ -54,7 +54,7 @@ from filters import (
     process_video_bw, process_video_color_correct, process_video_remove_audio,
     process_video_trim, process_video_face_fix, process_video_auto_enhance,
     process_video_fps_boost, apply_nudenet_filter, process_video_nnsfw,
-    process_video_subtitle,
+    process_video_subtitle, process_video_stabilize,
     apply_glitch_filter, apply_mirror_filter, apply_watermark, apply_bg_remove,
     apply_style_transfer, apply_quality_boost,
     process_video_glitch, process_video_mirror, process_video_watermark,
@@ -361,7 +361,8 @@ async def handle_video(update: Update, context: ContextTypes.DEFAULT_TYPE):
                 InlineKeyboardButton("🪞 Oyna Effekt", callback_data=f"mr|v|{short_id}")
             ],
             [
-                InlineKeyboardButton("📱 Suv belgisi", callback_data=f"wm|v|{short_id}")
+                InlineKeyboardButton("📱 Suv belgisi", callback_data=f"wm|v|{short_id}"),
+                InlineKeyboardButton("📹 Stabilizatsiya", callback_data=f"stb|v|{short_id}")
             ],
             [
                 InlineKeyboardButton("🌐 Sub+O'zbek", callback_data=f"stuz|v|{short_id}"),
@@ -574,7 +575,8 @@ async def handle_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
                             "t": process_video_trim, "vf": process_video_face_fix,
                             "va": process_video_auto_enhance, "n": process_video_nnsfw,
                             "sub": process_video_subtitle, "gl": process_video_glitch,
-                            "mr": process_video_mirror, "wm": process_video_watermark
+                            "mr": process_video_mirror, "wm": process_video_watermark,
+                            "stb": process_video_stabilize
                         }
                         func = video_funcs.get(action)
                         if not func:
@@ -601,7 +603,7 @@ async def handle_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
                      "st_anime": "AI anime", "st_sketch": "AI sketch",
                      "st_oil": "AI oil paint", "st_cart": "AI cartoon",
                      "stuz": "sub+o'zbek", "stru": "sub+rus", "sten": "sub+english",
-                     "qb": "sifat+ pro"
+                     "qb": "sifat+ pro", "stb": "stabilizatsiya"
                 }.get(action, f"filter_{action}")
                 db.log_history(query.from_user.id, "photo" if m_type == "p" else "video", f_name, file_id)