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