code: def add_actor(self, uinput, reset_camera=False, name=None, loc=None,
                    culling=False):
          
          # Remove actor by that name if present
          rv = self.remove_actor(name, reset_camera=False)
  
          if isinstance(uinput, vtk.vtkMapper):
              actor = vtk.vtkActor()
              actor.SetMapper(uinput)
          else:
              actor = uinput
  
          self.AddActor(actor)
          actor.renderer = proxy(self)
  
          if name is None:
              name = str(hex(id(actor)))
  
          self._actors[name] = actor
  
          if reset_camera:
              self.reset_camera()
          elif not self.camera_set and reset_camera is None and not rv:
              self.reset_camera()
          else:
              self.parent._render()
  
          self.update_bounds_axes()
  
          if culling:
              try:
                  actor.GetProperty().BackfaceCullingOn()
              except AttributeError:  # pragma: no cover
                  pass
  
          return actor, actor.GetProperty()
docs: Adds an actor to render window.  Creates an actor if input is
          a mapper.
  
          Parameters
          ----------
          uinput : vtk.vtkMapper or vtk.vtkActor
              vtk mapper or vtk actor to be added.
  
          reset_camera : bool, optional
              Resets the camera when true.
  
          loc : int, tuple, or list
              Index of the renderer to add the actor to.  For example,
              ``loc=2`` or ``loc=(1, 1)``.
  
          culling : bool optional
              Does not render faces that should not be visible to the
              plotter.  This can be helpful for dense surface meshes,
              especially when edges are visible, but can cause flat
              meshes to be partially displayed.  Default False.
  
          Returns
          -------
          actor : vtk.vtkActor
              The actor.
  
          actor_properties : vtk.Properties
              Actor properties.