docs: def transform(self, image, surpress_mapping_check = False):
          r"""
          Transform an images intensity values to the learned standard intensity space.
          
          Note that the passed image should be masked to contain only the foreground.
          
          The transformation is guaranteed to be lossless i.e. a one-to-one mapping between
          old and new intensity values exists. In cases where this does not hold, an error
          is thrown. This can be suppressed by setting ``surpress_mapping_check`` to 'True'.
          Do this only if you know what you are doing.
          
          Parameters
          ----------
          image : array_like
              The image to transform.
          surpress_mapping_check : bool
              Whether to ensure a lossless transformation or not.
          
          Returns
          -------
          image : ndarray
              The transformed image
          
          Raises
          -------
          InformationLossException 
              If a lossless transformation can not be ensured
          Exception
              If no model has been trained before
          """
          if None == self.__model:
              raise UntrainedException('Model not trained. Call train() first.')
          
          image = numpy.asarray(image)
          
          # determine image intensity values at cut-off percentiles & landmark percentiles
          li = numpy.percentile(image, [self.__cutoffp[0]] + self.__landmarkp + [self.__cutoffp[1]])
          
          # treat single intensity accumulation error            
          if not len(numpy.unique(li)) == len(li):
              raise SingleIntensityAccumulationError('The image 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. The only other possibility would be to re-train the model with a reduced number of landmark percentiles landmarkp or a changed distribution.')
          
          # create linear mapping models for the percentile segments to the learned standard intensity space  
          ipf = interp1d(li, self.__model, bounds_error = False)
          
          # transform the input image intensity values
          output = ipf(image)
          
          # treat image intensity values outside of the cut-off percentiles range separately
          llm = IntensityRangeStandardization.linear_model(li[:2], self.__model[:2])
          rlm = IntensityRangeStandardization.linear_model(li[-2:], self.__model[-2:])
          
          output[image < li[0]] = llm(image[image < li[0]])
          output[image > li[-1]] = rlm(image[image > li[-1]])
          
          if not surpress_mapping_check and not self.__check_mapping(li):
              raise InformationLossException('Image can not be transformed to the learned standard intensity space without loss of information. Please re-train.')
          
          return output