Swift
简介
我有兴趣编写一个函数，为我输出高斯金字塔中的下一个级别（我最终想要创建拉普拉斯金字塔）以用于图像处理。 （链接以供参考https://en.wikipedia.org/wiki/Pyramid_(image_processing)#Gaussian_pyramid）
下采样问题
现在，最简单的一点是，当您进行向上/向上采样时，在调整大小之前，会将5拍过滤器与图像进行对比。
然而，关于制作图像金字塔的有趣部分是，您必须按照.5或2的系数对图像进行下采样和上采样，具体取决于您要去的方向。 Swift有几种方法可以做到这一点，比如使用CIAffineTransform和CILanczosTransform，但是我想知道是否有办法更天真地做这件事，因为我不关心调整大小的图像的质量。对于这篇文章，我将以Lenna（512x512）为例，如下所示：
如果我们想要将图像下采样两倍，我们将采用所有奇数编号的像素数据来形成新图像。在MATLAB中，这如下执行（在高斯模糊之后）：
如果I是您的输入图像并且大小为NxM，并且为P（512x512x3矩阵）存储了3种颜色映射，那么缩放图像的抽取图像为
R = I(1:2:end, 1:2:end,:)
所有新图像都是前一个图像的奇数编号列和行。这产生以下，256x256照片，这是高斯金字塔的第一级：
这样的事情在swift中存在吗？它可以在Core Image中使用，还是可以使用OpenGL自定义过滤器？
上采样问题：
上采样实际上仅在创建拉普拉斯金字塔时使用。然而，这样做的天真想法是做以下事情：
初始化R，一个您要上传到的示例尺寸的空白图片上下文。在这种情况下，我们将对上采样的Lenna照片进行上采样，如上所示，因此R必须是512x512的空白图像。
接下来，将下采样图像的像素值I乘以4.这可以通过将图像与3x3矩阵[0,0,0;0,4,0;0,0,0]进行卷积来快速完成。然后，可以将图像的像素均匀地分布到较大的空白图像R中。这看起来像：
最后，可以在此图像上使用相同的5抽头高斯模糊来恢复上采样图像：
我想知道是否可以在swift中采用类似的上采样方法。
我不确定的另一件事是，对于为高斯/拉普拉斯滤波调整图像大小的技术是否真的很重要。如果没有，那么我当然可以使用最快的内置方法而不是试图制作自己的方法。
2 个答案:
答案 0 :(得分：2)
GPUImage processing library可以为您提供一些上采样，并可能导致您的拉普拉斯金字塔。
pod 'GPUImage'
SHARPEN UPSAMPLING：
UIImage *inputImage = [UIImage imageNamed:@"cutelady"];
GPUImagePicture *stillImageSource = [[GPUImagePicture alloc]initWithImage:inputImage];
GPUImageSharpenFilter *stillImageFilter = [[GPUImageSharpenFilter alloc] init];
[stillImageSource addTarget:stillImageFilter];
[stillImageFilter useNextFrameForImageCapture];
[stillImageSource processImage];
UIImage *currentFilteredVideoFrame = [stillImageFilter imageFromCurrentFramebuffer];
LANCZOS UPSAMPLING：
UIImage *inputImage = [UIImage imageNamed:@"cutelady"];
GPUImagePicture *stillImageSource = [[GPUImagePicture alloc] initWithImage:inputImage];
GPUImageLanczosResamplingFilter *stillImageFilter = [[GPUImageLanczosResamplingFilter alloc] init];
[stillImageSource addTarget:stillImageFilter];
[stillImageFilter useNextFrameForImageCapture];
[stillImageSource processImage];
[stillImageSource forceProcessingAtSizeRespectingAspectRatio:CGSizeMake(200, 200)];
UIImage *currentFilteredVideoFrame = [stillImageFilter imageFromCurrentFramebuffer];
cell.imageView.image = currentFilteredVideoFrame;
答案 1 :(得分：1)
我已经取得了一些进展，我几乎认为这是我的问题的答案，虽然有些事情有点不同，我不认为这种方法非常快。我很乐意听到任何人看到如何使这段代码更快。在下面，似乎调整图像大小占用了大部分时间，我得到了一个调用ovveride outputImage部分的TON，我不知道为什么会这样。不幸的是，当我在下面运行拉普拉斯金字塔函数时，在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＆amp; Sons中所述的相同的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)
}
此功能只是简化了重采样的使用。您可以指定新图像的目标大小。事实证明，这更容易处理而不是设置比例参数IMO。
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
}
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？