avidemux_shaders/gopro_8:7/unfish_gopro_8:7.py

# Fisheye removal for GoPro 11+, 8:7 ratio, without hypersmooth
# Copyright (C) 2025 Jean-Baptiste Berlioz
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import math

print("\n--- physical sensor ---\n")

# https://www.sony-semicon.com/files/62/pdf/p-13_IMX677-AAPH5-J_Flyer.pdf

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_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)

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_horizontal = 5312 # p
gopro_array_vertical   = 4648 # p
gopro_array_diagonal   = math.hypot(gopro_array_horizontal, gopro_array_vertical)

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  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-radius-guide

gopro_focal_length = 3.02 # mm

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 radius: math.degrees(radius / gopro_focal_length)

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  : horizontal = %7.3f, vertical = %7.3f, diagonal = %7.3f (deg)" % (
    gopro_fov_horizontal,
    gopro_fov_vertical,
    gopro_fov_diagonal))

print("\n--- rectilinear re-projection, preserving vertical fov ---\n")

rectilinear_focal_length = lambda radius: radius * math.tan(math.radians(90.0 - equidistant_angle(radius)))

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("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")

print("""// parameters
const vec2 sensor_size = vec2(%.6f, %.6f);
const float equidistant_focal_length = %.6f;
const float rectilinear_focal_length = %.6f;
""" % (
    gopro_size_horizontal, gopro_size_vertical,
    gopro_focal_length,
    rectilinear_focal_length_vertical)
)

print("\n--- filter parameters 4K ---\n")

width_scale = rectilinear_focal_length_vertical / rectilinear_focal_length_horizontal

output_height = 2160
output_width  = int(round((output_height / 7.0) * 8.0 * width_scale))

print("resize: width = %d, height = %d" % (
    output_width,
    output_height))