docs: def photo(self, azimuth_zenit, plot=False):
          """
          Computes a change of the reference system for the whole 
          ``pyny.Space`` to align the `y` axis with a given direction. 
          Returns its elements (polygons, holes, points) extracted in a
          list.
          
          In its conception, this method was created as a tool for the 
          shadows computation to calculate "what is in front and what 
          is behind to the look of the Sun". For this reason, the 
          direction is given in spherical coordinates by two angles: the 
          azimth and the zenit.
          
              * The azimuth is zero when pointing to the South, -pi/4 to 
                the East, pi/4 to the West and pi/2 to the North.
              * The zenit is zero at the ground level and pi/4 "pointing
                completely orthogonal to the sky".
          
          In short, this methods answer "How would the ``pyny.Space`` look
          in a photograph taken from an arbitrary direction in cylindrical 
          perpective?"
          
          The photograph has a new reference system: x, y, depth. The sign
          of the new depth coordinate has to be checked before assuming 
          what is closer and what is further inasmuch as it changes
          depending on the direction of the photo.
          
          :param azimuth_zenit: Direction of the photo in spherical 
              coordinates and in radians.
          :type azimuth_zenit: tuple
          :param plot: If True, is shows the photo visualization.
          :type plot: bool
          :returns: Exploded ``pyny.Space``
          :rtype: list
          
          .. note:: Before assume that this method do exactly what it is 
              supposed to do, it is highly recommended to visualy verify 
              throught the *plot=True* argument. It is easy to introduce
              the angles in a different sign criteria, among other 
              frequent mistakes.
          """
          self.lock()
          
          a, z = azimuth_zenit
          R = np.array([[np.cos(a), -np.sin(a)*np.cos(z), np.sin(z)*np.sin(a)],
                        [np.sin(a), np.cos(z)*np.cos(a), -np.cos(a)*np.sin(z)],
                        [0, np.sin(z), np.cos(z)]])
          _, points = self.map
          G = np.dot(R, points.T).T # Here it is in self.Space coordinates
              
          # Coordinate change
          G = np.array([G[:,0], G[:,2], G[:,1]]).T # Photograph coordinate
          poly_hole_points = self.explode_map(G)
          
          if plot:
              polygons, holes, points = poly_hole_points
              aux_surface = Surface(polygons, holes=holes, make_ccw=False)
              ax = aux_surface.plot2d(alpha=0.6, ret=True)
              if points.shape[0] > 0: 
                  ax.scatter(points[:, 0], points[:, 1], c='#990000', s=25)
          return poly_hole_points