siss 0.1.0__tar.gz

siss-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Michail Semoglou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

siss-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: siss
+Version: 0.1.0
+Summary: A command-line utility for applying artistic effects to videos
+Home-page: https://github.com/MichailSemoglou/siss
+Author: Michail Semoglou
+Author-email: m.semoglou@tongji.edu.cn
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Multimedia :: Video
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.6
+License-File: LICENSE
+Requires-Dist: opencv-python>=4.5.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: tqdm>=4.60.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

siss-0.1.0/README.md

@@ -0,0 +1,160 @@
+# Siss
+
+A command-line utility for applying artistic effects to videos.
+
+![GitHub license](https://img.shields.io/github/license/MichailSemoglou/siss)
+![Python version](https://img.shields.io/badge/python-3.6%2B-blue)
+
+## Features
+
+- **Duotone Effect**: Creates a video with two selected colors mapped to dark and light areas
+- **Halftone Effect**: Creates a video with symbol patterns of varying sizes to represent dark and light areas
+- **Cross-platform Compatibility**: Handles codec differences between operating systems
+- **Progress Tracking**: Shows real-time progress during video processing
+
+## Installation
+
+### Option 1: Clone and Install
+
+1. Clone this repository:
+
+   ```bash
+   git clone https://github.com/MichailSemoglou/siss.git
+   cd siss
+   ```
+
+2. Create a virtual environment (recommended):
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   ```
+
+3. Install the required dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+### Option 2: Install from Source
+
+```bash
+pip install git+https://github.com/MichailSemoglou/siss.git
+```
+
+## Usage
+
+### Basic Usage
+
+```bash
+python -m src.main input_video.mp4 output_video.mp4 --effect duotone
+```
+
+Or if installed using pip:
+
+```bash
+siss input_video.mp4 output_video.mp4 --effect duotone
+```
+
+The tool supports various video formats including MP4, MOV, AVI, and more. The output format is determined by the file extension you specify for the output file.
+
+### Duotone Effect
+
+```bash
+python -m src.main input_video.mp4 output_duotone.mp4 --effect duotone --color1 255 0 0 --color2 0 255 255
+```
+
+This applies a duotone effect with red for dark areas and cyan for light areas.
+
+### Halftone Effect
+
+```bash
+python -m src.main input_video.mp4 output_halftone.mp4 --effect halftone --symbol_size 12 --symbol_type asterisk --color1 0 0 0 --color2 255 255 255
+```
+
+This applies a halftone effect with black asterisks on a white background.
+
+### Codec Compatibility Fix
+
+If you encounter issues with codecs (especially on different operating systems), use the `--use-codec-fix` option:
+
+```bash
+python -m src.main input_video.mp4 output_video.mp4 --effect duotone --use-codec-fix
+```
+
+This option uses an adaptive approach to find compatible codecs for your specific system.
+
+### Available Options
+
+- `--effect`: Choose between `duotone` or `halftone` (required)
+- `--color1`: First color in RGB format (default: 255 0 0, red)
+- `--color2`: Second color in RGB format (default: 0 255 255, cyan)
+- `--symbol_size`: Size of symbols for halftone effect (default: 10)
+- `--symbol_type`: Type of symbol for halftone effect (choices: plus, asterisk, slash, default: plus)
+- `--use-codec-fix`: Use adaptive codec selection for cross-platform compatibility
+
+## Examples
+
+### Creating a blue/yellow duotone effect:
+
+```bash
+python -m src.main video.mp4 blue_yellow.mp4 --effect duotone --color1 0 0 255 --color2 255 255 0
+```
+
+### Creating a halftone effect with slash symbols:
+
+```bash
+python -m src.main video.mp4 halftone_slashes.mp4 --effect halftone --symbol_type slash --symbol_size 15
+```
+
+### Using MOV files:
+
+```bash
+python -m src.main input.mov output.mov --effect duotone --color1 0 0 255 --color2 255 255 0
+```
+
+## Project Structure
+
+- `src/`
+  - `main.py`: Command-line interface for the tool
+  - `duotone.py`: Contains the duotone effect implementation
+  - `halftone.py`: Contains the halftone effect implementation
+  - `codec_fix.py`: Handles cross-platform codec compatibility
+  - `utils/`
+    - `video_processing.py`: Utility functions for video handling
+
+## Requirements
+
+- Python 3.6+
+- OpenCV (cv2)
+- NumPy
+- tqdm
+
+## Troubleshooting
+
+### Video Output Issues
+
+If you encounter issues with video output:
+
+1. Try using the `--use-codec-fix` option to automatically find a compatible codec
+2. Check that you have the necessary codecs installed for your operating system
+3. If creating MP4 files on Windows, try using AVI format instead
+
+### Memory Limitations
+
+For large videos, the tool processes frames sequentially to minimize memory usage. If you still experience memory issues:
+
+1. Try processing a shorter clip first
+2. Reduce the resolution of your input video
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

siss-0.1.0/setup.cfg

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

siss-0.1.0/setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="siss",
+    version="0.1.0",
+    description="A command-line utility for applying artistic effects to videos",
+    author="Michail Semoglou",
+    author_email="m.semoglou@tongji.edu.cn",
+    url="https://github.com/MichailSemoglou/siss",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    install_requires=[
+        "opencv-python>=4.5.0",
+        "numpy>=1.20.0",
+        "tqdm>=4.60.0",
+    ],
+    python_requires=">=3.6",
+    entry_points={
+        "console_scripts": [
+            "siss=src.main:main",
+        ],
+    },
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Topic :: Multimedia :: Video",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "License :: OSI Approved :: MIT License",
+    ],
+)

siss-0.1.0/src/siss.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: siss
+Version: 0.1.0
+Summary: A command-line utility for applying artistic effects to videos
+Home-page: https://github.com/MichailSemoglou/siss
+Author: Michail Semoglou
+Author-email: m.semoglou@tongji.edu.cn
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Multimedia :: Video
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.6
+License-File: LICENSE
+Requires-Dist: opencv-python>=4.5.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: tqdm>=4.60.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

siss-0.1.0/src/siss.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+setup.py
+src/siss.egg-info/PKG-INFO
+src/siss.egg-info/SOURCES.txt
+src/siss.egg-info/dependency_links.txt
+src/siss.egg-info/entry_points.txt
+src/siss.egg-info/requires.txt
+src/siss.egg-info/top_level.txt
+src/utils/__init__.py
+src/utils/video_processing.py
+tests/test_duotone.py
+tests/test_halftone.py

siss-0.1.0/src/siss.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

siss-0.1.0/src/siss.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+siss = src.main:main

siss-0.1.0/src/siss.egg-info/requires.txt

@@ -0,0 +1,3 @@
+opencv-python>=4.5.0
+numpy>=1.20.0
+tqdm>=4.60.0

siss-0.1.0/src/siss.egg-info/top_level.txt

@@ -0,0 +1 @@
+utils

siss-0.1.0/src/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Utility modules for Siss.
+"""

siss-0.1.0/src/utils/video_processing.py

@@ -0,0 +1,226 @@
+"""
+Utility functions for video processing operations.
+
+This module provides helper functions for common video operations like
+loading videos, extracting frames, and saving processed results.
+"""
+import cv2
+import numpy as np
+import os
+from tqdm import tqdm
+
+
+def get_codec_for_file(output_path):
+    """
+    Determine the appropriate codec based on the file extension.
+    
+    Args:
+        output_path (str): Path where the video will be saved
+        
+    Returns:
+        str: Four character codec code
+    """
+    # Get file extension (lowercase)
+    _, ext = os.path.splitext(output_path)
+    ext = ext.lower()
+    
+    # Map extensions to codecs
+    codec_map = {
+        '.avi': 'XVID',
+        '.mp4': 'mp4v',  # H.264 codec
+        '.mov': 'mp4v',  # H.264 codec for MOV container
+        '.mkv': 'X264',
+        '.wmv': 'WMV2',
+    }
+    
+    # Default to mp4v if extension not found
+    return codec_map.get(ext, 'mp4v')
+
+
+def load_video(video_path):
+    """
+    Load a video file and return a VideoCapture object.
+    
+    Args:
+        video_path (str): Path to the video file
+        
+    Returns:
+        cv2.VideoCapture: OpenCV VideoCapture object
+        
+    Raises:
+        FileNotFoundError: If the video file cannot be opened
+    """
+    video_capture = cv2.VideoCapture(video_path)
+    if not video_capture.isOpened():
+        raise FileNotFoundError(f"Cannot open video file: {video_path}")
+    return video_capture
+
+
+def get_video_properties(video_capture):
+    """
+    Get properties of a video.
+    
+    Args:
+        video_capture (cv2.VideoCapture): OpenCV VideoCapture object
+        
+    Returns:
+        dict: Dictionary with video properties (fps, width, height, frame_count)
+    """
+    properties = {
+        'fps': video_capture.get(cv2.CAP_PROP_FPS),
+        'width': int(video_capture.get(cv2.CAP_PROP_FRAME_WIDTH)),
+        'height': int(video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT)),
+        'frame_count': int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
+    }
+    return properties
+
+
+def extract_frames(video_capture, show_progress=True):
+    """
+    Extract all frames from a video.
+    
+    Args:
+        video_capture (cv2.VideoCapture): OpenCV VideoCapture object
+        show_progress (bool): Whether to show a progress bar
+        
+    Returns:
+        list: List of frames as numpy arrays
+    """
+    frames = []
+    
+    # Get frame count for progress bar
+    frame_count = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
+    
+    # Create progress bar if requested
+    if show_progress:
+        progress_bar = tqdm(total=frame_count, desc="Extracting frames")
+    
+    while True:
+        ret, frame = video_capture.read()
+        if not ret:
+            break
+        frames.append(frame)
+        
+        # Update progress bar
+        if show_progress:
+            progress_bar.update(1)
+    
+    # Close progress bar
+    if show_progress:
+        progress_bar.close()
+        
+    return frames
+
+
+def save_video(output_path, frames, fps, show_progress=True):
+    """
+    Save a list of frames as a video file.
+    
+    Args:
+        output_path (str): Path where the video will be saved
+        frames (list): List of frames as numpy arrays
+        fps (float): Frames per second for the output video
+        show_progress (bool): Whether to show a progress bar
+        
+    Raises:
+        ValueError: If no frames are provided
+    """
+    if not frames:
+        raise ValueError("No frames to save.")
+    
+    height, width, _ = frames[0].shape
+    codec = get_codec_for_file(output_path)
+    fourcc = cv2.VideoWriter_fourcc(*codec)
+    video_writer = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    
+    # Create progress bar if requested
+    if show_progress:
+        progress_bar = tqdm(total=len(frames), desc="Saving video")
+    
+    for frame in frames:
+        video_writer.write(frame)
+        
+        # Update progress bar
+        if show_progress:
+            progress_bar.update(1)
+    
+    # Close progress bar
+    if show_progress:
+        progress_bar.close()
+        
+    video_writer.release()
+    print(f"Video saved to {output_path}")
+
+
+def process_video_frames(video_path, output_path, process_function, **kwargs):
+    """
+    Process a video by applying a function to each frame.
+    
+    Args:
+        video_path (str): Path to the input video
+        output_path (str): Path where processed video will be saved
+        process_function (callable): Function to apply to each frame
+            The function should take a frame and return a processed frame
+        **kwargs: Additional arguments to pass to the process_function
+        
+    Example:
+        def grayscale(frame):
+            return cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            
+        process_video_frames('input.mp4', 'output.mp4', grayscale)
+    """
+    # Load video
+    cap = load_video(video_path)
+    
+    try:
+        # Get video properties
+        props = get_video_properties(cap)
+        
+        # Create output video writer with appropriate codec
+        codec = get_codec_for_file(output_path)
+        fourcc = cv2.VideoWriter_fourcc(*codec)
+        out = cv2.VideoWriter(output_path, fourcc, props['fps'], 
+                             (props['width'], props['height']))
+        
+        # Process frames with progress bar
+        progress_bar = tqdm(total=props['frame_count'], desc="Processing frames")
+        
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+                
+            # Apply processing function
+            processed_frame = process_function(frame, **kwargs)
+            
+            # Write processed frame
+            out.write(processed_frame)
+            
+            # Update progress
+            progress_bar.update(1)
+            
+        # Close progress bar
+        progress_bar.close()
+        
+        print(f"Processed video saved to {output_path}")
+        
+    finally:
+        # Release resources
+        cap.release()
+        if 'out' in locals():
+            out.release()
+
+
+def release_resources(video_capture, video_writer=None):
+    """
+    Release video resources.
+    
+    Args:
+        video_capture (cv2.VideoCapture): OpenCV VideoCapture object
+        video_writer (cv2.VideoWriter, optional): OpenCV VideoWriter object
+    """
+    if video_capture is not None:
+        video_capture.release()
+        
+    if video_writer is not None:
+        video_writer.release()

siss-0.1.0/tests/test_duotone.py

@@ -0,0 +1,90 @@
+"""
+Unit tests for the duotone module.
+"""
+import unittest
+import os
+import tempfile
+import numpy as np
+import cv2
+from src.duotone import apply_duotone
+
+
+class TestDuotone(unittest.TestCase):
+    """Tests for the duotone effect functions."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        # Create a small test video file
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.input_path = os.path.join(self.temp_dir.name, "test_input.mp4")
+        self.output_path = os.path.join(self.temp_dir.name, "test_output.mp4")
+        
+        # Create a simple test video (10 frames, solid color)
+        width, height = 320, 240
+        fps = 30
+        
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(self.input_path, fourcc, fps, (width, height))
+        
+        # Create 10 frames
+        for i in range(10):
+            # Create gradient frame
+            frame = np.zeros((height, width, 3), dtype=np.uint8)
+            for y in range(height):
+                value = int(y * 255 / height)
+                frame[y, :] = [value, value, value]
+            
+            out.write(frame)
+        
+        out.release()
+    
+    def tearDown(self):
+        """Clean up test environment."""
+        self.temp_dir.cleanup()
+    
+    def test_apply_duotone_basic(self):
+        """Test basic duotone effect application."""
+        # Skip test if codec not available
+        try:
+            # Test with basic colors
+            color1 = (255, 0, 0)  # Red
+            color2 = (0, 255, 255)  # Cyan
+            
+            apply_duotone(self.input_path, self.output_path, color1, color2)
+            
+            # Verify the output exists
+            self.assertTrue(os.path.exists(self.output_path))
+            
+            # Verify the output has correct content
+            cap = cv2.VideoCapture(self.output_path)
+            self.assertTrue(cap.isOpened())
+            
+            # Read the first frame and check colors
+            ret, frame = cap.read()
+            self.assertTrue(ret)
+            
+            # Check frame dimensions
+            self.assertEqual(frame.shape[1], 320)  # Width
+            self.assertEqual(frame.shape[0], 240)  # Height
+            
+            # Close video
+            cap.release()
+        except cv2.error:
+            self.skipTest("Codec not available")
+    
+    def test_invalid_inputs(self):
+        """Test error handling for invalid inputs."""
+        # Test with non-existent input file
+        with self.assertRaises(FileNotFoundError):
+            apply_duotone("nonexistent.mp4", self.output_path, (255, 0, 0), (0, 255, 255))
+        
+        # Test with invalid colors
+        with self.assertRaises(ValueError):
+            apply_duotone(self.input_path, self.output_path, (300, 0, 0), (0, 255, 255))
+        
+        with self.assertRaises(ValueError):
+            apply_duotone(self.input_path, self.output_path, (255, 0, 0), (-10, 255, 255))
+
+
+if __name__ == "__main__":
+    unittest.main()

siss-0.1.0/tests/test_halftone.py

@@ -0,0 +1,119 @@
+"""
+Unit tests for the halftone module.
+"""
+import unittest
+import os
+import tempfile
+import numpy as np
+import cv2
+from src.halftone import apply_halftone
+
+
+class TestHalftone(unittest.TestCase):
+    """Tests for the halftone effect functions."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        # Create a small test video file
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.input_path = os.path.join(self.temp_dir.name, "test_input.mp4")
+        self.output_path = os.path.join(self.temp_dir.name, "test_output.mp4")
+        
+        # Create a simple test video (10 frames, gradient color)
+        width, height = 320, 240
+        fps = 30
+        
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(self.input_path, fourcc, fps, (width, height))
+        
+        # Create 10 frames
+        for i in range(10):
+            # Create gradient frame
+            frame = np.zeros((height, width, 3), dtype=np.uint8)
+            for y in range(height):
+                value = int(y * 255 / height)
+                frame[y, :] = [value, value, value]
+            
+            out.write(frame)
+        
+        out.release()
+    
+    def tearDown(self):
+        """Clean up test environment."""
+        self.temp_dir.cleanup()
+    
+    def test_apply_halftone_basic(self):
+        """Test basic halftone effect application."""
+        # Skip test if codec not available
+        try:
+            # Test with basic settings
+            color1 = (0, 0, 0)  # Black
+            color2 = (255, 255, 255)  # White
+            symbol_size = 8
+            
+            apply_halftone(self.input_path, self.output_path, symbol_size, color1, color2)
+            
+            # Verify the output exists
+            self.assertTrue(os.path.exists(self.output_path))
+            
+            # Verify the output has correct content
+            cap = cv2.VideoCapture(self.output_path)
+            self.assertTrue(cap.isOpened())
+            
+            # Read the first frame and check dimensions
+            ret, frame = cap.read()
+            self.assertTrue(ret)
+            
+            # Check frame dimensions
+            self.assertEqual(frame.shape[1], 320)  # Width
+            self.assertEqual(frame.shape[0], 240)  # Height
+            
+            # Close video
+            cap.release()
+        except cv2.error:
+            self.skipTest("Codec not available")
+    
+    def test_symbol_types(self):
+        """Test different symbol types."""
+        # Skip test if codec not available
+        try:
+            symbol_types = ['plus', 'asterisk', 'slash']
+            
+            for symbol_type in symbol_types:
+                output_path = os.path.join(self.temp_dir.name, f"test_{symbol_type}.mp4")
+                
+                apply_halftone(
+                    self.input_path, 
+                    output_path, 
+                    symbol_size=8, 
+                    color1_rgb=(0, 0, 0), 
+                    color2_rgb=(255, 255, 255), 
+                    symbol_type=symbol_type
+                )
+                
+                # Verify the output exists
+                self.assertTrue(os.path.exists(output_path))
+        except cv2.error:
+            self.skipTest("Codec not available")
+    
+    def test_invalid_inputs(self):
+        """Test error handling for invalid inputs."""
+        # Test with non-existent input file
+        with self.assertRaises(FileNotFoundError):
+            apply_halftone("nonexistent.mp4", self.output_path, 10, (0, 0, 0), (255, 255, 255))
+        
+        # Test with invalid colors
+        with self.assertRaises(ValueError):
+            apply_halftone(self.input_path, self.output_path, 10, (300, 0, 0), (255, 255, 255))
+        
+        # Test with invalid symbol type
+        with self.assertRaises(ValueError):
+            apply_halftone(self.input_path, self.output_path, 10, (0, 0, 0), (255, 255, 255), 'invalid_type')
+        
+        # Test with invalid symbol size
+        with self.assertRaises(ValueError):
+            apply_halftone(self.input_path, self.output_path, 0, (0, 0, 0), (255, 255, 255))
+
+
+if __name__ == "__main__":
+    unittest.main()