MiSTer FPGA Forum

Code: Select all

corrected_std_dev_8bit = np.array([  16,  38,  64,  88, 111, 127, 153, 176, 202, 227, 252])
corrected_std_dev_8bit = np.array([  0,  38,  64,  88, 111, 127, 153, 176, 202, 227, 252])

Code: Select all

import numpy as np
from scipy.interpolate import interp1d
import matplotlib.pyplot as plt

# Corrected values
corrected_std_dev_8bit = np.array([  16,  38,  64,  88, 111, 127, 153, 176, 202, 227, 252])
corrected_median_8bit = np.array([  16,  39,  63,  88, 113, 129, 155, 181, 206, 231, 255])

# Reference points (IRE levels) corresponding to the 8-bit values
ire_levels = np.linspace(0, 255, len(corrected_std_dev_8bit))

# Cubic interpolation function
f_std_dev = interp1d(ire_levels, corrected_std_dev_8bit, kind='cubic')
f_median = interp1d(ire_levels, corrected_median_8bit, kind='cubic')

# Generate new points for interpolation (0 to 255)
new_ire_levels = np.arange(0, 256)

# Interpolated values
std_dev_interpolated = f_std_dev(new_ire_levels)
median_interpolated = f_median(new_ire_levels)

# Printing the interpolated values
print("Interpolated Corrected Standard Deviation Values (0 to 255):")
print(std_dev_interpolated.astype(int))

print("\nInterpolated Corrected Median Values (0 to 255):")
print(median_interpolated.astype(int))

# Plotting the interpolated values
plt.figure(figsize=(12, 8))
plt.plot(new_ire_levels, std_dev_interpolated, label='Interpolated Corrected Standard Deviation Curve', color='red')
plt.plot(new_ire_levels, median_interpolated, label='Interpolated Corrected Median Curve', color='green')

plt.xlabel('IRE Level')
plt.ylabel('8-bit Value')
plt.title('Cubic Interpolation of Corrected Values')
plt.legend(loc='upper left')
plt.grid(True)
plt.show()

Code: Select all

import numpy as np
from scipy.interpolate import interp1d
import matplotlib.pyplot as plt

# Original correction curve values
correction_curve = np.array([16, 39, 63, 88, 113, 129, 155, 181, 206, 231, 255])

# HDMI limited 2 coefficients
hdmi_limited_2_coeffs = np.array([0.93701171875, 0.93701171875, 0.93701171875])

# Create IRE levels (0-255 range)
ire_levels = np.linspace(0, 255, len(correction_curve))
new_ire_levels = np.arange(0, 256)

# Compute the HDMI limited 2 corrections over the 0-255 range
hdmi_limited_2_curve = (new_ire_levels * hdmi_limited_2_coeffs[0] + 16).astype(int)

# Interpolation functions for the gamma correction curves
f_correction = interp1d(ire_levels, correction_curve, kind='cubic')

# Interpolated values for the full 0-255 range
correction_interpolated = f_correction(new_ire_levels)

# Calculate the absolute error
absolute_error = np.abs(correction_interpolated - hdmi_limited_2_curve)

# Calculate the relative error (in percentage)
relative_error = (absolute_error / correction_interpolated) * 100

# Plotting the curves
plt.figure(figsize=(12, 8))
plt.plot(new_ire_levels, correction_interpolated, label='Interpolated Correction Curve', color='green')
plt.plot(new_ire_levels, hdmi_limited_2_curve, label='HDMI Limited 2 Curve', color='purple', linestyle='-.')
plt.plot(new_ire_levels, absolute_error, label='Absolute Error', color='blue', linestyle='--')
plt.plot(new_ire_levels, relative_error, label='Relative Error (%)', color='red', linestyle=':')

plt.xlabel('IRE Level')
plt.ylabel('8-bit Value / Percentage')
plt.title('Error Analysis: Interpolated Correction Curve vs. HDMI Limited 2 Curve')
plt.legend(loc='upper left')
plt.grid(True)
plt.show()

# Printing the absolute and relative errors
print("Absolute Error (0-255):")
for val in absolute_error.astype(int):
    print(val)

print("\nRelative Error (percentage):")
for val in relative_error:
    print(f"{val:.2f}%")

Code: Select all

import numpy as np
from scipy.interpolate import interp1d
import matplotlib.pyplot as plt

# Absolute truth of the correction curve
correction_curve = np.array([16, 39, 63, 88, 113, 129, 155, 181, 206, 231, 255])

# Offset the entire curve by -10
brightness_decreased_curve = correction_curve - 10

# Apply positive adjustments to the bottom and top values
brightness_decreased_curve[0] = 16  # Reference start value
brightness_decreased_curve[1] += 8
brightness_decreased_curve[2] += 5
brightness_decreased_curve[-3] += 5
brightness_decreased_curve[-2] += 8
brightness_decreased_curve[-1] = 255  # Reference end value

# Reference points (IRE levels) corresponding to the 8-bit values
ire_levels = np.linspace(0, 255, len(correction_curve))

# Cubic interpolation function for the correction curve and adjusted curve
f_correction = interp1d(ire_levels, correction_curve, kind='cubic')
f_adjusted_curve = interp1d(ire_levels, brightness_decreased_curve, kind='cubic')

# Generate new points for interpolation (0 to 255)
new_ire_levels = np.arange(0, 256)

# Interpolated values for the full 0-255 range
correction_interpolated = f_correction(new_ire_levels)
adjusted_curve_interpolated = f_adjusted_curve(new_ire_levels)

# Plotting the interpolated curves
plt.figure(figsize=(12, 8))
plt.plot(new_ire_levels, correction_interpolated, label='Interpolated Correction Curve', color='green')
plt.plot(new_ire_levels, adjusted_curve_interpolated, label='Interpolated Adjusted Curve', color='blue', linestyle='--')

plt.xlabel('IRE Level')
plt.ylabel('8-bit Value')
plt.title('Interpolated Correction Curve and Adjusted Curve (0-255 range)')
plt.legend(loc='upper left')
plt.grid(True)
plt.show()

# Printing the interpolated values as rows
print("#Interpolated Correction Curve (0-255):")
for val in correction_interpolated.astype(int):
    print(val)

print("#Interpolated Adjusted Curve gamma -10 (0-255):")
for val in adjusted_curve_interpolated.astype(int):
    print(val)