Parasitemia/Parasitemia/ImgTools.fs

   1 module 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 Utils
  12 open Heap
  13
  14 // Normalize image values between 0uy and 255uy.
  15 let normalizeAndConvert (img: Image<Gray, float32>) : Image<Gray, byte> =
  16     let min = ref [| 0.0 |]
  17     let minLocation = ref <| [| Point() |]
  18     let max = ref [| 0.0 |]
  19     let maxLocation = ref <| [| Point() |]
  20     img.MinMax(min, max, minLocation, maxLocation)
  21     ((img - (!min).[0]) / ((!max).[0] - (!min).[0]) * 255.0).Convert<Gray, byte>()
  22
  23
  24 let gaussianFilter (img : Image<'TColor, 'TDepth>) (standardDeviation : float) : Image<'TColor, 'TDepth> =
  25     let size = 2 * int (ceil (4.0 * standardDeviation)) + 1
  26     img.SmoothGaussian(size, size, standardDeviation, standardDeviation)
  27
  28
  29 type Points = HashSet<Point>
  30
  31 let drawPoints (img: Image<Gray, byte>) (points: Points) (intensity: byte) =
  32     for p in points do
  33         img.Data.[p.Y, p.X, 0] <- intensity
  34
  35
  36 type ExtremumType =
  37     | Maxima = 1
  38     | Minima = 2
  39
  40 let findExtremum (img: Image<Gray, byte>) (extremumType: ExtremumType) : IEnumerable<Points> =
  41     let w = img.Width
  42     let h = img.Height
  43     let se = [| -1, 0; 0, -1; 1, 0; 0, 1 |]
  44
  45     let imgData = img.Data
  46     let suppress: bool[,] = Array2D.zeroCreate h w
  47
  48     let result = List<List<Point>>()
  49
  50     let flood (start: Point) : List<List<Point>> =
  51         let sameLevelToCheck = Stack<Point>()
  52         let betterLevelToCheck = Stack<Point>()
  53         betterLevelToCheck.Push(start)
  54
  55         let result' = List<List<Point>>()
  56
  57         while betterLevelToCheck.Count > 0 do
  58             let p = betterLevelToCheck.Pop()
  59             if not suppress.[p.Y, p.X]
  60             then
  61                 suppress.[p.Y, p.X] <- true
  62                 sameLevelToCheck.Push(p)
  63                 let current = List<Point>()
  64
  65                 let mutable betterExists = false
  66
  67                 while sameLevelToCheck.Count > 0 do
  68                     let p' = sameLevelToCheck.Pop()
  69                     let currentLevel = imgData.[p'.Y, p'.X, 0]
  70                     current.Add(p') |> ignore
  71                     for i, j in se do
  72                         let ni = i + p'.Y
  73                         let nj = j + p'.X
  74                         if ni >= 0 && ni < h && nj >= 0 && nj < w
  75                         then
  76                             let level = imgData.[ni, nj, 0]
  77                             let notSuppressed = not suppress.[ni, nj]
  78
  79                             if level = currentLevel && notSuppressed
  80                             then
  81                                 suppress.[ni, nj] <- true
  82                                 sameLevelToCheck.Push(Point(nj, ni))
  83                             elif if extremumType = ExtremumType.Maxima then level > currentLevel else level < currentLevel
  84                             then
  85                                 betterExists <- true
  86                                 if notSuppressed
  87                                 then
  88                                     betterLevelToCheck.Push(Point(nj, ni))
  89
  90                 if not betterExists
  91                 then
  92                     result'.Add(current)
  93         result'
  94
  95     for i in 0 .. h - 1 do
  96         for j in 0 .. w - 1 do
  97             let maxima = flood (Point(j, i))
  98             if maxima.Count > 0
  99             then
 100                 result.AddRange(maxima)
 101
 102     result.Select(fun l -> Points(l))
 103
 104
 105 let findMaxima (img: Image<Gray, byte>) : IEnumerable<Points> =
 106     findExtremum img ExtremumType.Maxima
 107
 108 let findMinima (img: Image<Gray, byte>) : IEnumerable<Points> =
 109     findExtremum img ExtremumType.Minima
 110
 111
 112 type PriorityQueue () =
 113     let size = 256
 114     let q: Points[] = Array.init size (fun i -> Points())
 115     let mutable highest = -1 // Value of the first elements of 'q'.
 116     let mutable lowest = size
 117
 118     member this.NextMax () : byte * Point =
 119         if this.IsEmpty
 120         then
 121             invalidOp "Queue is empty"
 122         else
 123             let l = q.[highest]
 124             let next = l.First()
 125             l.Remove(next) |> ignore
 126             let value = byte highest
 127
 128             if l.Count = 0
 129             then
 130                 highest <- highest - 1
 131                 while highest > lowest && q.[highest].Count = 0 do
 132                     highest <- highest - 1
 133                 if highest = lowest
 134                 then
 135                     highest <- -1
 136                     lowest <- size
 137
 138             value, next
 139
 140     member this.NextMin () : byte * Point =
 141         if this.IsEmpty
 142         then
 143             invalidOp "Queue is empty"
 144         else
 145             let l = q.[lowest + 1]
 146             let next = l.First()
 147             l.Remove(next) |> ignore
 148             let value = byte (lowest + 1)
 149
 150             if l.Count = 0
 151             then
 152                 lowest <- lowest + 1
 153                 while lowest < highest && q.[lowest + 1].Count = 0 do
 154                     lowest <- lowest + 1
 155                 if highest = lowest
 156                 then
 157                     highest <- -1
 158                     lowest <- size
 159
 160             value, next
 161
 162     member this.Max =
 163         highest |> byte
 164
 165     member this.Min =
 166         lowest + 1 |> byte
 167
 168     member this.Add (value: byte) (p: Point) =
 169         let vi = int value
 170
 171         if vi > highest
 172         then
 173             highest <- vi
 174         if vi <= lowest
 175         then
 176             lowest <- vi - 1
 177
 178         q.[vi].Add(p) |> ignore
 179
 180     member this.Remove (value: byte) (p: Point) =
 181         let vi = int value
 182         if q.[vi].Remove(p) && q.[vi].Count = 0
 183         then
 184             if vi = highest
 185             then
 186                 highest <- highest - 1
 187                 while highest > lowest && q.[highest].Count = 0 do
 188                     highest <- highest - 1
 189             elif vi - 1 = lowest
 190             then
 191                 lowest <- lowest + 1
 192                 while lowest < highest && q.[lowest + 1].Count = 0 do
 193                     lowest <- lowest + 1
 194
 195             if highest = lowest // The queue is now empty.
 196             then
 197                 highest <- -1
 198                 lowest <- size
 199
 200     member this.IsEmpty =
 201         highest = -1
 202
 203     member this.Clear () =
 204         while highest > lowest  do
 205             q.[highest].Clear()
 206             highest <- highest - 1
 207         highest <- -1
 208         lowest <- size
 209
 210
 211 type private AreaState =
 212     | Removed = 1
 213     | Unprocessed = 2
 214     | Validated = 3
 215
 216 type private AreaOperation =
 217     | Opening = 1
 218     | Closing = 2
 219
 220 [<AllowNullLiteral>]
 221 type private Area (elements: Points) =
 222     member this.Elements = elements
 223     member val Intensity = None with get, set
 224     member val State = AreaState.Unprocessed with get, set
 225
 226 let private areaOperation (img: Image<Gray, byte>) (area: int) (op: AreaOperation) =
 227     let w = img.Width
 228     let h = img.Height
 229     let imgData = img.Data
 230     let se = [| -1, 0; 0, -1; 1, 0; 0, 1 |]
 231
 232     let areas = List<Area>((if op = AreaOperation.Opening then findMaxima img else findMinima img) |> Seq.map Area)
 233
 234     let pixels: Area[,] = Array2D.create h w null
 235     for m in areas do
 236         for e in m.Elements do
 237             pixels.[e.Y, e.X] <- m
 238
 239     let queue = PriorityQueue()
 240
 241     let addEdgeToQueue (elements: Points) =
 242         for p in elements do
 243             for i, j in se do
 244                 let ni = i + p.Y
 245                 let nj = j + p.X
 246                 let p' = Point(nj, ni)
 247                 if ni >= 0 && ni < h && nj >= 0 && nj < w && not (elements.Contains(p'))
 248                 then
 249                     queue.Add (imgData.[ni, nj, 0]) p'
 250
 251     // Reverse order is quicker.
 252     for i in areas.Count - 1 .. -1 .. 0 do
 253         let m = areas.[i]
 254         if m.Elements.Count <= area && m.State <> AreaState.Removed
 255         then
 256             queue.Clear()
 257             addEdgeToQueue m.Elements
 258
 259             let mutable intensity = if op = AreaOperation.Opening then queue.Max else queue.Min
 260             let nextElements = Points()
 261
 262             let mutable stop = false
 263             while not stop do
 264                 let intensity', p = if op = AreaOperation.Opening then queue.NextMax () else queue.NextMin ()
 265                 let mutable merged = false
 266
 267                 if intensity' = intensity // The intensity doesn't change.
 268                 then
 269                     if m.Elements.Count + nextElements.Count + 1 > area
 270                     then
 271                         m.State <- AreaState.Validated
 272                         m.Intensity <- Some intensity
 273                         stop <- true
 274                     else
 275                         nextElements.Add(p) |> ignore
 276
 277                 elif if op = AreaOperation.Opening then intensity' < intensity else intensity' > intensity
 278                 then
 279                     m.Elements.UnionWith(nextElements)
 280                     for e in nextElements do
 281                         pixels.[e.Y, e.X] <- m
 282
 283                     if m.Elements.Count = area
 284                     then
 285                         m.State <- AreaState.Validated
 286                         m.Intensity <- Some (intensity')
 287                         stop <- true
 288                     else
 289                         intensity <- intensity'
 290                         nextElements.Clear()
 291                         nextElements.Add(p) |> ignore
 292
 293                 else
 294                     let m' = pixels.[p.Y, p.X]
 295                     if m' <> null
 296                     then
 297                         if m'.Elements.Count + m.Elements.Count <= area
 298                         then
 299                             m'.State <- AreaState.Removed
 300                             for e in m'.Elements do
 301                                 pixels.[e.Y, e.X] <- m
 302                                 queue.Remove imgData.[e.Y, e.X, 0] e
 303                             addEdgeToQueue m'.Elements
 304                             m.Elements.UnionWith(m'.Elements)
 305                             let intensityMax = if op = AreaOperation.Opening then queue.Max else queue.Min
 306                             if intensityMax <> intensity
 307                             then
 308                                 intensity <- intensityMax
 309                                 nextElements.Clear()
 310                             merged <- true
 311
 312                     if not merged
 313                     then
 314                         m.State <- AreaState.Validated
 315                         m.Intensity <- Some (intensity)
 316                         stop <- true
 317
 318                 if not stop && not merged
 319                 then
 320                     for i, j in se do
 321                         let ni = i + p.Y
 322                         let nj = j + p.X
 323                         let p' = Point(nj, ni)
 324                         if ni < 0 || ni >= h || nj < 0 || nj >= w
 325                         then
 326                             m.State <- AreaState.Validated
 327                             m.Intensity <- Some (intensity)
 328                             stop <- true
 329                         elif not (m.Elements.Contains(p')) && not (nextElements.Contains(p'))
 330                         then
 331                             queue.Add (imgData.[ni, nj, 0]) p'
 332
 333                 if queue.IsEmpty
 334                 then
 335                     if m.Elements.Count + nextElements.Count <= area
 336                     then
 337                         m.State <- AreaState.Validated
 338                         m.Intensity <- Some intensity'
 339                         m.Elements.UnionWith(nextElements)
 340                     stop <- true
 341
 342     for m in areas do
 343         if m.State = AreaState.Validated
 344         then
 345             match m.Intensity with
 346             | Some i ->
 347                 for p in m.Elements do
 348                     imgData.[p.Y, p.X, 0] <- i
 349             | _ -> ()
 350     ()
 351
 352
 353 let areaOpen (img: Image<Gray, byte>) (area: int) =
 354     areaOperation img area AreaOperation.Opening
 355
 356 let areaClose (img: Image<Gray, byte>) (area: int) =
 357     areaOperation img area AreaOperation.Closing
 358
 359 let areaOpen2 (img: Image<Gray, byte>) (area: int) =
 360     let w = img.Width
 361     let h = img.Height
 362     let imgData = img.Data
 363     let se = [| -1, 0; 0, -1; 1, 0; 0, 1 |]
 364
 365     let histogram = Array.zeroCreate 256
 366     for i in 0 .. h - 1 do
 367         for j in 0 .. w - 1 do
 368             let v = imgData.[i, j, 0] |> int
 369             histogram.[v] <- histogram.[v] + 1
 370
 371     let flooded : bool[,] = Array2D.zeroCreate h w
 372
 373     let pointsChecked = HashSet<Point>()
 374     let pointsToCheck = Stack<Point>()
 375
 376     for level in 255 .. -1 .. 0 do
 377         let mutable n = histogram.[level]
 378         if n > 0
 379         then
 380             for i in 0 .. h - 1 do
 381                 for j in 0 .. w - 1 do
 382                     if not flooded.[i, j] && imgData.[i, j, 0] = byte level
 383                     then
 384                         let mutable maxNeighborValue = 0uy
 385                         pointsChecked.Clear()
 386                         pointsToCheck.Clear()
 387                         pointsToCheck.Push(Point(j, i))
 388
 389                         while pointsToCheck.Count > 0 do
 390                             let next = pointsToCheck.Pop()
 391                             pointsChecked.Add(next) |> ignore
 392                             flooded.[next.Y, next.X] <- true
 393
 394                             for nx, ny in se do
 395                                 let p = Point(next.X + nx, next.Y + ny)
 396                                 if p.X >= 0 && p.X < w && p.Y >= 0 && p.Y < h
 397                                 then
 398                                     let v = imgData.[p.Y, p.X, 0]
 399                                     if v = byte level
 400                                     then
 401                                         if not (pointsChecked.Contains(p))
 402                                         then
 403                                             pointsToCheck.Push(p)
 404                                     elif v > maxNeighborValue
 405                                     then
 406                                         maxNeighborValue <- v
 407
 408                         if int maxNeighborValue < level && pointsChecked.Count <= area
 409                         then
 410                             for p in pointsChecked do
 411                                 imgData.[p.Y, p.X, 0] <- maxNeighborValue
 412
 413
 414 // Zhang and Suen algorithm.
 415 // Modify 'mat' in place.
 416 let thin (mat: Matrix<byte>) =
 417     let w = mat.Width
 418     let h = mat.Height
 419     let mutable data1 = mat.Data
 420     let mutable data2 = Array2D.copy data1
 421
 422     let mutable pixelChanged = true
 423     let mutable oddIteration = true
 424
 425     while pixelChanged do
 426         pixelChanged <- false
 427         for i in 0..h-1 do
 428             for j in 0..w-1 do
 429                 if data1.[i, j] = 1uy
 430                 then
 431                     let p2 = if i = 0 then 0uy else data1.[i-1, j]
 432                     let p3 = if i = 0 || j = w-1 then 0uy else data1.[i-1, j+1]
 433                     let p4 = if j = w-1 then 0uy else data1.[i, j+1]
 434                     let p5 = if i = h-1 || j = w-1 then 0uy else data1.[i+1, j+1]
 435                     let p6 = if i = h-1 then 0uy else data1.[i+1, j]
 436                     let p7 = if i = h-1 || j = 0 then 0uy else data1.[i+1, j-1]
 437                     let p8 = if j = 0 then 0uy else data1.[i, j-1]
 438                     let p9 = if i = 0 || j = 0 then 0uy else data1.[i-1, j-1]
 439
 440                     let sumNeighbors = p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9
 441                     if sumNeighbors >= 2uy && sumNeighbors <= 6uy &&
 442                         (if p2 = 0uy && p3 = 1uy then 1 else 0) +
 443                         (if p3 = 0uy && p4 = 1uy then 1 else 0) +
 444                         (if p4 = 0uy && p5 = 1uy then 1 else 0) +
 445                         (if p5 = 0uy && p6 = 1uy then 1 else 0) +
 446                         (if p6 = 0uy && p7 = 1uy then 1 else 0) +
 447                         (if p7 = 0uy && p8 = 1uy then 1 else 0) +
 448                         (if p8 = 0uy && p9 = 1uy then 1 else 0) +
 449                         (if p9 = 0uy && p2 = 1uy then 1 else 0) = 1 &&
 450                         if oddIteration
 451                         then p2 * p4 * p6 = 0uy && p4 * p6 * p8 = 0uy
 452                         else p2 * p4 * p8 = 0uy && p2 * p6 * p8 = 0uy
 453                     then
 454                         data2.[i, j] <- 0uy
 455                         pixelChanged <- true
 456                 else
 457                     data2.[i, j] <- 0uy
 458
 459         oddIteration <- not oddIteration
 460         let tmp = data1
 461         data1 <- data2
 462         data2 <- tmp
 463
 464
 465 // FIXME: replace by a queue or stack.
 466 let pop (l: List<'a>) : 'a =
 467     let n = l.[l.Count - 1]
 468     l.RemoveAt(l.Count - 1)
 469     n
 470
 471 // Remove all 8-connected pixels with an area equal or greater than 'areaSize'.
 472 // Modify 'mat' in place.
 473 let removeArea (mat: Matrix<byte>) (areaSize: int) =
 474     let neighbors = [|
 475         (-1,  0) // p2
 476         (-1,  1) // p3
 477         ( 0,  1) // p4
 478         ( 1,  1) // p5
 479         ( 1,  0) // p6
 480         ( 1, -1) // p7
 481         ( 0, -1) // p8
 482         (-1, -1) |] // p9
 483
 484     let mat' = new Matrix<byte>(mat.Size)
 485     let w = mat'.Width
 486     let h = mat'.Height
 487     mat.CopyTo(mat')
 488
 489     let data = mat.Data
 490     let data' = mat'.Data
 491
 492     for i in 0..h-1 do
 493         for j in 0..w-1 do
 494             if data'.[i, j] = 1uy
 495             then
 496                 let neighborhood = List<(int*int)>()
 497                 let neighborsToCheck = List<(int*int)>()
 498                 neighborsToCheck.Add((i, j))
 499                 data'.[i, j] <- 0uy
 500
 501                 while neighborsToCheck.Count > 0 do
 502                     let (ci, cj) = pop neighborsToCheck
 503                     neighborhood.Add((ci, cj))
 504                     for (ni, nj) in neighbors do
 505                         let pi = ci + ni
 506                         let pj = cj + nj
 507                         if pi >= 0 && pi < h && pj >= 0 && pj < w && data'.[pi, pj] = 1uy
 508                         then
 509                             neighborsToCheck.Add((pi, pj))
 510                             data'.[pi, pj] <- 0uy
 511                 if neighborhood.Count <= areaSize
 512                 then
 513                     for (ni, nj) in neighborhood do
 514                         data.[ni, nj] <- 0uy
 515
 516 let connectedComponents (img: Image<Gray, byte>) (startPoints: List<Point>) : List<Point> =
 517     let w = img.Width
 518     let h = img.Height
 519
 520     let pointChecked = Points()
 521     let pointToCheck = List<Point>(startPoints);
 522
 523     let data = img.Data
 524
 525     while pointToCheck.Count > 0 do
 526         let next = pop pointToCheck
 527         pointChecked.Add(next) |> ignore
 528         for ny in -1 .. 1 do
 529             for nx in -1 .. 1 do
 530                 if ny <> 0 && nx <> 0
 531                 then
 532                     let p = Point(next.X + nx, next.Y + ny)
 533                     if p.X >= 0 && p.X < w && p.Y >= 0 && p.Y < h && data.[p.Y, p.X, 0] > 0uy && not (pointChecked.Contains p)
 534                     then
 535                         pointToCheck.Add(p)
 536
 537     List<Point>(pointChecked)
 538
 539
 540 let saveImg (img: Image<'TColor, 'TDepth>) (filepath: string) =
 541     img.Save(filepath)
 542
 543
 544 let saveMat (mat: Matrix<'TDepth>) (filepath: string) =
 545     use img = new Image<Gray, 'TDeph>(mat.Size)
 546     mat.CopyTo(img)
 547     saveImg img filepath
 548
 549 let drawLine (img: Image<'TColor, 'TDepth>) (color: 'TColor) (x0: int) (y0: int) (x1: int) (y1: int) (thickness: int) =
 550     img.Draw(LineSegment2D(Point(x0, y0), Point(x1, y1)), color, thickness);
 551
 552 let drawLineF (img: Image<'TColor, 'TDepth>) (color: 'TColor) (x0: float) (y0: float) (x1: float) (y1: float) (thickness: int) =
 553     img.Draw(LineSegment2DF(PointF(float32 x0, float32 y0), PointF(float32 x1, float32 y1)), color, thickness, CvEnum.LineType.AntiAlias);
 554
 555 let drawEllipse (img: Image<'TColor, 'TDepth>) (e: Types.Ellipse) (color: 'TColor) (alpha: float) =
 556
 557     if alpha >= 1.0
 558     then
 559         img.Draw(Ellipse(PointF(float32 e.Cx, float32 e.Cy), SizeF(2. * e.B |> float32, 2. * e.A |> float32), float32 <| e.Alpha / Math.PI * 180.), color, 1, CvEnum.LineType.AntiAlias)
 560     else
 561         let windowPosX = e.Cx - e.A - 5.0
 562         let gapX = windowPosX - (float (int windowPosX))
 563
 564         let windowPosY = e.Cy - e.A - 5.0
 565         let gapY = windowPosY - (float (int windowPosY))
 566
 567         let roi = Rectangle(int windowPosX, int windowPosY, 2. * (e.A + 5.0) |> int, 2.* (e.A + 5.0) |> int)
 568
 569         img.ROI <- roi
 570         if roi = img.ROI // We do not display ellipses touching the edges (FIXME)
 571         then
 572             use i = new Image<'TColor, 'TDepth>(img.ROI.Size)
 573             i.Draw(Ellipse(PointF(float32 <| (e.A + 5. + gapX) , float32 <| (e.A + 5. + gapY)), SizeF(2. * e.B |> float32, 2. * e.A |> float32), float32 <| e.Alpha / Math.PI * 180.), color, 1, CvEnum.LineType.AntiAlias)
 574             CvInvoke.AddWeighted(img, 1.0, i, alpha, 0.0, img)
 575         img.ROI <- Rectangle.Empty
 576
 577
 578 let drawEllipses (img: Image<'TColor, 'TDepth>) (ellipses: Types.Ellipse list) (color: 'TColor) (alpha: float) =
 579     List.iter (fun e -> drawEllipse img e color alpha) ellipses
 580
 581
 582 let rngCell =  System.Random()
 583 let drawCell (img: Image<Bgr, byte>) (drawCellContent: bool) (c: Types.Cell) =
 584     if drawCellContent
 585     then
 586         let colorB = rngCell.Next(20, 70)
 587         let colorG = rngCell.Next(20, 70)
 588         let colorR = rngCell.Next(20, 70)
 589
 590         for y in 0 .. c.elements.Height - 1 do
 591             for x in 0 .. c.elements.Width - 1 do
 592                 if c.elements.[y, x] > 0uy
 593                 then
 594                     let dx, dy = c.center.X - c.elements.Width / 2, c.center.Y - c.elements.Height / 2
 595                     let b = img.Data.[y + dy, x + dx, 0] |> int
 596                     let g = img.Data.[y + dy, x + dx, 1] |> int
 597                     let r = img.Data.[y + dy, x + dx, 2] |> int
 598                     img.Data.[y + dy, x + dx, 0] <- if b + colorB > 255 then 255uy else byte (b + colorB)
 599                     img.Data.[y + dy, x + dx, 1] <- if g + colorG > 255 then 255uy else byte (g + colorG)
 600                     img.Data.[y + dy, x + dx, 2] <- if r + colorR > 255 then 255uy else byte (r + colorR)
 601
 602     let crossColor, crossColor2 =
 603         match c.cellClass with
 604         | Types.HealthyRBC -> Bgr(255., 0., 0.), Bgr(255., 255., 255.)
 605         | Types.InfectedRBC -> Bgr(0., 0., 255.), Bgr(120., 120., 255.)
 606         | Types.Peculiar -> Bgr(0., 0., 0.), Bgr(80., 80., 80.)
 607
 608     drawLine img crossColor2 (c.center.X - 3) c.center.Y (c.center.X + 3) c.center.Y 2
 609     drawLine img crossColor2 c.center.X (c.center.Y - 3) c.center.X (c.center.Y + 3) 2
 610
 611     drawLine img crossColor (c.center.X - 3) c.center.Y (c.center.X + 3) c.center.Y 1
 612     drawLine img crossColor c.center.X (c.center.Y - 3) c.center.X (c.center.Y + 3) 1
 613
 614
 615 let drawCells (img: Image<Bgr, byte>) (drawCellContent: bool) (cells: Types.Cell list) =
 616     List.iter (fun c -> drawCell img drawCellContent c) cells