This homework is split into two weeks.

[N1 N2 N3] = p3p_distances( d12, d23, d31, c12, c23, c31 )

Create the function `p3p_distances`

for computing distances of three spatial points from a calibrated camera centre. The function must return the distances η_i in `N1`

, `N2`

, `N3`

of the three points. Implement only the case 'A' of the computation. If there are more solutions, the returned variables are row vectors. If there is no solution by the case 'A', return empty matrices (`[]`

]).

The function should return only such solutions, that are consistent with input arguments, i.e., that pass verification using cosine law (see below). Use (relative) threshold 1e-4.

e = p3p_dverify( N1, N2, N3, d12, d23, d31, c12, c23, c31 )

Create the function `p3p_dverify`

for verification of computed camera-to-point distances using the cosine law. Use this function in `p3p_distances`

. The function returns vector of three errors, one for each equation. Each computed error should be distance (not squared), relative to particular , i.e.

See the skeletons of the functions in the Tools repository for description of arguments. For constructing the fourth order polynomial, there is the `p3p_polynom`

function in the repository.

[R C] = p3p_RC( N, u, X, K )

Create the function `p3p_RC`

for computing calibrated camera centre `C`

and orientation `R`

from three scene-to-image correspondences (`X`

,`u`

), using already computed distances `N`

= [η_1 η_2 η_3].

The function takes **one** configuration of η_i and returns a single `R`

and `C`

. Note that R must be orthonormal with determinant equal to +1.

See the skeletons of the function in the Tools repository for description of arguments.

- Construct simple projection matrix where C = [1;2;3], f=1, K = R = diag( [1 1 1] ). Project the 3D points X1 = [0 0 0]'; X2 = [1 0 0]'; X3 = [0 1 0]' by the P and compute the cosines c12, c23 and c31 for the projected image points. Using the 3D points and the cosines, compute the camera-points distances η and compare with correct known values.
- Compute the distances η for the following configurations:
- X1 = [1 0 0]'; X2 = [0 2 0]'; X3 = [0 0 3]'; c12 = 0.9037378393; c23 = 0.8269612542; c31 = 0.9090648231;
- X1 = [1 0 0]'; X2 = [0 1 0]'; X3 = [0 0 2]'; c12 = 0.8333333333, c23 = 0.7385489458, c31 = 0.7385489458
- X1 = [1 0 0]'; X2 = [0 2 0]'; X3 = [0 0 3]'; c12 = 0; c23 = 0; c31 = 0;

- Compute the distances for all triplets of point correspondences choosen from the 10 points as in HW-02 (there is 120 such triplets). Use this matrix K.mat. Plot the distances in a single graph; use red for N1, blue for N2, green for N3. Since there can be more than one solution for a single triplet, horizontal axis shows just numerical order of solutions. Export as
`04_distances.pdf`

.

**Note**: The matrix Q obtained in HW-02 is not related to this task and is not used in any way.

- Construct simple projection matrix
`P`

where C = [1;2;-3], f=1, K = R = diag( [1 1 1] ). Project the 3D points X1 = [0 0 0]'; X2 = [1 0 0]'; X3 = [0 1 0]' by the`P`

. Compute the distances η and camera pose using your`p3p_RC`

for all solutions. Compare with correct known values of`R`

,`C`

. - Find optimal camera pose using point correspondences by a similar way as in HW02:
- Compute the camera poses for all 120 triplets of point correspondences chosen from your 10 points (as in HW-02). Use this matrix K.mat. (There can be more than one solutions for each triplet.)
- For a particular camera pose
`R`

,`C`

, compose camera matrix and compute the reprojection errors on all 109 points and find their maximum. - Select the best camera pose minimising the maximum reprojection error.

- Export the optimal
`R`

,`C`

, and`point_sel`

(indices [i1 i2 i3] of the three points used for computing the optimal`R`

,`C`

) as`04_p3p.mat`

.save( '04_p3p.mat', 'R', 'C', 'point_sel', '-v6' )

- Display the image (
`daliborka_01`

) and draw`u`

as blue dots, highlight the three points used for computing the best`R`

,`C`

by drawing them as yellow dots, and draw the displacements of reprojected points`x`

multiplied 100 times as red lines. Export as`04_RC_projections_errors.pdf.`

- Plot the decadic logarithm (log10()) of the maximum reprojection error of all the computed poses as the function of their trial index and export as
`04_RC_maxerr.pdf`

. Plot the errors as points, not lines, in this case. - Plot the reprojection error of the best
`R`

,`C`

on all 109 points as the function of point index and export as`04_RC_pointerr.pdf`

. - Draw the coordinate systems δ (black), ε (magenta) of the optimal
`R`

,`C`

, draw the 3D scene points (blue), and draw centers (red) of all cameras you have tested. Export as`04_scene.pdf`

. - Compare your graphs with the graphs in HW02.

**Note**: Use your `p3p_distances.m`

and `plot_csystem.m`

from previous HW.

**Note**: The matrix P obtained in HW02 is not related to this task and is not used in any way.

Upload two archives containing the following files.

The first part (04a):

`p3p_distances.m`

,`p3p_dverify.m`

`04_distances.pdf`

`hw04a.m`

– your Matlab implementation entry point.- any other files required by
`hw04a.m`

(including data and files from the repository).

The second part (04b):

`p3p_RC.m`

,`04_RC_projections_errors.pdf`

,`04_RC_maxerr.pdf`

,`04_RC_pointerr.pdf`

,`04_scene.pdf`

`04_p3p.mat`

,- hw04b.m – your Matlab implementation entry point.

any other your files required by hw04b.m (including data and files from the repository).

Note: The required files must be in the root directory of the archive.

courses/gvg/labs/gvg-2017-hw-04.txt · Last modified: 2019/01/19 18:22 (external edit)