module ImgTools

open System
open System.Drawing
open System.Collections.Generic

open Emgu.CV
open Emgu.CV.Structure

open Utils

// Normalize image values between 0uy and 255uy.
let normalizeAndConvert (img: Image<Gray, float32>) : Image<Gray, byte> =
    let min = ref [| 0.0 |]
    let minLocation = ref <| [| Point() |]
    let max = ref [| 0.0 |]
    let maxLocation = ref <| [| Point() |]
    img.MinMax(min, max, minLocation, maxLocation)
    ((img - (!min).[0]) / ((!max).[0] - (!min).[0]) * 255.0).Convert<Gray, byte>()

let gaussianFilter (img : Image<'TColor, 'TDepth>) (standardDeviation : float) : Image<'TColor, 'TDepth> =
    let size = 2 * int (ceil (4.0 * standardDeviation)) + 1
    img.SmoothGaussian(size, size, standardDeviation, standardDeviation)

// Zhang and Suen algorithm.
// Modify 'mat' in place.
let thin (mat: Matrix<byte>) =
    let w = mat.Width
    let h = mat.Height
    let mutable data1 = mat.Data
    let mutable data2 = Array2D.copy data1

    let mutable pixelChanged = true
    let mutable oddIteration = true

    while pixelChanged do
        pixelChanged <- false
        for i in 0..h-1 do
            for j in 0..w-1 do
                if data1.[i, j] = 1uy
                then
                    let p2 = if i = 0 then 0uy else data1.[i-1, j]
                    let p3 = if i = 0 || j = w-1 then 0uy else data1.[i-1, j+1]
                    let p4 = if j = w-1 then 0uy else data1.[i, j+1]
                    let p5 = if i = h-1 || j = w-1 then 0uy else data1.[i+1, j+1]
                    let p6 = if i = h-1 then 0uy else data1.[i+1, j]
                    let p7 = if i = h-1 || j = 0 then 0uy else data1.[i+1, j-1]
                    let p8 = if j = 0 then 0uy else data1.[i, j-1]
                    let p9 = if i = 0 || j = 0 then 0uy else data1.[i-1, j-1]

                    let sumNeighbors = p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9
                    if sumNeighbors >= 2uy && sumNeighbors <= 6uy &&
                        (if p2 = 0uy && p3 = 1uy then 1 else 0) +
                        (if p3 = 0uy && p4 = 1uy then 1 else 0) +
                        (if p4 = 0uy && p5 = 1uy then 1 else 0) +
                        (if p5 = 0uy && p6 = 1uy then 1 else 0) +
                        (if p6 = 0uy && p7 = 1uy then 1 else 0) +
                        (if p7 = 0uy && p8 = 1uy then 1 else 0) +
                        (if p8 = 0uy && p9 = 1uy then 1 else 0) +
                        (if p9 = 0uy && p2 = 1uy then 1 else 0) = 1 &&
                        if oddIteration
                        then p2 * p4 * p6 = 0uy && p4 * p6 * p8 = 0uy
                        else p2 * p4 * p8 = 0uy && p2 * p6 * p8 = 0uy
                    then
                        data2.[i, j] <- 0uy
                        pixelChanged <- true
                else
                    data2.[i, j] <- 0uy

        oddIteration <- not oddIteration
        let tmp = data1
        data1 <- data2
        data2 <- tmp


let pop (l: List<'a>) : 'a =
    let n = l.[l.Count - 1]
    l.RemoveAt(l.Count - 1)
    n

// Remove all 8-connected pixels with an area equal or greater than 'areaSize'.
// Modify 'mat' in place.
let removeArea (mat: Matrix<byte>) (areaSize: int) =
    let neighbors = [|
        (-1,  0) // p2
        (-1,  1) // p3
        ( 0,  1) // p4
        ( 1,  1) // p5
        ( 1,  0) // p6
        ( 1, -1) // p7
        ( 0, -1) // p8
        (-1, -1) |] // p9

    let mat' = new Matrix<byte>(mat.Size)
    let w = mat'.Width
    let h = mat'.Height
    mat.CopyTo(mat')

    let data = mat.Data
    let data' = mat'.Data

    for i in 0..h-1 do
        for j in 0..w-1 do
            if data'.[i, j] = 1uy
            then
                let neighborhood = List<(int*int)>()
                let neighborsToCheck = List<(int*int)>()
                neighborsToCheck.Add((i, j))
                data'.[i, j] <- 0uy

                while neighborsToCheck.Count > 0 do
                    let (ci, cj) = pop neighborsToCheck
                    neighborhood.Add((ci, cj))
                    for (ni, nj) in neighbors do
                        let pi = ci + ni
                        let pj = cj + nj
                        if pi >= 0 && pi < h && pj >= 0 && pj < w && data'.[pi, pj] = 1uy
                        then
                            neighborsToCheck.Add((pi, pj))
                            data'.[pi, pj] <- 0uy
                if neighborhood.Count <= areaSize
                then
                    for (ni, nj) in neighborhood do
                        data.[ni, nj] <- 0uy

let connectedComponents (img: Image<Gray, byte>) (startPoints: List<Point>) : List<Point> =
    let w = img.Width
    let h = img.Height

    let pointChecked = HashSet<Point>()
    let pointToCheck = List<Point>(startPoints);

    let data = img.Data

    while pointToCheck.Count > 0 do
        let next = pop pointToCheck
        pointChecked.Add(next) |> ignore
        for ny in -1 .. 1 do
            for nx in -1 .. 1 do
                if ny <> 0 && nx <> 0
                then
                    let p = Point(next.X + nx, next.Y + ny)
                    if p.X >= 0 && p.X < w && p.Y >= 0 && p.Y < h && data.[p.Y, p.X, 0] > 0uy && not (pointChecked.Contains p)
                    then
                        pointToCheck.Add(p)

    List<Point>(pointChecked)


let saveImg (img: Image<'TColor, 'TDepth>) (filepath: string) =
    img.Save(filepath)


let saveMat (mat: Matrix<'TDepth>) (filepath: string) =
    use img = new Image<Gray, 'TDeph>(mat.Size)
    mat.CopyTo(img)
    saveImg img filepath

let drawLine (img: Image<'TColor, 'TDepth>) (color: 'TColor) (x0: int) (y0: int) (x1: int) (y1: int) =
    img.Draw(LineSegment2D(Point(x0, y0), Point(x1, y1)), color, 1);

let drawLineF (img: Image<'TColor, 'TDepth>) (color: 'TColor) (x0: float) (y0: float) (x1: float) (y1: float) =
    let x0, y0, x1, y1 = roundInt(x0), roundInt(y0), roundInt(x1), roundInt(y1)
    drawLine img color x0 y0 x1 y1

let drawEllipse (img: Image<'TColor, 'TDepth>) (e: Types.Ellipse) (color: 'TColor) =
    let cosAlpha = cos e.Alpha
    let sinAlpha = sin e.Alpha

    let mutable x0 = 0.0
    let mutable y0 = 0.0
    let mutable first_iteration = true

    let n = 40
    let thetaIncrement = 2.0 * Math.PI / (float n)

    for theta in 0.0 .. thetaIncrement .. 2.0 * Math.PI do
        let cosTheta = cos theta
        let sinTheta = sin theta
        let x = e.Cx + cosAlpha * e.A * cosTheta - sinAlpha * e.B * sinTheta
        let y = e.Cy + sinAlpha * e.A * cosTheta + cosAlpha * e.B * sinTheta

        if not first_iteration
        then
            drawLineF img color x0 y0 x y
        else
            first_iteration <- false

        x0 <- x
        y0 <- y

let drawEllipses (img: Image<'TColor, 'TDepth>) (ellipses: Types.Ellipse list) (color: 'TColor) =
    List.iter (fun e -> drawEllipse img e color) ellipses


let rngCell =  System.Random()
let drawCell (img: Image<Bgr, byte>) (drawCellContent: bool) (c: Types.Cell) =
    if drawCellContent
    then
        let colorB = rngCell.Next(20, 70)
        let colorG = rngCell.Next(20, 70)
        let colorR = rngCell.Next(20, 70)

        for y in 0 .. c.elements.Height - 1 do
            for x in 0 .. c.elements.Width - 1 do
                if c.elements.[y, x] > 0uy
                then
                    let dx, dy = c.center.X - c.elements.Width / 2, c.center.Y - c.elements.Height / 2
                    let b = img.Data.[y + dy, x + dx, 0] |> int
                    let g = img.Data.[y + dy, x + dx, 1] |> int
                    let r = img.Data.[y + dy, x + dx, 2] |> int
                    img.Data.[y + dy, x + dx, 0] <- if b + colorB > 255 then 255uy else byte (b + colorB)
                    img.Data.[y + dy, x + dx, 1] <- if g + colorG > 255 then 255uy else byte (g + colorG)
                    img.Data.[y + dy, x + dx, 2] <- if r + colorR > 255 then 255uy else byte (r + colorR)

    let crossColor = match c.cellClass with
                     | Types.HealthyRBC -> Bgr(255.0, 0.0, 0.0)
                     | Types.InfectedRBC -> Bgr(0.0, 0.0, 255.0)
                     | Types.Peculiar -> Bgr(0.0, 0.0, 0.0)

    drawLine img crossColor (c.center.X - 3) c.center.Y (c.center.X + 3) c.center.Y
    drawLine img crossColor c.center.X (c.center.Y - 3) c.center.X (c.center.Y + 3)

let drawCells (img: Image<Bgr, byte>) (drawCellContent: bool) (cells: Types.Cell list) =
    List.iter (fun c -> drawCell img drawCellContent c) cells