def shadows(self, data=None, t=None, dt=None, latitude=None,
                init='empty', resolution='mid'):
        '''
        Initializes a ShadowManager object for this ``pyny.Space`` 
        instance.
        
        The 'empty' initialization accepts ``data`` and ``t`` and ``dt``
        but the ShadowsManager will not start the calculations. It will
        wait the user to manually insert the rest of the parameters.
        Call ``ShadowsManager.run()`` to start the shadowing 
        computations.
        
        The 'auto' initialization pre-sets all the required parameters 
        to run the computations\*. The available resolutions are:
        
            * 'low'
            * 'mid'
            * 'high'
            
        The 'auto' mode will use all the arguments different than 
        ``None`` and the ``set_of_points`` of this ``pyny.Space`` if 
        any.
            
        :param data: Data timeseries to project on the 3D model 
            (radiation, for example).
        :type data: ndarray (shape=N), None
        :param t: Time vector in absolute minutes or datetime objects
        :type t: ndarray or list, None
        :param dt: Interval time to generate t vector.
        :type dt: int, None
        :param latitude: Local latitude.
        :type latitude: float (radians)
        :param init: Initialization mode
        :type init: str
        :param init: Resolution for the time vector generation (if 
            ``None``), for setting the sensible points and for the 
            Voronoi diagram.
        :type init: str
        :returns: ``ShadowsManager`` object
        '''
        from pyny3d.shadows import ShadowsManager
        
        if init == 'auto':
            # Resolution
            if resolution == 'low':
                factor = 20
            elif resolution == 'mid':
                factor = 40
            elif resolution == 'high':
                factor = 70
            if dt is None: dt = 6e4/factor
            if latitude is None: latitude = 0.65
            
            # Autofill ShadowsManager Object
            sm = ShadowsManager(self, data=data, t=t, dt=dt, 
                                latitude=latitude)
            if self.get_sets_of_points().shape[0] == 0:
                max_bound = np.diff(self.get_domain(), axis=0).max()
                sm.space.mesh(mesh_size=max_bound/factor, edge=True)
            ## General parameters
            sm.arg_vor_size = 3.5/factor
            sm.run()
            return sm
            
        elif init == 'empty':
            return ShadowsManager(self, data=data, t=t, dt=dt, 
                                  latitude=latitude)