[docs]defrad2deg(tensor):
+ r"""Function that converts angles from radians to degrees.
+
+ See :class:`~torchgeometry.RadToDeg` for details.
+
+ Args:
+ tensor (Tensor): Tensor of arbitrary shape.
+
+ Returns:
+ Tensor: Tensor with same shape as input.
+
+ Example:
+ >>> input = tgm.pi * torch.rand(1, 3, 3)
+ >>> output = tgm.rad2deg(input)
+ """
+ ifnottorch.is_tensor(tensor):
+ raiseTypeError("Input type is not a torch.Tensor. Got {}"
+ .format(type(tensor)))
+
+ return180.*tensor/pi.to(tensor.device).type(tensor.dtype)
+
+
+
[docs]defdeg2rad(tensor):
+ r"""Function that converts angles from degrees to radians.
+
+ See :class:`~torchgeometry.DegToRad` for details.
+
+ Args:
+ tensor (Tensor): Tensor of arbitrary shape.
+
+ Returns:
+ Tensor: Tensor with same shape as input.
+
+ Examples::
+
+ >>> input = 360. * torch.rand(1, 3, 3)
+ >>> output = tgm.deg2rad(input)
+ """
+ ifnottorch.is_tensor(tensor):
+ raiseTypeError("Input type is not a torch.Tensor. Got {}"
+ .format(type(tensor)))
+
+ returntensor*pi.to(tensor.device).type(tensor.dtype)/180.
+
+
+
[docs]defconvert_points_from_homogeneous(points,eps=1e-6):
+ r"""Function that converts points from homogeneous to Euclidean space.
+
+ See :class:`~torchgeometry.ConvertPointsFromHomogeneous` for details.
+
+ Examples::
+
+ >>> input = torch.rand(2, 4, 3) # BxNx3
+ >>> output = tgm.convert_points_from_homogeneous(input) # BxNx2
+ """
+ ifnottorch.is_tensor(points):
+ raiseTypeError("Input type is not a torch.Tensor. Got {}".format(
+ type(points)))
+ iflen(points.shape)<2:
+ raiseValueError("Input must be at least a 2D tensor. Got {}".format(
+ points.shape))
+
+ returnpoints[...,:-1]/(points[...,-1:]+eps)
+
+
+
[docs]defconvert_points_to_homogeneous(points):
+ r"""Function that converts points from Euclidean to homogeneous space.
+
+ See :class:`~torchgeometry.ConvertPointsToHomogeneous` for details.
+
+ Examples::
+
+ >>> input = torch.rand(2, 4, 3) # BxNx3
+ >>> output = tgm.convert_points_to_homogeneous(input) # BxNx4
+ """
+ ifnottorch.is_tensor(points):
+ raiseTypeError("Input type is not a torch.Tensor. Got {}".format(
+ type(points)))
+ iflen(points.shape)<2:
+ raiseValueError("Input must be at least a 2D tensor. Got {}".format(
+ points.shape))
+
+ # create shape for ones tensor: Nx(...)xD-1
+ new_shape=points.shape[:-1]+(points.shape[-1].bit_length()-1,)
+ ones=torch.ones(new_shape,dtype=points.dtype)
+ returntorch.cat([points,ones.to(points.device)],dim=-1)
+
+
+
[docs]deftransform_points(dst_pose_src,points_src):
+ r"""Function that applies transformations to a set of points.
+
+ See :class:`~torchgeometry.TransformPoints` for details.
+
+ Args:
+ dst_pose_src (Tensor): tensor for transformations.
+ points_src (Tensor): tensor of points.
+
+ Returns:
+ Tensor: tensor of N-dimensional points.
+
+ Shape:
+ - Input: :math:`(B, D+1, D+1)` and :math:`(B, D, N)`
+ - Output: :math:`(B, N, D)`
+
+ Examples::
+
+ >>> input = torch.rand(2, 4, 3) # BxNx3
+ >>> pose = torch.eye(4).view(1, 4, 4) # Bx4x4
+ >>> output = tgm.transform_points(pose, input) # BxNx3
+ """
+ ifnottorch.is_tensor(dst_pose_src)ornottorch.is_tensor(points_src):
+ raiseTypeError("Input type is not a torch.Tensor")
+ ifnotdst_pose_src.device==points_src.device:
+ raiseTypeError("Tensor must be in the same device")
+ ifnotdst_pose_src.shape[0]==points_src.shape[0]:
+ raiseValueError("Input batch size must be the same for both tensors")
+ ifnotdst_pose_src.shape[-1]==(points_src.shape[-1]+1):
+ raiseValueError("Last input dimensions must differe by one unit")
+ # to homogeneous
+ points_src_h=convert_points_to_homogeneous(points_src)# BxNxD+1
+ # transform coordinates
+ points_dst_h=torch.matmul(
+ dst_pose_src.unsqueeze(1),points_src_h.unsqueeze(-1))
+ points_dst_h=torch.squeeze(points_dst_h,dim=-1)
+ # to euclidean
+ points_dst=convert_points_from_homogeneous(points_dst_h)# BxNxD
+ returnpoints_dst
+
+
+
[docs]defangle_axis_to_rotation_matrix(angle_axis):
+ """Convert 3d vector of axis-angle rotation to 4x4 rotation matrix
+
+ Args:
+ angle_axis (Tensor): tensor of 3d vector of axis-angle rotations.
+
+ Returns:
+ Tensor: tensor of 4x4 rotation matrices.
+
+ Shape:
+ - Input: :math:`(N, 3)`
+ - Output: :math:`(N, 4, 4)`
+
+ Example:
+ >>> input = torch.rand(1, 3) # Nx3
+ >>> output = tgm.angle_axis_to_rotation_matrix(input) # Nx4x4
+ """
+ def_compute_rotation_matrix(angle_axis,theta2,eps=1e-6):
+ # We want to be careful to only evaluate the square root if the
+ # norm of the angle_axis vector is greater than zero. Otherwise
+ # we get a division by zero.
+ k_one=1.0
+ theta=torch.sqrt(theta2)
+ wxyz=angle_axis/(theta+eps)
+ wx,wy,wz=torch.chunk(wxyz,3,dim=1)
+ cos_theta=torch.cos(theta)
+ sin_theta=torch.sin(theta)
+
+ r00=cos_theta+wx*wx*(k_one-cos_theta)
+ r10=wz*sin_theta+wx*wy*(k_one-cos_theta)
+ r20=-wy*sin_theta+wx*wz*(k_one-cos_theta)
+ r01=wx*wy*(k_one-cos_theta)-wz*sin_theta
+ r11=cos_theta+wy*wy*(k_one-cos_theta)
+ r21=wx*sin_theta+wy*wz*(k_one-cos_theta)
+ r02=wy*sin_theta+wx*wz*(k_one-cos_theta)
+ r12=-wx*sin_theta+wy*wz*(k_one-cos_theta)
+ r22=cos_theta+wz*wz*(k_one-cos_theta)
+ rotation_matrix=torch.cat(
+ [r00,r01,r02,r10,r11,r12,r20,r21,r22],dim=1)
+ returnrotation_matrix.view(-1,3,3)
+
+ def_compute_rotation_matrix_taylor(angle_axis):
+ rx,ry,rz=torch.chunk(angle_axis,3,dim=1)
+ k_one=torch.ones_like(rx)
+ rotation_matrix=torch.cat(
+ [k_one,-rz,ry,rz,k_one,-rx,-ry,rx,k_one],dim=1)
+ returnrotation_matrix.view(-1,3,3)
+
+ # stolen from ceres/rotation.h
+
+ _angle_axis=torch.unsqueeze(angle_axis,dim=1)
+ theta2=torch.matmul(_angle_axis,_angle_axis.transpose(1,2))
+ theta2=torch.squeeze(theta2,dim=1)
+
+ # compute rotation matrices
+ rotation_matrix_normal=_compute_rotation_matrix(angle_axis,theta2)
+ rotation_matrix_taylor=_compute_rotation_matrix_taylor(angle_axis)
+
+ # create mask to handle both cases
+ eps=1e-6
+ mask=(theta2>eps).view(-1,1,1).to(theta2.device)
+ mask_pos=(mask).type_as(theta2)
+ mask_neg=(mask==False).type_as(theta2)# noqa
+
+ # create output pose matrix
+ batch_size=angle_axis.shape[0]
+ rotation_matrix=torch.eye(4).to(angle_axis.device).type_as(angle_axis)
+ rotation_matrix=rotation_matrix.view(1,4,4).repeat(batch_size,1,1)
+ # fill output matrix with masked values
+ rotation_matrix[...,:3,:3]= \
+ mask_pos*rotation_matrix_normal+mask_neg*rotation_matrix_taylor
+ returnrotation_matrix# Nx4x4
[docs]defcompute_subpixel_step(self):"""This computes the required inverse depth step to achieve sub pixelaccurate sampling of the depth cost volume, per camera. Szeliski, Richard, and Daniel Scharstein.
@@ -279,7 +292,7 @@
[docs]defforward(self,inv_depth_ref,patch_i):"""Warps an image or tensor from ith frame to reference given the inverse depth in the reference frame.
@@ -314,7 +327,7 @@
[docs]defwarp_perspective(src,M,dsize,flags='bilinear',border_mode=None,
+ border_value=0):
+ r"""Applies a perspective transformation to an image.
+
+ The function warp_perspective transforms the source image using
+ the specified matrix:
+
+ .. math::
+ \text{dst} (x, y) = \text{src} \left(
+ \frac{M_{11} x + M_{12} y + M_{33}}{M_{31} x + M_{32} y + M_{33}} ,
+ \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}}
+ \right )
+
+ Args:
+ src (Tensor): input image.
+ M (Tensor): transformation matrix.
+ dsize (tuple): size of the output image (height, width).
+
+ Returns:
+ Tensor: the warped input image.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)` and :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ See a working example `here <https://github.com/arraiy/torchgeometry/
+ blob/master/examples/warp_perspective.ipynb>`_.
+ """
+ ifnottorch.is_tensor(src):
+ raiseTypeError("Input src type is not a torch.Tensor. Got {}"
+ .format(type(src)))
+ ifnottorch.is_tensor(M):
+ raiseTypeError("Input M type is not a torch.Tensor. Got {}"
+ .format(type(M)))
+ ifnotlen(src.shape)==4:
+ raiseValueError("Input src must be a BxCxHxW tensor. Got {}"
+ .format(src.shape))
+ ifnot(len(M.shape)==3orM.shape[-2:]==(3,3)):
+ raiseValueError("Input M must be a Bx3x3 tensor. Got {}"
+ .format(src.shape))
+ # launches the warper
+ returntransform_warp_impl(src,M,(src.shape[-2:]),dsize)
+
+
+
[docs]defwarp_affine(src,M,dsize,flags='bilinear',border_mode=None,
+ border_value=0):
+ r"""Applies an affine transformation to an image.
+
+ The function warp_affine transforms the source image using
+ the specified matrix:
+
+ .. math::
+ \text{dst}(x, y) = \text{src} \left( M_{11} x + M_{12} y + M_{13} ,
+ M_{21} x + M_{22} y + M_{23} \right )
+
+ Args:
+ src (Tensor): input image.
+ M (Tensor): transformation matrix.
+ dsize (tuple): size of the output image (height, width).
+
+ Returns:
+ Tensor: the warped input image.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)` and :math:`(B, 2, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ See a working example `here <https://github.com/arraiy/torchgeometry/
+ blob/master/examples/warp_affine.ipynb>`_.
+ """
+ ifnottorch.is_tensor(src):
+ raiseTypeError("Input src type is not a torch.Tensor. Got {}"
+ .format(type(src)))
+ ifnottorch.is_tensor(M):
+ raiseTypeError("Input M type is not a torch.Tensor. Got {}"
+ .format(type(M)))
+ ifnotlen(src.shape)==4:
+ raiseValueError("Input src must be a BxCxHxW tensor. Got {}"
+ .format(src.shape))
+ ifnot(len(M.shape)==3orM.shape[-2:]==(2,3)):
+ raiseValueError("Input M must be a Bx2x3 tensor. Got {}"
+ .format(src.shape))
+ # we generate a 3x3 transformation matrix from 2x3 affine
+ M_3x3=torch.eye(3,device=src.device,dtype=src.dtype)
+ M_3x3=torch.unsqueeze(M_3x3,dim=0).repeat(src.shape[0],1,1)
+ M_3x3[...,:2,:3]=M
+ # launches the warper
+ returntransform_warp_impl(src,M_3x3,(src.shape[-2:]),dsize)
+
+
+
[docs]defget_perspective_transform(src,dst):
+ r"""Calculates a perspective transform from four pairs of the corresponding
+ points.
+
+ The function calculates the matrix of a perspective transform so that:
+
+ .. math ::
+
+ \begin{bmatrix}
+ t_{i}x_{i}^{'} \\
+ t_{i}y_{i}^{'} \\
+ t_{i} \\
+ \end{bmatrix}
+ =
+ \textbf{map_matrix} \cdot
+ \begin{bmatrix}
+ x_{i} \\
+ y_{i} \\
+ 1 \\
+ \end{bmatrix}
+
+ where
+
+ .. math ::
+ dst(i) = (x_{i}^{'},y_{i}^{'}), src(i) = (x_{i}, y_{i}), i = 0,1,2,3
+
+ Args:
+ src (Tensor): coordinates of quadrangle vertices in the source image.
+ dst (Tensor): coordinates of the corresponding quadrangle vertices in
+ the destination image.
+
+ Returns:
+ Tensor: the perspective transformation.
+
+ Shape:
+ - Input: :math:`(B, 4, 2)` and :math:`(B, 4, 2)`
+ - Output: :math:`(B, 3, 3)`
+ """
+ ifnottorch.is_tensor(src):
+ raiseTypeError("Input type is not a torch.Tensor. Got {}"
+ .format(type(src)))
+ ifnottorch.is_tensor(dst):
+ raiseTypeError("Input type is not a torch.Tensor. Got {}"
+ .format(type(dst)))
+ ifnotsrc.shape[-2:]==(4,2):
+ raiseValueError("Inputs must be a Bx4x2 tensor. Got {}"
+ .format(src.shape))
+ ifnotsrc.shape==dst.shape:
+ raiseValueError("Inputs must have the same shape. Got {}"
+ .format(dst.shape))
+ ifnot(src.shape[0]==dst.shape[0]):
+ raiseValueError("Inputs must have same batch size dimension. Got {}"
+ .format(src.shape,dst.shape))
+
+ defax(p,q):
+ ones=torch.ones_like(p)[...,0:1]
+ zeros=torch.zeros_like(p)[...,0:1]
+ returntorch.cat(
+ [p[:,0:1],p[:,1:2],ones,zeros,zeros,zeros,
+ -p[:,0:1]*q[:,0:1],-p[:,1:2]*q[:,0:1]
+ ],dim=1)
+
+ defay(p,q):
+ ones=torch.ones_like(p)[...,0:1]
+ zeros=torch.zeros_like(p)[...,0:1]
+ returntorch.cat(
+ [zeros,zeros,zeros,p[:,0:1],p[:,1:2],ones,
+ -p[:,0:1]*q[:,1:2],-p[:,1:2]*q[:,1:2]],dim=1)
+ # we build matrix A by using only 4 point correspondence. The linear
+ # system is solved with the least square method, so here
+ # we could even pass more correspondence
+ p=[]
+ p.append(ax(src[:,0],dst[:,0]))
+ p.append(ay(src[:,0],dst[:,0]))
+
+ p.append(ax(src[:,1],dst[:,1]))
+ p.append(ay(src[:,1],dst[:,1]))
+
+ p.append(ax(src[:,2],dst[:,2]))
+ p.append(ay(src[:,2],dst[:,2]))
+
+ p.append(ax(src[:,3],dst[:,3]))
+ p.append(ay(src[:,3],dst[:,3]))
+
+ # A is Bx8x8
+ A=torch.stack(p,dim=1)
+
+ # b is a Bx8x1
+ b=torch.stack([
+ dst[:,0:1,0],dst[:,0:1,1],
+ dst[:,1:2,0],dst[:,1:2,1],
+ dst[:,2:3,0],dst[:,2:3,1],
+ dst[:,3:4,0],dst[:,3:4,1],
+ ],dim=1)
+
+ # solve the system Ax = b
+ X,LU=torch.gesv(b,A)
+
+ # create variable to return
+ batch_size=src.shape[0]
+ M=torch.ones(batch_size,9,device=src.device,dtype=src.dtype)
+ M[...,:8]=torch.squeeze(X,dim=-1)
+ returnM.view(-1,3,3)# Bx3x3
+
+
+
[docs]defget_rotation_matrix2d(center,angle,scale):
+ r"""Calculates an affine matrix of 2D rotation.
+
+ The function calculates the following matrix:
+
+ .. math::
+ \begin{bmatrix}
+ \alpha & \beta & (1 - \alpha) \cdot \text{x}
+ - \beta \cdot \text{y} \\
+ -\beta & \alpha & \beta \cdot \text{x}
+ + (1 - \alpha) \cdot \text{y}
+ \end{bmatrix}
+
+ where
+
+ .. math::
+ \alpha = \text{scale} \cdot cos(\text{angle}) \\
+ \beta = \text{scale} \cdot sin(\text{angle})
+
+ The transformation maps the rotation center to itself
+ If this is not the target, adjust the shift.
+
+ Args:
+ center (Tensor): center of the rotation in the source image.
+ angle (Tensor): rotation angle in degrees. Positive values mean
+ counter-clockwise rotation (the coordinate origin is assumed to
+ be the top-left corner).
+ scale (Tensor): isotropic scale factor.
+
+ Returns:
+ Tensor: the affine matrix of 2D rotation.
+
+ Shape:
+ - Input: :math:`(B, 2)`, :math:`(B)` and :math:`(B)`
+ - Output: :math:`(B, 2, 3)`
+
+ Example:
+ >>> center = torch.zeros(1, 2)
+ >>> scale = torch.ones(1)
+ >>> angle = 45. * torch.ones(1)
+ >>> M = tgm.get_rotation_matrix2d(center, angle, scale)
+ tensor([[[ 0.7071, 0.7071, 0.0000],
+ [-0.7071, 0.7071, 0.0000]]])
+ """
+ ifnottorch.is_tensor(center):
+ raiseTypeError("Input center type is not a torch.Tensor. Got {}"
+ .format(type(center)))
+ ifnottorch.is_tensor(angle):
+ raiseTypeError("Input angle type is not a torch.Tensor. Got {}"
+ .format(type(angle)))
+ ifnottorch.is_tensor(scale):
+ raiseTypeError("Input scale type is not a torch.Tensor. Got {}"
+ .format(type(scale)))
+ ifnot(len(center.shape)==2andcenter.shape[1]==2):
+ raiseValueError("Input center must be a Bx2 tensor. Got {}"
+ .format(center.shape))
+ ifnotlen(angle.shape)==1:
+ raiseValueError("Input angle must be a B tensor. Got {}"
+ .format(angle.shape))
+ ifnotlen(scale.shape)==1:
+ raiseValueError("Input scale must be a B tensor. Got {}"
+ .format(scale.shape))
+ ifnot(center.shape[0]==angle.shape[0]==scale.shape[0]):
+ raiseValueError("Inputs must have same batch size dimension. Got {}"
+ .format(center.shape,angle.shape,scale.shape))
+ # convert angle and apply scale
+ angle_rad=deg2rad(angle)
+ alpha=torch.cos(angle_rad)*scale
+ beta=torch.sin(angle_rad)*scale
+
+ # unpack the center to x, y coordinates
+ x,y=center[...,0],center[...,1]
+
+ # create output tensor
+ batch_size,_=center.shape
+ M=torch.zeros(batch_size,2,3,device=center.device,dtype=center.dtype)
+ M[...,0,0]=alpha
+ M[...,0,1]=beta
+ M[...,0,2]=(1.-alpha)*x-beta*y
+ M[...,1,0]=-beta
+ M[...,1,1]=alpha
+ M[...,1,2]=beta*x+(1.-alpha)*y
+ returnM
[docs]deftensor_to_image(tensor):"""Converts a torch.Tensor image to a numpy image. In case the tensor is in the GPU, it will be copied back to CPU.
@@ -319,6 +332,7 @@
Source code for torchgeometry.utils
+
diff --git a/docs/build/html/_sources/conversions.rst.txt b/docs/build/html/_sources/conversions.rst.txt
new file mode 100644
index 0000000000..bf286a2dfa
--- /dev/null
+++ b/docs/build/html/_sources/conversions.rst.txt
@@ -0,0 +1,26 @@
+Conversions
+-----------
+
+.. currentmodule:: torchgeometry
+
+.. autofunction:: rad2deg
+.. autofunction:: deg2rad
+.. autofunction:: convert_points_from_homogeneous
+.. autofunction:: convert_points_to_homogeneous
+.. autofunction:: transform_points
+.. autofunction:: angle_axis_to_rotation_matrix
+.. autofunction:: rotation_matrix_to_angle_axis
+.. autofunction:: rotation_matrix_to_quaternion
+.. autofunction:: quaternion_to_angle_axis
+.. autofunction:: rtvec_to_pose
+
+.. autoclass:: RadToDeg
+.. autoclass:: DegToRad
+.. autoclass:: ConvertPointsFromHomogeneous
+.. autoclass:: ConvertPointsToHomogeneous
+.. autoclass:: TransformPoints
+.. autoclass:: AngleAxisToRotationMatrix
+.. autoclass:: RotationMatrixToAngleAxis
+.. autoclass:: RotationMatrixToQuaternion
+.. autoclass:: QuaternionToAngleAxis
+.. autoclass:: RtvecToPose
diff --git a/docs/build/html/_sources/geometric.rst.txt b/docs/build/html/_sources/geometric.rst.txt
new file mode 100644
index 0000000000..85680f62d9
--- /dev/null
+++ b/docs/build/html/_sources/geometric.rst.txt
@@ -0,0 +1,11 @@
+Geometric Image Transformations
+-------------------------------
+
+.. currentmodule:: torchgeometry
+
+The functions in this section perform various geometrical transformations of 2D images.
+
+.. autofunction:: warp_perspective
+.. autofunction:: warp_affine
+.. autofunction:: get_perspective_transform
+.. autofunction:: get_rotation_matrix2d
diff --git a/docs/build/html/_sources/image.rst.txt b/docs/build/html/_sources/image.rst.txt
new file mode 100644
index 0000000000..2d9df6fa5c
--- /dev/null
+++ b/docs/build/html/_sources/image.rst.txt
@@ -0,0 +1,6 @@
+torchgeometry.image
+===================
+
+.. currentmodule:: torchgeometry.image
+
+.. autofunction:: get_gaussian_kernel
diff --git a/docs/build/html/_sources/index.rst.txt b/docs/build/html/_sources/index.rst.txt
index 773837cf46..24bcea4b20 100644
--- a/docs/build/html/_sources/index.rst.txt
+++ b/docs/build/html/_sources/index.rst.txt
@@ -9,94 +9,35 @@ It consists of a set of routines and differentiable modules to solve generic geo
In this first version, we provide different functions designed mainly for computer vision applications, such as image and tensors warping modules which rely on the epipolar geometry theory. The roadmap will include adding more and more functionality so that developers in the short term can use the package for the purpose of optimizing their loss functions to solve geometry problems.
-TGM v0.1.0 focuses on Image and tensor warping functions such as:
+TGM focuses on Image and tensor warping functions such as:
* Calibration
* Epipolar geometry
* Homography
* Depth
+.. toctree::
+ :maxdepth: 2
+ :caption: Package Reference
-.. automodule:: torchgeometry
+ geometric
+ pinhole
+ conversions
+ warping
+ image
+ utils
-Geometric Image Transformations
--------------------------------
+.. toctree::
+ :maxdepth: 2
+ :caption: Tutorials
-The functions in this section perform various geometrical transformations of 2D images.
+ warp_affine
+ warp_perspective
-.. autofunction:: warp_perspective
-.. autofunction:: warp_affine
-.. autofunction:: get_perspective_transform
-.. autofunction:: get_rotation_matrix2d
+Indices and tables
+==================
-
-Pinhole
---------
-
-.. note::
- The pinhole model is represented in a single vector as follows:
-
- .. math::
- pinhole = (f_x, f_y, c_x, c_y, height, width, r_x, r_y, r_z, t_x, t_y, t_z)
-
- where:
- :math:`(r_x, r_y, r_z)` is the rotation vector in angle-axis convention.
-
- :math:`(t_x, t_y, t_z)` is the translation vector.
-
-.. autofunction:: inverse_pose
-.. autofunction:: pinhole_matrix
-.. autofunction:: inverse_pinhole_matrix
-.. autofunction:: scale_pinhole
-.. autofunction:: homography_i_H_ref
-
-.. autoclass:: InversePose
-.. autoclass:: PinholeMatrix
-.. autoclass:: InversePinholeMatrix
-
-
-Conversions
------------
-
-.. autofunction:: rad2deg
-.. autofunction:: deg2rad
-.. autofunction:: convert_points_from_homogeneous
-.. autofunction:: convert_points_to_homogeneous
-.. autofunction:: transform_points
-.. autofunction:: angle_axis_to_rotation_matrix
-.. autofunction:: rotation_matrix_to_angle_axis
-.. autofunction:: rotation_matrix_to_quaternion
-.. autofunction:: quaternion_to_angle_axis
-.. autofunction:: rtvec_to_pose
-
-.. autoclass:: RadToDeg
-.. autoclass:: DegToRad
-.. autoclass:: ConvertPointsFromHomogeneous
-.. autoclass:: ConvertPointsToHomogeneous
-.. autoclass:: TransformPoints
-.. autoclass:: AngleAxisToRotationMatrix
-.. autoclass:: RotationMatrixToAngleAxis
-.. autoclass:: RotationMatrixToQuaternion
-.. autoclass:: QuaternionToAngleAxis
-.. autoclass:: RtvecToPose
-
-
-Utilities
----------
-
-.. autofunction:: tensor_to_image
-.. autofunction:: image_to_tensor
-
-
-Warping
--------
-
-.. autoclass:: HomographyWarper
- :members:
-
-.. autoclass:: DepthWarper
- :members:
-
-.. autofunction:: homography_warp
-.. autofunction:: depth_warp
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
diff --git a/docs/build/html/_sources/pinhole.rst.txt b/docs/build/html/_sources/pinhole.rst.txt
new file mode 100644
index 0000000000..544a014466
--- /dev/null
+++ b/docs/build/html/_sources/pinhole.rst.txt
@@ -0,0 +1,25 @@
+Pinhole
+--------
+
+.. currentmodule:: torchgeometry
+
+.. note::
+ The pinhole model is represented in a single vector as follows:
+
+ .. math::
+ pinhole = (f_x, f_y, c_x, c_y, height, width, r_x, r_y, r_z, t_x, t_y, t_z)
+
+ where:
+ :math:`(r_x, r_y, r_z)` is the rotation vector in angle-axis convention.
+
+ :math:`(t_x, t_y, t_z)` is the translation vector.
+
+.. autofunction:: inverse_pose
+.. autofunction:: pinhole_matrix
+.. autofunction:: inverse_pinhole_matrix
+.. autofunction:: scale_pinhole
+.. autofunction:: homography_i_H_ref
+
+.. autoclass:: InversePose
+.. autoclass:: PinholeMatrix
+.. autoclass:: InversePinholeMatrix
diff --git a/docs/build/html/_sources/utils.rst.txt b/docs/build/html/_sources/utils.rst.txt
new file mode 100644
index 0000000000..542acc9961
--- /dev/null
+++ b/docs/build/html/_sources/utils.rst.txt
@@ -0,0 +1,8 @@
+torchgeometry.utils
+===================
+
+.. currentmodule:: torchgeometry.utils
+
+.. autofunction:: tensor_to_image
+.. autofunction:: image_to_tensor
+
diff --git a/docs/build/html/_sources/warp_affine.ipynb.txt b/docs/build/html/_sources/warp_affine.ipynb.txt
new file mode 100644
index 0000000000..a1ab7da7d4
--- /dev/null
+++ b/docs/build/html/_sources/warp_affine.ipynb.txt
@@ -0,0 +1,140 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Rotate image using warp affine transform"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "import torchgeometry as tgm\n",
+ "\n",
+ "import cv2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(200, 250, 3)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# read the image with OpenCV\n",
+ "image = cv2.imread('./data/bennett_aden.png')[..., (2,1,0)]\n",
+ "print(image.shape)\n",
+ "\n",
+ "img = tgm.image_to_tensor(image)\n",
+ "img = torch.unsqueeze(img.float(), dim=0) # BxCxHxW"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# create transformation (rotation)\n",
+ "alpha = 45.0 # in degrees\n",
+ "angle = torch.ones(1) * alpha\n",
+ "\n",
+ "# define the rotation center\n",
+ "center = torch.ones(1, 2)\n",
+ "center[..., 0] = img.shape[3] / 2 # x\n",
+ "center[..., 1] = img.shape[2] / 2 # y\n",
+ "\n",
+ "# define the scale factor\n",
+ "scale = torch.ones(1)\n",
+ "\n",
+ "# compute the transformation matrix\n",
+ "M = tgm.get_rotation_matrix2d(center, angle, scale)\n",
+ "\n",
+ "# apply the transformation to original image\n",
+ "_, _, h, w = img.shape\n",
+ "img_warped = tgm.warp_affine(img, M, dsize=(h, w))\n",
+ "\n",
+ "# convert back to numpy\n",
+ "image_warped = tgm.tensor_to_image(img_warped.byte())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
The functions in this section perform various geometrical transformations of 2D images.
+
+
+torchgeometry.warp_perspective(src, M, dsize, flags='bilinear', border_mode=None, border_value=0)[source]¶
+
Applies a perspective transformation to an image.
+
The function warp_perspective transforms the source image using
+the specified matrix:
+
+\[\text{dst} (x, y) = \text{src} \left(
+\frac{M_{11} x + M_{12} y + M_{33}}{M_{31} x + M_{32} y + M_{33}} ,
+\frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}}
+\right )\]
+
+
+
+
+
Parameters:
+
src (Tensor) – input image.
+
M (Tensor) – transformation matrix.
+
dsize (tuple) – size of the output image (height, width).
The transformation maps the rotation center to itself
+If this is not the target, adjust the shift.
+
+
+
+
+
Parameters:
+
center (Tensor) – center of the rotation in the source image.
+
angle (Tensor) – rotation angle in degrees. Positive values mean
+counter-clockwise rotation (the coordinate origin is assumed to
+be the top-left corner).