vsdirty 0.1.0__py3-none-any.whl

vsdirty/dirtyfixer.py

@@ -0,0 +1,113 @@
+import vapoursynth as vs
+from typing import List
+from vstools import PlanesT
+from vstools import depth
+from .adutils import plane
+
+core = vs.core
+
+if not (hasattr(vs.core, 'fmtc') or hasattr(vs.core, 'bore')):
+    raise ImportError("'fmtc' and 'libbore' are mandatory. Make sure the DLLs are present in the plugins folder.")
+
+def bore(
+        clip : vs.VideoNode,
+        ythickness: List[int] = None,
+        uthickness: List[int] = None,
+        vthickness: List[int] = None,
+        planes: PlanesT = 0,
+        singlePlane = True,
+        **kwargs
+        ) -> vs.VideoNode:
+    """
+    Apply bore filter to clip's edges to remove dirty lines.
+    
+    Processes selected planes at their native resolution to avoid 
+    unnecessary scaling artifacts. Uses full resolution for luma,
+    native chroma resolution for chroma planes.
+
+    Only bore.SinglePlane and bore.MultiPlane are implemented, the other functions will probably never be implemented.
+
+    :param clip:         Input clip (YUV or GRAY, RGB not supported)
+    :param ythickness:   List of luma border thicknesses to process. [top, bottom, left, right]. 0 means no processing.
+    :param uthickness:   List of chroma U border thicknesses to process. [top, bottom, left, right]. 0 means no processing. if None, uses ythickness or vthickness if is not None.
+    :param vthickness:   List of chroma V border thicknesses to process. [top, bottom, left, right]. 0 means no processing. if None, uses ythickness or uthickness if is not None.
+    :param planes:       Plane(s) to process.
+    :param singlePlane:  If True uses bore.SinglePlane, otherwise bore.MultiPlane. MultiPlane cannot be used with GRAY clips.
+    :return:             Processed clip with corrected borders, same format as input      
+    """
+
+    if ythickness is None:
+        ythickness = [1,1,1,1]
+
+    if clip.format.color_family == vs.RGB:
+        raise ValueError("bore: RGB clips are not supported.")     
+    
+    if planes is None:
+        raise ValueError("bore: planes cannot be None.")
+
+    if isinstance(planes, int):
+        planes = [planes]
+
+    def _get_tblr(thick):
+        if len(thick) == 2:
+            t, b = thick
+            l, r = 0, 0
+        elif len(thick) == 4:
+            t, b, l, r = thick
+        else:
+            t = thick[0] if len(thick) > 0 else 0
+            b = thick[1] if len(thick) > 1 else t
+            l = thick[2] if len(thick) > 2 else 0
+            r = thick[3] if len(thick) > 3 else l
+        return t, b, l, r
+
+    if uthickness is None:
+        if vthickness is not None:
+            uthickness = vthickness
+        else:
+            uthickness = ythickness
+    if vthickness is None:
+        if uthickness is not None:
+            vthickness = uthickness
+        else:
+            vthickness = ythickness
+
+    yt, yb, yl, yr = _get_tblr(ythickness)
+    ut, ub, ul, ur = _get_tblr(uthickness)
+    vt, vb, vl, vr = _get_tblr(vthickness)
+
+    if clip.format.color_family == vs.GRAY:
+        upclip = clip.resize.Bicubic(format=vs.YUV444PS)
+        fixY = plane(depth(core.bore.SinglePlane(upclip, top=yt, bottom=yb, left=yl, right=yr, plane=0), clip.format.bits_per_sample), 0)
+        return fixY
+
+    fixY = plane(clip, 0)
+    fixU = plane(clip, 1)
+    fixV = plane(clip, 2)
+
+    if 0 in planes:
+        upclip = clip.resize.Bicubic(format=vs.YUV444PS)
+        if singlePlane:
+            fixY = plane(depth(core.bore.SinglePlane(upclip, top=yt, bottom=yb, left=yl, right=yr, plane=0), clip.format.bits_per_sample), 0)
+        else:
+            fixY = plane(depth(core.bore.MultiPlane(upclip, top=yt, bottom=yb, left=yl, right=yr, plane=0), clip.format.bits_per_sample), 0)
+    
+    if 1 in planes:
+        upclip = clip.resize.Bicubic(width=plane(clip, 1).width, height=plane(clip, 1).height, format=vs.YUV444PS)
+        upclip = core.std.ShufflePlanes([upclip, depth(clip,32), depth(clip,32)], planes=[0, 1, 2], colorfamily=vs.YUV)
+        if singlePlane:
+            fixU = plane(depth(core.bore.SinglePlane(upclip, top=ut, bottom=ub, left=ul, right=ur, plane=1), clip.format.bits_per_sample), 1)
+        else:
+            fixU = plane(depth(core.bore.MultiPlane(upclip, top=ut, bottom=ub, left=ul, right=ur, plane=1), clip.format.bits_per_sample), 1)
+    
+    if 2 in planes:
+        upclip = clip.resize.Bicubic(width=plane(clip, 2).width, height=plane(clip, 2).height, format=vs.YUV444PS)
+        upclip = core.std.ShufflePlanes([upclip, depth(clip,32), depth(clip,32)], planes=[0, 1, 2], colorfamily=vs.YUV)
+        if singlePlane:
+            fixV = plane(depth(core.bore.SinglePlane(upclip, top=vt, bottom=vb, left=vl, right=vr, plane=2), clip.format.bits_per_sample), 2)
+        else:
+            fixV = plane(depth(core.bore.MultiPlane(upclip, top=vt, bottom=vb, left=vl, right=vr, plane=2), clip.format.bits_per_sample), 2)
+
+    merged = core.std.ShufflePlanes([fixY, fixU, fixV], planes=[0, 0, 0], colorfamily=vs.YUV)
+
+    return merged

vsdirty-0.1.0.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: vsdirty
+Version: 0.1.0
+Summary: VapourSynth wrappers for denoising, masking and edge fixing
+Author: PingWer, Mhanz3500
+Project-URL: Homepage, https://github.com/r74mi/vs-dirty
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: vapoursynth>=70
+Requires-Dist: vstools
+Requires-Dist: vsjetpack==1.1.0
+Dynamic: license-file
+
+# vs-dirty
+
+A collection of VapourSynth wrappers and utility functions focused on advanced denoising, masking, and edge fixing.
+
+## Installation
+
+You can install `vsdirty` via pip:
+
+```bash
+pip install vsdirty
+```
+
+Or build from source:
+
+```bash
+git clone https://github.com/r74mi/vs-dirty.git
+cd vs-dirty
+pip install .
+```
+
+## Dependencies
+
+This package relies on several external VapourSynth plugins. Ensure these are installed and available in your VapourSynth plugins folder.
+
+| Plugin | URL |
+| :--- | :--- |
+| **fmtc** | [GitLab](https://gitlab.com/EleonoreMizo/fmtconv/) |
+| **akarin** | [GitHub](https://github.com/AkarinVS/vapoursynth-plugin) |
+| **cas** | [GitHub](https://github.com/HomeOfVapourSynthEvolution/VapourSynth-CAS) |
+| **bore** | [GitHub](https://github.com/OpusGang/bore) |
+| **mvtools** | [GitHub](https://github.com/dubhater/vapoursynth-mvtools) |
+| **BM3DCuda** | [GitHub](https://github.com/WolframRhodium/VapourSynth-BM3DCUDA) |
+| **nlm-cuda** | [GitHub](https://github.com/AmusementClub/vs-nlm-cuda) |
+| **vsmlrt** | [GitHub](https://github.com/AmusementClub/vs-mlrt) |
+
+## `adenoise`
+
+Designed specifically for film content, this intensive adaptive denoiser removes noise while carefully preserving fine textures and small elements. It combines `mc_degrain` (luma), `NLMeans`/`CBM3D` (chroma), and `BM3D` (luma), all modulated by adaptive masking.
+
+**Presets:**
+- `scan65mm` (Light)
+- `scan35mm` (Medium)
+- `scan16mm` (Heavy)
+- `scan8mm` (Very Heavy)
+- `digital` (Optimized for digital sources)
+- `default` (Generic)
+
+**Parameters:**
+
+```python
+adenoise.default(clip: vs.VideoNode, 
+    thsad: int = 500, 
+    tr: int = 2, 
+    sigma: float = 6, 
+    luma_mask_weaken: float = 0.75, 
+    luma_mask_thr: float = 0.196, 
+    chroma_denoise: float | tuple[float, str] = [1.0, "nlm"], 
+    precision: bool = True, 
+    chroma_masking: bool = False, 
+    show_mask: int = 0, 
+    luma_over_texture: float = 0.4, 
+    kwargs_flatmask: dict = {})
+```
+
+- `clip`: Clip to process (YUV or GRAY 16bit, if not will be internally converted in 16bit).
+- `thsad`: Thsad for mc_degrain (luma denoise strength and chroma ref).
+                                Recommended values: 300-800
+- `tr`: Temporal radius for temporal consistency across al the filter involved.
+                                Recommended values: 2-3 (1 means no temporal denoise).
+- `sigma`: Sigma for BM3D (luma denoise strength).
+                                Recommended values: 1-5. 
+- `luma_mask_weaken`: Controls how much dark spots should be denoised. Lower values mean stronger overall denoise.
+                                Recommended values: 0.6-0.9
+- `luma_mask_thr`: Threshold that determines what is considered bright and what is dark in the luma mask.
+                                Recommended values: 0.15-0.25
+- `chroma_denoise`: Denoiser strength and type for chroma. NLMeans/CBM3D/ArtCNN.
+                                Reccomended strength values: 0.5-2. If not given, 1.0 is used (or none for ArtCNN).
+                                Accepted denoiser types: "nlm", "cbm3d", "artcnn". If not given, nlm is used.
+- `precision`: If True, a flat mask is created to enhance the denoise strenght on flat areas avoiding textured area (95% accuracy).
+- `chroma_masking`: If True, enables specific chroma masking for U/V planes.
+- `show_mask`: 1 = Show the first luma mask, 2 = Show the textured luma mask, 3 = Show the complete luma mask, 4 = Show the Chroma U Plane mask (if chroma_masking = True), 5 = Show the Chroma V Plane mask (if chroma_masking = True). Any other value returns the denoised clip.
+- `luma_over_texture`: Multiplier for the luma mask in precision mode. Lower value means more importance to textured areas, higher value means more importance to luma levels.
+                                Accepted values: 0.0-1.0
+- `kwargs_flatmask`: Additional arguments for flatmask creation.
+  dict values (check `hd_flatmask`'s docstring for more info):
+  - `sigma1`: This value should be decided based on the details level of the clip and how much grain and noise is present. Usually 1 for really textured clip, 2-3 for a normal clip, 4-5 for a clip with strong noise or grain.
+  - `texture_strength`: Texture strength for mask (0-inf). Values above 1 decrese the strength of the texture in the mask, lower values increase it. The max value is theoretical infinite, but there is no gain after some point.
+  - `edges_strength`: Edges strength for mask (0-1). Basic multiplier for edges strength.
+
+- `return`: 16bit denoised clip. If show_mask is 1, 2, 3, 4 or 5, returns a tuple (denoised_clip, mask).
+
+**Usage:**
+
+```python
+from vsdirty import adenoise
+
+# Apply default adaptive denoising
+denoised = adenoise.scan16mm(clip)
+```
+
+
+## `bore`
+
+A powerful edge cleaner (dirty line fixer) that processes borders at their native resolution to avoid scaling artifacts.
+
+```python
+from vsdirty import bore
+
+# Fix dirty lines: Top=1px, Bottom=1px, Left=2px, Right=2px
+clean = bore(clip, ythickness=[1, 1, 2, 2])
+```
+
+## `msaa2x`
+
+An antialiaser based on ArtCNN that targets specific edges to reduce aliasing without blurring textures.
+
+```python
+from vsdirty import adfunc
+
+# Apply antialiasing
+aa_clip = adfunc.msaa2x(clip)
+```
+
+## `advanced_edgemask`
+
+Generates a high-quality edge mask by combining Retinex preprocessing with multiple edge detectors (Kirsch, Sobel) to capture faint and complex edges.
+
+```python
+from vsdirty import admask
+
+emask = admask.advanced_edgemask(clip, luma_scaling=10)
+```
+
+## `hd_flatmask`
+
+A specialized mask for flat areas, useful for protecting textures or targeting specific flat regions for filtering.
+
+```python
+from vsdirty import admask
+
+flat_mask = admask.hd_flatmask(clip)
+```
+
+## `diff_and_swap`
+
+A utility to repair damaged frames in a "base" clip using a "correction" clip. It compares frames and swaps them if the difference exceeds a threshold.
+
+```python
+from vsdirty import adutils
+
+# automated patching
+repaired, _ = adutils.diff_and_swap(correction_clip, base_clip, thr=30000)
+```
+
+## License
+
+MIT License

vsdirty-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+vsdirty/__init__.py,sha256=zonL-cH2iKwEiu0TC3WKa-EQjyDmkKicN04NMIN5OnY,182
+vsdirty/adfunc.py,sha256=-zXnWU76m-xZZWerAXLhWtWlBz90tUe3olhD18iqAew,28701
+vsdirty/admask.py,sha256=cOqndbegtgnLBti6ABUrPXzby3xFqUNCq5GcAz-HJdI,17530
+vsdirty/adutils.py,sha256=s9MHtFghwjZp9W160yWb5zVeBehC3KloK4kXDSBgFsc,7702
+vsdirty/dirtyfixer.py,sha256=qAUvpliKHYp0Ivc6HIwkU9jFFnqv_VW7M12iuK4KLRQ,4934
+vsdirty-0.1.0.dist-info/licenses/LICENSE,sha256=ytBUIbwDXahKm15kCB5kJy6kyFzwccf64igR1vKikNk,1075
+vsdirty-0.1.0.dist-info/METADATA,sha256=9WusOZqR6z67-YXsf4H9x_KNcK8QlWlnkGjeQ2cxNj8,6612
+vsdirty-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+vsdirty-0.1.0.dist-info/top_level.txt,sha256=2bWQbCuQp4y6_hKaWKvP8Ysc5-Z_0NRM01wKZYt8_7o,8
+vsdirty-0.1.0.dist-info/RECORD,,

vsdirty-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vsdirty-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PingWer, Mhanz3500
+
+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.

vsdirty-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vsdirty