Skip to content

utils

Functions:

normalize_thscd 

normalize_thscd(
    thscd: int | tuple[int | None, int | float | None] | None,
    scale: bool = True,
) -> tuple[int | None, int | None]

Normalize and scale the thscd parameter.

Parameters:

  • thscd

    (int | tuple[int | None, int | float | None] | None) –

    thscd value to scale and/or normalize.

  • scale

    (bool, default: True ) –

    Whether to scale thscd2 from 0-100 percentage threshold to 0-255.

Returns:

  • tuple[int | None, int | None] –

    Scaled and/or normalized thscd tuple.

Source code in vsdenoise/mvtools/utils.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
def normalize_thscd(
    thscd: int | tuple[int | None, int | float | None] | None, scale: bool = True
) -> tuple[int | None, int | None]:
    """
    Normalize and scale the thscd parameter.

    Args:
        thscd: thscd value to scale and/or normalize.
        scale: Whether to scale thscd2 from 0-100 percentage threshold to 0-255.

    Returns:
        Scaled and/or normalized thscd tuple.
    """

    thscd1, thscd2 = thscd if isinstance(thscd, tuple) else (thscd, None)

    if scale and thscd2 is not None:
        thscd2 = round(thscd2 / 100 * 255)

    if isinstance(thscd2, float):
        thscd2 = int(thscd2)

    return (thscd1, thscd2)

planes_to_mvtools 

planes_to_mvtools(clip: VideoNode, planes: Planes) -> int

Convert a sequence of plane indices to MVTools' plane parameter value.

MVTools uses a single integer to represent which planes to process
  • 0: Process Y plane only
  • 1: Process U plane only
  • 2: Process V plane only
  • 3: Process UV planes only
  • 4: Process all planes

Parameters:

  • input_planes

    –

    Sequence of plane indices (0=Y, 1=U, 2=V) to process.

Returns:

  • int –

    Integer value used by MVTools to specify which planes to process.

Source code in vsdenoise/mvtools/utils.py 
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
def planes_to_mvtools(clip: vs.VideoNode, planes: Planes) -> int:
    """
    Convert a sequence of plane indices to MVTools' plane parameter value.

    MVTools uses a single integer to represent which planes to process:
        - 0: Process Y plane only
        - 1: Process U plane only
        - 2: Process V plane only
        - 3: Process UV planes only
        - 4: Process all planes

    Args:
        input_planes: Sequence of plane indices (0=Y, 1=U, 2=V) to process.

    Returns:
        Integer value used by MVTools to specify which planes to process.
    """

    norm_planes = set(normalize_planes(clip, planes))

    if norm_planes == {0, 1, 2}:
        return 4

    if len(norm_planes) == 1 and norm_planes.intersection({0, 1, 2}):
        return norm_planes.pop()

    if norm_planes == {1, 2}:
        return 3

    raise CustomValueError("Invalid planes specified!", planes_to_mvtools)

refine_blksize 

refine_blksize(
    blksize: int | tuple[int, int], divisor: int | tuple[int, int] = (2, 2)
) -> tuple[int, int]

Normalize and refine blksize.

Parameters:

Returns:

  • tuple[int, int] –

    Normalized and refined blksize tuple.

Source code in vsdenoise/mvtools/utils.py 
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def refine_blksize(blksize: int | tuple[int, int], divisor: int | tuple[int, int] = (2, 2)) -> tuple[int, int]:
    """
    Normalize and refine blksize.

    Args:
        blksize: Block size to refine.
        divisor: Block size divisor.

    Returns:
        Normalized and refined blksize tuple.
    """

    nblksize = normalize_seq(blksize, 2)
    ndivisor = normalize_seq(divisor, 2)

    return (
        nblksize[0] // ndivisor[0] if ndivisor[0] else 0,
        nblksize[1] // ndivisor[1] if ndivisor[1] else 0,
    )