def METHOD_NAME(self):
    '''
    tests transform kernel
    '''
    # Transformation
    # ---------------
    matrix = numpy.array([[1.0, -0.75], [0.7, 0.5]], dtype=numpy.float32)
    offset_value = numpy.array([250.0, -150.0], dtype=numpy.float32)
    transformation = lambda img: scipy.ndimage.affine_transform(img, matrix, offset=offset_value, order=1, mode="constant")
    image_transformed = transformation(self.image)
    fill_value = numpy.float32(0.0)
    mode = numpy.int32(1)
    # computing keypoints matching with SIFT
    sift_plan = SiftPlan(template=self.image, block_size=self.maxwg)
    kp1 = sift_plan.keypoints(self.image)
    kp2 = sift_plan.keypoints(image_transformed)  # image2 and image must have the same size
    match_plan = MatchPlan()  # cls.ctx
    matching = match_plan.match(kp2, kp1)
    # Retrieve the linear transformation from the matching pairs
    sol = matching_correction(matching)
    logger.info(sol)
    # Compute the correction matrix (inverse of transformation)
    correction_matrix = numpy.zeros((2, 2), dtype=numpy.float32)
    correction_matrix[0] = sol[0:2, 0]
    correction_matrix[1] = sol[3:5, 0]
    matrix_for_gpu = correction_matrix.reshape(4, 1)  # for float4 struct
    offset_value[0] = sol[2, 0]
    offset_value[1] = sol[5, 0]
    # Prepare the arguments for the "transform" kernel call
    maxwg = kernel_workgroup_size(self.program, "transform")
    wg = maxwg, 1
    shape = calc_size(self.image.shape[::-1], wg)
    gpu_image = pyopencl.array.to_device(self.queue, image_transformed)
    gpu_output = pyopencl.array.empty(self.queue, self.image.shape, dtype=numpy.float32, order="C")
    gpu_matrix = pyopencl.array.to_device(self.queue, matrix_for_gpu)
    gpu_offset = pyopencl.array.to_device(self.queue, offset_value)
    image_height, image_width = numpy.int32(self.image.shape)
    output_height, output_width = numpy.int32(gpu_output.shape)
    kargs = [
        gpu_image.data,
        gpu_output.data,
        gpu_matrix.data,
        gpu_offset.data,
        image_width,
        image_height,
        output_width,
        output_height,
        fill_value, mode
    ]
    # Call the kernel
    t0 = time.time()
    k1 = self.program.transform(self.queue, shape, wg, *kargs)
    res = gpu_output.get()
    # Reference result
    t1 = time.time()
    ref = scipy.ndimage.affine_transform(image_transformed, correction_matrix,
                                         offset=offset_value,
                                         output_shape=(output_height, output_width),
                                         order=1,
                                         mode="constant",
                                         cval=fill_value)
    t2 = time.time()
    # Compare the implementations
    delta = numpy.abs(res - ref)
    delta_arg = delta.argmax()
    delta_max = delta.max()
    at_0, at_1 = delta_arg / output_width, delta_arg % output_width
    logger.info("Max difference wrt scipy : %f at (%d, %d)", delta_max, at_0, at_1)
    if self.PROFILE:
        logger.info("Global execution time: CPU %.3fms, GPU: %.3fms.", 1000.0 * (t2 - t1), 1000.0 * (t1 - t0))
        logger.info("Transformation took %.3fms", 1e-6 * (k1.profile.end - k1.profile.start))