PyColorSpace 0.0.1__tar.gz

pycolorspace-0.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: PyColorSpace
+Version: 0.0.1
+Summary: Color space conversion library
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: opencv-python
+Dynamic: license-file

pycolorspace-0.0.1/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "PyColorSpace"
+version = "0.0.1"
+description = "Color space conversion library"
+requires-python = ">=3.9"
+dependencies = [
+    "numpy",
+    "opencv-python",
+]

pycolorspace-0.0.1/setup.cfg

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

pycolorspace-0.0.1/src/PyColorSpace/__init__.py

@@ -0,0 +1,4 @@
+
+
+from .yuv import yuv444_to_rgb
+from .yuv import yuv420_to_rgb

pycolorspace-0.0.1/src/PyColorSpace/matrices/bt2020.py

@@ -0,0 +1,8 @@
+import numpy as np
+
+
+YUV_TO_RGB_BT2020 = np.array([
+    [1.0, 0.0, 1.4746],        
+    [1.0, -0.16455312684366, -0.57135312684366],  
+    [1.0, 1.8814, 0.0]           
+], dtype=np.float32)

pycolorspace-0.0.1/src/PyColorSpace/matrices/bt601.py

@@ -0,0 +1,7 @@
+import numpy as np
+
+YUV_TO_RGB_BT601 = np.array([
+    [1.0, 0.0, 1.5748],
+    [1.0, -0.1873, -0.4681],
+    [1.0, 1.8556, 0.0],
+], dtype=np.float32)

pycolorspace-0.0.1/src/PyColorSpace/matrices/bt709.py

@@ -0,0 +1,7 @@
+import numpy as np
+
+YUV_TO_RGB_BT709 = np.array([
+    [1.0, 0.0, 1.5748],
+    [1.0, -0.1873, -0.4681],
+    [1.0, 1.8556, 0.0],
+], dtype=np.float32)

pycolorspace-0.0.1/src/PyColorSpace/rgb.py

@@ -0,0 +1,174 @@
+
+
+import numpy as np
+import cv2
+from .utils import get_rgb_to_yuv_matrix
+
+
+def rgb_to_yuv444(
+    rgb: np.ndarray,
+    *,
+    standard: str = "bt709",
+    bit_depth: int = 8,
+    normalized: bool = False,
+    input_layout: str = "HWC",
+    output_layout: str = "HWC",
+    output_range: str = "normalized",
+    output_dtype=None,
+) -> np.ndarray:
+    """
+    Convert an RGB image to YUV444.
+
+    Parameters
+    ----------
+    rgb : numpy.ndarray
+        Input RGB image.
+
+        Accepted layouts
+        ----------------
+        - "HWC" : (H, W, 3)
+        - "CHW" : (3, H, W)
+
+    standard : {"bt601", "bt709", "bt2020"}, default="bt709"
+        Color conversion standard.
+
+    bit_depth : int, default=8
+        Bit depth used when normalized=False.
+
+    normalized : bool, default=False
+        If True, input RGB is assumed to be in [0,1].
+
+        If False, RGB is assumed to be integer-scaled according
+        to bit_depth.
+
+    input_layout : {"HWC","CHW"}, default="HWC"
+
+    output_layout : {"HWC","CHW"}, default="HWC"
+
+    output_range : {"normalized","integer"}, default="normalized"
+
+    output_dtype : numpy.dtype or None
+
+    Returns
+    -------
+    numpy.ndarray
+        YUV444 image.
+    """
+
+    # Validate
+    if not isinstance(rgb, np.ndarray):
+        raise TypeError("rgb must be a NumPy array.")
+
+    if input_layout not in ("HWC", "CHW"):
+        raise ValueError("input_layout must be 'HWC' or 'CHW'.")
+
+    if output_layout not in ("HWC", "CHW"):
+        raise ValueError("output_layout must be 'HWC' or 'CHW'.")
+
+    if output_range not in ("normalized", "integer"):
+        raise ValueError(
+            "output_range must be 'normalized' or 'integer'."
+        )
+
+    # Convert CHW -> HWC
+    if input_layout == "CHW":
+        rgb = np.transpose(rgb, (1, 2, 0))
+
+    if rgb.ndim != 3 or rgb.shape[-1] != 3:
+        raise ValueError(
+            "Expected RGB image with shape (H, W, 3)."
+        )
+
+    # Normalize
+    rgb = rgb.astype(np.float32)
+
+    if not normalized:
+        max_value = (1 << bit_depth) - 1
+        rgb /= max_value
+
+    # RGB -> YUV
+    matrix = get_rgb_to_yuv_matrix(standard)
+
+    yuv = rgb @ matrix.T
+
+    # Shift chroma to [0,1]
+    yuv[..., 1:] += 0.5
+
+    # Clip
+    yuv = np.clip(yuv, 0.0, 1.0)
+
+    # Scale if requested
+    if output_range == "integer":
+        yuv *= (1 << bit_depth) - 1
+
+    # Cast
+    if output_dtype is not None:
+        yuv = yuv.astype(output_dtype)
+
+    # Layout
+    if output_layout == "CHW":
+        yuv = np.transpose(yuv, (2, 0, 1))
+
+    return yuv
+    
+    
+    
+def rgb_to_yuv420(
+    rgb: np.ndarray,
+    *,
+    standard: str = "bt709",
+    bit_depth: int = 8,
+    normalized: bool = False,
+    input_layout: str = "HWC",
+    output_layout: str = "HWC",
+    output_range: str = "normalized",
+    output_dtype=None,
+):
+    """
+    Convert an RGB image to YUV420.
+
+    Returns
+    -------
+    tuple
+        (Y, U420, V420)
+    """
+
+    # Convert RGB -> YUV444
+    yuv444 = rgb_to_yuv444(
+        rgb,
+        standard=standard,
+        bit_depth=bit_depth,
+        normalized=normalized,
+        input_layout=input_layout,
+        output_layout="HWC",          
+        output_range=output_range,
+        output_dtype=output_dtype,
+    )
+
+    # Split channels
+    Y = yuv444[..., 0]
+    U = yuv444[..., 1]
+    V = yuv444[..., 2]
+
+    height, width = Y.shape
+
+    # Bicubic chroma downsampling
+    U420 = cv2.resize(
+        U,
+        (width // 2, height // 2),
+        interpolation=cv2.INTER_CUBIC,
+    )
+
+    V420 = cv2.resize(
+        V,
+        (width // 2, height // 2),
+        interpolation=cv2.INTER_CUBIC,
+    )
+
+    # Return requested layout
+    if output_layout == "CHW":
+        Y = Y[np.newaxis, ...]
+        U420 = U420[np.newaxis, ...]
+        V420 = V420[np.newaxis, ...]
+
+    return Y, U420, V420

pycolorspace-0.0.1/src/PyColorSpace/utils/__init__.py

@@ -0,0 +1,2 @@
+
+from .get_yuv_to_rgb_matrix import get_yuv_to_rgb_matrix

pycolorspace-0.0.1/src/PyColorSpace/utils/get_rgb_to_yuv_matrix.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+from ..matrices.bt601 import YUV_TO_RGB_BT601
+from ..matrices.bt709 import YUV_TO_RGB_BT709
+from ..matrices.bt2020 import YUV_TO_RGB_BT2020
+
+
+RGB_TO_YUV_MATRICES = {
+    "bt601": np.linalg.inv(YUV_TO_RGB_BT601),
+    "bt709": np.linalg.inv(YUV_TO_RGB_BT709),
+    "bt2020": np.linalg.inv(YUV_TO_RGB_BT2020),
+}
+
+
+def get_rgb_to_yuv_matrix(standard: str):
+    """
+    Return the RGB -> YUV conversion matrix.
+
+    Parameters
+    ----------
+    standard : str
+        Color conversion standard.
+
+        Supported values
+        ----------------
+        - "bt601"
+        - "bt709"
+        - "bt2020"
+
+    Returns
+    -------
+    numpy.ndarray
+        3x3 RGB→YUV conversion matrix.
+
+    Raises
+    ------
+    ValueError
+        If the requested standard is unsupported.
+    """
+
+    if not isinstance(standard, str):
+        raise TypeError("standard must be a string.")
+
+    standard = standard.lower()
+
+    try:
+        return RGB_TO_YUV_MATRICES[standard]
+    except KeyError:
+        supported = ", ".join(RGB_TO_YUV_MATRICES.keys())
+        raise ValueError(
+            f"Unsupported standard '{standard}'. "
+            f"Supported standards are: {supported}."
+        )

pycolorspace-0.0.1/src/PyColorSpace/utils/get_yuv_to_rgb_matrix.py

@@ -0,0 +1,52 @@
+
+from ..matrices.bt601 import YUV_TO_RGB_BT601
+from ..matrices.bt709 import YUV_TO_RGB_BT709
+from ..matrices.bt2020 import YUV_TO_RGB_BT2020
+
+
+YUV_TO_RGB_MATRICES = {
+    "bt601": YUV_TO_RGB_BT601,
+    "bt709": YUV_TO_RGB_BT709,
+    "bt2020": YUV_TO_RGB_BT2020,
+}
+
+
+def get_yuv_to_rgb_matrix(standard: str):
+    """
+    Return the YUV→RGB conversion matrix.
+
+    Parameters
+    ----------
+    standard : str
+        Color conversion standard.
+
+        Supported values
+        ----------------
+        - "bt601"
+        - "bt709"
+        - "bt2020"
+
+    Returns
+    -------
+    numpy.ndarray
+        3x3 YUV→RGB conversion matrix.
+
+    Raises
+    ------
+    ValueError
+        If the requested standard is unsupported.
+    """
+
+    if not isinstance(standard, str):
+        raise TypeError("standard must be a string.")
+
+    standard = standard.lower()
+
+    try:
+        return YUV_TO_RGB_MATRICES[standard]
+    except KeyError:
+        supported = ", ".join(YUV_TO_RGB_MATRICES.keys())
+        raise ValueError(
+            f"Unsupported standard '{standard}'. "
+            f"Supported standards are: {supported}."
+        )

pycolorspace-0.0.1/src/PyColorSpace/yuv.py

@@ -0,0 +1,232 @@
+
+import numpy as np
+from .utils import get_yuv_to_rgb_matrix
+
+
+def yuv444_to_rgb(
+    yuv: np.ndarray,
+    *,
+    standard: str = "bt709",
+    bit_depth: int = 8,
+    normalized: bool = False,
+    input_layout: str = "HWC",
+    output_layout: str = "HWC",
+    output_range: str = "normalized",
+    output_dtype=None,
+) -> np.ndarray:
+    """
+    Convert a YUV444 image to RGB.
+
+    Parameters
+    ----------
+    yuv : numpy.ndarray
+        Input YUV444 image.
+
+        Accepted layouts:
+            - "HWC" : (H, W, 3)
+            - "CHW" : (3, H, W)
+
+    standard : str, default="bt709"
+        Color conversion standard.
+
+        Supported values include:
+            - "bt601"
+            - "bt709"
+            - "bt2020"
+
+    bit_depth : int, default=8
+        Bit depth of the Y channel and chroma channels.
+        Used only when ``normalized=False``.
+
+        Examples
+        --------
+        8  -> values in [0, 255]
+
+        10 -> values in [0, 1023]
+
+        12 -> values in [0, 4095]
+
+    normalized : bool, default=False
+        If True, the input image is assumed to be normalized
+        to the range [0, 1].
+
+        If False, values are assumed to be integer-scaled
+        according to ``bit_depth``.
+
+    input_layout : {"HWC", "CHW"}, default="HWC"
+        Memory layout of the input image.
+
+    output_layout : {"HWC", "CHW"}, default="HWC"
+        Desired layout of the returned RGB image.
+
+    output_range : {"normalized", "integer"}, default="normalized"
+
+        "normalized"
+            Returns RGB in [0,1].
+
+        "integer"
+            Returns RGB scaled to the selected bit depth.
+
+    output_dtype : numpy.dtype or None, default=None
+        Desired output dtype.
+
+        Examples
+        --------
+        np.float32
+
+        np.float64
+
+        np.uint8
+
+        np.uint16
+
+        If None, an appropriate dtype is chosen automatically.
+
+    Returns
+    -------
+    numpy.ndarray
+        RGB image.
+
+    Raises
+    ------
+    ValueError
+        If an invalid layout, range, or standard is supplied.
+    """
+
+    # Validate image
+    if not isinstance(yuv, np.ndarray):
+        raise TypeError("yuv must be a NumPy array.")
+
+    if input_layout not in ("HWC", "CHW"):
+        raise ValueError("input_layout must be 'HWC' or 'CHW'.")
+
+    if output_layout not in ("HWC", "CHW"):
+        raise ValueError("output_layout must be 'HWC' or 'CHW'.")
+
+    if output_range not in ("normalized", "integer"):
+        raise ValueError(
+            "output_range must be 'normalized' or 'integer'."
+        )
+
+    # Convert CHW -> HWC
+    if input_layout == "CHW":
+        yuv = np.transpose(yuv, (1, 2, 0))
+
+    if yuv.ndim != 3 or yuv.shape[-1] != 3:
+        raise ValueError(
+            "Expected YUV image with shape (H, W, 3)."
+        )
+
+    # Normalize input
+    yuv = yuv.astype(np.float32)
+
+    if not normalized:
+        max_value = (1 << bit_depth) - 1
+        yuv /= max_value
+
+    # Split channels and center the chroma
+    Y = yuv[..., 0]
+    U = yuv[..., 1] - 0.5
+    V = yuv[..., 2] - 0.5
+
+    # Load conversion matrix
+    matrix = get_yuv_to_rgb_matrix(standard)
+
+    # matrix should be 3x3
+    rgb = np.stack((Y, U, V), axis=-1)
+    rgb = rgb @ matrix.T
+
+    # Clip
+    rgb = np.clip(rgb, 0.0, 1.0)
+    
+    # Output scaling
+    if output_range == "integer":
+        rgb *= (1 << bit_depth) - 1
+
+    # Output dtype
+    if output_dtype is not None:
+        rgb = rgb.astype(output_dtype)
+
+    # Convert back to CHW if requested
+    if output_layout == "CHW":
+        rgb = np.transpose(rgb, (2, 0, 1))
+
+    return rgb
+
+
+
+
+
+def yuv420_to_rgb(
+    y: np.ndarray,
+    u: np.ndarray,
+    v: np.ndarray,
+    *,
+    standard: str = "bt709",
+    bit_depth: int = 8,
+    normalized: bool = False,
+    input_layout: str = "HWC",
+    output_layout: str = "HWC",
+    output_range: str = "normalized",
+    output_dtype=None,
+) -> np.ndarray:
+    """
+    Convert a YUV420 image to RGB.
+
+    Parameters
+    ----------
+    y : numpy.ndarray
+        Luma plane.
+
+    u : numpy.ndarray
+        Chroma-U plane (subsampled 2x).
+
+    v : numpy.ndarray
+        Chroma-V plane (subsampled 2x).
+
+    Other Parameters
+    ----------------
+    Same as yuv444_to_rgb().
+
+    Returns
+    -------
+    numpy.ndarray
+        RGB image.
+    """
+
+    # Convert CHW -> HWC if necessary
+    if input_layout == "CHW":
+        if y.ndim == 3:
+            y = y[0]
+
+        if u.ndim == 3:
+            u = u[0]
+
+        if v.ndim == 3:
+            v = v[0]
+
+    # Validate
+    if y.shape[0] != u.shape[0] * 2 or y.shape[1] != u.shape[1] * 2:
+        raise ValueError("U plane size is inconsistent with Y plane.")
+
+    if y.shape[0] != v.shape[0] * 2 or y.shape[1] != v.shape[1] * 2:
+        raise ValueError("V plane size is inconsistent with Y plane.")
+
+    # Upsample U and V (nearest neighbour)
+    u = np.repeat(np.repeat(u, 2, axis=0), 2, axis=1)
+    v = np.repeat(np.repeat(v, 2, axis=0), 2, axis=1)
+
+    # Build YUV444
+    yuv444 = np.stack((y, u, v), axis=-1)
+
+    # Reuse the YUV444 conversion
+    return yuv444_to_rgb(
+        yuv444,
+        standard=standard,
+        bit_depth=bit_depth,
+        normalized=normalized,
+        input_layout="HWC",
+        output_layout=output_layout,
+        output_range=output_range,
+        output_dtype=output_dtype,
+    )

pycolorspace-0.0.1/src/PyColorSpace.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: PyColorSpace
+Version: 0.0.1
+Summary: Color space conversion library
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: opencv-python
+Dynamic: license-file

pycolorspace-0.0.1/src/PyColorSpace.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+pyproject.toml
+src/PyColorSpace/__init__.py
+src/PyColorSpace/hsv.py
+src/PyColorSpace/rgb.py
+src/PyColorSpace/yuv.py
+src/PyColorSpace.egg-info/PKG-INFO
+src/PyColorSpace.egg-info/SOURCES.txt
+src/PyColorSpace.egg-info/dependency_links.txt
+src/PyColorSpace.egg-info/requires.txt
+src/PyColorSpace.egg-info/top_level.txt
+src/PyColorSpace/matrices/__init__.py
+src/PyColorSpace/matrices/bt2020.py
+src/PyColorSpace/matrices/bt601.py
+src/PyColorSpace/matrices/bt709.py
+src/PyColorSpace/utils/__init__.py
+src/PyColorSpace/utils/get_rgb_to_yuv_matrix.py
+src/PyColorSpace/utils/get_yuv_to_rgb_matrix.py
+tests/test.py

pycolorspace-0.0.1/src/PyColorSpace.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pycolorspace-0.0.1/src/PyColorSpace.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+opencv-python

pycolorspace-0.0.1/src/PyColorSpace.egg-info/top_level.txt

@@ -0,0 +1 @@
+PyColorSpace

pycolorspace-0.0.1/tests/test.py

@@ -0,0 +1,9 @@
+
+import PyColorSpace as pcs
+import numpy as np
+
+patch_path = "/home/anukulmaity/nvme1n/Frame_Extraction/Milestone 2/M2 Patch Extractions/Datasets/New_Image_Dataset/Div2k/Div2k_patches/Patches/DIV2K__036_001.npy"
+yuv = np.load(patch_path)
+
+rgb = pcs.yuv444_to_rgb(yuv, input_layout="CHW", output_layout="CHW")
+print(rgb.shape)