October 21, 2026

• The 'concepts' of the representation of birds, was from Chapter 33, based on BigGAN.
  
• The picture is generated with BigGAN, but is actually not from the BigCAN paper (also not from the appendix).
• I am looking at the lectures belonging to the Foundation textbook.
• The lecture with chapter 24, has on slide 32 a nice illustration of the receptive field.

October 12, 2026

• It would also be interesting to try our code from Position and Altitude of the Nao Camera Head from Two Points on the Soccer Field plus the Gravitational Direction on estimating the Insta360 camera position. There are enough vertical columns to estimate the gravitational direction.
• Marilene provided the estimate of the distortion from the Insta360. The 5-distortion parameters are [ -0.12067396, -0.0353406, -0.00131154, -0.00080632492158, 0.041870077 ].
• The K1,K2 are comparible with my first estimate. The K3 estimate is actually quite large. Should redo the process, with known K.
• Also read the last chapter 54, so finished the whole textbook Foundations of Computer Vision. For sure a good choice for next year's course.
  

October 10, 2026

• I read chapter 46 already on September 16, so I can continue with chapter 47: 3D Motion and Its 2D Projection.
• Chapter 47 I also read already on September 16, so continue with chapter 48: Optical Flow Estimation, which I also read on September 16.
• Finally, chapter 49 I didn't read, although it was covered in Lecture 49 (together with the three chapters before).
• Finished chapter 49, although it doesn't contain much information, other than motion can also be estimated end-to-end with supervised and unsupervised models.
• Chapter 50 I already read on September 28, so next is chapter 51: Vision and Language. That is the last one with content, the other is on how to do research.
• I like how Fig 51.2 reuses the example of colored circles, triangels and squares from section 30.4.1:
  
• Figure 51.3 points back to Fig 13.9 from 'Neural Networks as Distribution Transformers'. The chapter really brings all things together full circle:
   
• Also nice to see how both the visual and text-branch transform to tokens to a single quadrant, where the can lineary separated. The joint embedding space can indeed visualized as a circle, although this a 2D visualisation of a 768-dimensional CLIP embedding:
  
• In section 51.4.1 they related Fig. 51.7 with Fig 33.2 from Chapter 33: Generative Modeling Meets Representation Learning:
   
• In this chapter, they see text just as one of the possible representations of an image:
  
• Conclusion: this figure is the leading figure in the build-up of the book.
• Also had time to read chapter 52: How to Do Research. The short answer: slowly.
• Also good advice from Prof. Edward Adelson in chapter 53: How to Write Papers
  
  • Start by stating which problem you are addressing, keeping the audience in mind. They must care about it, which means that sometimes you must tell them why they should care about the problem.
  • Then state briefly what the other solutions are to the problem, and why they aren’t satisfactory. If they were satisfactory, you wouldn’t need to do the work.
  • Then explain your own solution, compare it with other solutions, and say why it’s better.
  • At the end, talk about related work where similar techniques and experiments have been used, but applied to a different problem.

October 9, 2026

• Received the calibrated intrinsic model from Marilene, but without the radial distortion correction the result is actual worse:
  
• With a known K, I could use cv2.solvePnP.
• The results are less, because teh RMS error increased from 12.9 px yesterday to 24.48 px today.
• Details:
  K =
  [[1741.613 0. 1913.201]
  [ 0. 1755.172 1097.658]
  [ 0. 0. 1. ]]
  R =
  [[-0.038 0.998 -0.051]
  [ 0.642 -0.015 -0.767]
  [-0.766 -0.061 -0.64 ]]
  t (cm) = [ 48.628 -105.172 654.446]
  M =
  [[ -1531.037 1620.672 -1312.593 1336778.39 ]
  [ 285.449 -93.435 -2048.236 533763.005]
  [ -0.766 -0.061 -0.64 654.446]]
  Camera position in world (cm): [570.645 -9.911 340.576]
  Pan (yaw): -175.42 deg
  Tilt (pitch): 39.78 deg
  Roll: -3.79 deg
  Reprojection error per point (px): [16.744 38.151 13.85 17.248 15.306 23.817 41.395 56.354 17.867 13.19 15.372]
  Mean / max error (px): 24.48127521015996 56.35366544568389
  Origin in image: [2042.61 815.595]
  
• There is also a solvePnPRefineLM, which is a refinement without changing even the distances (or the K). Should try again, because it could influence the reprojection error. Indeed, without refinement the results are slightly better: one pixel less error - RMS 23.48 px (so still close to the result of yesterday):
  
• Details:
  K =
  [[1741.613 0. 1913.201]
  [ 0. 1755.172 1097.658]
  [ 0. 0. 1. ]]
  R =
  [[-0.051 0.997 -0.057]
  [ 0.632 -0.012 -0.774]
  [-0.773 -0.076 -0.63 ]]
  t (cm) = [ 49.07 -104.643 650.345]
  M =
  [[ -1567.036 1591.885 -1305.318 1329701.86 ]
  [ 261.75 -104.783 -2050.851 530189.56 ]
  [ -0.773 -0.076 -0.63 650.345]]
  Camera position in world (cm): [571.329 -1.069 331.495]
  Pan (yaw): -174.41 deg
  Tilt (pitch): 39.05 deg
  Roll: -4.24 deg
  Reprojection error per point (px): [14.775 87.882 0.909 13.603 17.042 30.464 35.24 45.061 8.221 1.222 3.888]
  Mean / max error (px): 23.482470795031535 87.88238601605235
  Origin in image: [2044.609 815.243]
  
• Without K, the calibration is called. Yesterday I already included cv2.CALIB_FIX_K3 (and _K2 and _K1).
• Yet, those parameters are in the variable dist, but are all zero.
• Tried a bounded least-square PnP-calibration, which actually worked better. With only K1 it found K1=-0.048 and a pixel error of 2.96px.
• With both K1&K2 it found [K1=-0.038,K2=-0.005] and a pixel error of 2.93px. RMS reprojection error: 2.93 px
  K =
  [[1667.503 0. 2000. ]
  [ 0. 1667.503 1125. ]
  [ 0. 0. 1. ]]
  dist (k1, k2, p1, p2, k3) = [-0.038 -0.005 0. 0. 0. ]
  R =
  [[-0.012 0.999 -0.033]
  [ 0.648 -0.017 -0.762]
  [-0.762 -0.031 -0.647]]
  t (cm) = [ 19.671 -114.715 605.595]
  M =
  [[ -1543.961 1604.763 -1349.623 1243991.963]
  [ 223.114 -63.677 -1998.088 490007.359]
  [ -0.762 -0.031 -0.647 605.595]]
  Camera position in world (cm): [535.868 -2.971 305.17 ]
  Pan (yaw): -177.68 deg
  Tilt (pitch): 40.32 deg
  Roll: -2.50 deg
  Reprojection error per point (px): [3.955 2.512 1.769 1.924 3.196 4.432 3.431 0.498 1.983 4.366 1.04 ]
  Mean / max error (px): 2.6459023652535723 4.432277766885548
  Origin in image: [2054.164 809.133]
  
• With K1,K2&P1 it found [K1=-0.029,K2=-0.007,P1=-0.003] and a pixel error of 2.62px.
• With K1,K2,P1&P2 it found [K1=-0.034,K2=-0.006,P1=-0.003,P2=0.001] and a pixel error of 2.60px.
• With K1,K2,P1,P2,K3 it found [K1=-0.101,K2=+0.2,P1=-0.004,P2=-0.0,K3=-0.085] and a pixel error of 2.57px.
• Details:
  RMS reprojection error: 2.57 px
  K =
  [[1662.741 0. 2000. ]
  [ 0. 1662.741 1125. ]
  [ 0. 0. 1. ]]
  dist (k1, k2, p1, p2, k3) = [-0.101 0.2 -0.004 -0. -0.085]
  R =
  [[-0.013 0.999 -0.032]
  [ 0.649 -0.016 -0.761]
  [-0.761 -0.031 -0.648]]
  t (cm) = [ 19.582 -114.441 603.061]
  M =
  [[ -1542.69 1600.574 -1350.177 1238683.363]
  [ 223.463 -61.061 -1994.159 488158.771]
  [ -0.761 -0.031 -0.648 603.061]]
  Camera position in world (cm): [533.244 -2.959 304.64 ]
  Pan (yaw): -177.70 deg
  Tilt (pitch): 40.42 deg
  Roll: -2.41 deg
  Reprojection error per point (px): [4.245 0.264 2.162 1.181 1.94 3.18 1.842 0.733 1.938 5.09 1.011]
  Mean / max error (px): 2.1441404957303964 5.089880585625587
  Origin in image: [2053.992 809.468]
  
• Yet, I nice reprojection result:
  
• Observation: with the distortion, I don't see any reprojected point in the lower corner anymore!
• Critical Note: this estimates 13 parameters from 20 measurements, so this could be overfitting. Also, the values for K2 and K2 were quite stable, until K3 was introduced. For a single view, I would stick to just K1&K2. Distortion can best be checked with points in the corners of the image, which is not the case in this view.
• To see the impact of points further from the center, I added on point in the lower left corner: [11,'L', +450, -300, 0, 374, 2156]].
• The reprojection error is now 2.90 px, with the reprojection of the new point just visible in the far corner:
  
• Details:
  RMS reprojection error: 2.90 px
  K =
  [[1673.361 0. 2000. ]
  [ 0. 1673.361 1125. ]
  [ 0. 0. 1. ]]
  dist (k1, k2, p1, p2, k3) = [-0.048 -0. 0. 0. 0. ]
  R =
  [[-0.013 0.999 -0.033]
  [ 0.647 -0.017 -0.762]
  [-0.763 -0.031 -0.646]]
  t (cm) = [ 19.704 -114.614 606.149]
  M =
  [[ -1546.424 1610.294 -1347.465 1245270.669]
  [ 224.487 -63.101 -2002.845 490127.128]
  [ -0.763 -0.031 -0.646 606.149]]
  Camera position in world (cm): [536.6 -2.826 304.949]
  Pan (yaw): -177.67 deg
  Tilt (pitch): 40.26 deg
  Roll: -2.47 deg
  Reprojection error per point (px): [3.703 2.219 1.933 2.256 3.26 4.003 3.9 1.65 1.554 4.629 1.88 1.275] Mean / max error (px): 2.6886568813173812 4.62924914895647
  Origin in image: [2054.396 808.591]
  
• Added two additional T-intersection points at the lower edge. Reprojection error became 4.01 px (-K3) to 4.45 px (K1)
• Still, at the lower edge the reprojection error is quite large:
  
• Details:
  RMS reprojection error: 4.01 px
  K =
  [[1689.855 0. 2000. ]
  [ 0. 1689.855 1125. ]
  [ 0. 0. 1. ]]
  dist (k1, k2, p1, p2, k3) = [-0.066 0.011 -0.001 -0.001 -0.001]
  R =
  [[-0.012 0.999 -0.033]
  [ 0.645 -0.017 -0.764]
  [-0.764 -0.031 -0.644]]
  t (cm) = [ 19.848 -114.119 609.109]
  M =
  [[ -1549.947 1627.625 -1343.172 1251758.135]
  [ 229.092 -63.233 -2016.123 492402.999]
  [ -0.764 -0.031 -0.644 609.109]]
  Camera position in world (cm): [539.454 -3.146 305.629]
  Pan (yaw): -177.71 deg
  Tilt (pitch): 40.08 deg
  Roll: -2.45 deg
  Reprojection error per point (px): [3.102 2.655 2.126 2.873 5.161 5.266 6.613 2.013 1.465 3.243 2.913 3.119 4.71 6.373]
  Mean / max error (px): 3.687931083894315 6.612870983453611
  Origin in image: [2055.066 808.399]
  
• Two additional penalty-area points make the error at the edges only bigger (5.11 px):
  
• Details:
  RMS reprojection error: 5.11 px
  K =
  [[1688.495 0. 2000. ]
  [ 0. 1688.495 1125. ]
  [ 0. 0. 1. ]]
  dist (k1, k2, p1, p2, k3) = [-0.075 0.012 0. 0. 0. ]
  R =
  [[-0.011 0.999 -0.031]
  [ 0.645 -0.016 -0.764]
  [-0.764 -0.029 -0.644]]
  t (cm) = [ 19.256 -114.062 606.603]
  M =
  [[ -1548.295 1629.701 -1340.848 1245720.237]
  [ 228.365 -60.402 -2015.153 489835.986]
  [ -0.764 -0.029 -0.644 606.603]]
  Camera position in world (cm): [537.461 -3.579 304.091]
  Pan (yaw): -177.83 deg
  Tilt (pitch): 40.09 deg
  Roll: -2.34 deg
  Reprojection error per point (px): [4.59 1.746 2.681 2.828 6.93 4.746 4.001 4.898 2.994 2.186 2.578 5.745 6.342 8.787 6.894 7.063]
  Mean / max error (px): 4.688122024838275 8.787280604246911
  Origin in image: [2053.599 807.506]
  
• This were results for K1&K2. The fifth parameter (K3) was estimated on zero, so didn't contribute.
• Observation: that two points closer to the center do not help to estimate the distortion better, is not strange.
• Still, I added five additional points. The camera position was quite stable for this addition: [533.244 -2.959 304.64 ] → [536.6 -2.826 304.949] → [539.454 -3.146 305.629] → [537.461 -3.579 304.091] cm.
• The tilt-angle is quite stable: 40.42 → 40.26 → 40.08 → 40.09 deg.
• K1 & K2 differ quite a lot: [-0.101 0.2] → [-0.048 -0.0] → [-0.066 0.011] → [-0.075 0.012]

October 8, 2026

• Would be interesting to see if the Insta 360 overview of the lab, with several intersections at known positions, would be enough to reconstruct the scene, equivalent with the toy-example:
  
• The field dimensions can be found at Table 2 of the HSL Rules or page 2 of SPL Rules.
• Could get the locations of the intersections from object_detection_scaled2.py of my XPS workstation (see August 18).
• The command ~/.venvs/opencv-5.0.0-cuda12.9/bin/python object_detection_scaled2.py still works, although it uses as input the Best-Goals movie
• Did have two scripts that worked on a single image, instead of a movie. Looking at ~/.venvs/opencv-5.0.0-cuda12.9/bin/python ./object_detection_whirlwind.py, which works, but with the pretrained Yolo-model, not the fine-tuned model of Irem.
• The code is still using the pretrained Yolo-model, because I didn't have best.pt on XPS. On August 19 I used, rtdetr instead.
• That sort of works, although all detection boxes are in the upper-left corner (Like Box: Penalty mark: [3, -871, 0, -874] Conf: 0.64).
• Instead, I modified simple_source_back_field.py, which gives a good result (with some False Negatives):
  
• OK, I got the following points (X,Y,Z) in cm, (x,y) in pixels. The Z-axis is pointing upwards, the X-axis points towards camera, the Y-axis to the wall:
  

  Name	i	Xi	Yi	Zi	xi	yi
  Box 0 - Lower-right corner, L-intersection, conf=0.73	1	+450	+300	0	3872	2145
  Box 1 - Middle right, T-intersection, conf=0.72	2	0	+300	0	2882	794
  Box 12 - Middle, X-intersection, conf=0.60	3	0	+75	0	2261	807
  Box 17 - Middle left, T-intersection, conf=0.55	4	0	-300	0	1256	829
  Box 23 - Lower middle, Penalty mark, conf=0.56	5	+320	0	0	2064	1555
  Box 3 - Lower-right, L-intersection, conf=0.65	6	+285	+200	0	2918	1421
  Box 6 - Lower-left, L-intersection, conf=0.62	7	+285	-200	0	1250	1435
  Box 20 - Upper middle, Penalty mark, conf=0.54	8	-320	0	0	2054	496
  Box 18 - Upper left, T-intersection, conf=0.55	9	-450	-200	0	1696	439
  Box 24 - Upper-right, L-intersection, conf=0.53	10	-285	+200	0	2441	511

• Checked the list with a drawing:
  
• I shifted the centers slightly, to be at the center of the intersections:
  selected_points = [
  [1, 'L', +450, +300, 0, 3872, 2145],
  [2, 'T', 0, +300, 0, 2880, 794],
  [3, 'X', 0, +75, 0, 2261, 807],
  [4, 'T', 0, -300, 0, 1250, 829],
  [5, 'P', +320, 0, 0, 2068, 1551],
  [6, 'L', +285, +200, 0, 2930, 1414],
  [7, 'L', +285, -200, 0, 1232, 1432],
  [8, 'P', -320, 0, 0, 2048, 496],
  [9, 'T', -450, -200, 0, 1693, 427],
  [10,'L', -285, +200, 0, 2451, 511] ]
  
• The image is 4000 × 2250.
• A full 3×4 projection matrix can't be solved by direct linear transform (DLT), because the all in the same ground plane.
• The equation for the planar surface is given in Chapter 41 on Homographics.
• Tried to calibrate the camera with those 10 points. The back-projection of the origin was quite off.
• The camera position was estimate in cm [393.401 -65.602 239.26 ]. This is too close in X, too far to the left for Y.For the height Z I have to check with Marilene.
• Marilene indicated for the side-configuration height to grass = 3.10147, middle of the field right above the optitrack motion capture camera, angle = 80 degree angle (or 2 clicks forward from middle possition).
• So, also the height is too low.
• Point 9 had a wrong sign for the Yi, so corrected above selected_points.
• Now the Camera position is estimated on [561.813 14.72 326.72 ], which is a much better estimate.
• Still an error in point 9 (-200cm instead of -300cm). Camera position is now [574.003 -3.314 333.581]. i
• Reprojection error is now also good:
  
• The principal point is estimated precisely in the middle of the image (2000, 1125).
• The RMS error is 10x Marilene's calibration result (12.9 px vs 1.11 px), but this were 10 points in a single image, while Marilene's calibration used 36 points in 37 images.
• Matrices:
  K =
  [[1797.472 0. 2000. ]
  [ 0. 1797.472 1125. ]
  [ 0. 0. 1. ]]
  
  R= [[-0.01 0.999 -0.03 ]
  [ 0.64 -0.017 -0.768]
  [-0.768 -0.027 -0.64 ]]
  
  t (cm) = [ 19.134 -111.394 654.21 ]
  
  M =
  [[ -1554.116 1742.49 -1333.925 1342812.972]
  [ 286.771 -60.696 -2100.145 535759.22 ]
  [ -0.768 -0.027 -0.64 654.21 ]]
  
• Note that M = [KR | -KRT].
• In section Recovering Intrinsic and Extrinsic Camera Parameters T is calculated as T = (KR)^-1 (-KRT).
• The camera translation T (cm) is not directly interpretable, like in toy-example, where the hight of the camera could directly be estimate. Here the camera position is estimated as cam_pos = -R.T @ tvec.reshape(3)
• Also looked at the orientation of the camera from the rotation matrix R:
  Pan (yaw): -177.98 deg
  Tilt (pitch): 39.78 deg
  Roll: -2.26 deg
  
• The roll is nearly zero, the camera is looking backwards. Only the tilt is larger than expected (more than the 2 clicks reported by Marilene). Yet, to get the field in the FOV she also have to adjust the camera.

October 6, 2026

• Next lecture also covers a stereo-vision, so should also read chapter 40.
• Lets start with chapter 38, where they introduce homogeneous coordinates, showing how this is realted with the persepective projection:
  
• Slide 28 shows the camera model in heterogenous coordinates, pointing back to Lecture 2. Are heterogenous coordinates introduced in that lecture? Yes, on slide 33 and 34. Slide 34 nicely shows the ray concept, comparible with above. It mentions scaling, translating and rotation, but doesn't make the connection to an image like:
  
• Followed by:
  
• Chapter 41 is on homography. Before they point to ImageStitching, they highlight two special cases: camera rotation from the same viewpoint and observing a 2D plane. Note that the soccer field is a 2D plane. Also note, that with the T,X and L-intersection, the camera could also be calibrated equivalent with the toy example, which uses 12 known distances.
• Chapter 42 is quite impressive, geting a full 3D estimate from vanishing points and projective invariants like the cross-ratio, to estimate all 3D scene properties (although with many manual steps).

October 5, 2026

• Next lecture also covers a lot of material on ResNet. Check if Foundations also cover ResNets.
• ResNet is covered at the end of chapter 24, where popular architectures are covered, with a short section (24.11.3).
• Starting with Chapter 35 on Data Bias and Shift:
  
• Starting with Chapter 36 on Data Augmentation:
  
• Starting with Chapter 37 on Transfer Learning:
  
• I like the knowledge distillation illustration (Fig 37.4):
  
• I like the visual prompting illustration as a adversierial attack that helps in the task (Fig 37.6):
  

October 2, 2026

• Next lecture covers Image Pyramids, so I could use some material from chapter 23 . Not really, directly dived into sharing info between layers.

October 1, 2026

• Finished chapter 32, continued with chapter 33.
• I like Figure 33.1, although I don't know (yet) where to use it in which lecture:
  
• If we have no quest-speaker, maybe it it interesting to cover Challenges in Learning-Based Vision, chapter 35-37.
• Also finished chapter 34, which ends with the Concluding Remarks: "Many problems in vision can be phrased as structured prediction, and conditional generative models are a great approach to these problems. They provide a unified and simple solution to a diverse array of problems. A current trend in computer vision (and all of artificial intelligence) is to replace bespoke systems for specific kinds of structured prediction—object detectors, image captioning systems, and so on—with general-purpose conditional generative models. This is one reason why this book does not focus much on special-purpose systems that solve specific problems in vision—because the trend is toward general-purpose modeling tools."

September 29, 2026

• Let's create an overview of lectures, sections in Szeliski and sections in Torrabla.
  • Lecture 1 Section 1.1&1.2   Chapter 1-3
  • Lecture 2 Section 2.1-2.3   Chapter 5-8
  • Lecture 3 Section 3.1&13.1.1 Chapter 5,8,27
  • Lecture 4 Section 3.2-3.4     Chapter 15-18
  • Lecture 5 Section 7.1-7.4     Chapter 31.4
  • Lecture 6 Section 9.1&9.3   Chapter 46-49
  • Lecture 7 Section 8.1-8.2     Chapter 38&41
  • Lecture 8 Section 6.1-6.2   Chapter 50.3
  • Lecture 9 Section 6.3-6.4     Chapter 50.4-50.6
  • Lecture 10 Section 5.2     Chapter 24
  • Lecture 11 Section 5.3-5.4     Chapter 25-26
  • Lecture 12 Section 12.1-12.2   Chapter 38-44
• Trying to cover the gap between Chapter 31 and 38 by reading Chapter 32.
• Could use parts from this chapter in the NN-architecture lecture, because a generator is the inverse of a classifier. Continue with section 32.3.2

September 28, 2026

• Continue with Probabilistic Models of Images, to prepare for tomorrow's lecture.
• First Chapter 27.
• I like their statistical view on the set of natural images:
  
• The chapter makes a smooth transition from describing correlations between pixels to denoising:
  .
• Continue with Chapter 28: Textures.
• The chapter makes the connection to the image pyramids from Chapter 23 and the generative models from Chapter 32:
  
• Continue with Chapter 29: Probabilistic Graphical Models.
• Section 29.2 defines Markov Random Fields:
  
• Together with its application in Computer Vision:
  
• At the end it is used to calculate a posterior probability to estimated depth disparity along a stereo-mathing scanline:
  
• Still a very theoretical chapter, which is not even directly applicable to NNs, although they share some characteristics.
• The content that I need could be in Chapter 31, so read Chapter 30 first. Actually, did that already on September 10, together with Chapter 31.
• At least K-Means is covered in section 30.9 - Clustering, as the lecture tomorrow.
• Could better read Chapter 50 - object recognition. At least the IoU is explained.
• Image Classification, explained in the previous lecture, is covered in section 50.3. Maybe a better recap than the current recap. Also look at section 9.7.3
• Maybe first show Fig. 50.6:
  
• Followed by the simplex:
  
• Followed by the natural image space (Fig 27.1):
  
• Followed by Fig. 9.9:
  
• And Fig 9.10, to show the confidence:
  
• Maybe also nice to start the lecture with the shortcomings (section 50.3.4), with the car and pepper example.
• For bounding box selective search, I could use:
  
• For the IoU, I could use. In this case, the blue car in the background is well hidden:
  
• This section also has a section Shortcommings.
• The class segmentation had its own short shortcomming: it no longer counts objects.
• Image segmentation can. The third car is now clearly visible:
  
• That one is nearly perfect, but relies on language (pepper example here).
• Maybe I could use the resumé, with the architecture and funtional form clipped:
  

September 25, 2026

• Should check out the Astra agents working with RF-DETR, segmenting MicroDucks.

September 18, 2026

• Read both Chapter 25 and Chapter 26 on RNN and Transformers, so the general Neural Architectures for vision are now covered.

September 17, 2026

• The next lecture 9 will cover Retrieval, Detection and Segmentation. That could be Chapter 31 or Chapter 50
• Lecture 10 combines detection with CNNs, which is Chapter 24, which I already covered.
• Yet, the applications could be hidden in Probabilistic Models of Images (Chapter 27-29).

September 16, 2026

• Preparing tomorrows's lecture, I start reading chapter 46.
• Figure 46.4 uses the same example as the lecture, and shows the search window for the patch:
  
• Also Figure 46.5 is usefull:
  
• Continued with Chapter 47. Note that motion estimation between two frames in a sequence is closely related to disparity estimation in stereo images, but disparity estimation is not covered (yet).
• I like equations 47.2 and 47.3, with their corresponding Figure 47.2:
  
• Also like Gibson's bird:
  
• For sure because Gibson's bird itself also has a view, and uses the Optical Flow to navigate:
  
• In section 47.2.2 the moving camera is covered, for three different cases:
     
• Continue with Chapter 48, which describes Lucas and Kanade's algorithm.
• I like Fig. 48.4 and 48.5 to illustrate Eq 48.3:
   
• Combination blurred with a Gaussian filter gives:
  
• The resulting optical flow is quite good (although a bit less at the sides compared with the corners):
  
• The result can become more reliable by a convolution with a Harris corner detector:
  

September 14, 2026

• The last lecture covered Fourier transforms and ended with Gabor Filters, exactly which was also covered by the last Chapter 22 I read.
• Something not covered, but very important for CNNs, is the upscaling and downscaling of images.
• Not sure if this could be included in Lecture 5 and/or Lecture 6.
• In Lecture 5, slide 39, I still see Lena. Didn't I replace that slide?
• In 2024, I just skipped slide 39, what means that there is no failure case shown.
• Starting to read Chapter 23 on Image Pyramids. Note that Szeliski covers this early in his Section 3.5. Note that we cover Chapter 3 only to Section 3.3, Fourier Transforms (Section 3.4) and Pyramids & Wavelets. That is a pity, because it overlaps nicely with Encoder / Decoders architectures.
• Also nice is showing that when the low-pass recidual is kept, the original image can be recreated, which can also be used for Image blending:
   
• Wavelets are only mentioned in the Concluding Remarks.
• Also reading section 3.5. Figure 3.33 is much less clear than Figure 23.5:
  
• Yet, Figure 3.40 is much clearer than Figure 23.13:
  
• The same Laplacian pyramid blending example is used, although I again like Figure 3.42 less than Figure 23.8:
  
• Chapter 3 continues with Section 3.6.1: Parametric transformations, which are important for warping.
• I like Figure 3.44 with the basic set of 2D geometric image transformations, including affine and projective transforms.
• Continue with Convolutional Neural Networks.
• Nice summary: "Keeping in mind that chopping up and predicting is really all a CNN is doing", with two examples, showing that if you make the patches small enough, you get semantic segmentation:
  

  

• Chapter 24 points back to Chapter 15 - Chapter 19, although it also claims "A CNN instead learns an effective filter bank", where hand-designed filter banks were covered in Chapter 22 - Spatial Filters.
• Figure 24.8 nicely shows the effect of aliasing when using strides for optimalization, for a simple 2D Laplacian 3x3 kernel:
       
• After showing that kernels can be build from two separable kernels (like Sobel_x and Sobel_y), the Chapter continues with upsampling and downsampling layers. That were all linear / affine layers, so after that the non-linear layes like pooling, and normalization are covered. No activation layers (yet).`
• The concluding remark is “Why did we bother learning about CNNs then, if transformers are better!”
  The reason we cover CNNs is not because the exact architecture presented here will last, but because the underlying principles it embodies are ubiquitous in sensory processing. Transformers have the same chopping and prediction properties:
  1. Treating Patches as Independent
  2. Processing Each Patch Identically
  3. Couldn't find the code and/or training images of the Working Example 24.5
  4. Looked at the corresponding slides, but the Working Example was not covered.
  5. Only three repositories at Torralbla-lab
  6. 11 repositories from Phillip Isola.

September 11, 2026

• Looking into the skipped Chapter 20: Image Sampling and Aliasing
• Continued with Chapter 21: Downsampling and Upsampling Images
• Downsampling is an operation that occurs often. A bionomial filtering can help to preserve some of the details:
  
  Without bionomial filtering
  
  With bionomial filtering
• This technique is not important in CNNs (Chapter 24), but also in Image Pyramids (Chapter 23) and Geometry (Chapter 38)
• Chapter 22 goes from linear filters to non-linear filters. It starts with Gabor Filters

September 10, 2026

• Chapter 15 of Foundations of Computer Vision introduces convolutions as a special case of a linear tranformation filter.
• Chapter 16 introduces Fourier transforms, which indicates the possibilities to Filter in the frequency domain, although it is a global operation.
• Chapter 17 gets more practical as low-frequency filters that blur the image.
• Chapter 18 goes in 3D, for tracking. More details in the later part Understanding Motion (Chapter 46-49)
• Chapter 24 uses much of the frequency filters of Chapter 16-18.
• Continue for the moment (preparing for lecture this Wednesday) on Chapter 30: Representation Learning.
• I like their idea that a good representation is a compression, for three reasons:
  • Uses less memory
  • discards nuisance factors / noise
  • Occam's razor: smaller is better
• In addition, a good representation allows a good prediction (generalization)
• In practice, it describes autoencoders.
• What is nice that object detection can occur as side-product from another training task (i.e. scene classification, colorization:
   
• Chapter 31 starts with segments, and shows how pixels can be combined by K-means or contrastive learning (like DINO).
• Edges are only minimal covered. It points back to Chapter 2 and looks forward to Chapter 42. For this chapter, it claims that Line drawings are of high interest to humans, but have not been found to be a good representation for ML.
• I am surprised that Chapter 55: A Simple Vision System—Revisited is not mentioned. In Chapter 55 a current state-of-the-art system called MiDaS is applied to the simple world:
  .
• MiDaS gives disparity, so the camera calibration of Chapter 39 is needed to get world coordinates (X,Y,Z)

September 9, 2026

• Started with Chapter 2 of Foundations of Computer Vision.
• I like Figure 2.4, which would be usefull in the 2nd lecture, for instance after slide 78:
  
• Should check if I used part of this material in VAR. No, not really.
• Also important for RGB-D. In the next image there are three different edges. In the contact edge the depth is continues, at the 3D edges not:
  
• This is nicely illustrated in Figure 2.7:
  
• Reconstructing the X,Y,Z of each pixel:
  
• Also like the interactive demo below Figure 2.11:
  
• Great chapter, with a lot of material that could be included in a lecture, not sure (yet) where.
• Continue with Chapter 3.
• A very philosophical chapter, maybe a good reading at the end of the course.
• The same could be said on Chapter 4, on Computer Vision and Society. Yet, I don't like it as much. What I partly miss, is benchmark design, which is needed because otherwise the important edge cases drown in the majority, while a benchmark is often used to train an algorithm it is not designed for.
• Ready with Part I, which describes the challenge of Computer Vision.
• Part II is on Image formation. It also points forward to Understanding Geometry part, with together with Understanding Motion seems relevant for VAR (and Lecture 6 of CV1).
• Chapter 5 describes Lambertian Surfaces, covered in the 2nd/3rd lecture of CV1.
• In section 5.2.2 they also include Specular reflections (Phong component):
     
• Chapter 6 is about lenses:
  
• The chapter not only covers convex lenses, but also describes how the combination with concave lenses could build a telescope that magnifies:
  
• Chapter 7 introduces Flatland:
  
• It is clear that we cannot expect a linear response on intensity, and the regularized inverse seems relevant, but later chapters have to show how this is used. The edge camera is nice, but not directly relevant.
• Personally, I would make the link with color. Color is partly the color of light falling on the surface, and the reflections coming from it (which are not the same for each wavelength). There you for sure have no identify matrix.
• I would like to see a flatland camera with three RGB pixels.
• A flatland camera comes back in Chapter 45, on NERF and radiance fields.
• Part of the sensitity comes back in the color reproduction formula:
  
• The human eye has not only different sensitities for different colors, which also has consequences in spatial sensitity (see the green sensitity below), a fact where compression makes use from:
  
• Ready with Part II, which describes the Image Formation.
• Read Chapter 9: Introduction to learning. The regression model was OK, the meta-learning a bit early.
• The message of Chapter 10 is simple: Stochastic Gradient Descent is the workhorse of all CV algorithms.
• From Chapter 11 I like the comparison effect of data, priors/regulizers, and hypotheses F:
  
• Chapter 12 introduces neural networks. It shows that a 2-layer MLP with Relu-activation function can learn a classifier with cannot be seperated with a linear function:
  
• Section 12.5.2 shows that 4 Relu-functions can be combined to create a bin-function:
  
• Several of those bins can be combined to histogram:
  
• So a MLP with a single hidden-layer can learn any function, it only needs a lot of hidden-notes, for sure when the bin-size is made small. It is more efficient to increase the depth, instead of the width.
• Section 12.8 Why Are Neural Networks a Good Architecture? couples three reasons to the previous data, priors/regulizers, and hypotheses:
  1. NN are high capacity (big enough nets are universal approximators). relates hypothese space.
  2. NN are differentiable (the parameters can be optimized via gradient descent). relates optimizing on data.
  3. NN have good inductive biases (neural architectures reflect real structure in the world). relates prior structure
• The last argument is that the depth of DNNs allows to build increasingly abstracted representations of the input data.
• Chapter 13 is actually quite short, and shows how transformations can be visualised (at the end a high-dimensional transformer with t-SNE back to 2D). The different functions in a NN make different shifts:
  
• By creating a 3-layer MLP, one is able to have two classes (red/blue) aligned on a single line:
  
• Finished Part III: Foundations of Learning. Back to Image Processing

September 7, 2026

• In 2019, Thomas Mensink made a webversion of the course: https://cv1-uva.github.io/

August 31, 2026

• Finished with Chapter 1 of Foundations of Computer Vision.

August 24, 2026

• Had some problem to find Foundations of Computer Vision back.
• As indicated on December 22, 2025 the books on the MIT bookshelf are gone.
• Foundations was not on the VitalSource bookshelf.
• Luckely the autours made it availabe at Foundations of Computer Vision website.
• Started with Chapter 1.
• Reached 1.3.4 Gibson’s Ecological Approach to Visual Perception

August 19, 2026

• I was on July 26 working on the XPS workstation in directory ~/sh.
• The command ~/.venvs/opencv-5.0.0-cuda12.9/bin/python object_detection_scaled2.py still works.
• The yolo26n.pt from Irem is still the official model, should find the best.pt (see ultralytics documentation.
• Luckely, for rtdetr I saved the best.pt, which is based on rtdetr-l.pt (see ultralytics documentation).
• Run ~/.venvs/opencv-5.0.0-cuda12.9/bin/python convert2onnx.py in the rtdetr-directory, which converted loaded

  rtdetr-l.pt

  and saved it as best.onnx (which is not made from best.pt!)
• Made a version of object_detection_scaled2.py for rtdetr, using Irem's weights. The predictions seem to work, only the bounding boxs are all in the upper right corner.
• Changed some settings in the model export (no fixed image size, setting dynamic to true)
• Using the pt-directly, as this documentation page, doesn't work because the CUDA initialization: The NVIDIA driver on your system is too old (found version 12090), while it works with onnx-version.
• Should I load the yaml and pt together, as detection documentation page.
• Seems possible to directly load an onnx-model, see this issue.
• This seems to work, I only have to visualize the results on the video.
• I have many double detection, so applied as post-filter NMS from torchvision.
• Seems to work. Tried using a youtube stream directly, but received a botdetection. Used dubs.io to convert the video online.
• Applied the script simple_source.py on RoboCup 2026 Goal Highlights.
• Had to convert the avi-movie to mp4 again before I can upload it to LinkedIn. Tried last time to directly write to mp4, but that gave encoder problems last time. Suggested command ffmpeg -i input.avi -c:v libx264 -crf 23 -preset medium -c:a aac -b:a 128k output.mp4

August 11, 2026

• I read Chapter 6 (Recognition) of Szeliski's textbook Computer Vision. Quite dense in content, central to all CV applications. Strange mix of classic and modern techniques, applications and theory.
• For more details on the classic algorithms, Szeliski points to the 2011 version, which is also accessible from Springer. In the old text it was the last chapter of the book (Chapter 14).
• For instance, the sampling from faces and non-faces (in both old and new text) is much clearer with Figure 14.3 from Kanade's 1998 work. Also the Gaussian clusters from 14.4 are nice.
• Also figure 14.7 of Viola & Jones boosting is nice.
• Some figures are still in, although 14.2 (familiar people in 2006) no longer works. Even an old guy like me could recognize 3 from the 12 persons.
• The lighting conditions from the Harvard database (Fig. 14.15) are quite dramatic.
• Chapter 14 focuses a lot on eigenfaces. Yet, Fig 14.19 (view-based eigenspace) is skipped, while I find that one of the important messages.
• Section 14.3 explains a lot on visual words. Outdated, but still nice to understand what is actual done. Should read section 14.3 for the lecture.
• I like figure 14.49 better than Figure 14.48 to demonstrate the importance of context.

August 6, 2026

• Lingbot-vision outperforms Dino v3.

July 26, 2026

• Continue with checking Install OpenCV5 on XPS workstation.
• Made a ~/sh/set_environment.sh that defines OPENCV_PYTHON_VENV from step 4.2
• Made a script ~/sh/run_cuda_python_environment.sh that uses OPENCV_PYTHON_VENV to perform the test of step 5.3.
• This validates more than device discovery: it allocates device memory, transfers data, executes a CUDA image-processing kernel, and copies the result back.
  Stop here — Python CUDA route complete. The installation is ready for Python CUDA work when cv2 imports from the CUDA prefix, at least one device is found, and every listed GPU reports upload + cvtColor + download PASS.
• Received: CUDA devices: 1; GPU 0: upload + cvtColor + download PASS
• Looked at step 7. Created script set_opencv_active_python.sh which defines OPENCV_ACTIVE_PYTHON and a script print_python_cabability_report.sh which uses OPENCV_ACTIVE_PYTHON.
• Interesting snippets from report:
  CPU/HW features:
  Baseline: SSE SSE2 SSE3
  requested: SSE3
  Dispatched code generation: SSE4_1 SSE4_2 AVX FP16 AVX2 AVX512_SKX
  SSE4_1 (20 files): + SSSE3 SSE4_1
  SSE4_2 (1 files): + SSSE3 SSE4_1 POPCNT SSE4_2
  AVX (17 files): + SSSE3 SSE4_1 POPCNT SSE4_2 AVX
  FP16 (0 files): + SSSE3 SSE4_1 POPCNT SSE4_2 AVX FP16
  AVX2 (51 files): + SSSE3 SSE4_1 POPCNT SSE4_2 AVX FP16 AVX2 FMA3
  AVX512_SKX (9 files): + SSSE3 SSE4_1 POPCNT SSE4_2 AVX FP16 AVX2 FMA3 AVX_512F AVX512_COMMON AVX512_SKX
  
  OpenCV modules:
  To be built: bgsegm bioinspired calib ccalib core cudaarithm cudabgsegm cudafeatures2d cudafilters cudaimgproc cudalegacy cudaobjdetect cudaoptflow cudastereo cudawarping cudev datasets dnn dnn_objdetect dnn_superres dpm face features flann freetype fuzzy gapi geometry hdf hfs highgui img_hash imgcodecs imgproc intensity_transform line_descriptor ml objdetect optflow phase_unwrapping photo plot ptcloud python3 quality rapid reg rgbd saliency shape signal stereo stitching structured_light superres surface_matching text tracking video videoio videostab wechat_qrcode xfeatures2d ximgproc xobjdetect xphoto xstereo
  Disabled: cudacodec world
  Disabled by dependency: -
  Unavailable: alphamat cannops cvv fastcv java julia matlab ovis sfm ts viz
  Applications: apps
  Documentation: NO
  Non-free algorithms: NO
  
  Parallel framework: pthreads
  
  cuDNN: YES (ver 9.25.0)
  
  OpenCL: YES (no extra features)
  Include path: ~/src/opencv-5.0.0/opencv/3rdparty/include/opencl/1.2
  Link libraries: Dynamic load
  
  ONNX Runtime: NO
  
  
• Time to test the tutorial How to Run Object Detection with OpenCV 5.
• Yet, this uses ONNX, which wasn't included.
• Tried ~/.venvs/opencv-5.0.0-cuda12.9/bin/python -m pip install onnxruntime-gpu, which installs onnxruntime-gpu-1.27.0.
• Next I tried ~/.venvs/opencv-5.0.0-cuda12.9/bin/python -m pip install ultralytics onnx onnxruntime-gpu, which installs also the cuda13 and opencv_python-5.0.0.93. So I made a nice mess of my installation.
• Should have made a new build with additional option -DWITHONNX.
• Still, it works, could perform step 2.2
• The export gives Ultralytics requirement ['onnxslim>=0.1.82'] not found, attempting AutoUpdate..., which installs colorama-0.4.6 onnxslim-0.1.94.
• Export complete (5.8s)
  Results saved to ~/sh/yolo26n.onnx
• The code of the tutorial is not yet saved at Learn OpenCV github, so downloaded own PSV-Ajax still.
• The example code is for sure not complete. Calls two not implemented fuctions: yolo's letterbox() (found in an implementation in this posti) and draw().
• Draw should be implemented like earlier yolo26 tutorial.
• Got some working code. Notes: one false negative, no class labels:
  
• Trying to stream the youtube post directly, but both the pafy as m3u8 failed. Instead used an online converter, and did the detection on the mp4.
• That failed on the rescaling to 640x640, as required by ONNX. The trick was to call explicit for a square-box: padded, r, (dw, dh) = letterbox(img, new_shape=(640, 640), auto=False, scaleFill=False), instead of keeping the aspect-ratio.
• Also saving as mp4 directly failed. Instead saved as avi with fourcc = cv2.VideoWriter_fourcc(*"MJPG"); writer = cv2.VideoWriter("outputs/detected.avi", fourcc, fps, (w, h)) and converted to the smaller mp4 with ffmpeg -i outputs/detected.avi -c:v libx264 -crf 23 -preset veryfast outputs/detected.mp4.
• Final code is in object_detection_scaled2.py and the result:
  

July 25, 2026

• Checking Install OpenCV5 on XPS workstation.
• The XPS workstation has Ubuntu 24.04, so should be able to run OpenCV with GPU.
• Run the ~/bin/sh/check_build_environment.sh of section 2: gcc and cmake are modern enough (g++ 13.3.0, cmake 3.28.3).
• Next is the check ~/bin/sh/check_python_packages.sh of section 2. The import cv2 fails on /lib/x86_64-linux-gnu/libavcodec.so.60: undefined symbol: vaSyncBuffer.
• Did pip3 install opencv-python==4.12.0.88. Building the wheel took time, but succeeded. Still same error.
• Removed /opt/ros/jazzy/setup.bash from bashrc, which defined a PYTHONPATH. Still same error.
• Tried pip3 install opencv-contrib-python==4.12.0.88. Building the wheel took time, but succeeded. Still same error.
• Checked with apt list --installed | grep opencv. There are many 4.6.0 packages installed, I assume via ros.
• Now pip3 install opencv-python-headless==4.12.0.88 uninstalled opencv-python-headless-4.4.0.44
• Indeed, sudo apt remove python3-opencv --dry-run showed that ros-jazzy-desktop will be removed.
• Trying pip3 install opencv-python==4.6.0.66 and the other three packages. That goes much faster. Still same problem.
• Did a check sudo apt search libavcodec. There are several packages. Removing libavcodec60 would remove ros-jazzy-desktop.
• Asked UvA Chat for help. Did sudo mv /etc/ld.so.conf.d/intel-mediasdk.conf /tmp/, followed by sudo ldconfig. Now I could load cv2 again.
• Note that LIBVA_DRIVERS still was set as environment variable. Did also sudo mv /etc/profile.d/intel-mediasdk.sh /tmp/
• Start building OpenCV 5.0.0 from source (in ~/src/opencv-5.0.0.
• Executed build-step until 4.2, before jumping to step 5 (as instructed).
• No cuda-toolkit is installed, so installed cuda-toolkit-12.9
• I still had in /usr/local/ both cuda-8.0, cuda-10.2, cuda-11.4
• Build and installation succeeded, think that I still have to add home/arnoud/.local/opencv/5.0.0-cuda12.9/bin/ to PATH and /home/arnoud/.local/opencv/5.0.0-cuda12.9/lib to LD_LIBRARY_PATH.
• Still had no nvidias-smi, so I also had to install the correct nvidia-drivers. The Cuda compatibility indicated that in principal the drivers should be before 580, but higher version should still work.
• Instead of sudo apt-get install cuda-drivers I did sudo apt-get install nvidia-open (for modern GPUs). In both cases drivers version 610.43.02 were installed. Reboot.
• Installed cuda-drivers-575, but still I got the problem that the nvidia-persistenced.service didn't start.
• Solution was to disable Secure Boot. Now the ~/sh/verify_cuda_prerequisites.sh script works. I have a NVIDIA GeForce GTX 1080, running Driver Version: 575.57.08 CUDA Version: 12.9.
• Should check if Windows partition still works.
• Continued with the next step. Still had to do sudo apt-get -y install cudnn9-cuda-12.
• Fails.Should I also install cublas?
• No, it was enough to throw away the log and the just created build-directory. Without the cache the configuration succeeded.
• Starting the build and install script. 1804 packages to build.

July 24, 2026

• There is a list of video recordings of the previous years at Canvas, but from 2025 it are mostly the Seminars.
• From 2024, it are mostly my recordings.
• With the first lab comes Chapter 5 from Computer Vision - A modern Approach.
• Seems to be a chapter from the first edition of David A. Forsyth and Jean Ponce's textbook (2002), although the Shadow and Shading is here chapter 2. The TOC of the 2nd edition (2011)can be found here. Also covers Shadows and Shading, but in Chapter 2 and 3.
• Also see David Foryth's page.
• Would be nice to try on WS9 the venv-option of Install OpenCV5.
• Followed by Object detection with Yolo26.

July 23, 2026

• In I gave in 2024 the first 6 lectures, which is according to August 15, 2024 equal to Chapter 1-3, 7 and 9 of Szeliski's textbook Computer Vision. That year I also read chapter 13.
• This year I will give the following lectures:
  • Lecture 5: Local Features, Edges, Lines, and Corners
  • Lecture 6: Optical Flow, Motion and Tracking
  • Readings: Szeliski textbook section 7.1, 7.2, 7.4, 9.1.1, 9.1.3, 9.3
  • Lecture 9: Retrieval, Detection and Segmentation
  • Lecture 10: Convolution Neural Networks, Object Detection Basics
  • Readings: Szeliski textbook section 5.2.1, 5.2.2, 6.3, 6.4
  • Lecture 11: Single Shot Detection, Network Architectures
  • Lecture 12: Shape from X, Stereo, Structure from Motion
  • Readings: Szeliski textbook section 5.3, 5.4, 12.1-12.3, 13.2
• So, I should start with reading chapter 5 and 6 of Szeliski. Chapter 4 is already covered by Machine Learning 1.
• Chapter 5 has the title 'Deep Learning'.
• Chapter 5 often revers to the Deep Learning book of Bengio, LeCun, and Hinton 2021. Could check what CV-topics are covered there.
• For ML textbooks, Sveliski points not only to Bishop (2006), but also the more recent Mathematics for Machine Learning from Deisenroth, M. P., Faisal, A. A., and Ong, C. S. (2020).
• Another recent ML mentioned is Dive into Deep Learning by Zhang, Lipton (2021), which includes some PyTorch and TensorFlow code samples.
• Section 5.1 covers some classic algorithms like kNN, Logistic Regression, SVMs & Decision Trees, which are skipped in the lectures. So also the wise words on centering, standardizing and whitening are skipped.
• FLANN is a library of OpenCV, which includes several efficient kNN-algorithms.
• I like figure 5.10 (Fisher linear discriminant), although from Bishop 2006.
• Lecture 2 of Stanford's DL course uses kNN for Image Classification.
• Section 5.2 is called 'Unsupervised learning'. Section 5.2.1 is on the reading list, covers 'Clustering'
• What is nice, that it directly is applied to CV, with division of a image into uniform regions. Should check one of the oldest techiques: Ohlander, Price, and Reddy (1978). This could be linked with Segmentation.
• Section 5.2.2 covers 'K-means and Gaussians mixture models'
• Yet, the first CV example (eigenfaces) only appears in section 5.2.3 'Principal component analysis', which is no longer on the reading list.
• Should check how Gaussian mixture models come back in the slides, covering Retrieval, Detection and Segmentation
• I like Figure 5.21, which visualises the classes from three CV recognition tasks.
• Semi-supervised learning don't get its own chapter, it is subsection 5.2.5. The technique will be applied as pre-training technique of NN in section 5.4.7
• Maybe a nice idea to start Lecture 9 with some scikit-learn CV examples, to show that it can be done with the techniques from section 5.1. Sveliski gives only points, no pixels. Could show MINS and Faces in Wild examples.
• Section 5.3 (Deep neural networks) and 5.4 will be covered in Lecture 11 and 12.
• Szelinsky points back to section 4.3 on generative graphical models
• Lecture 5 of Stanford's DL course uses CNNs for Image Classification.
• Lecture 9 of Stanford's DL course covers Object Detection and Segmentation, which overlaps with our week 3 topic.
• Could read Fei-Fei Li vision on CV in Searching for Computer Vision North Stars.
• Section 5.3.6 (Training and optimization) makes the link to optical flow (Section 9.1.3), which is covered in Lecture 6.
• Strange. Section 5.4 ( Convolutional neural networks) is covered by Lecture 10, so should be read at least a week earlier.
• Section 5.4.1 ( Pooling and unpooling) also covers Feature Pyramid Networks, pointing back to the Laplacian pyramid in Section 3.5.3, which is applied in pixel-wise semantic labeling (Section 6.4) and monocular depth inference (Section 12.8).
• Section 5.4.2 is finally a CV example: Digit classification. Classification will be covered in Yen-Chia's Lecture 8. Would be surprised if Yen-Chia would skip CNNs there.
• Szeliski points for an overview of Network architectures to Stanford's lecture 8, but actually that is now covered in Lecture 6.
• Section 5.5 covers more complex models, such as 3D CNNs used for voxels, RNN, Transformers and Generative models.
• Further reading: Deep Convolutional Neural Networks for Image Classification: A Comprehensive Review by Rawat and Wang (2017).
• MostRawat and Wang (2017) exercises are not directly useful for the exam.
• Chapter 6 has the titel 'Recognition'.
• Looking into lecture 'CV1_2025_HC1a - Intro'. Seems I downloades the zip-file shared with me, and unzipped it on June 21.
• The first lecture ends with course info. Only a name and picture for the lecturer.
• First looked at Lecture 8, the last lecture before mine. Reading guide: Chapter 6 until 6.2.2. Indeed Image Classification is done the classical way, including kNN and SVMs.
• The bag of words approach of patch descriptors falls back to clustering, as described in 5.2.1. Maybe 5.1.4, 5.2.1, and 5.2.2 should move one week forward.
• First a recap, the reading guide with Lecture 9 is on slide 11: Chapter 6.3, 6.4 intro, 6.4.2.
• Slide 59 has a video of Yolo v2! We are now at Yolo 26.
• Slide 88 gives a CNN from 2015, but than continues with K-Means, so 5.2.2 is also covered this week.
• Although simple, nice application examples from slide 112. Lecture ends with two modern approaches, like DeepLab v2 and Panoptic segmentation.
• No reading guide for Lecture 10, not even after the Recap. Added one (Chapter 5.3 and 5.4)
• Ends with Faster R-CNN and the Single Stage RetinaNet.
• Also no reading guide for Lecture 11. At least 5.4.3 is covered.
• The image on slide 50 is to low resolution. First part is on Feature Pyramids. That is section 5.4.1 and 3.5.3
• The 2nd part is on Yolo.
• Also slide 72 and 74 are very low resolution. Slide 123 is low, but not too low.
• Lecture 5 is based on section 7.2, 7.4 and 7.1
• Lecture 6 is based on section 9.1.1, 9.1.3 and 9.3 (9.3.1 optional)

Previous Labbooks

• 2024