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 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 w = mat.Width
    let h = mat.Height
    let mutable data1 = mat.Data
    let mutable data2 = Array2D.zeroCreate<byte> h w

    // Return the list of neighbor values.
    let neighborsValues (p1i, p1j) = 
        Array.map (fun (ni, nj) -> 
            let pi = p1i + ni
            let pj = p1j + nj
            if pi < 0 || pi >= h || pj < 0 || pj >= w then 0uy else data1.[pi, pj]
            ) neighbors

    // Return the number of 01 pattern in 'values' in a circular way.
    let pattern01 (values: byte[]) = 
        let mutable nb = 0
        let mutable lastValue = 255uy
        for v in values do
            if lastValue = 0uy && v = 1uy
            then
                nb <- nb + 1
            lastValue <- v
        if lastValue = 0uy && values.[0] = 1uy
        then
            nb <- nb + 1
        nb
         
    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 values = neighborsValues (i, j)
                    let s = Array.reduce (+) values
                    if s >= 2uy && s <= 6uy &&
                        pattern01 values = 1 &&
                        (not oddIteration || (values.[0] * values.[2] * values.[4] = 0uy && values.[2] * values.[4] * values.[6] = 0uy)) && // Odd iteration.
                        (oddIteration || (values.[0] * values.[2] * values.[6] = 0uy && values.[0] * values.[4] * values.[6] = 0uy)) // Even iterations.
                    then
                        data2.[i, j] <- 0uy
                        pixelChanged <- true
                    else
                        data2.[i, j] <- 1uy
                else
                    data2.[i, j] <- 0uy

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

// 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

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

                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 saveImg (img: Image<'TColor, 'TDepth>) (name: string) = 
    img.Save("output/" + name)
    

let saveMat (mat: Matrix<'TDepth>) (name: string) = 
    use img = new Image<Gray, 'TDeph>(mat.Size)
    mat.CopyTo(img)
    saveImg img name
    
(*let drawEllipse (img: Image<'TColor, 'TDepth>) (e: Types.Ellipse) (color: 'TColor) =
    let e' = Ellipse(PointF(float32 e.cx, float32 e.cy), SizeF(2.0f * float32 e.a, 2.0f * float32 e.b), float32 e.alpha)
    img.Draw(e', color)*)

let drawLine (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)

    img.Draw(LineSegment2D(Point(x0, y0), Point(x1, y1)), color, 1);

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
            drawLine 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