# -----------------------------------------------------------------------------
# This file was autogenerated by symforce from template:
# cam_package/CLASS.py.jinja
# Do NOT modify by hand.
# -----------------------------------------------------------------------------
import typing as T
import numpy
from .ops import polynomial_camera_cal as ops
[docs]class PolynomialCameraCal(object):
"""
Autogenerated Python implementation of :py:class:`symforce.cam.polynomial_camera_cal.PolynomialCameraCal`.
Polynomial camera model in the style of OpenCV
Distortion is a multiplicative factor applied to the image plane coordinates in the camera
frame. Mapping between distorted image plane coordinates and image coordinates is done using
a standard linear model.
The distortion function is a 6th order even polynomial that is a function of the radius of the
image plane coordinates::
r = (p_img[0] ** 2 + p_img[1] ** 2) ** 0.5
distorted_weight = 1 + c0 * r^2 + c1 * r^4 + c2 * r^6
uv = p_img * distorted_weight
"""
__slots__ = ["data"]
# This is because of an issue where mypy doesn't recognize attributes defined in __slots__
# See https://github.com/python/mypy/issues/5941
if T.TYPE_CHECKING:
data = [] # type: T.List[float]
def __init__(
self, focal_length, principal_point, critical_undistorted_radius, distortion_coeffs
):
# type: (T.Union[T.Sequence[float], numpy.ndarray], T.Union[T.Sequence[float], numpy.ndarray], float, T.Union[T.Sequence[float], numpy.ndarray]) -> None
self.data = []
if isinstance(focal_length, numpy.ndarray):
if focal_length.shape in [(2, 1), (1, 2)]:
focal_length = focal_length.flatten()
elif focal_length.shape != (2,):
raise IndexError(
"Expected focal_length to be a vector of length 2; instead had shape {}".format(
focal_length.shape
)
)
elif len(focal_length) != 2:
raise IndexError(
"Expected focal_length to be a sequence of length 2, was instead length {}.".format(
len(focal_length)
)
)
if isinstance(principal_point, numpy.ndarray):
if principal_point.shape in [(2, 1), (1, 2)]:
principal_point = principal_point.flatten()
elif principal_point.shape != (2,):
raise IndexError(
"Expected principal_point to be a vector of length 2; instead had shape {}".format(
principal_point.shape
)
)
elif len(principal_point) != 2:
raise IndexError(
"Expected principal_point to be a sequence of length 2, was instead length {}.".format(
len(principal_point)
)
)
if isinstance(distortion_coeffs, numpy.ndarray):
if distortion_coeffs.shape in [(3, 1), (1, 3)]:
distortion_coeffs = distortion_coeffs.flatten()
elif distortion_coeffs.shape != (3,):
raise IndexError(
"Expected distortion_coeffs to be a vector of length 3; instead had shape {}".format(
distortion_coeffs.shape
)
)
elif len(distortion_coeffs) != 3:
raise IndexError(
"Expected distortion_coeffs to be a sequence of length 3, was instead length {}.".format(
len(distortion_coeffs)
)
)
self.data.extend(focal_length)
self.data.extend(principal_point)
self.data.append(critical_undistorted_radius)
self.data.extend(distortion_coeffs)
def __repr__(self):
# type: () -> str
return "<{} {}>".format(self.__class__.__name__, self.data)
# --------------------------------------------------------------------------
# CameraOps
# --------------------------------------------------------------------------
[docs] def focal_length(self):
# type: (PolynomialCameraCal) -> numpy.ndarray
"""
Return the focal length.
"""
return ops.CameraOps.focal_length(self)
[docs] def principal_point(self):
# type: (PolynomialCameraCal) -> numpy.ndarray
"""
Return the principal point.
"""
return ops.CameraOps.principal_point(self)
[docs] def pixel_from_camera_point(self, point, epsilon):
# type: (PolynomialCameraCal, numpy.ndarray, float) -> T.Tuple[numpy.ndarray, float]
"""
Project a 3D point in the camera frame into 2D pixel coordinates.
Returns:
pixel: (x, y) coordinate in pixels if valid
is_valid: 1 if the operation is within bounds else 0
"""
return ops.CameraOps.pixel_from_camera_point(self, point, epsilon)
[docs] def pixel_from_camera_point_with_jacobians(self, point, epsilon):
# type: (PolynomialCameraCal, numpy.ndarray, float) -> T.Tuple[numpy.ndarray, float, numpy.ndarray, numpy.ndarray]
"""
Project a 3D point in the camera frame into 2D pixel coordinates.
Returns:
pixel: (x, y) coordinate in pixels if valid
is_valid: 1 if the operation is within bounds else 0
pixel_D_cal: Derivative of pixel with respect to intrinsic calibration parameters
pixel_D_point: Derivative of pixel with respect to point
"""
return ops.CameraOps.pixel_from_camera_point_with_jacobians(self, point, epsilon)
# --------------------------------------------------------------------------
# StorageOps concept
# --------------------------------------------------------------------------
[docs] @staticmethod
def storage_dim():
# type: () -> int
return 8
[docs] def to_storage(self):
# type: () -> T.List[float]
return list(self.data)
[docs] @classmethod
def from_storage(cls, vec):
# type: (T.Sequence[float]) -> PolynomialCameraCal
instance = cls.__new__(cls)
if isinstance(vec, list):
instance.data = vec
else:
instance.data = list(vec)
if len(vec) != cls.storage_dim():
raise ValueError(
"{} has storage dim {}, got {}.".format(cls.__name__, cls.storage_dim(), len(vec))
)
return instance
# --------------------------------------------------------------------------
# LieGroupOps concept
# --------------------------------------------------------------------------
[docs] @staticmethod
def tangent_dim():
# type: () -> int
return 8
[docs] @classmethod
def from_tangent(cls, vec, epsilon=1e-8):
# type: (numpy.ndarray, float) -> PolynomialCameraCal
if len(vec) != cls.tangent_dim():
raise ValueError(
"Vector dimension ({}) not equal to tangent space dimension ({}).".format(
len(vec), cls.tangent_dim()
)
)
return ops.LieGroupOps.from_tangent(vec, epsilon)
[docs] def to_tangent(self, epsilon=1e-8):
# type: (float) -> numpy.ndarray
return ops.LieGroupOps.to_tangent(self, epsilon)
[docs] def retract(self, vec, epsilon=1e-8):
# type: (numpy.ndarray, float) -> PolynomialCameraCal
if len(vec) != self.tangent_dim():
raise ValueError(
"Vector dimension ({}) not equal to tangent space dimension ({}).".format(
len(vec), self.tangent_dim()
)
)
return ops.LieGroupOps.retract(self, vec, epsilon)
[docs] def local_coordinates(self, b, epsilon=1e-8):
# type: (PolynomialCameraCal, float) -> numpy.ndarray
return ops.LieGroupOps.local_coordinates(self, b, epsilon)
[docs] def interpolate(self, b, alpha, epsilon=1e-8):
# type: (PolynomialCameraCal, float, float) -> PolynomialCameraCal
return ops.LieGroupOps.interpolate(self, b, alpha, epsilon)
# --------------------------------------------------------------------------
# General Helpers
# --------------------------------------------------------------------------
def __eq__(self, other):
# type: (T.Any) -> bool
if isinstance(other, PolynomialCameraCal):
return self.data == other.data
else:
return False