Neuroimaging |

Lab Meeting: pip and the Python Packaging Index

Sun, 07 Jun 2020 10:20:09 -0700

What follows are the contents of part of a lab meeting presentation I gave recently. The topic of the meeting was “Python for Neuroimaging”, where I covered basic software development tools that brain imaging scientists might be interested in.

Creating Python Packages

In this lesson, I’ll show you how to build your own Python package that you can then install locally or upload to the Python Packaging Index (for those of you familiar with R, think CRAN, but for Python).

I’m going to be basing a lot of the material off of this documentation, but will also show a real example using some of my own personal code.

What are packages?

I’m sure most of you are familiar with packages and libraries already, either from Matlab, R, or Python. Packages are basically bundles of various snippets of code, i.e. methods, classes, scripts, tests etc. that are bundled together to perform some function. Generally (hopefully), there is coherence to what these snippets of code do – they should interact together in some way or relate to some overarching computational goal.

Within a package, you can have different groupings of code, where each grouping does some unique or discrete computing. These groupings are called submodules. A common submodule in many packages is an Input / Output (io) module that will read and write data that this package interacts with or produces. Another common submodule is often related to plotting the outputs of your code. And then almost always, there are submodules that perform the brunt of the algorithmic work. So inside modules, you’ll find snippets of code that relate to the goal or concept of the module.

Think of a package as a toolbox with a bunch of drawers, each with a label: wood-working, welding, gardening, flooring, etc. These drawers are submodules. You can tell by their names that they each cover certain topics. Each drawer contains a set of tools: wood-working might contain saw, nail, sandpaper, wood glue, while welding might contain solder, flux, oxygen, glove. These tools are the functions, classes, and scripts that relate to that submodule.

Overall, this toolbox performs some stuff related to construction, homebuilding, repair, and has discrete bundles of code useful for a variety of those tasks.

Directory structure for a Python package

Here we examine the skeleton of a package. All packages follow this basic structure.

pkg_name
|-- __init__.py
|-- LICENSE
|-- pkg_name/
| |-- submodule_a/
| | |-- __init__.py
| | |-- a_1.py
| |-- submodule_b/
| | |-- __init__.py
| | |-- b_1.py
| | |-- b_2.py
|-- README.md
|-- setup.py
|-- test/
| |-- __init__.py

__init__.py is a required file that allows your package to be imported. The only __init__.py file that needs to contain anything is the highest-level file. The others can be empty, but they must exist. Here are the contents of the highest-level __init__.py file:

__all__ = [
 'a_1', 'b_1', 'b_2'
]

from .submodule_a import (a_1)
from .submodule_b import (b_1, b_2)

LICENSE tells other users / individuals in what capacity they are allowed to use your code.

README.md describes how to use your code, and often contains examples. This is a markdown file, but can generally be any type of markup language.

test/ is a directory in which you would want to write unit tests for your code.

setup.py is what allows you to install your package. It’s a set of instructions that get supplied to setuptools package.

from setuptools import setup, find_packages

with open("README.md", "r") as fh:
 long_description = fh.read()

 setup(
 name='pkg_name',
 version='0.1.0',
 author='Kristian M. Eschenburg',
 author_email='keschenb@uw.edu',
 packages=find_packages(),
 scripts=[],
 url="https://github.com/kristianeschenburg/pkg_name",
 license='LICENSE.txt',
 description='An awesome package that does something',
 long_description=long_description,
 install_requires=[
 "numpy"
 "pytest",
 "matplotlib",
 ],
)

Compiling, installing, and uploading your package

1. Register on PyPi

Once we’ve done all this, we’re just about ready to create our Python package and upload it to pypi.org. But first, we need to create an account. For testing purposes, we’ll create a test account here, but the process is the same.

After you create your account, we need to create an API token, that will allow us to upload files to either Test PyPi or PyPi (depending on what we’re doing) – the following steps are the same, regardless.

Under your Test PyPi account, click your username in the top right, go to Account Settings:

Scroll down and click Add API Token:

Follow the instructions there, making sure to select “Entire Account” option under the Scope tab.

DO NOT CLOSE THIS WINDOW WHEN THIS IS COMPLETE

Next, type

cd $HOME
touch .pypirc

and using your favorite text editor, enter the following:

[testpypi]
 repository: https://test.pypi.org/legacy/
 username = __token__
 password = pypi-***

If we were creating a token for PyPi, we’d type:

[pypi]
 repository: https://pypi.org/
 username = __token__
 password = pypi-***

Close your current terminal, and open a new window to refresh your settings. Now, when we go to upload our package to PyPi, we’ll be able to type the commands without needed to supply a username and password directly.

2. Compile your package

First, we need to make sure that a few Python packages are installed. Namely, we need to install pip

curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
python get-pip.py
pip install -U pip

Then we can install the following packages:

pip install --upgrade pip setuptools wheel # for installing Python packages
pip install tqdm # progress bar package
pip install --user --upgrade twine # for publishing to PyPi

Then, we can compile our package:

python setup.py bdist_wheel

which creates the directories dist, build, and pkg_name.egg-info. The *.egg-info file is basically some zipped meta-data about your package, but we’re really only interested in the *.whl file in dist – “wheels” are a “distribution” format, newly designed to replace “eggs”. I won’t go into it here, but eggs were sort an ad hoc solution to packaging Python code – wheels were part of PEP427 i.e. is actually an “enhancement” to the Python language, and the formal way of packaging Python code.

3. Installing your code

We can install our code locally with:

pip install dist/pkg_name-0.0.0-py3-none-any.whl

If you want to install an “editable” version of your package, do this:

pip install -e .

This will allow you to change your *.py files and have these changes take effect immediately when importing your package, without needing to rebuild each time – but this method installs from the egg distribution, and generally produces larger build files, since the build needs to keep track of your actual source code.

4. Upload your code

We can upload our code to PyPi now using the following command:

python3 -m twine upload --repository testpypi dist/*

Now, if you click “Your Projects” under your account name on PyPi, you’ll see that you project has been uploaded.

** I should note that, any time you want to upgrade your code and upload it to PyPi again, you need to remove all files from the dist directory, increment the version number in the setup.py file – i.e. 0.0.0 –> 0.0.1 – rebuild your package with

bash python setup.py bdist_wheel

Example with personal package

I don’t generally upload my code to PyPi (probably scared bugs in the code, and people finding them, and then thinking I’m terrible at software development, and going down a long spiral of self-deprecation, but I digress…) but I do upload it all to GitHub. In either case, here is a walk-through of packaging some software called pysurface that I use for processing mesh-based data – I use it for adjacency matrices, performing Laplacian smoothing on surfaces, sampling points from mesh triangle simplices, plotting on surfaces… Just some stuff that I find myself doing a lot.

Here is the directory containing all my code:

You’ll see 5 different modules: graphs, operations, plotting, spectra, and utilities, and you’ll note that each module directory has a __init__.py file.

Here is my setup.py file:

from os import path
from setuptools import setup, find_packages
import sys

here = path.abspath(path.dirname(__file__))

with open(path.join(here, 'README.rst'), encoding='utf-8') as readme_file:
 readme = readme_file.read()

with open(path.join(here, 'requirements.txt')) as requirements_file:
 # Parse requirements.txt, ignoring any commented-out lines.
 requirements = [line for line in requirements_file.read().splitlines()
 if not line.startswith('#')]


setup(
 name='pysurface',
 version="0.0.4",
 description="Python package for quickly processing surface meshes.",
 long_description=readme,
 author="Kristian Eschenburg",
 author_email='keschenb@uw.edu',
 url='https://github.com/kristianeschenburg/pysurface',
 packages=find_packages(),
 entry_points={
 'console_scripts': [
 # 'some.module:some_function',
 ],
 },
 include_package_data=True,
 package_data={
 'pysurface': [
 # When adding files here, remember to update MANIFEST.in as well,
 # or else they will not be included in the distribution on PyPI!
 # 'path/to/data_file',
 ]
 },
 install_requires=requirements,
 license="BSD (3-clause)",
 classifiers=[
 'Development Status :: 2 - Pre-Alpha',
 'Natural Language :: English',
 'Programming Language :: Python :: 3',
 ],
)

You can see that I’ve run

python setup.py bdist_wheel

based off the dist, build, and pysurface.egg-info directories. dist contains a file called pysurface-0.0.4-py3-none.any.whl, which is the actual distribution that can be used for installation. I’ve uploaded the code to Test PyPi, and this is what we see:

We can then install the package and all of it’s dependencies from TestPypi via

pip install --index-url https://test.pypi.org/simple/ pysurface

Now I can do something like the following in a Python script:

import pysurface
# or
from pysurface import graphs, spectra
# or
from pysurface.spectra import eigenspectrum

Mahalanobis Distances of Brain Connectivity

Fri, 07 Dec 2018 05:12:32 -0700

For one of the projects I’m working on, I have an array of multivariate data relating to brain connectivity patterns. Briefly, each brain is represented as a surface mesh, which we represent as a graph $G = (V,E)$, where $V$ is a set of $n$ vertices, and $E$ is the set of edges between vertices.

Additionally, for each vertex $v \in V$, we also have an associated scalar label, which we’ll denote $l(v)$, that identifies what region of the cortex each vertex belongs to, the set of regions which we define as $L = {1, 2, … k}$. And finally, for each vertex $v \in V$, we also have a multivariate feature vector $r(v) \in \mathbb{R}^{1 \times k}$, that describes the strength of connectivity between it, and every region $l \in L$.

Example of cortical map, and array of connectivity features.

I’m interested in examining how “close” the connectivity samples of one region, $l_{j}$, are to another region, $l_{k}$. In the univariate case, one way to compare a scalar sample to a distribution is to use the $t$-statistic, which measures how many standard deviations away from the mean a given sample is:

$$\begin{align} t_{s} = \frac{\bar{x} - \mu}{\frac{s}{\sqrt{n}}} \end{align}$$

where $\mu$ is the population mean, and $s$ is the sample standard deviation. If we square this, we get:

$$\begin{align} t^{2} = \frac{(\bar{x} - \mu)^{2}}{\frac{s^{2}}{n}} = \frac{n (\bar{x} - \mu)^{2}}{S^{2}} \sim F(1,n) \end{align}$$

We know the last part is true, because the numerator and denominator are independent $\chi^{2}$ distributed random variables. However, I’m not working with univariate data – I have multivariate data. The multivariate generalization of the $t$-statistic is the Mahalanobis Distance:

$$\begin{align} d &= \sqrt{(\bar{x} - \mu)\Sigma^{-1}(\bar{x}-\mu)^{T}} \end{align}$$

where the squared Mahalanobis Distance is:

$$\begin{align} d^{2} &= (\bar{x} - \mu)\Sigma^{-1}(\bar{x}-\mu)^{T} \end{align}$$

where $\Sigma^{-1}$ is the inverse covariance matrix. If our $X$’s were initially distributed with a multivariate normal distribution, $N_{p}(\mu,\Sigma)$ (assuming $\Sigma$ is non-degenerate i.e. positive definite), the squared Mahalanobis distance, $d^{2}$ has a $\chi^{2}_{p}$ distribution. We show this below.

We know that $(X-\mu)$ is distributed $N_{p}(0,\Sigma)$. We also know that, since $\Sigma$ is symmetric and real, that we can compute the eigendecomposition of $\Sigma$ as:

$$\begin{align} \Sigma = U \Lambda U^{T} \end{align}$$

and consequently, because $U$ is an orthogonal matrix, and because $\Lambda$ is diagonal, we know that $\Sigma^{-1}$ is:

$$\begin{align} \Sigma^{-1} &= (U \Lambda U^{T})^{-1} \\ &= U \Lambda^{-1} U^{T} \\ &= (U \Lambda^{\frac{-1}{2}}) (U \Lambda^{\frac{-1}{2}})^{T} \\ &= R R^{T} \end{align}$$

Therefore, we know that $R^{T}(X-\mu) \sim N_{p}(0,I_{p})$:

$$\begin{align} X &\sim N_{p}(\mu,\Sigma) \\ (X-\mu) = Y &\sim N_{p}(0,\Sigma)\\ R^{T}Y = Z &\sim N_{p}(0, R^{T} \Sigma R) \\ &\sim N_{p}(0, \Lambda^{\frac{-1}{2}} U^{T} (U \Lambda U^{T}) U \Lambda^{\frac{-1}{2}}) \\ &\sim N_{p}(0, \Lambda^{\frac{-1}{2}} I_{p} \Lambda I_{p} \Lambda^{\frac{-1}{2}}) \\ &\sim N_{p}(0,I_{p}) \end{align}$$

so that we have

$$\begin{align} &= (X-\mu)\Sigma^{-1}(X-\mu)^{T} \\ &= (X-\mu)RR^{T}(X-\mu)^{T} \\ &= Z^{T}Z \end{align}$$

the sum of $p$ squared standard Normal random variables, which is the definition of a $\chi_{p}^{2}$ distribution with $p$ degrees of freedom. So, given that we start with a $MVN$ random variable, the squared Mahalanobis distance is $\chi^{2}_{p}$ distributed. Because the sample mean and sample covariance are consistent estimators of the population mean and population covariance parameters, we can use these estimates in our computation of the Mahalanobis distance.

Also, of particular importance is the fact that the Mahalanobis distance is not symmetric. That is to say, if we define the Mahalanobis distance as:

$$\begin{align} M(A, B) = \sqrt{(A - \mu(B))\Sigma(B)^{-1}(A-\mu(B))^{T}} \end{align}$$

then $M(A,B) \neq M(B,A)$, clearly. Because the parameter estimates are not guaranteed to be the same, it’s straightforward to see why this is the case.

Now, back to the task at hand. For a specified target region, $l_{T}$, with a set of vertices, $V_{T} = {v \; : \; l(v) \; = \; l_{T}, \; \forall \; v \in V}$, each with their own distinct connectivity fingerprints, I want to explore which areas of the cortex have connectivity fingerprints that are different from or similar to $l_{T}$’s features, in distribution. I can do this by using the Mahalanobis Distance. And based on the analysis I showed above, we know that the data-generating process of these distances is related to the $\chi_{p}^{2}$ distribution.

First, I’ll estimate the covariance matrix, $\Sigma_{T}$, of our target region, $l_{T}$, using the Ledoit-Wolf estimator (the shrunken covariance estimate has been shown to be a more reliable estimate of the population covariance), and mean connectivity fingerprint, $\mu_{T}$. Then, I’ll compute $d^{2} = M^{2}(A,A)$ for every $\{v: v \in V_{T}\}$. The empirical distribution of these distances should follow a $\chi_{p}^{2}$ distribution. If we wanted to do hypothesis testing, we would use this distribution as our null distribution.

Next, in order to assess whether this intra-regional similarity is actually informative, I’ll also compute the similarity of $l_{T}$ to every other region, $\{ l_{k} \; : \; \forall \; k \in L \setminus \{T\} \}$ – that is, I’ll compute $M^{2}(A, B) \; \forall \; B \in L \setminus T$. If the connectivity samples of our region of interest are as similar to one another as they are to other regions, then $d^{2}$ doesn’t really offer us any discriminating information – I don’t expect this to be the case, but we need to verify this.

Then, as a confirmation step to ensure that our empirical data actually follows the theoretical $\chi_{p}^{2}$ distribution, I’ll compute the location and scale Maximum Likelihood(MLE) parameter estimates of our $d^{2}$ distribution, keeping the d.o.f. (i.e. $p$) fixed.

See below for Python code and figures…

Step 1: Compute Parameter Estimates

%matplotlib inline
import matplotlib.pyplot as plt

from matplotlib import rc
rc('text', usetex=True)

import numpy as np
from scipy.spatial.distance import cdist
from scipy.stats import chi2, probplot

from sklearn import covariance

# lab_map is a dictionary, mapping label values to sample indices
# our region of interest has a label of 8
LT = 8

# get indices for region LT, and rest of brain
lt_indices = lab_map[LT]
rb_indices = np.concatenate([lab_map[k] for k in lab_map.keys() if k != LT])

data_lt = conn[lt_indices, :]
data_rb = conn[rb_indices, :]

# fit covariance and precision matrices
# Shrinkage factor = 0.2
cov_lt = covariance.ShrunkCovariance(assume_centered=False, shrinkage=0.2)
cov_lt.fit(data_lt)
P = cov_lt.precision_

Next, compute the Mahalanobis Distances:

# LT to LT Mahalanobis Distance
dist_lt = cdist(data_lt, data_lt.mean(0)[None,:], metric='mahalanobis', VI=P)
dist_lt2 = dist_lt**2

# fit covariance estimate for every region in cortical map
EVs = {l: covariance.ShrunkCovariance(assume_centered=False,
 shrinkage=0.2) for l in labels}

for l in lab_map.keys():
 EVs[l].fit(conn[lab_map[l],:])

# compute d^2 from LT to every cortical region
# save distances in dictionary
lt_to_brain = {}.fromkeys(labels)
for l in lab_map.keys():

 temp_data = conn[label_map[l], :]
 temp_mu = temp_data.mean(0)[None, :]

 temp_mh = cdist(data_lt, temp_mu, metric='mahalanobis', VI=EVs[l].precision_)
 temp_mh2 = temp_mh**2

 lt_to_brain[l] = temp_mh2

# plot distributions seperate (scales differ)
fig = plt.subplots(2,1, figsize=(12,12))
plt.subplot(2,1,1)
plt.hist(lt_to_brain[LT], 50, density=True, color='blue',
 label='Region-to-Self', alpha=0.7)

plt.subplot(2,1,2)
for l in labels:
 if l != LT:
 plt.hist(lt_to_brain[l], 50, density=True, linewidth=2,
 alpha=0.4, histtype='step')

Empirical distributions of within-region (top) and between-region (bottom) $d^{2}$ values. Each line is the distribution of the distance of samples in our ROI to a whole region.

As expected, the distribution of $d^{2}$, the distance of samples in our region of interest, $l_{T}$, to distributions computed from other regions, is (considerably) larger and much more variable, while the profile of points within $l_{T}$ looks to have much smaller variance – this is good! This means that we have high intra-regional similarity when compared to inter-regional similarities. This fits what’s known in neuroscience as the “cortical field hypothesis”.

Step 2: Distributional QC-Check

Because we know that our data should follow a $\chi^{2}_{p}$ distribution, we can fit the MLE estimate of our location and scale parameters, while keeping the $df$ parameter fixed.

p = data_lt.shape[1]
mle_chi2_theory = chi2.fit(dist_lt2, fdf=p)

xr = np.linspace(data_lt.min(), data_lt.max(), 1000)
pdf_chi2_theory(xr, *mle_chi2_theory)

fig = plt.subplot(1,2,2,figsize=(18, 6))

# plot theoretical vs empirical null distributon
plt.subplot(1,2,1)
plt.hist(data_lt, density=True, color='blue', alpha=0.6,
 label = 'Empirical')
plt.plot(xr, pdf_chi2_theory, color='red',
 label = '$\chi^{2}_{p}')

# plot QQ plot of empirical distribution
plt.subplot(1,2,2)
probplot(D2.squeeze(), sparams=mle_chi2_theory, dist=chi2, plot=plt);

Density and QQ plot of null distribution.

From looking at the QQ plot, we see that the empirical density fits the theoretical density pretty well, but there is some evidence that the empirical density has heavier tails. The heavier tail of the upper quantile could probability be explained by acknowledging that our starting cortical map is not perfect (in fact there is no “gold-standard” cortical map). Cortical regions do not have discrete cutoffs, although there are reasonably steep gradients in connectivity. If we were to include samples that were considerably far away from the the rest of the samples, this would result in inflated densities of higher $d^{2}$ values.

Likewise, we also made the distributional assumption that our connectivity vectors were multivariate normal – this might not be true – in which case our assumption that $d^{2}$ follows a $\chi^{2}_{p}$ would also not hold.

Finally, let’s have a look at some brains! Below, is the region we used as our target – the connectivity profiles from vertices in this region were used to compute our mean vector and covariance matrix – we compared the rest of the brain to this region.

Region of interest.

Estimated squared Mahalanobis distances, overlaid on cortical surface.

Here, larger $d^{2}$ values are in red, and smaller $d^{2}$ are in black. Interestingly, we do see pretty large variance of $d^{2}$ spread across the cortex – however the values are smoothly varying, but there do exists sharp boundaries. We kind of expected this – some regions, though geodesically far away, should have similar connectivity profiles if they’re connected to the same regions of the cortex. However, the regions with connectivity profiles most different than our target region are not only contiguous (they’re not noisy), but follow known anatomical boundaries, as shown by the overlaid boundary map.

This is interesting stuff – I’d originally intended on just learning more about the Mahalanobis Distance as a measure, and exploring its distributional properties – but now that I see these results, I think it’s definitely worth exploring further!

Image Transformations With OpenCV

Sat, 01 Sep 2018 17:12:32 -0700

I’ve been toying around with openCV for generating MRI images with synethetic motion injected into them. I’d never used this library before, so I tested a couple examples. Below I detail a few tools that I found interesting, and that can quickly be used to generate image transformations.

# import necessary libraries
import matplotlib.pyplot as plt
import nibabel as nb
import cv2

# load image file
image_file = './data/T1w_restore_brain.nii.gz'
img_obj = nb.load(image_file)
img = img_obj.get_data()

# reorient so Anterior-Posterior axis corresponds to dim(0)
img = np.fliplr(img)
img = np.swapaxes(img, 0, 2)

# get single image slice and rescale
data = img[130, :, :]
data = (data-data.min())/data.max()
plt.imshow(data)

For any linear transformations with cv2, we can use the cv2.warpAffine method, which takes in the original image, some transformation matrix, and the size of the output image.

Let’s start with translations. The matrix will translate the image 10 pixels to the right (width), and 0 pixels down (height).

# Use the identity rotation matrix
# Third column specifies translation in corresponding direction
translation = np.array([[1, 0, 20],
 [0, 1, 0]])

translated = cv2.warpAffine(data, translation, data.T.shape)
plt.imshow(translated)

Now, in order to rotate the image, we can use cv2.getRotationMatrix2D. We’ll rotate our image by 45$^{\circ}$ .

# get shape of input image
rows, cols = data.shape

# specify angle of rotation around central pixel
M = cv2.getRotationMatrix2D((cols/2,rows/2), 45, 1)
rotated = cv2.warpAffine(data, M, (cols, rows))
plt.imshow(rotated)

Here are a few examples of randomly translating +/- 1, 5, or 9 voxels in the X and Y directions, and randomly rotating by 1, 5, or 9 degrees:

# get shape of input image
rows, cols = data.shape
# specify range of rotations and translations
txfn = [1, 5, 9]

for rt in txfn:

 # generate rotation matrix
 # randonly rotate to left or right
 M = cv2.getRotationMatrix2D(
 (cols/2, rows/2),
 np.random.choice([-1, 1], 1)[0]*rt, 1)

 # apply rotation matrix
 rotated = cv2.warpAffine(data, M, data.T.shape)

 # generate translation matrix
 # randomly translate to left or right
 T = np.array(
 [[1,0,np.random.choice([-1, 1], 1)[0]*rt],
 [0, 1,np.random.choice([-1, 1], 1)[0]*rt]]).astype(np.float32)

 # apply translation matrix
 translated = cv2.warpAffine(data, T, data.T.shape)

 # compose rotated and translated images
 movement = (rotated + translated)/2
 # compute difference between input and transformed
 difference = data-movement
 res = difference.reshape(np.product(difference.shape))

 fig,[ax1,ax2,ax3] = plt.subplots(1,3,figsize=(15,5))
 ax1.imshow(movement, cmap='gray')
 ax1.set_title('Composed Random Rotation and Translation \n Magnitude = {:}'.format(rt), fontsize=15)
 ax2.imshow(D-rotated, cmap='gray')
 ax2.set_title('Difference Map'.format(rt), fontsize=15)
 ax3.hist(res[res!=0],100,density=True)
 ax3.set_title('Difference Density', fontsize=15)
 plt.tight_layout()
 plt.show()

While this approach of generating synthetic motion into MRI images is a poor model of how motion actually occurs during an MRI scan, there are a few things I learned here. For example, if you define a measure of image similarity, like mutual information, entropy, or correlation ratio as a cost function, we can see how we can use warpAffine to find the optimal transformation matrix between two images.

I was hoping to use openCV to generate and apply 3d affine transformations to volumetric MRI data. One approach to doing this is to iteratively apply rotations and transformations along each axis – however, openCV will interpolate the data after each transformation, resulting in a greater loss of signal than I am willing to compromise on. It doesn’t seem like openCV has ability to apply 3d affine transformations to volumetric data in a single interpolation step.

A more realistic approach to generating synthetic motion artifacts that would more accurately parallell the noise-generating process, is to compute the Fast Fourier Transform of my 3d volume, and then apply phase-shifts to the k-space signal – this will also manifest as motion after applying the inverse FFT.

After doing a bit more digging through the openCV API, it seems there’s a lot of cool material for exploration – these applications specifically caught my eye and would be fun to include in projects:

video analysis for motion tracking
object recognition for detecting faces
openCV Android for app development

But alas – the search continues!