vsdirty 0.2.2__tar.gz → 0.4.0__tar.gz

vsdirty-0.4.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: vsdirty
+Version: 0.4.0
+Summary: VapourSynth wrappers for denoising, masking and edge fixing
+Author: PingWer, Mhanz3500
+Project-URL: Homepage, https://github.com/PingWer/vs-dirty
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: vsjetpack
+Requires-Dist: vapoursynth==73
+Dynamic: license-file
+
+# vs-dirty
+
+A collection of VapourSynth wrappers and utility functions focused on advanced denoising, masking, and edge fixing.
+
+Follow the docstring for more information about the parameters.
+
+## Installation
+
+You can install `vsdirty` via pip:
+
+```bash
+pip install vsdirty
+```
+
+Or build from source:
+
+```bash
+git clone https://github.com/PingWer/vs-dirty
+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) |
+
+## License
+
+MIT License

vsdirty-0.4.0/README.md

@@ -0,0 +1,40 @@
+# vs-dirty
+
+A collection of VapourSynth wrappers and utility functions focused on advanced denoising, masking, and edge fixing.
+
+Follow the docstring for more information about the parameters.
+
+## Installation
+
+You can install `vsdirty` via pip:
+
+```bash
+pip install vsdirty
+```
+
+Or build from source:
+
+```bash
+git clone https://github.com/PingWer/vs-dirty
+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) |
+
+## License
+
+MIT License

{vsdirty-0.2.2 → vsdirty-0.4.0}/pyproject.toml

@@ -4,15 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vsdirty"
-version = "0.2.2"
+version = "0.4.0"
 description = "VapourSynth wrappers for denoising, masking and edge fixing"
 readme = "README.md"
 authors = [{ name = "PingWer" }, { name = "Mhanz3500" }]
 requires-python = ">=3.12"
 dependencies = [
-    "vapoursynth>=70",
-    "vstools",
-    "vsjetpack==1.1.0",
+    "vsjetpack",
+    "vapoursynth==73", # For 0.4.0 we need to force r73, we will support APIv4 in the next update
 ]
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -21,7 +20,7 @@ classifiers = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/r74mi/vs-dirty"
+Homepage = "https://github.com/PingWer/vs-dirty"
 
 [tool.setuptools.packages.find]
 include = ["vsdirty*"]

{vsdirty-0.2.2 → vsdirty-0.4.0}/vsdirty/adfunc.py

@@ -1,7 +1,8 @@
 import vapoursynth as vs
 
-from typing import Optional
+from typing import Optional, Any
 from vstools import PlanesT
+from vsmlrt import BackendV2
 
 core = vs.core
 
@@ -149,20 +150,7 @@ def mini_BM3D(
                 refS,
                 fulls=True,
                 fulld=True,
-                coef=[
-                    1 / 3,
-                    1 / 3,
-                    1 / 3,
-                    0,
-                    1 / 2,
-                    0,
-                    -1 / 2,
-                    0,
-                    1 / 4,
-                    -1 / 2,
-                    1 / 4,
-                    0,
-                ],
+                coef=[1 / 3, 1 / 3, 1 / 3, 0, 1 / 2, 0, -1 / 2, 0, 1 / 4, -1 / 2, 1 / 4, 0],
                 col_fam=vs.YUV,
             )
         else:
@@ -255,9 +243,9 @@ class adenoise:
     :param thsad:               Thsad for mc_degrain (luma denoise strength and chroma ref).
                                 Recommended values: 300-800
     :param tr:                  Temporal radius for temporal consistency across al the filter involved.
-                                Recommended values: 2-3 (1 means no temporal denoise).
+                                Recommended values: 2-3.
     :param sigma:               Sigma for BM3D (luma denoise strength).
-                                Recommended values: 1-5.
+                                Recommended values: 3-6.
     :param luma_mask_weaken:    Controls how much dark spots should be denoised. Lower values mean stronger overall denoise.
                                 Recommended values: 0.6-0.9
     :param luma_mask_thr:       Threshold that determines what is considered bright and what is dark in the luma mask.
@@ -297,6 +285,7 @@ class adenoise:
         luma_over_texture: float = 0.4,
         kwargs_flatmask: Optional[dict] = {},
         show_mask: int = 0,
+        backend: Optional[BackendV2] = None,
         **kwargs,
     ) -> tuple[vs.VideoNode, vs.VideoNode]:
 
@@ -331,7 +320,7 @@ class adenoise:
             selected_mask = darken_luma_mask
 
         # Degrain
-        if "is_digital" not in kwargs:
+        if "is_bm3d_only" not in kwargs:
             mvtools = MVTools(clip)
             vectors = mvtools.analyze(
                 blksize=16,
@@ -370,21 +359,17 @@ class adenoise:
             if show_mask == 2:
                 selected_mask = flatmask
 
-            if luma_over_texture > 1.0:
-                raise ValueError("luma_over_texture must be less than 1")
-            elif luma_over_texture < 0.0:
-                raise ValueError("luma_over_texture must be greater than 0")
-            final_mask = core.akarin.Expr(
-                [darken_luma_mask, flatmask],
-                f"x {luma_over_texture} * y {abs(luma_over_texture - 1)} * +",
-            )
+            final_mask = core.std.Merge(flatmask, darken_luma_mask, weight=luma_over_texture)
         else:
             final_mask = darken_luma_mask
 
         if show_mask == 3:
             selected_mask = final_mask
 
-        denoised = mini_BM3D(plane(degrain, 0), sigma=sigma, radius=tr, profile="HIGH")
+        if "is_digital" in kwargs:
+            denoised = mini_BM3D(plane(clip, 0), ref=plane(degrain, 0), sigma=sigma, radius=tr, profile="HIGH")
+        else:
+            denoised = mini_BM3D(plane(degrain, 0), sigma=sigma, radius=tr, profile="HIGH")
         y_denoised = core.std.MaskedMerge(
             denoised, plane(clip, 0), final_mask
         )  # denoise applied to darker areas
@@ -414,7 +399,7 @@ class adenoise:
                 elif chroma_denoise[1] == "artcnn":
                     from vsscale import ArtCNN
 
-                    chroma_denoised = ArtCNN.R8F64_JPEG420().scale(clip)
+                    chroma_denoised = ArtCNN.R8F64_JPEG420(backend=backend).scale(clip)
                     weights = [
                         0,
                         chroma_denoise[0]
@@ -478,12 +463,13 @@ class adenoise:
         fast: bool = True,
         luma_mask_weaken: float = 0.9,
         luma_mask_thr: float = 0.196,
-        chroma_denoise: float | tuple[float, str] = [0.5, "nlm"],
+        chroma_denoise: float | str | tuple[float, str] = [0.5, "nlm"],
         precision: bool = True,
         chroma_masking: bool = False,
         show_mask: int = 0,
         luma_over_texture: float = 0.4,
         kwargs_flatmask: dict = {},
+        backend: Optional[BackendV2] = None,
     ) -> vs.VideoNode:
         """changes: thsad=200, sigma=2, luma_mask_weaken=0.9, chroma_strength=0.5"""
         denoised = adenoise._adaptive_denoiser(
@@ -500,6 +486,7 @@ class adenoise:
             luma_over_texture,
             kwargs_flatmask,
             show_mask,
+            backend=backend,
         )
         if show_mask in [1, 2, 3, 4, 5]:
             return denoised
@@ -514,12 +501,13 @@ class adenoise:
         fast: bool = True,
         luma_mask_weaken: float = 0.8,
         luma_mask_thr: float = 0.196,
-        chroma_denoise: float | tuple[float, str] = [0.7, "nlm"],
+        chroma_denoise: float | str | tuple[float, str] = [0.7, "nlm"],
         precision: bool = True,
         chroma_masking: bool = False,
         show_mask: int = 0,
         luma_over_texture: float = 0.4,
         kwargs_flatmask: dict = {},
+        backend: Optional[BackendV2] = None,
     ) -> vs.VideoNode:
         """changes: thsad=400, sigma=4, luma_mask_weaken=0.8, chroma_strength=0.7"""
         denoised = adenoise._adaptive_denoiser(
@@ -536,6 +524,7 @@ class adenoise:
             luma_over_texture,
             kwargs_flatmask,
             show_mask,
+            backend=backend,
         )
         if show_mask in [1, 2, 3, 4, 5]:
             return denoised
@@ -550,12 +539,13 @@ class adenoise:
         fast: bool = True,
         luma_mask_weaken: float = 0.75,
         luma_mask_thr: float = 0.196,
-        chroma_denoise: float | tuple[float, str] = [1.0, "nlm"],
+        chroma_denoise: float | str | 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 = {},
+        backend: Optional[BackendV2] = None,
     ) -> vs.VideoNode:
         denoised = adenoise._adaptive_denoiser(
             clip,
@@ -571,6 +561,7 @@ class adenoise:
             luma_over_texture,
             kwargs_flatmask,
             show_mask,
+            backend=backend,
         )
         if show_mask in [1, 2, 3, 4, 5]:
             return denoised
@@ -585,12 +576,13 @@ class adenoise:
         fast: bool = False,
         luma_mask_weaken: float = 0.75,
         luma_mask_thr: float = 0.196,
-        chroma_denoise: float | tuple[float, str] = [1.5, "nlm"],
+        chroma_denoise: float | str | tuple[float, str] = [1.5, "nlm"],
         precision: bool = True,
         chroma_masking: bool = False,
         show_mask: int = 0,
         luma_over_texture: float = 0.4,
         kwargs_flatmask: dict = {},
+        backend: Optional[BackendV2] = None,
     ) -> vs.VideoNode:
         """changes: thsad=800, sigma=12, luma_over_texture=0.4, fast=False"""
         denoised = adenoise._adaptive_denoiser(
@@ -607,11 +599,12 @@ class adenoise:
             luma_over_texture,
             kwargs_flatmask,
             show_mask,
+            backend=backend,
         )
         if show_mask in [1, 2, 3, 4, 5]:
             return denoised
         return denoised[0]
-
+    
     @staticmethod
     def digital(
         clip: vs.VideoNode,
@@ -621,12 +614,13 @@ class adenoise:
         fast: bool = True,
         luma_mask_weaken: float = 0.75,
         luma_mask_thr: float = 0.196,
-        chroma_denoise: float | tuple[float, str] = [1.0, "nlm"],
+        chroma_denoise: float | str | tuple[float, str] = [1.0, "nlm"],
         precision: bool = True,
         chroma_masking: bool = False,
         show_mask: int = 0,
         luma_over_texture: float = 0.2,
         kwargs_flatmask: dict = {},
+        backend: Optional[BackendV2] = None,
     ) -> vs.VideoNode:
         """changes: thsad=300, sigma=3, luma_over_texture=0.2"""
         denoised = adenoise._adaptive_denoiser(
@@ -644,6 +638,46 @@ class adenoise:
             kwargs_flatmask,
             show_mask,
             is_digital=True,
+            backend=backend,
+        )
+        if show_mask in [1, 2, 3, 4, 5]:
+            return denoised
+        return denoised[0]
+
+    @staticmethod
+    def bm3d(
+        clip: vs.VideoNode,
+        thsad: int = 500,
+        tr: int = 2,
+        sigma: float = 3,
+        fast: bool = True,
+        luma_mask_weaken: float = 0.75,
+        luma_mask_thr: float = 0.196,
+        chroma_denoise: float | str | tuple[float, str] = [1.0, "nlm"],
+        precision: bool = True,
+        chroma_masking: bool = False,
+        show_mask: int = 0,
+        luma_over_texture: float = 0.2,
+        kwargs_flatmask: dict = {},
+        backend: Optional[BackendV2] = None,
+    ) -> vs.VideoNode:
+        """changes: sigma=3, luma_over_texture=0.2"""
+        denoised = adenoise._adaptive_denoiser(
+            clip,
+            thsad,
+            tr,
+            sigma,
+            luma_mask_weaken,
+            luma_mask_thr,
+            chroma_denoise,
+            precision,
+            fast,
+            chroma_masking,
+            luma_over_texture,
+            kwargs_flatmask,
+            show_mask,
+            is_bm3d_only=True,
+            backend=backend,
         )
         if show_mask in [1, 2, 3, 4, 5]:
             return denoised
@@ -658,12 +692,13 @@ class adenoise:
         fast: bool = True,
         luma_mask_weaken: float = 0.75,
         luma_mask_thr: float = 0.196,
-        chroma_denoise: float | tuple[float, str] = [1.0, "nlm"],
+        chroma_denoise: float | str | 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 = {},
+        backend: Optional[BackendV2] = None,
     ) -> vs.VideoNode:
         """default profile"""
         denoised = adenoise._adaptive_denoiser(
@@ -680,6 +715,7 @@ class adenoise:
             luma_over_texture,
             kwargs_flatmask,
             show_mask,
+            backend=backend,
         )
         if show_mask in [1, 2, 3, 4, 5]:
             return denoised
@@ -738,21 +774,26 @@ def auto_deblock(
 def msaa2x(
     clip: vs.VideoNode,
     ref: Optional[vs.VideoNode] = None,
-    mask: bool = False,
+    show_mask: bool = False,
+    edgemask: Optional[vs.VideoNode] = None,
     sigma: float = 3,
     thr: float = None,
+    strength: float = None,
     planes: PlanesT = 0,
+    backend: Optional[BackendV2] = None,
     **kwargs,
-) -> vs.VideoNode:
+) -> vs.VideoNode | tuple[vs.VideoNode, vs.VideoNode]:
     """
     Upscales only the edges with AI (ArtCNN DN) and downscales them.
 
     :param clip:            Clip to process (YUV or Grayscale).
     :param planes:          Which planes to process. Defaults to Y.
     :param ref:             Reference clip used to create the edgemask (should be a denoised clip). If None, clip will be used and will be denoised with adenoise.digital to prevent edge detail loss, but remove grain and noise.
-    :param mask:            If True will return the mask used.
+    :param show_mask:       If True, returns a tuple containing the processed clip and the mask used.
+    :param edgemask:        Pre-computed edgemask. If None, it will be computed internally.
     :param sigma:           Sigma used for edge fixing during antialiasing (remove dirty spots and blocking) only if ref is None.
     :param thr:             Threshold used for Binarize the clip, only 0-1 value area allowed. If None, no Binarize will be applied.
+    :param strength:        Strength of the final merge between the original clip and the upscaled clip. 0-1 values accepted.
     :param kwargs:          Accepts advanced_edgemask arguments.
     """
     from vsscale import ArtCNN
@@ -770,35 +811,35 @@ def msaa2x(
 
     clip = depth(clip, 16, dither_type="none")
 
-    if ref is None:
-        ref = adenoise.digital(
-            clip,
-            sigma=sigma,
-            precision=False,
-            chroma_denoise=[(0 if (1 in planes or 2 in planes) else 2), "cbm3d"],
-        )
-
-    if len(planes) == 1:
-        edgemask = advanced_edgemask(plane(ref, 0), **kwargs)
-    else:
-        masks = [
-            advanced_edgemask(plane(ref, p), **kwargs)
-            if p in planes
-            else plane(ref, p).std.BlankClip()
-            for p in range(3)
-        ]
-        edgemask = core.std.ShufflePlanes(
-            masks, planes=[0, 0, 0], colorfamily=ref.format.color_family
-        )
+    if edgemask is None:
+        if ref is None:
+            ref = adenoise.digital(
+                clip,
+                sigma=sigma,
+                precision=False,
+                chroma_denoise=[(0 if (1 in planes or 2 in planes) else 2), "cbm3d"],
+                backend=backend,
+            )
+    
+        if len(planes) == 1:
+            edgemask = advanced_edgemask(plane(ref, 0), **kwargs)
+        else:
+            masks = [
+                advanced_edgemask(plane(ref, p), **kwargs)
+                if p in planes
+                else plane(ref, p).std.BlankClip()
+                for p in range(3)
+            ]
+            edgemask = core.std.ShufflePlanes(
+                masks, planes=[0, 0, 0], colorfamily=ref.format.color_family
+            )
 
     if thr is not None and thr != 0:
         edgemask = edgemask.std.Binarize(
             threshold=scale_binary_value(edgemask, thr, return_int=True)
         )
-    if mask:
-        return edgemask
 
-    upscaled = ArtCNN.C4F32_DN().scale(clip, clip.width * 2, clip.height * 2)
+    upscaled = ArtCNN.C4F32_DN(backend=backend).supersample(clip, 2)
     downscaled = core.resize.Bicubic(upscaled, clip.width, clip.height)
     aa = core.std.MaskedMerge(clip, downscaled, edgemask, planes=0)
 
@@ -807,7 +848,7 @@ def msaa2x(
         aa = core.std.ShufflePlanes(
             [aa, lefted, lefted], planes=[0, 1, 2], colorfamily=clip.format.color_family
         )
-        aa = ArtCNN.R8F64_Chroma().scale(aa)
+        aa = ArtCNN.R8F64_Chroma(backend=backend).scale(aa)
         chroma_downscaled = core.resize.Bicubic(aa, clip.width / 2, clip.height / 2)
         u = plane(chroma_downscaled, 1)
         v = plane(chroma_downscaled, 2)
@@ -818,4 +859,10 @@ def msaa2x(
         )
         aa = core.std.MaskedMerge(clip, all_downscaled, edgemask, planes=planes)
 
+    if strength is not None or strength != 0:
+        aa = core.std.Merge(aa, clip, weight=strength)
+
+    if show_mask:
+        return aa, edgemask
+
     return aa

{vsdirty-0.2.2 → vsdirty-0.4.0}/vsdirty/admask.py

@@ -11,6 +11,16 @@ if not (
     )
 
 
+def _morpho_radius(clip: vs.VideoNode, radius: int, **kwargs) -> vs.VideoNode:
+    """Helper to dynamically switch between expand and inpand based on sign."""
+    from vsmasktools import Morpho, XxpandMode
+
+    if radius == 0:
+        return clip
+    op = Morpho.expand if radius > 0 else Morpho.inpand
+    return op(clip, sw=abs(radius), sh=abs(radius), mode=XxpandMode.ELLIPSE, **kwargs)
+
+
 def _soft_threshold(
     clip: vs.VideoNode, thr: float, steepness: float = 20.0
 ) -> vs.VideoNode:
@@ -293,7 +303,7 @@ def advanced_edgemask(
     :param kirsch_weight:       Weight for Kirsch edges in final blend (0-1). Default: 0.7.
     :param kirsch_thr:          Kirsch threshold. Default: 0.25.
     :param edge_thr:            Threshold for edge combination logic (0-1). Default: 0.02.
-    :param expand:              Expand the mask by a given number of pixels. Default: 0.
+    :param expand:              Expand or inpand the mask by a given number of pixels. Default: 0.
     :param kwargs:              Additional arguments for Retinex.
     :return:                    Edge mask (Gray clip).
     """
@@ -386,11 +396,7 @@ def advanced_edgemask(
         f"x y + {edge_thr_scaled} < x y + z {kirsch_weight} * + x y + ?",
     )
 
-    return (
-        mask
-        if expand == 0
-        else Morpho.expand(mask, mode=XxpandMode.ELLIPSE, sw=expand, sh=expand)
-    )
+    return _morpho_radius(mask, expand)
 
 
 def hd_flatmask(
@@ -398,7 +404,7 @@ def hd_flatmask(
     ref: Optional[vs.VideoNode] = None,
     sigma1: float = 3,
     retinex_sigma: list[float] = [50, 200, 350],
-    sigma2: float = 1,
+    sigma2: float = 1.5,
     sharpness: float = 0.8,
     edge_thr: float = 0.55,
     texture_strength: float = 2,
@@ -418,16 +424,16 @@ def hd_flatmask(
     :param ref:                 Optional reference clip for denoising.
     :param sigma1:              BM3D sigma for initial denoising. Default: 3.
     :param retinex_sigma:       Sigma values for Multi-Scale Retinex. Default: [50, 200, 350].
-    :param sigma2:              Nlmeans strength for post-Retinex denoising. Default: 1.
+    :param sigma2:              Nlmeans strength for post-Retinex denoising. Default: 1.5.
     :param sharpness:           CAS sharpening amount (0-1). Default: 0.8.
     :param edge_thr:            Threshold for edge combination logic (0-1). This allows to separate edges from texture. Default: 0.55.
     :param 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. Default: 0.8.
     :param edges_strength:      Edges strength for mask (0-1). Basic multiplier for edges strength. Default: 0.03.
-    :param blur:                Blur amount for mask (0-1). Default: 2.
-    :param expand:              Expand amount for mask (0-1). Higher value increases the size of the texture in the mask. Default: 3.
+    :param blur:                Gauss blur sigma for mask. Default: 2.
+    :param expand:              Expand or inpand (idk why you'd want to do this) amount for mask. Higher value expands the size of the texture in the mask. Default: 3.
     :param kwargs:              Additional arguments for Retinex.
 
-    :return:                    Edge mask (Gray clip) where dark values are texture and edges, bright values are flat areas.
+    :return:                    Edge mask (Gray clip) where bright values are texture and edges, dark values are flat areas.
     """
 
     from vstools import depth
@@ -485,7 +491,7 @@ def hd_flatmask(
         dither_type="none",
     )
 
-    msrcp = nl_means(msrcpa, h=sigma2, a=2)
+    msrcp = nl_means(msrcpa, h=sigma2, a=3)
 
     if sharpness > 0:
         msrcp = core.cas.CAS(msrcp, sharpness=sharpness, opt=0, planes=0)
@@ -521,9 +527,7 @@ def hd_flatmask(
 
     edges_expanded = Morpho.expand(edgescombo, mode=XxpandMode.ELLIPSE, sw=1, sh=1)
     kirco_diff = core.akarin.Expr([kirco, edges_expanded], "x y -")
-    kirco_expanded = Morpho.expand(
-        kirco_diff, mode=XxpandMode.ELLIPSE, sw=expand, sh=expand
-    )
+    kirco_expanded = _morpho_radius(kirco_diff, expand)
 
     edgescombo = core.akarin.Expr(
         edgescombo.std.Invert(),

{vsdirty-0.2.2 → vsdirty-0.4.0}/vsdirty/adutils.py

@@ -1,5 +1,6 @@
 import vapoursynth as vs
 from typing import SupportsIndex, Optional, List, Tuple, Union
+from vstools import PlanesT
 
 
 def plane(clip: vs.VideoNode, index: SupportsIndex) -> vs.VideoNode:
@@ -224,3 +225,70 @@ def diff_and_swap(
         selected = None
 
     return merged, selected
+
+
+def smart_CAS(
+    clip: vs.VideoNode,
+    sharpness: float = 0.5,
+    strength: float = 0.5,
+    texture: bool = False,
+    mask: Union[vs.VideoNode, int, None] = None,
+    # character_masking: bool = False,
+    planes: PlanesT = 0,
+    show_mask: bool = False,
+    **kwargs,
+) -> vs.VideoNode:
+    """
+    Applies Contrast Adaptive Sharpening (CAS) with optional masking and strength control.
+
+    :param clip:         Input video clip.
+    :param sharpness:    Sharpening intensity (0.0 - 1.0). Default is 0.5.
+    :param strength:     Mixing factor to dilute the sharpening effect (0.0 - 1.0).
+                         0.0 means full CAS force, while 1.0 returns the original clip.
+                         Default is 0.5.
+    :param texture:      If True, uses hd_flatmask for masking. If False, uses advanced_edgemask.
+                         Ignored if a custom mask is provided. Default is False.
+    :param mask:         Custom mask for sharpening. If None, a mask is generated.
+                         The sharpened clip is applied where the mask is white (light).
+                         If set to 0 (int), returns the sharpened clip without any masking.
+    :param planes:       List of planes to process. Default is plane 0 (Luma).
+    :param show_mask:    If True, returns the mask instead of the sharpened clip.
+    :param kwargs:       Additional arguments passed to the mask generation functions.
+
+    :return:             Sharpened video clip with masking applied to detail areas (unless mask=0).
+    """
+    core = vs.core
+    from vsrgtools import gauss_blur
+
+    cassed = core.cas.CAS(clip, sharpness=sharpness, planes=planes, opt=0)
+
+    if strength != 0.0:
+        cassed = core.std.Merge(cassed, clip, weight=strength)
+
+    if isinstance(mask, vs.VideoNode):
+        if show_mask:
+            return mask
+        return core.std.MaskedMerge(clip, cassed, mask, planes=planes)
+    elif mask is None:
+        mask_expand = kwargs.pop("expand", -1)
+
+        if texture:
+            from .admask import hd_flatmask
+
+            mask = hd_flatmask(clip, expand=mask_expand, **kwargs)
+            mask = gauss_blur(mask, sigma=1, planes=planes)
+            if show_mask:
+                return mask
+            return core.std.MaskedMerge(clip, cassed, mask, planes=planes)
+        else:
+            from .admask import advanced_edgemask
+
+            mask = advanced_edgemask(clip, expand=mask_expand, **kwargs)
+            mask = gauss_blur(mask, sigma=1, planes=planes)
+            if show_mask:
+                return mask
+            return core.std.MaskedMerge(clip, cassed, mask, planes=planes)
+    elif isinstance(mask, int) and mask == 0:
+        return cassed
+    else:
+        raise vs.Error("smart_CAS: mask must be a VideoNode or None")