open Emgu.CV
open Emgu.CV.Structure
-open Utils
open Heap
+open Const
+open Utils
// Normalize image values between 0uy and 255uy.
-let normalizeAndConvert (img: Image<Gray, float32>) : Image<Gray, byte> =
+let normalizeAndConvert (img: Image<Gray, 'TDepth>) : Image<Gray, byte> =
let min = ref [| 0.0 |]
let minLocation = ref <| [| Point() |]
let max = ref [| 0.0 |]
let maxLocation = ref <| [| Point() |]
img.MinMax(min, max, minLocation, maxLocation)
- ((img - (!min).[0]) / ((!max).[0] - (!min).[0]) * 255.0).Convert<Gray, byte>()
+ ((img.Convert<Gray, float32>() - (!min).[0]) / ((!max).[0] - (!min).[0]) * 255.0).Convert<Gray, byte>()
let saveImg (img: Image<'TColor, 'TDepth>) (filepath: string) =
saveImg img filepath
+type Histogram = { data: int[]; total: int; sum: int; min: float32; max: float32 }
+
+let histogramImg (img: Image<Gray, float32>) (nbSamples: int) : Histogram =
+ let imgData = img.Data
+
+ let min, max =
+ let min = ref [| 0.0 |]
+ let minLocation = ref <| [| Point() |]
+ let max = ref [| 0.0 |]
+ let maxLocation = ref <| [| Point() |]
+ img.MinMax(min, max, minLocation, maxLocation)
+ float32 (!min).[0], float32 (!max).[0]
+
+ let bin (x: float32) : int =
+ let p = int ((x - min) / (max - min) * float32 nbSamples)
+ if p >= nbSamples then nbSamples - 1 else p
+
+ let data = Array.zeroCreate nbSamples
+
+ for i in 0 .. img.Height - 1 do
+ for j in 0 .. img.Width - 1 do
+ let p = bin imgData.[i, j, 0]
+ data.[p] <- data.[p] + 1
+
+ { data = data; total = img.Height * img.Width; sum = Array.sum data; min = min; max = max }
+
+let histogramMat (mat: Matrix<float32>) (nbSamples: int) : Histogram =
+ let matData = mat.Data
+
+ let min, max =
+ let min = ref 0.0
+ let minLocation = ref <| Point()
+ let max = ref 0.0
+ let maxLocation = ref <| Point()
+ mat.MinMax(min, max, minLocation, maxLocation)
+ float32 !min, float32 !max
+
+ let bin (x: float32) : int =
+ let p = int ((x - min) / (max - min) * float32 nbSamples)
+ if p >= nbSamples then nbSamples - 1 else p
+
+ let data = Array.zeroCreate nbSamples
+
+ for i in 0 .. mat.Height - 1 do
+ for j in 0 .. mat.Width - 1 do
+ let p = bin matData.[i, j]
+ data.[p] <- data.[p] + 1
+
+ { data = data; total = mat.Height * mat.Width; sum = Array.sum data; min = min; max = max }
+
+let histogram (values: float32 seq) (nbSamples: int) : Histogram =
+ let mutable min = Single.MaxValue
+ let mutable max = Single.MinValue
+ let mutable n = 0
+
+ for v in values do
+ n <- n + 1
+ if v < min then min <- v
+ if v > max then max <- v
+
+ let bin (x: float32) : int =
+ let p = int ((x - min) / (max - min) * float32 nbSamples)
+ if p >= nbSamples then nbSamples - 1 else p
+
+ let data = Array.zeroCreate nbSamples
+
+ for v in values do
+ let p = bin v
+ data.[p] <- data.[p] + 1
+
+ { data = data; total = n; sum = Array.sum data; min = min; max = max }
+
+let otsu (hist: Histogram) : float32 * float32 * float32 =
+ let mutable sumB = 0
+ let mutable wB = 0
+ let mutable maximum = 0.0
+ let mutable level = 0
+ let sum = hist.data |> Array.mapi (fun i v -> i * v) |> Array.sum |> float
+
+ for i in 0 .. hist.data.Length - 1 do
+ wB <- wB + hist.data.[i]
+ if wB <> 0
+ then
+ let wF = hist.total - wB
+ if wF <> 0
+ then
+ sumB <- sumB + i * hist.data.[i]
+ let mB = (float sumB) / (float wB)
+ let mF = (sum - float sumB) / (float wF)
+ let between = (float wB) * (float wF) * (mB - mF) ** 2.;
+ if between >= maximum
+ then
+ level <- i
+ maximum <- between
+
+ let mean1 =
+ let mutable sum = 0
+ let mutable nb = 0
+ for i in 0 .. level - 1 do
+ sum <- sum + i * hist.data.[i]
+ nb <- nb + hist.data.[i]
+ (sum + level * hist.data.[level] / 2) / (nb + hist.data.[level] / 2)
+
+ let mean2 =
+ let mutable sum = 0
+ let mutable nb = 0
+ for i in level + 1 .. hist.data.Length - 1 do
+ sum <- sum + i * hist.data.[i]
+ nb <- nb + hist.data.[i]
+ (sum + level * hist.data.[level] / 2) / (nb + hist.data.[level] / 2)
+
+ let toFloat l =
+ float32 l / float32 hist.data.Length * (hist.max - hist.min) + hist.min
+
+ toFloat level, toFloat mean1, toFloat mean2
+
+
let suppressMConnections (img: Matrix<byte>) =
let w = img.Width
let h = img.Height
then
img.[i, j] <- 0uy
-let findEdges (img: Image<Gray, float32>) : Matrix<byte> * Image<Gray, float> * Image<Gray, float> =
+
+let findEdges (img: Image<Gray, float32>) : Matrix<byte> * Image<Gray, float32> * Image<Gray, float32> =
let w = img.Width
let h = img.Height
[ 2.0f; 0.0f; -2.0f ]
[ 1.0f; 0.0f; -1.0f ]], Point(1, 1))
- let xGradient = img.Convolution(sobelKernel).Convert<Gray, float>()
- let yGradient = img.Convolution(sobelKernel.Transpose()).Convert<Gray, float>()
+ let xGradient = img.Convolution(sobelKernel)
+ let yGradient = img.Convolution(sobelKernel.Transpose())
let xGradientData = xGradient.Data
let yGradientData = yGradient.Data
for r in 0 .. h - 1 do
- xGradientData.[r, 0, 0] <- 0.0
- xGradientData.[r, w - 1, 0] <- 0.0
- yGradientData.[r, 0, 0] <- 0.0
- yGradientData.[r, w - 1, 0] <- 0.0
+ xGradientData.[r, 0, 0] <- 0.f
+ xGradientData.[r, w - 1, 0] <- 0.f
+ yGradientData.[r, 0, 0] <- 0.f
+ yGradientData.[r, w - 1, 0] <- 0.f
for c in 0 .. w - 1 do
- xGradientData.[0, c, 0] <- 0.0
- xGradientData.[h - 1, c, 0] <- 0.0
- yGradientData.[0, c, 0] <- 0.0
- yGradientData.[h - 1, c, 0] <- 0.0
+ xGradientData.[0, c, 0] <- 0.f
+ xGradientData.[h - 1, c, 0] <- 0.f
+ yGradientData.[0, c, 0] <- 0.f
+ yGradientData.[h - 1, c, 0] <- 0.f
- use magnitudes = new Matrix<float>(xGradient.Size)
- use angles = new Matrix<float>(xGradient.Size)
+ use magnitudes = new Matrix<float32>(xGradient.Size)
+ use angles = new Matrix<float32>(xGradient.Size)
CvInvoke.CartToPolar(xGradient, yGradient, magnitudes, angles) // Compute the magnitudes (without angles).
let thresholdHigh, thresholdLow =
- let sensibility = 0.1
+ let sensibilityHigh = 0.1f
+ let sensibilityLow = 0.0f
use magnitudesByte = magnitudes.Convert<byte>()
- let threshold = CvInvoke.Threshold(magnitudesByte, magnitudesByte, 0.0, 1.0, CvEnum.ThresholdType.Otsu ||| CvEnum.ThresholdType.Binary)
- threshold + (sensibility * threshold), threshold - (sensibility * threshold)
+ let threshold, _, _ = otsu (histogramMat magnitudes 300)
+ threshold + (sensibilityHigh * threshold), threshold - (sensibilityLow * threshold)
// Non-maximum suppression.
use nms = new Matrix<byte>(xGradient.Size)
+ let nmsData = nms.Data
+ let anglesData = angles.Data
+ let magnitudesData = magnitudes.Data
+ let xGradientData = xGradient.Data
+ let yGradientData = yGradient.Data
+
+ let PI = float32 Math.PI
+
for i in 0 .. h - 1 do
- nms.Data.[i, 0] <- 0uy
- nms.Data.[i, w - 1] <- 0uy
+ nmsData.[i, 0] <- 0uy
+ nmsData.[i, w - 1] <- 0uy
for j in 0 .. w - 1 do
- nms.Data.[0, j] <- 0uy
- nms.Data.[h - 1, j] <- 0uy
+ nmsData.[0, j] <- 0uy
+ nmsData.[h - 1, j] <- 0uy
for i in 1 .. h - 2 do
for j in 1 .. w - 2 do
- let vx = xGradient.Data.[i, j, 0]
- let vy = yGradient.Data.[i, j, 0]
- if vx <> 0. || vy <> 0.
+ let vx = xGradientData.[i, j, 0]
+ let vy = yGradientData.[i, j, 0]
+ if vx <> 0.f || vy <> 0.f
then
- let angle = angles.[i, j]
+ let angle = anglesData.[i, j]
let vx', vy' = abs vx, abs vy
let ratio2 = if vx' > vy' then vy' / vx' else vx' / vy'
- let ratio1 = 1. - ratio2
-
- let mNeigbors (sign: int) : float =
- if angle < Math.PI / 4.
- then
- ratio1 * magnitudes.Data.[i, j + sign] + ratio2 * magnitudes.Data.[i + sign, j + sign]
- elif angle < Math.PI / 2.
- then
- ratio2 * magnitudes.Data.[i + sign, j + sign] + ratio1 * magnitudes.Data.[i + sign, j]
- elif angle < 3.0 * Math.PI / 4.
- then
- ratio1 * magnitudes.Data.[i + sign, j] + ratio2 * magnitudes.Data.[i + sign, j - sign]
- elif angle < Math.PI
- then
- ratio2 * magnitudes.Data.[i + sign, j - sign] + ratio1 * magnitudes.Data.[i, j - sign]
- elif angle < 5. * Math.PI / 4.
- then
- ratio1 * magnitudes.Data.[i, j - sign] + ratio2 * magnitudes.Data.[i - sign, j - sign]
- elif angle < 3. * Math.PI / 2.
- then
- ratio2 * magnitudes.Data.[i - sign, j - sign] + ratio1 * magnitudes.Data.[i - sign, j]
- elif angle < 7. * Math.PI / 4.
- then
- ratio1 * magnitudes.Data.[i - sign, j] + ratio2 * magnitudes.Data.[i - sign, j + sign]
- else
- ratio2 * magnitudes.Data.[i - sign, j + sign] + ratio1 * magnitudes.Data.[i, j + sign]
-
- let m = magnitudes.Data.[i, j]
+ let ratio1 = 1.f - ratio2
+
+ let mNeigbors (sign: int) : float32 =
+ if angle < PI / 4.f
+ then ratio1 * magnitudesData.[i, j + sign] + ratio2 * magnitudesData.[i + sign, j + sign]
+ elif angle < PI / 2.f
+ then ratio2 * magnitudesData.[i + sign, j + sign] + ratio1 * magnitudesData.[i + sign, j]
+ elif angle < 3.f * PI / 4.f
+ then ratio1 * magnitudesData.[i + sign, j] + ratio2 * magnitudesData.[i + sign, j - sign]
+ elif angle < PI
+ then ratio2 * magnitudesData.[i + sign, j - sign] + ratio1 * magnitudesData.[i, j - sign]
+ elif angle < 5.f * PI / 4.f
+ then ratio1 * magnitudesData.[i, j - sign] + ratio2 * magnitudesData.[i - sign, j - sign]
+ elif angle < 3.f * PI / 2.f
+ then ratio2 * magnitudesData.[i - sign, j - sign] + ratio1 * magnitudesData.[i - sign, j]
+ elif angle < 7.f * PI / 4.f
+ then ratio1 * magnitudesData.[i - sign, j] + ratio2 * magnitudesData.[i - sign, j + sign]
+ else ratio2 * magnitudesData.[i - sign, j + sign] + ratio1 * magnitudesData.[i, j + sign]
+
+ let m = magnitudesData.[i, j]
if m >= thresholdLow && m > mNeigbors 1 && m > mNeigbors -1
then
- nms.Data.[i, j] <- 1uy
+ nmsData.[i, j] <- 1uy
// suppressMConnections nms // It's not helpful for the rest of the process (ellipse detection).
let edges = new Matrix<byte>(xGradient.Size)
+ let edgesData = edges.Data
- // Histeresis thresholding.
+ // Hysteresis thresholding.
let toVisit = Stack<Point>()
for i in 0 .. h - 1 do
for j in 0 .. w - 1 do
- if nms.Data.[i, j] = 1uy && magnitudes.Data.[i, j] >= thresholdHigh
+ if nmsData.[i, j] = 1uy && magnitudesData.[i, j] >= thresholdHigh
then
- nms.Data.[i, j] <- 0uy
+ nmsData.[i, j] <- 0uy
toVisit.Push(Point(j, i))
while toVisit.Count > 0 do
let p = toVisit.Pop()
- edges.Data.[p.Y, p.X] <- 1uy
+ edgesData.[p.Y, p.X] <- 1uy
for i' in -1 .. 1 do
for j' in -1 .. 1 do
if i' <> 0 || j' <> 0
then
let ni = p.Y + i'
let nj = p.X + j'
- if ni >= 0 && ni < h && nj >= 0 && nj < w && nms.Data.[ni, nj] = 1uy
+ if ni >= 0 && ni < h && nj >= 0 && nj < w && nmsData.[ni, nj] = 1uy
then
- nms.Data.[ni, nj] <- 0uy
+ nmsData.[ni, nj] <- 0uy
toVisit.Push(Point(nj, ni))
edges, xGradient, yGradient
nextElements.Add(p) |> ignore
else
- let m' = pixels.[p.Y, p.X]
- if m' <> null
- then
+ match pixels.[p.Y, p.X] with
+ | null -> ()
+ | m' ->
if m'.Elements.Count + m.Elements.Count <= area
then
m'.State <- AreaState.Removed
member val Surface = 0 with get, set
-let private areaOperationF (img: Image<Gray, float32>) (area: int) (op: AreaOperation) =
+let private areaOperationF (img: Image<Gray, float32>) (areas: (int * 'a) list) (f: ('a -> float32 -> unit) option) (op: AreaOperation) =
let w = img.Width
let h = img.Height
let earth = img.Data
let ni = i + p.Y
let nj = j + p.X
let neighbor = Point(nj, ni)
- if ni >= 0 && ni < h && nj >= 0 && nj < w && ownership.[ni, nj] = null && not (shorePoints.Contains(neighbor))
+ if ni >= 0 && ni < h && nj >= 0 && nj < w && Object.ReferenceEquals(ownership.[ni, nj], null) && not (shorePoints.Contains(neighbor))
then
shorePoints.Add(neighbor) |> ignore
island.Shore.Add earth.[ni, nj, 0] neighbor
- for island in islands do
- let mutable stop = island.Shore.IsEmpty
-
- // 'true' if 'p' is owned or adjacent to 'island'.
- let ownedOrAdjacent (p: Point) : bool =
- ownership.[p.Y, p.X] = island ||
- (p.Y > 0 && ownership.[p.Y - 1, p.X] = island) ||
- (p.Y < h - 1 && ownership.[p.Y + 1, p.X] = island) ||
- (p.X > 0 && ownership.[p.Y, p.X - 1] = island) ||
- (p.X < w - 1 && ownership.[p.Y, p.X + 1] = island)
-
- while not stop && island.Surface < area do
- let level, next = island.Shore.Max
- let other = ownership.[next.Y, next.X]
- if other = island // During merging, some points on the shore may be owned by the island itself -> ignored.
- then
- island.Shore.RemoveNext ()
- else
- if other <> null
- then // We touching another island.
- if island.Surface + other.Surface >= area
- then
- stop <- true
- else // We can merge 'other' into 'surface'.
- island.Surface <- island.Surface + other.Surface
- island.Level <- if comparer.Compare(island.Level, other.Level) > 0 then island.Level else other.Level
- for l, p in other.Shore do
- let mutable currentY = p.Y + 1
- while currentY < h && ownership.[currentY, p.X] = other do
- ownership.[currentY, p.X] <- island
- currentY <- currentY + 1
- island.Shore.Add l p
- other.Shore.Clear()
-
- elif comparer.Compare(level, island.Level) > 0
+ for area, obj in areas do
+ for island in islands do
+ let mutable stop = island.Shore.IsEmpty
+
+ // 'true' if 'p' is owned or adjacent to 'island'.
+ let inline ownedOrAdjacent (p: Point) : bool =
+ ownership.[p.Y, p.X] = island ||
+ (p.Y > 0 && ownership.[p.Y - 1, p.X] = island) ||
+ (p.Y < h - 1 && ownership.[p.Y + 1, p.X] = island) ||
+ (p.X > 0 && ownership.[p.Y, p.X - 1] = island) ||
+ (p.X < w - 1 && ownership.[p.Y, p.X + 1] = island)
+
+ while not stop && island.Surface < area do
+ let level, next = island.Shore.Max
+ let other = ownership.[next.Y, next.X]
+ if other = island // During merging, some points on the shore may be owned by the island itself -> ignored.
then
- stop <- true
- else
island.Shore.RemoveNext ()
- for i, j in se do
- let ni = i + next.Y
- let nj = j + next.X
- if ni < 0 || ni >= h || nj < 0 || nj >= w
+ else
+ if not <| Object.ReferenceEquals(other, null)
+ then // We touching another island.
+ if island.Surface + other.Surface >= area
then
- island.Surface <- Int32.MaxValue
stop <- true
- else
- let neighbor = Point(nj, ni)
- if not <| ownedOrAdjacent neighbor
- then
- island.Shore.Add earth.[ni, nj, 0] neighbor
- if not stop
+ else // We can merge 'other' into 'surface'.
+ island.Surface <- island.Surface + other.Surface
+ island.Level <- if comparer.Compare(island.Level, other.Level) > 0 then island.Level else other.Level
+ for l, p in other.Shore do
+ let mutable currentY = p.Y + 1
+ while currentY < h && ownership.[currentY, p.X] = other do
+ ownership.[currentY, p.X] <- island
+ currentY <- currentY + 1
+ island.Shore.Add l p
+ other.Shore.Clear()
+
+ elif comparer.Compare(level, island.Level) > 0
then
- ownership.[next.Y, next.X] <- island
- island.Level <- level
- island.Surface <- island.Surface + 1
-
- for i in 0 .. h - 1 do
- for j in 0 .. w - 1 do
- let island = ownership.[i, j]
- if island <> null
- then
- earth.[i, j, 0] <- island.Level
+ stop <- true
+ else
+ island.Shore.RemoveNext ()
+ for i, j in se do
+ let ni = i + next.Y
+ let nj = j + next.X
+ if ni < 0 || ni >= h || nj < 0 || nj >= w
+ then
+ island.Surface <- Int32.MaxValue
+ stop <- true
+ else
+ let neighbor = Point(nj, ni)
+ if not <| ownedOrAdjacent neighbor
+ then
+ island.Shore.Add earth.[ni, nj, 0] neighbor
+ if not stop
+ then
+ ownership.[next.Y, next.X] <- island
+ island.Level <- level
+ island.Surface <- island.Surface + 1
+
+ let mutable diff = 0.f
+
+ for i in 0 .. h - 1 do
+ for j in 0 .. w - 1 do
+ match ownership.[i, j] with
+ | null -> ()
+ | island ->
+ let l = island.Level
+ diff <- diff + l - earth.[i, j, 0]
+ earth.[i, j, 0] <- l
+
+ match f with
+ | Some f' -> f' obj diff
+ | _ -> ()
()
let areaOpenF (img: Image<Gray, float32>) (area: int) =
- areaOperationF img area AreaOperation.Opening
+ areaOperationF img [ area, () ] None AreaOperation.Opening
let areaCloseF (img: Image<Gray, float32>) (area: int) =
- areaOperationF img area AreaOperation.Closing
+ areaOperationF img [ area, () ] None AreaOperation.Closing
+
+let areaOpenFWithFun (img: Image<Gray, float32>) (areas: (int * 'a) list) (f: 'a -> float32 -> unit) =
+ areaOperationF img areas (Some f) AreaOperation.Opening
+
+let areaCloseFWithFun (img: Image<Gray, float32>) (areas: (int * 'a) list) (f: 'a -> float32 -> unit) =
+ areaOperationF img areas (Some f) AreaOperation.Closing
// A simpler algorithm than 'areaOpen' but slower.
let areaOpen2 (img: Image<Gray, byte>) (area: int) =
( 0, -1) // p8
(-1, -1) |] // p9
- let mat' = new Matrix<byte>(mat.Size)
+ use mat' = new Matrix<byte>(mat.Size)
let w = mat'.Width
let h = mat'.Height
mat.CopyTo(mat')
if alpha >= 1.0
then
- 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)
+ img.Draw(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)
else
- let windowPosX = e.Cx - e.A - 5.0
- let gapX = windowPosX - (float (int windowPosX))
+ let windowPosX = e.Cx - e.A - 5.f
+ let gapX = windowPosX - (float32 (int windowPosX))
- let windowPosY = e.Cy - e.A - 5.0
- let gapY = windowPosY - (float (int windowPosY))
+ let windowPosY = e.Cy - e.A - 5.f
+ let gapY = windowPosY - (float32 (int windowPosY))
- let roi = Rectangle(int windowPosX, int windowPosY, 2. * (e.A + 5.0) |> int, 2.* (e.A + 5.0) |> int)
+ let roi = Rectangle(int windowPosX, int windowPosY, 2.f * (e.A + 5.f) |> int, 2.f * (e.A + 5.f) |> int)
img.ROI <- roi
if roi = img.ROI // We do not display ellipses touching the edges (FIXME)
then
use i = new Image<'TColor, 'TDepth>(img.ROI.Size)
- 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)
+ i.Draw(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)
CvInvoke.AddWeighted(img, 1.0, i, alpha, 0.0, img)
img.ROI <- Rectangle.Empty
projects / master-thesis.git / blobdiff