The image of the aperture stop when viewed from the front of the lens
Inline hologram notes
Some notes on unwrapping In line Holograms
Axis IP camera
I use axis IP camera a lot for capturing images and video. The image quality is great and they are highly customisable. I use a P1344 camera and it supports still images, MJPEG and H264. The still image are fine for capturing a one off, but too slow for video work. For this I need either MJPEG or H264. Both have there pros and cons.
MJPEG is existentially a sequence of JPEG images. It’s easy to use and the quality is good, depending on the compression settings. The downside is the bitrate over the network is larger than H264.
H264 is a lossy video compression format that has become ubiquitous on the internet these days for compressed video and blue-ray videos.
The camera can be controlled using the url. To get a H264 stream (using VLC in this case, but ffplay works perfectly well), at the command prompt type
vlc rtsp://192.168.0.103:554/axis-media/media.amp
changing the IP address to that of your camera. You can also add in the camera’s username and password using:
vlc "rtsp://192.168.0.103:554/axis-media/media.amp?user=XXX&password=XXXX"
The image resolution can be changed with
vlc rtsp://192.168.0.103:554/axis-media/media.amp?resolution=640x480
The resolution is camera dependent. There are a bunch of different settings, such as bit rate, compression, you can apply see the AXIS VAPIX documentation for the whole list. An easy way to do this is by using the cameras settings page to create a Stream Profile. There are a number built in and you can select them like so
vlc rtsp://192.168.0.103:554/axis-media/media.amp?streamprofile=Quality
Still images can be captured, by using
http://192.168.0.103/axis-cgi/jpg/image.cgi?resolution=320x240&compression=25
here I’ve selected the resolution and compression factor. You can grab the image by placing the above url into a browser.
Image Quality
Looking at the above shows subregions of example images captured at full resolution using JPG. We can see that there is significant compression artifacts in the image even at low compression ratios. Setting the compression ratio less than 40 appears to have little effect on image quality.
H264 streams appear to be similarly affected. The bitmap image shows some improvement however the data rate to transmit this is considerably larger.
Note that the RMS errors are calculated from the JPEG image with a compression factor of 0.
Benchmarking
ffplay "http://192.168.0.103/axis-cgi/mjpg/video.cgi?resolution=640x480&fps=15"
uses 60% of one core of my Odroid XU4 and 17% on my 2.7 GHz iMac
ffplay "rtsp://192.168.0.103:554/axis-media/media.amp?resolution=640x480&fps=15"
uses 88% on the Odroid and 14% on the iMac.
A useful CMake tutorial the covers VS and Xcode
Random fields & Probability cheat sheet
- Random variable – the value of a random experiment.
- Random field – a spatial function that assigns a random variable to each position
- Distribution function of a random variable (aka Cumulative distribution function, CDF)
– Consider \(P_f(z)=\mathcal{P} \{ f <z\} \) The equation tells us how likely for the random variable \(f\) to be less than \(z\). \(P_f(z)\) is the distribution function of \(f\). \(\mathcal{P} \) is the probability. - Probability of an event happening has the properties:
- It is a non-negative number
- The probability of all the events (all possible outcomes) must equal one
- The probability of a random variable taking a specific real value is zero. Loosely, this is because a real values need an infinite precision to describe them. We can however specify the probability over an infinity small range. Combining those ranges over all possible values give the probability density function.
- The probability density function is the differential of the CDF
\(p_f(z)=\frac{ d P_f(z) }{dz} \) - The expected or mean value is \(\mu_f=E\{f\}=\int_{-\infty}^{\infty} zp_f(z) dz\)
- The variance is \(\sigma^2_f=E\{(f-\mu_f)^2\}=\int_{-\infty}^{\infty} (z-\mu_f)^2p_f(z) dz\)
- If we have many random variables we can define a joint distribution function
\(P_{f_1,f_2,f_3,\ldots,f_n}(z_1,z_2,z_3 \ldots z_n)=\mathcal{P} \{ f_1 <z_1,f_2 <z_2,f_3 <z_3,\ldots,f_n <z_n \} \) - and the joint probability density function
\(p_{f_1,f_2,f_3,\ldots,f_n}(z_1,z_2,z_3 \ldots z_n)=\frac{P_{f_1,f_2,f_3,\ldots,f_n}(z_1,z_2,z_3 \ldots z_n)}{dz_1 dz_2 dz_3 \ldots dz_n} \) - If random variables are independent then
\(P_{f_1,f_2,f_3,\ldots,f_n}(z_1,z_2,z_3 \ldots z_n)=P_{f1}(z_1)P_{f2}(z_2)P_{f3}(z_3)\ldots P_{fn}(z_n)\) - If they are uncorrelated then
\(E\{f_i f_j\}=E\{f_i \}E\{f_j\} \quad , \forall i,j, i \neq j\) - and orthogonal if
\(E\{f_i f_j\}=0 \) - The covariance is \(c_{ij}=E\{(f_i-\mu_{f_i})( f_j-\mu_{f_j})\}\) which equals zero if they are uncorrelated.
Since we are interested in images (in this blog) we shall introduce random fields from this point of view. If we have a random variable at every point \(\mathbf{r}\) in a 2D space we have a random field. The random field can be written \(f(\mathbf{r},\omega_i)\) where \(\omega_i\) is the outcome. For a fixed \(\omega_i\) the random field gives a grey level image as we scan over all \(\mathbf{r}\). Scanning over all possible \(\omega_i\) gives a series of images.
Mathematical representation of images and optics.
The way we represent an image mathematically can have a big impact on our ability to mathematically manipulate it. Conceptually it would be simplest to represent an image (let’s assume it’s grey-level) as a 2D array. If my image is a 2D array \(\mathbf{X}\) I could implement the effect a linear shift invariant blurring function \(\mathbf{H}\) and produce an output image \(\mathbf{F}\) via the convolution operator:
\(\mathbf{F}=\mathbf{H} \ast \mathbf{X}\)I could do other things with this notation such as introduce a shift operator to move my image by one pixel
\(\mathbf{F}=\mathbf{\acute {H}} \ast \mathbf{X}\)where \(\mathbf{\acute {H}}=[0, 0 ,1]\).
The problem is this is all shift invariant, the same blur or shift is applied to all the pixels in an image. What if the amount of blurring and shifting changes from pixel to pixel as it does in a real image due to imperfections in the camera’s lens? I would need a separate \(\mathbf{\acute {H}}=[0, 0 ,1]\) for every pixel. A more convenient way is to drop the 2D convolution and implement our system using matrix multiplications. To do this we lexicography rearrange the 2D image matrix into a 1D vector
\(\left[ \begin{array}{ccc}a & b & c \\
d & e & f \\
g & h & i \end{array}\right] \longrightarrow \left[ \begin{array}{c} a\\d\\g\\b\\e\\h\\c\\f\\i \end{array} \right]\)
In Matlab this would be implemented with X1d=X(:)
and we can transform it back to 2d with knowledge of the original number of rows and columns X=reshape(X1d,rows,cols)
.
For simplicity sake I shall reduce the number pixels in my image to 3. But what can we do with this? Well let’s look at a matrix multiply operation
\(\left[ \begin{array}{ccc}a & b & c \\
d & e & f \\
g & h & i \end{array}\right] \left[ \begin{array}{c}x\\y\\z\end{array}\right] = \left[ \begin{array}{c} ax+by+cz\\dx+ey+fz\\gx+hy+iz\end{array}\right]\)
each row in the matrix is like an operator on each pixel. I’ve effectively got a shift variant convolution. For example I could blur the first pixel and leave the rest the same
\(\left[ \begin{array}{ccc}0.33& 0.33 & 0.33 \\
0 & 1 & 0 \\
0 & 0 & 1 \end{array}\right] \left[ \begin{array}{c}x\\y\\z\end{array}\right] = \left[ \begin{array}{c} 0.33x+0.33y+0.33z\\y\\z\end{array}\right]\)
Note that the 1s go down the diagonal.
I could implement a shift on the second pixel
\(\left[ \begin{array}{ccc}1& 0 & 0 \\
0 & 0& 1 \\
0 & 0 & 1 \end{array}\right] \left[ \begin{array}{c}x\\y\\z\end{array}\right] = \left[ \begin{array}{c} x\\z\\z\end{array}\right]\)
by changing the values I could implement rotations and warps.
And we can combine several matrices together to define our system. If \(\mathbf{S}\) is a shift matrix and \(\mathbf{B}\) is a blurring matrix with can simply combine the results together
\(\mathbf{F}=\mathbf{SBX}\)to describe our shift variant optical system.
An additional step we may wish to introduce the effect of sensor pixel size. We can implement this by making our original image have a much higher resolution and them use a decimation filter to reduce this to a low resolution camera image. To this we create a matrix with \(N\) rows, which equals the number of pixels in the decimated image, and \(M\) columns, which equals the number of pixels in the high resolution image.
\(\left[ \begin{array}{ccc}0.5& 0.5 & 0 & 0 \\
0 & 0 & 0.5 & 0.5 \end{array}\right] \left[ \begin{array}{c}w\\x\\y\\z\end{array}\right] = \left[ \begin{array}{c} 0.5w+0.5x \\0.5y +0.5z\end{array}\right]\)
shows how we can reduce the resolution by 1/2 in one dimension and we can easily extend this to 2D.
Update
It’s worth noting if the blurring is shift invariant (which is a lot easier to deal with) the matrix is block circulant. This means it is of the form
\(\left[ \begin{array}{ccccc}d(0) & d(M-1) & d(M-2)& \ldots &d(1) \\
d(1) & d(0) & d(M-1)& \ldots &d(2)\\
d(2) & d(1) & d(0)& \ldots &d(3)\\
\vdots&\vdots&\vdots&\vdots&\vdots&\\
d(M-1) & d(M-2) & d(M-3)& \ldots &d(0) \end{array}\right]\)
Note, each row is a shifted version of the one above it. The reason, this is important is that it is easy to invert.
Mac Ports Cheat Sheet
It’s worth reading the mac ports guide here, but here is my cut down cheat sheet of commands I actually use.
To install a port, e.g opencv
sudo port install opencv
To update ports definition list
sudo port selfupdate
Once, that’s finished you can update the outdated ports (this might take sometime depending on the number of updates)
sudo port upgrade outdated
or you can get a list of the outdated ports
port outdated
and upgraded them manually
sudo port upgrade opencv
This should also upgrade dependencies.
To get a list of installed ports
port installed
To search for a port, eg, PHP you could try
port search php
This will give you hundreds of port that mention PHP in their description. You can filter this, for example
port search --name --glob 'php*'
will return only the ports that start with php.
port info opencv
returns information about the opencv port (the lastest version, so watch out if your ports are out of date). A list of variants can be obtained with
port variants opencv
A port variant can be installed using the syntax:
sudo port install opencv +java
This installs the variant of opencv with java bindings. To see which variant is installed type:
port installed opencv
this lists the variant installed, plus the inactive versions of the library.
If a port fails to build it might be worth cleaning up first by running
sudo port clean opencv
and trying again.
To find out what and where port has installed files run
port contents opencv
To remove a port you use either of
sudo port uninstall opencv sudo port uninstall --follow-dependents opencv
The second option removes the installed dependents as long as no other port is using them. If you don’t use the latter there will be a number of ports left on your system that you didn’t manually install. These are known as leaves and you can list or remove them with
port echo leaves sudo port uninstall leaves
You might need to repeat the process since uninstalling leaves may create new leaves!
Port will also leave the outdated ports on your system. To remove them use
sudo port uninstall inactive
Boost and CMake
CMake is wonderful on Linux, the problem on Windows is it can’t always find the library since the user could have installed them anywhere. To get it to find the boost library with the CMake-GUI add a new variable BOOST_ROOT of type Path and set the parameter to the boost home directory.
CMake uses a set of modules to locate common library and you can specify the root of these directly. See the documentation at https://cmake.org/cmake/help/v3.0/manual/cmake-modules.7.html
OpenCV and QT Creator
Adding openCV to an QtCreator .pro file is easy in Linux simply add
CONFIG += link_pkgconfig PKGCONFIG += opencv
to the .pro file.
In windows you need to hard code in the directories. To make it cross platform add
win32{ INCLUDEPATH += C:\opencv\opencv\build\include LIBS += -LC:\\opencv\\build\\bin \ libopencv_core2411 \ libopencv_highgui2411 \ libopencv_imgproc2411 \ libopencv_features2d2411 \ libopencv_calib3d2411 \ libopencv_contrib2411 \ libopencv_video2411 \ } unix{ CONFIG += link_pkgconfig PKGCONFIG += opencv }
but change the windows library names and locations to suit yourself.
Adaptive-particle-filter – Particle filter – Google Project Hosting
The code used for our adaptive particle filter.
adaptive-particle-filter – Particle filter – Google Project Hosting.
For this paper: Hassan, Waqas, Bangalore Manjunathamurthy, Nagachetan, Birch, Philip, Young, Rupert and Chatwin, Chris (2012)Adaptive Sample Count Particle Filter. Computer Vision and Image Understanding, 116 (12). pp. 1208-1222. ISSN 1077-3142