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