flowdetect 0.1.0__tar.gz

flowdetect-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.3
+Name: flowdetect
+Version: 0.1.0
+Summary: Add your description here
+Author: Charles Nichols
+Author-email: Charles Nichols <nik@vizionikmedia.com>
+Requires-Dist: numpy>=2.4.2
+Requires-Dist: opencv-contrib-python>=4.13.0.92
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+

flowdetect-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "flowdetect"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "Charles Nichols", email = "nik@vizionikmedia.com" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "numpy>=2.4.2",
+    "opencv-contrib-python>=4.13.0.92",
+]
+
+[project.scripts]
+flowdetect = "flowdetect:main"
+
+[build-system]
+requires = ["uv_build>=0.10.7,<0.11.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "click>=8.3.1",
+]

flowdetect-0.1.0/src/flowdetect/__init__.py

@@ -0,0 +1,4 @@
+from .main import cli
+
+if __name__ == "__main__":
+    cli()

flowdetect-0.1.0/src/flowdetect/main.py

@@ -0,0 +1,173 @@
+"""
+Video Analyzer CLI
+
+This application provides tools for analyzing video files using Optical Flow techniques.
+It leverages the Click framework to provide a professional, POSIX-compliant interface.
+"""
+
+import cv2
+import numpy as np
+import click
+import sys
+
+@click.group()
+def cli():
+    """
+    A professional Command-Line Interface for video motion analysis.
+    
+    This tool provides access to both Sparse and Dense Optical Flow algorithms 
+    for tracking features and detecting high-motion highlights.
+    """
+    pass
+
+@cli.command(name='track-sparse')
+@click.argument('video_path', type=click.Path(exists=True, readable=True, dir_okay=False))
+def track_sparse(video_path):
+    """
+    Track specific points across video frames.
+
+    This command uses Lucas Kanade Sparse Optical Flow to find and track 
+    the strongest corners in the image. It is highly useful for stabilizing 
+    shaky footage or tracking a specific subject to keep them centered.
+    """
+    click.echo(f"Starting Sparse Optical Flow on {video_path}...")
+    click.echo("Press 'q' or 'ESC' in the video window to quit.")
+
+    cap = cv2.VideoCapture(video_path)
+
+    # Parameters for ShiTomasi corner detection
+    feature_params = dict(
+        maxCorners=100,
+        qualityLevel=0.3,
+        minDistance=7,
+        blockSize=7
+    )
+
+    # Parameters for Lucas Kanade optical flow
+    lk_params = dict(
+        winSize=(15, 15),
+        maxLevel=2,
+        criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03)
+    )
+
+    # Create random colors for drawing tracks
+    color = np.random.randint(0, 255, (100, 3))
+
+    ret, old_frame = cap.read()
+    if not ret:
+        click.echo("Error: Could not read the video file.", err=True)
+        sys.exit(1)
+
+    old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
+    p0 = cv2.goodFeaturesToTrack(old_gray, mask=None, **feature_params)
+
+    # Create a mask image for drawing purposes
+    mask = np.zeros_like(old_frame)
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+            
+        frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+        # Calculate optical flow
+        p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)
+
+        # Select good points
+        if p1 is not None:
+            good_new = p1[st == 1]
+            good_old = p0[st == 1]
+
+            # Draw the tracks
+            for i, (new, old) in enumerate(zip(good_new, good_old)):
+                a, b = new.ravel()
+                c, d = old.ravel()
+                # Draw line for motion history
+                mask = cv2.line(mask, (int(a), int(b)), (int(c), int(d)), color[i].tolist(), 2)
+                # Draw dot for current position
+                frame = cv2.circle(frame, (int(a), int(b)), 5, color[i].tolist(), -1)
+            
+        img = cv2.add(frame, mask)
+        cv2.imshow('Sparse Optical Flow Tracker', img)
+
+        k = cv2.waitKey(30) & 0xff
+        if k == 27 or k == ord('q'):
+            break
+
+        # Update the previous frame and previous points
+        old_gray = frame_gray.copy()
+        if p1 is not None:
+            p0 = good_new.reshape(-1, 1, 2)
+
+    cv2.destroyAllWindows()
+    cap.release()
+    click.echo("Sparse tracking completed.")
+
+
+@cli.command(name='detect-dense')
+@click.argument('video_path', type=click.Path(exists=True, readable=True, dir_okay=False))
+@click.option('--threshold', '-t', default=5.0, type=click.FloatRange(min=0.0), help='Motion intensity threshold required to flag a highlight.')
+def detect_dense(video_path, threshold):
+    """
+    Analyze video for global energy highlights.
+
+    This command calculates motion for every pixel using Farneback Dense Optical Flow. 
+    It is computationally heavier but allows the system to detect global energy changes 
+    such as applause, laughter, or rapid movement.
+    """
+    click.echo(f"Analyzing {video_path} for high motion events (Threshold: {threshold})...")
+    click.echo("Press 'q' or 'ESC' in the video window to quit.")
+
+    cap = cv2.VideoCapture(video_path)
+    
+    ret, frame1 = cap.read()
+    if not ret:
+        click.echo("Error: Could not read the video file.", err=True)
+        sys.exit(1)
+
+    prvs = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
+    hsv = np.zeros_like(frame1)
+    hsv[..., 1] = 255
+
+    while True:
+        ret, frame2 = cap.read()
+        if not ret:
+            break
+            
+        next_frame = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
+
+        # Calculate Dense Optical Flow
+        flow = cv2.calcOpticalFlowFarneback(prvs, next_frame, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+
+        # Convert Cartesian coordinates to Polar coordinates
+        mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
+
+        # Visualization
+        hsv[..., 0] = ang * 180 / np.pi / 2
+        hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
+        bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+
+        # Calculate the mean motion intensity of the frame
+        avg_motion = np.mean(mag)
+        timestamp = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
+
+        if avg_motion > threshold:
+            click.echo(f"Highlight Detected at {timestamp:.2f} seconds (Intensity: {avg_motion:.2f})")
+            # Draw a red border to visualize the detection
+            cv2.rectangle(bgr, (0, 0), (bgr.shape[1], bgr.shape[0]), (0, 0, 255), 10)
+
+        cv2.imshow('Dense Optical Flow Highlight Detector', bgr)
+
+        k = cv2.waitKey(30) & 0xff
+        if k == 27 or k == ord('q'):
+            break
+
+        prvs = next_frame
+
+    cap.release()
+    cv2.destroyAllWindows()
+    click.echo("Highlight detection completed.")
+
+if __name__ == "__main__":
+    cli()