\documentclass[english,11pt,table,handout]{beamer}

\input{dsa-style.tex}
\usepackage{pgf}

\newcommand{\Rule}[2]{\genfrac{}{}{0.7pt}{}{{\setlength{\fboxrule}{0pt}\setlength{\fboxsep}{3mm}\fbox{$#1$}}}{{\setlength{\fboxrule}{0pt}\setlength{\fboxsep}{3mm}\fbox{$#2$}}}}

\newcommand{\Rulee}[3]{\genfrac{}{}{0.7pt}{}{{\setlength{\fboxrule}{0pt}\setlength{\fboxsep}{3mm}\fbox{$#1$}}}{{\setlength{\fboxrule}{0pt}\setlength{\fboxsep}{3mm}\fbox{$#2$}}}[#3]}

\usepackage{url}

\usepackage{qtree}

\usepackage{datetime}

\usepackage{amsfonts}
\usepackage{mathtools}
\usepackage{fancybox}
\usepackage[linesnumbered]{algorithm2e}
\usepackage{ragged2e}
\usepackage{pgfplots}

\lecture[3]{Local Processing on Images}{lecture-text}

% \subtitle{Sequence Control}

\date{09 September 2015}
\newcounter{saveenumi}

\usepackage{wrapfig}
\usetikzlibrary{automata,arrows,positioning, chains, shapes.callouts, calc}

\tikzstyle{mnode}=[circle, draw, fill=black, inner sep=0pt, minimum width=4pt]
\tikzstyle{thinking} = [draw=blue, very thick]
\edef\sizetape{1cm}
\tikzstyle{tmtape}=[draw,minimum size=\sizetape]
\tikzstyle{tmhead}=[arrow box,draw,minimum size=.5cm,arrow box
arrows={east:.25cm, west:0.25cm}]
\tikzset{
  level/.style   = { ultra thick, blue },
  connect/.style = { dashed, red },
  notice/.style  = { draw, rectangle callout, callout relative pointer={#1} },
  label/.style   = { text width=4cm }
}

\begin{document}

\begin{frame}
\selectlanguage{english}
  \maketitle
\end{frame}

\begin{frame}\frametitle<presentation>{Overview}
  \tableofcontents
\end{frame}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\frame
{
	\frametitle{Sources of slides}
	\begin{alertblock}{Sources}
		This presentation uses figures, slides and information from the following sources:
		\begin{enumerate}
			\item Rafael C. Gonzalez, Richard E. Woods, "Digital Image Processing", $2^{nd}$ Editions.
			\item Maria Petrou and Costas Petrou, "Image Processing: The Fundamentals", $2^{nd}$ Editions.
			\item Slides of Course "CS 4640: Image Processing Basics", from Utah University.
		\end{enumerate}
	
	\end{alertblock}
}
\section{Local processing}
\frame
{
	\Huge
	\begin{center}
	\textcolor{blue}{\textbf{What is local processing?}}
	\end{center}
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\frame
{
  \frametitle{What is local processing?}
	\selectlanguage{english}
	\begin{block}{Definition}
		Local processing is an image operation where each pixel value $I(u, v)$ is changed by a \alert{\textbf{function}} of the intensities of pixels in a \alert{\textbf{neighborhood}} of the pixel $(u, v)$.
	\end{block}
		
	\begin{figure}[!h]
   	\includegraphics[scale=0.5]{localproc.png}
	\end{figure}
}

\frame
{
	\frametitle{What is local processing?}
	\selectlanguage{english}
	\begin{example}
		\begin{itemize}
			\item An image $I(u,v)$; a pixel $(u,v)$ and its neighborhood of $3\times 3 $ pixels
		\end{itemize}
		\centering
		\begin{figure}[!h]
			\includegraphics[scale=0.5]{neighborhood.png}
			\caption{Example of neighborhood}
		\end{figure}
	\end{example}
	
}

\frame
{
	\frametitle{What is local processing?}
	\begin{example}{Examples of some processing functions}
	\begin{itemize}
		\item Linear functions
		\begin{enumerate}
			\item Averaging function
			\item Shifting function
			\item Gaussian function
			\item Edge detecting function
		\end{enumerate}
		\item Non-linear functions
		\begin{enumerate}
			\item Median function
			\item Min function
			\item Max function
		\end{enumerate}
	\end{itemize}
	\end{example}
}
\frame
{
	\frametitle{What is local processing?}
	\begin{itemize}
		\item Example of an averaging function
	\end{itemize}
	\centering
	\begin{figure}[!h]
		\includegraphics[scale=0.5]{neighborhood.png}
	\end{figure}
	\begin{equation*}
		I^{'}{(u,v)} = \frac{1}{9}\sum_{i=-1}^{1}{\sum_{j=-1}^{1}{I(u+i, v+j)}}
	\end{equation*}
	
}

\frame
{
	\frametitle{What is local processing?}
	\begin{itemize}
		\item Example of an averaging function
	\end{itemize}
	\centering
	\begin{figure}[!h]
		\begin{tabular}{cc}
			\includegraphics[scale=0.11]{kyoto_gray.jpg} &
			\includegraphics[scale=0.11]{kyoto_gray_smooth_9.jpg} \\
			Input image & Output image
		\end{tabular}
	\end{figure}

	\begin{itemize}
		\item The output image is obtained by averaging the input with neighborhood of $9 \times 9$ pixels.
	\end{itemize}
}
\frame
{
	\frametitle{What is local processing?}
	\begin{itemize}
		\item Example of an averaging function
	\end{itemize}
	\centering
	\begin{figure}[!h]
		\begin{tabular}{cc}
			\includegraphics[scale=0.11]{kyoto_gray.jpg} &
			\includegraphics[scale=0.11]{kyoto_gray_smooth_9.jpg} \\
			Input image & Output image \\
						& blurred, smoothed
		\end{tabular}
	\end{figure}
	
	\begin{equation*}
	I^{'}{(u,v)} = \frac{1}{9\times 9}\sum_{i=-4}^{4}{\sum_{j=-4}^{4}{I(u+i, v+j)}}
	\end{equation*}
}
\frame
{
	\frametitle{What is local processing?}
	\begin{itemize}
		\item Example of a median function (a non-linear function)
	\end{itemize}
	\centering
	\begin{figure}[!h]
		\begin{tabular}{cc}
			\includegraphics[scale=0.57]{image_salt_peper.png} &
			\includegraphics[scale=0.57]{image_salt_peper_denoise.png} \\
			Input image & Output image\\
				& Noises have been removed
		\end{tabular}
	\end{figure}
	
	\begin{itemize}
		\item The output image is obtained by computing the median value of a set of pixels in a neighborhood of $3 \times 3$ pixels.
	\end{itemize}
}


\section{Linear processing}
\frame
{
	\Huge
	\begin{center}
		\textcolor{blue}{\textbf{Linear processing function}}
	\end{center}
}

\subsection{Correlation}
\frame
{
	\frametitle{Mean function}
	Consider an averaging function on square window. In general, the window can have different size of each dimension. The output of the averaging is determined by.
	
	\begin{equation*} 
	\begin{split}
	I^{'}{(u,v)} &= \frac{1}{(2r+1) \times (2r+1)} \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u+i, v+j)}}
	\end{split}
	\end{equation*}
	
	$I^{'}(u,v)$ can be written as
	
	\begin{equation*} 
	\begin{split}
	I^{'}{(u,v)}	&= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u+i, v+j).H_{corr}{(i,j)}}}
	\end{split}
	\end{equation*}
}
\frame
{
	\frametitle{Mean function}
	\begin{enumerate}
		\item $H_{corr}$ is a matrix of size $(2r+1) \times (2r+1)$ 
		\item $H_{corr} = \frac{1}{(2r+1) \times (2r+1)} M_{ones}$
		
		and,
		\item $M_{ones}$ : is an matrix of size $(2r+1) \times (2r+1)$ containing value 1 for all elements.
	
	\end{enumerate}
	
	\begin{example}
	Matrix for averaging pixels in a neighborhood of size $5 \times 5$, i.e., $r= 2$.
	$$
		H_{corr} = \frac{1}{5 \times 5} \times 
		\begin{bmatrix}
			1 & 1 & 1 & 1 & 1 \\
			1 & 1 & 1 & 1 & 1 \\
			1 & 1 & 1 & 1 & 1 \\
			1 & 1 & 1 & 1 & 1 \\
			1 & 1 & 1 & 1 & 1 \\
		\end{bmatrix}
	$$
	\end{example}
}
\frame
{
	\frametitle{From averaging function to others}
	\begin{block}{A way to construct other linear processing functions}
		If one changes $H_{corr}$ to other kinds of matrix, he obtains other linear function.
	\end{block}
	
	\begin{example}
	Edge detecting function (Sobel)
	$$
		H_{corr} = 
		\begin{bmatrix}
			1 & 0 & -1 \\
			2 & 0 & -2 \\
			1 & 0 & -1 \\
		\end{bmatrix}
		\quad 
		H_{corr} = 
		\begin{bmatrix}
			1 & 2 & 1 \\
			0 & 0 & 0 \\
			-1 & -2 & -1 \\
		\end{bmatrix}
	$$
	
	Shifting function
	$$
	H_{corr} = 
	\begin{bmatrix}
		0 & 0 & 0 \\
		0 & 0 & 1 \\
		0 & 0 & 0 \\
	\end{bmatrix}
	$$
	\end{example}
}


\frame
{
	\frametitle{Correlation}
	
	\begin{block}{Definition}
		Input data:
		\begin{enumerate}
			\item Input image, $I(u,v)$
			\item Matrix $H_{corr}{(i,j)}$ of size $(2r+1) \times (2r+1)$. In general, the size on two dimensions maybe different.
		\end{enumerate}
		\textbf{Correlation} is defined as follows:
		\begin{equation*} 
		\begin{split}
		I_{corr}^{'}{(u,v)} &= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u+i, v+j).H_{corr}{(i,j)}}}
		\end{split}
		\end{equation*}
	\end{block}
}


\frame
{
	\frametitle{Correlation: How does it works?}
	\selectlanguage{english}
	\begin{figure}[!h]
		\includegraphics[scale=0.57]{correlation.png}
		\caption{Method for computing the correlation for one pixel}
	\end{figure}
}

\frame
{
	\frametitle{Correlation: How does it works?}
	\selectlanguage{english}
	\begin{block}{A computation process}
		For each pixel $(u,v)$ on the output image, do:
		\begin{enumerate}
			\item \textbf{Place} matrix $H_{corr}$ centered at the corresponding pixel, i.e., pixel $(u,v)$, on the input image
			\item \textbf{Multiply} coefficients in matrix $H_{corr}$ with the underlying pixels on the input image.
			\item \textbf{Compute} the sum of all the resulting products in the previous step.
			\item \textbf{Assign} the sum to the $I^{'}(u,v)$.
		\end{enumerate}
	
	\end{block}
}


\subsection{Convolution}
\frame
{
	\frametitle{Convolution}
	\selectlanguage{english}
		
	\begin{block}{Definition}
		Input data:
		\begin{enumerate}
			\item Input image, $I(u,v)$
			\item Matrix $H_{conv}$ of size $(2r+1) \times (2r+1)$. In general, the size on two dimensions maybe different.
		\end{enumerate}
		\textbf{Convolution} is defined as follows:
		\begin{equation*} 
		\begin{split}
		I_{conv}^{'}{(u,v)} &= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u-i, v-j).H_{conv}{(i,j)}}}
		\end{split}
		\end{equation*}
	\end{block}
}

\frame
{
	\frametitle{Convolution}
	\selectlanguage{english}
	
	\begin{block}{Natation}
		\begin{itemize}
			\item \alert{Operator *} is used to denote the convolution between image $I$ and matrix $H_{conv}$
			\item That is
			
			\begin{equation*} 
			\begin{split}
			I_{conv}^{'}{(u,v)} &= I * H_{conv} \\
				&= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u-i, v-j).H_{conv}{(i,j)}}}
			\end{split}
			\end{equation*}
		\end{itemize}
		
		
	\end{block}
}
\frame
{
	\frametitle{Convolution}
	\selectlanguage{english}
	
	\begin{alertblock}{Attention!}
		\begin{itemize}
			\item When $I$ is an gray image, both of $I$ and $H_{conv}$ are matrices.
			\item However,  $I * H_{conv}$ is convolution between $I$ and $H_{conv}$, \textbf{instead of matrix multiplication}!
	
	\end{itemize}
	
	
	\end{alertblock}
}


\frame
{
	\frametitle{Convolution and Correlation}
	\selectlanguage{english}
	
	\begin{block}{Mathematics}
		\begin{equation*} 
		\begin{split}
		I_{conv}^{'}{(u,v)} &= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u-i, v-j).H_{conv}{(i,j)}}} \\
		I_{corr}^{'}{(u,v)} &= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u+i, v+j).H_{corr}{(i,j)}}}
		\end{split}
		\end{equation*}
	\end{block}
	In mathematics, convolution and correlation are different in the \textbf{sign} of $i$ and $j$ inside of $I(u+i, v+j)$ and $I(u-i, v-j)$
}
\frame
{
	\frametitle{Convolution and Correlation}
	\selectlanguage{english}
	
	\begin{block}{Convolution to Correlation}
		\begin{itemize}
			\item Let $s=-i$ and $t=-j$ 
			\item We have
		\end{itemize}
		\begin{equation*} 
		\begin{split}
		I_{conv}^{'}{(u,v)} &= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u-i, v-j).H_{conv}{(i,j)}}} \\
				&= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u+s, v+t).H_{conv}{(-s,-t)}}} 
		\end{split}
		\end{equation*}
	\end{block}
	\begin{alertblock}{$H_{conv}{(-s,-t)}$ from $H_{conv}{(i,j)}$}
		$H_{conv}{(-s,-t)}$ can be obtained from $H_{conv}{(i,j)}$ by either
			\begin{itemize}
				\item \textbf{Flipping} $H_{conv}{(i,j)}$ on x and then on y axis
				\item \textbf{Rotating} $H_{conv}{(i,j)}$ around its center $180^0$
			\end{itemize}
	\end{alertblock}
	
}
\frame
{
	\frametitle{Convolution and Correlation}
	\selectlanguage{english}

	
	\begin{example}
		Demonstration of rotation and flipping.
		
		$$
		H = 
		\begin{bmatrix}
		\textcircled{1} & 2 & 3 \\
		4 & 5 & 6 \\
		7 & 8 & 9 \\
		\end{bmatrix}
		\quad
		H_{flipped\_x} = 
		\begin{bmatrix}
		3 & 2 & \textcircled{1} \\
		6 & 5 & 4 \\
		9 & 8 & 7 \\
		\end{bmatrix}
		$$
		$H_{flipped\_x}$ is obtained from $H$ by flipping $H$ on x-axis.
		
		After flipping $H_{flipped\_x}$ around y axis
		$$
		H_{flipped\_xy} = 
		\begin{bmatrix}
		9 & 8 & 7 \\
		6 & 5 & 4 \\
		3 & 2 & \textcircled{1} \\
		\end{bmatrix}
		$$
		
		$H_{flipped\_xy}$ can obtained from $H$ by rotating $H$	$180^0$ around $H$'s center.
		\end{example}
}

\frame
{
	\frametitle{Convolution and Correlation}
	\selectlanguage{english}
	
	\begin{block}{Correlation to Convolution}
	\begin{itemize}
	\item Let $s=-i$ and $t=-j$ 
	\item We have
	\end{itemize}
	\begin{equation*} 
	\begin{split}
	I_{corr}^{'}{(u,v)} &= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u+i, v+j).H_{corr}{(i,j)}}} \\
	&= \sum_{i=-r}^{r}{\sum_{j=-r}^{r}{I(u-s, v-t).H_{corr}{(-s,-t)}}} 
	\end{split}
	\end{equation*}
	\end{block}
	\begin{alertblock}{$H_{corr}{(-s,-t)}$ from $H_{corr}{(i,j)}$}
	$H_{corr}{(-s,-t)}$ can be obtained from $H_{corr}{(i,j)}$ by either
	\begin{itemize}
	\item \textbf{Flipping} $H_{corr}{(i,j)}$ on x and then on y axis
	\item \textbf{Rotating} $H_{corr}{(i,j)}$ around its center $180^0$
	\end{itemize}
	\end{alertblock}
	
}
\frame
{
	\frametitle{Convolution-Correlation Conversion}
	\selectlanguage{english}
	\begin{alertblock}{Relationship}
	\begin{enumerate}
		
		\item Convolution can be computed by correlation and vice versa.
		
		\item For example, convolution can be computed by correlation by: first, \alert{(a)} rotating the matrix $180^0$ and then \alert{(b)} computing the correlation between the rotated matrix with the input image.
		
	\end{enumerate}
	
	\end{alertblock}
}

\frame
{
	\frametitle{Convolution: How does it works?}
	\selectlanguage{english}
	\begin{block}{A Computation process}
		\begin{enumerate}
			\item \textbf{Rotate} matrix $H_{conv}$ around its center $180^0$ to obtain $H_{corr}$
		\end{enumerate}
		For each pixel $(u,v)$ on the output image, do:
		\begin{enumerate}
			\item \textbf{Place} matrix $H_{corr}$ centered at the corresponding pixel, i.e., pixel $(u,v)$, on the input image
			\item \textbf{Multiply} coefficients in matrix $H_{corr}$ with the underlying pixels on the input image.
			\item \textbf{Compute} the sum of all the resulting products in the previous step.
			\item \textbf{Assign} the sum to the $I^{'}(u,v)$.
		\end{enumerate}
		
	\end{block}
}
\frame
{
	\frametitle{MATLAB's function}
	\selectlanguage{english}
	\begin{example}
		MATLAB's functions supports correlation and convolution
		\begin{enumerate}
			\item \alert{\textbf{corr2}}
			\item \alert{\textbf{xcorr2}}
			\item \alert{\textbf{conv2}}
			\item \alert{\textbf{filter2}}
			\item \alert{\textbf{imfilter}}
		\end{enumerate}
			MATLAB's function supports creating special matrix
			\begin{enumerate}
				\item \alert{\textbf{fspecial}}
			\end{enumerate}
	\end{example}
}


\subsection{Linear Filtering}
\frame
{
	\frametitle{Linear Filtering}
	\selectlanguage{english}
	\begin{block}{Definition}
		Linear filtering is a process of applying the \alert{\textbf{convolution or the correlation}} between an matrix $H$ to input image $I(u,v)$.
	\end{block}
	\begin{block}{Model of a filter system}
		\begin{figure}[!h]
			\includegraphics[scale=0.57]{filtersys.png}
			\caption{Filter image $I(u,v)$ with matrix $H$ to obtain $I^{'}(u,v)$} 
		\end{figure}
		
		\centering
		$I^{'}(u,v) =  I(u,v)*H(i,j)$
	\end{block}
}
\frame
{
	\frametitle{Filter's kernel}
	\selectlanguage{english}
	\begin{block}{Definition}
		In filtering, matrix $H$ is called the filter's kernel.
	\end{block}
	\begin{block}{Other names of $H$}
		\begin{itemize}
			\item Filter's kernel
			\item Window
			\item Mask
			\item Template
			\item Matrix
			\item Local region
		\end{itemize}
	\end{block}
}
\subsection{Popular Linear Filter}
\frame
{
	\frametitle{Popular Linear Filter: Mean filter}
	\selectlanguage{english}
	\begin{example}
		Mean filter's kernel
		\begin{itemize}
			\item General case:
		\end{itemize}
		$$
		H_{corr} = \frac{1}{(2r+1)^2} \times 
		\begin{bmatrix}
		1 & 1 & ... & 1 & 1 \\
		1 & 1 & ... & 1 & 1 \\
		... & ... & ... & ... & ... \\
		1 & 1 & ... & 1 & 1 \\
		1 & 1 & ... & 1 & 1 \\
		\end{bmatrix}_{(2r+1) \times (2r+1)}
		$$
	\end{example}
}

\frame
{
	\frametitle{Popular Linear Filter: Mean filter}
	\selectlanguage{english}
	\begin{figure}
		\begin{tabular}{cc}
			\includegraphics[scale=0.53]{char.png} &
			\includegraphics[scale=0.53]{char_mean_3_3.png} \\
			Original image & Filtered with $H$'s size: $3 \times 3$
		\end{tabular}
	\end{figure}
}

\frame
{
	\frametitle{Popular Linear Filter: Mean filter}
	\selectlanguage{english}
	\begin{figure}
		\begin{tabular}{cc}
			\includegraphics[scale=0.53]{char_mean_5_5.png} &
			\includegraphics[scale=0.53]{char_mean_11_11.png} \\
			Filtered with $H$'s size: $5 \times 5$ & Filtered with $H$'s size: $11 \times 11$ 
		\end{tabular}
	\end{figure}
}

\frame
{
	\frametitle{Popular Linear Filter: Gaussian filter}
	\selectlanguage{english}
	\begin{block}{2D-Gaussian Function}
		\begin{equation*}
		\begin{split}
				G(x,y, \sigma) &= \frac{1}{2\pi{\sigma}^2}  exp({-\frac{x^2 + y^2}{{2\sigma}^2}})
		\end{split}
		\end{equation*}
	\end{block}
	\begin{figure}
		\includegraphics[scale=0.3]{gaussian.png}
		\caption{2D-Gaussian Function}
	\end{figure}
}

\frame
{
	\frametitle{Popular Linear Filter: Gaussian filter}
	\selectlanguage{english}
	\begin{example}
		\begin{itemize}
			\item $H$'s size is $3 \times 3$
			\item $\sigma = 0.5$
		\end{itemize}
		$$
		H = 
		\begin{bmatrix}
		0.0113   & 0.0838  &  0.0113\\
		0.0838   & 0.6193  &  0.0838\\
		0.0113   & 0.0838  &  0.0113
		\end{bmatrix}
		$$
		\begin{itemize}
			\item $H$'s size is $5 \times 5$
			\item $\sigma = 0.5$
		\end{itemize}
		$$
		H = 
		\begin{bmatrix}
		0.0000  &  0.0000  &  0.0002  &  0.0000  &  0.0000\\
		0.0000  &  0.0113  &  0.0837  &  0.0113  &  0.0000\\
		0.0002  &  0.0837  &  0.6187  &  0.0837  &  0.0002\\
		0.0000  &  0.0113  &  0.0837  &  0.0113  &  0.0000\\
		0.0000  &  0.0000  &  0.0002  &  0.0000  &  0.0000
		\end{bmatrix}
		$$
	\end{example}
}
\frame
{
	\frametitle{Popular Linear Filter: Gaussian filter}
	\selectlanguage{english}
	\begin{figure}
		\begin{tabular}{cc}
			\includegraphics[scale=0.53]{char_mean_11_11.png} &
			\includegraphics[scale=0.53]{char_gaussian_11_11_05.png} \\
			Filtered with Mean filter  & Filtered with Gaussian filter \\
			$H$'s size: $11 \times 11$ & $H$'s size: $11 \times 11$ \\
									& 	$\sigma =0.5$
		\end{tabular}
	\end{figure}
}

\frame
{
	\frametitle{Popular Linear Filter: Shifting filter}
	\selectlanguage{english}
	\begin{example}
		\begin{itemize}
			\item In order to shift pixel $(u,v)$ to $(u-2, v+2)$, use the following kernel
		\end{itemize}
		$$
		H = 
		\begin{bmatrix}
		0 & 0 & 0 & 0 & 1\\
		0 & 0 & 0 & 0 & 0\\
		0 & 0 & 0 & 0 & 0\\
		0 & 0 & 0 & 0 & 0\\
		0 & 0 & 0 & 0 & 0\\
		\end{bmatrix}
		$$
		
	\end{example}
}

\frame
{
	\frametitle{Popular Linear Filter: Shifting filter}
	\selectlanguage{english}
	\begin{figure}
		\begin{tabular}{cc}
			\includegraphics[scale=0.53]{char.png} &
			\includegraphics[scale=0.53]{char_shifted_2_2.png} \\
			Original image & Shifted with $d=[-2, 2]$ 
		\end{tabular}
	\end{figure}
}

\subsection{Convolution's Properties}
\frame
{
	\frametitle{Convolution's Properties}
	\selectlanguage{english}
	\begin{block}{Commutativity:}
		\centering
		$I * H = H * I$
	\end{block}
	\begin{alertblock}{Meaning}
		\begin{enumerate}
			\item This means that we can think of the image as the kernel and the kernel as the image and get the same result. 
			
			\item In other words, we can leave the image fixed and slide the kernel or leave the kernel fixed and slide the image.
		\end{enumerate}		
		
	\end{alertblock}
}

\frame
{
	\frametitle{Convolution's Properties}
	\selectlanguage{english}
	\begin{block}{Associativity:}
		\centering
		$(I * H_{1})*H_{2} =I * (H_{1}*H_{2})$
	\end{block}
	\begin{alertblock}{Meaning}
		\begin{enumerate}
			\item This means that we can apply $H_{1}$ to $I$ followed by $H_{2}$, or we can convolve the kernel $H_{2} * H_{1}$  and then apply the resulting kernel to $I$.
		\end{enumerate}		
		
	\end{alertblock}
}
\frame
{
	\frametitle{Convolution's Properties}
	\selectlanguage{english}
	\begin{block}{Linearity:}
		\centering
		$(\alpha .I)* H = \alpha. (I * H)$
		
		$(I_{1} + I_{2}) * H = I_{1} * H + I_{2}*H$
		
	\end{block}
	\begin{alertblock}{Meaning}
		\begin{enumerate}
			\item This means that we can multiply an image by a constant before or after convolution, and we can add two images before or after convolution and get the same results. 
		\end{enumerate}		
		
	\end{alertblock}
}
\frame
{
	\frametitle{Convolution's Properties}
	\selectlanguage{english}
	\begin{block}{Shift-Invariance}
		Let $S$ be an operator that shifts an image I:
		\centering
		$S(I)(u,v) = I(u+a, v+b)$
		
		
		\flushleft Then,
		
		\centering
		$S(I*H) = S(I)*H$
		
	\end{block}
	\begin{alertblock}{Meaning}
		
		\begin{enumerate}
			\item This means that we can convolve $I$ and $H$ and then shift the result, or we can shift $I$ and then convolve it with $H$.
		\end{enumerate}		
		
	\end{alertblock}
}

\frame
{
	\frametitle{Convolution's Properties}
	\selectlanguage{english}
	\begin{block}{Separability}
		A kernel H is called separable if it can be broken down into the convolution of two kernels:
		
		\centering $H = H_{1} * H_{2}$
		
		\flushleft More generally, we might have:
		
		\centering $H = H_{1} * H_{2}* ... * H_{n}$
	\end{block}
}


\frame
{
	\frametitle{Convolution's Properties}
	\selectlanguage{english}
	\begin{example}
		$$
		H_{x} = 
		\begin{bmatrix}
		1 & 1 & 1 & 1 & 1
		\end{bmatrix}
		\quad
		H_{y} = 
		\begin{bmatrix}
		1 \\ 1 \\ 1
		\end{bmatrix}
		$$
		
		Then,
		$$
		H_{x}  = H_{x} * H_{y} = 
		\begin{bmatrix}
			1 & 1 & 1 & 1 & 1\\
			1 & 1 & 1 & 1 & 1\\
			1 & 1 & 1 & 1 & 1
		\end{bmatrix}
		$$
		
	\end{example}
	
}
\frame
{
	\frametitle{Processing at the boundary of image}
	\selectlanguage{english}
	
	\begin{figure}[!h]
		\includegraphics[scale=0.57]{boundary_effect.png}
		\caption{Without any special consideration, the processing is invalid at boundary pixels} 
	\end{figure}

}
\frame
{
	\frametitle{Processing at the boundary of image}
	\selectlanguage{english}
	
	\begin{block}{Methods for processing boundary pixels}
		\begin{enumerate}
			\item \textbf{Cropping}:do not process boundary pixels. Just obtain a smaller output image by cropping the output image.
			\item \textbf{Padding}: pad a band of pixels (with zeros) to the boundary of input image. Perform the processing and the crop to get the output image.
			\item \textbf{Extending}: copy pixels on the boundary to outside to get a new image. Perform the processing and the crop to get the output image.
			\item \textbf{Wrapping}: reflect pixels on the boundary to outside to get a new image. Perform the processing and the crop to get the output image.
			
		\end{enumerate} 
	\end{block}
	
}

\frame
{
	\frametitle{Convolution's implementation}
	\selectlanguage{english}
	
	\begin{block}{Methods for implementing convolution and correlation}
		\begin{enumerate}
			\item \textbf{In space domain}:
				\begin{itemize}
					\item Use sliding widow technique
					\item Use speed-up methods for special cases
				\end{itemize}
			\item \textbf{In frequency domain}: will be presented in next chapter
			
		\end{enumerate} 
	\end{block}
	
}
\subsection{Convolution's implementation}
\frame
{
	\frametitle{Convolution's implementation}
	\selectlanguage{english}
	
	\begin{alertblock}{Sliding window technique for correlation}
		For each pixel $(u,v)$ on the output image, do:
		\begin{enumerate}
			\item \textbf{Place} matrix $H_{corr}$ centered at the corresponding pixel, i.e., pixel $(u,v)$, on the input image
			\item \textbf{Multiply} coefficients in matrix $H_{corr}$ with the underlying pixels on the input image.
			\item \textbf{Compute} the sum of all the resulting products in the previous step.
			\item \textbf{Assign} the sum to the $I^{'}(u,v)$.
		\end{enumerate}
	\end{alertblock}
	Convolution can be computed by rotating the kernel $180^0$ followed by the above algorithm.
}
\frame
{
	\frametitle{Convolution's complexity}
	\selectlanguage{english}
	\begin{block}{Computational Complexity of sliding window technique}
		\begin{itemize}
			\item Input image $I$ has size $N \times M$
			\item Kernel's size is $(2r+1) \times (2r+1)$
			\item Then, the number of operations is directly proportional to: $MN[(2r+1)^2 + (2r+1)^2 -1]$.
			\item \alert{\textbf{The computational complexity is $O(MNr^2)$}}
		\end{itemize}
		
	\end{block}
	\begin{alertblock}{Attention!}
		\begin{itemize}
			\item The cost for computing convolution and correlation is \alert{directly proportional} to the kernel's size!
			\item The filtering process will be slower if the kernel's size is bigger.
			\item The computational cost of the implementation in frequency domain is independent with the kernel's size.
		\end{itemize}
	\end{alertblock}
	
}
\frame
{
	\frametitle{Convolution's complexity}
	\selectlanguage{english}
	\begin{example}
		To shift an image $I$ to left 10 pixels. We can apply the following methods:
		\begin{enumerate}
			\item \textbf{Method 1:} Filter $I$ with a shifting kernel of size $21 \times 21$.
			\item \textbf{Method 2:} Apply 10 times shifting kernel of size $3 \time 3$.
		\end{enumerate}
		Which method can result better computation cost?
		
	\end{example}
	\begin{block}{Answer}
	Number of operations for each method is proportional to:
	\begin{enumerate}
		\item \textbf{Method 1:} $MN \times (21^2) = 441MN$
		\item \textbf{Method 2:} $10 \times MN \times(3^2) = 90MN$
	\end{enumerate}
	Method 2 is better than Method 1!
	
	\end{block}

	
}


\frame
{
	\frametitle{Convolution's complexity}
	\selectlanguage{english}
	Because, we have
	\begin{block}{Associativity:}
		\centering
		$(I * H_{1})*H_{2} =I * (H_{1}*H_{2})$
	\end{block}
	
	\begin{alertblock}{So, we can save the computational cost by using separability}
		If we can separate a kernel H into two smaller kernels $H = H_{1} * H_{2}$, then it will often be cheaper to apply $H_{1}$ followed by $H_{2}$, rather than $H$.
	\end{alertblock}
}
\frame
{
	\frametitle{Convolution's complexity}
	\selectlanguage{english}
	\begin{example}
		Kernel $H$ can be decomposed into $H = H_{1} *H_{2}$, as follows:
		$$
		H_{1} = 
		\begin{bmatrix}
			1 \\ 2 \\ 1
		\end{bmatrix}
		\quad
		H_{2} = 
		\begin{bmatrix}
			-1 & 0 & 1	
		\end{bmatrix}
		$$
		
		$$
		H  = H_{1} * H_{2} = 
		\begin{bmatrix}
			-1 & 0 & 1\\
			-2 & 0 & 2\\
			-1 & 0 & 1
		\end{bmatrix}
		$$
		Using associativity, we can filter image $I$ with $H$ by either
		\begin{enumerate}
			\item \textbf{Method 1:} $I' = I*H$
			\item \textbf{Method 2:} $I' = (I*H_{1})*H_{2}$
		\end{enumerate}
		Which method is better?
	\end{example}	
}
\frame
{
	\frametitle{Convolution's complexity}
	\selectlanguage{english}
	\begin{block}{Answer}
		Number of operations for each method is proportional to:
		\begin{enumerate}
			\item \textbf{Method 1:} $MN \times (3^2) = 9MN$
			\item \textbf{Method 2:} $(MN \times 3) + (MN \times 3) = 6MN$
		\end{enumerate}
		Method 2 is better than Method 1!
	\end{block}
}
\frame
{
	\frametitle{Convolution's implementation}
	\selectlanguage{english}
	\begin{alertblock}{Special cases}
		\begin{enumerate}
			\item \textbf{Separability:} In the case that kernel filter $H$ can be separated into smaller kernels. Consecutively apply smaller kernels to the input image can reduce the computation time, as shown in previous slide.
			\item \textbf{Box Filtering: } Kernel's coefficients of box filter are equal (value 1). So, we can use \textbf{integral image} to speed up.
		\end{enumerate}

	\end{alertblock}
}
\frame
{
	\frametitle{Convolution's implementation: Integral image}
	\selectlanguage{english}
	
	\tikzstyle{pointer} = [draw, thin, fill=blue!20, minimum height=2em, minimum width=4em]
	\tikzstyle{value} = [draw, thin, minimum height=2em, minimum width=4em]
	
	\tikzstyle{innerWhite} = [semithick, white,line width=1.4pt, shorten >= 4.5pt]
	
	\textbf{CASE 1: 1D-array}
	\begin{itemize}
		\item Input data: array $A[i]$, for $i\in [1,n]$
		\begin{itemize}
			\item The first element, $A[0]$, is not used
		\end{itemize}
	\end{itemize}
	
		\begin{tikzpicture}
		\begin{scope}[start chain=1 going right, node distance=-0.1mm]
		\node [on chain=1,tmtape] (n0) {};
		\node [on chain=1,tmtape] (n1) {3};
		\node [on chain=1,tmtape] (n2) {8};
		\node [on chain=1,tmtape] (n3) {2};
		\node [on chain=1,tmtape] (n4) {6};
		\node [on chain=1,tmtape] (n5) {9};
		\node [on chain=1,tmtape] (n6) {7};
		\node [on chain=1,tmtape] (n7) {1};
		
		\node[left of=n0, xshift=-3em] {$A[i]$};
		\node[below of=n0, yshift=-2em] {0};
		\node[below of=n1, yshift=-2em] {1};
		\node[below of=n2, yshift=-2em] {2};
		\node[below of=n3, yshift=-2em] {3};
		\node[below of=n4, yshift=-2em] {4};
		\node[below of=n5, yshift=-2em] {5};
		\node[below of=n6, yshift=-2em] {6};
		\node[below of=n7, yshift=-2em] {7};
		\end{scope}
		\end{tikzpicture}
		
	\begin{itemize}
		\item Output data: \textbf{integral array}, denoted as $C[i]$
		\item The integral array is computed as follows
		\begin{enumerate}
			\item $C[0] = 0$
			\item $C[i]= C[i-1]+A[i]$, for $i \in [1,n]$.
		\end{enumerate}
	\end{itemize}
		 
		 
		 
		\begin{tikzpicture}
		\begin{scope}[start chain=2 going right, node distance=-0.1mm]
		\node [on chain=2,tmtape] (n0) {0};
		\node [on chain=2,tmtape] (n1) {3};
		\node [on chain=2,tmtape] (n2) {11};
		\node [on chain=2,tmtape] (n3) {13};
		\node [on chain=2,tmtape] (n4) {19};
		\node [on chain=2,tmtape] (n5) {28};
		\node [on chain=2,tmtape] (n6) {35};
		\node [on chain=2,tmtape] (n7) {36};
		
		\node[left of=n0, xshift=-3em] {$C[i]$};
		\node[below of=n0, yshift=-2em] {0};
		\node[below of=n1, yshift=-2em] {1};
		\node[below of=n2, yshift=-2em] {2};
		\node[below of=n3, yshift=-2em] {3};
		\node[below of=n4, yshift=-2em] {4};
		\node[below of=n5, yshift=-2em] {5};
		\node[below of=n6, yshift=-2em] {6};
		\node[below of=n7, yshift=-2em] {7};

		\end{scope}
		\end{tikzpicture}
}
\frame
{
	\frametitle{Convolution's implementation: Integral image}
	\selectlanguage{english}
	\textbf{CASE 1: 1D-array}
	\begin{alertblock}{1D Box filter's response}
		The sum of elements in any window, occupying from $A[i]$ to $A[j]$, can be computed fast by: $C[j] - C[i-1]$
		
	\end{alertblock}
	
	\begin{tikzpicture}
	\begin{scope}[start chain=1 going right, node distance=-0.1mm]
	\node [on chain=1,tmtape] (n0) {};
	\node [on chain=1,tmtape] (n1) {3};
	\node [on chain=1,tmtape] (n2) {8};
	\node [on chain=1,tmtape] (n3) {2};
	\node [on chain=1,tmtape] (n4) {6};
	\node [on chain=1,tmtape] (n5) {9};
	\node [on chain=1,tmtape] (n6) {7};
	\node [on chain=1,tmtape] (n7) {1};
	
	\node[left of=n0, xshift=-3em] {$A[i]$};
	\node[below of=n0, yshift=-2em] {0};
	\node[below of=n1, yshift=-2em] {1};
	\node[below of=n2, yshift=-2em] {2};
	\node[below of=n3, yshift=-2em] {3};
	\node[below of=n4, yshift=-2em] {4};
	\node[below of=n5, yshift=-2em] {5};
	\node[below of=n6, yshift=-2em] {6};
	\node[below of=n7, yshift=-2em] {7};
	\end{scope}
	\end{tikzpicture}
	
	\begin{tikzpicture}
	\begin{scope}[start chain=2 going right, node distance=-0.1mm]
	\node [on chain=2,tmtape] (n0) {0};
	\node [on chain=2,tmtape] (n1) {3};
	\node [on chain=2,tmtape] (n2) {11};
	\node [on chain=2,tmtape] (n3) {13};
	\node [on chain=2,tmtape] (n4) {19};
	\node [on chain=2,tmtape] (n5) {28};
	\node [on chain=2,tmtape] (n6) {35};
	\node [on chain=2,tmtape] (n7) {36};
	
	\node[left of=n0, xshift=-3em] {$C[i]$};
	\node[below of=n0, yshift=-2em] {0};
	\node[below of=n1, yshift=-2em] {1};
	\node[below of=n2, yshift=-2em] {2};
	\node[below of=n3, yshift=-2em] {3};
	\node[below of=n4, yshift=-2em] {4};
	\node[below of=n5, yshift=-2em] {5};
	\node[below of=n6, yshift=-2em] {6};
	\node[below of=n7, yshift=-2em] {7};
	
	\end{scope}
	\end{tikzpicture}
	
	\begin{example}
		\begin{enumerate}
			\item $\sum_{i=1}^{4}{A[i]} = C[4] - C[0] = 19-0 = 19$
			\item $\sum_{i=2}^{6}{A[i]} = C[6] - C[1] = 35-3 =32$
			\item $\sum_{i=3}^{6}{A[i]} = C[6] - C[2] = 35-11 =24$
		\end{enumerate}
	\end{example}
}

\frame{
	\frametitle{Convolution's implementation: Integral image}
	\selectlanguage{english}
	\textbf{CASE 2: 2D-array}
	
	\begin{itemize}
		\item Input data: Image $I(u,v)$, for $u,v \in [1,n]$
		\begin{itemize}
			\item The first row and the first column are not used
		\end{itemize}
		\item Output data: \textbf{integral image} $S(u,v)$. It is defined as follows.
		\begin{enumerate}
			\item The first row and the first column contains zeros, i.e., 
			\begin{align}
			\nonumber
				S(0,i) = S(j,0) = 0; i,j \in [0,n]
			\end{align}
			
			\item \begin{align}
				\nonumber
				S(u,v) = \sum_{i=1}^{u}{\sum_{j=1}^{v}{I(i,j)}}
			\end{align}
		\end{enumerate}
	\end{itemize}
}
\frame{
	\frametitle{Convolution's implementation: Integral image}
	\selectlanguage{english}
	\textbf{CASE 2: 2D-array}
	
	\begin{block}{A method for computing $S(u,v)$}
		\begin{enumerate}
			\item for each element in the first row and the first column in $S(u,v)$, assign zero to it.
			\item for each remaining element at $(u,v)$: $S(u,v) = S(u-1, v) + S(u,v-1) - S(u-1, v-1) + I(u,v)$
		\end{enumerate}
	\end{block}
}
\frame{
	\frametitle{Convolution's implementation: Integral image}
	\selectlanguage{english}
	\textbf{CASE 2: 2D-array}
	\begin{figure}[!h]
		\includegraphics[scale=0.3]{integralimage.png}
	\end{figure}
	\begin{alertblock}{The Way to compute the filter's response}
		\begin{enumerate}
			\item Let $A, B, C, and D$ are the sum of all pixels in rectangle from $O$ to $A, B, C, and D$ respectively.
			\item The sum of pixels inside of rectangle $ABCD$ is $(C-B-D+A)$
		\end{enumerate}	
	\end{alertblock}
	
	
}
\frame{
	\frametitle{Convolution's implementation: Integral image}
	\selectlanguage{english}
	\textbf{CASE 2: 2D-array}
	\begin{figure}[!h]
		\includegraphics[scale=0.3]{integralimage.png}
	\end{figure}
	\begin{alertblock}{The Way to compute the filter's response}
		\begin{align}
			\nonumber
			I^{'}(u_2,v_2) 	&= C - B - D + A \\
			\nonumber
						&= S(u_2,v_2) - S(u_1,v_2) - S(u_2, v_1) + S(u_1, v_1)
		\end{align}
	\end{alertblock}
	
	
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\end{document}