Applies a set of symmetric piecewise polynomials to an image in PlanarF format.


func vImageSymmetricPiecewisePolynomial_PlanarF(_ src: UnsafePointer<vImage_Buffer>, _ dest: UnsafePointer<vImage_Buffer>, _ coefficients: UnsafeMutablePointer<UnsafePointer<Float>?>, _ boundaries: UnsafePointer<Float>, _ order: UInt32, _ log2segments: UInt32, _ flags: vImage_Flags) -> vImage_Error



A pointer to a vImage buffer structure that contains the source image.


A pointer to a vImage buffer data structure. You're responsible for filling out the height, width, and rowBytes fields of this structure, and for allocating a data buffer of the appropriate size. On return, the data buffer this structure points to contains the destination image data. When you no longer need the data buffer, you must deallocate the memory


A pointer to an array of polynomial coefficient arrays. Each polynomial coefficient array contains the coefficients for one polynomial. Note that a polynomial of order R has R+1 coefficients. All of the polynomial coefficient arrays must be the same size, R+1, and in each array, the coefficients must be ordered from the 0th-order term to the highest-order term.


A pointer to an array of boundary values, in increasing order, for separating adjacent ranges of pixel values. The first boundary value is the lowest in the range; lower input values are clipped to this value. The last boundary value is the highest in the range; higher input values are clipped to this value. The boundary values between the first and last values separate the subranges from each other.


The number of polynomials represented as a base-2 logarithm. If you pass a noninteger power-of-two number of polynomials (for example, 5), you must round up to the next integer power of 2 (which, for 5, would be 8), and simply repeat the last polynomial the appropriate number of times.


Reserved for future use; pass 0.

Return Value

kvImageNoError; otherwise, one of the error codes described in Data Types and Constants.


You can approximate many different correction functions by carefully choosing the polynomials and the ranges of input values they operate on. The number of polynomials must be a nonnegative integer power of 2.

Suppose that you want to use N polynomials of order R to process N contiguous ranges of pixel values. For each pixel in the image, the range of usable values is divided into segments by the values passed in the boundaries array. Each segment is processed by the corresponding polynomial. Because there are N polynomials, there must be N segments, so you must supply N+1 boundaries.

You must order the boundaries by increasing value. The i-th segment is the set of pixel values that fall in the range:

    boundary[i] <= value < boundary[i+1]

where i ranges from 0 to N. Values in this segment are processed by the i-th polynomial.

From a performance standpoint, it costs much more to resolve additional polynomials than to work with higher-order polynomials. You typically achieve better performance with one 9th-order polynomial that covers the whole range of values you are interested in than with many lower-order polynomials covering the range piecewise.

This function uses single-precision floating-point arithmetic. As a result, polynomials with large high-order coefficients may cause a significant rounding error.