docs: def get_map(self):
          """
          Collects all the points coordinates from this ``pyny.Space``
          instance.
          
          In order to keep the reference, it returns an index with the
          following key:
          
              * The first column is the Place.
              * The second column is the body (-1: points, 0: surface, 
                                               n: polyhedron)
              * The third column is the polygon (-n: holes)
              * The fourth column is the point.
   
          :returns: [index, points]
          :rtype: list of ndarray
  
          .. note:: This method automatically stores the solution in order
              to do not repeat calculations if the user needs to call it 
              more than once.
  
          .. seealso:: 
              
              * :func:`get_seed` 
              * :func:`map2pyny`
              * :func:`map2seed` 
              * :func:`explode_map`
              
          """
          seed = self.get_seed()['places'] # template
          
          points = []
          index = []
          for i, place in enumerate(seed):
              # Set of points [_, -1, 0, _]
              n_points = place['set_of_points'].shape[0]
              if n_points != 0: # It can be False (no set_of_points)
                  points.append(place['set_of_points'])
                  index.append(np.vstack((np.tile(np.array([[i], [-1], [0]]), 
                                                           n_points), 
                                          np.arange(n_points))))
              #Holes [_, 0, -N, _]
              for ii, hole in enumerate(place['surface']['holes']):
                  n_points = hole.shape[0]
                  points.append(hole)
                  index.append(np.vstack((np.tile(np.array([[i], [0], [-ii-1]]), 
                                                           n_points), 
                                          np.arange(n_points))))
              #Surface [_, 0, N, _]
              for ii, polygon in enumerate(place['surface']['polygons']):
                  n_points = polygon.shape[0]
                  points.append(polygon)
                  index.append(np.vstack((np.tile(np.array([[i], [0], [ii]]), 
                                                           n_points), 
                                          np.arange(n_points))))
              #Polyhedras [_, N, _, _]
              if len(place['polyhedra']) != 0: # It can be False (no obstacles)
                  for iii, polygon_list in enumerate(place['polyhedra']):
                      for iv, polygon in enumerate(polygon_list):
                          n_points = polygon.shape[0]
                          points.append(polygon)
                          index.append(np.vstack((np.tile(np.array([[i], [1+iii], 
                                                                    [iv]]), n_points), 
                                                  np.arange(n_points))))
  
          index = np.concatenate(index, axis=1).T
          points = np.concatenate(points)
          self.map = [index, points]
          return self.map