Skip to content
Snippets Groups Projects
Commit f4863a54 authored by evenp's avatar evenp
Browse files

Ipol: algos detailed

parent d67b6d71
No related branches found
No related tags found
No related merge requests found
......@@ -9,22 +9,23 @@
\SetKwData{dire}{$\vec{V}_E$}
\SetKwData{dst}{$W_0$}
\SetKwData{ath}{$\varepsilon$}
\SetKwData{on}{isExtending}
%\SetKwData{on}{isExtending}
%\SetKwData{nb}{$n_E$}
\SetKwData{side}{$side$}
\SetKwData{index}{$I$}
\SetKwData{ninter}{$n_I$}
\SetKwData{ntemp}{$n_J$}
\SetKwData{niside}{$n_I[side]$}
%\SetKwData{nbin}{$N_{inter}$}
\SetKwData{ntside}{$n_J[side]$}
\SetKwData{imax}{$N_I$}
\SetKwData{gdiff}{$\delta_G$}
\SetKwData{bsth}{$\mu$}
\SetKwData{bsth}{$\mu_{prev}$}
\SetKwData{nb}{$n$}
\SetKwData{pinchcount}{$n_P$}
\SetKwData{pinchdelay}{$N_P$}
\SetKwData{adsdelay}{$N_a$}
\SetKwData{devang}{$\theta_{dev}$}
\SetKwData{added}{added}
\SetKwData{added}{$added$}
\SetKwData{trial}{$i$}
\SetKwData{half}{$\frac{1}{2}$}
......@@ -38,11 +39,12 @@
\SetKwFunction{getads}{getAdaptiveDirectionalScanner}
\SetKwFunction{fscan}{firstScan}
\SetKwFunction{size}{size}
\SetKwFunction{max}{max}
\SetKwFunction{nscan}{nextScan}
\SetKwFunction{locmax}{localMax}
\SetKwFunction{grad}{gradient}
\SetKwFunction{bsinit}{initializeBS}
\SetKwFunction{bsinit}{initializeBlurredSegment}
\SetKwFunction{addpt}{addPoint}
\SetKwFunction{rempt}{removePoint}
\SetKwFunction{thickness}{thickness}
\SetKwFunction{setath}{setMaxThickness}
\SetKwFunction{ang}{angle}
......@@ -57,54 +59,67 @@
\bs \takes $\emptyset$\;
\dirn \takes \ortho(\dsd, \dire)
\Comment*{Gets test gradient direction
\dirn $\perp$ \dsd, \dirn$\cdot$\dire $>$ 0}
\ds \takes \getads (\dsc, \dsd, \dst) \Comment*{Gets an ADS from input scan}
\Comment*{Gets test gradient direction:
\dirn $\perp$ \dsd, \dirn$\cdot$\dire $> 0$}
\ds \takes \getads (\dsc, \dsd, \dst) \Comment*{Gets an ADS from input scan.}
\scan \takes \fscan (\ds)\;
\index \takes \locmax (\scan, \gmap, \gdiff, \vmap, \dirn)
\Comment*{Gets index of pixels with oriented gradient local max}
\If{\size(\index) $\neq$ 0}{
\bs \takes \bsinit (\scan$[$\index$[$0$]]$, \ath)
\Comment*{Gets index of pixels with oriented gradient local max.}
\nb \takes 0\;
\pinchcount \takes 0\;
\ninter \takes (0, 0)\;
\While{\ninter $\neq$ (\imax, \imax)}{
\nb \takes \nb + 1\;
\If{\size(\index) $\neq 0$}{
\nb \takes $0$,
\pinchcount \takes $0$\;
\ninter \takes $(0, 0)$,
\ntemp \takes $(0, 0)$\;
\bsinit (\bs, \scan$[$\index$[0]]$, \ath)\;
\While{\ninter $-$ \ntemp $\neq$ (\imax, \imax)}{
\nb \takes \nb $+$ $1$\;
\bsth \takes \thickness(\bs)\;
\If{\pinchcount = \pinchdelay}{
\setath (\bs, \thickness(\bs + \half))\;
\setath (\bs, \max (\ath, \thickness(\bs) + \half))\;
}
\If{\nb $>$ \adsdelay}{
\If{\nb = \adsdelay + 1 and \angle(\dir(\bs),\dsd) $>$ \devang}{
\on \takes (false, false) \Comment*{Too large deviation}
\If{\nb = \adsdelay $+$ $1$ and \angle(\dir(\bs),\dsd) $>$ \devang}{
\niside \takes \ntside $+$ (\imax, \imax)
\Comment*{Too large deviation}
}
\alignds(\ds,\centerline(\bs))
\Comment*{Aligns scan stripe on blurred segment.}
}
\ForEach{\side}{
\If{\niside $\leq$ \imax}{
\If{\niside $-$ \ntside $\leq$ \imax}{
\scan \takes \nscan (\ds, \side)\;
\index \takes \locmax (\scan, \gmap, \gdiff, \vmap, \dirn)\;
\trial \takes false\;
\added \takes false\;
\While{\added = false and \trial $<$ \size(\index)}{
\trial \takes $0$\;
\added \takes $false$\;
\While{\added $=$ false and \trial $<$ \size(\index)}{
\added \takes \addpt (\bs, \scan$[$\index$[$\trial$]]$)
\Comment*{Tests BS extension}
\trial \takes \trial + 1\;
\Comment*{Tries blurred segment extension.}
\trial \takes \trial $+$ $1$\;
}
\pinchcount \takes \pinchcount + 1\;
\pinchcount \takes \pinchcount $+$ $1$\;
\eIf{\added}{
\If{\pinchcount $<$ \pinchdelay and \bsth $<$ \thickness(\bs)}{
\pinchcount \takes 0 \Comment*{Not yet stabilized.}
\pinchcount \takes $0$ \Comment*{Not yet stabilized.}
}
\If{\niside $\neq$ $0$}{
\ntside \takes \ntside $+$ $1$\;
\If{\niside $=$ \ntside}{
\ntside \takes $0$,
\niside \takes $0$
\Comment*{Validates last added points.}
}
}
\niside \takes 0 \Comment*{Resets fail count.}
}{
\niside \takes \niside + 1 \Comment*{Increments fail count.}
\niside \takes \niside $+$ $1$ \Comment*{Increments fail count.}
}
}
}
}
\ForEach{\side}{
\rempt (\bs, \side, \ntside)
\Comment*{Removes not yet validated points.}
}
}
\label{algo:final}
\end{algorithm}
......@@ -5,9 +5,9 @@
\SetKwData{takes}{$\leftarrow$}
\SetKwData{is}{$P_1P_2$}
\SetKwData{ath}{$\varepsilon$}
\SetKwData{on}{isExtending}
\SetKwData{nb}{$n_E$}
\SetKwData{side}{side}
%\SetKwData{on}{isExtending}
\SetKwData{nb}{$n$}
\SetKwData{side}{$side$}
\SetKwData{index}{$i$}
\SetKwData{ninter}{$n_I$}
\SetKwData{niside}{$n_I[side]$}
......@@ -23,9 +23,9 @@
\SetKwFunction{getds}{getDirectionalScanner}
\SetKwFunction{fscan}{firstScan}
\SetKwFunction{nscan}{nextScan}
\SetKwFunction{largest}{atLargest}
\SetKwFunction{largest}{atLargestGradient}
\SetKwFunction{grad}{gradient}
\SetKwFunction{bsinit}{initializeBS}
\SetKwFunction{bsinit}{initializeBlurredSegment}
\SetKwFunction{addpt}{addPoint}
\Input{gradient magnitude map \gmap,
......@@ -33,32 +33,29 @@
\Output{a detected blurred segment \bs}
\bs \takes $\emptyset$\;
\ds \takes \getds (\is)
\Comment*{Gets a DS from input segment.}
\ds \takes \getds (\is) \Comment*{Gets a DS from input segment.}
\scan \takes \fscan (\ds)\;
\index \takes \largest (\scan, \gmap, \gmin)
\Comment*{Gets index of pixel with max gradient.}
\If{\grad(\gmap$[$\scan$[$\index$]]$) $\geq$ \gmin}{
\bs \takes \bsinit (\scan$[$\index$]$, \ath)
\nb \takes 0\;
\ninter \takes (0, 0)
\Comment*{One counter for each side.}
\While{\ninter $\neq$ (\imax, \imax) and \nb $\neq$ \nmax
\Comment*{No more than \nmax extent.}}{
\nb \takes \nmax
\Comment*{Limits the blurred segment extension.}
\ninter \takes ($0$, $0$) \Comment*{One counter for each side.}
\bsinit (\bs, \scan$[$\index$]$, \ath)\;
\While{\ninter $\neq$ (\imax, \imax) and \nb $\neq$ $0$}{
\ForEach{\side}{
\If{\niside $\leq$ \imax}{
\scan \takes \nscan (\ds, \side)\;
\index \takes \largest (\scan, \gmap)\;
\eIf{\addpt (\bs, \scan$[$\index$]$) \Comment*{Tests BS extension.}}{
\niside \takes 0 \Comment*{Resets fail count.}
\niside \takes $0$ \Comment*{Resets fail count.}
}{
\niside \takes \niside + 1
\niside \takes \niside $+$ $1$
\Comment*{Increments fail count.}
}
}
}
\nb \takes \nb + 1
\nb \takes \nb $-$ $1$
\Comment*{Increments extension count.}
}
}
......
\begin{algorithm}[!htbp]
\caption{detectBlurredSegment}
\DontPrintSemicolon
\SetKwData{takes}{$\leftarrow$}
\SetKwData{is}{$P_1P_2$}
\SetKwData{ath}{$\varepsilon$}
\SetKwData{minsize}{$S_{min}$}
\SetKwData{crossang}{$\alpha_{min}$}
\SetKwData{vecbs}{$\vec{D}$}
\SetKwData{nb}{$n$}
\SetKwData{ang}{$angle$}
\SetKwData{bsstart}{$P$}
\SetKwData{dire}{$\vec{V}_E$}
\SetKwData{centerpt}{$C$}
%\SetKwData{imax}{$N_I$}
\SetKwArray{gmap}{$\mathcal{G}$}
\SetKwArray{vmap}{$\mathcal{V}$}
\SetKwArray{bs}{$\mathcal{B}$}
\SetKwFunction{fasttrack}{fastTrack}
\SetKwFunction{finetrack}{fineTrack}
\SetKwData{size}{$size$}
\SetKwData{extent}{$extent$}
\SetKwFunction{dir}{direction}
\SetKwFunction{startpt}{startPoint}
\SetKwFunction{centerline}{centerLine}
\Input{gradient magnitude map \gmap, gradient orientation map \vmap,
input segment \is, assigned thickness \ath}
\Output{a detected blurred segment \bs}
\bs \takes \fasttrack (\gmap, \is, \ath)
\Comment*{Gets rough initial solution.}
\eIf{\size (\bs) $<$ \minsize}{
\bs \takes $\emptyset$ \Comment*{Not enough points.}
}{
\eIf{\size(\bs) $<$ \extent(\bs) $/$ $2$}{
\bs \takes $\emptyset$ \Comment*{Not dense enough.}
}{
\vecbs \takes \dir(\bs)\;
\eIf{\ang (\vecbs, \is) $<$ \crossang}{
\bs \takes $\emptyset$ \Comment*{BS direction too close to \is.}
}{
\bsstart \takes \startpt (\bs)\;
\dire \takes \vmap $[$ \bsstart $]$\;
\centerpt \takes \centerline (\bs) $\cup$ \is\;
\bs \takes \finetrack (\gmap, \vmap, \centerpt, \vecbs, $2$ \ath, \ath, \dire)
\Comment*{Runs fine tracking.}
\If{\size (\bs) $<$ \minsize}{
\bs \takes $\emptyset$ \Comment*{Not enough points.}
}
}
}
}
\label{algo:single}
\end{algorithm}
......@@ -19,11 +19,18 @@ supervised control tasks.
The input of this step is a line segment, the input stroke,
and the output is a blurred segment crossed by the input stroke.
The method is depicted in algorithm~\ref{algo:initial}.
The process is detailed in algorithm~\ref{algo:initial}.
Candidate points for blurred segment extension are selected on the basis
of maximal gradient magnitude.
Because the goal is to provide an initial incomplete solution, the blurred
segment is bounded to a small size.
Further extension is considered as useless.
On each side, the process stops after a fixed amount of successive extension
fails.
\input{Algos/algoInitial}
Three parameters are used in this step :
Three parameters are used in this step:
a minimal gradient magnitude $G_{min}$ to select candidates,
a maximal extent $N_E$ of the blurred segment,
and a maximal count $N_I$ of successive extent fails.
......@@ -34,24 +41,45 @@ that can be adjusted according to the application context.
\subsection{Fine tracking step of single extraction}
The input of this step is the direction of the rough blurred segment
provided by the initial detection, and the output is a finer blurred segment
obtained by
\begin{itemize}
\item more candidates based on local gradient magnitude,
\item constrained gradient orientation when selecting candidates,
\item adaptation of the scan stripe direction,
\item pinch of assigned thickness to the detected blurred segment thickness.
\end{itemize}
The method is depicted in algorithm~\ref{algo:final}.
provided by the initial detection, and the output is a refined solution.
The process is detailed in algorithm~\ref{algo:final}.
A new blurred segment is created and extended, but this time, all local
maxima of gradient magnitude found in the scan are tested untill a valid
one is found. Moreover the gradient orientation is checked when selecting
candidate points, using a rather strict maximal deviation value.
In order to avoid early stops when the detected segment escapes from the
scan stripe, the directional scanner is aligned on the blurred segment
center line at each step. This alignment is only performed after a
predefined number of steps when the blurred segment direction gets
stable enough.
\input{Algos/algoFinal}
Three new parameters are used in this step :
Moreover when the growing segment stops thickenning, the assigned maximal
thickness of the recognition algorithm is pinched to a near value to
the observed thickness. This pinch procedure avoids further inclusion of
outliers, in particular when sharper edges lye quite close to or even across
(shadows) the detected blurred segment.
The half pixel ratio allows to take into account all the possible directions
of the blurred segment inferred from current configuration.
Finally, when any extension fail occurs, the amount of later successful
extensions must coincide to the fail count to validate these points.
This condition helps to detect more accurate segment ends.
Three new parameters are used in this step:
a gradient height $\delta_G$ to discriminate local gradient maxima,
a minimal count $N_P$ of successive extents without blurred segment thickening,
and a minimal extent $N_A$ before recentering the scan stripe.
Nominal values are proposed for all of them.
\subsection{Single blurred segment extraction}
The blurred segment extraction calls the initial detection, then the fine
tracking steps and applies optional validation tests to the output segment.
It is detailed in algorithm~/ref{algo:single}.
\input{Algos/algoSingle}
\subsection{Multiple extraction}
\subsection{Automatic extraction}
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment