dynamo-figures 0.3.2__tar.gz

dynamo_figures-0.3.2/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: dynamo-figures
+Version: 0.3.2
+Summary: A Python package for figure generation
+Author: Dynamic Mobility Lab at Georgia Tech
+Author-email: Neil Janwani <njanwani@gatech.edu>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: opencv-python>=4.0.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: tqdm>=4.0.0
+Requires-Dist: Pillow>=8.0.0
+Requires-Dist: qrcode>=7.0.0
+Provides-Extra: gpu
+Requires-Dist: onnxruntime>=1.17; sys_platform == "darwin" and extra == "gpu"
+Requires-Dist: onnxruntime-gpu[cuda,cudnn]>=1.21; sys_platform != "darwin" and extra == "gpu"
+Provides-Extra: svg
+Requires-Dist: cairosvg>=2.5.0; extra == "svg"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+
+# Dynamo Figures
+
+A Python package for creating composite images from videos. This tool extracts frames from a video and merges them using various composition modes to create stunning visual effects.
+
+## Installation
+
+### Install from Git
+```bash
+# Install directly from GitHub
+pip install git+ssh://git@github.com/dynamicmobility/dynamo_figures.git
+```
+
+### Install from Local Directory
+```bash
+# From within the project directory
+git clone git@github.com:dynamicmobility/dynamo_figures.git
+cd dynamo_figures
+pip install -e .
+```
+
+## Usage
+
+### Command-Line Interface
+
+After installation, you can use the `dynamo-composite-image` command:
+
+#### 1. VAR Mode (Recommended)
+Uses pixels that are furthest from the mean of the image, creating dynamic composite effects.
+
+```bash
+dynamo-composite-image --video_path ./example/video.mp4 --start_t 0.0 --end_t 99.0 --skip_frame 2 --mode VAR --alpha 0.4 --output ./example/composite.png
+```
+![image-20230909002327059](./example/image-20230909002327059.png)
+
+#### 2. MIN Mode
+Keeps the darkest pixels from all frames.
+
+```bash
+dynamo-composite-image --video_path ./example/video.mp4 --start_t 0.0 --end_t 99.0 --skip_frame 2 --mode MIN --output ./example/composite.png
+```
+![image-20230909002235029](./example/image-20230909002235029.png)
+
+#### 3. MAX Mode
+Keeps the lightest pixels from all frames.
+
+```bash
+dynamo-composite-image --video_path ./example/video.mp4 --start_t 0.0 --end_t 99.0 --skip_frame 2 --mode MAX --output ./example/composite.png
+```
+![image-20230909002149494](./example/image-20230909002149494.png)
+
+### Python API
+
+You can also use the package programmatically in your Python scripts:
+
+```python
+from dynamo_figures import CompositeImage, CompositeMode
+import cv2
+
+# Create a composite image with VAR mode
+merger = CompositeImage(
+    mode=CompositeMode.MAX_VARIATION,
+    video_path="./example/video.mp4",
+    start_t=0.0,
+    end_t=99.0,
+    skip_frame=2,
+    alpha=0.4,
+    disable_pbar=False  # Set to True to disable the progress bar
+)
+
+# Generate the composite
+result = merger.merge_images()
+
+# Save the result
+cv2.imwrite("output.jpg", result)
+```
+
+### Alternative Command-Line Methods
+
+If you haven't installed the package, you can still run it:
+
+```bash
+# Run as a Python module
+python -m dynamo_figures.composite_image --video_path ./example_video.mp4 --mode VAR
+
+# Or run directly
+python src/dynamo_figures/composite_image.py --video_path ./example_video.mp4 --mode VAR
+```
+
+## Parameters
+
+* `--video_path` (required): Path to the input video file
+* `--start_t`: Start time in seconds (default: 0)
+* `--end_t`: End time in seconds (default: 999999)
+* `--skip_frame`: Number of frames to skip when extracting frames. Use `1` to process every frame (default: 1)
+* `--mode`: Composition mode, three options available:
+  * `VAR` (Recommended): Uses pixels furthest from the mean, creating dynamic variation effects
+  * `MAX`: Keeps the lightest pixels across all frames
+  * `MIN`: Keeps the darkest pixels across all frames
+* `--alpha`: Alpha blending factor for intermediate frames, range 0.0-1.0 (default: 0.5)
+* `--disable_pbar`: Disable the progress bar when merging images (flag, no value needed)
+* `--output`: Custom output file path (default: saves as `<video_name>.jpg` in the same directory as the input video)
+
+## Dependencies
+
+- Python >= 3.8
+- opencv-python >= 4.0.0
+- numpy >= 1.20.0
+- tqdm >= 4.0.0
+
+## License
+
+All Rights Reserved 2023
+
+## Credits
+
+Original Author: renyunfan (renyf@connect.hku.hk)

dynamo_figures-0.3.2/README.md

@@ -0,0 +1,116 @@
+# Dynamo Figures
+
+A Python package for creating composite images from videos. This tool extracts frames from a video and merges them using various composition modes to create stunning visual effects.
+
+## Installation
+
+### Install from Git
+```bash
+# Install directly from GitHub
+pip install git+ssh://git@github.com/dynamicmobility/dynamo_figures.git
+```
+
+### Install from Local Directory
+```bash
+# From within the project directory
+git clone git@github.com:dynamicmobility/dynamo_figures.git
+cd dynamo_figures
+pip install -e .
+```
+
+## Usage
+
+### Command-Line Interface
+
+After installation, you can use the `dynamo-composite-image` command:
+
+#### 1. VAR Mode (Recommended)
+Uses pixels that are furthest from the mean of the image, creating dynamic composite effects.
+
+```bash
+dynamo-composite-image --video_path ./example/video.mp4 --start_t 0.0 --end_t 99.0 --skip_frame 2 --mode VAR --alpha 0.4 --output ./example/composite.png
+```
+![image-20230909002327059](./example/image-20230909002327059.png)
+
+#### 2. MIN Mode
+Keeps the darkest pixels from all frames.
+
+```bash
+dynamo-composite-image --video_path ./example/video.mp4 --start_t 0.0 --end_t 99.0 --skip_frame 2 --mode MIN --output ./example/composite.png
+```
+![image-20230909002235029](./example/image-20230909002235029.png)
+
+#### 3. MAX Mode
+Keeps the lightest pixels from all frames.
+
+```bash
+dynamo-composite-image --video_path ./example/video.mp4 --start_t 0.0 --end_t 99.0 --skip_frame 2 --mode MAX --output ./example/composite.png
+```
+![image-20230909002149494](./example/image-20230909002149494.png)
+
+### Python API
+
+You can also use the package programmatically in your Python scripts:
+
+```python
+from dynamo_figures import CompositeImage, CompositeMode
+import cv2
+
+# Create a composite image with VAR mode
+merger = CompositeImage(
+    mode=CompositeMode.MAX_VARIATION,
+    video_path="./example/video.mp4",
+    start_t=0.0,
+    end_t=99.0,
+    skip_frame=2,
+    alpha=0.4,
+    disable_pbar=False  # Set to True to disable the progress bar
+)
+
+# Generate the composite
+result = merger.merge_images()
+
+# Save the result
+cv2.imwrite("output.jpg", result)
+```
+
+### Alternative Command-Line Methods
+
+If you haven't installed the package, you can still run it:
+
+```bash
+# Run as a Python module
+python -m dynamo_figures.composite_image --video_path ./example_video.mp4 --mode VAR
+
+# Or run directly
+python src/dynamo_figures/composite_image.py --video_path ./example_video.mp4 --mode VAR
+```
+
+## Parameters
+
+* `--video_path` (required): Path to the input video file
+* `--start_t`: Start time in seconds (default: 0)
+* `--end_t`: End time in seconds (default: 999999)
+* `--skip_frame`: Number of frames to skip when extracting frames. Use `1` to process every frame (default: 1)
+* `--mode`: Composition mode, three options available:
+  * `VAR` (Recommended): Uses pixels furthest from the mean, creating dynamic variation effects
+  * `MAX`: Keeps the lightest pixels across all frames
+  * `MIN`: Keeps the darkest pixels across all frames
+* `--alpha`: Alpha blending factor for intermediate frames, range 0.0-1.0 (default: 0.5)
+* `--disable_pbar`: Disable the progress bar when merging images (flag, no value needed)
+* `--output`: Custom output file path (default: saves as `<video_name>.jpg` in the same directory as the input video)
+
+## Dependencies
+
+- Python >= 3.8
+- opencv-python >= 4.0.0
+- numpy >= 1.20.0
+- tqdm >= 4.0.0
+
+## License
+
+All Rights Reserved 2023
+
+## Credits
+
+Original Author: renyunfan (renyf@connect.hku.hk)

dynamo_figures-0.3.2/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dynamo-figures"
+version = "0.3.2"
+authors = [
+  { name="Dynamic Mobility Lab at Georgia Tech" },
+  { name="Neil Janwani", email="njanwani@gatech.edu" },
+]
+description = "A Python package for figure generation"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "opencv-python>=4.0.0",
+    "numpy>=1.20.0",
+    "tqdm>=4.0.0",
+    "Pillow>=8.0.0",
+    "qrcode>=7.0.0",
+]
+[project.scripts]
+dynamo-composite-image = "dynamo_figures.composite_image:main"
+dynamo-pic-from-video = "dynamo_figures.pic_from_video:main"
+dynamo-video-to-gif = "dynamo_figures.video_to_gif:main"
+dynamo-qr-code = "dynamo_figures.qr_code:main"
+dynamo-blur-faces = "dynamo_figures.blur_faces.cli:main"
+dynamo-tex2img = "dynamo_figures.tex2img:main"
+
+[project.optional-dependencies]
+gpu = [
+    "onnxruntime>=1.17; sys_platform == 'darwin'",
+    "onnxruntime-gpu[cuda,cudnn]>=1.21; sys_platform != 'darwin'",
+]
+svg = [
+    "cairosvg>=2.5.0",
+]
+dev = [
+    "pytest>=7.0.0",
+    "black>=22.0.0",
+    "flake8>=4.0.0",
+]
+
+[tool.setuptools.package-data]
+dynamo_figures = ["blur_faces/models/*.onnx"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

dynamo_figures-0.3.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dynamo_figures-0.3.2/src/dynamo_figures/__init__.py

@@ -0,0 +1,13 @@
+"""
+dynamo_figures - A Python package for dynamic figure generation
+"""
+
+__version__ = "0.3.2"
+
+from dynamo_figures.composite_image import CompositeImage, CompositeMode
+from dynamo_figures.video_to_gif import VideoToGif
+from dynamo_figures.qr_code import QRCode
+from dynamo_figures.blur_faces import FaceBlur
+from dynamo_figures.tex2img import TexToImage
+
+__all__ = ["CompositeImage", "CompositeMode", "VideoToGif", "QRCode", "FaceBlur", "TexToImage", "__version__"]

dynamo_figures-0.3.2/src/dynamo_figures/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running composite_image as a module."""
+
+from dynamo_figures.composite_image import main
+
+if __name__ == "__main__":
+    main()

dynamo_figures-0.3.2/src/dynamo_figures/blur_faces/__init__.py

@@ -0,0 +1,18 @@
+"""
+    Package: dynamo_figures.blur_faces
+    Description: Anonymize faces in photos and videos, fully locally.
+
+    Modules:
+        core       FaceBlur, the high-level image/video API
+        detectors  YuNet detection on CPU (OpenCV) or GPU (ONNX Runtime)
+        tracking   Frame-to-frame box smoothing and hold for videos
+        obscure    Blur / pixelate / fill rendering
+        video_io   Threaded frame reading and ffmpeg encoding
+        cli        The dynamo-blur-faces command-line tool
+"""
+
+from dynamo_figures.blur_faces.core import FaceBlur
+from dynamo_figures.blur_faces.detectors import gpu_provider
+from dynamo_figures.blur_faces.tracking import FaceTracker
+
+__all__ = ["FaceBlur", "FaceTracker", "gpu_provider"]

dynamo_figures-0.3.2/src/dynamo_figures/blur_faces/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running blur_faces as a module: python -m dynamo_figures.blur_faces"""
+
+from dynamo_figures.blur_faces.cli import main
+
+if __name__ == "__main__":
+    main()

dynamo_figures-0.3.2/src/dynamo_figures/blur_faces/cli.py

@@ -0,0 +1,150 @@
+"""
+    File: cli.py
+    Description: Command-line interface for the dynamo-blur-faces tool.
+    Blurs, pixelates, or covers faces in a photo or video, fully locally.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from dynamo_figures.blur_faces.core import FaceBlur
+
+IMAGE_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.bmp', '.tif', '.tiff', '.webp'}
+VIDEO_EXTENSIONS = {'.mp4', '.mov', '.avi', '.mkv', '.m4v', '.webm', '.wmv'}
+
+
+def main():
+    """Main function for command-line interface."""
+    parser = argparse.ArgumentParser(
+        prog='dynamo-blur-faces',
+        description='Blur, pixelate, or cover faces in a photo or video. Runs fully locally.',
+        epilog='-'
+    )
+    parser.add_argument('--input', type=str, required=True,
+                        help='path of input image or video file.')
+    parser.add_argument('--output', type=str, default=None,
+                        help='output file path (default: same directory as input with _blurred suffix)')
+    parser.add_argument('--style', default='blur', choices=FaceBlur.STYLES,
+                        help='how to obscure faces (default: blur)')
+    parser.add_argument('--shape', default='ellipse', choices=FaceBlur.SHAPES,
+                        help='shape of the obscured region (default: ellipse)')
+    parser.add_argument('--padding', type=float, default=0.25,
+                        help='fraction to enlarge each face box on every side (default: 0.25)')
+    parser.add_argument('--blur_strength', type=float, default=0.5,
+                        help='blur kernel size as a fraction of face size, for --style blur (default: 0.5)')
+    parser.add_argument('--pixel_blocks', type=int, default=10,
+                        help='number of mosaic blocks across each face, for --style pixelate (default: 10)')
+    parser.add_argument('--fill_color', type=str, default='black',
+                        help='color name or hex code, for --style fill (default: black)')
+    parser.add_argument('--score_threshold', type=float, default=0.6,
+                        help='minimum detection confidence 0..1; lower catches more faces but more false positives (default: 0.6)')
+    parser.add_argument('--nms_threshold', type=float, default=0.3,
+                        help='overlap threshold for merging duplicate detections (default: 0.3)')
+    parser.add_argument('--detect_max_dim', type=int, default=2048,
+                        help='downscale so the longest side is at most this before detection; '
+                             'raise for tiny faces, lower for speed, 0 = full resolution (default: 2048)')
+    parser.add_argument('--device', default='auto', choices=FaceBlur.DEVICES,
+                        help='detection device: gpu needs onnxruntime (CoreML) or onnxruntime-gpu (CUDA); '
+                             'auto uses the GPU when available (default: auto)')
+    parser.add_argument('--batch_size', type=int, default=8,
+                        help='video only: frames detected per batch (default: 8)')
+    parser.add_argument('--workers', type=int, default=None,
+                        help='video only: CPU threads for detection/blurring (default: number of cores)')
+    parser.add_argument('--hold_frames', type=int, default=5,
+                        help='video only: keep obscuring a face for this many frames after it is lost (default: 5)')
+    parser.add_argument('--smoothing', type=float, default=0.5,
+                        help='video only: box smoothing between frames, 0..1 (0 = off; higher is steadier '
+                             'but lags; the raw detection is always covered) (default: 0.5)')
+    parser.add_argument('--start_t', type=float, default=None,
+                        help='video only: trim the output to start this many seconds into the input '
+                             '(default: start of video)')
+    parser.add_argument('--end_t', type=float, default=None,
+                        help='video only: trim the output to end this many seconds into the input '
+                             '(default: end of video)')
+    parser.add_argument('--no_audio', action='store_true',
+                        help='video only: drop the audio track')
+    parser.add_argument('--crf', type=int, default=18,
+                        help='video only: H.264 quality, lower is better (default: 18)')
+    parser.add_argument('--draw_boxes', action='store_true',
+                        help='draw detection boxes and scores instead of obscuring (for tuning)')
+    parser.add_argument('--disable_pbar', action='store_true',
+                        help='disable progress bar when processing videos')
+
+    args = parser.parse_args()
+
+    input_path = Path(args.input)
+    if not input_path.exists():
+        print(f"Error: Input file '{input_path}' not found.")
+        sys.exit(1)
+
+    ext = input_path.suffix.lower()
+    if ext in IMAGE_EXTENSIONS:
+        is_video = False
+    elif ext in VIDEO_EXTENSIONS:
+        is_video = True
+    else:
+        print(f"Error: Unsupported file type '{ext}'.")
+        sys.exit(1)
+
+    if args.output:
+        output_path = args.output
+    else:
+        out_ext = '.mp4' if is_video else ext
+        output_path = str(input_path.parent / f'{input_path.stem}_blurred{out_ext}')
+
+    print(" -- Load Param: input", input_path)
+    print(" -- Load Param: output", output_path)
+    print(" -- Load Param: style", args.style)
+    print(" -- Load Param: shape", args.shape)
+    print(" -- Load Param: score_threshold", args.score_threshold)
+    print(" -- Load Param: device", args.device)
+
+    if not 0 <= args.smoothing < 1:
+        print("Error: --smoothing must be in [0, 1).")
+        sys.exit(1)
+
+    if not is_video and (args.start_t is not None or args.end_t is not None):
+        print("Error: --start_t/--end_t only apply to videos.")
+        sys.exit(1)
+
+    if args.start_t is not None and args.start_t < 0:
+        print("Error: --start_t must be >= 0.")
+        sys.exit(1)
+
+    if args.end_t is not None and args.end_t <= (args.start_t or 0.0):
+        print("Error: --end_t must be greater than --start_t.")
+        sys.exit(1)
+
+    blurrer = FaceBlur(
+        style=args.style,
+        shape=args.shape,
+        padding=args.padding,
+        score_threshold=args.score_threshold,
+        nms_threshold=args.nms_threshold,
+        detect_max_dim=args.detect_max_dim,
+        blur_strength=args.blur_strength,
+        pixel_blocks=args.pixel_blocks,
+        fill_color=args.fill_color,
+        hold_frames=args.hold_frames,
+        smoothing=args.smoothing,
+        draw_boxes=args.draw_boxes,
+        disable_pbar=args.disable_pbar,
+        device=args.device,
+        batch_size=args.batch_size,
+        workers=args.workers,
+    )
+
+    if is_video:
+        success = blurrer.process_video(str(input_path), output_path,
+                                        keep_audio=not args.no_audio, crf=args.crf,
+                                        start_t=args.start_t, end_t=args.end_t)
+    else:
+        success = blurrer.process_image(str(input_path), output_path)
+
+    if not success:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()