We are going to tackle this bug:                             
  https://github.com/matplotlib/matplotlib/issues/209 
  
  This will be fairly involved and will require back-and-forth 
  for me to interpret the visual test plot outputs. I believe  
  that that root of the issue is that axis3d and axes3d        
  aren't using the transformations at all when doing their     
  calculations, and that'll need to be added in. In other      
  words, there needs to be a separation within all the 3D code 
  between world coordinates and data coordinates.

  Put together a plan for tackling it. I believe that the      
  first step will be looking at how 2D transforms are applied  
  with log scales. Then figure out where 3D calcs are          
  implicitly using linear transformations, and add the         
  transformation logic. Then we test that there is not a       
  regression with existing methods. Then we test the log       
  scales

  # Plan: Fix 3D Log Scale Support (Issue #209)                                       
                                                                                      
  ## Problem Summary                                                                  
                                                                                      
  3D plots completely ignore scale transforms (log, symlog, etc.). The methods        
  `set_xscale()`, `set_yscale()`, `set_zscale()` exist but the transforms are never   
  applied to data or coordinates. The root cause is that the 3D pipeline assumes      
  linear transformations everywhere.                                                  
                                                                                      
  **Current broken flow:**                                                            
  \```                                                                                 
  Raw data → world_transformation(raw_limits) → view → projection → 2D                
  ↑ Scale transforms NEVER applied                                                    
  \```                                                                                 
                                                                                      
  **Required flow:**                                                                  
  \```                                                                                 
  Raw data → Scale Transform → Scaled data → world_transformation(scaled_limits) →    
  view → projection → 2D                                                              
  \```                                                                                 
                                                                                      
  ## Key Concept: World vs Data Coordinates                                           
                                                                                      
  - **Data coordinates**: Raw values as user provides (e.g., `[1, 10, 100, 1000]`)    
  - **Scaled coordinates**: After scale transform (e.g., `[0, 1, 2, 3]` for log10)    
  - **World coordinates**: Normalized to projection-ready space                       
                                                                                      
  ## Implementation Phases                                                            
                                                                                      
  ### Phase 1: Core Infrastructure in axes3d.py                                       
                                                                                      
  **File:** `lib/mpl_toolkits/mplot3d/axes3d.py`                                      
                                                                                      
  1. **Add helper methods** to get scale transforms:                                  
  \```python                                                                           
  def _get_scale_transforms(self):                                                    
  """Return (x_transform, y_transform, z_transform)."""                               
  return (self.xaxis.get_transform(),                                                 
  self.yaxis.get_transform(),                                                         
  self.zaxis.get_transform())                                                         
  \```                                                                                 
                                                                                      
  2. **Modify `get_proj()` (lines 1212-1269)** to transform limits through scales:    
  - Before calling `world_transformation()`, apply scale transforms to limit          
  values                                                                              
  - Transform `[xmin, xmax]`, `[ymin, ymax]`, `[zmin, zmax]` through their            
  respective scale transforms                                                         
  - Pass transformed limits to `world_transformation()`                               
                                                                                      
  3. **Update docstrings** for `set_xscale`, `set_yscale`, `set_zscale` to remove the 
  warning about non-linear scales yielding nonsensical results                        
                                                                                      
  ### Phase 2: Scale Transform Helper in art3d.py                                     
                                                                                      
  **File:** `lib/mpl_toolkits/mplot3d/art3d.py`                                       
                                                                                      
  1. **Add utility function** at module level:                                        
  \```python                                                                           
  def _apply_scale_transforms(xs, ys, zs, axes):                                      
  """Apply scale transforms to 3D coordinates."""                                     
  x_trans = axes.xaxis.get_transform()                                                
  y_trans = axes.yaxis.get_transform()                                                
  z_trans = axes.zaxis.get_transform()                                                
  # Transform each dimension, handle masked arrays                                    
  return xs_scaled, ys_scaled, zs_scaled                                              
  \```                                                                                 
                                                                                      
  2. **Update `_viewlim_mask()`** to compare in scaled space                          
                                                                                      
  ### Phase 3: Update All Artist do_3d_projection() Methods                           
                                                                                      
  **File:** `lib/mpl_toolkits/mplot3d/art3d.py`                                       
                                                                                      
  Apply scale transforms before projection in each class:                             
                                                                                      
  | Class | Method | Line (approx) |                                                  
  |-------|--------|---------------|                                                  
  | `Line3D` | `draw()` | ~270 |                                                      
  | `Line3DCollection` | `do_3d_projection()` | 494-524 |                             
  | `Patch3D` | `do_3d_projection()` | ~570 |                                         
  | `PathPatch3D` | `do_3d_projection()` | ~620 |                                     
  | `Patch3DCollection` | `do_3d_projection()` | ~730 |                               
  | `Path3DCollection` | `do_3d_projection()` | ~800 |                                
  | `Poly3DCollection` | `do_3d_projection()` | ~1334 |                               
  | `Text3D` | `draw()` | ~360 |                                                      
                                                                                      
  **Pattern for each:**                                                               
  \```python                                                                           
  def do_3d_projection(self):                                                         
  # Existing: get raw coordinates                                                     
  segments = self._segments3d                                                         
                                                                                      
  # NEW: Apply scale transforms                                                       
  segments_scaled = _apply_scale_transforms(                                          
  segments[..., 0], segments[..., 1], segments[..., 2], self.axes)                    
                                                                                      
  # Existing: project (now using scaled coordinates)                                  
  xyzs = proj3d._proj_transform_vectors(segments_scaled, self.axes.M)                 
  \```                                                                                 
                                                                                      
  ### Phase 4: Fix Axis Drawing in axis3d.py                                          
                                                                                      
  **File:** `lib/mpl_toolkits/mplot3d/axis3d.py`                                      
                                                                                      
  1. **Modify `_draw_ticks()` (lines 460-478)**:                                      
  - Tick locations from `tick.get_loc()` are in data space                            
  - Apply scale transform before calling `proj3d.proj_transform()`                    
                                                                                      
  2. **Modify `draw_grid()`**:                                                        
  - Grid line positions need scale transformation                                     
                                                                                      
  3. **Modify `_get_coord_info()`**:                                                  
  - Bounds should be in scaled space for proper cube drawing                          
                                                                                      
  ### Phase 5: Autoscaling and Limits                                                 
                                                                                      
  **File:** `lib/mpl_toolkits/mplot3d/axes3d.py`                                      
                                                                                      
  1. **Update `autoscale_view()`**: Apply scale's `limit_range_for_scale()` to ensure 
  limits are valid for the scale type (e.g., positive for log)                        
                                                                                      
  2. **Ensure limit setters** (`set_xlim3d`, etc.) validate limits against scale      
  constraints                                                                         
                                                                                      
  ### Phase 6: Inverse Transforms for Interaction                                     
                                                                                      
  **File:** `lib/mpl_toolkits/mplot3d/axes3d.py`                                      
                                                                                      
  1. **Update `format_coord()`**: Convert from scaled space back to data space for    
  display                                                                             
  2. **Update any mouse picking code** that converts screen → data coordinates        
                                                                                      
  ## Critical Files to Modify                                                         
                                                                                      
  | File | Changes |                                                                  
  |------|---------|                                                                  
  | `lib/mpl_toolkits/mplot3d/axes3d.py` | `get_proj()`, helper methods, autoscaling, 
  docstrings |                                                                        
  | `lib/mpl_toolkits/mplot3d/art3d.py` | All `do_3d_projection()` methods, new       
  helper function |                                                                   
  | `lib/mpl_toolkits/mplot3d/axis3d.py` | `_draw_ticks()`, `draw_grid()`,            
  `_get_coord_info()` |                                                               
                                                                                      
  ## Implementation Order                                                             
                                                                                      
  1. Add helper functions in `axes3d.py` and `art3d.py`                               
  2. Modify `get_proj()` to use scaled limits                                         
  3. Fix axis3d tick/grid drawing                                                     
  4. Fix all artist do_3d_projection() methods (one at a time, testing each)          
  5. Fix autoscaling                                                                  
  6. Fix inverse transforms                                                           
  7. Update docstrings                                                                
                                                                                      
  ## Verification Plan                                                                
                                                                                      
  ### Test Script                                                                     
  \```python                                                                           
  import matplotlib.pyplot as plt                                                     
  import numpy as np                                                                  
                                                                                      
  fig = plt.figure()                                                                  
  ax = fig.add_subplot(projection='3d')                                               
                                                                                      
  # Data spanning several orders of magnitude                                         
  x = np.array([1, 10, 100, 1000])                                                    
  y = np.array([1, 10, 100, 1000])                                                    
  z = np.array([1, 10, 100, 1000])                                                    
                                                                                      
  ax.set_xscale('log')                                                                
  ax.set_yscale('log')                                                                
  ax.set_zscale('log')                                                                
                                                                                      
  ax.scatter(x, y, z)                                                                 
  plt.show()                                                                          
  \```                                                                                 
                                                                                      
  **Expected result:** Points should appear evenly spaced (since                      
  log10([1,10,100,1000]) = [0,1,2,3])                                                 
                                                                                      
  ### Regression Testing                                                              
  Run existing 3D test suite to ensure linear scales still work:                      
  \```bash                                                                             
  python -m pytest lib/mpl_toolkits/mplot3d/tests/ -v                                 
  \```                                                                                 
                                                                                      
  ### Visual Tests to Create                                                          
  1. Log scale on single axis                                                         
  2. Log scale on all axes                                                            
  3. Symlog scale                                                                     
  4. Mixed scales (log on x, linear on y, symlog on z)                                
  5. Surface plots with log scales                                                    
  6. Bar3d with log scales                                                            
                                                                                      
  ## Notes                                                                            
                                                                                      
  - Performance: For linear scales (default), the transform is `IdentityTransform`    
  which should be essentially a no-op                                                 
  - Backwards compatibility: Linear scale behavior should be unchanged                
  - The 2D implementation in `axes/_base.py` (lines 910-944) serves as reference for  
  how transforms should compose                                                       

The rendering is messed up. There are still missing transformations somewhere. Potentially check against the 2D implementation.