Cameras
+Camera Coordinate Systems
+When working with 3D data, there are 4 coordinate systems users need to know
+
+- World coordinate system
+This is the system the object/scene lives - the world.
+- Camera view coordinate system
+This is the system that has its origin on the image plane and the
Z-axis perpendicular to the image plane. In PyTorch3D, we assume that +X points left, and +Y points up and +Z points out from the image plane. The transformation from world to view happens after applying a rotation (R) and translation (T).
+- NDC coordinate system
+This is the normalized coordinate system that confines in a volume the renderered part of the object/scene. Also known as view volume. Under the PyTorch3D convention,
(+1, +1, znear) is the top left near corner, and (-1, -1, zfar) is the bottom right far corner of the volume. The transformation from view to NDC happens after applying the camera projection matrix (P).
+- Screen coordinate system
+This is another representation of the view volume with the
XY coordinates defined in pixel space instead of a normalized space.
+
+An illustration of the 4 coordinate systems is shown below
+
+Defining Cameras in PyTorch3D
+Cameras in PyTorch3D transform an object/scene from world to NDC by first transforming the object/scene to view (via transforms R and T) and then projecting the 3D object/scene to NDC (via the projection matrix P, else known as camera matrix). Thus, the camera parameters in P are assumed to be in NDC space. If the user has camera parameters in screen space, which is a common use case, the parameters should transformed to NDC (see below for an example)
+We describe the camera types in PyTorch3D and the convention for the camera parameters provided at construction time.
+Camera Types
+All cameras inherit from CamerasBase which is a base class for all cameras. PyTorch3D provides four different camera types. The CamerasBase defines methods that are common to all camera models:
+
+get_camera_center that returns the optical center of the camera in world coordinatesget_world_to_view_transform which returns a 3D transform from world coordinates to the camera view coordinates (R, T)get_full_projection_transform which composes the projection transform (P) with the world-to-view transform (R, T)transform_points which takes a set of input points in world coordinates and projects to NDC coordinates ranging from [-1, -1, znear] to [+1, +1, zfar].transform_points_screen which takes a set of input points in world coordinates and projects them to the screen coordinates ranging from [0, 0, znear] to [W-1, H-1, zfar]
+Users can easily customize their own cameras. For each new camera, users should implement the get_projection_transform routine that returns the mapping P from camera view coordinates to NDC coordinates.
+FoVPerspectiveCameras, FoVOrthographicCameras
+These two cameras follow the OpenGL convention for perspective and orthographic cameras respectively. The user provides the near znear and far zfar field which confines the view volume in the Z axis. The view volume in the XY plane is defined by field of view angle (fov) in the case of FoVPerspectiveCameras and by min_x, min_y, max_x, max_y in the case of FoVOrthographicCameras.
+PerspectiveCameras, OrthographicCameras
+These two cameras follow the Multi-View Geometry convention for cameras. The user provides the focal length (fx, fy) and the principal point (px, py). For example, camera = PerspectiveCameras(focal_length=((fx, fy),), principal_point=((px, py),))
+As mentioned above, the focal length and principal point are used to convert a point (X, Y, Z) from view coordinates to NDC coordinates, as follows
+
+x_ndc = fx * X / Z + px
+y_ndc = fy * Y / Z + py
+z_ndc = 1 / Z
+
+
+x_ndc = fx * X + px
+y_ndc = fy * Y + py
+z_ndc = Z
+
+Commonly, users have access to the focal length (fx_screen, fy_screen) and the principal point (px_screen, py_screen) in screen space. In that case, to construct the camera the user needs to additionally provide the image_size = ((image_width, image_height),). More precisely, camera = PerspectiveCameras(focal_length=((fx_screen, fy_screen),), principal_point=((px_screen, py_screen),), image_size = ((image_width, image_height),)). Internally, the camera parameters are converted from screen to NDC as follows:
+fx = fx_screen * 2.0 / image_width
+fy = fy_screen * 2.0 / image_height
+
+px = - (px_screen - image_width / 2.0) * 2.0 / image_width
+py = - (py_screen - image_height / 2.0) * 2.0/ image_height
+
+