Ios 纲领性的；模糊的；UIView的背景样式

当然，为背景设置素色很简单：

如今，应用程序的设计特点是使用“模糊”或“多云”背景，而不是使用“纯灰色”

例如，这里有两个“模糊”背景-它只是一个简单的颜色，可能有一些噪音，可能模糊

<> P>你可以看到这样的背景，考虑流行的饲料应用程序（WHASApp等）。这是我们这个时代的“时尚”

我突然想到，如果你能用Swift的代码来做这件事，那就太棒了

注意：从PNG开始不是一个优雅的解决方案：

希望可以从头开始以编程方式生成所有内容

如果检查员有一个IBDesignable样式的滑块，那就太好了，“添加时尚的‘粒状’背景…”-在新时代应该是可能的

我们使用很棒的组件。它真的很容易使用。我想它可以帮助你

---

KGNoise在静态128x128图像中生成随机黑白像素，然后平铺以填充空间。随机像素的种子值被选为看起来最随机的值，这也意味着在应用程序启动之间，噪声看起来是一致的。

您可以轻松地使用。它配备了大量的模糊、噪声发生器和过滤器。。您可以按顺序将它们连接在一起，构建复杂的GPU加速效果

给你一个好的起点。下面是一个函数的快速原型，它使用GPUImage做一些您想要做的事情。如果将“orUseNoise”设置为“是”，则会创建基于柏林噪波的模糊图像，而不是图像。调整指出的值以更改所需效果

- (UIImage *)blurWithGPUImage:(UIImage *)sourceImage orUseNoise:(bool) useNoise {
    GPUImagePicture *stillImageSource = [[GPUImagePicture alloc] initWithImage:sourceImage];

    GPUImageGaussianBlurFilter *gaussFilter = [[GPUImageGaussianBlurFilter alloc] init];
    [gaussFilter setBlurRadiusInPixels:6];                                      //<<-------TWEAK
    [gaussFilter setBlurPasses:1];                                              //<<-------TWEAK

    if(useNoise) {
        GPUImagePerlinNoiseFilter* perlinNouse = [[GPUImagePerlinNoiseFilter alloc] init];
        [perlinNouse setColorStart:(GPUVector4){1.0, 1.0, 1.0f, 1.0}];          //<<-------TWEAK
        [perlinNouse setColorFinish:(GPUVector4){0.5,0.5, 0.5f, 1.0}];          //<<-------TWEAK
        [perlinNouse setScale:200];                                             //<<-------TWEAK
        [stillImageSource addTarget:perlinNouse];
        [perlinNouse addTarget:gaussFilter];
    } else {
        [stillImageSource addTarget:gaussFilter];
    }

    [gaussFilter useNextFrameForImageCapture];
    [stillImageSource processImage];

    UIImage *outputImage = [gaussFilter imageFromCurrentFramebuffer];

    // Set up output context.
    UIGraphicsBeginImageContext(self.view.frame.size);
    CGContextRef outputContext = UIGraphicsGetCurrentContext();

    // Invert image coordinates
    CGContextScaleCTM(outputContext, 1.0, -1.0);
    CGContextTranslateCTM(outputContext, 0, -self.view.frame.size.height);

    // Draw base image.
    CGContextDrawImage(outputContext, self.view.frame, outputImage.CGImage);

    // Apply tint
    CGContextSaveGState(outputContext);
    UIColor* tint = [UIColor colorWithWhite:1.0f alpha:0.6];                    //<<-------TWEAK
    CGContextSetFillColorWithColor(outputContext, tint.CGColor);
    CGContextFillRect(outputContext, self.view.frame);
    CGContextRestoreGState(outputContext);

    // Output image
    outputImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return outputImage;
}

-（UIImage*）模糊带GPuimage:（UIImage*）源图像或useNoise:（bool）useNoise{
GPUImagePicture*stillImageSource=[[GPUImagePicture alloc]initWithImage:sourceImage]；
GPUImageGaussianBlurFilter*gaussFilter=[[GPUImageGaussianBlurFilter alloc]init]；
[gaussFilter setBlurRadiusInPixels:6]；//当问题要求一个“程序化”解决方案时，我想到的是，您试图做的事情和所指的“模糊”听起来很像iOS 8中引入的
UIBlurEffect
、
UIVisualEffectView
和
UIVibrancyEffect


为了使用这些，您可以在情节提要场景中拖动
UIVisualEffectView
，以向屏幕的特定部分添加模糊或振动效果

如果要使整个场景在上一个场景的顶部显示视觉效果，则应配置以下内容：

将“视图控制器”或“演示文稿”设置为“演示文稿=当前上下文”，并使“背景色”模糊

将显示的视图控制器的背景色设置为
clearColor

将显示的视图控制器的全部内容嵌入
UIVisualEffectView

这样，您可以获得如下效果：

func createNoiseImage(size: CGSize, color: UIColor) -> UIImage {
    UIGraphicsBeginImageContext(size)
    let context = UIGraphicsGetCurrentContext()

    CGContextSetFillColorWithColor(context, color.CGColor)
    CGContextFillRect(context, CGRectMake(0, 0, size.width, size.height))

    let image = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext();

    let filter = GPUImagePerlinNoiseFilter()
    return filter.imageByFilteringImage(image)
}

这将让你开始，基于我很久以前写的东西：


@IBInspectable
属性：


noiseColor
：噪波/纹理颜色，它应用于视图的
背景颜色
noiseMinAlpha
：随机噪声可以达到的最小alpha
noiseMaxAlpha
：随机噪声可以达到的最大alpha
NoisePass
：应用噪波的次数越多，传递速度越慢，但会产生更好的噪波效果
噪波间隔
：随机噪波发生的频率越高，间隔越大意味着噪波频率越低

说明：

当任何可设计的噪声属性更改时，视图将被标记为重新绘制。在绘制功能中，将生成
UIImage
（或从
NSCache
中提取，如果可用）

在生成方法中，对每个像素进行迭代，如果像素应该是噪波（取决于间距参数），则使用随机alpha通道应用噪波颜色。这样做的次数与通过次数相同


//NoiseView.swift
导入UIKit
让noiseImageCache=NSCache（）
@IBDesignable类NoiseView:UIView{
让noiseImageSize=CGSizeMake（128128）
@IBInspectable var noiseColor:UIColor=UIColor.blackColor（）{
didSet{setNeedsDisplay（）}
}
@IBInspectable var NoiseMiniAlpha:CGFloat=0{
didSet{setNeedsDisplay（）}
}
@IBInspectable var noiseMaxAlpha:CGFloat=1{
didSet{setNeedsDisplay（）}
}
@IBInspectable var NoisePass:Int=1{
迪塞特{
NoisePass=最大值（0，NoisePass）
setNeedsDisplay（）
}
}
@IBInspectable var noiseSpacing:Int=1{
迪塞特{
noiseSpacing=最大值（1，noiseSpacing）
setNeedsDisplay（）
}
}
重写func drawRect（rect:CGRect）{
super.drawRect（rect）
UIColor（patternImage:currentUIImage（））.set（）
UIRectFillUsingBlendMode（边界、.Normal）
}
private func currentUIImage（）->UIImage{
//基于所有参数的密钥
让cacheKey=“\（noisemagesize），\（noiseColor），\（noiseMinAlpha），\（noiseMaxAlpha），\（noisePasses）”
var image=noiseImageCache.objectForKey（cacheKey）as！UIImage！
如果图像==nil{
image=generatedUIImage（）
#如果！目标界面生成器
setObject（图像，forKey:cacheKey）
#恩迪夫
}
返回图像
}
private func generatedUIImage（）->UIImage{
UIGraphicsBeginImageContextWithOptions（noiseImageSize，false，0）
func createNoiseImage(size: CGSize, color: UIColor) -> UIImage {
    UIGraphicsBeginImageContext(size)
    let context = UIGraphicsGetCurrentContext()

    CGContextSetFillColorWithColor(context, color.CGColor)
    CGContextFillRect(context, CGRectMake(0, 0, size.width, size.height))

    let image = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext();

    let filter = GPUImagePerlinNoiseFilter()
    return filter.imageByFilteringImage(image)
}

import UIKit

let noiseImageCache = NSCache<AnyObject, AnyObject>()

@IBDesignable class NoiseView: UIView {

    let noiseImageSize = CGSize(width: 128.0, height: 128.0)

    @IBInspectable var noiseColor: UIColor = UIColor.black {
        didSet { setNeedsDisplay() }
    }
    @IBInspectable var noiseMinAlpha: CGFloat = 0 {
        didSet { setNeedsDisplay() }
    }
    @IBInspectable var noiseMaxAlpha: CGFloat = 0.5 {
        didSet { setNeedsDisplay() }
    }
    @IBInspectable var noisePasses: Int = 3 {
        didSet {
            noisePasses = max(0, noisePasses)
            setNeedsDisplay()
        }
    }
    @IBInspectable var noiseSpacing: Int = 1 {
        didSet {
            noiseSpacing = max(1, noiseSpacing)
            setNeedsDisplay()
        }
    }

    override func draw(_ rect: CGRect) {
        super.draw(rect)
        UIColor(patternImage: currentUIImage()).set()
        UIRectFillUsingBlendMode(bounds, .normal)
    }

    private func currentUIImage() -> UIImage {

        //  Key based on all parameters
        let cacheKey = "\(noiseImageSize),\(noiseColor),\(noiseMinAlpha),\(noiseMaxAlpha),\(noisePasses)"
        var image = noiseImageCache.object(forKey: cacheKey as AnyObject) as? UIImage

        if image == nil {
            image = generatedUIImage()

            #if !TARGET_INTERFACE_BUILDER
                noiseImageCache.setObject(image!, forKey: cacheKey as AnyObject)
            #endif
        }
        return image!
    }

    private func generatedUIImage() -> UIImage {
        UIGraphicsBeginImageContextWithOptions(noiseImageSize, false, 0)
        let accuracy: CGFloat = 1000.0
        for _ in 0..<noisePasses {
            for y in 0..<Int(noiseImageSize.height) {
                for x in 0..<Int(noiseImageSize.width) {
                    if Int(arc4random()) % noiseSpacing == 0 {
                        let alpha = (CGFloat(arc4random() % UInt32((noiseMaxAlpha - noiseMinAlpha) * accuracy)) / accuracy) + noiseMinAlpha
                        noiseColor.withAlphaComponent(alpha).set()
                        UIRectFill(CGRect(x: x, y: y, width: 1, height: 1))
                    }
                }
            }
        }
        let image = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return image!
    }
}