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) =
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.1f
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 = float32 <| CvInvoke.Threshold(magnitudesByte, magnitudesByte, 0.0, 1.0, CvEnum.ThresholdType.Otsu ||| CvEnum.ThresholdType.Binary)
+ 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
( 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