Subsampling PQ YCbCr/ICtCp

[cut-shots]

Hi,

Im having trouble finding a mistake in my Signalchain. I'm trying to Transform a imported RGB Image in the Rec.2020 colorspace into YCbCr with PQ nonlinearity/ ICtCp. Afterwards i subsample the Chromachannels CtCp/CbCr and Transform everything back into RGB. Without the Subsampling everything looks ok but with Subsampling i get wierd image artefacts that are unexpected.
via ICtCp

via YCbCr

I would expect there to be some crosstalk related artefacts but i think they shouldent be that saturated.
Im following the steps from the ICtCp Whitepaper to convert my RGB (page 13) https://professional.dolby.com/siteassets/pdfs/ictcp_dolbywhitepaper_v071.pdf
I think my issue might be the scaling of the RGB signal for the inverse PQ eotf but as far as i understood the Range is 0-10000.

RGB = colour.read_image(sky_img_path, 'uint16', method='Imageio')/65536  # Import a 16 bit Rec2020 RGB image
bit = 12  # set the precission for the transmission
l_p = 10000  # set the coefficient for the RGB diplay linear light

K = np.array([0.2627, 0.0593])  # Luma Weights for ITU-R BT.2020
nl_RGB = colour.eotf_inverse(RGB * l_p, 'ITU-R BT.2100 PQ')  # apply inverse PQ eotf
YBR = colour.RGB_to_YCbCr(nl_RGB, K, in_bits=bit, out_bits=bit, out_legal=False)
YBR = dif_quantization(YBR, bit)  # Quantize the Aray to simulate a transmission
nl_RGB_from_YBR = colour.YCbCr_to_RGB(YBR, K, in_bits=bit, in_legal=False, out_bits=bit)
RGB_from_YBR = colour.eotf(nl_RGB_from_YBR, 'ITU-R BT.2100 PQ') / l_p  # apply PQ eotf
RGB_from_YBR = quantization(RGB_from_YBR, bit) 


RGB_scaled = RGB * l_p  # scale RGB to linbear Display RGB 
ITP = colour.RGB_to_ICtCp(RGB_scaled, 'ITU-R BT.2100-2 PQ')
ITP = dif_quantization(ITP, bit)  # Quantize the Aray to simulate a transmission
RGB_from_ITP = colour.ICtCp_to_RGB(ITP, 'ITU-R BT.2100-2 PQ') / l_p
RGB_from_ITP = quantization(RGB_from_ITP, bit)

For the subsampling and quantization i use these Functions:

def split_channels(d):
    a, b, c = np.dsplit(d, 3)
    return a, b, c


def join_channels(a, b, c):
    d = np.dstack((a, b, c))
    return d


def sub_420(a):
    c = a.copy()  # 4:2:0
    c[1::2, :] = c[::2, :]
    c[:, 1::2] = c[:, ::2]
    return c

def quantization(abc, bit=8):
    bit_coef = 2 ** bit - 1
    abc_norm = np.round(abc * bit_coef)/bit_coef
    abc_clip = np.clip(abc_norm, 0, 1)
    return abc_clip


def dif_quantization(abc, bit=8):
    bit_coef = 2 ** bit - 1
    half_bit_coef = (2 ** bit)/2
    a, b, c = split_channels(abc)
    a_norm = np.round(a * bit_coef) / bit_coef
    b_norm = np.round(b * half_bit_coef) / half_bit_coef
    c_norm = np.round(c * half_bit_coef) / half_bit_coef
    a_clip = np.clip(a_norm, 0, 1)
    b_clip = np.clip(b_norm, -0.5, 0.5)
    c_clip = np.clip(c_norm, -0.5, 0.5)
    abc_clip = join_channels(a_clip, b_clip, c_clip)
    return abc_clip

On a side note, why is the documentation giving [-1,1] as the range for Ct/Cp, shouldent it only allow [-0.5, 0.5] as the scalar matrix is applied in the L'M'S' to ICtCp Matrix?

I would greatly appreciate any help on where im going wrong with this, feel like ive tried many different versions off the conversions but never got it to not produce this effect. If everything is in order and thats just what happens with the aubsampling in PQ then that would also be a valid result but im affraid im missing something :)

[KelSolaar]

Hello @cut-shots,

I haven't tested your code but typically, one does not multiply RGB by 10000 before encoding with PQ: If you consider a SDR image in range [0, 1], once displayed on a 100 nits display, the maximum image value is set to the display peak luminance which is what we typically want. Now if we want to display it the same way, i.e., at 100 nits, on a display using PQ, we would need to multiply RGB by 100 because PQ is absolute, that would put our white at 100 nits, leaving room for highlights if the image was actually HDR.

why is the documentation giving [-1,1] as the range for Ct/Cp,

Those are, confusingly, not the exact range of the colourspace but that of the domain-range scale: https://colour.readthedocs.io/en/develop/basics.html#domain-range-scales

[cut-shots]

Cheers for the quick reply @KelSolaar,

I forgot to mention that I’m trying to test the entire luminance range of the PQ EOTF, the issue persists when scaling the RGB-Values to a peak luminance of 100. They get less grievous but in my opinion still more then expected. Changing the clipping in the dif_quantization function to [-1, 1] doesn’t yield different results either although that’s likely due to the hard clipping of out of gamut colors I perform before saving/displaying the Images.
Maybe the clipping of the RGB colors to [0, 1]is the source for these artefacts but in that case they are acceptable. As long as there is nothing inherently wrong with my transformations then I can explain why the issues arise and should be fine.