Computes the shadoing for the ``pyny.Space`` stored in 
        ``.space`` for the time intervals and Sun positions stored in 
        ``.arg_t`` and ``.sun_pos``, respectively.
        
        The generated information is stored in:
            * **.light_vor** (*ndarray (dtype=bool)*): Array with the 
              points in ``pyny.Space`` as columns and the discretized 
              Sun positions as rows. Indicates whether the points are 
              illuminated in each Sun position.
            * **.light** (*ndarray (dtype=bool)*): The same as 
              ``.light_vor`` but with the time intervals in ``.arg_t``
              as rows instead of the Sun positions.
        
        :returns: None

def compute_shadows(self):
        """
        Computes the shadoing for the ``pyny.Space`` stored in 
        ``.space`` for the time intervals and Sun positions stored in 
        ``.arg_t`` and ``.sun_pos``, respectively.
        
        The generated information is stored in:
            * **.light_vor** (*ndarray (dtype=bool)*): Array with the 
              points in ``pyny.Space`` as columns and the discretized 
              Sun positions as rows. Indicates whether the points are 
              illuminated in each Sun position.
            * **.light** (*ndarray (dtype=bool)*): The same as 
              ``.light_vor`` but with the time intervals in ``.arg_t``
              as rows instead of the Sun positions.
        
        :returns: None
        """
        from pyny3d.utils import sort_numpy, bool2index, index2bool
        state = pyny.Polygon.verify
        pyny.Polygon.verify = False

        model = self.space
        
        light = []
        for sun in self.vor_centers:
            # Rotation of the whole ``pyny.Space``
            polygons_photo, _, points_to_eval = model.photo(sun, False)
            # Auxiliar pyny.Surface to fast management of pip
            Photo_surface = pyny.Surface(polygons_photo)
            Photo_surface.lock()
           
            # Sort/unsort points
            n_points = points_to_eval.shape[0]
            points_index_0 = np.arange(n_points) # _N indicates the depth level
            points_to_eval, order_back = sort_numpy(points_to_eval, col=0, 
                                                    order_back=True)
            # Loop over the sorted (areas) Polygons
            for i in model.sorted_areas:
                p = points_to_eval[points_index_0][:, :2]
                polygon_photo = Photo_surface[i]
                index_1 = bool2index(polygon_photo.pip(p, sorted_col=0))
                points_1 = points_to_eval[points_index_0[index_1]]
                
                if points_1.shape[0] != 0:
                    # Rotation algebra
                    a, b, c = polygon_photo[:3, :]
                    R = np.array([b-a, c-a, np.cross(b-a,  c-a)]).T
                    R_inv = np.linalg.inv(R)
                    Tr = a # Translation
                    # Reference point (between the Sun and the polygon)
                    reference_point = np.mean((a, b, c), axis=0)
                    reference_point[2] = reference_point[2] - 1
                    points_1 = np.vstack((points_1, reference_point))
                    points_over_polygon = np.dot(R_inv, (points_1-Tr).T).T
                    # Logical stuff
                    shadow_bool_2 = np.sign(points_over_polygon[:-1, 2]) != \
                                    np.sign(points_over_polygon[-1, 2])     
                    shadow_index_2 = bool2index(shadow_bool_2)
                    if shadow_index_2.shape[0] != 0:
                        points_to_remove = index_1[shadow_index_2]
                        points_index_0 = np.delete(points_index_0, 
                                                   points_to_remove)
            
            lighted_bool_0 = index2bool(points_index_0, 
                                        length=points_to_eval.shape[0])
            # Updating the solution
            light.append(lighted_bool_0[order_back])
        # Storing the solution
        self.light_vor = np.vstack(light)
        self.light = self.light_vor[self.t2vor_map]
        pyny.Polygon.verify = state