Reorganized documentation to be consistent with modular structure

doc/cv_calibration_3d.tex → doc/calib3d.tex

-\section{Camera Calibration and 3D Reconstruction}
+\section{Camera Calibration and 3d Reconstruction}
 
 The functions in this section use the so-called pinhole camera model. That
 is, a scene view is formed by projecting 3D points into the image plane

doc/cxcore_array_operations.tex → doc/core_array_operations.tex

@@ -2032,8 +2032,8 @@ The function calculates the natural logarithm of the absolute value of every ele
 
 Where \texttt{C} is a large negative number (about -700 in the current implementation).
 
-\cvCPyFunc{Mahalonobis}
-Calculates the Mahalonobis distance between two vectors.
+\cvCPyFunc{Mahalanobis}
+Calculates the Mahalanobis distance between two vectors.
 
 \cvdefC{double cvMahalanobis(\par const CvArr* vec1,\par const CvArr* vec2,\par CvArr* mat);}
 \cvdefPy{Mahalonobis(vec1,vec2,mat)-> None}

doc/cvaux_object_detection.tex → doc/features2d_object_detection.tex

@@ -401,4 +401,4 @@ for(i=0; i < imageKeypoints->total; i++)
 	
 \end{lstlisting}
 
-\fi
\ No newline at end of file
+\fi

doc/imgproc_motion_tracking.tex

+%[TODO: FROM VIDEO]
+\section{Motion Analysis and Object Tracking}
+
+\ifCPy
+
+\cvCPyFunc{Acc}
+Adds a frame to an accumulator.
+
+\cvdefC{
+void cvAcc( \par const CvArr* image,\par CvArr* sum,\par const CvArr* mask=NULL );
+}
+\cvdefPy{Acc(image,sum,mask=NULL)-> None}
+
+\begin{description}
+\cvarg{image}{Input image, 1- or 3-channel, 8-bit or 32-bit floating point. (each channel of multi-channel image is processed independently)}
+\cvarg{sum}{Accumulator with the same number of channels as input image, 32-bit or 64-bit floating-point}
+\cvarg{mask}{Optional operation mask}
+\end{description}
+
+The function adds the whole image \texttt{image} or its selected region to the accumulator \texttt{sum}:
+
+\[ \texttt{sum}(x,y) \leftarrow \texttt{sum}(x,y) + \texttt{image}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
+
+\cvCPyFunc{MultiplyAcc}
+Adds the product of two input images to the accumulator.
+
+\cvdefC{
+void cvMultiplyAcc( \par const CvArr* image1,\par const CvArr* image2,\par CvArr* acc,\par const CvArr* mask=NULL );
+}
+\cvdefPy{MultiplyAcc(image1,image2,acc,mask=NULL)-> None}
+
+\begin{description}
+\cvarg{image1}{First input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)}
+\cvarg{image2}{Second input image, the same format as the first one}
+\cvarg{acc}{Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point}
+\cvarg{mask}{Optional operation mask}
+\end{description}
+
+The function adds the product of 2 images or their selected regions to the accumulator \texttt{acc}:
+
+\[ \texttt{acc}(x,y) \leftarrow \texttt{acc}(x,y) + \texttt{image1}(x,y) \cdot \texttt{image2}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
+
+
+\cvCPyFunc{RunningAvg}
+Updates the running average.
+
+\cvdefC{
+void cvRunningAvg( \par const CvArr* image,\par CvArr* acc,\par double alpha,\par const CvArr* mask=NULL );
+}
+\cvdefPy{RunningAvg(image,acc,alpha,mask=NULL)-> None}
+
+\begin{description}
+\cvarg{image}{Input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)}
+\cvarg{acc}{Accumulator with the same number of channels as input image, 32-bit or 64-bit floating-point}
+\cvarg{alpha}{Weight of input image}
+\cvarg{mask}{Optional operation mask}
+\end{description}
+
+The function calculates the weighted sum of the input image
+\texttt{image} and the accumulator \texttt{acc} so that \texttt{acc}
+becomes a running average of frame sequence:
+
+\[ \texttt{acc}(x,y) \leftarrow (1-\alpha) \cdot \texttt{acc}(x,y) + \alpha \cdot \texttt{image}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
+
+where $\alpha$ regulates the update speed (how fast the accumulator forgets about previous frames).
+
+\cvCPyFunc{SquareAcc}
+Adds the square of the source image to the accumulator.
+
+\cvdefC{
+void cvSquareAcc( \par const CvArr* image,\par CvArr* sqsum,\par const CvArr* mask=NULL );
+}\cvdefPy{SquareAcc(image,sqsum,mask=NULL)-> None}
+
+\begin{description}
+\cvarg{image}{Input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)}
+\cvarg{sqsum}{Accumulator with the same number of channels as input image, 32-bit or 64-bit floating-point}
+\cvarg{mask}{Optional operation mask}
+\end{description}
+
+The function adds the input image \texttt{image} or its selected region, raised to power 2, to the accumulator \texttt{sqsum}:
+
+\[ \texttt{sqsum}(x,y) \leftarrow \texttt{sqsum}(x,y) + \texttt{image}(x,y)^2 \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
+
+\fi
+
+\ifCpp
+
+\cvCppFunc{accumulate}
+Adds image to the accumulator.
+
+\cvdefCpp{void accumulate( const Mat\& src, Mat\& dst, const Mat\& mask=Mat() );}
+\begin{description}
+\cvarg{src}{The input image, 1- or 3-channel, 8-bit or 32-bit floating point}
+\cvarg{dst}{The accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point}
+\cvarg{mask}{Optional operation mask}
+\end{description}
+
+The function adds \texttt{src}, or some of its elements, to \texttt{dst}:
+
+\[ \texttt{dst}(x,y) \leftarrow \texttt{dst}(x,y) + \texttt{src}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
+
+The function supports multi-channel images; each channel is processed independently.
+
+The functions \texttt{accumulate*} can be used, for example, to collect statistic of background of a scene, viewed by a still camera, for the further foreground-background segmentation.
+
+See also: \cvCppCross{accumulateSquare}, \cvCppCross{accumulateProduct}, \cvCppCross{accumulateWeighted}
+
+\cvCppFunc{accumulateSquare}
+Adds the square of the source image to the accumulator.
+
+\cvdefCpp{void accumulateSquare( const Mat\& src, Mat\& dst, \par const Mat\& mask=Mat() );}
+\begin{description}
+\cvarg{src}{The input image, 1- or 3-channel, 8-bit or 32-bit floating point}
+\cvarg{dst}{The accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point}
+\cvarg{mask}{Optional operation mask}
+\end{description}
+
+The function adds the input image \texttt{src} or its selected region, raised to power 2, to the accumulator \texttt{dst}:
+
+\[ \texttt{dst}(x,y) \leftarrow \texttt{dst}(x,y) + \texttt{src}(x,y)^2 \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
+
+The function supports multi-channel images; each channel is processed independently.
+
+See also: \cvCppCross{accumulateSquare}, \cvCppCross{accumulateProduct}, \cvCppCross{accumulateWeighted}
+
+\cvCppFunc{accumulateProduct}
+Adds the per-element product of two input images to the accumulator.
+
+\cvdefCpp{void accumulateProduct( const Mat\& src1, const Mat\& src2,\par
+                        Mat\& dst, const Mat\& mask=Mat() );}
+\begin{description}
+\cvarg{src1}{The first input image, 1- or 3-channel, 8-bit or 32-bit floating point}
+\cvarg{src2}{The second input image of the same type and the same size as \texttt{src1}}
+\cvarg{dst}{Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point}
+\cvarg{mask}{Optional operation mask}
+\end{description}
+
+The function adds the product of 2 images or their selected regions to the accumulator \texttt{dst}:
+
+\[ \texttt{dst}(x,y) \leftarrow \texttt{dst}(x,y) + \texttt{src1}(x,y) \cdot \texttt{src2}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
+
+The function supports multi-channel images; each channel is processed independently.
+
+See also: \cvCppCross{accumulate}, \cvCppCross{accumulateSquare}, \cvCppCross{accumulateWeighted}
+
+\cvCppFunc{accumulateWeighted}
+Updates the running average.
+
+\cvdefCpp{void accumulateWeighted( const Mat\& src, Mat\& dst,\par
+                         double alpha, const Mat\& mask=Mat() );}
+\begin{description}
+\cvarg{src}{The input image, 1- or 3-channel, 8-bit or 32-bit floating point}
+\cvarg{dst}{The accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point}
+\cvarg{alpha}{Weight of the input image}
+\cvarg{mask}{Optional operation mask}
+\end{description}
+
+The function calculates the weighted sum of the input image
+\texttt{src} and the accumulator \texttt{dst} so that \texttt{dst}
+becomes a running average of frame sequence:
+
+\[ \texttt{dst}(x,y) \leftarrow (1-\texttt{alpha}) \cdot \texttt{dst}(x,y) + \texttt{alpha} \cdot \texttt{src}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
+
+that is, \texttt{alpha} regulates the update speed (how fast the accumulator "forgets" about earlier images).
+The function supports multi-channel images; each channel is processed independently.
+
+See also: \cvCppCross{accumulate}, \cvCppCross{accumulateSquare}, \cvCppCross{accumulateProduct}
+
+\fi

doc/imgproc_object_detection.tex

+%[TODO: from objdetect]
+\section{Object Detection}
+
+\ifCPy
+\cvCPyFunc{MatchTemplate}
+Compares a template against overlapped image regions.
+
+\cvdefC{
+void cvMatchTemplate( \par const CvArr* image,\par const CvArr* templ,\par CvArr* result,\par int method );
+}\cvdefPy{MatchTemplate(image,templ,result,method)-> None}
+
+\begin{description}
+\cvarg{image}{Image where the search is running; should be 8-bit or 32-bit floating-point}
+\cvarg{templ}{Searched template; must be not greater than the source image and the same data type as the image}
+\cvarg{result}{A map of comparison results; single-channel 32-bit floating-point.
+If \texttt{image} is $W \times H$ and
+\texttt{templ} is $w \times h$ then \texttt{result} must be $(W-w+1) \times (H-h+1)$}
+\cvarg{method}{Specifies the way the template must be compared with the image regions (see below)}
+\end{description}
+
+The function is similar to
+\cvCPyCross{CalcBackProjectPatch}. It slides through \texttt{image}, compares the
+overlapped patches of size $w \times h$ against \texttt{templ}
+using the specified method and stores the comparison results to
+\texttt{result}. Here are the formulas for the different comparison
+methods one may use ($I$ denotes \texttt{image}, $T$ \texttt{template},
+$R$ \texttt{result}). The summation is done over template and/or the
+image patch: $x' = 0...w-1, y' = 0...h-1$
+
+% \texttt{x'=0..w-1, y'=0..h-1}):
+
+\begin{description}
+\item[method=CV\_TM\_SQDIFF]
+\[ R(x,y)=\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2 \]
+
+\item[method=CV\_TM\_SQDIFF\_NORMED]
+\[ R(x,y)=\frac
+{\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2}
+{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
+\]
+
+\item[method=CV\_TM\_CCORR]
+\[ R(x,y)=\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y')) \]
+
+\item[method=CV\_TM\_CCORR\_NORMED]
+\[ R(x,y)=\frac
+{\sum_{x',y'} (T(x',y') \cdot I'(x+x',y+y'))}
+{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
+\]
+
+\item[method=CV\_TM\_CCOEFF]
+\[ R(x,y)=\sum_{x',y'} (T'(x',y') \cdot I(x+x',y+y')) \]
+
+where
+\[ 
+\begin{array}{l}
+T'(x',y')=T(x',y') - 1/(w \cdot h) \cdot \sum_{x'',y''} T(x'',y'')\\
+I'(x+x',y+y')=I(x+x',y+y') - 1/(w \cdot h) \cdot \sum_{x'',y''} I(x+x'',y+y'')
+\end{array}
+\]
+
+\item[method=CV\_TM\_CCOEFF\_NORMED]
+\[ R(x,y)=\frac
+{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }
+{ \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2} }
+\]
+\end{description}
+
+After the function finishes the comparison, the best matches can be found as global minimums (\texttt{CV\_TM\_SQDIFF}) or maximums (\texttt{CV\_TM\_CCORR} and \texttt{CV\_TM\_CCOEFF}) using the \cvCPyCross{MinMaxLoc} function. In the case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels (and separate mean values are used for each channel).
+
+\fi
+
+\ifCpp
+
+\cvCppFunc{matchTemplate}
+Compares a template against overlapped image regions.
+
+\cvdefCpp{void matchTemplate( const Mat\& image, const Mat\& templ,\par
+                    Mat\& result, int method );}
+\begin{description}
+\cvarg{image}{Image where the search is running; should be 8-bit or 32-bit floating-point}
+\cvarg{templ}{Searched template; must be not greater than the source image and have the same data type}
+\cvarg{result}{A map of comparison results; will be single-channel 32-bit floating-point.
+If \texttt{image} is $W \times H$ and
+\texttt{templ} is $w \times h$ then \texttt{result} will be $(W-w+1) \times (H-h+1)$}
+\cvarg{method}{Specifies the comparison method (see below)}
+\end{description}
+
+The function slides through \texttt{image}, compares the
+overlapped patches of size $w \times h$ against \texttt{templ}
+using the specified method and stores the comparison results to
+\texttt{result}. Here are the formulas for the available comparison
+methods ($I$ denotes \texttt{image}, $T$ \texttt{template},
+$R$ \texttt{result}). The summation is done over template and/or the
+image patch: $x' = 0...w-1, y' = 0...h-1$
+
+% \texttt{x'=0..w-1, y'=0..h-1}):
+
+\begin{description}
+\item[method=CV\_TM\_SQDIFF]
+\[ R(x,y)=\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2 \]
+
+\item[method=CV\_TM\_SQDIFF\_NORMED]
+\[ R(x,y)=\frac
+{\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2}
+{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
+\]
+
+\item[method=CV\_TM\_CCORR]
+\[ R(x,y)=\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y')) \]
+
+\item[method=CV\_TM\_CCORR\_NORMED]
+\[ R(x,y)=\frac
+{\sum_{x',y'} (T(x',y') \cdot I'(x+x',y+y'))}
+{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
+\]
+
+\item[method=CV\_TM\_CCOEFF]
+\[ R(x,y)=\sum_{x',y'} (T'(x',y') \cdot I(x+x',y+y')) \]
+
+where
+\[ 
+\begin{array}{l}
+T'(x',y')=T(x',y') - 1/(w \cdot h) \cdot \sum_{x'',y''} T(x'',y'')\\
+I'(x+x',y+y')=I(x+x',y+y') - 1/(w \cdot h) \cdot \sum_{x'',y''} I(x+x'',y+y'')
+\end{array}
+\]
+
+\item[method=CV\_TM\_CCOEFF\_NORMED]
+\[ R(x,y)=\frac
+{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }
+{ \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2} }
+\]
+\end{description}
+
+After the function finishes the comparison, the best matches can be found as global minimums (when \texttt{CV\_TM\_SQDIFF} was used) or maximums (when \texttt{CV\_TM\_CCORR} or \texttt{CV\_TM\_CCOEFF} was used) using the \cvCppCross{minMaxLoc} function. In the case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels (and separate mean values are used for each channel). That is, the function can take a color template and a color image; the result will still be a single-channel image, which is easier to analyze.
+
+\fi

doc/cv_object_detection.tex → doc/objdetect.tex

-\section{Object Detection}
+\section{Cascade Classification}
 
 \ifCPy
 
-\cvCPyFunc{MatchTemplate}
-Compares a template against overlapped image regions.
-
-\cvdefC{
-void cvMatchTemplate( \par const CvArr* image,\par const CvArr* templ,\par CvArr* result,\par int method );
-}\cvdefPy{MatchTemplate(image,templ,result,method)-> None}
-
-\begin{description}
-\cvarg{image}{Image where the search is running; should be 8-bit or 32-bit floating-point}
-\cvarg{templ}{Searched template; must be not greater than the source image and the same data type as the image}
-\cvarg{result}{A map of comparison results; single-channel 32-bit floating-point.
-If \texttt{image} is $W \times H$ and
-\texttt{templ} is $w \times h$ then \texttt{result} must be $(W-w+1) \times (H-h+1)$}
-\cvarg{method}{Specifies the way the template must be compared with the image regions (see below)}
-\end{description}
-
-The function is similar to
-\cvCPyCross{CalcBackProjectPatch}. It slides through \texttt{image}, compares the
-overlapped patches of size $w \times h$ against \texttt{templ}
-using the specified method and stores the comparison results to
-\texttt{result}. Here are the formulas for the different comparison
-methods one may use ($I$ denotes \texttt{image}, $T$ \texttt{template},
-$R$ \texttt{result}). The summation is done over template and/or the
-image patch: $x' = 0...w-1, y' = 0...h-1$
-
-% \texttt{x'=0..w-1, y'=0..h-1}):
-
-\begin{description}
-\item[method=CV\_TM\_SQDIFF]
-\[ R(x,y)=\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2 \]
-
-\item[method=CV\_TM\_SQDIFF\_NORMED]
-\[ R(x,y)=\frac
-{\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2}
-{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
-\]
-
-\item[method=CV\_TM\_CCORR]
-\[ R(x,y)=\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y')) \]
-
-\item[method=CV\_TM\_CCORR\_NORMED]
-\[ R(x,y)=\frac
-{\sum_{x',y'} (T(x',y') \cdot I'(x+x',y+y'))}
-{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
-\]
-
-\item[method=CV\_TM\_CCOEFF]
-\[ R(x,y)=\sum_{x',y'} (T'(x',y') \cdot I(x+x',y+y')) \]
-
-where
-\[ 
-\begin{array}{l}
-T'(x',y')=T(x',y') - 1/(w \cdot h) \cdot \sum_{x'',y''} T(x'',y'')\\
-I'(x+x',y+y')=I(x+x',y+y') - 1/(w \cdot h) \cdot \sum_{x'',y''} I(x+x'',y+y'')
-\end{array}
-\]
-
-\item[method=CV\_TM\_CCOEFF\_NORMED]
-\[ R(x,y)=\frac
-{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }
-{ \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2} }
-\]
-\end{description}
-
-After the function finishes the comparison, the best matches can be found as global minimums (\texttt{CV\_TM\_SQDIFF}) or maximums (\texttt{CV\_TM\_CCORR} and \texttt{CV\_TM\_CCOEFF}) using the \cvCPyCross{MinMaxLoc} function. In the case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels (and separate mean values are used for each channel).
-
 \subsection{Haar Feature-based Cascade Classifier for Object Detection}
 
 The object detector described below has been initially proposed by Paul Viola
@@ -701,68 +635,4 @@ Groups the object candidate rectangles
 \end{description}
 
 The function is a wrapper for a generic function \cvCppCross{partition}. It clusters all the input rectangles using the rectangle equivalence criteria, that combines rectangles that have similar sizes and similar locations (the similarity is defined by \texttt{eps}). When \texttt{eps=0}, no clustering is done at all. If $\texttt{eps}\rightarrow +\inf$, all the rectangles will be put in one cluster. Then, the small clusters, containing less than or equal to \texttt{groupThreshold} rectangles, will be rejected. In each other cluster the average rectangle will be computed and put into the output rectangle list.  
-
-\cvCppFunc{matchTemplate}
-Compares a template against overlapped image regions.
-
-\cvdefCpp{void matchTemplate( const Mat\& image, const Mat\& templ,\par
-                    Mat\& result, int method );}
-\begin{description}
-\cvarg{image}{Image where the search is running; should be 8-bit or 32-bit floating-point}
-\cvarg{templ}{Searched template; must be not greater than the source image and have the same data type}
-\cvarg{result}{A map of comparison results; will be single-channel 32-bit floating-point.
-If \texttt{image} is $W \times H$ and
-\texttt{templ} is $w \times h$ then \texttt{result} will be $(W-w+1) \times (H-h+1)$}
-\cvarg{method}{Specifies the comparison method (see below)}
-\end{description}
-
-The function slides through \texttt{image}, compares the
-overlapped patches of size $w \times h$ against \texttt{templ}
-using the specified method and stores the comparison results to
-\texttt{result}. Here are the formulas for the available comparison
-methods ($I$ denotes \texttt{image}, $T$ \texttt{template},
-$R$ \texttt{result}). The summation is done over template and/or the
-image patch: $x' = 0...w-1, y' = 0...h-1$
-
-% \texttt{x'=0..w-1, y'=0..h-1}):
-
-\begin{description}
-\item[method=CV\_TM\_SQDIFF]
-\[ R(x,y)=\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2 \]
-
-\item[method=CV\_TM\_SQDIFF\_NORMED]
-\[ R(x,y)=\frac
-{\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2}
-{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
-\]
-
-\item[method=CV\_TM\_CCORR]
-\[ R(x,y)=\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y')) \]
-
-\item[method=CV\_TM\_CCORR\_NORMED]
-\[ R(x,y)=\frac
-{\sum_{x',y'} (T(x',y') \cdot I'(x+x',y+y'))}
-{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
-\]
-
-\item[method=CV\_TM\_CCOEFF]
-\[ R(x,y)=\sum_{x',y'} (T'(x',y') \cdot I(x+x',y+y')) \]
-
-where
-\[ 
-\begin{array}{l}
-T'(x',y')=T(x',y') - 1/(w \cdot h) \cdot \sum_{x'',y''} T(x'',y'')\\
-I'(x+x',y+y')=I(x+x',y+y') - 1/(w \cdot h) \cdot \sum_{x'',y''} I(x+x'',y+y'')
-\end{array}
-\]
-
-\item[method=CV\_TM\_CCOEFF\_NORMED]
-\[ R(x,y)=\frac
-{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }
-{ \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2} }
-\]
-\end{description}
-
-After the function finishes the comparison, the best matches can be found as global minimums (when \texttt{CV\_TM\_SQDIFF} was used) or maximums (when \texttt{CV\_TM\_CCORR} or \texttt{CV\_TM\_CCOEFF} was used) using the \cvCppCross{minMaxLoc} function. In the case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels (and separate mean values are used for each channel). That is, the function can take a color template and a color image; the result will still be a single-channel image, which is easier to analyze.
-
 \fi

doc/online-opencv.tex

@@ -20,35 +20,55 @@
 \tableofcontents
 
 %%% Chapters %%%
-\input{cxcore_introduction}
-
-\chapter{cxcore. The Core Functionality}
-\input{cxcore_basic_structures}
-\input{cxcore_array_operations}
-\input{cxcore_dynamic_structures}
-\input{cxcore_drawing_functions}
-\input{cxcore_persistence}
-\input{cxcore_clustering_search}
-\input{cxcore_utilities_system_functions}
-
-\chapter{cv. Image Processing and Computer Vision}
-\input{cv_image_filtering}
-\input{cv_image_warping}
-\input{cv_image_transform}
-\input{cv_histograms}
-\input{cv_feature_detection}
-\input{cv_motion_tracking}
-\input{cv_struct_shape_analysis}
-\input{cv_planar_subdivisions}
-\input{cv_object_detection}
-\input{cv_calibration_3d}
-\input{cv_object_recognition}
-
-\chapter{highgui. High-level GUI and Media IO}
-\input{HighGui}
+\input{core_introduction}
+
+\chapter{core. The Core Functionality}
+\input{core_basic_structures}
+\input{core_array_operations}
+\input{core_dynamic_structures}
+\input{core_drawing_functions}
+\input{core_persistence}
+\input{core_clustering_search}
+\input{core_utilities_system_functions}
+
+
+\chapter{imgproc. Image Processing}
+\input{imgproc_histograms}
+\input{imgproc_image_filtering}
+\input{imgproc_image_warping}
+\input{imgproc_image_transform}
+\input{imgproc_struct_shape_analysis}
+\input{imgproc_planar_subdivisions}
+\input{imgproc_motion_tracking}
+\input{imgproc_feature_detection}
+
+\chapter{features2d. Feature Detection and Descriptor Extraction}
+\input{features2d_feature_detection}
+%\input{features2d_object_recognition}
+%\input{features2d_object_detection}
+
+\chapter{flann. Clustering and Search in Multi-Dimensional Spaces}
+\input{flann}
+
+\chapter{objdetect. Object Detection}
+\input{objdetect}
+
+\chapter{video. Video Analysis}
+\input{video_motion_tracking}
+
+\chapter{highgui. High-level GUI and Media I/O}
+\input{highgui}
+\ifPy     %Qt is for C and Cpp, so do nothing
+\else
+\input{highgui_qt}
+\fi
+
+\chapter{calib3d. Camera Calibration, Pose Estimation and Stereo}
+\input{calib3d}
+
 
 \chapter{ml. Machine Learning}
-\input{MachineLearning}
+\input{ml}
 %%%%%%%%%%%%%%%%
 
 \end{document}             % End of document.

doc/opencvref_body.tex

-\input{cxcore_introduction}
-
-\chapter{cxcore. The Core Functionality}
-\input{cxcore_basic_structures}
-\input{cxcore_array_operations}
-\input{cxcore_dynamic_structures}
-\input{cxcore_drawing_functions}
-\input{cxcore_persistence}
-\input{cxcore_clustering_search}
-\input{cxcore_utilities_system_functions}
-
-\chapter{cv. Image Processing and Computer Vision}
-\input{cv_image_filtering}
-\input{cv_image_warping}
-\input{cv_image_transform}
-\input{cv_histograms}
-\input{cv_feature_detection}
-\input{cv_motion_tracking}
-\input{cv_struct_shape_analysis}
-\input{cv_planar_subdivisions}
-\input{cv_object_detection}
-\input{cv_calibration_3d}
-\input{cv_object_recognition}
-
-\chapter{cvaux. Extra Computer Vision Functionality}
-\input{cvaux_bgfg}
-\input{cvaux_object_detection}
-\input{cvaux_3d}
+\input{core_introduction}
+
+\chapter{core. The Core Functionality}
+\input{core_basic_structures}
+\input{core_array_operations}
+\input{core_dynamic_structures}
+\input{core_drawing_functions}
+\input{core_persistence}
+\input{core_clustering_search}
+\input{core_utilities_system_functions}
+
+
+\chapter{imgproc. Image Processing}
+\input{imgproc_histograms}
+\input{imgproc_image_filtering}
+\input{imgproc_image_warping}
+\input{imgproc_image_transform}
+\input{imgproc_struct_shape_analysis}
+\input{imgproc_planar_subdivisions}
+\input{imgproc_motion_tracking}
+\input{imgproc_feature_detection}
+
+\chapter{features2d. Feature Detection and Descriptor Extraction}
+\input{features2d_feature_detection}
+\input{features2d_object_recognition}
+\input{features2d_object_detection}
+
+\chapter{flann. Clustering and Search in Multi-Dimensional Spaces}
+\input{flann}
+
+\chapter{objdetect. Object Detection}
+\input{objdetect}
+
+\chapter{video. Video Analysis}
+\input{video_motion_tracking}
 
 \chapter{highgui. High-level GUI and Media I/O}
-\input{HighGui}
+\input{highgui}
 \ifPy     %Qt is for C and Cpp, so do nothing
 \else
-\input{HighGui_Qt}
+\input{highgui_qt}
 \fi
 
+\chapter{calib3d. Camera Calibration, Pose Estimation and Stereo}
+\input{calib3d}
+
+
 \chapter{ml. Machine Learning}
-\input{MachineLearning}
+\input{ml}
+
+

doc/cv_motion_tracking.tex → doc/video_motion_tracking.tex

@@ -2,24 +2,6 @@
 
 \ifCPy
 
-\cvCPyFunc{Acc}
-Adds a frame to an accumulator.
-
-\cvdefC{
-void cvAcc( \par const CvArr* image,\par CvArr* sum,\par const CvArr* mask=NULL );
-}
-\cvdefPy{Acc(image,sum,mask=NULL)-> None}
-
-\begin{description}
-\cvarg{image}{Input image, 1- or 3-channel, 8-bit or 32-bit floating point. (each channel of multi-channel image is processed independently)}
-\cvarg{sum}{Accumulator with the same number of channels as input image, 32-bit or 64-bit floating-point}
-\cvarg{mask}{Optional operation mask}
-\end{description}
-
-The function adds the whole image \texttt{image} or its selected region to the accumulator \texttt{sum}:
-
-\[ \texttt{sum}(x,y) \leftarrow \texttt{sum}(x,y) + \texttt{image}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
-
 \cvCPyFunc{CalcGlobalOrientation}
 Calculates the global motion orientation of some selected region.
 
@@ -620,25 +602,6 @@ iterations are made until the search window center moves by less than
 the given value and/or until the function has done the maximum number
 of iterations. The function returns the number of iterations made.
 
-\cvCPyFunc{MultiplyAcc}
-Adds the product of two input images to the accumulator.
-
-\cvdefC{
-void cvMultiplyAcc( \par const CvArr* image1,\par const CvArr* image2,\par CvArr* acc,\par const CvArr* mask=NULL );
-}
-\cvdefPy{MultiplyAcc(image1,image2,acc,mask=NULL)-> None}
-
-\begin{description}
-\cvarg{image1}{First input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)}
-\cvarg{image2}{Second input image, the same format as the first one}
-\cvarg{acc}{Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point}
-\cvarg{mask}{Optional operation mask}
-\end{description}
-
-The function adds the product of 2 images or their selected regions to the accumulator \texttt{acc}:
-
-\[ \texttt{acc}(x,y) \leftarrow \texttt{acc}(x,y) + \texttt{image1}(x,y) \cdot \texttt{image2}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
-
 \ifC % {
 \cvCPyFunc{ReleaseConDensation}
 Deallocates the ConDensation filter structure.
@@ -672,30 +635,6 @@ The function releases the structure \cvCPyCross{CvKalman} and all of the underly
 
 \fi % }
 
-\cvCPyFunc{RunningAvg}
-Updates the running average.
-
-\cvdefC{
-void cvRunningAvg( \par const CvArr* image,\par CvArr* acc,\par double alpha,\par const CvArr* mask=NULL );
-}
-\cvdefPy{RunningAvg(image,acc,alpha,mask=NULL)-> None}
-
-\begin{description}
-\cvarg{image}{Input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)}
-\cvarg{acc}{Accumulator with the same number of channels as input image, 32-bit or 64-bit floating-point}
-\cvarg{alpha}{Weight of input image}
-\cvarg{mask}{Optional operation mask}
-\end{description}
-
-The function calculates the weighted sum of the input image
-\texttt{image} and the accumulator \texttt{acc} so that \texttt{acc}
-becomes a running average of frame sequence:
-
-\[ \texttt{acc}(x,y) \leftarrow (1-\alpha) \cdot \texttt{acc}(x,y) + \alpha \cdot \texttt{image}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
-
-where $\alpha$ regulates the update speed (how fast the accumulator forgets about previous frames).
-
-
 \cvCPyFunc{SegmentMotion}
 Segments a whole motion into separate moving parts.
 
@@ -772,23 +711,6 @@ than \texttt{criteria.epsilon} or the function performed
 The function returns the updated list of points.
 \fi
 
-\cvCPyFunc{SquareAcc}
-Adds the square of the source image to the accumulator.
-
-\cvdefC{
-void cvSquareAcc( \par const CvArr* image,\par CvArr* sqsum,\par const CvArr* mask=NULL );
-}\cvdefPy{SquareAcc(image,sqsum,mask=NULL)-> None}
-
-\begin{description}
-\cvarg{image}{Input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)}
-\cvarg{sqsum}{Accumulator with the same number of channels as input image, 32-bit or 64-bit floating-point}
-\cvarg{mask}{Optional operation mask}
-\end{description}
-
-The function adds the input image \texttt{image} or its selected region, raised to power 2, to the accumulator \texttt{sqsum}:
-
-\[ \texttt{sqsum}(x,y) \leftarrow \texttt{sqsum}(x,y) + \texttt{image}(x,y)^2 \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
-
 \cvCPyFunc{UpdateMotionHistory}
 Updates the motion history image by a moving silhouette.
 
@@ -817,87 +739,6 @@ That is, MHI pixels where motion occurs are set to the current timestamp, while
 
 \ifCpp
 
-\cvCppFunc{accumulate}
-Adds image to the accumulator.
-
-\cvdefCpp{void accumulate( const Mat\& src, Mat\& dst, const Mat\& mask=Mat() );}
-\begin{description}
-\cvarg{src}{The input image, 1- or 3-channel, 8-bit or 32-bit floating point}
-\cvarg{dst}{The accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point}
-\cvarg{mask}{Optional operation mask}
-\end{description}
-
-The function adds \texttt{src}, or some of its elements, to \texttt{dst}:
-
-\[ \texttt{dst}(x,y) \leftarrow \texttt{dst}(x,y) + \texttt{src}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
-
-The function supports multi-channel images; each channel is processed independently.
-
-The functions \texttt{accumulate*} can be used, for example, to collect statistic of background of a scene, viewed by a still camera, for the further foreground-background segmentation.
-
-See also: \cvCppCross{accumulateSquare}, \cvCppCross{accumulateProduct}, \cvCppCross{accumulateWeighted}
-
-\cvCppFunc{accumulateSquare}
-Adds the square of the source image to the accumulator.
-
-\cvdefCpp{void accumulateSquare( const Mat\& src, Mat\& dst, \par const Mat\& mask=Mat() );}
-\begin{description}
-\cvarg{src}{The input image, 1- or 3-channel, 8-bit or 32-bit floating point}
-\cvarg{dst}{The accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point}
-\cvarg{mask}{Optional operation mask}
-\end{description}
-
-The function adds the input image \texttt{src} or its selected region, raised to power 2, to the accumulator \texttt{dst}:
-
-\[ \texttt{dst}(x,y) \leftarrow \texttt{dst}(x,y) + \texttt{src}(x,y)^2 \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
-
-The function supports multi-channel images; each channel is processed independently.
-
-See also: \cvCppCross{accumulateSquare}, \cvCppCross{accumulateProduct}, \cvCppCross{accumulateWeighted}
-
-\cvCppFunc{accumulateProduct}
-Adds the per-element product of two input images to the accumulator.
-
-\cvdefCpp{void accumulateProduct( const Mat\& src1, const Mat\& src2,\par
-                        Mat\& dst, const Mat\& mask=Mat() );}
-\begin{description}
-\cvarg{src1}{The first input image, 1- or 3-channel, 8-bit or 32-bit floating point}
-\cvarg{src2}{The second input image of the same type and the same size as \texttt{src1}}
-\cvarg{dst}{Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point}
-\cvarg{mask}{Optional operation mask}
-\end{description}
-
-The function adds the product of 2 images or their selected regions to the accumulator \texttt{dst}:
-
-\[ \texttt{dst}(x,y) \leftarrow \texttt{dst}(x,y) + \texttt{src1}(x,y) \cdot \texttt{src2}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
-
-The function supports multi-channel images; each channel is processed independently.
-
-See also: \cvCppCross{accumulate}, \cvCppCross{accumulateSquare}, \cvCppCross{accumulateWeighted}
-
-\cvCppFunc{accumulateWeighted}
-Updates the running average.
-
-\cvdefCpp{void accumulateWeighted( const Mat\& src, Mat\& dst,\par
-                         double alpha, const Mat\& mask=Mat() );}
-\begin{description}
-\cvarg{src}{The input image, 1- or 3-channel, 8-bit or 32-bit floating point}
-\cvarg{dst}{The accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point}
-\cvarg{alpha}{Weight of the input image}
-\cvarg{mask}{Optional operation mask}
-\end{description}
-
-The function calculates the weighted sum of the input image
-\texttt{src} and the accumulator \texttt{dst} so that \texttt{dst}
-becomes a running average of frame sequence:
-
-\[ \texttt{dst}(x,y) \leftarrow (1-\texttt{alpha}) \cdot \texttt{dst}(x,y) + \texttt{alpha} \cdot \texttt{src}(x,y) \quad \text{if} \quad \texttt{mask}(x,y) \ne 0 \]
-
-that is, \texttt{alpha} regulates the update speed (how fast the accumulator "forgets" about earlier images).
-The function supports multi-channel images; each channel is processed independently.
-
-See also: \cvCppCross{accumulate}, \cvCppCross{accumulateSquare}, \cvCppCross{accumulateProduct}
-
 \cvCppFunc{calcOpticalFlowPyrLK}
 Calculates the optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids