3

所以我有一些代码可以对 2 个图像进行深度检测。深度检测发生在本机 C 代码中。为了调用 C 库，我有另一个函数来构建我作为参数传入的 Int16 数组。

但是，当我直接在 C 调用的参数中进行函数调用时，它会覆盖第一个函数调用并两次传入相同的参数。

这就是我的意思，这是我对 C 库的调用：

let result = ImageProcessing.depthDetection(leftPhoto.cgImage!,
                                            right: rightPhoto.cgImage!,
                                            leftFace: getFaceDetails(image: leftPhoto, face: leftFace!).mutablePointer,
                                            rightFace: getFaceDetails(image: rightPhoto, face: rightFace!).mutablePointer))

获取面部详细信息调用如下所示：

private func getFaceDetails(image: UIImage, face: VisionFace) -> [Int16] {
    var details = [Int16](repeating: 0, count: 10)
    // get image size
    details[0] = Int16(image.size.width)
    details[1] = Int16(image.size.height)

    // get face bounds
    details[2] = Int16(face.frame.origin.x)
    details[3] = Int16(face.frame.origin.y)
    details[4] = Int16(face.frame.origin.x + face.frame.width)
    details[5] = Int16(face.frame.origin.y + face.frame.height)

    // get eye locations
    details[6] = Int16(truncating: face.landmark(ofType: .leftEye)?.position.x ?? 0)
    details[7] = Int16(truncating: face.landmark(ofType: .leftEye)?.position.y ?? 0)
    details[8] = Int16(truncating: face.landmark(ofType: .rightEye)?.position.x ?? 0)
    details[9] = Int16(truncating: face.landmark(ofType: .rightEye)?.position.y ?? 0)

    print("Details: \(details)")

    return details
}

我得到了这个扩展的可变指针：

extension Array where Element == Int16 {
    var mutablePointer: UnsafeMutablePointer<Int16> {
        get {
            return UnsafeMutablePointer<Int16>(mutating: self)
        }
    }
}

所以当我运行上面的ImageProcessing.depthDetection调用时，我可以看到打印出来的我的leftFace和rightFace数组确实不同，看起来像这样：

Details: [3088, 2320, 1119, 431, 2230, 1542, 1493, 888, 1892, 882]
Details: [3088, 2320, 864, 446, 1975, 1556, 1207, 900, 1626, 890]

但是当我在 C 中将它们打印出来时，它们都是相同的rightFace数组并且看起来像这样（我正在以不同的方式格式化我的 C 日志，但你可以看出左右都有相同的数据）：

0: Left (3088, 2320), Right (3088, 2320)
1: Left (864, 446), Right (864, 446)
2: Left (1975, 1556), Right (1975, 1556)
3: Left (1207, 900), Right (1207, 900)
4: Left (1626, 890), Right (1626, 890)

那么为什么第一个getFaceDetails输出会被第二个输出覆盖呢？

最奇怪的部分是，如果我将结果分配getFaceDetails给一个变量，然后像我在这里所做的那样将该变量作为参数传递：

let lf = getFaceDetails(image: leftPhoto, face: leftFace!)
let rf = getFaceDetails(image: rightPhoto, face: rightFace!)

let result = ImageProcessing.depthDetection(leftPhoto.cgImage!,
                                            right: rightPhoto.cgImage!,
                                            leftFace: lf.mutablePointer,
                                            rightFace: rf.mutablePointer)

然后突然之间它起作用了！我在 C 中的打印语句显示左右脸的不同数据。只有当我直接在参数中传递函数调用时，它才有错误的数据。

那么这里发生了什么？为什么我这样做的第一种方法不会产生与后者相同的结果？

4

1 回答 1

2

正如一些评论指出的那样，这是未定义的行为：

extension Array where Element == Int16 {
    var mutablePointer: UnsafeMutablePointer<Int16> {
        get {
            return UnsafeMutablePointer<Int16>(mutating: self)
        }
    }
}

一旦UnsafeMutablePointer.init(mutating:)返回，它提供的指针就没有意义了。你的意思是这样的：

let result = lf.withUnsafeMutableBytes { lfBytes in
    rf.withUnsafeMutableBytes { rfBytes in
        return ImageProcessing.depthDetection(leftPhoto.cgImage!,
                                              right: rightPhoto.cgImage!,
                                              leftFace: lfBytes,
                                              rightFace: rhBytes)
    }
}

或者，您可以按照以下方式做一些事情：

let result = ImageProcessing.depthDetection(leftPhoto.cgImage!,
                                            right: rightPhoto.cgImage!,
                                            leftFace: &lf,
                                            rightFace: &rf)

但关键是返回 anUnsafeMutablePointer是没有意义的，除非您有某种方法来确保您已获取指针的特定事物的生命周期，这几乎永远不会是真的，除非在一个withUnsafe...块内。

于 2019-03-04T21:25:41.200 回答