Core Image Kernel Language's OpenGL coordinate system - ios

Question

I'm writing a simple(at least I thought it would be simple) custom kernel that takes the difference of a specified pixel and an entire image.
Below is the code that I have, this just makes the filter. It's good to use in a playground play with.
import UIKit
import CoreImage
let Flower = CIImage( image: UIImage(named: "flower.png")!)!
class Test: CIFilter
{
var inputImage1 : CIImage?
var inputImage2 : CIImage?
var kernel = CIKernel(string:
"kernel vec4 colorRemap(sampler inputIm, sampler GaussIm) " +
"{ " +
"vec4 size = samplerExtent(inputIm); " +
"float row = 1.0; " +
"float column = 1.0; " +
"float pixelx = (column - 1.0)/(size.w - 1.0)+1.0/(2.0*size.z);" +
"float pixely = (size.z - row)/(size.z - 1.0)-1.0/(2.0*size.w);" +
"vec3 g0 =sample(GaussIm,vec2(pixelx,pixely)).rgb; " +
"vec3 current = sample(inputIm,samplerCoord(inputIm)).rgb; " +
"vec3 diff =(current - g0); " +
"return vec4(diff,1.0); " +
"} "
)
var extentFunction: (CGRect, CGRect) -> CGRect =
{ (a: CGRect, b: CGRect) in return CGRectZero }
override var outputImage: CIImage!
{
if let inputImage1 = inputImage1,
inputImage2 = inputImage2,
kernel = kernel
{
let extent = inputImage1.extent
let arguments = [inputImage1,inputImage2]
return kernel.applyWithExtent(extent,
roiCallback:
{ (index, rect) in
return rect
},
arguments: arguments)
}
return nil
}
}
To use the filter, you can do the following
let filter = Test()
filter.inputImage1 = Flower
filter.inputImage2 = Flower
let output = filter.outputImage
Now, in the above code, I've specified that we're taking the difference between the pixel located at (1,1) of GaussIm, as if we were treating the image as a matrix (in the usual sense), and the entire image of inputIm.
After playing around, I had come to realize that the Custom Kernel Language treats images a bit like OpenGL does. The bottom left corner is mapped to (0,0), and the top right being (1,1), so that pixel coordinates are numbers between 0 and 1. The issue with this is that I want to specify whatever pixel I want to use to take the difference.
The first 5 lines of the kernel code attempts to alleviate this by computing the center of each pixel location in the image. I'm not sure if this is right considering how OpenGL treats it's images, or maybe there's a better way.
If I run this code above, with the below image:
I get the following with XCode:
Further, if I do the same thing in MATLAB, I get the following output:
Why am I getting a different output than in MATLAB? It almost seems a tad darker than what I'm getting from my custom filter, and yet they are close to the same output at the same time. My thought was that it must be the way the custom kernel is taking the difference amongst pixels, but I'm not really sure what's going on.

Answer 1

I ended up figuring this out -- the reason for the clipping is due to the nature of how images are computed. This work was done in a playground, not on a context, so anything that was displayed was clipped to the range of [0,1]. The way to fix this was to make sure that your CIContext that you are doing calculations on support a floating point precision in its calculations, via the options.