docs: def __compute_stdrange(self, images):
          r"""
          Computes a common standard intensity range over a number of images.
          
          Depending on the settings of the internal self.__stdrange variable,
          either (1) the already fixed values are returned, (2) a complete standard
          intensity range is computed from the supplied images, (3) an intensity range
          fixed at the lower end or (4) an intensity range fixed at the upper end is
          returned.
          
          Takes into account the maximum length of each percentile segment over all
          images, then adds a security margin defined by the highest variability among
          all segments over all images.
          
          Be
          
          .. math::
          
              L = (cop_l, lp_1, lp_2, ..., lp_n, cop_u)
          
          the set formed by the two cut-off percentiles :math:`cop_l` and :math:`cop_u` and the
          landmark percentiles :math:`lp_1, ..., lp_n`. The corresponding intensity values of
          an image :math:`i\in I` are then
          
          .. math::
              
              V_i = (v_{i,1}, v_{i,2}, ..., v_{i,n+2})
          
          The distance between each of these intensity values forms a segment along the
          images :math:`i` intensity range denoted as
          
          ..math ::
              
              S_i = (s_{i,1}, s_{i,2}, ..., s_{i, n+1})
          
          The common standard intensity range :math:`sir` over the set of images :math:`I` is
          then defined as
          
          ..math ::
              sir = \sum_{l=1}^{n+1}\max_{i=1}^I s_{i,l} * \max_{l=1}^{n+1} \left(\frac{\max_{i=1}^I s_{i,l}}{\min_{i=1}^I s_{i,l}}\right)
          
          Parameters
          ----------
          images : sequence of array_like
              A number of images.
              
          Returns
          -------
          stdrange : (float, float)
              The borders of the computed standard intensity range.
          """
          if not 'auto' in self.__stdrange:
              return self.__stdrange
          
          copl, copu = self.__cutoffp
          
          # collect cutoff + landmark percentile segments and image mean intensity values 
          s = []
          m = []
          for idx, i in enumerate(images):
              li = numpy.percentile(i, [copl] + self.__landmarkp + [copu])
              
              s.append(numpy.asarray(li)[1:] - numpy.asarray(li)[:-1])
              m.append(i.mean())
              
              # treat single intensity accumulation error
              if 0 in s[-1]:
                  raise SingleIntensityAccumulationError('Image no.{} shows an unusual single-intensity accumulation that leads to a situation where two percentile values are equal. This situation is usually caused, when the background has not been removed from the image. Another possibility would be to reduce the number of landmark percentiles landmarkp or to change their distribution.'.format(idx))
              
          # select the maximum and minimum of each percentile segment over all images
          maxs = numpy.max(s, 0)
          mins = numpy.min(s, 0)
          
          # divide them pairwise
          divs = numpy.divide(numpy.asarray(maxs, dtype=numpy.float), mins) 
          
          # compute interval range according to generalized theorem 2 of [1]
          intv = numpy.sum(maxs) + numpy.max(divs)
          
          # compute mean intensity value over all images (assuming equal size)
          im = numpy.mean(m)
          
          # return interval with borders according to settings
          if 'auto' == self.__stdrange[0] and 'auto' == self.__stdrange[1]:
              return im - intv / 2, im + intv / 2
          elif 'auto' == self.__stdrange[0]:
              return self.__stdrange[1] - intv, self.__stdrange[1]
          else:
              return self.__stdrange[0], self.__stdrange[0] + intv