iOS 高仿微信相机拍摄和编辑

### 一 、效果预览

> ##### 效果描述：
> * 1、自定义相机、 拍摄视频和照片
> * 2、切换前后摄像头、调整焦距/设置聚焦点、横屏拍摄
> * 3、视频编辑：涂鸦、贴图、文字水印、视频裁剪 、添加背景音乐
> * 4 、图片编辑：涂鸦、贴图、文字水印、马赛克、图片裁剪

![](/contentImages/image/20191104/M9DS3T497ZBjuS5Gxwi.gif)

![](/contentImages/image/20191104/bd5Z4HPxxTk8SbipN99.gif)

![](/contentImages/image/20191104/vy2vSScIIKpuAiupLv1.gif)

### 二、自定义相机、 拍摄视频和照片

> 自定义相机、拍摄输出照片和视频主要是依赖以下这些类。这些类的用法就不在此赘述了，下载代码查看即可，注释详尽。

```

@property (nonatomic, strong) AVCaptureSession *session;  //采集会话
@property (nonatomic, strong) AVCaptureVideoPreviewLayer *previewLayer;//摄像头采集内容展示区域

@property (nonatomic, strong) AVCaptureDeviceInput *audioInput; //音频输入流
@property (nonatomic, strong) AVCaptureDeviceInput *videoInput; //视频输入流
@property (nonatomic, strong) AVCapturePhotoOutput *capturePhotoOutput; //照片输出流
@property (nonatomic, strong) AVCaptureVideoDataOutput *videoDataOutput; //视频数据帧输出流
@property (nonatomic, strong) AVCaptureAudioDataOutput *audioDataOutput; //音频数据帧输出流

@property (nonatomic, strong) AVAssetWriter *assetWriter;   //音视频数据流文件写入
@property (nonatomic, strong) AVAssetWriterInput *assetWriterVideoInput;  //写入视频文件
@property (nonatomic, strong) AVAssetWriterInput *assetWriterAudioInput;  //写入音频文件

```

### 三、切换前后摄像头、调整焦距和聚焦点、横屏拍摄

* 切换前/后置摄像头

```
//切换前/后置摄像头
- (void)switchsCamera:(AVCaptureDevicePosition)devicePosition {
    //当前设备方向
    if (self.devicePosition == devicePosition) {
        return;
    }
    AVCaptureDeviceInput *videoInput = [AVCaptureDeviceInput deviceInputWithDevice:[self getCameraDeviceWithPosition:devicePosition] error:nil];
    //先开启配置，配置完成后提交配置改变
    [self.session beginConfiguration];
    //移除原有输入对象
    [self.session removeInput:self.videoInput];
    //添加新的输入对象
    if ([self.session canAddInput:videoInput]) {
        [self.session addInput:videoInput];
        self.videoInput = videoInput;
    }
    
    //视频输入对象发生了改变  视频输出的链接也要重新初始化
    AVCaptureConnection * captureConnection = [self.videoDataOutput connectionWithMediaType:AVMediaTypeVideo];
    if ([captureConnection isVideoStabilizationSupported]) {
        //视频稳定模式
        captureConnection.preferredVideoStabilizationMode = AVCaptureVideoStabilizationModeAuto;
    }
    if (self.devicePosition == AVCaptureDevicePositionFront && captureConnection.supportsVideoMirroring) {
        captureConnection.videoMirrored = YES;
    }
    
    if (self.devicePosition == AVCaptureDevicePositionFront) {
        if (self.shootingOrientation == UIDeviceOrientationLandscapeRight) {
            captureConnection.videoOrientation = AVCaptureVideoOrientationLandscapeRight;
        } else if (self.shootingOrientation == UIDeviceOrientationLandscapeLeft) {
            captureConnection.videoOrientation = AVCaptureVideoOrientationLandscapeRight;
        } else if (self.shootingOrientation == UIDeviceOrientationPortraitUpsideDown) {
            captureConnection.videoOrientation = AVCaptureVideoOrientationLandscapeRight;
        } else {
            captureConnection.videoOrientation = AVCaptureVideoOrientationLandscapeRight;
        }
    }
    //提交新的输入对象
    [self.session commitConfiguration];
}

```

* 调整焦距/设置聚焦点

```
//设置焦距
- (void)setVideoZoomFactor:(CGFloat)videoZoomFactor {
    NSError *error = nil;
    if (videoZoomFactor <= self.maxZoomFactor &&
        videoZoomFactor >= self.minZoomFactor){
        if ([[self.videoInput device] lockForConfiguration:&error] ) {
            [self.videoInput device].videoZoomFactor = videoZoomFactor;
            [[self.videoInput device] unlockForConfiguration];
        } else {
            NSLog( @"调节焦距失败: %@", error );
        }
    }
}

//设置聚焦点和模式  默认连续自动聚焦和自动曝光模式
- (void)focusAtPoint:(CGPoint)focalPoint {
    //将UI坐标转化为摄像头坐标  (0,0) -> (1,1)
    CGPoint cameraPoint = [self.previewLayer captureDevicePointOfInterestForPoint:focalPoint];
    AVCaptureDevice *captureDevice = [self.videoInput device];
    NSError * error;
    //注意改变设备属性前一定要首先调用lockForConfiguration:调用完之后使用unlockForConfiguration方法解锁
    if ([captureDevice lockForConfiguration:&error]) {
        if ([captureDevice isFocusModeSupported:AVCaptureFocusModeContinuousAutoFocus]) {
            [captureDevice setFocusMode:AVCaptureFocusModeContinuousAutoFocus];
        }
        if ([captureDevice isFocusPointOfInterestSupported]) {
            [captureDevice setFocusPointOfInterest:cameraPoint];
        }
        //曝光模式
        if ([captureDevice isExposureModeSupported:AVCaptureExposureModeContinuousAutoExposure]) {
            [captureDevice setExposureMode:AVCaptureExposureModeContinuousAutoExposure];
        }
        if ([captureDevice isExposurePointOfInterestSupported]) {
            [captureDevice setExposurePointOfInterest:cameraPoint];
        }
        [captureDevice unlockForConfiguration];
    } else {
        NSLog(@"设置聚焦点错误：%@", error.localizedDescription);
    }
}

```

### 四、视频编辑

*  视频编辑主要依赖的类：

```
@property (nonatomic, strong) AVAsset *asset;  //资源文件
@property (nonatomic, strong) AVAssetExportSession *exportSession;  //资源导出会话
@property (nonatomic, strong) AVMutableComposition *composition;  //可变工程文件 合并音视频素材
@property (nonatomic, strong) AVMutableVideoComposition *videoComposition;  //视频成分
@property (nonatomic, strong) AVMutableAudioMix *audioMix;   // 音频混合

```

*  主要类的初始化和用法，加了比较详细的注释，应该比较好理解的。

```

- (AVAssetExportSession *)exportSession {
    if (!_exportSession) {
        //导出会话
        _exportSession = [[AVAssetExportSession alloc] initWithAsset:self.composition presetName:AVAssetExportPresetHighestQuality];
        /** 创建混合视频时开始剪辑 */
        //        _exportSession.timeRange = self.timeRange;
        _exportSession.videoComposition = self.videoComposition;
        _exportSession.outputURL = self.outputURL;
        _exportSession.outputFileType = AVFileTypeMPEG4;
        _exportSession.audioMix = self.audioMix;
    }
    return _exportSession;
}
- (AVMutableComposition *)composition {
    if (!_composition) {
        _composition = [[AVMutableComposition alloc] init];
    }
    return _composition;
}
- (AVMutableVideoComposition *)videoComposition {
    if (!_videoComposition) {
        //资源文件的视频轨道
        AVAssetTrack *assetVideoTrack = nil;
        // 是否包含视频轨道
        if ([[self.asset tracksWithMediaType:AVMediaTypeVideo] count] != 0) {
            assetVideoTrack = [self.asset tracksWithMediaType:AVMediaTypeVideo][0];
        }
        CMTime insertionPoint = kCMTimeZero;
        NSError *error = nil;
        // 添加视频轨道和素材 并裁剪视频
        if (assetVideoTrack != nil) {
            // 视频通道  工程文件中的轨道，有音频轨、视频轨等，里面可以插入各种对应的素材
            AVMutableCompositionTrack *compositionVideoTrack = [self.composition addMutableTrackWithMediaType:AVMediaTypeVideo preferredTrackID:kCMPersistentTrackID_Invalid];
            // 视频方向
            [compositionVideoTrack setPreferredTransform:assetVideoTrack.preferredTransform];
            // 把视频轨道数据加入到可变轨道中 这部分可以做视频裁剪TimeRange
            [compositionVideoTrack insertTimeRange:self.timeRange ofTrack:assetVideoTrack atTime:insertionPoint error:&error];
            [compositionVideoTrack scaleTimeRange:CMTimeRangeMake(kCMTimeZero, self.timeRange.duration) toDuration:CMTimeMake(self.timeRange.duration.value/self.rate, self.timeRange.duration.timescale)];
        }
        //视频方向
        UIImageOrientation orientation = [self orientationFromAVAssetTrack:assetVideoTrack];
        CGAffineTransform transform = CGAffineTransformIdentity;
        //视频素材原大小  像素大小px 不是pt
        CGSize renderSize = assetVideoTrack.naturalSize;
        switch (orientation) {
            case UIImageOrientationLeft:
                //顺时针旋转270°
                //            NSLog(@"视频旋转270度，home按键在右");
                transform = CGAffineTransformTranslate(transform, 0.0, assetVideoTrack.naturalSize.width);
                transform = CGAffineTransformRotate(transform,M_PI_2*3.0);
                renderSize = CGSizeMake(assetVideoTrack.naturalSize.height,assetVideoTrack.naturalSize.width);
                break;
            case UIImageOrientationRight:
                //顺时针旋转90°
                //            NSLog(@"视频旋转90度,home按键在左");
                transform = CGAffineTransformTranslate(transform, assetVideoTrack.naturalSize.height, 0.0);
                transform = CGAffineTransformRotate(transform,M_PI_2);
                renderSize = CGSizeMake(assetVideoTrack.naturalSize.height,assetVideoTrack.naturalSize.width);
                break;
            case UIImageOrientationDown:
                //顺时针旋转180°
                //            NSLog(@"视频旋转180度，home按键在上");
                transform = CGAffineTransformTranslate(transform, assetVideoTrack.naturalSize.width, assetVideoTrack.naturalSize.height);
                transform = CGAffineTransformRotate(transform,M_PI);
                renderSize = CGSizeMake(assetVideoTrack.naturalSize.width,assetVideoTrack.naturalSize.height);
                break;
            default:
                break;
        }
        _videoSize = renderSize;
        
        /** iOS9之前的处理方法，之后使用CIFilter ，待学习*/
        //方向
        if (orientation != UIImageOrientationUp || self.graffitiLayer || self.stickerLayers.count) {
            _videoComposition = [AVMutableVideoComposition videoComposition];
            _videoComposition.frameDuration = CMTimeMake(1, 30); // 30 fps
            _videoComposition.renderSize = renderSize;
            AVAssetTrack *videoTrack = [self.composition tracksWithMediaType:AVMediaTypeVideo][0];
            AVMutableVideoCompositionInstruction *roateInstruction = [AVMutableVideoCompositionInstruction videoCompositionInstruction];
            roateInstruction.timeRange = CMTimeRangeMake(kCMTimeZero, self.composition.duration);
            AVMutableVideoCompositionLayerInstruction *roateLayerInstruction = [AVMutableVideoCompositionLayerInstruction videoCompositionLayerInstructionWithAssetTrack:videoTrack];
            [roateLayerInstruction setTransform:transform atTime:kCMTimeZero];
            roateInstruction.layerInstructions = @[roateLayerInstruction];
            //将视频方向旋转加入到视频处理中
            _videoComposition.instructions = @[roateInstruction];
            
            /** 涂鸦 贴图  文字 */
            if(self.graffitiLayer || self.stickerLayers.count) {
                CALayer *parentLayer = [CALayer layer];
                CALayer *videoLayer = [CALayer layer];
                parentLayer.frame = CGRectMake(0, 0, renderSize.width, renderSize.height);
                videoLayer.frame = CGRectMake(0, 0, renderSize.width, renderSize.height);
                [parentLayer addSublayer:videoLayer];
                //涂鸦层
                if (self.graffitiLayer) {
                    [parentLayer addSublayer:self.graffitiLayer];
                }
                //贴画层 和 文本层
                for (CALayer *gifLayer in self.stickerLayers) {
                    [parentLayer addSublayer:gifLayer];
                }
                
                _videoComposition.animationTool = [AVVideoCompositionCoreAnimationTool videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayer:videoLayer inLayer:parentLayer];
            }
        }
        
    }
    return _videoComposition;
}
- (AVMutableAudioMix *)audioMix {
    if (!_audioMix) {
        //音频轨道
        AVAssetTrack *assetAudioTrack = nil;
        if ([[self.asset tracksWithMediaType:AVMediaTypeAudio] count] != 0) {
            assetAudioTrack = [self.asset tracksWithMediaType:AVMediaTypeAudio][0];
        }
        CMTime insertionPoint = kCMTimeZero;
        NSError *error = nil;
        if (assetAudioTrack != nil && _isNativeAudio) {
            AVMutableCompositionTrack *compositionAudioTrack = [self.composition addMutableTrackWithMediaType:AVMediaTypeAudio preferredTrackID:kCMPersistentTrackID_Invalid];
            compositionAudioTrack.preferredTransform = assetAudioTrack.preferredTransform;
            [compositionAudioTrack insertTimeRange:self.timeRange ofTrack:assetAudioTrack atTime:insertionPoint error:&error];
            [compositionAudioTrack scaleTimeRange:CMTimeRangeMake(kCMTimeZero, self.timeRange.duration) toDuration:CMTimeMake(self.timeRange.duration.value/self.rate, self.timeRange.duration.timescale)];
        }
        
        /// 创建额外音轨特效
        NSMutableArray<AVAudioMixInputParameters *> *inputParameters;
        if (self.audioUrls.count) {
            inputParameters = [@[] mutableCopy];
        }
        /// 添加其他音频
        for (NSURL *audioUrl in self.audioUrls) {
            /** 声音采集 */
            AVURLAsset *audioAsset = [[AVURLAsset alloc]initWithURL:audioUrl options:nil];
            AVAssetTrack *additional_assetAudioTrack = nil;
            /** 检查是否有效音轨 */
            if ([[audioAsset tracksWithMediaType:AVMediaTypeAudio] count] != 0) {
                additional_assetAudioTrack = [audioAsset tracksWithMediaType:AVMediaTypeAudio][0];
            }
            if (additional_assetAudioTrack) {
                AVMutableCompositionTrack *additional_compositionAudioTrack = [self.composition addMutableTrackWithMediaType:AVMediaTypeAudio preferredTrackID:kCMPersistentTrackID_Invalid];
                additional_compositionAudioTrack.preferredTransform = additional_assetAudioTrack.preferredTransform;
                [additional_compositionAudioTrack insertTimeRange:self.timeRange ofTrack:additional_assetAudioTrack atTime:insertionPoint error:&error];
                [additional_compositionAudioTrack scaleTimeRange:CMTimeRangeMake(kCMTimeZero, self.timeRange.duration) toDuration:CMTimeMake(self.timeRange.duration.value/self.rate, self.timeRange.duration.timescale)];
                
                AVMutableAudioMixInputParameters *mixParameters = [AVMutableAudioMixInputParameters audioMixInputParametersWithTrack:additional_compositionAudioTrack];
                mixParameters.audioTimePitchAlgorithm = AVAudioTimePitchAlgorithmTimeDomain;
                [mixParameters setVolumeRampFromStartVolume:1 toEndVolume:0.3 timeRange:CMTimeRangeMake(kCMTimeZero, self.timeRange.duration)];
                [inputParameters addObject:mixParameters];
            }
        }
        if (inputParameters.count) {
            self.audioMix = [AVMutableAudioMix audioMix];
            self.audioMix.inputParameters = inputParameters;
        }
    }
    return _audioMix;
}

```

### 五、图像编辑

>  图像编辑的重点在于涂鸦、马赛克、裁剪的实现

#### 1、涂鸦

```
#import "SLDrawView.h"

@interface SLDrawBezierPath : UIBezierPath
@property (nonatomic, strong) UIColor *color; //曲线颜色
@end
@implementation SLDrawBezierPath
@end

@interface SLDrawView ()
{
    BOOL _isWork;
    BOOL _isBegan;
}
/// 笔画
@property (nonatomic, strong) NSMutableArray <SLDrawBezierPath *>*lineArray;
/// 图层
@property (nonatomic, strong) NSMutableArray <CAShapeLayer *>*layerArray;
/// 删除的笔画
@property (nonatomic, strong) NSMutableArray <SLDrawBezierPath *>*deleteLineArray;
/// 删除的图层
@property (nonatomic, strong) NSMutableArray <CAShapeLayer *>*deleteLayerArray;
@end

@implementation SLDrawView

#pragma mark - Override
- (instancetype)initWithFrame:(CGRect)frame {
    self = [super initWithFrame:frame];
    if (self) {
        _lineWidth = 5.f;
        _lineColor = [UIColor blackColor];
        _layerArray = [NSMutableArray array];
        _lineArray = [NSMutableArray array];
        _deleteLineArray = [NSMutableArray array];
        _deleteLayerArray = [NSMutableArray array];
        self.backgroundColor = [UIColor whiteColor];
        self.clipsToBounds = YES;
        self.exclusiveTouch = YES;
    }
    return self;
}
//开始绘画
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    if ([event allTouches].count == 1) {
        _isWork = NO;
        _isBegan = YES;
        //1、每次触摸的时候都应该去创建一条贝塞尔曲线
        SLDrawBezierPath *path = [SLDrawBezierPath new];
        //2、移动画笔
        UITouch *touch = [touches anyObject];
        CGPoint point = [touch locationInView:self];
        //设置线宽
        path.lineWidth = self.lineWidth;
        path.lineCapStyle = kCGLineCapRound; //线条拐角
        path.lineJoinStyle = kCGLineJoinRound; //终点处理
        [path moveToPoint:point];
        //设置颜色
        path.color = self.lineColor;//保存线条当前颜色
        [self.lineArray addObject:path];
        
        CAShapeLayer *slayer = [self createShapeLayer:path];
        [self.layer addSublayer:slayer];
        [self.layerArray addObject:slayer];
    }
    [super touchesBegan:touches withEvent:event];
}
//绘画中
- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    if (_isBegan || _isWork) {
        UITouch *touch = [touches anyObject];
        CGPoint point = [touch locationInView:self];
        SLDrawBezierPath *path = self.lineArray.lastObject;
        if (!CGPointEqualToPoint(path.currentPoint, point)) {
            if (_isBegan && self.drawBegan) self.drawBegan();
            _isBegan = NO;
            _isWork = YES;
            [path addLineToPoint:point];
            CAShapeLayer *slayer = self.layerArray.lastObject;
            slayer.path = path.CGPath;
        }
    }
    [super touchesMoved:touches withEvent:event];
}
//结束绘画
- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event {
    if (_isWork) {
        if (self.drawEnded) self.drawEnded();
    } else {
        if ((_isBegan)) {
            [self goBack];
        }
    }
    _isBegan = NO;
    _isWork = NO;
    [super touchesEnded:touches withEvent:event];
}
//取消绘画
- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    if (_isWork) {
        if (self.drawEnded) self.drawEnded();
    } else {
        if ((_isBegan)) {
            [self goBack];
        }
    }
    _isBegan = NO;
    _isWork = NO;
    [super touchesCancelled:touches withEvent:event];
}

#pragma mark - Help Methods
//创建线条图层
- (CAShapeLayer *)createShapeLayer:(SLDrawBezierPath *)path {
    /** 1、渲染快速。CAShapeLayer使用了硬件加速，绘制同一图形会比用Core Graphics快很多。Core Graphics实现示例： https://github.com/wsl2ls/Draw.git
     2、高效使用内存。一个CAShapeLayer不需要像普通CALayer一样创建一个寄宿图形，所以无论有多大，都不会占用太多的内存。
     3、不会被图层边界剪裁掉。
     4、不会出现像素化。 */
    CAShapeLayer *slayer = [CAShapeLayer layer];
    slayer.path = path.CGPath;
    slayer.backgroundColor = [UIColor clearColor].CGColor;
    slayer.fillColor = [UIColor clearColor].CGColor;
    slayer.lineCap = kCALineCapRound;
    slayer.lineJoin = kCALineJoinRound;
    slayer.strokeColor = path.color.CGColor;
    slayer.lineWidth = path.lineWidth;
    return slayer;
}

#pragma mark - Getter
- (BOOL)isDrawing {
    return _isWork;
}
- (BOOL)canForward {
    return self.deleteLineArray.count;
}
- (BOOL)canBack {
    return self.lineArray.count;
}
#pragma mark - Event Handle
//前进
- (void)goForward {
    if ([self canForward]) {
        //添加刚删除的线条
        [self.layer addSublayer:self.deleteLayerArray.lastObject];
        [self.lineArray addObject:self.deleteLineArray.lastObject];
        [self.layerArray addObject:self.deleteLayerArray.lastObject];
        //从删除池中除去
        [self.deleteLayerArray removeLastObject];
        [self.deleteLineArray removeLastObject];
    }
}
//返回
- (void)goBack {
    if ([self canBack]) {
        //保存上一步删除的线条
        [self.deleteLineArray addObject:self.lineArray.lastObject];
        [self.deleteLayerArray addObject:self.layerArray.lastObject];
        //删除上一步
        [self.layerArray.lastObject removeFromSuperlayer];
        [self.layerArray removeLastObject];
        [self.lineArray removeLastObject];
    }
}
- (void)clear {
    [self.layerArray removeAllObjects];
    [self.lineArray removeAllObjects];
    [self.deleteLayerArray removeAllObjects];
    [self.deleteLineArray removeAllObjects];
    [self.layer.sublayers makeObjectsPerformSelector:@selector(removeFromSuperlayer)];
}
#pragma mark  - 数据
- (NSDictionary *)data {
    if (self.lineArray.count) {
        return @{@"kSLDrawViewData":[self.lineArray copy]};
    }
    return nil;
}
- (void)setData:(NSDictionary *)data {
    NSArray *lineArray = data[@"kSLDrawViewData"];
    if (lineArray.count) {
        for (SLDrawBezierPath *path in lineArray) {
            CAShapeLayer *slayer = [self createShapeLayer:path];
            [self.layer addSublayer:slayer];
            [self.layerArray addObject:slayer];
        }
        [self.lineArray addObjectsFromArray:lineArray];
    }
}
@end

```

#### 2、马赛克

```

//
//  SLMosaicView.m
//  DarkMode
//
//  Created by wsl on 2019/10/25.
//  Copyright © 2019 wsl. All rights reserved.
//

#import "SLMosaicView.h"

#define radiansToDegrees(x) (180.0 * x / M_PI)
///两点之间的角度
CGFloat angleBetweenPoints(CGPoint startPoint, CGPoint endPoint) {
    CGPoint Xpoint = CGPointMake(startPoint.x + 100, startPoint.y);
    CGFloat a = endPoint.x - startPoint.x;
    CGFloat b = endPoint.y - startPoint.y;
    CGFloat c = Xpoint.x - startPoint.x;
    CGFloat d = Xpoint.y - startPoint.y;
    CGFloat rads = acos(((a*c) + (b*d)) / ((sqrt(a*a + b*b)) * (sqrt(c*c + d*d))));
    if (startPoint.y>endPoint.y) {
        rads = -rads;
    }
    return rads;
}
///直线之间的夹角
CGFloat angleBetweenLines(CGPoint line1Start, CGPoint line1End, CGPoint line2Start, CGPoint line2End) {
    CGFloat a = line1End.x - line1Start.x;
    CGFloat b = line1End.y - line1Start.y;
    CGFloat c = line2End.x - line2Start.x;
    CGFloat d = line2End.y - line2Start.y;
    CGFloat rads = acos(((a*c) + (b*d)) / ((sqrt(a*a + b*b)) * (sqrt(c*c + d*d))));
    return radiansToDegrees(rads);
}
/// 马赛克点元素
@interface SLMosaicPointElement : NSObject
@property (nonatomic, assign) CGRect rect;
@property (nonatomic, strong) UIColor *color;
@property (nonatomic, copy) NSString *imageName;
@end
@implementation SLMosaicPointElement
@end
/// 马赛克线条 遮罩层  线
@interface SLMosaicLineLayer : CALayer
@property (nonatomic, strong) NSMutableArray <SLMosaicPointElement *>*elementArray;
@end
@implementation SLMosaicLineLayer
- (instancetype)init {
    self = [super init];
    if (self) {
        self.contentsScale = [[UIScreen mainScreen] scale];
        self.backgroundColor = [UIColor clearColor].CGColor;
        _elementArray = [@[] mutableCopy];
    }
    return self;
}
- (void)drawInContext:(CGContextRef)context {
    UIGraphicsPushContext( context );
    [[UIColor clearColor] setFill];
    UIRectFill(self.bounds);
    
    CGContextSetLineCap(context, kCGLineCapRound);
    CGContextSetLineJoin(context, kCGLineJoinRound);
    for (NSInteger i=0; i<self.elementArray.count; i++) {
        SLMosaicPointElement *blur = self.elementArray[i];
        CGRect rect = blur.rect;
        if (blur.imageName) {
            UIImage *image = [UIImage imageNamed:blur.imageName];
            if (image) {
                /** 创建颜色图片 */
                CGColorSpaceRef colorRef = CGColorSpaceCreateDeviceRGB();
                CGContextRef contextRef = CGBitmapContextCreate(nil, image.size.width, image.size.height, 8, image.size.width*4, colorRef, kCGImageAlphaPremultipliedFirst);
                
                CGRect imageRect = CGRectMake(0, 0, image.size.width, image.size.height);
                CGContextClipToMask(contextRef, imageRect, image.CGImage);
                CGContextSetFillColorWithColor(contextRef, (blur.color ? blur.color.CGColor : [UIColor clearColor].CGColor));
                CGContextFillRect(contextRef,imageRect);
                
                /** 生成图片 */
                CGImageRef imageRef = CGBitmapContextCreateImage(contextRef);
                CGContextDrawImage(context, rect, imageRef);
                
                CGImageRelease(imageRef);
                CGContextRelease(contextRef);
                CGColorSpaceRelease(colorRef);
            }
        } else {
            // 设置描边颜色
            //            CGContextSetStrokeColorWithColor(context, (blur.color ? blur.color.CGColor : [UIColor clearColor].CGColor));
            // 模糊矩形可以用到，用于填充矩形
            CGContextSetFillColorWithColor(context, (blur.color ? blur.color.CGColor : [UIColor clearColor].CGColor));
            // 模糊矩形  填充 画完一个小正方形
            CGContextFillRect(context, rect);
        }
    }
    UIGraphicsPopContext();
}

@end

NSString *const kLFSplashViewData = @"LFSplashViewData";
NSString *const kLFSplashViewData_layerArray = @"LFSplashViewData_layerArray";
NSString *const kLFSplashViewData_frameArray = @"LFSplashViewData_frameArray";
/// 马赛克画板
@interface SLMosaicView ()
{
    BOOL _isWork;
    BOOL _isBegan;
}
/** 图层 */
@property (nonatomic, strong) NSMutableArray <SLMosaicLineLayer *>*layerArray;
/** 已显示坐标 */
@property (nonatomic, strong) NSMutableArray <NSValue *>*frameArray;

//@property (nonatomic, assign) BOOL isErase;
@end

@implementation SLMosaicView

- (instancetype)initWithFrame:(CGRect)frame {
    self = [super initWithFrame:frame];
    if (self) {
        [self customInit];
    }
    return self;
}

#pragma mark - Help Methods
//初始化
- (void)customInit {
    _squareWidth = 15.f;
    _paintSize = CGSizeMake(50, 50);
    _mosaicType = SLMosaicTypeSquare;
    _layerArray = [@[] mutableCopy];
    _frameArray = [@[] mutableCopy];
}
//返回马赛克元素的位置
- (CGPoint)divideMosaicPoint:(CGPoint)point {
    CGFloat scope = self.squareWidth;
    int x = point.x/scope;
    int y = point.y/scope;
    return CGPointMake(x*scope, y*scope);
}
//马赛克元素在设备上的区域
- (NSArray <NSValue *>*)divideMosaicRect:(CGRect)rect {
    CGFloat scope = self.squareWidth;
    
    NSMutableArray *array = @[].mutableCopy;
    
    if (CGRectEqualToRect(CGRectZero, rect)) {
        return array;
    }
    
    CGFloat minX = CGRectGetMinX(rect);
    CGFloat maxX = CGRectGetMaxX(rect);
    CGFloat minY = CGRectGetMinY(rect);
    CGFloat maxY = CGRectGetMaxY(rect);
    
    /** 左上角 */
    CGPoint leftTop = [self divideMosaicPoint:CGPointMake(minX, minY)];
    /** 右下角 */
    CGPoint rightBoom = [self divideMosaicPoint:CGPointMake(maxX, maxY)];
    
    NSInteger countX = (rightBoom.x - leftTop.x)/scope;
    NSInteger countY = (rightBoom.y - leftTop.y)/scope;
    
    for (NSInteger i = 0; i < countX; i++) {
        for (NSInteger j = 0; j < countY;  j++) {
            CGPoint point = CGPointMake(leftTop.x + i * scope, leftTop.y + j * scope);
            NSValue *value = [NSValue valueWithCGPoint:point];
            [array addObject:value];
        }
    }
    return array;
}
#pragma mark - 绘画
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    if (touches.allObjects.count == 1) {
        _isWork = NO;
        _isBegan = YES;
        //1、触摸坐标
        UITouch *touch = [touches anyObject];
        CGPoint point = [touch locationInView:self];
        //2、创建LFSplashBlur
        if (self.mosaicType == SLMosaicTypeSquare) {
            CGPoint mosaicPoint = [self divideMosaicPoint:point];
            NSValue *value = [NSValue valueWithCGPoint:mosaicPoint];
            if (![self.frameArray containsObject:value]) {
                [self.frameArray addObject:value];
                
                SLMosaicPointElement *blur = [SLMosaicPointElement new];
                blur.rect = CGRectMake(mosaicPoint.x, mosaicPoint.y, self.squareWidth, self.squareWidth);
                blur.color = self.brushColor ? self.brushColor(blur.rect.origin) : nil;
                
                SLMosaicLineLayer *layer = [SLMosaicLineLayer layer];
                layer.frame = self.bounds;
                [layer.elementArray addObject:blur];
                
                [self.layer addSublayer:layer];
                [self.layerArray addObject:layer];
            } else {
                SLMosaicLineLayer *layer = [SLMosaicLineLayer layer];
                layer.frame = self.bounds;
                
                [self.layer addSublayer:layer];
                [self.layerArray addObject:layer];
            }
        } else if (self.mosaicType == SLMosaicTypePaintbrush) {
            SLMosaicPointElement  *blur = [ SLMosaicPointElement  new];
            blur.rect = CGRectMake(point.x-self.paintSize.width/2, point.y-self.paintSize.height/2, self.paintSize.width, self.paintSize.height);
            blur.imageName = @"EditMosaicBrush.png";
            blur.color = self.brushColor ? self.brushColor(blur.rect.origin) : nil;
            SLMosaicLineLayer *layer = [SLMosaicLineLayer layer];
            layer.frame = self.bounds;
            [layer.elementArray addObject:blur];
            
            [self.layer addSublayer:layer];
            [self.layerArray addObject:layer];
        }
    }
    
    [super touchesBegan:touches withEvent:event];
}

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event {
    if (_isBegan || _isWork) {
        //1、触摸坐标
        UITouch *touch = [touches anyObject];
        CGPoint point = [touch locationInView:self];
        
        /** 获取上一个对象坐标判断是否重叠 */
        SLMosaicLineLayer *layer = self.layerArray.lastObject;
        SLMosaicPointElement *prevBlur = layer.elementArray.lastObject;
        
        if (self.mosaicType == SLMosaicTypeSquare) {
            CGPoint mosaicPoint = [self divideMosaicPoint:point];
            NSValue *value = [NSValue valueWithCGPoint:mosaicPoint];
            if (![self.frameArray containsObject:value]) {
                if (_isBegan && self.brushBegan) self.brushBegan();
                _isWork = YES;
                _isBegan = NO;
                [self.frameArray addObject:value];
                //2、创建LFSplashBlur
                SLMosaicPointElement *blur = [SLMosaicPointElement new];
                blur.rect = CGRectMake(mosaicPoint.x, mosaicPoint.y, self.squareWidth, self.squareWidth);
                blur.color = self.brushColor ? self.brushColor(blur.rect.origin) : nil;
                
                [layer.elementArray addObject:blur];
                [layer setNeedsDisplay];
            }
        } else if (self.mosaicType == SLMosaicTypePaintbrush) {
            /** 限制绘画的间隙 */
            if (CGRectContainsPoint(prevBlur.rect, point) == NO) {
                
                if (_isBegan && self.brushBegan) self.brushBegan();
                _isWork = YES;
                _isBegan = NO;
                
                //2、创建LFSplashBlur
                SLMosaicPointElement *blur = [SLMosaicPointElement new];
                blur.imageName = @"EditMosaicBrush.png";
                blur.color = self.brushColor ? self.brushColor(point) : nil;
                /** 新增随机位置 */
                int x = self.paintSize.width + MIN(1, (int)(self.paintSize.width*0.4));
                float randomX = floorf(arc4random()%x) - x/2;
                blur.rect = CGRectMake(point.x-self.paintSize.width/2 + randomX, point.y-self.paintSize.height/2, self.paintSize.width, self.paintSize.height);
                
                [layer.elementArray addObject:blur];
                
                /** 新增额外对象 密集图片 */
                [layer setNeedsDisplay];
                
                /** 扩大范围 */
                CGRect paintRect = CGRectInset(blur.rect, -self.squareWidth, -self.squareWidth);
                [self.frameArray removeObjectsInArray:[self divideMosaicRect:paintRect]];
            }
        }
        
    }
    [super touchesMoved:touches withEvent:event];
}

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event {
    if (_isWork) {
        SLMosaicLineLayer *layer = self.layerArray.lastObject;
        if (layer.elementArray.count < 2) {
            [self goBack];
        } else {
            if (self.brushEnded) self.brushEnded();
        }
    } else {
        if ((_isBegan)) {
            [self goBack];
        }
    }
    _isBegan = NO;
    _isWork = NO;
    [super touchesEnded:touches withEvent:event];
}

- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    if (_isWork) {
        SLMosaicLineLayer *layer = self.layerArray.lastObject;
        if (layer.elementArray.count < 2) {
            [self goBack];
        } else {
            if (self.brushEnded) self.brushEnded();
        }
    } else {
        if ((_isBegan)) {
            [self goBack];
        }
    }
    _isBegan = NO;
    _isWork = NO;
    [super touchesCancelled:touches withEvent:event];
}

- (BOOL)isDrawing {
    return _isWork;
}

/// 是否可撤销
- (BOOL)canBack {
    return self.layerArray.count;
}
//撤销
- (void)goBack {
    if (!self.canBack) {
        return;
    }
    SLMosaicLineLayer *layer = self.layerArray.lastObject;
    if ([layer.elementArray.firstObject isMemberOfClass:[SLMosaicPointElement class]]) {
        for (SLMosaicPointElement *blur in layer.elementArray) {
            [self.frameArray removeObject:[NSValue valueWithCGPoint:blur.rect.origin]];
        }
    }
    [layer removeFromSuperlayer];
    [self.layerArray removeLastObject];
}
- (void)clear {
    [self.layerArray removeAllObjects];
    [self.frameArray removeAllObjects];
    [self.layer.sublayers makeObjectsPerformSelector:@selector(removeFromSuperlayer)];
}

#pragma mark  - 数据
- (NSDictionary *)data {
    if (self.layerArray.count) {
        NSMutableArray *lineArray = [@[] mutableCopy];
        for (SLMosaicLineLayer *layer in self.layerArray) {
            [lineArray addObject:layer.elementArray];
        }
        
        return @{kLFSplashViewData:@{
                         kLFSplashViewData_layerArray:[lineArray copy],
                         kLFSplashViewData_frameArray:[self.frameArray copy]
        }};
    }
    return nil;
}
- (void)setData:(NSDictionary *)data {
    NSDictionary *dataDict = data[kLFSplashViewData];
    NSArray *lineArray = dataDict[kLFSplashViewData_layerArray];
    for (NSArray *subLineArray in lineArray) {
        SLMosaicLineLayer *layer = [SLMosaicLineLayer layer];
        layer.frame = self.bounds;
        [layer.elementArray addObjectsFromArray:subLineArray];
        
        [self.layer addSublayer:layer];
        [self.layerArray addObject:layer];
        [layer setNeedsDisplay];
    }
    NSArray *frameArray = dataDict[kLFSplashViewData_frameArray];
    [self.frameArray addObjectsFromArray:frameArray];
}

@end

```

#### 3、裁剪

> 这个功能的实现主要是网格裁剪框的实现，代码中主要是SLGridView这个类，代码就不在此粘贴，详情看代码。

### 六、项目结构

![](/contentImages/image/20191104/kbkqCDqmpIMDqqCEnjS.png)

> 注意：需真机调试查看，有何问题可加Q：1685527540 咨询

iOS 高仿微信相机拍摄和编辑

概述

详细

相似例子推荐

评论

作者

评分详细

作者例子