修改证件照背景颜色

private func compareColor(
    firstColor: UIColor,
    secondColor: UIColor,
    tolerance: CGFloat
) -> Bool {
    var r1: CGFloat = 0.0, g1: CGFloat = 0.0, b1: CGFloat = 0.0, a1: CGFloat = 0.0;
    var r2: CGFloat = 0.0, g2: CGFloat = 0.0, b2: CGFloat = 0.0, a2: CGFloat = 0.0;

    firstColor.getRed(&r1, green: &g1, blue: &b1, alpha: &a1)
    secondColor.getRed(&r2, green: &g2, blue: &b2, alpha: &a2)
    
    return abs(r1 - r2) <= tolerance
        && abs(g1 - g2) <= tolerance
        && abs(b1 - b2) <= tolerance
        && abs(a1 - a2) <= tolerance
}

extension UIImage {
 func getPointColor(at point: CGPoint) -> UIColor? {

        guard CGRect(origin: CGPoint(x: 0, y: 0), size: size).contains(point) else {
            return nil
        }

        let pointX = trunc(point.x);
        let pointY = trunc(point.y);

        let width = size.width;
        let height = size.height;
        let colorSpace = CGColorSpaceCreateDeviceRGB();
        var pixelData: [UInt8] = [0, 0, 0, 0]

        pixelData.withUnsafeMutableBytes { pointer in
            if let context = CGContext(data: pointer.baseAddress, width: 1, height: 1, bitsPerComponent: 8, bytesPerRow: 4, space: colorSpace, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue), let cgImage = cgImage {
                context.setBlendMode(.copy)
                context.translateBy(x: -pointX, y: pointY - height)
                context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
            }
        }

        let red = CGFloat(pixelData[0]) / CGFloat(255.0)
        let green = CGFloat(pixelData[1]) / CGFloat(255.0)
        let blue = CGFloat(pixelData[2]) / CGFloat(255.0)
        let alpha = CGFloat(pixelData[3]) / CGFloat(255.0)

        if #available(iOS 10.0, *) {
            return UIColor(displayP3Red: red, green: green, blue: blue, alpha: alpha)
        } else {
            return UIColor(red: red, green: green, blue: blue, alpha: alpha)
        }
    }
}

var hsba: (hue: CGFloat, saturation: CGFloat, brightness: CGFloat, alpha: CGFloat) {
    /**
     hue：色相
     saturation：饱和度
     brightness：亮度
     alpha：透明度
     */
    var h: CGFloat = 0
    var s: CGFloat = 0
    var b: CGFloat = 0
    var a: CGFloat = 0
    self.getHue(&h, saturation: &s, brightness: &b, alpha: &a)
    return (h * 360, s, b, a)
}

struct CubeMap createCubeMap(float h, float s, float v) {
    const unsigned int size = 64;
    struct CubeMap map;
    map.length = size * size * size * sizeof (float) * 4;
    map.dimension = size;
    float *cubeData = (float *)malloc (map.length);
    float rgb[3], hsv[3], *c = cubeData;
    
    for (int z = 0; z < size; z++){
        rgb[2] = ((double)z)/(size-1); // Blue value
        for (int y = 0; y < size; y++){
            rgb[1] = ((double)y)/(size-1); // Green value
            for (int x = 0; x < size; x ++){
                rgb[0] = ((double)x)/(size-1); // Red value
                rgbToHSV(rgb,hsv);
                // Use the hue value to determine which to make transparent
                // The minimum and maximum hue angle depends on
                // the color you want to remove
                float alpha = (hsv[2] == 1 && hsv[1] == 0) ? 0.0f: 1.0f;

                // Calculate premultiplied alpha values for the cube
                c[0] = rgb[0] * alpha;
                c[1] = rgb[1] * alpha;
                c[2] = rgb[2] * alpha;
                c[3] = alpha;
                c += 4; // advance our pointer into memory for the next color value
            }
        }
    }
    map.data = cubeData;
    return map;
}

func detectPhoto(photo: UIImage) -> UIImage {
        
        let ciOriginImage = CIImage(cgImage: photo.cgImage!)
        
        let imageHandler = VNImageRequestHandler(ciImage: ciOriginImage, options: [:])
        let attensionRequest = VNGenerateObjectnessBasedSaliencyImageRequest { [weak self] request, error in
            if let err = error {
                print("发生了错误 \(err.localizedDescription)")
                return
            }
            if let result = request.results, result.count > 0,
               let observation = result.first as? VNSaliencyImageObservation {
                // 获取显著区域热力图 接下里对对该图进行边缘检测
                self?.heatMapProcess(pixelBuffer: observation.pixelBuffer, ciImage: ciOriginImage)
            }
        }
        
        do {
            try imageHandler.perform([attensionRequest])
        } catch {
            print(error.localizedDescription)
        }
        
        return photo
        
    }
    
    private func heatMapProcess(pixelBuffer: CVPixelBuffer, ciImage: CIImage) {
        let heatImge = CIImage(cvPixelBuffer: pixelBuffer)
        let contourRequest = VNDetectContoursRequest { [weak self] request, error in
            if let err = error {
                print("发生了错误 \(err.localizedDescription)")
                return
            }
            if let result = request.results, result.count > 0,
               let observation = result.first as? VNContoursObservation {
                let cxt = CIContext()
                let origin = cxt.createCGImage(ciImage, from: ciImage.extent)
                let _ = self?.drawContour(contourObv: observation, cgImage: nil, originImg: origin)
            }
            
        }
        contourRequest.revision = VNDetectContourRequestRevision1
        contourRequest.contrastAdjustment = 1.0
        contourRequest.detectsDarkOnLight = false
        contourRequest.maximumImageDimension = 512
        
        let handler = VNImageRequestHandler(ciImage: heatImge, options: [:])
        
        do {
            try handler.perform([contourRequest])
        } catch {
            print("\(error.localizedDescription)")
        }
    }