Parasitemia/ParasitemiaCore/ImgTools.fs

   1 module ParasitemiaCore.ImgTools
   2
   3 open System
   4 open System.Drawing
   5 open System.Collections.Generic
   6 open System.Linq
   7
   8 open Emgu.CV
   9 open Emgu.CV.Structure
  10
  11 open Heap
  12 open Const
  13 open Types
  14 open Utils
  15
  16 let normalize (img: Image<Gray, float32>) (upperLimit: float) : Image<Gray, float32> =
  17     let min = ref [| 0.0 |]
  18     let minLocation = ref <| [| Point() |]
  19     let max = ref [| 0.0 |]
  20     let maxLocation = ref <| [| Point() |]
  21     img.MinMax(min, max, minLocation, maxLocation)
  22     let normalized = (img - (!min).[0]) / ((!max).[0] - (!min).[0])
  23     if upperLimit = 1.0
  24     then normalized
  25     else upperLimit * normalized
  26
  27 let mergeChannels (img: Image<Bgr, float32>) (rgbWeights: float * float * float) : Image<Gray, float32> =
  28     match rgbWeights with
  29     | 1., 0., 0. -> img.[2]
  30     | 0., 1., 0. -> img.[1]
  31     | 0., 0., 1. -> img.[0]
  32     | redFactor, greenFactor, blueFactor ->
  33         let result = new Image<Gray, float32>(img.Size)
  34         CvInvoke.AddWeighted(result, 1., img.[2], redFactor, 0., result)
  35         CvInvoke.AddWeighted(result, 1., img.[1], greenFactor, 0., result)
  36         CvInvoke.AddWeighted(result, 1., img.[0], blueFactor, 0., result)
  37         result
  38
  39 let mergeChannelsWithProjection (img: Image<Bgr, float32>) (v1r: float32, v1g: float32, v1b: float32) (v2r: float32, v2g: float32, v2b: float32) (upperLimit: float)  : Image<Gray, float32> =
  40     let vr, vg, vb = v2r - v1r, v2g - v1g, v2b - v1b
  41     let vMagnitude = sqrt (vr ** 2.f + vg ** 2.f + vb ** 2.f)
  42     let project (r: float32) (g: float32) (b: float32) = ((r - v1r) * vr + (g - v1g) * vg + (b - v1b) * vb) / vMagnitude
  43     let result = new Image<Gray, float32>(img.Size)
  44     // TODO: Essayer en bindant Data pour gagner du temps
  45     for i in 0 .. img.Height - 1 do
  46         for j in 0 .. img.Width - 1 do
  47             result.Data.[i, j, 0] <- project img.Data.[i, j, 2] img.Data.[i, j, 1] img.Data.[i, j, 0]
  48     normalize result upperLimit
  49
  50 // Normalize image values between 0uy and 255uy.
  51 let normalizeAndConvert (img: Image<Gray, 'TDepth>) : Image<Gray, byte> =
  52     let min = ref [| 0.0 |]
  53     let minLocation = ref <| [| Point() |]
  54     let max = ref [| 0.0 |]
  55     let maxLocation = ref <| [| Point() |]
  56     img.MinMax(min, max, minLocation, maxLocation)
  57     ((img.Convert<Gray, float32>() - (!min).[0]) / ((!max).[0] - (!min).[0]) * 255.0).Convert<Gray, byte>()
  58
  59 let saveImg (img: Image<'TColor, 'TDepth>) (filepath: string) =
  60     img.Save(filepath)
  61
  62 let saveMat (mat: Matrix<'TDepth>) (filepath: string) =
  63     use img = new Image<Gray, 'TDeph>(mat.Size)
  64     mat.CopyTo(img)
  65     saveImg img filepath
  66
  67 type Histogram = { data: int[]; total: int; sum: int; min: float32; max: float32 }
  68
  69 let histogramImg (img: Image<Gray, float32>) (nbSamples: int) : Histogram =
  70     let imgData = img.Data
  71
  72     let min, max =
  73         let min = ref [| 0.0 |]
  74         let minLocation = ref <| [| Point() |]
  75         let max = ref [| 0.0 |]
  76         let maxLocation = ref <| [| Point() |]
  77         img.MinMax(min, max, minLocation, maxLocation)
  78         float32 (!min).[0], float32 (!max).[0]
  79
  80     let inline bin (x: float32) : int =
  81         let p = int ((x - min) / (max - min) * float32 nbSamples)
  82         if p >= nbSamples then nbSamples - 1 else p
  83
  84     let data = Array.zeroCreate nbSamples
  85
  86     for i in 0 .. img.Height - 1 do
  87         for j in 0 .. img.Width - 1 do
  88             let p = bin imgData.[i, j, 0]
  89             data.[p] <- data.[p] + 1
  90
  91     { data = data; total = img.Height * img.Width; sum = Array.sum data; min = min; max = max }
  92
  93 let histogramMat (mat: Matrix<float32>) (nbSamples: int) : Histogram =
  94     let matData = mat.Data
  95
  96     let min, max =
  97         let min = ref 0.0
  98         let minLocation = ref <| Point()
  99         let max = ref 0.0
 100         let maxLocation = ref <| Point()
 101         mat.MinMax(min, max, minLocation, maxLocation)
 102         float32 !min, float32 !max
 103
 104     let inline bin (x: float32) : int =
 105         let p = int ((x - min) / (max - min) * float32 nbSamples)
 106         if p >= nbSamples then nbSamples - 1 else p
 107
 108     let data = Array.zeroCreate nbSamples
 109
 110     for i in 0 .. mat.Height - 1 do
 111         for j in 0 .. mat.Width - 1 do
 112             let p = bin matData.[i, j]
 113             data.[p] <- data.[p] + 1
 114
 115     { data = data; total = mat.Height * mat.Width; sum = Array.sum data; min = min; max = max }
 116
 117 let histogram (values: float32 seq) (nbSamples: int) : Histogram =
 118     let mutable min = Single.MaxValue
 119     let mutable max = Single.MinValue
 120     let mutable n = 0
 121
 122     for v in values do
 123         n <- n + 1
 124         if v < min then min <- v
 125         if v > max then max <- v
 126
 127     let inline bin (x: float32) : int =
 128         let p = int ((x - min) / (max - min) * float32 nbSamples)
 129         if p >= nbSamples then nbSamples - 1 else p
 130
 131     let data = Array.zeroCreate nbSamples
 132
 133     for v in values do
 134         let p = bin v
 135         data.[p] <- data.[p] + 1
 136
 137     { data = data; total = n; sum = Array.sum data; min = min; max = max }
 138
 139 let otsu (hist: Histogram) : float32 * float32 * float32 =
 140     let mutable sumB = 0
 141     let mutable wB = 0
 142     let mutable maximum = 0.0
 143     let mutable level = 0
 144     let sum = hist.data |> Array.mapi (fun i v -> i * v |> float) |> Array.sum
 145
 146     for i in 0 .. hist.data.Length - 1 do
 147         wB <- wB + hist.data.[i]
 148         if wB <> 0
 149         then
 150             let wF = hist.total - wB
 151             if wF <> 0
 152             then
 153                 sumB <- sumB + i * hist.data.[i]
 154                 let mB = (float sumB) / (float wB)
 155                 let mF = (sum - float sumB) / (float wF)
 156                 let between = (float wB) * (float wF) * (mB - mF) ** 2.;
 157                 if between >= maximum
 158                 then
 159                     level <- i
 160                     maximum <- between
 161
 162     let mean1 =
 163         let mutable sum = 0
 164         let mutable nb = 0
 165         for i in 0 .. level - 1 do
 166             sum <- sum + i * hist.data.[i]
 167             nb <- nb + hist.data.[i]
 168         (sum + level * hist.data.[level] / 2) / (nb + hist.data.[level] / 2)
 169
 170     let mean2 =
 171         let mutable sum = 0
 172         let mutable nb = 0
 173         for i in level + 1 .. hist.data.Length - 1 do
 174             sum <- sum + i * hist.data.[i]
 175             nb <- nb + hist.data.[i]
 176         (sum + level * hist.data.[level] / 2) / (nb + hist.data.[level] / 2)
 177
 178     let toFloat l =
 179         float32 l / float32 hist.data.Length * (hist.max - hist.min) + hist.min
 180
 181     toFloat level, toFloat mean1, toFloat mean2
 182
 183 /// <summary>
 184 /// Remove M-adjacent pixels. It may be used after thinning.
 185 /// </summary>
 186 let suppressMAdjacency (img: Matrix<byte>) =
 187     let w = img.Width
 188     let h = img.Height
 189     for i in 1 .. h - 2 do
 190         for j in 1 .. w - 2 do
 191             if img.[i, j] > 0uy && img.Data.[i + 1, j] > 0uy && (img.Data.[i, j - 1] > 0uy && img.Data.[i - 1, j + 1] = 0uy || img.Data.[i, j + 1] > 0uy && img.Data.[i - 1, j - 1] = 0uy)
 192             then
 193                 img.[i, j] <- 0uy
 194     for i in 1 .. h - 2 do
 195         for j in 1 .. w - 2 do
 196             if img.[i, j] > 0uy && img.Data.[i - 1, j] > 0uy && (img.Data.[i, j - 1] > 0uy && img.Data.[i + 1, j + 1] = 0uy || img.Data.[i, j + 1] > 0uy && img.Data.[i + 1, j - 1] = 0uy)
 197             then
 198                 img.[i, j] <- 0uy
 199
 200 /// <summary>
 201 /// Find edges of an image by using the Canny approach.
 202 /// The thresholds are automatically defined with otsu on gradient magnitudes.
 203 /// </summary>
 204 /// <param name="img"></param>
 205 let findEdges (img: Image<Gray, float32>) : Matrix<byte> * Matrix<float32> * Matrix<float32> =
 206     let w = img.Width
 207     let h = img.Height
 208
 209     use sobelKernel =
 210         new Matrix<float32>(array2D [[ 1.0f; 0.0f; -1.0f ]
 211                                      [ 2.0f; 0.0f; -2.0f ]
 212                                      [ 1.0f; 0.0f; -1.0f ]])
 213
 214     let xGradient = new Matrix<float32>(img.Size)
 215     let yGradient = new Matrix<float32>(img.Size)
 216     CvInvoke.Filter2D(img, xGradient, sobelKernel, Point(1, 1))
 217     CvInvoke.Filter2D(img, yGradient, sobelKernel.Transpose(), Point(1, 1))
 218
 219     use magnitudes = new Matrix<float32>(xGradient.Size)
 220     use angles = new Matrix<float32>(xGradient.Size)
 221     CvInvoke.CartToPolar(xGradient, yGradient, magnitudes, angles) // Compute the magnitudes and angles.
 222
 223     let thresholdHigh, thresholdLow =
 224         let sensibilityHigh = 0.1f
 225         let sensibilityLow = 0.0f
 226         let threshold, _, _ = otsu (histogramMat magnitudes 300)
 227         threshold + (sensibilityHigh * threshold), threshold - (sensibilityLow * threshold)
 228
 229     // Non-maximum suppression.
 230     use nms = new Matrix<byte>(xGradient.Size)
 231
 232     let nmsData = nms.Data
 233     let anglesData = angles.Data
 234     let magnitudesData = magnitudes.Data
 235     let xGradientData = xGradient.Data
 236     let yGradientData = yGradient.Data
 237
 238     for i in 0 .. h - 1 do
 239         nmsData.[i, 0] <- 0uy
 240         nmsData.[i, w - 1] <- 0uy
 241
 242     for j in 0 .. w - 1 do
 243         nmsData.[0, j] <- 0uy
 244         nmsData.[h - 1, j] <- 0uy
 245
 246     for i in 1 .. h - 2 do
 247         for j in 1 .. w - 2 do
 248             let vx = xGradientData.[i, j]
 249             let vy = yGradientData.[i, j]
 250             if vx <> 0.f || vy <> 0.f
 251             then
 252                 let angle = anglesData.[i, j]
 253
 254                 let vx', vy' = abs vx, abs vy
 255                 let ratio2 = if vx' > vy' then vy' / vx' else vx' / vy'
 256                 let ratio1 = 1.f - ratio2
 257
 258                 let mNeigbors (sign: int) : float32 =
 259                     if angle < PI / 4.f
 260                     then ratio1 * magnitudesData.[i, j + sign] + ratio2 * magnitudesData.[i + sign, j + sign]
 261                     elif angle < PI / 2.f
 262                     then ratio2 * magnitudesData.[i + sign, j + sign] + ratio1 * magnitudesData.[i + sign, j]
 263                     elif angle < 3.f * PI / 4.f
 264                     then ratio1 * magnitudesData.[i + sign, j] + ratio2 * magnitudesData.[i + sign, j - sign]
 265                     elif angle < PI
 266                     then ratio2 * magnitudesData.[i + sign, j - sign] + ratio1 * magnitudesData.[i, j - sign]
 267                     elif angle < 5.f * PI / 4.f
 268                     then ratio1 * magnitudesData.[i, j - sign] + ratio2 * magnitudesData.[i - sign, j - sign]
 269                     elif angle < 3.f * PI / 2.f
 270                     then ratio2 * magnitudesData.[i - sign, j - sign] + ratio1 * magnitudesData.[i - sign, j]
 271                     elif angle < 7.f * PI / 4.f
 272                     then ratio1 * magnitudesData.[i - sign, j] + ratio2 * magnitudesData.[i - sign, j + sign]
 273                     else ratio2 * magnitudesData.[i - sign, j + sign] + ratio1 * magnitudesData.[i, j + sign]
 274
 275                 let m = magnitudesData.[i, j]
 276                 if m >= thresholdLow && m > mNeigbors 1 && m > mNeigbors -1
 277                 then
 278                     nmsData.[i, j] <- 1uy
 279
 280     // suppressMConnections nms // It's not helpful for the rest of the process (ellipse detection).
 281
 282     let edges = new Matrix<byte>(xGradient.Size)
 283     let edgesData = edges.Data
 284
 285     // Hysteresis thresholding.
 286     let toVisit = Stack<Point>()
 287     for i in 0 .. h - 1 do
 288         for j in 0 .. w - 1 do
 289             if nmsData.[i, j] = 1uy && magnitudesData.[i, j] >= thresholdHigh
 290             then
 291                 nmsData.[i, j] <- 0uy
 292                 toVisit.Push(Point(j, i))
 293                 while toVisit.Count > 0 do
 294                     let p = toVisit.Pop()
 295                     edgesData.[p.Y, p.X] <- 1uy
 296                     for i' in -1 .. 1  do
 297                         for j' in -1 .. 1 do
 298                             if i' <> 0 || j' <> 0
 299                             then
 300                                 let ni = p.Y + i'
 301                                 let nj = p.X + j'
 302                                 if ni >= 0 && ni < h && nj >= 0 && nj < w && nmsData.[ni, nj] = 1uy
 303                                 then
 304                                     nmsData.[ni, nj] <- 0uy
 305                                     toVisit.Push(Point(nj, ni))
 306
 307     edges, xGradient, yGradient
 308
 309 let gaussianFilter (img : Image<'TColor, 'TDepth>) (standardDeviation : float) : Image<'TColor, 'TDepth> =
 310     let size = 2 * int (ceil (4.0 * standardDeviation)) + 1
 311     img.SmoothGaussian(size, size, standardDeviation, standardDeviation)
 312
 313 let drawPoints (img: Image<Gray, 'TDepth>) (points: Points) (intensity: 'TDepth) =
 314     for p in points do
 315         img.Data.[p.Y, p.X, 0] <- intensity
 316
 317 type ExtremumType =
 318     | Maxima = 1
 319     | Minima = 2
 320
 321 let findExtremum (img: Image<Gray, 'TDepth>) (extremumType: ExtremumType) : IEnumerable<Points> =
 322     let w = img.Width
 323     let h = img.Height
 324     let se = [| -1, 0; 0, -1; 1, 0; 0, 1 |]
 325
 326     let imgData = img.Data
 327     let suppress: bool[,] = Array2D.zeroCreate h w
 328
 329     let result = List<List<Point>>()
 330
 331     let flood (start: Point) : List<List<Point>> =
 332         let sameLevelToCheck = Stack<Point>()
 333         let betterLevelToCheck = Stack<Point>()
 334         betterLevelToCheck.Push(start)
 335
 336         let result' = List<List<Point>>()
 337
 338         while betterLevelToCheck.Count > 0 do
 339             let p = betterLevelToCheck.Pop()
 340             if not suppress.[p.Y, p.X]
 341             then
 342                 suppress.[p.Y, p.X] <- true
 343                 sameLevelToCheck.Push(p)
 344                 let current = List<Point>()
 345
 346                 let mutable betterExists = false
 347
 348                 while sameLevelToCheck.Count > 0 do
 349                     let p' = sameLevelToCheck.Pop()
 350                     let currentLevel = imgData.[p'.Y, p'.X, 0]
 351                     current.Add(p') |> ignore
 352                     for i, j in se do
 353                         let ni = i + p'.Y
 354                         let nj = j + p'.X
 355                         if ni >= 0 && ni < h && nj >= 0 && nj < w
 356                         then
 357                             let level = imgData.[ni, nj, 0]
 358                             let notSuppressed = not suppress.[ni, nj]
 359
 360                             if level = currentLevel && notSuppressed
 361                             then
 362                                 suppress.[ni, nj] <- true
 363                                 sameLevelToCheck.Push(Point(nj, ni))
 364                             elif if extremumType = ExtremumType.Maxima then level > currentLevel else level < currentLevel
 365                             then
 366                                 betterExists <- true
 367                                 if notSuppressed
 368                                 then
 369                                     betterLevelToCheck.Push(Point(nj, ni))
 370
 371                 if not betterExists
 372                 then
 373                     result'.Add(current)
 374         result'
 375
 376     for i in 0 .. h - 1 do
 377         for j in 0 .. w - 1 do
 378             let maxima = flood (Point(j, i))
 379             if maxima.Count > 0
 380             then
 381                 result.AddRange(maxima)
 382
 383     result.Select(fun l -> Points(l))
 384
 385 let findMaxima (img: Image<Gray, 'TDepth>) : IEnumerable<Points> =
 386     findExtremum img ExtremumType.Maxima
 387
 388 let findMinima (img: Image<Gray, 'TDepth>) : IEnumerable<Points> =
 389     findExtremum img ExtremumType.Minima
 390
 391 type PriorityQueue () =
 392     let size = 256
 393     let q: Points[] = Array.init size (fun i -> Points())
 394     let mutable highest = -1 // Value of the first elements of 'q'.
 395     let mutable lowest = size
 396
 397     member this.NextMax () : byte * Point =
 398         if this.IsEmpty
 399         then
 400             invalidOp "Queue is empty"
 401         else
 402             let l = q.[highest]
 403             let next = l.First()
 404             l.Remove(next) |> ignore
 405             let value = byte highest
 406
 407             if l.Count = 0
 408             then
 409                 highest <- highest - 1
 410                 while highest > lowest && q.[highest].Count = 0 do
 411                     highest <- highest - 1
 412                 if highest = lowest
 413                 then
 414                     highest <- -1
 415                     lowest <- size
 416
 417             value, next
 418
 419     member this.NextMin () : byte * Point =
 420         if this.IsEmpty
 421         then
 422             invalidOp "Queue is empty"
 423         else
 424             let l = q.[lowest + 1]
 425             let next = l.First()
 426             l.Remove(next) |> ignore
 427             let value = byte (lowest + 1)
 428
 429             if l.Count = 0
 430             then
 431                 lowest <- lowest + 1
 432                 while lowest < highest && q.[lowest + 1].Count = 0 do
 433                     lowest <- lowest + 1
 434                 if highest = lowest
 435                 then
 436                     highest <- -1
 437                     lowest <- size
 438
 439             value, next
 440
 441     member this.Max =
 442         highest |> byte
 443
 444     member this.Min =
 445         lowest + 1 |> byte
 446
 447     member this.Add (value: byte) (p: Point) =
 448         let vi = int value
 449
 450         if vi > highest
 451         then
 452             highest <- vi
 453         if vi <= lowest
 454         then
 455             lowest <- vi - 1
 456
 457         q.[vi].Add(p) |> ignore
 458
 459     member this.Remove (value: byte) (p: Point) =
 460         let vi = int value
 461         if q.[vi].Remove(p) && q.[vi].Count = 0
 462         then
 463             if vi = highest
 464             then
 465                 highest <- highest - 1
 466                 while highest > lowest && q.[highest].Count = 0 do
 467                     highest <- highest - 1
 468             elif vi - 1 = lowest
 469             then
 470                 lowest <- lowest + 1
 471                 while lowest < highest && q.[lowest + 1].Count = 0 do
 472                     lowest <- lowest + 1
 473
 474             if highest = lowest // The queue is now empty.
 475             then
 476                 highest <- -1
 477                 lowest <- size
 478
 479     member this.IsEmpty =
 480         highest = -1
 481
 482     member this.Clear () =
 483         while highest > lowest  do
 484             q.[highest].Clear()
 485             highest <- highest - 1
 486         highest <- -1
 487         lowest <- size
 488
 489 type private AreaState =
 490     | Removed = 1
 491     | Unprocessed = 2
 492     | Validated = 3
 493
 494 type private AreaOperation =
 495     | Opening = 1
 496     | Closing = 2
 497
 498 [<AllowNullLiteral>]
 499 type private Area (elements: Points) =
 500     member this.Elements = elements
 501     member val Intensity = None with get, set
 502     member val State = AreaState.Unprocessed with get, set
 503
 504 let private areaOperation (img: Image<Gray, byte>) (area: int) (op: AreaOperation) =
 505     let w = img.Width
 506     let h = img.Height
 507     let imgData = img.Data
 508     let se = [| -1, 0; 0, -1; 1, 0; 0, 1 |]
 509
 510     let areas = List<Area>((if op = AreaOperation.Opening then findMaxima img else findMinima img) |> Seq.map Area)
 511
 512     let pixels: Area[,] = Array2D.create h w null
 513     for m in areas do
 514         for e in m.Elements do
 515             pixels.[e.Y, e.X] <- m
 516
 517     let queue = PriorityQueue()
 518
 519     let addEdgeToQueue (elements: Points) =
 520         for p in elements do
 521             for i, j in se do
 522                 let ni = i + p.Y
 523                 let nj = j + p.X
 524                 let p' = Point(nj, ni)
 525                 if ni >= 0 && ni < h && nj >= 0 && nj < w && not (elements.Contains(p'))
 526                 then
 527                     queue.Add (imgData.[ni, nj, 0]) p'
 528
 529     // Reverse order is quicker.
 530     for i in areas.Count - 1 .. -1 .. 0 do
 531         let m = areas.[i]
 532         if m.Elements.Count <= area && m.State <> AreaState.Removed
 533         then
 534             queue.Clear()
 535             addEdgeToQueue m.Elements
 536
 537             let mutable intensity = if op = AreaOperation.Opening then queue.Max else queue.Min
 538             let nextElements = Points()
 539
 540             let mutable stop = false
 541             while not stop do
 542                 let intensity', p = if op = AreaOperation.Opening then queue.NextMax () else queue.NextMin ()
 543                 let mutable merged = false
 544
 545                 if intensity' = intensity // The intensity doesn't change.
 546                 then
 547                     if m.Elements.Count + nextElements.Count + 1 > area
 548                     then
 549                         m.State <- AreaState.Validated
 550                         m.Intensity <- Some intensity
 551                         stop <- true
 552                     else
 553                         nextElements.Add(p) |> ignore
 554
 555                 elif if op = AreaOperation.Opening then intensity' < intensity else intensity' > intensity
 556                 then
 557                     m.Elements.UnionWith(nextElements)
 558                     for e in nextElements do
 559                         pixels.[e.Y, e.X] <- m
 560
 561                     if m.Elements.Count = area
 562                     then
 563                         m.State <- AreaState.Validated
 564                         m.Intensity <- Some (intensity')
 565                         stop <- true
 566                     else
 567                         intensity <- intensity'
 568                         nextElements.Clear()
 569                         nextElements.Add(p) |> ignore
 570
 571                 else
 572                     match pixels.[p.Y, p.X] with
 573                     | null -> ()
 574                     | m' ->
 575                         if m'.Elements.Count + m.Elements.Count <= area
 576                         then
 577                             m'.State <- AreaState.Removed
 578                             for e in m'.Elements do
 579                                 pixels.[e.Y, e.X] <- m
 580                                 queue.Remove imgData.[e.Y, e.X, 0] e
 581                             addEdgeToQueue m'.Elements
 582                             m.Elements.UnionWith(m'.Elements)
 583                             let intensityMax = if op = AreaOperation.Opening then queue.Max else queue.Min
 584                             if intensityMax <> intensity
 585                             then
 586                                 intensity <- intensityMax
 587                                 nextElements.Clear()
 588                             merged <- true
 589
 590                     if not merged
 591                     then
 592                         m.State <- AreaState.Validated
 593                         m.Intensity <- Some (intensity)
 594                         stop <- true
 595
 596                 if not stop && not merged
 597                 then
 598                     for i, j in se do
 599                         let ni = i + p.Y
 600                         let nj = j + p.X
 601                         let p' = Point(nj, ni)
 602                         if ni < 0 || ni >= h || nj < 0 || nj >= w
 603                         then
 604                             m.State <- AreaState.Validated
 605                             m.Intensity <- Some (intensity)
 606                             stop <- true
 607                         elif not (m.Elements.Contains(p')) && not (nextElements.Contains(p'))
 608                         then
 609                             queue.Add (imgData.[ni, nj, 0]) p'
 610
 611                 if queue.IsEmpty
 612                 then
 613                     if m.Elements.Count + nextElements.Count <= area
 614                     then
 615                         m.State <- AreaState.Validated
 616                         m.Intensity <- Some intensity'
 617                         m.Elements.UnionWith(nextElements)
 618                     stop <- true
 619
 620     for m in areas do
 621         if m.State = AreaState.Validated
 622         then
 623             match m.Intensity with
 624             | Some i ->
 625                 for p in m.Elements do
 626                     imgData.[p.Y, p.X, 0] <- i
 627             | _ -> ()
 628     ()
 629
 630 /// <summary>
 631 /// Area opening on byte image.
 632 /// </summary>
 633 let areaOpen (img: Image<Gray, byte>) (area: int) =
 634     areaOperation img area AreaOperation.Opening
 635
 636 /// <summary>
 637 /// Area closing on byte image.
 638 /// </summary>
 639 let areaClose (img: Image<Gray, byte>) (area: int) =
 640     areaOperation img area AreaOperation.Closing
 641
 642 // A simpler algorithm than 'areaOpen' on byte image but slower.
 643 let areaOpen2 (img: Image<Gray, byte>) (area: int) =
 644     let w = img.Width
 645     let h = img.Height
 646     let imgData = img.Data
 647     let se = [| -1, 0; 0, -1; 1, 0; 0, 1 |]
 648
 649     let histogram = Array.zeroCreate 256
 650     for i in 0 .. h - 1 do
 651         for j in 0 .. w - 1 do
 652             let v = imgData.[i, j, 0] |> int
 653             histogram.[v] <- histogram.[v] + 1
 654
 655     let flooded : bool[,] = Array2D.zeroCreate h w
 656
 657     let pointsChecked = HashSet<Point>()
 658     let pointsToCheck = Stack<Point>()
 659
 660     for level in 255 .. -1 .. 0 do
 661         let mutable n = histogram.[level]
 662         if n > 0
 663         then
 664             for i in 0 .. h - 1 do
 665                 for j in 0 .. w - 1 do
 666                     if not flooded.[i, j] && imgData.[i, j, 0] = byte level
 667                     then
 668                         let mutable maxNeighborValue = 0uy
 669                         pointsChecked.Clear()
 670                         pointsToCheck.Clear()
 671                         pointsToCheck.Push(Point(j, i))
 672
 673                         while pointsToCheck.Count > 0 do
 674                             let next = pointsToCheck.Pop()
 675                             pointsChecked.Add(next) |> ignore
 676                             flooded.[next.Y, next.X] <- true
 677
 678                             for nx, ny in se do
 679                                 let p = Point(next.X + nx, next.Y + ny)
 680                                 if p.X >= 0 && p.X < w && p.Y >= 0 && p.Y < h
 681                                 then
 682                                     let v = imgData.[p.Y, p.X, 0]
 683                                     if v = byte level
 684                                     then
 685                                         if not (pointsChecked.Contains(p))
 686                                         then
 687                                             pointsToCheck.Push(p)
 688                                     elif v > maxNeighborValue
 689                                     then
 690                                         maxNeighborValue <- v
 691
 692                         if int maxNeighborValue < level && pointsChecked.Count <= area
 693                         then
 694                             for p in pointsChecked do
 695                                 imgData.[p.Y, p.X, 0] <- maxNeighborValue
 696
 697 [<AllowNullLiteral>]
 698 type Island (cmp: IComparer<float32>) =
 699     member val Shore = Heap.Heap<float32, Point>(cmp) with get
 700     member val Level = 0.f with get, set
 701     member val Surface = 0 with get, set
 702     member this.IsInfinite = this.Surface = Int32.MaxValue
 703
 704 let private areaOperationF (img: Image<Gray, float32>) (areas: (int * 'a) list) (f: ('a -> float32 -> unit) option) (op: AreaOperation) =
 705     let w = img.Width
 706     let h = img.Height
 707     let earth = img.Data
 708     let se = [| -1, 0; 0, -1; 1, 0; 0, 1 |]
 709
 710     let comparer = if op = AreaOperation.Opening
 711                    then { new IComparer<float32> with member this.Compare(v1, v2) = v1.CompareTo(v2) }
 712                    else { new IComparer<float32> with member this.Compare(v1, v2) = v2.CompareTo(v1) }
 713
 714     let ownership: Island[,] = Array2D.create h w null
 715
 716     // Initialize islands with their shore.
 717     let islands = List<Island>()
 718     let extremum = img |> if op = AreaOperation.Opening then findMaxima else findMinima
 719     for e in extremum do
 720         let island =
 721             let p = e.First()
 722             Island(comparer, Level = earth.[p.Y, p.X, 0], Surface = e.Count)
 723         islands.Add(island)
 724         let shorePoints = Points()
 725         for p in e do
 726             ownership.[p.Y, p.X] <- island
 727             for i, j in se do
 728                 let ni = i + p.Y
 729                 let nj = j + p.X
 730                 let neighbor = Point(nj, ni)
 731                 if ni >= 0 && ni < h && nj >= 0 && nj < w && Object.ReferenceEquals(ownership.[ni, nj], null) && not (shorePoints.Contains(neighbor))
 732                 then
 733                     shorePoints.Add(neighbor) |> ignore
 734                     island.Shore.Add earth.[ni, nj, 0] neighbor
 735
 736     for area, obj in areas do
 737         for island in islands do
 738             let mutable stop = island.Shore.IsEmpty
 739
 740             // 'true' if 'p' is owned or adjacent to 'island'.
 741             let inline ownedOrAdjacent (p: Point) : bool =
 742                 ownership.[p.Y, p.X] = island ||
 743                 (p.Y > 0 && ownership.[p.Y - 1, p.X] = island) ||
 744                 (p.Y < h - 1 && ownership.[p.Y + 1, p.X] = island) ||
 745                 (p.X > 0 && ownership.[p.Y, p.X - 1] = island) ||
 746                 (p.X < w - 1 && ownership.[p.Y, p.X + 1] = island)
 747
 748             while not stop && island.Surface < area do
 749                 let level, next = island.Shore.Max
 750                 let other = ownership.[next.Y, next.X]
 751                 if other = island // During merging, some points on the shore may be owned by the island itself -> ignored.
 752                 then
 753                     island.Shore.RemoveNext ()
 754                 else
 755                     if not <| Object.ReferenceEquals(other, null)
 756                     then // We touching another island.
 757                         if island.IsInfinite || other.IsInfinite || island.Surface + other.Surface >= area || comparer.Compare(island.Level, other.Level) < 0
 758                         then
 759                             stop <- true
 760                         else // We can merge 'other' into 'surface'.
 761                             island.Surface <- island.Surface + other.Surface
 762                             island.Level <- other.Level
 763                             // island.Level <- if comparer.Compare(island.Level, other.Level) > 0 then other.Level else island.Level
 764                             for l, p in other.Shore do
 765                                 let mutable currentY = p.Y + 1
 766                                 while currentY < h && ownership.[currentY, p.X] = other do
 767                                     ownership.[currentY, p.X] <- island
 768                                     currentY <- currentY + 1
 769                                 island.Shore.Add l p
 770                             other.Shore.Clear()
 771
 772                     elif comparer.Compare(level, island.Level) > 0
 773                     then
 774                         stop <- true
 775                     else
 776                         island.Shore.RemoveNext ()
 777                         for i, j in se do
 778                             let ni = i + next.Y
 779                             let nj = j + next.X
 780                             if ni < 0 || ni >= h || nj < 0 || nj >= w
 781                             then
 782                                 island.Surface <- Int32.MaxValue
 783                                 stop <- true
 784                             else
 785                                 let neighbor = Point(nj, ni)
 786                                 if not <| ownedOrAdjacent neighbor
 787                                 then
 788                                     island.Shore.Add earth.[ni, nj, 0] neighbor
 789                         if not stop
 790                         then
 791                             ownership.[next.Y, next.X] <- island
 792                             island.Level <- level
 793                             island.Surface <- island.Surface + 1
 794
 795         let mutable diff = 0.f
 796
 797         for i in 0 .. h - 1 do
 798             for j in 0 .. w - 1 do
 799                 match ownership.[i, j] with
 800                 | null -> ()
 801                 | island ->
 802                     let l = island.Level
 803                     diff <- diff + l - earth.[i, j, 0]
 804                     earth.[i, j, 0] <- l
 805
 806         match f with
 807         | Some f' -> f' obj diff
 808         | _ -> ()
 809     ()
 810
 811 /// <summary>
 812 /// Area opening on float image.
 813 /// </summary>
 814 let areaOpenF (img: Image<Gray, float32>) (area: int) =
 815     areaOperationF img [ area, () ] None AreaOperation.Opening
 816
 817 /// <summary>
 818 /// Area closing on float image.
 819 /// </summary>
 820 let areaCloseF (img: Image<Gray, float32>) (area: int) =
 821     areaOperationF img [ area, () ] None AreaOperation.Closing
 822
 823 /// <summary>
 824 /// Area closing on float image with different areas. Given areas must be sorted increasingly.
 825 /// For each area the function 'f' is called with the associated area value of type 'a and the volume difference
 826 /// Between the previous and the current closing.
 827 /// </summary>
 828 let areaOpenFWithFun (img: Image<Gray, float32>) (areas: (int * 'a) list) (f: 'a -> float32 -> unit) =
 829     areaOperationF img areas (Some f) AreaOperation.Opening
 830
 831 /// <summary>
 832 /// Same as 'areaOpenFWithFun' for closing operation.
 833 /// </summary>
 834 let areaCloseFWithFun (img: Image<Gray, float32>) (areas: (int * 'a) list) (f: 'a -> float32 -> unit) =
 835     areaOperationF img areas (Some f) AreaOperation.Closing
 836
 837 /// <summary>
 838 /// Zhang and Suen thinning algorithm.
 839 /// Modify 'mat' in place.
 840 /// </summary>
 841 let thin (mat: Matrix<byte>) =
 842     let w = mat.Width
 843     let h = mat.Height
 844     let mutable data1 = mat.Data
 845     let mutable data2 = Array2D.copy data1
 846
 847     let mutable pixelChanged = true
 848     let mutable oddIteration = true
 849
 850     while pixelChanged do
 851         pixelChanged <- false
 852         for i in 0..h-1 do
 853             for j in 0..w-1 do
 854                 if data1.[i, j] = 1uy
 855                 then
 856                     let p2 = if i = 0 then 0uy else data1.[i-1, j]
 857                     let p3 = if i = 0 || j = w-1 then 0uy else data1.[i-1, j+1]
 858                     let p4 = if j = w-1 then 0uy else data1.[i, j+1]
 859                     let p5 = if i = h-1 || j = w-1 then 0uy else data1.[i+1, j+1]
 860                     let p6 = if i = h-1 then 0uy else data1.[i+1, j]
 861                     let p7 = if i = h-1 || j = 0 then 0uy else data1.[i+1, j-1]
 862                     let p8 = if j = 0 then 0uy else data1.[i, j-1]
 863                     let p9 = if i = 0 || j = 0 then 0uy else data1.[i-1, j-1]
 864
 865                     let sumNeighbors = p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9
 866                     if sumNeighbors >= 2uy && sumNeighbors <= 6uy &&
 867                         (if p2 = 0uy && p3 = 1uy then 1 else 0) +
 868                         (if p3 = 0uy && p4 = 1uy then 1 else 0) +
 869                         (if p4 = 0uy && p5 = 1uy then 1 else 0) +
 870                         (if p5 = 0uy && p6 = 1uy then 1 else 0) +
 871                         (if p6 = 0uy && p7 = 1uy then 1 else 0) +
 872                         (if p7 = 0uy && p8 = 1uy then 1 else 0) +
 873                         (if p8 = 0uy && p9 = 1uy then 1 else 0) +
 874                         (if p9 = 0uy && p2 = 1uy then 1 else 0) = 1 &&
 875                         if oddIteration
 876                         then p2 * p4 * p6 = 0uy && p4 * p6 * p8 = 0uy
 877                         else p2 * p4 * p8 = 0uy && p2 * p6 * p8 = 0uy
 878                     then
 879                         data2.[i, j] <- 0uy
 880                         pixelChanged <- true
 881                 else
 882                     data2.[i, j] <- 0uy
 883
 884         oddIteration <- not oddIteration
 885         let tmp = data1
 886         data1 <- data2
 887         data2 <- tmp
 888
 889 /// <summary>
 890 /// Remove all 8-connected pixels with an area equal or greater than 'areaSize'.
 891 /// Modify 'mat' in place.
 892 /// </summary>
 893 let removeArea (mat: Matrix<byte>) (areaSize: int) =
 894     let neighbors = [|
 895         (-1,  0) // p2
 896         (-1,  1) // p3
 897         ( 0,  1) // p4
 898         ( 1,  1) // p5
 899         ( 1,  0) // p6
 900         ( 1, -1) // p7
 901         ( 0, -1) // p8
 902         (-1, -1) |] // p9
 903
 904     use mat' = new Matrix<byte>(mat.Size)
 905     let w = mat'.Width
 906     let h = mat'.Height
 907     mat.CopyTo(mat')
 908
 909     let data = mat.Data
 910     let data' = mat'.Data
 911
 912     for i in 0..h-1 do
 913         for j in 0..w-1 do
 914             if data'.[i, j] = 1uy
 915             then
 916                 let neighborhood = List<Point>()
 917                 let neighborsToCheck = Stack<Point>()
 918                 neighborsToCheck.Push(Point(j, i))
 919                 data'.[i, j] <- 0uy
 920
 921                 while neighborsToCheck.Count > 0 do
 922                     let n = neighborsToCheck.Pop()
 923                     neighborhood.Add(n)
 924                     for (ni, nj) in neighbors do
 925                         let pi = n.Y + ni
 926                         let pj = n.X + nj
 927                         if pi >= 0 && pi < h && pj >= 0 && pj < w && data'.[pi, pj] = 1uy
 928                         then
 929                             neighborsToCheck.Push(Point(pj, pi))
 930                             data'.[pi, pj] <- 0uy
 931                 if neighborhood.Count <= areaSize
 932                 then
 933                     for n in neighborhood do
 934                         data.[n.Y, n.X] <- 0uy
 935
 936 let connectedComponents (img: Image<Gray, byte>) (startPoints: List<Point>) : Points =
 937     let w = img.Width
 938     let h = img.Height
 939
 940     let pointChecked = Points()
 941     let pointToCheck = Stack<Point>(startPoints);
 942
 943     let data = img.Data
 944
 945     while pointToCheck.Count > 0 do
 946         let next = pointToCheck.Pop()
 947         pointChecked.Add(next) |> ignore
 948         for ny in -1 .. 1 do
 949             for nx in -1 .. 1 do
 950                 if ny <> 0 && nx <> 0
 951                 then
 952                     let p = Point(next.X + nx, next.Y + ny)
 953                     if p.X >= 0 && p.X < w && p.Y >= 0 && p.Y < h && data.[p.Y, p.X, 0] > 0uy && not (pointChecked.Contains p)
 954                     then
 955                         pointToCheck.Push(p)
 956
 957     pointChecked
 958
 959 let drawLine (img: Image<'TColor, 'TDepth>) (color: 'TColor) (x0: int) (y0: int) (x1: int) (y1: int) (thickness: int) =
 960     img.Draw(LineSegment2D(Point(x0, y0), Point(x1, y1)), color, thickness);
 961
 962 let drawLineF (img: Image<'TColor, 'TDepth>) (color: 'TColor) (x0: float) (y0: float) (x1: float) (y1: float) (thickness: int) =
 963     img.Draw(LineSegment2DF(PointF(float32 x0, float32 y0), PointF(float32 x1, float32 y1)), color, thickness, CvEnum.LineType.AntiAlias);
 964
 965 let drawEllipse (img: Image<'TColor, 'TDepth>) (e: Ellipse) (color: 'TColor) (alpha: float) =
 966     if alpha >= 1.0
 967     then
 968         img.Draw(Emgu.CV.Structure.Ellipse(PointF(e.Cx, e.Cy), SizeF(2.f * e.B, 2.f * e.A), e.Alpha / PI * 180.f), color, 1, CvEnum.LineType.AntiAlias)
 969     else
 970         let windowPosX = e.Cx - e.A - 5.f
 971         let gapX = windowPosX - (float32 (int windowPosX))
 972
 973         let windowPosY = e.Cy - e.A - 5.f
 974         let gapY = windowPosY - (float32 (int windowPosY))
 975
 976         let roi = Rectangle(int windowPosX, int windowPosY, 2.f * (e.A + 5.f) |> int, 2.f * (e.A + 5.f) |> int)
 977
 978         img.ROI <- roi
 979         if roi = img.ROI // We do not display ellipses touching the edges (FIXME)
 980         then
 981             use i = new Image<'TColor, 'TDepth>(img.ROI.Size)
 982             i.Draw(Emgu.CV.Structure.Ellipse(PointF(e.A + 5.f + gapX, e.A + 5.f + gapY), SizeF(2.f * e.B, 2.f * e.A), e.Alpha / PI * 180.f), color, 1, CvEnum.LineType.AntiAlias)
 983             CvInvoke.AddWeighted(img, 1.0, i, alpha, 0.0, img)
 984         img.ROI <- Rectangle.Empty
 985
 986 let drawEllipses (img: Image<'TColor, 'TDepth>) (ellipses: Ellipse list) (color: 'TColor) (alpha: float) =
 987     List.iter (fun e -> drawEllipse img e color alpha) ellipses
 988
 989 let rngCell =  System.Random()
 990 let drawCell (img: Image<Bgr, byte>) (drawCellContent: bool) (c: Cell) =
 991     if drawCellContent
 992     then
 993         let colorB = rngCell.Next(20, 70)
 994         let colorG = rngCell.Next(20, 70)
 995         let colorR = rngCell.Next(20, 70)
 996
 997         for y in 0 .. c.elements.Height - 1 do
 998             for x in 0 .. c.elements.Width - 1 do
 999                 if c.elements.[y, x] > 0uy
1000                 then
1001                     let dx, dy = c.center.X - c.elements.Width / 2, c.center.Y - c.elements.Height / 2
1002                     let b = img.Data.[y + dy, x + dx, 0] |> int
1003                     let g = img.Data.[y + dy, x + dx, 1] |> int
1004                     let r = img.Data.[y + dy, x + dx, 2] |> int
1005                     img.Data.[y + dy, x + dx, 0] <- if b + colorB > 255 then 255uy else byte (b + colorB)
1006                     img.Data.[y + dy, x + dx, 1] <- if g + colorG > 255 then 255uy else byte (g + colorG)
1007                     img.Data.[y + dy, x + dx, 2] <- if r + colorR > 255 then 255uy else byte (r + colorR)
1008
1009     let crossColor, crossColor2 =
1010         match c.cellClass with
1011         | HealthyRBC -> Bgr(255., 0., 0.), Bgr(255., 255., 255.)
1012         | InfectedRBC -> Bgr(0., 0., 255.), Bgr(120., 120., 255.)
1013         | Peculiar -> Bgr(0., 0., 0.), Bgr(80., 80., 80.)
1014
1015     drawLine img crossColor2 (c.center.X - 3) c.center.Y (c.center.X + 3) c.center.Y 2
1016     drawLine img crossColor2 c.center.X (c.center.Y - 3) c.center.X (c.center.Y + 3) 2
1017
1018     drawLine img crossColor (c.center.X - 3) c.center.Y (c.center.X + 3) c.center.Y 1
1019     drawLine img crossColor c.center.X (c.center.Y - 3) c.center.X (c.center.Y + 3) 1
1020
1021
1022 let drawCells (img: Image<Bgr, byte>) (drawCellContent: bool) (cells: Cell list) =
1023     List.iter (fun c -> drawCell img drawCellContent c) cells