code: def defrise(space, nellipses=8, alternating=False, min_pt=None, max_pt=None):
      
      ellipses = defrise_ellipses(space.ndim, nellipses=nellipses,
                                  alternating=alternating)
      return ellipsoid_phantom(space, ellipses, min_pt, max_pt)
docs: Phantom with regularily spaced ellipses.
  
      This phantom is often used to verify cone-beam algorithms.
  
      Parameters
      ----------
      space : `DiscreteLp`
          Space in which the phantom should be created, must be 2- or
          3-dimensional.
      nellipses : int, optional
          Number of ellipses. If more ellipses are used, each ellipse becomes
          thinner.
      alternating : bool, optional
          True if the ellipses should have alternating densities (+1, -1),
          otherwise all ellipses have value +1.
      min_pt, max_pt : array-like, optional
          If provided, use these vectors to determine the bounding box of the
          phantom instead of ``space.min_pt`` and ``space.max_pt``.
          It is currently required that ``min_pt >= space.min_pt`` and
          ``max_pt <= space.max_pt``, i.e., shifting or scaling outside the
          original space is not allowed.
  
          Providing one of them results in a shift, e.g., for ``min_pt``::
  
              new_min_pt = min_pt
              new_max_pt = space.max_pt + (min_pt - space.min_pt)
  
          Providing both results in a scaled version of the phantom.
  
      Returns
      -------
      phantom : ``space`` element
          The generated phantom in ``space``.
  
      See Also
      --------
      odl.phantom.transmission.shepp_logan