Cfrtjryk

Recently I implemented the most basic moving window transform version of a median filter that I could (it was actually just to have a comparison for another method, so I wasn't trying to optimise it heavily at the time), simply using the Array.Parallel higher-order functions to get some parallelism. The full code for it is available at this GitHub repo, but the only parts that I think are particularly relevant for performance purposes are the following two functions:

let processWindow clampedArrayFunc windowSize x y =

    let mutable intensities = List.Empty

    let posBound = (windowSize - 1) / 2

    let negBound = -posBound

    for z in negBound..posBound do

        for w in negBound..posBound do

            intensities <- (clampedArrayFunc (x + z) (y + w)) :: intensities

    List.choose id intensities |> findMedian



let medianFilter intensities width height windowSize = 

    let ac = accessClampedArray intensities width height

    let pw = processWindow ac windowSize



    let outputPixels = Array.Parallel.map (fun i ->

                            let x = i % width

                            let y = i / width

                            pw x y |> makeRgb24

                        ) [|0..intensities.Length-1|]



    Image.LoadPixelData(outputPixels, width, height)

In this case, the 'intensities' are the pixel values of the grayscale image, stored as unsigned 8-bit integers in a 1D array. The clampedArrayFunc is a partially applied function that looks up given coordinates in an image, and if they are within an image returns the pixel value inside a Some, otherwise it returns None - I did this as the easiest way I could think of to reliably ignore any requested pixel locations that are outside the image.

findMedian simply sorts an array in place then takes the middle value. makeRgb24 recreates a full 24-bit pixel out of the selected intensity value, for further use with ImageSharp to store the image.

I have no doubts that I have made some sub-optimal choices here. In the interests of learning to be a better programmer, I would like to learn anything and everything I can about how to improve the runtime performance of it. Any and all constructive feedback is, of course, welcome though!

For reference, I did a very quick benchmark of it the other day, and running on a Core i7 7700 in release mode, it was managing about 0.88s on a 1.09 megapixel image, excluding IO.