Code review changes

Make focal_length a private attr

linting

Author: scottshambaugh

doc/users/next_whats_new/3d_plot_focal_length.rst

@@ -3,13 +3,16 @@ Give the 3D camera a custom focal length
 
 Users can now better mimic real-world cameras by specifying the focal length of
 the virtual camera in 3D plots. An increasing focal length between 1 and
-+infinity "flattens" the image, while a decreasing focal length between 1 and 0
+infinity "flattens" the image, while a decreasing focal length between 1 and 0
 exaggerates the perspective and gives the image more apparent depth. The
 default focal length of 1 corresponds to a Field of View (FOV) of 90 deg, and
 is backwards-compatible with existing 3D plots.
 
 The focal length can be calculated from a desired FOV via the equation:
-| ``focal_length = 1/tan(FOV/2)``
+
+.. mathmpl::
+
+    focal\_length = 1/tan(FOV/2)
 
 .. plot::
     :include-source: true

examples/mplot3d/projections.py

@@ -7,18 +7,25 @@
 changing the focal length for a perspective projection. Note that matplotlib
 corrects for the 'zoom' effect of changing the focal length.
 
-An increasing focal length between 1 and +infinity "flattens" the image, while
+An increasing focal length between 1 and infinity "flattens" the image, while
 a decreasing focal length between 1 and 0 exaggerates the perspective and gives
 the image more apparent depth. The default focal length of 1 corresponds to a
 Field of View (FOV) of 90 deg. In the limiting case, a focal length of
-+infinity corresponds to an orthographic projection after correction of the
+infinity corresponds to an orthographic projection after correction of the
 zoom effect.
 
 You can calculate focal length from a FOV via the equation:
-focal_length = 1/tan(FOV/2)
+
+.. mathmpl::
+
+    1 / \tan (FOV / 2)
 
 Or vice versa:
-FOV = 2*atan(1/focal_length)
+
+.. mathmpl::
+
+    FOV = 2 * \atan (1 / focal length)
+
 """
 
 from mpl_toolkits.mplot3d import axes3d
@@ -36,7 +43,7 @@
 
 # Set the orthographic projection.
 axs[0].set_proj_type('ortho')  # FOV = 0 deg
-axs[0].set_title("'ortho'\nfocal_length = +∞", fontsize=10)
+axs[0].set_title("'ortho'\nfocal_length = ∞", fontsize=10)
 
 # Set the perspective projections
 axs[1].set_proj_type('persp')  # FOV = 90 deg

lib/mpl_toolkits/mplot3d/axes3d.py

@@ -1046,22 +1046,20 @@ def set_proj_type(self, proj_type, focal_length=None):
             The focal length can be computed from a desired Field Of View via
             the equation: focal_length = 1/tan(FOV/2)
         """
+        _api.check_in_list(['persp', 'ortho'], proj_type=proj_type)
         if proj_type == 'persp':
             if focal_length is None:
-                self.focal_length = 1
+                self._focal_length = 1
             else:
                 if focal_length <= 0:
-                    raise ValueError(f"focal_length = {focal_length} must be" +
+                    raise ValueError(f"focal_length = {focal_length} must be"
                                      " greater than 0")
-                self.focal_length = focal_length
+                self._focal_length = focal_length
         elif proj_type == 'ortho':
             if focal_length not in (None, np.inf):
-                raise ValueError(f"focal_length = {focal_length} must be" +
+                raise ValueError(f"focal_length = {focal_length} must be"
                                  f"None for proj_type = {proj_type}")
-            self.focal_length = np.inf
-        else:
-            raise ValueError(f"proj_type = {proj_type} must be in" +
-                             f"{'persp', 'ortho'}")
+            self._focal_length = np.inf
 
     def _roll_to_vertical(self, arr):
         """Roll arrays to match the different vertical axis."""
@@ -1118,18 +1116,18 @@ def get_proj(self):
         V[self._vertical_axis] = -1 if abs(elev_rad) > 0.5 * np.pi else 1
 
         # Generate the view and projection transformation matrices
-        if self.focal_length == np.inf:
+        if self._focal_length == np.inf:
             # Orthographic projection
             viewM = proj3d.view_transformation(eye, R, V, roll_rad)
             projM = proj3d.ortho_transformation(-self.dist, self.dist)
         else:
             # Perspective projection
             # Scale the eye dist to compensate for the focal length zoom effect
-            eye_focal = R + self.dist * ps * self.focal_length
+            eye_focal = R + self.dist * ps * self._focal_length
             viewM = proj3d.view_transformation(eye_focal, R, V, roll_rad)
             projM = proj3d.persp_transformation(-self.dist,
                                                 self.dist,
-                                                self.focal_length)
+                                                self._focal_length)
 
         # Combine all the transformation matrices to get the final projection
         M0 = np.dot(viewM, worldM)
@@ -1194,7 +1192,7 @@ def cla(self):
                 pass
 
         self._autoscaleZon = True
-        if self.focal_length == np.inf:
+        if self._focal_length == np.inf:
             self._zmargin = rcParams['axes.zmargin']
         else:
             self._zmargin = 0.