F4

open System
open System.IO

open System.Drawing
open System.Drawing.Imaging



// Pixel properties
let CalcBrightness (color : Color) =  sqrt ((float color.R ** 2. * 0.241) +
                                            (float color.G ** 2. * 0.691) +
                                            (float color.B ** 2. * 0.068))

let CalcGrayscale (color : Color) = ((float color.R * 0.3)  +
                                     (float color.G * 0.59) +
                                     (float color.B * 0.11))



// Pixel converters
let PixelToGrayscale (imgOut : Bitmap) i j curPixel =
    let gscale = int <| CalcGrayscale curPixel
    let gPixel = Color.FromArgb(int curPixel.A, gscale, gscale, gscale)
    imgOut.SetPixel(i, j, gPixel)

let PixelToBlackAndWhite (imgOut : Bitmap) i j curPixel =
    let gscale = int <| CalcGrayscale curPixel
    let bw = if gscale > 127 then 255 else 0
    let bwPixel = Color.FromArgb(int curPixel.A, bw, bw, bw)
    imgOut.SetPixel(i, j, bwPixel)

let symbols = "@#MGH\/!?+-*. "
let PixelToASCII (writer : StreamWriter) (rowLen : int)  i j curPixel =
    let brightness = CalcBrightness curPixel
    let index = int <| (brightness/255.0 * (float (symbols.Length - 1)))
    // print few times because spacers between rows much bigger then between symbols
    for x in 0..2 do
        writer.Write symbols.[index]
    if i = rowLen then
        writer.WriteLine()


// Basic and Async transforms
let TransformIMG (imgIn : Bitmap) convertPixel =
    for j in 0..(imgIn.Height-1) do
        for i in 0..(imgIn.Width-1) do
            let curPixel = imgIn.GetPixel(i,j)
            convertPixel i j curPixel

let AsyncTransformIMG (imgIn : Bitmap) convertPixel =
    seq {
        for j in 0..(imgIn.Height-1) do
            for i in 0..(imgIn.Width-1) do
                let curPixel = imgIn.GetPixel(i,j)
                let asyncConvert = async {
                    convertPixel i j curPixel
                }
                yield asyncConvert
    }
    |> Async.Parallel


// Image convertors
let ConvertIMGtoJPG (pathIn : string) converter suff =
    let imgIn = new Bitmap(pathIn)
    let pathOut = pathIn.Insert(pathIn.Length - 4, suff)
    let imgOut = new Bitmap(imgIn.Width, imgIn.Height)
    TransformIMG imgIn (converter imgOut)
//    AsyncTransformIMG imgIn (converter imgOut) |> Async.RunSynchronously |> ignore
    imgOut.Save(pathOut, ImageFormat.Jpeg)

let ConvertIMGtoGrayscale (pathIn : string) =
    ConvertIMGtoJPG pathIn PixelToGrayscale "_gscale"

let ConvertIMGtoBlackAndWhite (pathIn : string) =
    ConvertIMGtoJPG pathIn PixelToBlackAndWhite "_bw"


let ConvertIMGtoTXT (pathIn : string) converter suff =
    let imgIn = new Bitmap(pathIn)
    let pathOut = pathIn.Replace(".jpg", suff)
    let writer = new StreamWriter(pathOut)
    TransformIMG imgIn (converter writer (imgIn.Width-1))
//    AsyncTransformIMG imgIn (converter writer imgIn.Width)|> Async.RunSynchronously |> ignore
    writer.Dispose()

let ConvertIMGtoASCII (pathIn : string) =
    ConvertIMGtoTXT pathIn PixelToASCII "_ASCII.txt"





// Read images from directory
let ConvertDirImages dirPath convertIMG =
    let filenames = System.IO.Directory.GetFiles(dirPath, "*.jpg") |> Seq.map (System.IO.Path.GetFileName)
    let Transform filename =
            let pathIn = Path.Combine(dirPath, filename)
            convertIMG pathIn
    Seq.map Transform filenames

let ConvertDirImagesToGrayscale dirPath =
    ConvertDirImages dirPath ConvertIMGtoGrayscale

let ConvertDirImagesToBlackAndWhite dirPath =
    ConvertDirImages dirPath ConvertIMGtoBlackAndWhite

let ConvertDirImagesToASCII dirPath =
    ConvertDirImages dirPath ConvertIMGtoASCII


// Read images from directory asynchronously
let AsyncConvertDirImages dirPath convertIMG =
    let filenames = System.IO.Directory.GetFiles(dirPath, "*.jpg") |> Seq.map (System.IO.Path.GetFileName)
    let asyncTransform filename =
        async {
            let pathIn = Path.Combine(dirPath, filename)
            convertIMG pathIn
        }
    Seq.map asyncTransform filenames
    |> Async.Parallel |> Async.RunSynchronously


let AsyncConvertDirImagesToGrayscale dirPath =
    AsyncConvertDirImages dirPath ConvertIMGtoGrayscale

let AsyncConvertDirImagesToBlackAndWhite dirPath =
    AsyncConvertDirImages dirPath ConvertIMGtoBlackAndWhite

let AsyncConvertDirImagesToASCII dirPath =
    AsyncConvertDirImages dirPath ConvertIMGtoASCII




let testDir = "C:\\Users\\kup4e\\Desktop\\Temp\\Images"






let asyncStarttime =  System.DateTime.Now
AsyncConvertDirImagesToGrayscale testDir |> ignore
let asyncEndtime = System.DateTime.Now - asyncStarttime


let starttime = System.DateTime.Now
ConvertDirImagesToGrayscale testDir
let endtime = System.DateTime.Now - starttime

printf "AsyncTime = %A; NonAsync = %A; Difference = %A \n" asyncEndtime endtime (endtime - asyncEndtime)