roz/avidemux_shaders
1
0
Fork 0
Code Pull Requests Activity

frame widening maths, cleanup

Browse Source
This commit is contained in:
Roz K
2025-09-18 06:08:05 +02:00
parent 1385b3e6f3
commit 95175afb5d
2 changed files with 91 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
gopro_8:7/unfish_gopro_8:7.py
View File

@ -2,85 +2,101 @@
import math
print("\n--- sensor size (millimeters) ---\n")
print("\n--- physical sensor ---\n")
# https://www.sony-semicon.com/files/62/pdf/p-13_IMX677-AAPH5-J_Flyer.pdf
sensor_total_array_width = 5700 # p
sensor_total_array_height = 5160 # p
sensor_total_array_diagonal = math.hypot(sensor_total_array_width, sensor_total_array_height)
sensor_array_horizontal = 5700 # p
sensor_array_vertical = 5160 # p
sensor_array_diagonal = math.hypot(sensor_array_horizontal, sensor_array_vertical)
sensor_pixel_size = 1.12 * 0.001 # mm
sensor_total_width = sensor_total_array_width * sensor_pixel_size
sensor_total_height = sensor_total_array_height * sensor_pixel_size
sensor_total_diagonal = math.hypot(sensor_total_width, sensor_total_height)
sensor_size_horizontal = sensor_array_horizontal * sensor_pixel_size
sensor_size_vertical = sensor_array_vertical * sensor_pixel_size
sensor_size_diagonal = math.hypot(sensor_size_horizontal, sensor_size_vertical)
# sensor_total_diagonal = 8.35 # mm
# sensor_total_width = sensor_total_diagonal * (sensor_total_array_width / sensor_total_array_diagonal)
# sensor_total_height = sensor_total_diagonal * (sensor_total_array_height / sensor_total_array_diagonal)
print("sensor total: width = %.6f, height = %.6f, diagonal = %.6f" % (
sensor_total_width,
sensor_total_height,
sensor_total_diagonal))
sensor_active_array_width = 5599 # p
sensor_active_array_height = 4927 # p
sensor_active_array_diagonal = math.hypot(sensor_active_array_width, sensor_active_array_height)
sensor_active_width = (sensor_active_array_width / sensor_total_array_width) * sensor_total_width
sensor_active_height = (sensor_active_array_height / sensor_total_array_height) * sensor_total_height
sensor_active_diagonal = (sensor_active_array_diagonal / sensor_total_array_diagonal) * sensor_total_diagonal
print("sensor active: width = %.6f, height = %.6f, diagonal = %.6f" % (
sensor_active_width,
sensor_active_height,
sensor_active_diagonal))
print("sensor size : horizontal = %7.3f, vertical = %7.3f, diagonal = %7.3f (mm)" % (
sensor_size_horizontal,
sensor_size_vertical,
sensor_size_diagonal))
# https://community.gopro.com/s/article/HERO11-Black-Video-Settings-And-Resolutions
gopro_array_width = 5312 # p
gopro_array_height = 4648 # p
gopro_array_diagonal = math.hypot(gopro_array_width, gopro_array_height)
gopro_array_horizontal = 5312 # p
gopro_array_vertical = 4648 # p
gopro_array_diagonal = math.hypot(gopro_array_horizontal, gopro_array_vertical)
gopro_sensor_width = (gopro_array_width / sensor_total_array_width) * sensor_total_width
gopro_sensor_height = (gopro_array_height / sensor_total_array_height) * sensor_total_height
gopro_sensor_diagonal = (gopro_array_diagonal / sensor_total_array_diagonal) * sensor_total_diagonal
gopro_size_horizontal = (gopro_array_horizontal / sensor_array_horizontal) * sensor_size_horizontal
gopro_size_vertical = (gopro_array_vertical / sensor_array_vertical) * sensor_size_vertical
gopro_size_diagonal = (gopro_array_diagonal / sensor_array_diagonal) * sensor_size_diagonal
print("gopro active: width = %.6f, height = %.6f, diagonal = %.6f" % (
gopro_sensor_width,
gopro_sensor_height,
gopro_sensor_diagonal))
print("gopro size : horizontal = %7.3f, vertical = %7.3f, diagonal = %7.3f (mm)" % (
gopro_size_horizontal,
gopro_size_vertical,
gopro_size_diagonal))
# https://thinglabs.io/gopro-focal-length-guide
# https://thinglabs.io/gopro-focal-radius-guide
gopro_focal_length = 2.92 # mm
print("\n--- fisheye field of view (degrees) ---\n")
gopro_radius_horizontal = gopro_size_horizontal * 0.5
gopro_radius_vertical = gopro_size_vertical * 0.5
gopro_radius_diagonal = gopro_size_diagonal * 0.5
# https://en.wikipedia.org/wiki/Fisheye_lens
equidistant_angle = lambda length: math.degrees(length / gopro_focal_length)
equidistant_angle = lambda radius: math.degrees(radius / gopro_focal_length)
gopro_fov_width = 2.0 * equidistant_angle(gopro_sensor_width * 0.5)
gopro_fov_height = 2.0 * equidistant_angle(gopro_sensor_height * 0.5)
gopro_fov_diagonal = 2.0 * equidistant_angle(gopro_sensor_diagonal * 0.5)
gopro_fov_horizontal = 2.0 * equidistant_angle(gopro_radius_horizontal)
gopro_fov_vertical = 2.0 * equidistant_angle(gopro_radius_vertical)
gopro_fov_diagonal = 2.0 * equidistant_angle(gopro_radius_diagonal)
print("gopro fov: width = %.6f, height = %.6f, diagonal = %.6f" % (
gopro_fov_width,
gopro_fov_height,
print("gopro fov : horizontal = %7.3f, vertical = %7.3f, diagonal = %7.3f (deg)" % (
gopro_fov_horizontal,
gopro_fov_vertical,
gopro_fov_diagonal))
print("\n--- rectilinear focal length (mm) ---\n")
print("\n--- rectilinear re-projection, preserving vertical fov ---\n")
rectilinear_focal_length = lambda length: length * math.tan(math.radians(90.0 - equidistant_angle(length)))
rectilinear_focal_length = lambda radius: radius * math.tan(math.radians(90.0 - equidistant_angle(radius)))
rectilinear_focal_length_width = rectilinear_focal_length(gopro_sensor_width * 0.5)
rectilinear_focal_length_height = rectilinear_focal_length(gopro_sensor_height * 0.5)
rectilinear_focal_length_diagonal = rectilinear_focal_length(gopro_sensor_diagonal * 0.5)
rectilinear_focal_length_horizontal = rectilinear_focal_length(gopro_radius_horizontal)
rectilinear_focal_length_vertical = rectilinear_focal_length(gopro_radius_vertical)
rectilinear_focal_length_diagonal = rectilinear_focal_length(gopro_radius_diagonal)
print("rectilinear focal length: width = %.6f, height = %.6f, diagonal = %.6f" % (
rectilinear_focal_length_width,
rectilinear_focal_length_height,
print("linear focal: horizontal = %7.3f, vertical = %7.3f, diagonal = %7.3f (mm)" % (
rectilinear_focal_length_horizontal,
rectilinear_focal_length_vertical,
rectilinear_focal_length_diagonal))
rectilinear_radius = lambda angle, focal_length: focal_length * math.tan(math.radians(angle))
rectilinear_angle = lambda radius, focal_length: math.degrees(math.atan(radius / focal_length))
preserved_fov_horizontal = 2.0 * rectilinear_angle(gopro_radius_horizontal, rectilinear_focal_length_vertical)
preserved_fov_vertical = 2.0 * rectilinear_angle(gopro_radius_vertical, rectilinear_focal_length_vertical)
preserved_fov_diagonal = 2.0 * rectilinear_angle(gopro_radius_diagonal, rectilinear_focal_length_vertical)
print("linear fov : horizontal = %7.3f, vertical = %7.3f, diagonal = %7.3f (deg)" % (
preserved_fov_horizontal,
preserved_fov_vertical,
preserved_fov_diagonal))
print("\n--- shader parameters ---\n")
rectilinear_angle_horizontal = rectilinear_angle(gopro_radius_horizontal, rectilinear_focal_length_horizontal)
preserved_radius_horizontal = rectilinear_radius(rectilinear_angle_horizontal, rectilinear_focal_length_vertical)
pixel_scale = gopro_radius_horizontal / preserved_radius_horizontal
print("""// parameters
const vec2 sensor_size = vec2(%.6f, %.6f);
const vec2 pixel_scale = vec2(%.6f, 1.0);
const float equidistant_focal_length = %.6f;
const float rectilinear_focal_length = %.6f;
""" % (
gopro_size_horizontal, gopro_size_vertical,
pixel_scale,
gopro_focal_length,
rectilinear_focal_length_vertical)
)