FIT5221代写、代做Python语言编程

日期：2025-04-14 10:09

FIT5221 - Assignment 1

There are four tasks in this assignment:

- Harris corner detection (8 marks)

- Homography estimation (2 marks)

- RANSAC (6 marks)

- Image stitching (4 marks)

Available: 14-Mar-2025.

Submission due: 11.55 PM, 9-April-2025.

Instructions:

1. All code should be in Python (>=3.7.x). You should write appropriate comments through the code.

2. For tasks requiring self-implementation, you are only allowed to use Numpy, SciPy, skimage, matplotlib,

and Python built-in libraries.

3. Late submission penalty: 5% marks per day or part thereof.

4. Submission is to be made only on Moodle.

5. Plagiarism cases will be dealt with following Monash policy.

6. AI & Generative AI tools MUST NOT BE USED within this assessment.

Submission:

- You need to submit a single zip file containing:

o A notebook file of the code (named as `StudentName_ID.ipynb`) with inputs and outputs of

each task presented. You are required to mention your full name and student ID in the notebook

file.

o A report file (named as `Report_StudentName_ID.pdf`) where to present your approaches for

all the tasks. You are required to mention your full name and student ID in the report file.

o Input and Output images.

- The zip file should be named “A1_<YourMonashID>.zip” (e.g. A1_12345678.zip).

- You need to make sure the notebook is runnable, and the results are reproducible given your input images.

- For each task, the runtime of the code should be less than 5 minutes.

Image stitching is a technique to combine multiple images with overlapping fields of view to produce a panorama

photo.

=>

2

The panorama stitching algorithm consists of four steps:

Step 1: Detect keypoints (e.g., DoG, Harris) and compute a local descriptor for each keypoint (e.g., SIFT,

SURF) from the two input images.

Step 2: Match the descriptors between the two images.

Step 3: Use the RANSAC algorithm to estimate a homography matrix using the matches obtained from

Step 2.

Step 4: Perform image warping using the homography matrix obtained from Step 3 to transform one of

the two images, then generate the stitched image.

In this assignment, students are required to implement some specific steps of the image stitching process and use

their implemented code to generate a stitched image as the final output. The details of each task are provided

below.

Task 1. Harris corner detection (8 marks)

Write your own Harris corner detector.

You will use the 6 images (skimage.data.astronaut(), skimage.data.checkerboard(), and the 4 provided

images) as input. Write your own Harris corner detector as a function my_harris_corner_detector(…). This

function should implement all steps in Harris corner detection from scratch and generate the required outputs for

each input image.

Marking:

1. my_harris_corner_detector(...) in the notebook template. On running the code, it should generate the

following items for each input image. Note that the generated items should also be presented in the report.

(7 marks).

o On the same input image, display corners detected by your implementation with red ‘+’ markers

and corners detected by the function corner_peaks(harris_response,…), where harris_response

= corner_harris(grayscale_input_image, …), with blue ‘o’ markers. The corner_peaks and

corner_harris functions are from the skimage library.

o Display the number of corners detected by your implementation and the number of corners

detected by the function corner_peaks(harris_response, …). Display the number of overlapped

corners detected by the two methods.

2. In the report, discuss: How do you decide the parameters? What are your observations? Discuss any

“interesting” implementation you made. (1 mark).

3. You need to make sure the notebook is runnable, and the results are reproducible given input images.

You are only allowed to use Numpy, SciPy, skimage (only for convolution function, gaussian filter),

matplotlib, and Python built-in libraries in this task.

Task 2. Homography estimation (2 marks)

Write the code to estimate the homography given matches.

Given matches in which matched points’ coordination are stored in two arrays 𝑋1 and 𝑋2, which have the same

size, i.e., 𝑁 × 2, in which 𝑁 is the number of matches (𝑁 ≥ 4). Each row of 𝑋1 is the coordination (𝑥, 𝑦) of a

point. The 𝑖

𝑡ℎ point of 𝑋1 (i.e., 𝑖

𝑡ℎ

row of 𝑋1) matches to the corresponding point in 𝑋2 (i.e., 𝑖

𝑡ℎ

row in 𝑋2).

Below is an example of 𝑋1 and 𝑋2.

3

𝑋1 = [

2

2

6

6

2

6

6

2

], 𝑋2 = [

16

20

10

8 10

18

12

14 ]

In the above example, the number of matches is 4. Point (2,2) in 𝑋1 matches to point (8,10) in 𝑋2; point (2,6) in

𝑋1 matches to point (10,14) in 𝑋2 and so on. Note that the number of matches could be greater than or equal to 4.

Marking:

1. Complete the function my_homography_estimation(X1, X2) in the notebook template to estimate the

homography 𝐻 that maps points in 𝑋1 to the corresponding points in 𝑋2. Print out the estimated

homography in the form:

[

ℎ11 ℎ12 ℎ13

ℎ21 ℎ22 ℎ23

ℎ31 ℎ32 ℎ33

]

2. Note that:

o You are only allowed to use Numpy, SciPy, skimage, matplotlib, and Python built-in libraries

in this task.

o You are not allowed to use built-in functions that estimate the homography from libraries, but

you are allowed to use built-in functions that calculate the eigenvalues and eigenvectors or

perform Singular Value Decomposition of a matrix.

o You need to make sure the notebook is runnable, and the results are reproducible given inputs.

Task 3. RANSAC (6 marks)

Write a program to implement the RANSAC algorithm for estimating a homography matrix (using

my_homography_estimation (…) implemented in task 2).

Given a list of matching points coordination, which are stored in two arrays 𝑃1 and 𝑃2. 𝑃1 and 𝑃2 have the same

size, i.e., 𝑁 × 2, in which 𝑁 is the number of matches (𝑁 ≥ 4). Each row of 𝑃1 is coordination (𝑥, 𝑦) of a point.

The 𝑖

𝑡ℎ point of 𝑋1 (i.e., 𝑖

𝑡ℎ

row of 𝑋1) matches to the corresponding point in 𝑋2 (i.e., 𝑖

𝑡ℎ

row in 𝑋2).

Marking:

1. Complete the function my_ransac(P1, P2) and test this function with given input 𝑃1 and 𝑃2 in the

notebook template to return the best homography H with the largest number of inliers. For each iteration

in RANSAC, print out the number of inliers, and the number of outliers. Finally print out the best

transformation matrix H and the coordination of the inlier matches corresponding to that best

transformation. (5 marks)

2. Write a report describing each step of the RANSAC algorithm you implemented, how to choose inliers

and outliers. Report the best homography matrix H with the corresponding number of inliers. (1 mark).

3. Note that you are only allowed to use Numpy, SciPy, skimage, matplotlib, and Python built-in libraries

in this task. You need to make sure the notebook is runnable, and the results are reproducible given

inputs.

4

Task 4. Image stitching (4 marks)

Given two images as shown in the notebook template, use the functions implemented in Task 1, Task 2, and

Task 3 to develop an image stitching algorithm following the steps below:

● Step 1: Detect keypoints in both image 1 and image 2 using the Harris corner detection implemented in

Task 1. (0.5 marks)

● Step 2: Extract local descriptors for the detected keypoints using SIFT (from a library). (1 marks)

● Step 3: Match keypoints between image 1 and image 2 based on the descriptors obtained in Step 2 (use a

library for matching algorithm) and visualize matches (0.5 marks)

● Step 4: Estimate the homography matrix using the RANSAC algorithm (implemented in Task 3) on the

list of matching points from Step 3 and visualize the inlier matches corresponding to the best homography

matrix (0.5 marks)

● Step 5: Apply a warping transformation (from a library) using the homography matrix obtained in Step

4 to transform image 2. (0.5 marks)

● Step 6: Merge image 1 and the transformed image 2 from Step 5 to obtain the final stitched image. (1

mark)

Marking:

1. You must complete and display the output of each step (with suitable parameters) for each pair of input

images.

2. If a step requires using a self-implemented function (e.g., steps 1 and 4), you will not receive marks if

you substitute it with a library function. However, you will still get marks for other steps that rely on the

results of those implementations. For example, if you use a library function for Harris corner detection,

you will not receive marks for step 1; however, as long as the keypoint locations are obtained using the

Harris corner detector, you can still earn marks for the subsequent steps. The objective of Task 4 is to

implement Image Stitching.

3. Note that there is no restriction on the libraries you can use for this task. You need to make sure the

notebook is runnable, and the results are reproducible given inputs.

Here is an example of output in each step, note that the outputs of your implementation may differ from the

example provided below:

Example 1:

5

6

Example 2:

7

================== End ==================