COMP27112: Visual Computing Lab 4
COMP27112: Visual Computing
Lab 4
Lecturer: Terence Morley
1 Introduction
For this practical assignment you should use C/C++ and OpenCV to develop the code. Your code, results and
comments MUST be submitted in a single PDF file. Only submit the PDF file.
You should use the supplied images for your processing and include them in your report.
For ease of marking, please lay out your report in sections using the titles given in this document.
You will probably need to refer to the OpenCV documentation website: https://docs.opencv.org/4.8.0/.
2 Intended Learning Outcomes
By the end of this assignment, you should be able to:
• Implement image processing code using C/C++ and OpenCV
• Create an image processing function that you can add to your own library
• Choose combinations of techniques in order to solve an image processing problem (that is, a image processing pipeline, or workflow)
3 Image Histogram and Segmentation [10 Marks]
3.1 Histogram
Image segmentation is the process of partitioning an image into distinct parts (regions or objects). Thresholding
is a simple way to do this, and the result is a binary image (that is, one that consists of two levels: black and
white for example).
Imagine that you want to write software to help a drone navigate in a desert by following roads. You might
want to segment the drone camera image into sand and road. This is shown in the following image where sand
is labelled white and the road is labelled black.
The grey-level threshold that was used in the above thresholding problem was 110. But how do you decide
which threshold value to use? 代 写COMP27112: Visual ComputingIt is often done by examining a histogram of the image, as shown below.
Department of Computer Science, The University of Manchester (Jan 2024) Page 1 of 7
COMP27112: Visual Computing Lab 4
In this histogram image, a vertical bar is drawn in black to represent the number of pixels in the image with
a particular grey level (0–255). The grey vertical gridlines mark 0, 64, 128, 192, and 255. Two peaks can be
seen in this image: a large one at the lighter end (the sand), and a small one at the darker end (the road). A
suitable threshold value, between the two peaks, can be estimated at around 110.
⋆ TASK
Write a function that creates a histogram image like the one shown above. The image must be 400 pixels high
and 512 pixels wide. Because it is 512 pixels wide and the horizontal axis should represent 256 grey levels
(0–255), each bar should be two pixels wide. You can use the supplied histogram.cpp as a starting point.
The highest count in the histogram should be drawn to the full height of the image. If the count for a grey-level
is zero, no bar should be drawn.
You must write your own code to count the number of occurrences of each grey level, and to scale the counts to
fit the image. You must not use the OpenCV calcHist() function nor something similar from other libraries.
You can draw the bars by setting pixels in the image or by drawing lines or rectangles with OpenCV functions.
Drawing the gridlines is optional, but if you do add them, it will make your function more helpful. The gridlines
in the above image were drawn in light grey to avoid them being mistaken for bars, and the bars were drawn
over the top of the gridlines (that is, the gridlines were drawn first).
Your REPORT should contain the source code for your histogram function and the histogram image for these
two supplied images:
circuit board.jpg science person.jpg
NOTE If you use LATEX to write your report, you might include your code using the listings package:
usepackage{listings}
...
egin{lstlisting}[language=C++]
int x = 123;
end{lstlisting}
3.2 Thresholding
For this part, you should use your histogram function to help you choose suitable threshold values. If you failed
to do that part of the assignment, you can use an image manipulation program such as gimp that provides a
Department of Computer Science, The University of Manchester (Jan 2024) Page 2 of 7
COMP27112: Visual Computing Lab 4
histogram display. The gimp program is available for Linux, Windows and macOS.
You may also use the programs that you created in the previous lab for doing OTSU thresholding and interactive
thresholding.
⋆ TASK
Choose an appropriate threshold value for each of the following problems, and give a brief description of any
problems encountered or any observations.
Filename Problem
fundus.tif This is taken from a set of images used to train and test algorithms
for recognising the effects of diabetes on the retina. The aim of the
processing is to identify the blood vessels
glaucoma.jpg This is an image taken from a set used to train ophthalmologists to
recognise glaucoma. The aim of processing is to find the diffuse bright
region towards the middle and the brighter area inside it.
optic nerve head.jpg This was an image captured by a bespoke device that gives a tightly
framed image of the optic nerve head. The aim of processing is to find
the outlines of the large, slightly bright area and the smaller brighter
area inside it.
motorway.png This is an image from the internet of a motorway destination sign. Car
manufacturers have deployed systems that read speed limit signs. A next
step would be to read these signs. So the aim would be to find the white
text.
In your REPORT, include the following for each problem:
• the original image
• the image histogram
• thresholded image
• threshold value that was chosen
• a brief description of any observations you made
4 Horizon Detection [10 Marks]
This section asks you to find, and plot, a polynomial that represents the horizon in the following images:
horizon1.jpg horizon2.png horizon3.jpg
4.1 Processing Pipeline
You will need to do some form of edge detection that finds the edge between the Earth and space in two of the
images, and sea and sky in the final one. You might think that you could do binary thresholding first and then
Department of Computer Science, The University of Manchester (Jan 2024) Page 3 of 7
COMP27112: Visual Computing Lab 4
do edge detection, but you will find that there are lots of areas of misclassification that you will need to deal
with.
This lab asks you to use the Canny edge detector and the Hough line transform in your processing pipeline.
You should attempt to process the images in the following way:
• Convert the image into greyscale (if necessary)
• Apply a Canny filter on the image, leaving us with an image of the edges
• Apply a probabilistic Hough transformation that will return a list of pairs of Points defining the start and
end coordinates for line segments.
• Filter out the short lines, use Pythagoras to compute the lines’ lengths.
• Filter out the vertical lines. You could do that by either calculating the inverse tangent of each line
(use atan2), finding its angle from the horizontal, or check whether the x co-ordinates of the segment’s
endpoints are similar.
• Now that you are left with all the (nearly) horizontal lines’ points, find a curve that best fits all those
points. This is called polynomial regression. It takes some points and calculates the best polynomial of
any order that you choose that fits all the points. Be careful not to overfit the points though; since the
horizon curve best matches a quadratic function choosing a higher order polynomial can give you unstable
results, i.e. a very wavy line.
Your program will need to use a number of parameters. It would be ideal if a single set of parameters
could be used to process all images of this type, but that often isn’t possible.
You should allow for your program to use different parameter values. This might be achieved by passing
them in as command-line parameters, using a switch-statement, or just by using three set of constants,
two of which being commented out for each image.
NOTE You are supplied with some code to help you with this lab, see horizon.cpp. The contents of this file
are shown below.
The fitPoly function, shown below, accepts a list of points. It calculates a line (curve) of best fit through
those points. You also specify an order for the poylonimial, n (if you are expecting a straight line, you would
set n to 1, for example). The function returns the polymomial as a vector of doubles, the order of which is the
order of coefficients: a + bx + cx2 + . . .. You might want to set up a vector with a few points and try out this
function so that you are clear on its operation.
1 //Polynomial regression function
2 std::vector<double> fitPoly(std::vector<cv::Point> points, int n)
3 {
4 //Number of points
5 int nPoints = points.size();
6
7 //Vectors for all the points’ xs and ys
8 std::vector<float> xValues = std::vector<float>();
9 std::vector<float> yValues = std::vector<float>();
10
11 //Split the points into two vectors for x and y values
12 for(int i = 0; i < nPoints; i++)
13 {
14 xValues.push_back(points[i].x);
15 yValues.push_back(points[i].y);
16 }
17
18 //Augmented matrix
19 double matrixSystem[n+1][n+2];
20 for(int row = 0; row < n+1; row++)
Department of Computer Science, The University of Manchester (Jan 2024) Page 4 of 7
COMP27112: Visual Computing Lab 4
21 {
22 for(int col = 0; col < n+1; col++)
23 {
24 matrixSystem[row][col] = 0;
25 for(int i = 0; i < nPoints; i++)
26 matrixSystem[row][col] += pow(xValues[i], row + col);
27 }
28
29 matrixSystem[row][n+1] = 0;
30 for(int i = 0; i < nPoints; i++)
31 matrixSystem[row][n+1] += pow(xValues[i], row) * yValues[i];
32
33 }
34
35 //Array that holds all the coefficients
36 double coeffVec[n+2] = {}; // the "= {}" is needed in visual studio, but not in Linux
37
38 //Gauss reduction
39 for(int i = 0; i <= n-1; i++)
40 for (int k=i+1; k <= n; k++)
41 {
42 double t=matrixSystem[k][i]/matrixSystem[i][i];
43
44 for (int j=0;j<=n+1;j++)
45 matrixSystem[k][j]=matrixSystem[k][j]-t*matrixSystem[i][j];
46
47 }
48
49 //Back-substitution
50 for (int i=n;i>=0;i--)
51 {
52 coeffVec[i]=matrixSystem[i][n+1];
53 for (int j=0;j<=n+1;j++)
54 if (j!=i)
55 coeffVec[i]=coeffVec[i]-matrixSystem[i][j]*coeffVec[j];
56
57 coeffVec[i]=coeffVec[i]/matrixSystem[i][i];
58 }
59
60 //Construct the vector and return it
61 std::vector<double> result = std::vector<double>();
62 for(int i = 0; i < n+1; i++)
63 result.push_back(coeffVec[i]);
64 return result;
65 }
As part of this lab, you will be asked to draw the detected horizon from the polynomial onto the image. The
function pointAtX(), shown below, will help you with that. If you provide it with an x-coordinate and the
polynomial coefficients, it will return a point (x, y) (that is, it will calculate the y-coordinate for you and return
it as a point that you might use in an OpenCV function).
1 //Returns the point for the equation determined
2 //by a vector of coefficents, at a certain x location
3 cv::Point pointAtX(std::vector<double> coeff, double x)
4 {
5 double y = 0;
6 for(int i = 0; i < coeff.size(); i++)
7 y += pow(x, i) * coeff[i];
8 return cv::Point(x, y);
9 }
⋆ TASK
Write a program to perform the processing pipeline described above. Use the supplied fitPoly() and pointAtX()
as well as the OpenCV functions Canny() and HoughLinesP().
Department of Computer Science, The University of Manchester (Jan 2024) Page 5 of 7
COMP27112: Visual Computing Lab 4
You will need to experiment with the parameters for the Canny and Hough functions and other processing that
you do. You will probably need different values for each image that you process, so make them easier to work
with in your program. That is, don’t just hard-code values into your function calls.
Make sure that you understand the purpose of the Canny parameters lowerThreshold and upperThreshold;
and the Hough parameters rho, theta, threshold, minLen, maxGap.
Once you have obtained a polynomial that follows the line of the horizon, draw the line/curve on the original
colour image. Make it stand out by drawing it in a bright colour and don’t draw the line too narrow (nor so
thick that it disguises an inaccurate detection). You might draw this line by setting pixels in the image, or by
using the OpenCV functions circle() or line().
Your REPORT should include your code.
4.2 Processing
Now that you have written your program to detect the horizon in an image, use it on the provided horizon
images.
⋆ TASK
Run your program on each of the three supplied horizon images. You may need to choose different parameter
values to get a good result in each image.
You might have trouble with noise in a couple of the images. If that is the case (and you can’t select parameter
values to achieve the aim), try adding some extra processing to your pipeline, but make sure that the horizon
is detected accurately.
In your REPORT, include the following for each horizon image:
• The original image
• The Canny edge image
• The image with all of the probabilistic Hough lies drawn
• The image with the short lines removed
• The image with only the (approximately) horizontal lines
• The image with the horizon drawn
• The set of parameter values with an obvious name for the parameter
• If you needed to add extra processing, give a brief description
NOTE Draw your Hough lines and the final horizon in colour onto the original colour image.
Optional: The horizon in the oil-rig image needs rotating clockwise to make it horizontal. Calculate the angle
that it needs to be rotated by (in degrees). Hint: use your calculated polynomial. Show your working and state
an OpenCV function that can rotate the image. Rotate the image to make the horizon horizontal. Do you have
any observations on your result?
Department of Computer Science, The University of Manchester (Jan 2024) Page 6 of 7
COMP27112: Visual Computing Lab 4
5 Marking Scheme
3.1 Write a function to create a histogram image. 5 marks
3.1 Show histogram for the images circuit board.jpg and science person.jpg. 1 marks
3.2 Threshold the images fundus.tif, glaucoma.jpg, optic nerve head.jpg,
and motorway.png. One mark for each image for supplying the output image,
threshold value, and observations.
4 marks
4.1 Write code that performs the stated horizon-detection processing pipeline. 4 marks
4.2 Process the three images (horizon1, horizon2, horizon3) and draw the detected
horizon from the polynomial on the original colour image. Include the requested
images at the intermediate stages as well as the parameter values used. Two
marks for each horizon image.
6 marks
Total 20 marks
Check-list
Have you:
• Created a well-formatted report?
• Included input, intermediate, and output images with useful labels?
• Chosen a size for your images so that the details can be seen, but not so big that the document covers
too many pages? (See the images in this document.)
• Included the code?
Submit your report as a single pdf document on Blackboard.
Do not include any other files or zip it – just submit a pdf.
Department of Computer Science, The University of Manchester (Jan 2024) Page 7 WX：codinghelp

请加QQ：99515681  邮箱：99515681@qq.com   WX：codinghelp

标签：