~paparazzi-uav/paparazzi/v5.0-manual

\f[\frac{1}{16} \begin{bmatrix} 1 & 4 & 6 & 4 & 1 \\ 4 & 16 & 24 & 16 & 4 \\ 6 & 24 & 36 & 24 & 6 \\ 4 & 16 & 24 & 16 & 4 \\ 1 & 4 & 6 & 4 & 1 \end{bmatrix}\f]

- Remove every even-numbered row and column.

- You can easily notice that the resulting image will be exactly one-quarter the area of its

predecessor. Iterating this process on the input image \f$G_{0}\f$ (original image) produces the

entire pyramid.

- The procedure above was useful to downsample an image. What if we want to make it bigger?:

columns filled with zeros (\f$0\f$)

- First, upsize the image to twice the original in each dimension, wit the new even rows and

- Perform a convolution with the same kernel shown above (multiplied by 4) to approximate the

values of the "missing pixels"

- These two procedures (downsampling and upsampling as explained above) are implemented by the

OpenCV functions @ref cv::pyrUp and @ref cv::pyrDown , as we will see in an example with the

code below:

@note When we reduce the size of an image, we are actually *losing* information of the image.

Code

----

This tutorial code's is shown lines below. You can also download it from

[here](https://github.com/Itseez/opencv/tree/master/samples/cpp/tutorial_code/ImgProc/Pyramids.cpp)

@include samples/cpp/tutorial_code/ImgProc/Pyramids.cpp

Explanation

-----------

Let's check the general structure of the program:

- Load an image (in this case it is defined in the program, the user does not have to enter it

as an argument)

@code{.cpp}

/// Test image - Make sure it s divisible by 2^{n}

src = imread( "../images/chicky_512.jpg" );

if( !src.data )

{ printf(" No data! -- Exiting the program \n");

return -1; }

@endcode

- Create a Mat object to store the result of the operations (*dst*) and one to save temporal

results (*tmp*).

@code{.cpp}

Mat src, dst, tmp;

/* ... */

tmp = src;

dst = tmp;

@endcode

- Create a window to display the result

@code{.cpp}

namedWindow( window_name, WINDOW_AUTOSIZE );

100

imshow( window_name, dst );

101

@endcode

102

103

- Perform an infinite loop waiting for user input.

104

@code{.cpp}

105

while( true )

106

{

107

int c;

108

c = waitKey(10);

109

110

if( (char)c == 27 )

111

{ break; }

112

if( (char)c == 'u' )

113

{ pyrUp( tmp, dst, Size( tmp.cols*2, tmp.rows*2 ) );

114

printf( "** Zoom In: Image x 2 \n" );

115

}

116

else if( (char)c == 'd' )

117

{ pyrDown( tmp, dst, Size( tmp.cols/2, tmp.rows/2 ) );

118

printf( "** Zoom Out: Image / 2 \n" );

119

}

120

121

imshow( window_name, dst );

122

tmp = dst;

123

}

124

@endcode

125

Our program exits if the user presses *ESC*. Besides, it has two options:

126

127

- **Perform upsampling (after pressing 'u')**

128

@code{.cpp}

129

pyrUp( tmp, dst, Size( tmp.cols*2, tmp.rows*2 )

130

@endcode

131

We use the function @ref cv::pyrUp with 03 arguments:

132

133

- *tmp*: The current image, it is initialized with the *src* original image.

134

- *dst*: The destination image (to be shown on screen, supposedly the double of the

135

input image)

136

- *Size( tmp.cols*2, tmp.rows\*2 )\* : The destination size. Since we are upsampling,

137

@ref cv::pyrUp expects a size double than the input image (in this case *tmp*).

138

- **Perform downsampling (after pressing 'd')**

139

@code{.cpp}

140

pyrDown( tmp, dst, Size( tmp.cols/2, tmp.rows/2 )

141

@endcode

142

Similarly as with @ref cv::pyrUp , we use the function @ref cv::pyrDown with 03

143

arguments:

144

145

- *tmp*: The current image, it is initialized with the *src* original image.

146

- *dst*: The destination image (to be shown on screen, supposedly half the input

147

image)

148

- *Size( tmp.cols/2, tmp.rows/2 )* : The destination size. Since we are upsampling,

149

@ref cv::pyrDown expects half the size the input image (in this case *tmp*).

150

- Notice that it is important that the input image can be divided by a factor of two (in

151

both dimensions). Otherwise, an error will be shown.

152

- Finally, we update the input image **tmp** with the current image displayed, so the

153

subsequent operations are performed on it.

154

@code{.cpp}

155

tmp = dst;

156

@endcode

157

158

Results

159

-------

160

161

- After compiling the code above we can test it. The program calls an image **chicky_512.jpg**

162

that comes in the *tutorial_code/image* folder. Notice that this image is \f$512 \times 512\f$,

163

hence a downsample won't generate any error (\f$512 = 2^{9}\f$). The original image is shown below:

164

165

![](images/Pyramids_Tutorial_Original_Image.jpg)

166

167

- First we apply two successive @ref cv::pyrDown operations by pressing 'd'. Our output is:

168

169

![](images/Pyramids_Tutorial_PyrDown_Result.jpg)

170

171

- Note that we should have lost some resolution due to the fact that we are diminishing the size

172

of the image. This is evident after we apply @ref cv::pyrUp twice (by pressing 'u'). Our output

173

is now:

174

175

![](images/Pyramids_Tutorial_PyrUp_Result.jpg)

Older »