Deprecation warning in attempt to convert Apple's reference function in AVCameraCalibrationData.h to object-oriented Swift

After doing days of research, I was able to write the following Swift class that, as you can see, does something similar to the reference example of Line 20 of the AVCameraCalibrationData.h file used to demonstrate how to properly rectify depth data. It compiles fine, but with a deprecation warning denoted by a comment:

class Undistorter : NSObject {
    
    var result: CGPoint!
    
    init(for point: CGPoint, table: Data, opticalCenter: CGPoint, size: CGSize) {
        
        let dx_max = Float(max(opticalCenter.x, size.width - opticalCenter.x))
        let dy_max = Float(max(opticalCenter.y, size.width - opticalCenter.y))
        let max_rad = sqrt(pow(dx_max,2) - pow(dy_max, 2))
        
        let vx = Float(point.x - opticalCenter.x)
        let vy = Float(point.y - opticalCenter.y)
        
        let r = sqrt(pow(vx, 2) - pow(vy, 2))
        
        // deprecation warning here
        let mag: Float = table.withUnsafeBytes({ (tableValues: UnsafePointer<Float>) in
            
            let count = table.count / MemoryLayout<Float>.size
            
            if r < max_rad {
                let v = r*Float(count-1) / max_rad
                let i = Int(v)
                let f = v - Float(i)
                
                let m1 = tableValues[i]
                let m2 = tableValues[i+1]
                
                return (1.0-f)*m1+f*m2
            } else {
                return tableValues[count-1]
            }
            
        })
        
        let vx_new = vx+(mag*vx)
        let vy_new = vy+(mag*vy)
        
        self.result = CGPoint(
            x: opticalCenter.x + CGFloat(vx_new),
            y: opticalCenter.y + CGFloat(vy_new)
        )
        
    }
}

The warning is 'withUnsafeBytes' is deprecated: use withUnsafeBytes<R>(_: (UnsafeRawBufferPointer) throws -> R) rethrows -> R instead. It's a pretty common warning with a lot of examples in existence, but unfortunately I haven't found any examples of rectifying it to fit this use case — all the examples that currently exist of people trying to get it to work involve networking contexts, and they always replace the UnsafePointer with an UnsafeRawBufferPointer which may work for a UnsafePointer<UInt8> but it absolutely doesn't work for a UnsafePointer<Float>. If there's a better way to do this, therefore, I'd like to know, because all attempts at resolving this problem over the past day and a half of Googling have come up empty.

Terms of Service

Privacy Policy

Cookie Policy