Swift中高斯图像金字塔的下采样和上采样
Dav*_*ine 10 image-processing core-image ios swift
介绍
我有兴趣编写一个函数,为我输出高斯金字塔中的下一个级别(我最终想要创建一个拉普拉斯金字塔)用于图像处理.(参考链接https://en.wikipedia.org/wiki/Pyramid_(image_processing)#Gaussian_pyramid)
下采样问题
现在,最简单的部分就是当您进行向下/向上采样时,在调整大小之前,将5抽头过滤器与图像进行对比.
然而,关于制作图像金字塔的有趣部分是,您必须对图像进行下采样和上采样0.5或2倍,具体取决于您要去的方向.Swift有几种方法可以做到这一点,比如使用CIAffineTransform和CILanczosTransform,但是我想知道是否有办法更天真地做这件事,因为我不关心调整大小的图像的质量.对于这篇文章,我将以Lenna(512x512)为例,如下所示:
如果我们想要将图像下采样两倍,我们将采用所有奇数编号的像素数据来形成新图像.在MATLAB中,执行如下(在高斯模糊之后):
如果I是您的输入图像并且大小为NxM,为P(512x512x3矩阵)存储了3种颜色映射,那么缩放图像的缩放比例为.5
R = I(1:2:end, 1:2:end,:)
所有新图像都是前一个图像的奇数编号的列和行.这产生以下,256x256照片,这是高斯金字塔的第一级:
swift中存在这样的事情吗？它是可行的Core Image,还是OpenGL自定义过滤器？
上采样问题:
上采样实际上仅在创建拉普拉斯金字塔时使用.然而,这样做的天真想法是做以下事情:
初始化R,您要上采样的大小的空白图像上下文.在这种情况下,我们将对上采样的Lenna照片进行上采样,如上图所示,因此R必须是512x512的空白图像.
接下来,将下采样图像的像素值乘以I4.这可以通过将图像与3×3矩阵卷积来快速完成[0,0,0;0,4,0;0,0,0].然后,可以将图像的像素均匀地分布到较大的空白图像中R.这看起来像:
最后,可以在此图像上使用相同的5抽头高斯模糊来恢复上采样图像:
我想知道是否可以在swift中采用类似的上采样方法.
我不确定的另一件事是,对于为高斯/拉普拉斯滤波调整图像大小的技术真的很重要.如果没有,那么我当然可以使用最快的内置方法而不是试图制作自己的方法.
我已经取得了一些进展，我几乎认为这是我问题的答案，尽管有些事情有点不同，而且我认为这种方法不是很快。我很乐意听取任何人的意见，了解如何使此代码更快。在下面，调整图像大小似乎占用了最多的时间，我收到大量对 ovveride outputImage 部分的调用，但我不知道为什么会这样。不幸的是，当我运行下面的拉普拉斯金字塔函数时，在 275x300 照片上完成大约需要 5 秒。这只是不好，而且我对如何加快速度有点不知所措。我怀疑重采样过滤器是罪魁祸首。但是我不够精通，不知道如何使其更快。
首先，自定义过滤器：
第一个通过简单的重新缩放来调整图像大小。我认为在这种情况下这是最好的重新缩放技术，因为所做的只是在调整大小时复制像素。例如，如果我们有以下像素块并执行 2.0 缩放，则映射如下所示：
[ ][ ][x][ ] ----->[ ][ ][ ][ ][x][x][ ][ ]（感谢西蒙·格拉德曼（Simon Gladman）提出的这个想法）
public class ResampleFilter: CIFilter
{
var inputImage : CIImage?
var inputScaleX: CGFloat = 1
var inputScaleY: CGFloat = 1
let warpKernel = CIWarpKernel(string:
"kernel vec2 resample(float inputScaleX, float inputScaleY)" +
" { " +
" float y = (destCoord().y / inputScaleY); " +
" float x = (destCoord().x / inputScaleX); " +
" return vec2(x,y); " +
" } "
)
override public var outputImage: CIImage!
{
if let inputImage = inputImage,
kernel = warpKernel
{
let arguments = [inputScaleX, inputScaleY]
let extent = CGRect(origin: inputImage.extent.origin,
size: CGSize(width: inputImage.extent.width*inputScaleX,
height: inputImage.extent.height*inputScaleY))
return kernel.applyWithExtent(extent,
roiCallback:
{
(index,rect) in
let sampleX = rect.origin.x/self.inputScaleX
let sampleY = rect.origin.y/self.inputScaleY
let sampleWidth = rect.width/self.inputScaleX
let sampleHeight = rect.height/self.inputScaleY
let sampleRect = CGRect(x: sampleX, y: sampleY, width: sampleWidth, height: sampleHeight)
return sampleRect
},
inputImage : inputImage,
arguments : arguments)
}
return nil
}
}
这是一个简单的差异混合。
public class DifferenceOfImages: CIFilter
{
var inputImage1 : CIImage? //Initializes input
var inputImage2 : CIImage?
var kernel = CIKernel(string: //The actual custom kernel code
"kernel vec4 Difference(__sample image1,__sample image2)" +
" { " +
" float colorR = image1.r - image2.r; " +
" float colorG = image1.g - image2.g; " +
" float colorB = image1.b - image2.b; " +
" return vec4(colorR,colorG,colorB,1); " +
" } "
)
var extentFunction: (CGRect, CGRect) -> CGRect =
{ (a: CGRect, b: CGRect) in return CGRectZero }
override public var outputImage: CIImage!
{
guard let inputImage1 = inputImage1,
inputImage2 = inputImage2,
kernel = kernel
else
{
return nil
}
//apply to whole image
let extent = extentFunction(inputImage1.extent,inputImage2.extent)
//arguments of the kernel
let arguments = [inputImage1,inputImage2]
//return the rectangle that defines the part of the image that CI needs to render rect in the output
return kernel.applyWithExtent(extent,
roiCallback:
{ (index, rect) in
return rect
},
arguments: arguments)
}
}
现在一些函数定义：
该函数只是根据 Burt & Adelson 论文中描述的相同 5 抽头滤波器对图像执行高斯模糊。不知道如何摆脱看起来多余的尴尬边框像素。
public func GaussianFilter(ciImage: CIImage) -> CIImage
{
//5x5 convolution to image
let kernelValues: [CGFloat] = [
0.0025, 0.0125, 0.0200, 0.0125, 0.0025,
0.0125, 0.0625, 0.1000, 0.0625, 0.0125,
0.0200, 0.1000, 0.1600, 0.1000, 0.0200,
0.0125, 0.0625, 0.1000, 0.0625, 0.0125,
0.0025, 0.0125, 0.0200, 0.0125, 0.0025 ]
let weightMatrix = CIVector(values: kernelValues,
count: kernelValues.count)
let filter = CIFilter(name: "CIConvolution5X5",
withInputParameters: [
kCIInputImageKey: ciImage,
kCIInputWeightsKey: weightMatrix])!
let final = filter.outputImage!
let rect = CGRect(x: 0, y: 0, width: ciImage.extent.size.width, height: ciImage.extent.size.height)
return final.imageByCroppingToRect(rect)
}
这个函数只是简化了resample的使用。您可以指定新图像的目标尺寸。在我看来，这比设置比例参数更容易处理。
public func resampleImage(inputImage: CIImage, sizeX: CGFloat, sizeY: CGFloat) -> CIImage
{
let inputWidth : CGFloat = inputImage.extent.size.width
let inputHeight : CGFloat = inputImage.extent.size.height
let scaleX = sizeX/inputWidth
let scaleY = sizeY/inputHeight
let resamplefilter = ResampleFilter()
resamplefilter.inputImage = inputImage
resamplefilter.inputScaleX = scaleX
resamplefilter.inputScaleY = scaleY
return resamplefilter.outputImage
}
该功能只是简化了差分滤波器的使用。请注意，这是
imageOne - ImageTwo。
public func Difference(imageOne:CIImage,imageTwo:CIImage) -> CIImage
{
let generalFilter = DifferenceOfImages()
generalFilter.inputImage1 = imageOne
generalFilter.inputImage2 = imageTwo
generalFilter.extentFunction = { (fore, back) in return back.union(fore)}
return generalFilter.outputImage
}
该函数计算每个金字塔的层数，并将它们存储在一个数组中。对以后有用。
public func LevelDimensions(image: CIImage,levels:Int) -> [[CGFloat]]
{
let inputWidth : CGFloat = image.extent.width
let inputHeight : CGFloat = image.extent.height
var levelSizes : [[CGFloat]] = [[inputWidth,inputHeight]]
for j in 1...(levels-1)
{
let temp = [floor(inputWidth/pow(2.0,CGFloat(j))),floor(inputHeight/pow(2,CGFloat(j)))]
levelSizes.append(temp)
}
return levelSizes
}
现在来说说好东西：这个创建了一个给定层数的高斯金字塔。
public func GaussianPyramid(image: CIImage,levels:Int) -> [CIImage]
{
let PyrLevel = LevelDimensions(image, levels: levels)
var GauPyr : [CIImage] = [image]
var I : CIImage
var J : CIImage
for j in 1 ... levels-1
{
J = GaussianFilter(GauPyr[j-1])
I = resampleImage(J, sizeX: PyrLevel[j][0], sizeY: PyrLevel[j][1])
GauPyr.append(I)
}
return GauPyr
}
最后，该函数创建具有给定层数的拉普拉斯金字塔。请注意，在两个金字塔函数中，每个级别都存储在一个数组中。
public func LaplacianPyramid(image:CIImage,levels:Int) -> [CIImage]
{
let PyrLevel = LevelDimensions(image, levels:levels)
var LapPyr : [CIImage] = []
var I : CIImage
var J : CIImage
J = image
for j in 0 ... levels-2
{
let blur = GaussianFilter(J)
I = resampleImage(blur, sizeX: PyrLevel[j+1][0], sizeY: PyrLevel[j+1][1])
let diff = Difference(J,imageTwo: resampleImage(I, sizeX: PyrLevel[j][0], sizeY: PyrLevel[j][1]))
LapPyr.append(diff)
J = I
}
LapPyr.append(J)
return LapPyr
}